int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
struct userdata *u = NULL;
#if defined(USE_TCP_SOCKETS)
uint32_t port = IPV4_PORT;
pa_bool_t port_fallback = TRUE;
const char *listen_on;
#else
int r;
#endif
#if defined(USE_PROTOCOL_NATIVE) || defined(USE_PROTOCOL_HTTP)
char t[256];
#endif
pa_assert(m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments");
goto fail;
}
m->userdata = u = pa_xnew0(struct userdata, 1);
u->module = m;
#if defined(USE_PROTOCOL_SIMPLE)
u->simple_protocol = pa_simple_protocol_get(m->core);
u->simple_options = pa_simple_options_new();
if (pa_simple_options_parse(u->simple_options, m->core, ma) < 0)
goto fail;
u->simple_options->module = m;
#elif defined(USE_PROTOCOL_CLI)
u->cli_protocol = pa_cli_protocol_get(m->core);
#elif defined(USE_PROTOCOL_HTTP)
u->http_protocol = pa_http_protocol_get(m->core);
#elif defined(USE_PROTOCOL_NATIVE)
u->native_protocol = pa_native_protocol_get(m->core);
u->native_options = pa_native_options_new();
if (pa_native_options_parse(u->native_options, m->core, ma) < 0)
goto fail;
u->native_options->module = m;
#else
u->esound_protocol = pa_esound_protocol_get(m->core);
u->esound_options = pa_esound_options_new();
if (pa_esound_options_parse(u->esound_options, m->core, ma) < 0)
goto fail;
u->esound_options->module = m;
#endif
#if defined(USE_TCP_SOCKETS)
if (pa_in_system_mode() || pa_modargs_get_value(ma, "port", NULL))
port_fallback = FALSE;
if (pa_modargs_get_value_u32(ma, "port", &port) < 0 || port < 1 || port > 0xFFFF) {
pa_log("port= expects a numerical argument between 1 and 65535.");
goto fail;
}
listen_on = pa_modargs_get_value(ma, "listen", NULL);
if (listen_on) {
# ifdef HAVE_IPV6
u->socket_server_ipv6 = pa_socket_server_new_ipv6_string(m->core->mainloop, listen_on, (uint16_t) port, port_fallback, TCPWRAP_SERVICE);
# endif
u->socket_server_ipv4 = pa_socket_server_new_ipv4_string(m->core->mainloop, listen_on, (uint16_t) port, port_fallback, TCPWRAP_SERVICE);
} else {
# ifdef HAVE_IPV6
u->socket_server_ipv6 = pa_socket_server_new_ipv6_any(m->core->mainloop, (uint16_t) port, port_fallback, TCPWRAP_SERVICE);
# endif
u->socket_server_ipv4 = pa_socket_server_new_ipv4_any(m->core->mainloop, (uint16_t) port, port_fallback, TCPWRAP_SERVICE);
}
# ifdef HAVE_IPV6
if (!u->socket_server_ipv4 && !u->socket_server_ipv6)
# else
if (!u->socket_server_ipv4)
# endif
goto fail;
if (u->socket_server_ipv4)
pa_socket_server_set_callback(u->socket_server_ipv4, socket_server_on_connection_cb, u);
# ifdef HAVE_IPV6
if (u->socket_server_ipv6)
pa_socket_server_set_callback(u->socket_server_ipv6, socket_server_on_connection_cb, u);
# endif
#else
# if defined(USE_PROTOCOL_ESOUND)
# if defined(USE_PER_USER_ESOUND_SOCKET)
u->socket_path = pa_sprintf_malloc("/tmp/.esd-%lu/socket", (unsigned long) getuid());
# else
u->socket_path = pa_xstrdup("/tmp/.esd/socket");
# endif
/* This socket doesn't reside in our own runtime dir but in
* /tmp/.esd/, hence we have to create the dir first */
if (pa_make_secure_parent_dir(u->socket_path, pa_in_system_mode() ? 0755U : 0700U, (uid_t)-1, (gid_t)-1, FALSE) < 0) {
pa_log("Failed to create socket directory '%s': %s\n", u->socket_path, pa_cstrerror(errno));
goto fail;
}
# else
if (!(u->socket_path = pa_runtime_path(pa_modargs_get_value(ma, "socket", UNIX_SOCKET)))) {
pa_log("Failed to generate socket path.");
goto fail;
}
# endif
if ((r = pa_unix_socket_remove_stale(u->socket_path)) < 0) {
pa_log("Failed to remove stale UNIX socket '%s': %s", u->socket_path, pa_cstrerror(errno));
goto fail;
} else if (r > 0)
pa_log_info("Removed stale UNIX socket '%s'.", u->socket_path);
if (!(u->socket_server_unix = pa_socket_server_new_unix(m->core->mainloop, u->socket_path)))
goto fail;
pa_socket_server_set_callback(u->socket_server_unix, socket_server_on_connection_cb, u);
#endif
#if defined(USE_PROTOCOL_NATIVE)
# if defined(USE_TCP_SOCKETS)
if (u->socket_server_ipv4)
if (pa_socket_server_get_address(u->socket_server_ipv4, t, sizeof(t)))
pa_native_protocol_add_server_string(u->native_protocol, t);
# ifdef HAVE_IPV6
if (u->socket_server_ipv6)
if (pa_socket_server_get_address(u->socket_server_ipv6, t, sizeof(t)))
pa_native_protocol_add_server_string(u->native_protocol, t);
# endif
# else
if (pa_socket_server_get_address(u->socket_server_unix, t, sizeof(t)))
pa_native_protocol_add_server_string(u->native_protocol, t);
# endif
#endif
#if defined(USE_PROTOCOL_HTTP)
#if defined(USE_TCP_SOCKETS)
if (u->socket_server_ipv4)
if (pa_socket_server_get_address(u->socket_server_ipv4, t, sizeof(t)))
pa_http_protocol_add_server_string(u->http_protocol, t);
#ifdef HAVE_IPV6
if (u->socket_server_ipv6)
if (pa_socket_server_get_address(u->socket_server_ipv6, t, sizeof(t)))
pa_http_protocol_add_server_string(u->http_protocol, t);
#endif /* HAVE_IPV6 */
#else /* USE_TCP_SOCKETS */
if (pa_socket_server_get_address(u->socket_server_unix, t, sizeof(t)))
pa_http_protocol_add_server_string(u->http_protocol, t);
#endif /* USE_TCP_SOCKETS */
#endif /* USE_PROTOCOL_HTTP */
if (ma)
pa_modargs_free(ma);
return 0;
fail:
if (ma)
pa_modargs_free(ma);
pa__done(m);
return -1;
}
int main(int argc, char *argv[]) {
pa_core *c = NULL;
pa_strbuf *buf = NULL;
pa_daemon_conf *conf = NULL;
pa_mainloop *mainloop = NULL;
char *s;
int r = 0, retval = 1, d = 0;
pa_bool_t valid_pid_file = FALSE;
pa_bool_t ltdl_init = FALSE;
int passed_fd = -1;
const char *e;
#ifdef HAVE_FORK
int daemon_pipe[2] = { -1, -1 };
#endif
#ifdef OS_IS_WIN32
pa_time_event *win32_timer;
struct timeval win32_tv;
#endif
int autospawn_fd = -1;
pa_bool_t autospawn_locked = FALSE;
#ifdef HAVE_DBUS
pa_dbus_connection *dbus = NULL;
#endif
pa_log_set_ident("pulseaudio");
pa_log_set_level(PA_LOG_NOTICE);
pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
#if defined(__linux__) && defined(__OPTIMIZE__)
/*
Disable lazy relocations to make usage of external libraries
more deterministic for our RT threads. We abuse __OPTIMIZE__ as
a check whether we are a debug build or not. This all is
admittedly a bit snake-oilish.
*/
if (!getenv("LD_BIND_NOW")) {
char *rp;
char *canonical_rp;
/* We have to execute ourselves, because the libc caches the
* value of $LD_BIND_NOW on initialization. */
pa_set_env("LD_BIND_NOW", "1");
if ((canonical_rp = pa_realpath(PA_BINARY))) {
if ((rp = pa_readlink("/proc/self/exe"))) {
if (pa_streq(rp, canonical_rp))
pa_assert_se(execv(rp, argv) == 0);
else
pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
pa_xfree(rp);
} else
pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
pa_xfree(canonical_rp);
} else
pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
}
#endif
if ((e = getenv("PULSE_PASSED_FD"))) {
passed_fd = atoi(e);
if (passed_fd <= 2)
passed_fd = -1;
}
/* We might be autospawned, in which case have no idea in which
* context we have been started. Let's cleanup our execution
* context as good as possible */
pa_reset_personality();
pa_drop_root();
pa_close_all(passed_fd, -1);
pa_reset_sigs(-1);
pa_unblock_sigs(-1);
pa_reset_priority();
setlocale(LC_ALL, "");
pa_init_i18n();
conf = pa_daemon_conf_new();
if (pa_daemon_conf_load(conf, NULL) < 0)
goto finish;
if (pa_daemon_conf_env(conf) < 0)
goto finish;
if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
pa_log(_("Failed to parse command line."));
goto finish;
}
pa_log_set_level(conf->log_level);
pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
if (conf->log_meta)
pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
if (conf->log_time)
pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
pa_log_set_show_backtrace(conf->log_backtrace);
LTDL_SET_PRELOADED_SYMBOLS();
pa_ltdl_init();
ltdl_init = TRUE;
if (conf->dl_search_path)
lt_dlsetsearchpath(conf->dl_search_path);
#ifdef OS_IS_WIN32
{
WSADATA data;
WSAStartup(MAKEWORD(2, 0), &data);
}
#endif
pa_random_seed();
switch (conf->cmd) {
case PA_CMD_DUMP_MODULES:
pa_dump_modules(conf, argc-d, argv+d);
retval = 0;
goto finish;
case PA_CMD_DUMP_CONF: {
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
s = pa_daemon_conf_dump(conf);
fputs(s, stdout);
pa_xfree(s);
retval = 0;
goto finish;
}
case PA_CMD_DUMP_RESAMPLE_METHODS: {
int i;
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
for (i = 0; i < PA_RESAMPLER_MAX; i++)
if (pa_resample_method_supported(i))
printf("%s\n", pa_resample_method_to_string(i));
retval = 0;
goto finish;
}
case PA_CMD_HELP :
pa_cmdline_help(argv[0]);
retval = 0;
goto finish;
case PA_CMD_VERSION :
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
retval = 0;
goto finish;
case PA_CMD_CHECK: {
pid_t pid;
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
pa_log_info(_("Daemon not running"));
else {
pa_log_info(_("Daemon running as PID %u"), pid);
retval = 0;
}
goto finish;
}
case PA_CMD_KILL:
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
else
retval = 0;
goto finish;
case PA_CMD_CLEANUP_SHM:
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
if (pa_shm_cleanup() >= 0)
retval = 0;
goto finish;
default:
pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
}
if (d < argc) {
pa_log("Too many arguments.\n");
goto finish;
}
if (getuid() == 0 && !conf->system_instance)
pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
else if (getuid() != 0 && conf->system_instance) {
pa_log(_("Root privileges required."));
goto finish;
}
if (conf->cmd == PA_CMD_START && conf->system_instance) {
pa_log(_("--start not supported for system instances."));
goto finish;
}
if (conf->system_instance && !conf->disallow_exit)
pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
if (conf->system_instance && !conf->disallow_module_loading)
pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
if (conf->system_instance && !conf->disable_shm) {
pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
conf->disable_shm = TRUE;
}
if (conf->system_instance && conf->exit_idle_time >= 0) {
pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
conf->exit_idle_time = -1;
}
if (conf->cmd == PA_CMD_START) {
/* If we shall start PA only when it is not running yet, we
* first take the autospawn lock to make things
* synchronous. */
if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
pa_log("Failed to initialize autospawn lock");
goto finish;
}
if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
pa_log("Failed to acquire autospawn lock");
goto finish;
}
autospawn_locked = TRUE;
}
if (conf->daemonize) {
pid_t child;
int tty_fd;
if (pa_stdio_acquire() < 0) {
pa_log(_("Failed to acquire stdio."));
goto finish;
}
#ifdef HAVE_FORK
if (pipe(daemon_pipe) < 0) {
pa_log(_("pipe failed: %s"), pa_cstrerror(errno));
goto finish;
}
if ((child = fork()) < 0) {
pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
goto finish;
}
if (child != 0) {
ssize_t n;
/* Father */
pa_assert_se(pa_close(daemon_pipe[1]) == 0);
daemon_pipe[1] = -1;
if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
if (n < 0)
pa_log(_("read() failed: %s"), pa_cstrerror(errno));
retval = 1;
}
if (retval)
pa_log(_("Daemon startup failed."));
else
pa_log_info(_("Daemon startup successful."));
goto finish;
}
if (autospawn_fd >= 0) {
/* The lock file is unlocked from the parent, so we need
* to close it in the child */
pa_autospawn_lock_release();
pa_autospawn_lock_done(TRUE);
autospawn_locked = FALSE;
autospawn_fd = -1;
}
pa_assert_se(pa_close(daemon_pipe[0]) == 0);
daemon_pipe[0] = -1;
#endif
if (conf->auto_log_target)
pa_log_set_target(PA_LOG_SYSLOG);
#ifdef HAVE_SETSID
setsid();
#endif
#ifdef HAVE_SETPGID
setpgid(0,0);
#endif
#ifndef OS_IS_WIN32
pa_close(0);
pa_close(1);
pa_close(2);
pa_assert_se(open("/dev/null", O_RDONLY) == 0);
pa_assert_se(open("/dev/null", O_WRONLY) == 1);
pa_assert_se(open("/dev/null", O_WRONLY) == 2);
#else
FreeConsole();
#endif
#ifdef SIGTTOU
signal(SIGTTOU, SIG_IGN);
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN);
#endif
#ifdef TIOCNOTTY
if ((tty_fd = open("/dev/tty", O_RDWR)) >= 0) {
ioctl(tty_fd, TIOCNOTTY, (char*) 0);
pa_assert_se(pa_close(tty_fd) == 0);
}
#endif
}
pa_set_env_and_record("PULSE_INTERNAL", "1");
pa_assert_se(chdir("/") == 0);
umask(0022);
#ifdef HAVE_SYS_RESOURCE_H
set_all_rlimits(conf);
#endif
pa_rtclock_hrtimer_enable();
pa_raise_priority(conf->nice_level);
if (conf->system_instance)
if (change_user() < 0)
goto finish;
pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
s = pa_uname_string();
pa_log_debug(_("Running on host: %s"), s);
pa_xfree(s);
pa_log_debug(_("Found %u CPUs."), pa_ncpus());
pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
#ifdef HAVE_VALGRIND_MEMCHECK_H
pa_log_debug(_("Compiled with Valgrind support: yes"));
#else
pa_log_debug(_("Compiled with Valgrind support: no"));
#endif
pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
#ifdef __OPTIMIZE__
pa_log_debug(_("Optimized build: yes"));
#else
pa_log_debug(_("Optimized build: no"));
#endif
#ifdef NDEBUG
pa_log_debug(_("NDEBUG defined, all asserts disabled."));
#elif defined(FASTPATH)
pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
#else
pa_log_debug(_("All asserts enabled."));
#endif
if (!(s = pa_machine_id())) {
pa_log(_("Failed to get machine ID"));
goto finish;
}
pa_log_info(_("Machine ID is %s."), s);
pa_xfree(s);
if ((s = pa_session_id())) {
pa_log_info(_("Session ID is %s."), s);
pa_xfree(s);
}
if (!(s = pa_get_runtime_dir()))
goto finish;
pa_log_info(_("Using runtime directory %s."), s);
pa_xfree(s);
if (!(s = pa_get_state_dir()))
goto finish;
pa_log_info(_("Using state directory %s."), s);
pa_xfree(s);
pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
if (pa_in_system_mode())
pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
"If you do it nonetheless then it's your own fault if things don't work as expected.\n"
"Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
if (conf->use_pid_file) {
int z;
if ((z = pa_pid_file_create("pulseaudio")) != 0) {
if (conf->cmd == PA_CMD_START && z > 0) {
/* If we are already running and with are run in
* --start mode, then let's return this as success. */
retval = 0;
goto finish;
}
pa_log(_("pa_pid_file_create() failed."));
goto finish;
}
valid_pid_file = TRUE;
}
pa_disable_sigpipe();
if (pa_rtclock_hrtimer())
pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
else
pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
if (conf->lock_memory) {
#ifdef HAVE_SYS_MMAN_H
if (mlockall(MCL_FUTURE) < 0)
pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
else
pa_log_info("Sucessfully locked process into memory.");
#else
pa_log_warn("Memory locking requested but not supported on platform.");
#endif
}
pa_memtrap_install();
if (!getenv("PULSE_NO_SIMD")) {
pa_cpu_init_x86();
pa_cpu_init_arm();
}
pa_assert_se(mainloop = pa_mainloop_new());
if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
pa_log(_("pa_core_new() failed."));
goto finish;
}
c->default_sample_spec = conf->default_sample_spec;
c->default_channel_map = conf->default_channel_map;
c->default_n_fragments = conf->default_n_fragments;
c->default_fragment_size_msec = conf->default_fragment_size_msec;
c->exit_idle_time = conf->exit_idle_time;
c->scache_idle_time = conf->scache_idle_time;
c->resample_method = conf->resample_method;
c->realtime_priority = conf->realtime_priority;
c->realtime_scheduling = !!conf->realtime_scheduling;
c->disable_remixing = !!conf->disable_remixing;
c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
c->running_as_daemon = !!conf->daemonize;
c->disallow_exit = conf->disallow_exit;
c->flat_volumes = conf->flat_volumes;
pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
pa_signal_new(SIGINT, signal_callback, c);
pa_signal_new(SIGTERM, signal_callback, c);
#ifdef SIGUSR1
pa_signal_new(SIGUSR1, signal_callback, c);
#endif
#ifdef SIGUSR2
pa_signal_new(SIGUSR2, signal_callback, c);
#endif
#ifdef SIGHUP
pa_signal_new(SIGHUP, signal_callback, c);
#endif
#ifdef OS_IS_WIN32
win32_timer = pa_mainloop_get_api(mainloop)->rtclock_time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
#endif
if (!conf->no_cpu_limit)
pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
buf = pa_strbuf_new();
if (conf->load_default_script_file) {
FILE *f;
if ((f = pa_daemon_conf_open_default_script_file(conf))) {
r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
fclose(f);
}
}
if (r >= 0)
r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
pa_xfree(s);
/* We completed the initial module loading, so let's disable it
* from now on, if requested */
c->disallow_module_loading = !!conf->disallow_module_loading;
if (r < 0 && conf->fail) {
pa_log(_("Failed to initialize daemon."));
goto finish;
}
if (!c->modules || pa_idxset_size(c->modules) == 0) {
pa_log(_("Daemon startup without any loaded modules, refusing to work."));
goto finish;
}
#ifdef HAVE_FORK
if (daemon_pipe[1] >= 0) {
int ok = 0;
pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
pa_close(daemon_pipe[1]);
daemon_pipe[1] = -1;
}
#endif
#ifdef HAVE_DBUS
dbus = register_dbus(c);
#endif
pa_log_info(_("Daemon startup complete."));
retval = 0;
if (pa_mainloop_run(mainloop, &retval) < 0)
goto finish;
pa_log_info(_("Daemon shutdown initiated."));
finish:
#ifdef HAVE_DBUS
if (dbus)
pa_dbus_connection_unref(dbus);
#endif
if (autospawn_fd >= 0) {
if (autospawn_locked)
pa_autospawn_lock_release();
pa_autospawn_lock_done(FALSE);
}
#ifdef OS_IS_WIN32
if (win32_timer)
pa_mainloop_get_api(mainloop)->time_free(win32_timer);
#endif
if (c) {
pa_core_unref(c);
pa_log_info(_("Daemon terminated."));
}
if (!conf->no_cpu_limit)
pa_cpu_limit_done();
pa_signal_done();
#ifdef HAVE_FORK
if (daemon_pipe[1] >= 0)
pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
pa_close_pipe(daemon_pipe);
#endif
if (mainloop)
pa_mainloop_free(mainloop);
if (conf)
pa_daemon_conf_free(conf);
if (valid_pid_file)
pa_pid_file_remove();
/* This has no real purpose except making things valgrind-clean */
pa_unset_env_recorded();
#ifdef OS_IS_WIN32
WSACleanup();
#endif
if (ltdl_init)
pa_ltdl_done();
#ifdef HAVE_DBUS
dbus_shutdown();
#endif
return retval;
}
