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 <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 #include <pulsecore/strlist.h>
  94 #ifdef HAVE_DBUS
  95 #include <pulsecore/dbus-shared.h>
  96 #endif
  97 #include <pulsecore/cpu-arm.h>
  98 #include <pulsecore/cpu-x86.h>
  99 #include <pulsecore/cpu-orc.h>
 100
 101 #include "cmdline.h"
 102 #include "cpulimit.h"
 103 #include "daemon-conf.h"
 104 #include "dumpmodules.h"
 105 #include "caps.h"
 106 #include "ltdl-bind-now.h"
 107 #include "server-lookup.h"
 108
 109 #ifdef HAVE_LIBWRAP
 110 /* Only one instance of these variables */
 111 int allow_severity = LOG_INFO;
 112 int deny_severity = LOG_WARNING;
 113 #endif
 114
 115 #ifdef HAVE_OSS_WRAPPER
 116 /* padsp looks for this symbol in the running process and disables
 117  * itself if it finds it and it is set to 7 (which is actually a bit
 118  * mask). For details see padsp. */
 119 int __padsp_disabled__ = 7;
 120 #endif
 121
 122 #ifdef OS_IS_WIN32
 123
 124 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
 125     MSG msg;
 126     struct timeval tvnext;
 127
 128     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
 129         if (msg.message == WM_QUIT)
 130             raise(SIGTERM);
 131         else {
 132             TranslateMessage(&msg);
 133             DispatchMessage(&msg);
 134         }
 135     }
 136
 137     pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
 138     a->time_restart(e, &tvnext);
 139 }
 140
 141 #endif
 142
 143 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
 144     pa_log_info(_("Got signal %s."), pa_sig2str(sig));
 145
 146     switch (sig) {
 147 #ifdef SIGUSR1
 148         case SIGUSR1:
 149             pa_module_load(userdata, "module-cli", NULL);
 150             break;
 151 #endif
 152
 153 #ifdef SIGUSR2
 154         case SIGUSR2:
 155             pa_module_load(userdata, "module-cli-protocol-unix", NULL);
 156             break;
 157 #endif
 158
 159 #ifdef SIGHUP
 160         case SIGHUP: {
 161             char *c = pa_full_status_string(userdata);
 162             pa_log_notice("%s", c);
 163             pa_xfree(c);
 164             return;
 165         }
 166 #endif
 167
 168         case SIGINT:
 169         case SIGTERM:
 170         default:
 171             pa_log_info(_("Exiting."));
 172             m->quit(m, 1);
 173             break;
 174     }
 175 }
 176
 177 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
 178
 179 static int change_user(void) {
 180     struct passwd *pw;
 181     struct group * gr;
 182     int r;
 183
 184     /* This function is called only in system-wide mode. It creates a
 185      * runtime dir in /var/run/ with proper UID/GID and drops privs
 186      * afterwards. */
 187
 188     if (!(pw = getpwnam(PA_SYSTEM_USER))) {
 189         pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
 190         return -1;
 191     }
 192
 193     if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
 194         pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
 195         return -1;
 196     }
 197
 198     pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
 199                 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
 200                 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
 201
 202     if (pw->pw_gid != gr->gr_gid) {
 203         pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
 204         return -1;
 205     }
 206
 207     if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
 208         pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
 209
 210     if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
 211         pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
 212         return -1;
 213     }
 214
 215     if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
 216         pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
 217         return -1;
 218     }
 219
 220     /* We don't create the config dir here, because we don't need to write to it */
 221
 222     if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
 223         pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
 224         return -1;
 225     }
 226
 227 #if defined(HAVE_SETRESGID)
 228     r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
 229 #elif defined(HAVE_SETEGID)
 230     if ((r = setgid(gr->gr_gid)) >= 0)
 231         r = setegid(gr->gr_gid);
 232 #elif defined(HAVE_SETREGID)
 233     r = setregid(gr->gr_gid, gr->gr_gid);
 234 #else
 235 #error "No API to drop privileges"
 236 #endif
 237
 238     if (r < 0) {
 239         pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
 240         return -1;
 241     }
 242
 243 #if defined(HAVE_SETRESUID)
 244     r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
 245 #elif defined(HAVE_SETEUID)
 246     if ((r = setuid(pw->pw_uid)) >= 0)
 247         r = seteuid(pw->pw_uid);
 248 #elif defined(HAVE_SETREUID)
 249     r = setreuid(pw->pw_uid, pw->pw_uid);
 250 #else
 251 #error "No API to drop privileges"
 252 #endif
 253
 254     if (r < 0) {
 255         pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
 256         return -1;
 257     }
 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 dropped root privileges."));
 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. Weird shit!", 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     pa_bool_t valid_pid_file = FALSE;
 409     pa_bool_t 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     pa_bool_t 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     pa_bool_t 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     pa_log_set_level(conf->log_level);
 506     pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
 507     if (conf->log_meta)
 508         pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
 509     if (conf->log_time)
 510         pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
 511     pa_log_set_show_backtrace(conf->log_backtrace);
 512
 513 #ifdef HAVE_DBUS
 514     /* conf->system_instance and conf->local_server_type control almost the
 515      * same thing; make them agree about what is requested. */
 516     switch (conf->local_server_type) {
 517         case PA_SERVER_TYPE_UNSET:
 518             conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
 519             break;
 520         case PA_SERVER_TYPE_USER:
 521         case PA_SERVER_TYPE_NONE:
 522             conf->system_instance = FALSE;
 523             break;
 524         case PA_SERVER_TYPE_SYSTEM:
 525             conf->system_instance = TRUE;
 526             break;
 527         default:
 528             pa_assert_not_reached();
 529     }
 530
 531     start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
 532
 533     if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
 534         pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
 535         conf->system_instance = FALSE;
 536     }
 537 #endif
 538
 539     LTDL_SET_PRELOADED_SYMBOLS();
 540     pa_ltdl_init();
 541     ltdl_init = TRUE;
 542
 543     if (conf->dl_search_path)
 544         lt_dlsetsearchpath(conf->dl_search_path);
 545
 546 #ifdef OS_IS_WIN32
 547     {
 548         WSADATA data;
 549         WSAStartup(MAKEWORD(2, 0), &data);
 550     }
 551 #endif
 552
 553     pa_random_seed();
 554
 555     switch (conf->cmd) {
 556         case PA_CMD_DUMP_MODULES:
 557             pa_dump_modules(conf, argc-d, argv+d);
 558             retval = 0;
 559             goto finish;
 560
 561         case PA_CMD_DUMP_CONF: {
 562
 563             if (d < argc) {
 564                 pa_log("Too many arguments.\n");
 565                 goto finish;
 566             }
 567
 568             s = pa_daemon_conf_dump(conf);
 569             fputs(s, stdout);
 570             pa_xfree(s);
 571             retval = 0;
 572             goto finish;
 573         }
 574
 575         case PA_CMD_DUMP_RESAMPLE_METHODS: {
 576             int i;
 577
 578             if (d < argc) {
 579                 pa_log("Too many arguments.\n");
 580                 goto finish;
 581             }
 582
 583             for (i = 0; i < PA_RESAMPLER_MAX; i++)
 584                 if (pa_resample_method_supported(i))
 585                     printf("%s\n", pa_resample_method_to_string(i));
 586
 587             retval = 0;
 588             goto finish;
 589         }
 590
 591         case PA_CMD_HELP :
 592             pa_cmdline_help(argv[0]);
 593             retval = 0;
 594             goto finish;
 595
 596         case PA_CMD_VERSION :
 597
 598             if (d < argc) {
 599                 pa_log("Too many arguments.\n");
 600                 goto finish;
 601             }
 602
 603             printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
 604             retval = 0;
 605             goto finish;
 606
 607         case PA_CMD_CHECK: {
 608             pid_t pid;
 609
 610             if (d < argc) {
 611                 pa_log("Too many arguments.\n");
 612                 goto finish;
 613             }
 614
 615             if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
 616                 pa_log_info(_("Daemon not running"));
 617             else {
 618                 pa_log_info(_("Daemon running as PID %u"), pid);
 619                 retval = 0;
 620             }
 621
 622             goto finish;
 623
 624         }
 625         case PA_CMD_KILL:
 626
 627             if (d < argc) {
 628                 pa_log("Too many arguments.\n");
 629                 goto finish;
 630             }
 631
 632             if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
 633                 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
 634             else
 635                 retval = 0;
 636
 637             goto finish;
 638
 639         case PA_CMD_CLEANUP_SHM:
 640
 641             if (d < argc) {
 642                 pa_log("Too many arguments.\n");
 643                 goto finish;
 644             }
 645
 646             if (pa_shm_cleanup() >= 0)
 647                 retval = 0;
 648
 649             goto finish;
 650
 651         default:
 652             pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
 653     }
 654
 655     if (d < argc) {
 656         pa_log("Too many arguments.\n");
 657         goto finish;
 658     }
 659
 660 #ifdef HAVE_GETUID
 661     if (getuid() == 0 && !conf->system_instance)
 662         pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
 663 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
 664     else if (getuid() != 0 && conf->system_instance) {
 665         pa_log(_("Root privileges required."));
 666         goto finish;
 667     }
 668 #endif
 669 #endif  /* HAVE_GETUID */
 670
 671     if (conf->cmd == PA_CMD_START && conf->system_instance) {
 672         pa_log(_("--start not supported for system instances."));
 673         goto finish;
 674     }
 675
 676     if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
 677         /* There is an server address in our config, but where did it come from?
 678          * By default a standard X11 login will load module-x11-publish which will
 679          * inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
 680          * up hitting this code path. So we have to check to see if our configured_address
 681          * is the same as the value that would go into this property so that we can
 682          * recover (i.e. autospawn) from a crash.
 683          */
 684         char *ufn;
 685         pa_bool_t start_anyway = FALSE;
 686
 687         if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
 688             char *id;
 689
 690             if ((id = pa_machine_id())) {
 691                 pa_strlist *server_list;
 692                 char formatted_ufn[256];
 693
 694                 pa_snprintf(formatted_ufn, sizeof(formatted_ufn), "{%s}unix:%s", id, ufn);
 695                 pa_xfree(id);
 696
 697                 if ((server_list = pa_strlist_parse(configured_address))) {
 698                     char *u = NULL;
 699
 700                     /* We only need to check the first server */
 701                     server_list = pa_strlist_pop(server_list, &u);
 702                     pa_strlist_free(server_list);
 703
 704                     start_anyway = (u && pa_streq(formatted_ufn, u));
 705                     pa_xfree(u);
 706                 }
 707             }
 708             pa_xfree(ufn);
 709         }
 710
 711         if (!start_anyway) {
 712             pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address);
 713             pa_xfree(configured_address);
 714             retval = 0;
 715             goto finish;
 716         }
 717
 718         pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address);
 719         pa_xfree(configured_address);
 720     }
 721
 722     if (conf->system_instance && !conf->disallow_exit)
 723         pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
 724
 725     if (conf->system_instance && !conf->disallow_module_loading)
 726         pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
 727
 728     if (conf->system_instance && !conf->disable_shm) {
 729         pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
 730         conf->disable_shm = TRUE;
 731     }
 732
 733     if (conf->system_instance && conf->exit_idle_time >= 0) {
 734         pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
 735         conf->exit_idle_time = -1;
 736     }
 737
 738     if (conf->cmd == PA_CMD_START) {
 739         /* If we shall start PA only when it is not running yet, we
 740          * first take the autospawn lock to make things
 741          * synchronous. */
 742
 743         if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
 744             pa_log("Failed to initialize autospawn lock");
 745             goto finish;
 746         }
 747
 748         if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
 749             pa_log("Failed to acquire autospawn lock");
 750             goto finish;
 751         }
 752
 753         autospawn_locked = TRUE;
 754     }
 755
 756     if (conf->daemonize) {
 757         pid_t child;
 758
 759         if (pa_stdio_acquire() < 0) {
 760             pa_log(_("Failed to acquire stdio."));
 761             goto finish;
 762         }
 763
 764 #ifdef HAVE_FORK
 765         if (pipe(daemon_pipe) < 0) {
 766             pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
 767             goto finish;
 768         }
 769
 770         if ((child = fork()) < 0) {
 771             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 772             pa_close_pipe(daemon_pipe);
 773             goto finish;
 774         }
 775
 776         if (child != 0) {
 777             ssize_t n;
 778             /* Father */
 779
 780             pa_assert_se(pa_close(daemon_pipe[1]) == 0);
 781             daemon_pipe[1] = -1;
 782
 783             if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 784
 785                 if (n < 0)
 786                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 787
 788                 retval = 1;
 789             }
 790
 791             if (retval)
 792                 pa_log(_("Daemon startup failed."));
 793             else
 794                 pa_log_info(_("Daemon startup successful."));
 795
 796             goto finish;
 797         }
 798
 799         if (autospawn_fd >= 0) {
 800             /* The lock file is unlocked from the parent, so we need
 801              * to close it in the child */
 802
 803             pa_autospawn_lock_release();
 804             pa_autospawn_lock_done(TRUE);
 805
 806             autospawn_locked = FALSE;
 807             autospawn_fd = -1;
 808         }
 809
 810         pa_assert_se(pa_close(daemon_pipe[0]) == 0);
 811         daemon_pipe[0] = -1;
 812 #endif
 813
 814         if (conf->auto_log_target)
 815             pa_log_set_target(PA_LOG_SYSLOG);
 816
 817 #ifdef HAVE_SETSID
 818         if (setsid() < 0) {
 819             pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
 820             goto finish;
 821         }
 822 #endif
 823
 824 #ifdef HAVE_FORK
 825         /* We now are a session and process group leader. Let's fork
 826          * again and let the father die, so that we'll become a
 827          * process that can never acquire a TTY again, in a session and
 828          * process group without leader */
 829
 830         if (pipe(daemon_pipe2) < 0) {
 831             pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
 832             goto finish;
 833         }
 834
 835         if ((child = fork()) < 0) {
 836             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 837             pa_close_pipe(daemon_pipe2);
 838             goto finish;
 839         }
 840
 841         if (child != 0) {
 842             ssize_t n;
 843             /* Father */
 844
 845             pa_assert_se(pa_close(daemon_pipe2[1]) == 0);
 846             daemon_pipe2[1] = -1;
 847
 848             if ((n = pa_loop_read(daemon_pipe2[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 849
 850                 if (n < 0)
 851                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 852
 853                 retval = 1;
 854             }
 855
 856             /* We now have to take care of signalling the first fork with
 857              * the return value we've received from this fork... */
 858             pa_assert(daemon_pipe[1] >= 0);
 859
 860             pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
 861             pa_close(daemon_pipe[1]);
 862             daemon_pipe[1] = -1;
 863
 864             goto finish;
 865         }
 866
 867         pa_assert_se(pa_close(daemon_pipe2[0]) == 0);
 868         daemon_pipe2[0] = -1;
 869
 870         /* We no longer need the (first) daemon_pipe as it's handled in our child above */
 871         pa_close_pipe(daemon_pipe);
 872 #endif
 873
 874 #ifdef SIGTTOU
 875         signal(SIGTTOU, SIG_IGN);
 876 #endif
 877 #ifdef SIGTTIN
 878         signal(SIGTTIN, SIG_IGN);
 879 #endif
 880 #ifdef SIGTSTP
 881         signal(SIGTSTP, SIG_IGN);
 882 #endif
 883
 884         pa_nullify_stdfds();
 885     }
 886
 887     pa_set_env_and_record("PULSE_INTERNAL", "1");
 888     pa_assert_se(chdir("/") == 0);
 889     umask(0022);
 890
 891 #ifdef HAVE_SYS_RESOURCE_H
 892     set_all_rlimits(conf);
 893 #endif
 894     pa_rtclock_hrtimer_enable();
 895
 896     pa_raise_priority(conf->nice_level);
 897
 898     if (conf->system_instance)
 899         if (change_user() < 0)
 900             goto finish;
 901
 902     pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
 903
 904     pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
 905     pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
 906     pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
 907
 908     s = pa_uname_string();
 909     pa_log_debug(_("Running on host: %s"), s);
 910     pa_xfree(s);
 911
 912     pa_log_debug(_("Found %u CPUs."), pa_ncpus());
 913
 914     pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
 915
 916 #ifdef HAVE_VALGRIND_MEMCHECK_H
 917     pa_log_debug(_("Compiled with Valgrind support: yes"));
 918 #else
 919     pa_log_debug(_("Compiled with Valgrind support: no"));
 920 #endif
 921
 922     pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
 923
 924     pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
 925
 926 #ifdef __OPTIMIZE__
 927     pa_log_debug(_("Optimized build: yes"));
 928 #else
 929     pa_log_debug(_("Optimized build: no"));
 930 #endif
 931
 932 #ifdef NDEBUG
 933     pa_log_debug(_("NDEBUG defined, all asserts disabled."));
 934 #elif defined(FASTPATH)
 935     pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
 936 #else
 937     pa_log_debug(_("All asserts enabled."));
 938 #endif
 939
 940     if (!(s = pa_machine_id())) {
 941         pa_log(_("Failed to get machine ID"));
 942         goto finish;
 943     }
 944     pa_log_info(_("Machine ID is %s."), s);
 945     pa_xfree(s);
 946
 947     if ((s = pa_session_id())) {
 948         pa_log_info(_("Session ID is %s."), s);
 949         pa_xfree(s);
 950     }
 951
 952     if (!(s = pa_get_runtime_dir()))
 953         goto finish;
 954     pa_log_info(_("Using runtime directory %s."), s);
 955     pa_xfree(s);
 956
 957     if (!(s = pa_get_state_dir()))
 958         goto finish;
 959     pa_log_info(_("Using state directory %s."), s);
 960     pa_xfree(s);
 961
 962     pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
 963
 964     pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
 965
 966     if (pa_in_system_mode())
 967         pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
 968                       "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
 969                       "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
 970
 971     if (conf->use_pid_file) {
 972         int z;
 973
 974         if ((z = pa_pid_file_create("pulseaudio")) != 0) {
 975
 976             if (conf->cmd == PA_CMD_START && z > 0) {
 977                 /* If we are already running and with are run in
 978                  * --start mode, then let's return this as success. */
 979
 980                 retval = 0;
 981                 goto finish;
 982             }
 983
 984             pa_log(_("pa_pid_file_create() failed."));
 985             goto finish;
 986         }
 987
 988         valid_pid_file = TRUE;
 989     }
 990
 991     pa_disable_sigpipe();
 992
 993     if (pa_rtclock_hrtimer())
 994         pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
 995     else
 996         pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
 997
 998     if (conf->lock_memory) {
 999 #ifdef HAVE_SYS_MMAN_H
1000         if (mlockall(MCL_FUTURE) < 0)
1001             pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
1002         else
1003             pa_log_info("Successfully locked process into memory.");
1004 #else
1005         pa_log_warn("Memory locking requested but not supported on platform.");
1006 #endif
1007     }
1008
1009     pa_memtrap_install();
1010
1011     pa_assert_se(mainloop = pa_mainloop_new());
1012
1013     if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
1014         pa_log(_("pa_core_new() failed."));
1015         goto finish;
1016     }
1017
1018     c->default_sample_spec = conf->default_sample_spec;
1019     c->default_channel_map = conf->default_channel_map;
1020     c->default_n_fragments = conf->default_n_fragments;
1021     c->default_fragment_size_msec = conf->default_fragment_size_msec;
1022     c->sync_volume_safety_margin_usec = conf->sync_volume_safety_margin_usec;
1023     c->sync_volume_extra_delay_usec = conf->sync_volume_extra_delay_usec;
1024     c->exit_idle_time = conf->exit_idle_time;
1025     c->scache_idle_time = conf->scache_idle_time;
1026     c->resample_method = conf->resample_method;
1027     c->realtime_priority = conf->realtime_priority;
1028     c->realtime_scheduling = !!conf->realtime_scheduling;
1029     c->disable_remixing = !!conf->disable_remixing;
1030     c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
1031     c->sync_volume = !!conf->sync_volume;
1032     c->running_as_daemon = !!conf->daemonize;
1033     c->disallow_exit = conf->disallow_exit;
1034     c->flat_volumes = conf->flat_volumes;
1035 #ifdef HAVE_DBUS
1036     c->server_type = conf->local_server_type;
1037 #endif
1038
1039     c->cpu_info.cpu_type = PA_CPU_UNDEFINED;
1040     if (!getenv("PULSE_NO_SIMD")) {
1041         if (pa_cpu_init_x86(&(c->cpu_info.flags.x86)))
1042             c->cpu_info.cpu_type = PA_CPU_X86;
1043         if (pa_cpu_init_arm(&(c->cpu_info.flags.arm)))
1044             c->cpu_info.cpu_type = PA_CPU_ARM;
1045         pa_cpu_init_orc(c->cpu_info);
1046     }
1047
1048     pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1049     pa_signal_new(SIGINT, signal_callback, c);
1050     pa_signal_new(SIGTERM, signal_callback, c);
1051 #ifdef SIGUSR1
1052     pa_signal_new(SIGUSR1, signal_callback, c);
1053 #endif
1054 #ifdef SIGUSR2
1055     pa_signal_new(SIGUSR2, signal_callback, c);
1056 #endif
1057 #ifdef SIGHUP
1058     pa_signal_new(SIGHUP, signal_callback, c);
1059 #endif
1060
1061 #ifdef OS_IS_WIN32
1062     win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1063 #endif
1064
1065     if (!conf->no_cpu_limit)
1066         pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1067
1068     buf = pa_strbuf_new();
1069
1070 #ifdef HAVE_DBUS
1071     if (start_server) {
1072 #endif
1073         if (conf->load_default_script_file) {
1074             FILE *f;
1075
1076             if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1077                 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1078                 fclose(f);
1079             }
1080         }
1081
1082         if (r >= 0)
1083             r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1084
1085         pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1086         pa_xfree(s);
1087
1088         if (r < 0 && conf->fail) {
1089             pa_log(_("Failed to initialize daemon."));
1090             goto finish;
1091         }
1092
1093         if (!c->modules || pa_idxset_size(c->modules) == 0) {
1094             pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1095             goto finish;
1096         }
1097 #ifdef HAVE_DBUS
1098     } else {
1099         /* When we just provide the D-Bus server lookup service, we don't want
1100          * any modules to be loaded. We haven't loaded any so far, so one might
1101          * think there's no way to contact the server, but receiving certain
1102          * signals could still cause modules to load. */
1103         conf->disallow_module_loading = TRUE;
1104     }
1105 #endif
1106
1107     /* We completed the initial module loading, so let's disable it
1108      * from now on, if requested */
1109     c->disallow_module_loading = !!conf->disallow_module_loading;
1110
1111 #ifdef HAVE_DBUS
1112     if (!conf->system_instance) {
1113         if (!(server_lookup = pa_dbusobj_server_lookup_new(c)))
1114             goto finish;
1115         if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1116             goto finish;
1117     }
1118
1119     if (start_server && !(server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server")))
1120         goto finish;
1121 #endif
1122
1123 #ifdef HAVE_FORK
1124     if (daemon_pipe2[1] >= 0) {
1125         int ok = 0;
1126         pa_loop_write(daemon_pipe2[1], &ok, sizeof(ok), NULL);
1127         pa_close(daemon_pipe2[1]);
1128         daemon_pipe2[1] = -1;
1129     }
1130 #endif
1131
1132     pa_log_info(_("Daemon startup complete."));
1133
1134     retval = 0;
1135     if (pa_mainloop_run(mainloop, &retval) < 0)
1136         goto finish;
1137
1138     pa_log_info(_("Daemon shutdown initiated."));
1139
1140 finish:
1141 #ifdef HAVE_DBUS
1142     if (server_bus)
1143         pa_dbus_connection_unref(server_bus);
1144     if (lookup_service_bus)
1145         pa_dbus_connection_unref(lookup_service_bus);
1146     if (server_lookup)
1147         pa_dbusobj_server_lookup_free(server_lookup);
1148 #endif
1149
1150     if (autospawn_fd >= 0) {
1151         if (autospawn_locked)
1152             pa_autospawn_lock_release();
1153
1154         pa_autospawn_lock_done(FALSE);
1155     }
1156
1157 #ifdef OS_IS_WIN32
1158     if (mainloop && win32_timer)
1159         pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1160 #endif
1161
1162     if (c) {
1163         pa_core_unref(c);
1164         pa_log_info(_("Daemon terminated."));
1165     }
1166
1167     if (!conf->no_cpu_limit)
1168         pa_cpu_limit_done();
1169
1170     pa_signal_done();
1171
1172 #ifdef HAVE_FORK
1173     /* If we have daemon_pipe[1] still open, this means we've failed after
1174      * the first fork, but before the second. Therefore just write to it. */
1175     if (daemon_pipe[1] >= 0)
1176         pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1177     else if (daemon_pipe2[1] >= 0)
1178         pa_loop_write(daemon_pipe2[1], &retval, sizeof(retval), NULL);
1179
1180     pa_close_pipe(daemon_pipe2);
1181     pa_close_pipe(daemon_pipe);
1182 #endif
1183
1184     if (mainloop)
1185         pa_mainloop_free(mainloop);
1186
1187     if (conf)
1188         pa_daemon_conf_free(conf);
1189
1190     if (valid_pid_file)
1191         pa_pid_file_remove();
1192
1193     /* This has no real purpose except making things valgrind-clean */
1194     pa_unset_env_recorded();
1195
1196 #ifdef OS_IS_WIN32
1197     WSACleanup();
1198 #endif
1199
1200     if (ltdl_init)
1201         pa_ltdl_done();
1202
1203 #ifdef HAVE_DBUS
1204     dbus_shutdown();
1205 #endif
1206
1207     return retval;
1208 }