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/rtsig.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 #include "polkit.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
 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(pa_core *c) {
 343     DBusError error;
 344     pa_dbus_connection *conn;
 345
 346     dbus_error_init(&error);
 347
 348     if (!(conn = pa_dbus_bus_get(c, pa_in_system_mode() ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &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), "org.pulseaudio.Server", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 354         pa_log_debug("Got org.pulseaudio.Server!");
 355         return conn;
 356     }
 357
 358     if (dbus_error_is_set(&error))
 359         pa_log_warn("Failed to acquire org.pulseaudio.Server: %s: %s", error.name, error.message);
 360     else
 361         pa_log_warn("D-Bus name org.pulseaudio.Server already taken. Weird shit!");
 362
 363     /* PA cannot be started twice by the same user and hence we can
 364      * ignore mostly the case that org.pulseaudio.Server is already
 365      * taken. */
 366
 367 fail:
 368
 369     if (conn)
 370         pa_dbus_connection_unref(conn);
 371
 372     dbus_error_free(&error);
 373     return NULL;
 374 }
 375 #endif
 376
 377 int main(int argc, char *argv[]) {
 378     pa_core *c = NULL;
 379     pa_strbuf *buf = NULL;
 380     pa_daemon_conf *conf = NULL;
 381     pa_mainloop *mainloop = NULL;
 382     char *s;
 383     int r = 0, retval = 1, d = 0;
 384     pa_bool_t suid_root, real_root;
 385     pa_bool_t valid_pid_file = FALSE;
 386     gid_t gid = (gid_t) -1;
 387     pa_bool_t ltdl_init = FALSE;
 388     int passed_fd = -1;
 389     const char *e;
 390 #ifdef HAVE_FORK
 391     int daemon_pipe[2] = { -1, -1 };
 392 #endif
 393 #ifdef OS_IS_WIN32
 394     pa_time_event *win32_timer;
 395     struct timeval win32_tv;
 396 #endif
 397     int autospawn_fd = -1;
 398     pa_bool_t autospawn_locked = FALSE;
 399 #ifdef HAVE_DBUS
 400     pa_dbus_connection *dbus = NULL;
 401 #endif
 402
 403     pa_log_set_ident("pulseaudio");
 404     pa_log_set_level(PA_LOG_NOTICE);
 405     pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
 406
 407 #if defined(__linux__) && defined(__OPTIMIZE__)
 408     /*
 409        Disable lazy relocations to make usage of external libraries
 410        more deterministic for our RT threads. We abuse __OPTIMIZE__ as
 411        a check whether we are a debug build or not.
 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             pa_assert_se(execv(rp, argv) == 0);
 424         else
 425             pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
 426     }
 427 #endif
 428
 429 #ifdef HAVE_GETUID
 430     real_root = getuid() == 0;
 431     suid_root = !real_root && geteuid() == 0;
 432 #else
 433     real_root = FALSE;
 434     suid_root = FALSE;
 435 #endif
 436
 437     if (!real_root) {
 438         /* Drop all capabilities except CAP_SYS_NICE  */
 439         pa_limit_caps();
 440
 441         /* Drop privileges, but keep CAP_SYS_NICE */
 442         pa_drop_root();
 443
 444         /* After dropping root, the effective set is reset, hence,
 445          * let's raise it again */
 446         pa_limit_caps();
 447
 448         /* When capabilities are not supported we will not be able to
 449          * acquire RT sched anymore. But yes, that's the way it is. It
 450          * is just too risky tun let PA run as root all the time. */
 451     }
 452
 453     if ((e = getenv("PULSE_PASSED_FD"))) {
 454         passed_fd = atoi(e);
 455
 456         if (passed_fd <= 2)
 457             passed_fd = -1;
 458     }
 459
 460     pa_close_all(passed_fd, -1);
 461
 462     pa_reset_sigs(-1);
 463     pa_unblock_sigs(-1);
 464
 465     /* At this point, we are a normal user, possibly with CAP_NICE if
 466      * we were started SUID. If we are started as normal root, than we
 467      * still are normal root. */
 468
 469     setlocale(LC_ALL, "");
 470     pa_init_i18n();
 471
 472     conf = pa_daemon_conf_new();
 473
 474     if (pa_daemon_conf_load(conf, NULL) < 0)
 475         goto finish;
 476
 477     if (pa_daemon_conf_env(conf) < 0)
 478         goto finish;
 479
 480     if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
 481         pa_log(_("Failed to parse command line."));
 482         goto finish;
 483     }
 484
 485     pa_log_set_level(conf->log_level);
 486     pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
 487     if (conf->log_meta)
 488         pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
 489     if (conf->log_time)
 490         pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
 491     pa_log_set_show_backtrace(conf->log_backtrace);
 492
 493     pa_log_debug("Started as real root: %s, suid root: %s", pa_yes_no(real_root), pa_yes_no(suid_root));
 494
 495     if (!real_root && pa_have_caps()) {
 496 #ifdef HAVE_SYS_RESOURCE_H
 497         struct rlimit rl;
 498 #endif
 499         pa_bool_t allow_high_priority = FALSE, allow_realtime = FALSE;
 500
 501         /* Let's better not enable high prio or RT by default */
 502
 503         if (conf->high_priority && !allow_high_priority) {
 504             if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
 505                 pa_log_info(_("We're in the group '%s', allowing high-priority scheduling."), PA_REALTIME_GROUP);
 506                 allow_high_priority = TRUE;
 507             }
 508         }
 509
 510         if (conf->realtime_scheduling && !allow_realtime) {
 511             if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
 512                 pa_log_info(_("We're in the group '%s', allowing real-time scheduling."), PA_REALTIME_GROUP);
 513                 allow_realtime = TRUE;
 514             }
 515         }
 516
 517 #ifdef HAVE_POLKIT
 518         if (conf->high_priority && !allow_high_priority) {
 519             if (pa_polkit_check("org.pulseaudio.acquire-high-priority") > 0) {
 520                 pa_log_info(_("PolicyKit grants us acquire-high-priority privilege."));
 521                 allow_high_priority = TRUE;
 522             } else
 523                 pa_log_info(_("PolicyKit refuses acquire-high-priority privilege."));
 524         }
 525
 526         if (conf->realtime_scheduling && !allow_realtime) {
 527             if (pa_polkit_check("org.pulseaudio.acquire-real-time") > 0) {
 528                 pa_log_info(_("PolicyKit grants us acquire-real-time privilege."));
 529                 allow_realtime = TRUE;
 530             } else
 531                 pa_log_info(_("PolicyKit refuses acquire-real-time privilege."));
 532         }
 533 #endif
 534
 535         if (!allow_high_priority && !allow_realtime) {
 536
 537             /* OK, there's no further need to keep CAP_NICE. Hence
 538              * let's give it up early */
 539
 540             pa_drop_caps();
 541         }
 542
 543 #ifdef RLIMIT_RTPRIO
 544         if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0)
 545             if (rl.rlim_cur > 0) {
 546                 pa_log_info("RLIMIT_RTPRIO is set to %u, allowing real-time scheduling.", (unsigned) rl.rlim_cur);
 547                 allow_realtime = TRUE;
 548             }
 549 #endif
 550 #ifdef RLIMIT_NICE
 551         if (getrlimit(RLIMIT_NICE, &rl) >= 0)
 552             if (rl.rlim_cur > 20 ) {
 553                 pa_log_info("RLIMIT_NICE is set to %u, allowing high-priority scheduling.", (unsigned) rl.rlim_cur);
 554                 allow_high_priority = TRUE;
 555             }
 556 #endif
 557
 558         if ((conf->high_priority && !allow_high_priority) ||
 559             (conf->realtime_scheduling && !allow_realtime))
 560             pa_log_info(_("Called SUID root and real-time and/or high-priority scheduling was requested in the configuration. However, we lack the necessary privileges:\n"
 561                             "We are not in group '%s', PolicyKit refuse to grant us the requested privileges and we have no increase RLIMIT_NICE/RLIMIT_RTPRIO resource limits.\n"
 562                             "For enabling real-time/high-priority scheduling please acquire the appropriate PolicyKit privileges, or become a member of '%s', or increase the RLIMIT_NICE/RLIMIT_RTPRIO resource limits for this user."),
 563                           PA_REALTIME_GROUP, PA_REALTIME_GROUP);
 564
 565
 566         if (!allow_realtime)
 567             conf->realtime_scheduling = FALSE;
 568
 569         if (!allow_high_priority)
 570             conf->high_priority = FALSE;
 571     }
 572
 573 #ifdef HAVE_SYS_RESOURCE_H
 574     /* Reset resource limits. If we are run as root (for system mode)
 575      * this might end up increasing the limits, which is intended
 576      * behaviour. For all other cases, i.e. started as normal user, or
 577      * SUID root at this point we should have no CAP_SYS_RESOURCE and
 578      * increasing the limits thus should fail. Which is, too, intended
 579      * behaviour */
 580
 581     set_all_rlimits(conf);
 582 #endif
 583
 584     if (conf->high_priority && !pa_can_high_priority()) {
 585         pa_log_info(_("High-priority scheduling enabled in configuration but not allowed by policy."));
 586         conf->high_priority = FALSE;
 587     }
 588
 589     if (conf->high_priority && (conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START))
 590         pa_raise_priority(conf->nice_level);
 591
 592     pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
 593
 594     if (!real_root && pa_have_caps()) {
 595         pa_bool_t drop;
 596
 597         drop = (conf->cmd != PA_CMD_DAEMON && conf->cmd != PA_CMD_START) || !conf->realtime_scheduling;
 598
 599 #ifdef RLIMIT_RTPRIO
 600         if (!drop) {
 601             struct rlimit rl;
 602             /* At this point we still have CAP_NICE if we were loaded
 603              * SUID root. If possible let's acquire RLIMIT_RTPRIO
 604              * instead and give CAP_NICE up. */
 605
 606             if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
 607
 608                 if (rl.rlim_cur >= 9)
 609                     drop = TRUE;
 610                 else {
 611                     rl.rlim_max = rl.rlim_cur = 9;
 612
 613                     if (setrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
 614                         pa_log_info(_("Successfully increased RLIMIT_RTPRIO"));
 615                         drop = TRUE;
 616                     } else
 617                         pa_log_warn(_("RLIMIT_RTPRIO failed: %s"), pa_cstrerror(errno));
 618                 }
 619             }
 620         }
 621 #endif
 622
 623         if (drop)  {
 624             pa_log_info(_("Giving up CAP_NICE"));
 625             pa_drop_caps();
 626             suid_root = FALSE;
 627         }
 628     }
 629
 630     if (conf->realtime_scheduling && !pa_can_realtime()) {
 631         pa_log_info(_("Real-time scheduling enabled in configuration but not allowed by policy."));
 632         conf->realtime_scheduling = FALSE;
 633     }
 634
 635     pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
 636
 637     LTDL_SET_PRELOADED_SYMBOLS();
 638     pa_ltdl_init();
 639     ltdl_init = TRUE;
 640
 641     if (conf->dl_search_path)
 642         lt_dlsetsearchpath(conf->dl_search_path);
 643
 644 #ifdef OS_IS_WIN32
 645     {
 646         WSADATA data;
 647         WSAStartup(MAKEWORD(2, 0), &data);
 648     }
 649 #endif
 650
 651     pa_random_seed();
 652
 653     switch (conf->cmd) {
 654         case PA_CMD_DUMP_MODULES:
 655             pa_dump_modules(conf, argc-d, argv+d);
 656             retval = 0;
 657             goto finish;
 658
 659         case PA_CMD_DUMP_CONF: {
 660             s = pa_daemon_conf_dump(conf);
 661             fputs(s, stdout);
 662             pa_xfree(s);
 663             retval = 0;
 664             goto finish;
 665         }
 666
 667         case PA_CMD_DUMP_RESAMPLE_METHODS: {
 668             int i;
 669
 670             for (i = 0; i < PA_RESAMPLER_MAX; i++)
 671                 if (pa_resample_method_supported(i))
 672                     printf("%s\n", pa_resample_method_to_string(i));
 673
 674             retval = 0;
 675             goto finish;
 676         }
 677
 678         case PA_CMD_HELP :
 679             pa_cmdline_help(argv[0]);
 680             retval = 0;
 681             goto finish;
 682
 683         case PA_CMD_VERSION :
 684             printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
 685             retval = 0;
 686             goto finish;
 687
 688         case PA_CMD_CHECK: {
 689             pid_t pid;
 690
 691             if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
 692                 pa_log_info(_("Daemon not running"));
 693             else {
 694                 pa_log_info(_("Daemon running as PID %u"), pid);
 695                 retval = 0;
 696             }
 697
 698             goto finish;
 699
 700         }
 701         case PA_CMD_KILL:
 702
 703             if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
 704                 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
 705             else
 706                 retval = 0;
 707
 708             goto finish;
 709
 710         case PA_CMD_CLEANUP_SHM:
 711
 712             if (pa_shm_cleanup() >= 0)
 713                 retval = 0;
 714
 715             goto finish;
 716
 717         default:
 718             pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
 719     }
 720
 721     if (real_root && !conf->system_instance)
 722         pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
 723     else if (!real_root && conf->system_instance) {
 724         pa_log(_("Root privileges required."));
 725         goto finish;
 726     }
 727
 728     if (conf->cmd == PA_CMD_START && conf->system_instance) {
 729         pa_log(_("--start not supported for system instances."));
 730         goto finish;
 731     }
 732
 733     if (conf->system_instance && !conf->disallow_exit)
 734         pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
 735
 736     if (conf->system_instance && !conf->disallow_module_loading)
 737         pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
 738
 739     if (conf->system_instance && !conf->disable_shm) {
 740         pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
 741         conf->disable_shm = TRUE;
 742     }
 743
 744     if (conf->system_instance && conf->exit_idle_time >= 0) {
 745         pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
 746         conf->exit_idle_time = -1;
 747     }
 748
 749     if (conf->cmd == PA_CMD_START) {
 750         /* If we shall start PA only when it is not running yet, we
 751          * first take the autospawn lock to make things
 752          * synchronous. */
 753
 754         if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
 755             pa_log("Failed to initialize autospawn lock");
 756             goto finish;
 757         }
 758
 759         if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
 760             pa_log("Failed to acquire autospawn lock");
 761             goto finish;
 762         }
 763
 764         autospawn_locked = TRUE;
 765     }
 766
 767     if (conf->daemonize) {
 768         pid_t child;
 769         int tty_fd;
 770
 771         if (pa_stdio_acquire() < 0) {
 772             pa_log(_("Failed to acquire stdio."));
 773             goto finish;
 774         }
 775
 776 #ifdef HAVE_FORK
 777         if (pipe(daemon_pipe) < 0) {
 778             pa_log(_("pipe failed: %s"), pa_cstrerror(errno));
 779             goto finish;
 780         }
 781
 782         if ((child = fork()) < 0) {
 783             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 784             goto finish;
 785         }
 786
 787         if (child != 0) {
 788             ssize_t n;
 789             /* Father */
 790
 791             pa_assert_se(pa_close(daemon_pipe[1]) == 0);
 792             daemon_pipe[1] = -1;
 793
 794             if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 795
 796                 if (n < 0)
 797                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 798
 799                 retval = 1;
 800             }
 801
 802             if (retval)
 803                 pa_log(_("Daemon startup failed."));
 804             else
 805                 pa_log_info(_("Daemon startup successful."));
 806
 807             goto finish;
 808         }
 809
 810         if (autospawn_fd >= 0) {
 811             /* The lock file is unlocked from the parent, so we need
 812              * to close it in the child */
 813
 814             pa_autospawn_lock_release();
 815             pa_autospawn_lock_done(TRUE);
 816
 817             autospawn_locked = FALSE;
 818             autospawn_fd = -1;
 819         }
 820
 821         pa_assert_se(pa_close(daemon_pipe[0]) == 0);
 822         daemon_pipe[0] = -1;
 823 #endif
 824
 825         if (conf->auto_log_target)
 826             pa_log_set_target(PA_LOG_SYSLOG);
 827
 828 #ifdef HAVE_SETSID
 829         setsid();
 830 #endif
 831 #ifdef HAVE_SETPGID
 832         setpgid(0,0);
 833 #endif
 834
 835 #ifndef OS_IS_WIN32
 836         pa_close(0);
 837         pa_close(1);
 838         pa_close(2);
 839
 840         pa_assert_se(open("/dev/null", O_RDONLY) == 0);
 841         pa_assert_se(open("/dev/null", O_WRONLY) == 1);
 842         pa_assert_se(open("/dev/null", O_WRONLY) == 2);
 843 #else
 844         FreeConsole();
 845 #endif
 846
 847 #ifdef SIGTTOU
 848         signal(SIGTTOU, SIG_IGN);
 849 #endif
 850 #ifdef SIGTTIN
 851         signal(SIGTTIN, SIG_IGN);
 852 #endif
 853 #ifdef SIGTSTP
 854         signal(SIGTSTP, SIG_IGN);
 855 #endif
 856
 857 #ifdef TIOCNOTTY
 858         if ((tty_fd = open("/dev/tty", O_RDWR)) >= 0) {
 859             ioctl(tty_fd, TIOCNOTTY, (char*) 0);
 860             pa_assert_se(pa_close(tty_fd) == 0);
 861         }
 862 #endif
 863     }
 864
 865     pa_set_env("PULSE_INTERNAL", "1");
 866     pa_assert_se(chdir("/") == 0);
 867     umask(0022);
 868
 869     if (conf->system_instance)
 870         if (change_user() < 0)
 871             goto finish;
 872
 873     pa_set_env("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
 874
 875     pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
 876     pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
 877     pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
 878
 879     s = pa_uname_string();
 880     pa_log_debug(_("Running on host: %s"), s);
 881     pa_xfree(s);
 882
 883     pa_log_debug(_("Found %u CPUs."), pa_ncpus());
 884
 885     pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
 886
 887 #ifdef HAVE_VALGRIND_MEMCHECK_H
 888     pa_log_debug(_("Compiled with Valgrind support: yes"));
 889 #else
 890     pa_log_debug(_("Compiled with Valgrind support: no"));
 891 #endif
 892
 893     pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
 894
 895 #ifdef __OPTIMIZE__
 896     pa_log_debug(_("Optimized build: yes"));
 897 #else
 898     pa_log_debug(_("Optimized build: no"));
 899 #endif
 900
 901 #ifdef NDEBUG
 902     pa_log_debug(_("NDEBUG defined, all asserts disabled."));
 903 #elif defined(FASTPATH)
 904     pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
 905 #else
 906     pa_log_debug(_("All asserts enabled."));
 907 #endif
 908
 909     if (!(s = pa_machine_id())) {
 910         pa_log(_("Failed to get machine ID"));
 911         goto finish;
 912     }
 913     pa_log_info(_("Machine ID is %s."), s);
 914     pa_xfree(s);
 915
 916     if ((s = pa_session_id())) {
 917             pa_log_info(_("Session ID is %s."), s);
 918             pa_xfree(s);
 919     }
 920
 921     if (!(s = pa_get_runtime_dir()))
 922         goto finish;
 923     pa_log_info(_("Using runtime directory %s."), s);
 924     pa_xfree(s);
 925
 926     if (!(s = pa_get_state_dir()))
 927         goto finish;
 928     pa_log_info(_("Using state directory %s."), s);
 929     pa_xfree(s);
 930
 931     pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
 932
 933     if (pa_in_system_mode())
 934         pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
 935                       "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
 936                       "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
 937
 938     if (conf->use_pid_file) {
 939         int z;
 940
 941         if ((z = pa_pid_file_create("pulseaudio")) != 0) {
 942
 943             if (conf->cmd == PA_CMD_START && z > 0) {
 944                 /* If we are already running and with are run in
 945                  * --start mode, then let's return this as success. */
 946
 947                 retval = 0;
 948                 goto finish;
 949             }
 950
 951             pa_log(_("pa_pid_file_create() failed."));
 952             goto finish;
 953         }
 954
 955         valid_pid_file = TRUE;
 956     }
 957
 958     pa_disable_sigpipe();
 959
 960     if (pa_rtclock_hrtimer())
 961         pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
 962     else
 963         pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
 964
 965     pa_rtclock_hrtimer_enable();
 966
 967 #ifdef SIGRTMIN
 968     /* Valgrind uses SIGRTMAX. To easy debugging we don't use it here */
 969     pa_rtsig_configure(SIGRTMIN, SIGRTMAX-1);
 970 #endif
 971
 972     if (conf->lock_memory) {
 973 #ifdef HAVE_SYS_MMAN_H
 974         if (mlockall(MCL_FUTURE) < 0)
 975             pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
 976         else
 977             pa_log_info("Sucessfully locked process into memory.");
 978 #else
 979         pa_log_warn("Memory locking requested but not supported on platform.");
 980 #endif
 981     }
 982
 983     pa_memtrap_install();
 984
 985     pa_assert_se(mainloop = pa_mainloop_new());
 986
 987     if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
 988         pa_log(_("pa_core_new() failed."));
 989         goto finish;
 990     }
 991
 992     c->default_sample_spec = conf->default_sample_spec;
 993     c->default_channel_map = conf->default_channel_map;
 994     c->default_n_fragments = conf->default_n_fragments;
 995     c->default_fragment_size_msec = conf->default_fragment_size_msec;
 996     c->exit_idle_time = conf->exit_idle_time;
 997     c->scache_idle_time = conf->scache_idle_time;
 998     c->resample_method = conf->resample_method;
 999     c->realtime_priority = conf->realtime_priority;
1000     c->realtime_scheduling = !!conf->realtime_scheduling;
1001     c->disable_remixing = !!conf->disable_remixing;
1002     c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
1003     c->running_as_daemon = !!conf->daemonize;
1004     c->disallow_exit = conf->disallow_exit;
1005     c->flat_volumes = conf->flat_volumes;
1006
1007     pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1008     pa_signal_new(SIGINT, signal_callback, c);
1009     pa_signal_new(SIGTERM, signal_callback, c);
1010 #ifdef SIGUSR1
1011     pa_signal_new(SIGUSR1, signal_callback, c);
1012 #endif
1013 #ifdef SIGUSR2
1014     pa_signal_new(SIGUSR2, signal_callback, c);
1015 #endif
1016 #ifdef SIGHUP
1017     pa_signal_new(SIGHUP, signal_callback, c);
1018 #endif
1019
1020 #ifdef OS_IS_WIN32
1021     win32_timer = pa_mainloop_get_api(mainloop)->rtclock_time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1022 #endif
1023
1024     oil_init();
1025
1026     if (!conf->no_cpu_limit)
1027         pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1028
1029     buf = pa_strbuf_new();
1030     if (conf->load_default_script_file) {
1031         FILE *f;
1032
1033         if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1034             r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1035             fclose(f);
1036         }
1037     }
1038
1039     if (r >= 0)
1040         r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1041
1042     pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1043     pa_xfree(s);
1044
1045     /* We completed the initial module loading, so let's disable it
1046      * from now on, if requested */
1047     c->disallow_module_loading = !!conf->disallow_module_loading;
1048
1049     if (r < 0 && conf->fail) {
1050         pa_log(_("Failed to initialize daemon."));
1051         goto finish;
1052     }
1053
1054     if (!c->modules || pa_idxset_size(c->modules) == 0) {
1055         pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1056         goto finish;
1057     }
1058
1059 #ifdef HAVE_FORK
1060     if (daemon_pipe[1] >= 0) {
1061         int ok = 0;
1062         pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1063         pa_close(daemon_pipe[1]);
1064         daemon_pipe[1] = -1;
1065     }
1066 #endif
1067
1068 #ifdef HAVE_DBUS
1069     dbus = register_dbus(c);
1070 #endif
1071
1072     pa_log_info(_("Daemon startup complete."));
1073
1074     retval = 0;
1075     if (pa_mainloop_run(mainloop, &retval) < 0)
1076         goto finish;
1077
1078     pa_log_info(_("Daemon shutdown initiated."));
1079
1080 finish:
1081 #ifdef HAVE_DBUS
1082     if (dbus)
1083         pa_dbus_connection_unref(dbus);
1084 #endif
1085
1086     if (autospawn_fd >= 0) {
1087         if (autospawn_locked)
1088             pa_autospawn_lock_release();
1089
1090         pa_autospawn_lock_done(FALSE);
1091     }
1092
1093 #ifdef OS_IS_WIN32
1094     if (win32_timer)
1095         pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1096 #endif
1097
1098     if (c) {
1099         pa_core_unref(c);
1100         pa_log_info(_("Daemon terminated."));
1101     }
1102
1103     if (!conf->no_cpu_limit)
1104         pa_cpu_limit_done();
1105
1106     pa_signal_done();
1107
1108 #ifdef HAVE_FORK
1109     if (daemon_pipe[1] >= 0)
1110         pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1111
1112     pa_close_pipe(daemon_pipe);
1113 #endif
1114
1115     if (mainloop)
1116         pa_mainloop_free(mainloop);
1117
1118     if (conf)
1119         pa_daemon_conf_free(conf);
1120
1121     if (valid_pid_file)
1122         pa_pid_file_remove();
1123
1124 #ifdef OS_IS_WIN32
1125     WSACleanup();
1126 #endif
1127
1128     if (ltdl_init)
1129         pa_ltdl_done();
1130
1131 #ifdef HAVE_DBUS
1132     dbus_shutdown();
1133 #endif
1134
1135     return retval;
1136 }