code.delx.au - pulseaudio/blob - src/daemon/main.c

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