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