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
  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->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 static char *check_configured_address(void) {
 347     char *default_server = NULL;
 348     pa_client_conf *c = pa_client_conf_new();
 349
 350     pa_client_conf_load(c, NULL);
 351 #ifdef HAVE_X11
 352     pa_client_conf_from_x11(c, NULL);
 353 #endif
 354     pa_client_conf_env(c);
 355
 356     if (c->default_server && *c->default_server)
 357         default_server = pa_xstrdup(c->default_server);
 358
 359     pa_client_conf_free(c);
 360
 361     return default_server;
 362 }
 363
 364 #ifdef HAVE_DBUS
 365 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
 366     DBusError error;
 367     pa_dbus_connection *conn;
 368
 369     dbus_error_init(&error);
 370
 371     if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
 372         pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
 373         goto fail;
 374     }
 375
 376     if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 377         pa_log_debug("Got %s!", name);
 378         return conn;
 379     }
 380
 381     if (dbus_error_is_set(&error))
 382         pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
 383     else
 384         pa_log_error("D-Bus name %s already taken. Weird shit!", name);
 385
 386     /* PA cannot be started twice by the same user and hence we can
 387      * ignore mostly the case that a name is already taken. */
 388
 389 fail:
 390     if (conn)
 391         pa_dbus_connection_unref(conn);
 392
 393     dbus_error_free(&error);
 394     return NULL;
 395 }
 396 #endif
 397
 398 int main(int argc, char *argv[]) {
 399     pa_core *c = NULL;
 400     pa_strbuf *buf = NULL;
 401     pa_daemon_conf *conf = NULL;
 402     pa_mainloop *mainloop = NULL;
 403     char *s;
 404     char *configured_address;
 405     int r = 0, retval = 1, d = 0;
 406     pa_bool_t valid_pid_file = FALSE;
 407     pa_bool_t ltdl_init = FALSE;
 408     int passed_fd = -1;
 409     const char *e;
 410 #ifdef HAVE_FORK
 411     int daemon_pipe[2] = { -1, -1 };
 412 #endif
 413 #ifdef OS_IS_WIN32
 414     pa_time_event *win32_timer;
 415     struct timeval win32_tv;
 416 #endif
 417     int autospawn_fd = -1;
 418     pa_bool_t autospawn_locked = FALSE;
 419 #ifdef HAVE_DBUS
 420     pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
 421     pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
 422     pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
 423     pa_bool_t start_server;
 424 #endif
 425
 426     pa_log_set_ident("pulseaudio");
 427     pa_log_set_level(PA_LOG_NOTICE);
 428     pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
 429
 430 #if defined(__linux__) && defined(__OPTIMIZE__)
 431     /*
 432        Disable lazy relocations to make usage of external libraries
 433        more deterministic for our RT threads. We abuse __OPTIMIZE__ as
 434        a check whether we are a debug build or not. This all is
 435        admittedly a bit snake-oilish.
 436     */
 437
 438     if (!getenv("LD_BIND_NOW")) {
 439         char *rp;
 440         char *canonical_rp;
 441
 442         /* We have to execute ourselves, because the libc caches the
 443          * value of $LD_BIND_NOW on initialization. */
 444
 445         pa_set_env("LD_BIND_NOW", "1");
 446
 447         if ((canonical_rp = pa_realpath(PA_BINARY))) {
 448
 449             if ((rp = pa_readlink("/proc/self/exe"))) {
 450
 451                 if (pa_streq(rp, canonical_rp))
 452                     pa_assert_se(execv(rp, argv) == 0);
 453                 else
 454                     pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
 455
 456                 pa_xfree(rp);
 457
 458             } else
 459                 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
 460
 461             pa_xfree(canonical_rp);
 462
 463         } else
 464             pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
 465     }
 466 #endif
 467
 468     if ((e = getenv("PULSE_PASSED_FD"))) {
 469         passed_fd = atoi(e);
 470
 471         if (passed_fd <= 2)
 472             passed_fd = -1;
 473     }
 474
 475     /* We might be autospawned, in which case have no idea in which
 476      * context we have been started. Let's cleanup our execution
 477      * context as good as possible */
 478
 479     pa_reset_personality();
 480     pa_drop_root();
 481     pa_close_all(passed_fd, -1);
 482     pa_reset_sigs(-1);
 483     pa_unblock_sigs(-1);
 484     pa_reset_priority();
 485
 486     setlocale(LC_ALL, "");
 487     pa_init_i18n();
 488
 489     conf = pa_daemon_conf_new();
 490
 491     if (pa_daemon_conf_load(conf, NULL) < 0)
 492         goto finish;
 493
 494     if (pa_daemon_conf_env(conf) < 0)
 495         goto finish;
 496
 497     if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
 498         pa_log(_("Failed to parse command line."));
 499         goto finish;
 500     }
 501
 502     pa_log_set_level(conf->log_level);
 503     pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
 504     if (conf->log_meta)
 505         pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
 506     if (conf->log_time)
 507         pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
 508     pa_log_set_show_backtrace(conf->log_backtrace);
 509
 510 #ifdef HAVE_DBUS
 511     /* conf->system_instance and conf->local_server_type control almost the
 512      * same thing; make them agree about what is requested. */
 513     switch (conf->local_server_type) {
 514         case PA_SERVER_TYPE_UNSET:
 515             conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
 516             break;
 517         case PA_SERVER_TYPE_USER:
 518         case PA_SERVER_TYPE_NONE:
 519             conf->system_instance = FALSE;
 520             break;
 521         case PA_SERVER_TYPE_SYSTEM:
 522             conf->system_instance = TRUE;
 523             break;
 524         default:
 525             pa_assert_not_reached();
 526     }
 527
 528     start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
 529
 530     if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
 531         pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
 532         conf->system_instance = FALSE;
 533     }
 534 #endif
 535
 536     LTDL_SET_PRELOADED_SYMBOLS();
 537     pa_ltdl_init();
 538     ltdl_init = TRUE;
 539
 540     if (conf->dl_search_path)
 541         lt_dlsetsearchpath(conf->dl_search_path);
 542
 543 #ifdef OS_IS_WIN32
 544     {
 545         WSADATA data;
 546         WSAStartup(MAKEWORD(2, 0), &data);
 547     }
 548 #endif
 549
 550     pa_random_seed();
 551
 552     switch (conf->cmd) {
 553         case PA_CMD_DUMP_MODULES:
 554             pa_dump_modules(conf, argc-d, argv+d);
 555             retval = 0;
 556             goto finish;
 557
 558         case PA_CMD_DUMP_CONF: {
 559
 560             if (d < argc) {
 561                 pa_log("Too many arguments.\n");
 562                 goto finish;
 563             }
 564
 565             s = pa_daemon_conf_dump(conf);
 566             fputs(s, stdout);
 567             pa_xfree(s);
 568             retval = 0;
 569             goto finish;
 570         }
 571
 572         case PA_CMD_DUMP_RESAMPLE_METHODS: {
 573             int i;
 574
 575             if (d < argc) {
 576                 pa_log("Too many arguments.\n");
 577                 goto finish;
 578             }
 579
 580             for (i = 0; i < PA_RESAMPLER_MAX; i++)
 581                 if (pa_resample_method_supported(i))
 582                     printf("%s\n", pa_resample_method_to_string(i));
 583
 584             retval = 0;
 585             goto finish;
 586         }
 587
 588         case PA_CMD_HELP :
 589             pa_cmdline_help(argv[0]);
 590             retval = 0;
 591             goto finish;
 592
 593         case PA_CMD_VERSION :
 594
 595             if (d < argc) {
 596                 pa_log("Too many arguments.\n");
 597                 goto finish;
 598             }
 599
 600             printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
 601             retval = 0;
 602             goto finish;
 603
 604         case PA_CMD_CHECK: {
 605             pid_t pid;
 606
 607             if (d < argc) {
 608                 pa_log("Too many arguments.\n");
 609                 goto finish;
 610             }
 611
 612             if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
 613                 pa_log_info(_("Daemon not running"));
 614             else {
 615                 pa_log_info(_("Daemon running as PID %u"), pid);
 616                 retval = 0;
 617             }
 618
 619             goto finish;
 620
 621         }
 622         case PA_CMD_KILL:
 623
 624             if (d < argc) {
 625                 pa_log("Too many arguments.\n");
 626                 goto finish;
 627             }
 628
 629             if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
 630                 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
 631             else
 632                 retval = 0;
 633
 634             goto finish;
 635
 636         case PA_CMD_CLEANUP_SHM:
 637
 638             if (d < argc) {
 639                 pa_log("Too many arguments.\n");
 640                 goto finish;
 641             }
 642
 643             if (pa_shm_cleanup() >= 0)
 644                 retval = 0;
 645
 646             goto finish;
 647
 648         default:
 649             pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
 650     }
 651
 652     if (d < argc) {
 653         pa_log("Too many arguments.\n");
 654         goto finish;
 655     }
 656
 657 #ifdef HAVE_GETUID
 658     if (getuid() == 0 && !conf->system_instance)
 659         pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
 660 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
 661     else if (getuid() != 0 && conf->system_instance) {
 662         pa_log(_("Root privileges required."));
 663         goto finish;
 664     }
 665 #endif
 666 #endif  /* HAVE_GETUID */
 667
 668     if (conf->cmd == PA_CMD_START && conf->system_instance) {
 669         pa_log(_("--start not supported for system instances."));
 670         goto finish;
 671     }
 672
 673     if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
 674         pa_log_notice(_("User-configured server at %s, not autospawning."), configured_address);
 675         pa_xfree(configured_address);
 676         retval = 0;
 677         goto finish;
 678     }
 679
 680     if (conf->system_instance && !conf->disallow_exit)
 681         pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
 682
 683     if (conf->system_instance && !conf->disallow_module_loading)
 684         pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
 685
 686     if (conf->system_instance && !conf->disable_shm) {
 687         pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
 688         conf->disable_shm = TRUE;
 689     }
 690
 691     if (conf->system_instance && conf->exit_idle_time >= 0) {
 692         pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
 693         conf->exit_idle_time = -1;
 694     }
 695
 696     if (conf->cmd == PA_CMD_START) {
 697         /* If we shall start PA only when it is not running yet, we
 698          * first take the autospawn lock to make things
 699          * synchronous. */
 700
 701         if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
 702             pa_log("Failed to initialize autospawn lock");
 703             goto finish;
 704         }
 705
 706         if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
 707             pa_log("Failed to acquire autospawn lock");
 708             goto finish;
 709         }
 710
 711         autospawn_locked = TRUE;
 712     }
 713
 714     if (conf->daemonize) {
 715         pid_t child;
 716
 717         if (pa_stdio_acquire() < 0) {
 718             pa_log(_("Failed to acquire stdio."));
 719             goto finish;
 720         }
 721
 722 #ifdef HAVE_FORK
 723         if (pipe(daemon_pipe) < 0) {
 724             pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
 725             goto finish;
 726         }
 727
 728         if ((child = fork()) < 0) {
 729             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 730             goto finish;
 731         }
 732
 733         if (child != 0) {
 734             ssize_t n;
 735             /* Father */
 736
 737             pa_assert_se(pa_close(daemon_pipe[1]) == 0);
 738             daemon_pipe[1] = -1;
 739
 740             if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 741
 742                 if (n < 0)
 743                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 744
 745                 retval = 1;
 746             }
 747
 748             if (retval)
 749                 pa_log(_("Daemon startup failed."));
 750             else
 751                 pa_log_info(_("Daemon startup successful."));
 752
 753             goto finish;
 754         }
 755
 756         if (autospawn_fd >= 0) {
 757             /* The lock file is unlocked from the parent, so we need
 758              * to close it in the child */
 759
 760             pa_autospawn_lock_release();
 761             pa_autospawn_lock_done(TRUE);
 762
 763             autospawn_locked = FALSE;
 764             autospawn_fd = -1;
 765         }
 766
 767         pa_assert_se(pa_close(daemon_pipe[0]) == 0);
 768         daemon_pipe[0] = -1;
 769 #endif
 770
 771         if (conf->auto_log_target)
 772             pa_log_set_target(PA_LOG_SYSLOG);
 773
 774 #ifdef HAVE_SETSID
 775         if (setsid() < 0) {
 776             pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
 777             goto finish;
 778         }
 779 #endif
 780
 781         /* We now are a session and process group leader. Let's fork
 782          * again and let the father die, so that we'll become a
 783          * process that can never acquire a TTY again, in a session and
 784          * process group without leader */
 785
 786 #ifdef HAVE_FORK
 787         if ((child = fork()) < 0) {
 788             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 789             goto finish;
 790         }
 791
 792         if (child != 0) {
 793             retval = 0;
 794             goto finish;
 795         }
 796 #endif
 797
 798 #ifdef SIGTTOU
 799         signal(SIGTTOU, SIG_IGN);
 800 #endif
 801 #ifdef SIGTTIN
 802         signal(SIGTTIN, SIG_IGN);
 803 #endif
 804 #ifdef SIGTSTP
 805         signal(SIGTSTP, SIG_IGN);
 806 #endif
 807
 808         pa_nullify_stdfds();
 809     }
 810
 811     pa_set_env_and_record("PULSE_INTERNAL", "1");
 812     pa_assert_se(chdir("/") == 0);
 813     umask(0022);
 814
 815 #ifdef HAVE_SYS_RESOURCE_H
 816     set_all_rlimits(conf);
 817 #endif
 818     pa_rtclock_hrtimer_enable();
 819
 820     pa_raise_priority(conf->nice_level);
 821
 822     if (conf->system_instance)
 823         if (change_user() < 0)
 824             goto finish;
 825
 826     pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
 827
 828     pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
 829     pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
 830     pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
 831
 832     s = pa_uname_string();
 833     pa_log_debug(_("Running on host: %s"), s);
 834     pa_xfree(s);
 835
 836     pa_log_debug(_("Found %u CPUs."), pa_ncpus());
 837
 838     pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
 839
 840 #ifdef HAVE_VALGRIND_MEMCHECK_H
 841     pa_log_debug(_("Compiled with Valgrind support: yes"));
 842 #else
 843     pa_log_debug(_("Compiled with Valgrind support: no"));
 844 #endif
 845
 846     pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
 847
 848     pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
 849
 850 #ifdef __OPTIMIZE__
 851     pa_log_debug(_("Optimized build: yes"));
 852 #else
 853     pa_log_debug(_("Optimized build: no"));
 854 #endif
 855
 856 #ifdef NDEBUG
 857     pa_log_debug(_("NDEBUG defined, all asserts disabled."));
 858 #elif defined(FASTPATH)
 859     pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
 860 #else
 861     pa_log_debug(_("All asserts enabled."));
 862 #endif
 863
 864     if (!(s = pa_machine_id())) {
 865         pa_log(_("Failed to get machine ID"));
 866         goto finish;
 867     }
 868     pa_log_info(_("Machine ID is %s."), s);
 869     pa_xfree(s);
 870
 871     if ((s = pa_session_id())) {
 872         pa_log_info(_("Session ID is %s."), s);
 873         pa_xfree(s);
 874     }
 875
 876     if (!(s = pa_get_runtime_dir()))
 877         goto finish;
 878     pa_log_info(_("Using runtime directory %s."), s);
 879     pa_xfree(s);
 880
 881     if (!(s = pa_get_state_dir()))
 882         goto finish;
 883     pa_log_info(_("Using state directory %s."), s);
 884     pa_xfree(s);
 885
 886     pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
 887
 888     pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
 889
 890     if (pa_in_system_mode())
 891         pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
 892                       "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
 893                       "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
 894
 895     if (conf->use_pid_file) {
 896         int z;
 897
 898         if ((z = pa_pid_file_create("pulseaudio")) != 0) {
 899
 900             if (conf->cmd == PA_CMD_START && z > 0) {
 901                 /* If we are already running and with are run in
 902                  * --start mode, then let's return this as success. */
 903
 904                 retval = 0;
 905                 goto finish;
 906             }
 907
 908             pa_log(_("pa_pid_file_create() failed."));
 909             goto finish;
 910         }
 911
 912         valid_pid_file = TRUE;
 913     }
 914
 915     pa_disable_sigpipe();
 916
 917     if (pa_rtclock_hrtimer())
 918         pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
 919     else
 920         pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
 921
 922     if (conf->lock_memory) {
 923 #ifdef HAVE_SYS_MMAN_H
 924         if (mlockall(MCL_FUTURE) < 0)
 925             pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
 926         else
 927             pa_log_info("Successfully locked process into memory.");
 928 #else
 929         pa_log_warn("Memory locking requested but not supported on platform.");
 930 #endif
 931     }
 932
 933     pa_memtrap_install();
 934
 935     pa_assert_se(mainloop = pa_mainloop_new());
 936
 937     if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
 938         pa_log(_("pa_core_new() failed."));
 939         goto finish;
 940     }
 941
 942     c->default_sample_spec = conf->default_sample_spec;
 943     c->default_channel_map = conf->default_channel_map;
 944     c->default_n_fragments = conf->default_n_fragments;
 945     c->default_fragment_size_msec = conf->default_fragment_size_msec;
 946     c->sync_volume_safety_margin_usec = conf->sync_volume_safety_margin_usec;
 947     c->sync_volume_extra_delay_usec = conf->sync_volume_extra_delay_usec;
 948     c->exit_idle_time = conf->exit_idle_time;
 949     c->scache_idle_time = conf->scache_idle_time;
 950     c->resample_method = conf->resample_method;
 951     c->realtime_priority = conf->realtime_priority;
 952     c->realtime_scheduling = !!conf->realtime_scheduling;
 953     c->disable_remixing = !!conf->disable_remixing;
 954     c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
 955     c->sync_volume = !!conf->sync_volume;
 956     c->running_as_daemon = !!conf->daemonize;
 957     c->disallow_exit = conf->disallow_exit;
 958     c->flat_volumes = conf->flat_volumes;
 959 #ifdef HAVE_DBUS
 960     c->server_type = conf->local_server_type;
 961 #endif
 962
 963     c->cpu_info.cpu_type = PA_CPU_UNDEFINED;
 964     if (!getenv("PULSE_NO_SIMD")) {
 965         if (pa_cpu_init_x86(&(c->cpu_info.flags.x86)))
 966             c->cpu_info.cpu_type = PA_CPU_X86;
 967         if (pa_cpu_init_arm(&(c->cpu_info.flags.arm)))
 968             c->cpu_info.cpu_type = PA_CPU_ARM;
 969         pa_cpu_init_orc(c->cpu_info);
 970     }
 971
 972     pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
 973     pa_signal_new(SIGINT, signal_callback, c);
 974     pa_signal_new(SIGTERM, signal_callback, c);
 975 #ifdef SIGUSR1
 976     pa_signal_new(SIGUSR1, signal_callback, c);
 977 #endif
 978 #ifdef SIGUSR2
 979     pa_signal_new(SIGUSR2, signal_callback, c);
 980 #endif
 981 #ifdef SIGHUP
 982     pa_signal_new(SIGHUP, signal_callback, c);
 983 #endif
 984
 985 #ifdef OS_IS_WIN32
 986     win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
 987 #endif
 988
 989     if (!conf->no_cpu_limit)
 990         pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
 991
 992     buf = pa_strbuf_new();
 993
 994 #ifdef HAVE_DBUS
 995     if (start_server) {
 996 #endif
 997         if (conf->load_default_script_file) {
 998             FILE *f;
 999
1000             if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1001                 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1002                 fclose(f);
1003             }
1004         }
1005
1006         if (r >= 0)
1007             r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1008
1009         pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1010         pa_xfree(s);
1011
1012         if (r < 0 && conf->fail) {
1013             pa_log(_("Failed to initialize daemon."));
1014             goto finish;
1015         }
1016
1017         if (!c->modules || pa_idxset_size(c->modules) == 0) {
1018             pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1019             goto finish;
1020         }
1021 #ifdef HAVE_DBUS
1022     } else {
1023         /* When we just provide the D-Bus server lookup service, we don't want
1024          * any modules to be loaded. We haven't loaded any so far, so one might
1025          * think there's no way to contact the server, but receiving certain
1026          * signals could still cause modules to load. */
1027         conf->disallow_module_loading = TRUE;
1028     }
1029 #endif
1030
1031     /* We completed the initial module loading, so let's disable it
1032      * from now on, if requested */
1033     c->disallow_module_loading = !!conf->disallow_module_loading;
1034
1035 #ifdef HAVE_DBUS
1036     if (!conf->system_instance) {
1037         if (!(server_lookup = pa_dbusobj_server_lookup_new(c)))
1038             goto finish;
1039         if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1040             goto finish;
1041     }
1042
1043     if (start_server && !(server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server")))
1044         goto finish;
1045 #endif
1046
1047 #ifdef HAVE_FORK
1048     if (daemon_pipe[1] >= 0) {
1049         int ok = 0;
1050         pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1051         pa_close(daemon_pipe[1]);
1052         daemon_pipe[1] = -1;
1053     }
1054 #endif
1055
1056     pa_log_info(_("Daemon startup complete."));
1057
1058     retval = 0;
1059     if (pa_mainloop_run(mainloop, &retval) < 0)
1060         goto finish;
1061
1062     pa_log_info(_("Daemon shutdown initiated."));
1063
1064 finish:
1065 #ifdef HAVE_DBUS
1066     if (server_bus)
1067         pa_dbus_connection_unref(server_bus);
1068     if (lookup_service_bus)
1069         pa_dbus_connection_unref(lookup_service_bus);
1070     if (server_lookup)
1071         pa_dbusobj_server_lookup_free(server_lookup);
1072 #endif
1073
1074     if (autospawn_fd >= 0) {
1075         if (autospawn_locked)
1076             pa_autospawn_lock_release();
1077
1078         pa_autospawn_lock_done(FALSE);
1079     }
1080
1081 #ifdef OS_IS_WIN32
1082     if (mainloop && win32_timer)
1083         pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1084 #endif
1085
1086     if (c) {
1087         pa_core_unref(c);
1088         pa_log_info(_("Daemon terminated."));
1089     }
1090
1091     if (!conf->no_cpu_limit)
1092         pa_cpu_limit_done();
1093
1094     pa_signal_done();
1095
1096 #ifdef HAVE_FORK
1097     if (daemon_pipe[1] >= 0)
1098         pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1099
1100     pa_close_pipe(daemon_pipe);
1101 #endif
1102
1103     if (mainloop)
1104         pa_mainloop_free(mainloop);
1105
1106     if (conf)
1107         pa_daemon_conf_free(conf);
1108
1109     if (valid_pid_file)
1110         pa_pid_file_remove();
1111
1112     /* This has no real purpose except making things valgrind-clean */
1113     pa_unset_env_recorded();
1114
1115 #ifdef OS_IS_WIN32
1116     WSACleanup();
1117 #endif
1118
1119     if (ltdl_init)
1120         pa_ltdl_done();
1121
1122 #ifdef HAVE_DBUS
1123     dbus_shutdown();
1124 #endif
1125
1126     return retval;
1127 }