src/daemon/main.c

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