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