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