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