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