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

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