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