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