static void card_changed(struct userdata *u, struct udev_device *dev) {
struct device *d;
const char *path;
const char *t;
char *n;
pa_assert(u);
pa_assert(dev);
/* Maybe /dev/snd is now available? */
setup_inotify(u);
path = udev_device_get_devpath(dev);
if ((d = pa_hashmap_get(u->devices, path))) {
verify_access(u, d);
return;
}
d = pa_xnew0(struct device, 1);
d->path = pa_xstrdup(path);
d->module = PA_INVALID_INDEX;
PA_INIT_RATELIMIT(d->ratelimit, 10*PA_USEC_PER_SEC, 5);
if (!(t = udev_device_get_property_value(dev, "PULSE_NAME")))
if (!(t = udev_device_get_property_value(dev, "ID_ID")))
if (!(t = udev_device_get_property_value(dev, "ID_PATH")))
t = path_get_card_id(path);
n = pa_namereg_make_valid_name(t);
d->card_name = pa_sprintf_malloc("alsa_card.%s", n);
d->args = pa_sprintf_malloc("device_id=\"%s\" "
"name=\"%s\" "
"card_name=\"%s\" "
"namereg_fail=false "
"tsched=%s "
"fixed_latency_range=%s "
"ignore_dB=%s "
"deferred_volume=%s "
"use_ucm=1 "
"card_properties=\"module-udev-detect.discovered=1\"",
path_get_card_id(path),
n,
d->card_name,
pa_yes_no(u->use_tsched),
pa_yes_no(u->fixed_latency_range),
pa_yes_no(u->ignore_dB),
pa_yes_no(u->deferred_volume));
pa_xfree(n);
pa_hashmap_put(u->devices, d->path, d);
verify_access(u, d);
}
static void setup_context(pa_context *c, pa_iochannel *io) {
uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
pa_tagstruct *t;
uint32_t tag;
pa_assert(c);
pa_assert(io);
pa_context_ref(c);
pa_assert(!c->pstream);
c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
pa_pstream_set_receive_packet_callback(c->pstream, pstream_packet_callback, c);
pa_pstream_set_receive_memblock_callback(c->pstream, pstream_memblock_callback, c);
pa_assert(!c->pdispatch);
c->pdispatch = pa_pdispatch_new(c->mainloop, c->use_rtclock, command_table, PA_COMMAND_MAX);
if (pa_client_conf_load_cookie(c->conf, cookie, sizeof(cookie)) < 0)
pa_log_info("No cookie loaded. Attempting to connect without.");
t = pa_tagstruct_command(c, PA_COMMAND_AUTH, &tag);
c->do_shm =
pa_mempool_is_shared(c->mempool) &&
c->is_local;
pa_log_debug("SHM possible: %s", pa_yes_no(c->do_shm));
/* Starting with protocol version 13 we use the MSB of the version
* tag for informing the other side if we could do SHM or not.
* Starting from version 31, second MSB is used to flag memfd support. */
pa_tagstruct_putu32(t, PA_PROTOCOL_VERSION | (c->do_shm ? 0x80000000U : 0) |
(c->memfd_on_local ? 0x40000000 : 0));
pa_tagstruct_put_arbitrary(t, cookie, sizeof(cookie));
#ifdef HAVE_CREDS
{
pa_creds ucred;
if (pa_iochannel_creds_supported(io))
pa_iochannel_creds_enable(io);
ucred.uid = getuid();
ucred.gid = getgid();
pa_pstream_send_tagstruct_with_creds(c->pstream, t, &ucred);
}
#else
pa_pstream_send_tagstruct(c->pstream, t);
#endif
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
pa_context_set_state(c, PA_CONTEXT_AUTHORIZING);
pa_context_unref(c);
}
char *pa_scache_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u cache entrie(s) available.\n", c->scache ? pa_idxset_size(c->scache) : 0);
if (c->scache) {
pa_scache_entry *e;
uint32_t idx = PA_IDXSET_INVALID;
for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
double l = 0;
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a", cv[PA_CVOLUME_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX] = "n/a", *t;
const char *cmn;
cmn = pa_channel_map_to_pretty_name(&e->channel_map);
if (e->memchunk.memblock) {
pa_sample_spec_snprint(ss, sizeof(ss), &e->sample_spec);
pa_channel_map_snprint(cm, sizeof(cm), &e->channel_map);
l = (double) e->memchunk.length / (double) pa_bytes_per_second(&e->sample_spec);
}
pa_strbuf_printf(
s,
" name: <%s>\n"
"\tindex: %u\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tlength: %lu\n"
"\tduration: %0.1f s\n"
"\tvolume: %s\n"
"\t %s\n"
"\t balance %0.2f\n"
"\tlazy: %s\n"
"\tfilename: <%s>\n",
e->name,
e->index,
ss,
cm,
cmn ? "\n\t " : "",
cmn ? cmn : "",
(long unsigned)(e->memchunk.memblock ? e->memchunk.length : 0),
l,
e->volume_is_set ? pa_cvolume_snprint(cv, sizeof(cv), &e->volume) : "n/a",
e->volume_is_set ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &e->volume) : "n/a",
(e->memchunk.memblock && e->volume_is_set) ? pa_cvolume_get_balance(&e->volume, &e->channel_map) : 0.0f,
pa_yes_no(e->lazy),
e->filename ? e->filename : "n/a");
t = pa_proplist_to_string_sep(e->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
}
return pa_strbuf_tostring_free(s);
}
char *pa_module_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_module *m;
uint32_t idx = PA_IDXSET_INVALID;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u module(s) loaded.\n", pa_idxset_size(c->modules));
for (m = pa_idxset_first(c->modules, &idx); m; m = pa_idxset_next(c->modules, &idx)) {
char *t;
pa_strbuf_printf(s, " index: %u\n"
"\tname: <%s>\n"
"\targument: <%s>\n"
"\tused: %i\n"
"\tload once: %s\n",
m->index,
m->name,
pa_strempty(m->argument),
pa_module_get_n_used(m),
pa_yes_no(m->load_once));
t = pa_proplist_to_string_sep(m->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
return pa_strbuf_tostring_free(s);
}
/* This routine is called whenever the stream state changes */
static void stream_state_callback(pa_stream *s, void *userdata) {
pa_assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
if (verbose) {
const pa_buffer_attr *a;
char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_log(_("Stream successfully created."));
if (!(a = pa_stream_get_buffer_attr(s)))
pa_log(_("pa_stream_get_buffer_attr() failed: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
else {
if (mode == PLAYBACK)
pa_log(_("Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u"), a->maxlength, a->tlength, a->prebuf, a->minreq);
else {
pa_assert(mode == RECORD);
pa_log(_("Buffer metrics: maxlength=%u, fragsize=%u"), a->maxlength, a->fragsize);
}
}
pa_log(_("Using sample spec '%s', channel map '%s'."),
pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(s)),
pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(s)));
pa_log(_("Connected to device %s (index: %u, suspended: %s)."),
pa_stream_get_device_name(s),
pa_stream_get_device_index(s),
pa_yes_no(pa_stream_is_suspended(s)));
}
break;
case PA_STREAM_FAILED:
default:
pa_log(_("Stream error: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
quit(1);
}
}
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
bool restore_device = true, restore_volume = true;
pa_module *n;
char *t;
pa_assert(m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments");
goto fail;
}
if (pa_modargs_get_value_boolean(ma, "restore_device", &restore_device) < 0 ||
pa_modargs_get_value_boolean(ma, "restore_volume", &restore_volume) < 0) {
pa_log("restore_volume= and restore_device= expect boolean arguments");
goto fail;
}
pa_log_warn("We will now load module-stream-restore. Please make sure to remove module-volume-restore from your configuration.");
t = pa_sprintf_malloc("restore_volume=%s restore_device=%s", pa_yes_no(restore_volume), pa_yes_no(restore_device));
n = pa_module_load(m->core, "module-stream-restore", t);
pa_xfree(t);
if (n)
pa_module_unload_request(m, true);
pa_modargs_free(ma);
return n ? 0 : -1;
fail:
if (ma)
pa_modargs_free(ma);
return -1;
}
char *pa_daemon_conf_dump(pa_daemon_conf *c) {
static const char* const log_level_to_string[] = {
[PA_LOG_DEBUG] = "debug",
[PA_LOG_INFO] = "info",
[PA_LOG_NOTICE] = "notice",
[PA_LOG_WARN] = "warning",
[PA_LOG_ERROR] = "error"
};
#ifdef HAVE_DBUS
static const char* const server_type_to_string[] = {
[PA_SERVER_TYPE_UNSET] = "!!UNSET!!",
[PA_SERVER_TYPE_USER] = "user",
[PA_SERVER_TYPE_SYSTEM] = "system",
[PA_SERVER_TYPE_NONE] = "none"
};
#endif
pa_strbuf *s;
char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
char *log_target = NULL;
pa_assert(c);
s = pa_strbuf_new();
if (c->config_file)
pa_strbuf_printf(s, _("### Read from configuration file: %s ###\n"), c->config_file);
pa_assert(c->log_level < PA_LOG_LEVEL_MAX);
if (c->log_target)
log_target = pa_log_target_to_string(c->log_target);
pa_strbuf_printf(s, "daemonize = %s\n", pa_yes_no(c->daemonize));
pa_strbuf_printf(s, "fail = %s\n", pa_yes_no(c->fail));
pa_strbuf_printf(s, "high-priority = %s\n", pa_yes_no(c->high_priority));
pa_strbuf_printf(s, "nice-level = %i\n", c->nice_level);
pa_strbuf_printf(s, "realtime-scheduling = %s\n", pa_yes_no(c->realtime_scheduling));
pa_strbuf_printf(s, "realtime-priority = %i\n", c->realtime_priority);
pa_strbuf_printf(s, "allow-module-loading = %s\n", pa_yes_no(!c->disallow_module_loading));
pa_strbuf_printf(s, "allow-exit = %s\n", pa_yes_no(!c->disallow_exit));
pa_strbuf_printf(s, "use-pid-file = %s\n", pa_yes_no(c->use_pid_file));
pa_strbuf_printf(s, "system-instance = %s\n", pa_yes_no(c->system_instance));
#ifdef HAVE_DBUS
pa_strbuf_printf(s, "local-server-type = %s\n", server_type_to_string[c->local_server_type]);
#endif
pa_strbuf_printf(s, "cpu-limit = %s\n", pa_yes_no(!c->no_cpu_limit));
pa_strbuf_printf(s, "enable-shm = %s\n", pa_yes_no(!c->disable_shm));
pa_strbuf_printf(s, "flat-volumes = %s\n", pa_yes_no(c->flat_volumes));
pa_strbuf_printf(s, "lock-memory = %s\n", pa_yes_no(c->lock_memory));
pa_strbuf_printf(s, "exit-idle-time = %i\n", c->exit_idle_time);
pa_strbuf_printf(s, "scache-idle-time = %i\n", c->scache_idle_time);
pa_strbuf_printf(s, "dl-search-path = %s\n", pa_strempty(c->dl_search_path));
pa_strbuf_printf(s, "default-script-file = %s\n", pa_strempty(pa_daemon_conf_get_default_script_file(c)));
pa_strbuf_printf(s, "load-default-script-file = %s\n", pa_yes_no(c->load_default_script_file));
pa_strbuf_printf(s, "log-target = %s\n", pa_strempty(log_target));
pa_strbuf_printf(s, "log-level = %s\n", log_level_to_string[c->log_level]);
pa_strbuf_printf(s, "resample-method = %s\n", pa_resample_method_to_string(c->resample_method));
pa_strbuf_printf(s, "avoid-resampling = %s\n", pa_yes_no(!c->avoid_resampling));
pa_strbuf_printf(s, "enable-remixing = %s\n", pa_yes_no(!c->disable_remixing));
pa_strbuf_printf(s, "remixing-use-all-sink-channels = %s\n", pa_yes_no(c->remixing_use_all_sink_channels));
pa_strbuf_printf(s, "enable-lfe-remixing = %s\n", pa_yes_no(!c->disable_lfe_remixing));
pa_strbuf_printf(s, "lfe-crossover-freq = %u\n", c->lfe_crossover_freq);
pa_strbuf_printf(s, "default-sample-format = %s\n", pa_sample_format_to_string(c->default_sample_spec.format));
pa_strbuf_printf(s, "default-sample-rate = %u\n", c->default_sample_spec.rate);
pa_strbuf_printf(s, "alternate-sample-rate = %u\n", c->alternate_sample_rate);
pa_strbuf_printf(s, "default-sample-channels = %u\n", c->default_sample_spec.channels);
pa_strbuf_printf(s, "default-channel-map = %s\n", pa_channel_map_snprint(cm, sizeof(cm), &c->default_channel_map));
pa_strbuf_printf(s, "default-fragments = %u\n", c->default_n_fragments);
pa_strbuf_printf(s, "default-fragment-size-msec = %u\n", c->default_fragment_size_msec);
pa_strbuf_printf(s, "enable-deferred-volume = %s\n", pa_yes_no(c->deferred_volume));
pa_strbuf_printf(s, "deferred-volume-safety-margin-usec = %u\n", c->deferred_volume_safety_margin_usec);
pa_strbuf_printf(s, "deferred-volume-extra-delay-usec = %d\n", c->deferred_volume_extra_delay_usec);
pa_strbuf_printf(s, "shm-size-bytes = %lu\n", (unsigned long) c->shm_size);
pa_strbuf_printf(s, "log-meta = %s\n", pa_yes_no(c->log_meta));
pa_strbuf_printf(s, "log-time = %s\n", pa_yes_no(c->log_time));
pa_strbuf_printf(s, "log-backtrace = %u\n", c->log_backtrace);
#ifdef HAVE_SYS_RESOURCE_H
pa_strbuf_printf(s, "rlimit-fsize = %li\n", c->rlimit_fsize.is_set ? (long int) c->rlimit_fsize.value : -1);
pa_strbuf_printf(s, "rlimit-data = %li\n", c->rlimit_data.is_set ? (long int) c->rlimit_data.value : -1);
pa_strbuf_printf(s, "rlimit-stack = %li\n", c->rlimit_stack.is_set ? (long int) c->rlimit_stack.value : -1);
pa_strbuf_printf(s, "rlimit-core = %li\n", c->rlimit_core.is_set ? (long int) c->rlimit_core.value : -1);
#ifdef RLIMIT_RSS
pa_strbuf_printf(s, "rlimit-rss = %li\n", c->rlimit_rss.is_set ? (long int) c->rlimit_rss.value : -1);
#endif
#ifdef RLIMIT_AS
pa_strbuf_printf(s, "rlimit-as = %li\n", c->rlimit_as.is_set ? (long int) c->rlimit_as.value : -1);
#endif
#ifdef RLIMIT_NPROC
pa_strbuf_printf(s, "rlimit-nproc = %li\n", c->rlimit_nproc.is_set ? (long int) c->rlimit_nproc.value : -1);
#endif
#ifdef RLIMIT_NOFILE
pa_strbuf_printf(s, "rlimit-nofile = %li\n", c->rlimit_nofile.is_set ? (long int) c->rlimit_nofile.value : -1);
#endif
#ifdef RLIMIT_MEMLOCK
pa_strbuf_printf(s, "rlimit-memlock = %li\n", c->rlimit_memlock.is_set ? (long int) c->rlimit_memlock.value : -1);
#endif
#ifdef RLIMIT_LOCKS
pa_strbuf_printf(s, "rlimit-locks = %li\n", c->rlimit_locks.is_set ? (long int) c->rlimit_locks.value : -1);
#endif
#ifdef RLIMIT_SIGPENDING
pa_strbuf_printf(s, "rlimit-sigpending = %li\n", c->rlimit_sigpending.is_set ? (long int) c->rlimit_sigpending.value : -1);
#endif
#ifdef RLIMIT_MSGQUEUE
pa_strbuf_printf(s, "rlimit-msgqueue = %li\n", c->rlimit_msgqueue.is_set ? (long int) c->rlimit_msgqueue.value : -1);
#endif
#ifdef RLIMIT_NICE
pa_strbuf_printf(s, "rlimit-nice = %li\n", c->rlimit_nice.is_set ? (long int) c->rlimit_nice.value : -1);
#endif
#ifdef RLIMIT_RTPRIO
pa_strbuf_printf(s, "rlimit-rtprio = %li\n", c->rlimit_rtprio.is_set ? (long int) c->rlimit_rtprio.value : -1);
#endif
#ifdef RLIMIT_RTTIME
pa_strbuf_printf(s, "rlimit-rttime = %li\n", c->rlimit_rttime.is_set ? (long int) c->rlimit_rttime.value : -1);
#endif
#endif
pa_xfree(log_target);
return pa_strbuf_to_string_free(s);
}
static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *source_ss, uint32_t nframes, pa_modargs *ma) {
pa_bool_t agc;
pa_bool_t denoise;
pa_bool_t echo_suppress;
int32_t echo_suppress_attenuation;
int32_t echo_suppress_attenuation_active;
agc = DEFAULT_AGC_ENABLED;
if (pa_modargs_get_value_boolean(ma, "agc", &agc) < 0) {
pa_log("Failed to parse agc value");
goto fail;
}
denoise = DEFAULT_DENOISE_ENABLED;
if (pa_modargs_get_value_boolean(ma, "denoise", &denoise) < 0) {
pa_log("Failed to parse denoise value");
goto fail;
}
echo_suppress = DEFAULT_ECHO_SUPPRESS_ENABLED;
if (pa_modargs_get_value_boolean(ma, "echo_suppress", &echo_suppress) < 0) {
pa_log("Failed to parse echo_suppress value");
goto fail;
}
echo_suppress_attenuation = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation", &echo_suppress_attenuation) < 0) {
pa_log("Failed to parse echo_suppress_attenuation value");
goto fail;
}
if (echo_suppress_attenuation > 0) {
pa_log("echo_suppress_attenuation should be a negative dB value");
goto fail;
}
echo_suppress_attenuation_active = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation_active", &echo_suppress_attenuation_active) < 0) {
pa_log("Failed to parse echo_suppress_attenuation_active value");
goto fail;
}
if (echo_suppress_attenuation_active > 0) {
pa_log("echo_suppress_attenuation_active should be a negative dB value");
goto fail;
}
if (agc || denoise || echo_suppress) {
spx_int32_t tmp;
if (source_ss->channels != 1) {
pa_log("AGC, denoising and echo suppression only work with channels=1");
goto fail;
}
ec->params.priv.speex.pp_state = speex_preprocess_state_init(nframes, source_ss->rate);
tmp = agc;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_AGC, &tmp);
tmp = denoise;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
if (echo_suppress) {
if (echo_suppress_attenuation)
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS,
&echo_suppress_attenuation);
if (echo_suppress_attenuation_active) {
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE,
&echo_suppress_attenuation_active);
}
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_STATE,
ec->params.priv.speex.state);
}
pa_log_info("Loaded speex preprocessor with params: agc=%s, denoise=%s, echo_suppress=%s", pa_yes_no(agc),
pa_yes_no(denoise), pa_yes_no(echo_suppress));
} else
pa_log_info("All preprocessing options are disabled");
return TRUE;
fail:
return FALSE;
}
static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_context *c = userdata;
pa_assert(pd);
pa_assert(c);
pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
pa_context_ref(c);
if (command != PA_COMMAND_REPLY) {
pa_context_handle_error(c, command, t, TRUE);
goto finish;
}
switch(c->state) {
case PA_CONTEXT_AUTHORIZING: {
pa_tagstruct *reply;
pa_bool_t shm_on_remote = FALSE;
if (pa_tagstruct_getu32(t, &c->version) < 0 ||
!pa_tagstruct_eof(t)) {
pa_context_fail(c, PA_ERR_PROTOCOL);
goto finish;
}
/* Minimum supported version */
if (c->version < 8) {
pa_context_fail(c, PA_ERR_VERSION);
goto finish;
}
/* Starting with protocol version 13 the MSB of the version
tag reflects if shm is available for this connection or
not. */
if (c->version >= 13) {
shm_on_remote = !!(c->version & 0x80000000U);
c->version &= 0x7FFFFFFFU;
}
pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
/* Enable shared memory support if possible */
if (c->do_shm)
if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
c->do_shm = FALSE;
if (c->do_shm) {
/* Only enable SHM if both sides are owned by the same
* user. This is a security measure because otherwise
* data private to the user might leak. */
#ifdef HAVE_CREDS
const pa_creds *creds;
if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
c->do_shm = FALSE;
#endif
}
pa_log_debug("Negotiated SHM: %s", pa_yes_no(c->do_shm));
pa_pstream_enable_shm(c->pstream, c->do_shm);
reply = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
if (c->version >= 13) {
pa_init_proplist(c->proplist);
pa_tagstruct_put_proplist(reply, c->proplist);
} else
pa_tagstruct_puts(reply, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
pa_pstream_send_tagstruct(c->pstream, reply);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
break;
}
case PA_CONTEXT_SETTING_NAME :
if ((c->version >= 13 && (pa_tagstruct_getu32(t, &c->client_index) < 0 ||
c->client_index == PA_INVALID_INDEX)) ||
!pa_tagstruct_eof(t)) {
pa_context_fail(c, PA_ERR_PROTOCOL);
goto finish;
}
pa_context_set_state(c, PA_CONTEXT_READY);
break;
default:
pa_assert_not_reached();
}
finish:
pa_context_unref(c);
}
static void verify_access(struct userdata *u, struct device *d) {
char *cd;
pa_card *card;
bool accessible;
pa_assert(u);
pa_assert(d);
cd = pa_sprintf_malloc("/dev/snd/controlC%s", path_get_card_id(d->path));
accessible = access(cd, R_OK|W_OK) >= 0;
pa_log_debug("%s is accessible: %s", cd, pa_yes_no(accessible));
pa_xfree(cd);
if (d->module == PA_INVALID_INDEX) {
/* If we are not loaded, try to load */
if (accessible) {
pa_module *m;
bool busy;
/* Check if any of the PCM devices that belong to this
* card are currently busy. If they are, don't try to load
* right now, to make sure the probing phase can
* successfully complete. When the current user of the
* device closes it we will get another notification via
* inotify and can then recheck. */
busy = is_card_busy(path_get_card_id(d->path));
pa_log_debug("%s is busy: %s", d->path, pa_yes_no(busy));
if (!busy) {
/* So, why do we rate limit here? It's certainly ugly,
* but there seems to be no other way. Problem is
* this: if we are unable to configure/probe an audio
* device after opening it we will close it again and
* the module initialization will fail. This will then
* cause an inotify event on the device node which
* will be forwarded to us. We then try to reopen the
* audio device again, practically entering a busy
* loop.
*
* A clean fix would be if we would be able to ignore
* our own inotify close events. However, inotify
* lacks such functionality. Also, during probing of
* the device we cannot really distinguish between
* other processes causing EBUSY or ourselves, which
* means we have no way to figure out if the probing
* during opening was canceled by a "try again"
* failure or a "fatal" failure. */
if (pa_ratelimit_test(&d->ratelimit, PA_LOG_DEBUG)) {
pa_log_debug("Loading module-alsa-card with arguments '%s'", d->args);
m = pa_module_load(u->core, "module-alsa-card", d->args);
if (m) {
d->module = m->index;
pa_log_info("Card %s (%s) module loaded.", d->path, d->card_name);
} else
pa_log_info("Card %s (%s) failed to load module.", d->path, d->card_name);
} else
pa_log_warn("Tried to configure %s (%s) more often than %u times in %llus",
d->path,
d->card_name,
d->ratelimit.burst,
(long long unsigned) (d->ratelimit.interval / PA_USEC_PER_SEC));
}
}
} else {
/* If we are already loaded update suspend status with
* accessible boolean */
if ((card = pa_namereg_get(u->core, d->card_name, PA_NAMEREG_CARD))) {
pa_log_debug("%s all sinks and sources of card %s.", accessible ? "Resuming" : "Suspending", d->card_name);
pa_card_suspend(card, !accessible, PA_SUSPEND_SESSION);
}
}
}
static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_context *c = userdata;
pa_assert(pd);
pa_assert(c);
pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
pa_context_ref(c);
if (command != PA_COMMAND_REPLY) {
pa_context_handle_error(c, command, t, true);
goto finish;
}
switch(c->state) {
case PA_CONTEXT_AUTHORIZING: {
pa_tagstruct *reply;
bool shm_on_remote = false;
bool memfd_on_remote = false;
if (pa_tagstruct_getu32(t, &c->version) < 0 ||
!pa_tagstruct_eof(t)) {
pa_context_fail(c, PA_ERR_PROTOCOL);
goto finish;
}
/* Minimum supported version */
if (c->version < 8) {
pa_context_fail(c, PA_ERR_VERSION);
goto finish;
}
/* Starting with protocol version 13 the MSB of the version
tag reflects if shm is available for this connection or
not. */
if (c->version >= 13) {
shm_on_remote = !!(c->version & 0x80000000U);
/* Starting with protocol version 31, the second MSB of the version
* tag reflects whether memfd is supported on the other PA end. */
if (c->version >= 31)
memfd_on_remote = !!(c->version & 0x40000000U);
/* Reserve the two most-significant _bytes_ of the version tag
* for flags. */
c->version &= 0x0000FFFFU;
}
pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
/* Enable shared memory support if possible */
if (c->do_shm)
if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
c->do_shm = false;
if (c->do_shm) {
/* Only enable SHM if both sides are owned by the same
* user. This is a security measure because otherwise
* data private to the user might leak. */
#ifdef HAVE_CREDS
const pa_creds *creds;
if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
c->do_shm = false;
#endif
}
pa_log_debug("Negotiated SHM: %s", pa_yes_no(c->do_shm));
pa_pstream_enable_shm(c->pstream, c->do_shm);
c->shm_type = PA_MEM_TYPE_PRIVATE;
if (c->do_shm) {
if (c->version >= 31 && memfd_on_remote && c->memfd_on_local) {
const char *reason;
pa_pstream_enable_memfd(c->pstream);
if (pa_mempool_is_memfd_backed(c->mempool))
if (pa_pstream_register_memfd_mempool(c->pstream, c->mempool, &reason))
pa_log("Failed to regester memfd mempool. Reason: %s", reason);
/* Even if memfd pool registration fails, the negotiated SHM type
* shall remain memfd as both endpoints claim to support it. */
c->shm_type = PA_MEM_TYPE_SHARED_MEMFD;
} else
c->shm_type = PA_MEM_TYPE_SHARED_POSIX;
}
pa_log_debug("Memfd possible: %s", pa_yes_no(c->memfd_on_local));
pa_log_debug("Negotiated SHM type: %s", pa_mem_type_to_string(c->shm_type));
reply = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
if (c->version >= 13) {
pa_init_proplist(c->proplist);
pa_tagstruct_put_proplist(reply, c->proplist);
} else
pa_tagstruct_puts(reply, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
pa_pstream_send_tagstruct(c->pstream, reply);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
break;
}
case PA_CONTEXT_SETTING_NAME :
if ((c->version >= 13 && (pa_tagstruct_getu32(t, &c->client_index) < 0 ||
c->client_index == PA_INVALID_INDEX)) ||
!pa_tagstruct_eof(t)) {
pa_context_fail(c, PA_ERR_PROTOCOL);
goto finish;
}
pa_context_set_state(c, PA_CONTEXT_READY);
break;
default:
pa_assert_not_reached();
}
finish:
pa_context_unref(c);
}
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;
char *configured_address;
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 };
int daemon_pipe2[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_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
pa_bool_t start_server;
#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);
#ifdef HAVE_DBUS
/* conf->system_instance and conf->local_server_type control almost the
* same thing; make them agree about what is requested. */
switch (conf->local_server_type) {
case PA_SERVER_TYPE_UNSET:
conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
break;
case PA_SERVER_TYPE_USER:
case PA_SERVER_TYPE_NONE:
conf->system_instance = FALSE;
break;
case PA_SERVER_TYPE_SYSTEM:
conf->system_instance = TRUE;
break;
default:
pa_assert_not_reached();
}
start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
conf->system_instance = FALSE;
}
#endif
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;
}
#ifdef HAVE_GETUID
if (getuid() == 0 && !conf->system_instance)
pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
#ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
else if (getuid() != 0 && conf->system_instance) {
pa_log(_("Root privileges required."));
goto finish;
}
#endif
#endif /* HAVE_GETUID */
if (conf->cmd == PA_CMD_START && conf->system_instance) {
pa_log(_("--start not supported for system instances."));
goto finish;
}
if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
/* There is an server address in our config, but where did it come from?
* By default a standard X11 login will load module-x11-publish which will
* inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
* up hitting this code path. So we have to check to see if our configured_address
* is the same as the value that would go into this property so that we can
* recover (i.e. autospawn) from a crash.
*/
char *ufn;
pa_bool_t start_anyway = FALSE;
if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
char *id;
if ((id = pa_machine_id())) {
pa_strlist *server_list;
char formatted_ufn[256];
pa_snprintf(formatted_ufn, sizeof(formatted_ufn), "{%s}unix:%s", id, ufn);
pa_xfree(id);
if ((server_list = pa_strlist_parse(configured_address))) {
char *u = NULL;
/* We only need to check the first server */
server_list = pa_strlist_pop(server_list, &u);
pa_strlist_free(server_list);
start_anyway = (u && pa_streq(formatted_ufn, u));
pa_xfree(u);
}
}
pa_xfree(ufn);
}
if (!start_anyway) {
pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address);
pa_xfree(configured_address);
retval = 0;
goto finish;
}
pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address);
pa_xfree(configured_address);
}
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) {
#ifdef HAVE_FORK
pid_t child;
#endif
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));
pa_close_pipe(daemon_pipe);
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
if (setsid() < 0) {
pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
goto finish;
}
#endif
#ifdef HAVE_FORK
/* We now are a session and process group leader. Let's fork
* again and let the father die, so that we'll become a
* process that can never acquire a TTY again, in a session and
* process group without leader */
if (pipe(daemon_pipe2) < 0) {
pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
goto finish;
}
if ((child = fork()) < 0) {
pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
pa_close_pipe(daemon_pipe2);
goto finish;
}
if (child != 0) {
ssize_t n;
/* Father */
pa_assert_se(pa_close(daemon_pipe2[1]) == 0);
daemon_pipe2[1] = -1;
if ((n = pa_loop_read(daemon_pipe2[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
if (n < 0)
pa_log(_("read() failed: %s"), pa_cstrerror(errno));
retval = 1;
}
/* We now have to take care of signalling the first fork with
* the return value we've received from this fork... */
pa_assert(daemon_pipe[1] >= 0);
pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
pa_close(daemon_pipe[1]);
daemon_pipe[1] = -1;
goto finish;
}
pa_assert_se(pa_close(daemon_pipe2[0]) == 0);
daemon_pipe2[0] = -1;
/* We no longer need the (first) daemon_pipe as it's handled in our child above */
pa_close_pipe(daemon_pipe);
#endif
#ifdef SIGTTOU
signal(SIGTTOU, SIG_IGN);
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN);
#endif
pa_nullify_stdfds();
}
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("Successfully locked process into memory.");
#else
pa_log_warn("Memory locking requested but not supported on platform.");
#endif
}
pa_memtrap_install();
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->alternate_sample_rate = conf->alternate_sample_rate;
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->deferred_volume_safety_margin_usec = conf->deferred_volume_safety_margin_usec;
c->deferred_volume_extra_delay_usec = conf->deferred_volume_extra_delay_usec;
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->deferred_volume = !!conf->deferred_volume;
c->running_as_daemon = !!conf->daemonize;
c->disallow_exit = conf->disallow_exit;
c->flat_volumes = conf->flat_volumes;
#ifdef HAVE_DBUS
c->server_type = conf->local_server_type;
#endif
c->cpu_info.cpu_type = PA_CPU_UNDEFINED;
if (!getenv("PULSE_NO_SIMD")) {
if (pa_cpu_init_x86(&(c->cpu_info.flags.x86)))
c->cpu_info.cpu_type = PA_CPU_X86;
if (pa_cpu_init_arm(&(c->cpu_info.flags.arm)))
c->cpu_info.cpu_type = PA_CPU_ARM;
pa_cpu_init_orc(c->cpu_info);
}
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)->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();
#ifdef HAVE_DBUS
pa_assert_se(dbus_threads_init_default());
if (start_server) {
#endif
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);
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_DBUS
} else {
/* When we just provide the D-Bus server lookup service, we don't want
* any modules to be loaded. We haven't loaded any so far, so one might
* think there's no way to contact the server, but receiving certain
* signals could still cause modules to load. */
conf->disallow_module_loading = TRUE;
}
#endif
/* We completed the initial module loading, so let's disable it
* from now on, if requested */
c->disallow_module_loading = !!conf->disallow_module_loading;
#ifdef HAVE_DBUS
if (!conf->system_instance) {
if ((server_lookup = pa_dbusobj_server_lookup_new(c))) {
if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
goto finish;
}
}
if (start_server)
server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server");
#endif
#ifdef HAVE_FORK
if (daemon_pipe2[1] >= 0) {
int ok = 0;
pa_loop_write(daemon_pipe2[1], &ok, sizeof(ok), NULL);
pa_close(daemon_pipe2[1]);
daemon_pipe2[1] = -1;
}
#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 (server_bus)
pa_dbus_connection_unref(server_bus);
if (lookup_service_bus)
pa_dbus_connection_unref(lookup_service_bus);
if (server_lookup)
pa_dbusobj_server_lookup_free(server_lookup);
#endif
if (autospawn_fd >= 0) {
if (autospawn_locked)
pa_autospawn_lock_release();
pa_autospawn_lock_done(FALSE);
}
#ifdef OS_IS_WIN32
if (mainloop && win32_timer)
pa_mainloop_get_api(mainloop)->time_free(win32_timer);
#endif
if (c) {
/* Ensure all the modules/samples are unloaded when the core is still ref'ed,
* as unlink callback hooks in modules may need the core to be ref'ed */
pa_module_unload_all(c);
pa_scache_free_all(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 we have daemon_pipe[1] still open, this means we've failed after
* the first fork, but before the second. Therefore just write to it. */
if (daemon_pipe[1] >= 0)
pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
else if (daemon_pipe2[1] >= 0)
pa_loop_write(daemon_pipe2[1], &retval, sizeof(retval), NULL);
pa_close_pipe(daemon_pipe2);
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;
}
char *pa_sink_input_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_sink_input *i;
uint32_t idx = PA_IDXSET_INVALID;
static const char* const state_table[] = {
[PA_SINK_INPUT_INIT] = "INIT",
[PA_SINK_INPUT_RUNNING] = "RUNNING",
[PA_SINK_INPUT_DRAINED] = "DRAINED",
[PA_SINK_INPUT_CORKED] = "CORKED",
[PA_SINK_INPUT_UNLINKED] = "UNLINKED"
};
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u sink input(s) available.\n", pa_idxset_size(c->sink_inputs));
for (i = pa_idxset_first(c->sink_inputs, &idx); i; i = pa_idxset_next(c->sink_inputs, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX], *t, clt[28];
pa_usec_t cl;
const char *cmn;
pa_cvolume v;
char *volume_str = NULL;
cmn = pa_channel_map_to_pretty_name(&i->channel_map);
if ((cl = pa_sink_input_get_requested_latency(i)) == (pa_usec_t) -1)
pa_snprintf(clt, sizeof(clt), "n/a");
else
pa_snprintf(clt, sizeof(clt), "%0.2f ms", (double) cl / PA_USEC_PER_MSEC);
pa_assert(i->sink);
if (pa_sink_input_is_volume_readable(i)) {
pa_sink_input_get_volume(i, &v, TRUE);
volume_str = pa_sprintf_malloc("%s\n\t %s\n\t balance %0.2f",
pa_cvolume_snprint(cv, sizeof(cv), &v),
pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &v),
pa_cvolume_get_balance(&v, &i->channel_map));
} else
volume_str = pa_xstrdup("n/a");
pa_strbuf_printf(
s,
" index: %u\n"
"\tdriver: <%s>\n"
"\tflags: %s%s%s%s%s%s%s%s%s%s%s\n"
"\tstate: %s\n"
"\tsink: %u <%s>\n"
"\tvolume: %s\n"
"\tmuted: %s\n"
"\tcurrent latency: %0.2f ms\n"
"\trequested latency: %s\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tresample method: %s\n",
i->index,
i->driver,
i->flags & PA_SINK_INPUT_VARIABLE_RATE ? "VARIABLE_RATE " : "",
i->flags & PA_SINK_INPUT_DONT_MOVE ? "DONT_MOVE " : "",
i->flags & PA_SINK_INPUT_START_CORKED ? "START_CORKED " : "",
i->flags & PA_SINK_INPUT_NO_REMAP ? "NO_REMAP " : "",
i->flags & PA_SINK_INPUT_NO_REMIX ? "NO_REMIX " : "",
i->flags & PA_SINK_INPUT_FIX_FORMAT ? "FIX_FORMAT " : "",
i->flags & PA_SINK_INPUT_FIX_RATE ? "FIX_RATE " : "",
i->flags & PA_SINK_INPUT_FIX_CHANNELS ? "FIX_CHANNELS " : "",
i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND ? "DONT_INHIBIT_AUTO_SUSPEND " : "",
i->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND ? "NO_CREATE_SUSPEND " : "",
i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND ? "KILL_ON_SUSPEND " : "",
state_table[pa_sink_input_get_state(i)],
i->sink->index, i->sink->name,
volume_str,
pa_yes_no(pa_sink_input_get_mute(i)),
(double) pa_sink_input_get_latency(i, NULL) / PA_USEC_PER_MSEC,
clt,
pa_sample_spec_snprint(ss, sizeof(ss), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
cmn ? "\n\t " : "",
cmn ? cmn : "",
pa_resample_method_to_string(pa_sink_input_get_resample_method(i)));
pa_xfree(volume_str);
if (i->module)
pa_strbuf_printf(s, "\tmodule: %u\n", i->module->index);
if (i->client)
pa_strbuf_printf(s, "\tclient: %u <%s>\n", i->client->index, pa_strnull(pa_proplist_gets(i->client->proplist, PA_PROP_APPLICATION_NAME)));
t = pa_proplist_to_string_sep(i->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
return pa_strbuf_tostring_free(s);
}
char *pa_source_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_source *source;
uint32_t idx = PA_IDXSET_INVALID;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u source(s) available.\n", pa_idxset_size(c->sources));
for (source = pa_idxset_first(c->sources, &idx); source; source = pa_idxset_next(c->sources, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX],
cv[PA_CVOLUME_SNPRINT_MAX],
cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX],
v[PA_VOLUME_SNPRINT_MAX],
vdb[PA_SW_VOLUME_SNPRINT_DB_MAX],
cm[PA_CHANNEL_MAP_SNPRINT_MAX], *t;
const char *cmn;
cmn = pa_channel_map_to_pretty_name(&source->channel_map);
pa_strbuf_printf(
s,
" %c index: %u\n"
"\tname: <%s>\n"
"\tdriver: <%s>\n"
"\tflags: %s%s%s%s%s%s%s\n"
"\tstate: %s\n"
"\tsuspend cause: %s%s%s%s\n"
"\tpriority: %u\n"
"\tvolume: %s%s%s\n"
"\t balance %0.2f\n"
"\tbase volume: %s%s%s\n"
"\tvolume steps: %u\n"
"\tmuted: %s\n"
"\tcurrent latency: %0.2f ms\n"
"\tmax rewind: %lu KiB\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tused by: %u\n"
"\tlinked by: %u\n",
c->default_source == source ? '*' : ' ',
source->index,
source->name,
source->driver,
source->flags & PA_SOURCE_HARDWARE ? "HARDWARE " : "",
source->flags & PA_SOURCE_NETWORK ? "NETWORK " : "",
source->flags & PA_SOURCE_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
source->flags & PA_SOURCE_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
source->flags & PA_SOURCE_LATENCY ? "LATENCY " : "",
source->flags & PA_SOURCE_DYNAMIC_LATENCY ? "DYNAMIC_LATENCY" : "",
source_state_to_string(pa_source_get_state(source)),
source->suspend_cause & PA_SUSPEND_USER ? "USER " : "",
source->suspend_cause & PA_SUSPEND_APPLICATION ? "APPLICATION " : "",
source->suspend_cause & PA_SUSPEND_IDLE ? "IDLE " : "",
source->suspend_cause & PA_SUSPEND_SESSION ? "SESSION" : "",
source->priority,
pa_cvolume_snprint(cv, sizeof(cv), pa_source_get_volume(source, FALSE)),
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), pa_source_get_volume(source, FALSE)) : "",
pa_cvolume_get_balance(pa_source_get_volume(source, FALSE), &source->channel_map),
pa_volume_snprint(v, sizeof(v), source->base_volume),
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), source->base_volume) : "",
source->n_volume_steps,
pa_yes_no(pa_source_get_mute(source, FALSE)),
(double) pa_source_get_latency(source) / PA_USEC_PER_MSEC,
(unsigned long) pa_source_get_max_rewind(source) / 1024,
pa_sample_spec_snprint(ss, sizeof(ss), &source->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &source->channel_map),
cmn ? "\n\t " : "",
cmn ? cmn : "",
pa_source_used_by(source),
pa_source_linked_by(source));
if (source->flags & PA_SOURCE_DYNAMIC_LATENCY) {
pa_usec_t min_latency, max_latency;
pa_source_get_latency_range(source, &min_latency, &max_latency);
pa_strbuf_printf(
s,
"\tconfigured latency: %0.2f ms; range is %0.2f .. %0.2f ms\n",
(double) pa_source_get_requested_latency(source) / PA_USEC_PER_MSEC,
(double) min_latency / PA_USEC_PER_MSEC,
(double) max_latency / PA_USEC_PER_MSEC);
} else
pa_strbuf_printf(
s,
"\tfixed latency: %0.2f ms\n",
(double) pa_source_get_fixed_latency(source) / PA_USEC_PER_MSEC);
if (source->monitor_of)
pa_strbuf_printf(s, "\tmonitor_of: %u\n", source->monitor_of->index);
if (source->card)
pa_strbuf_printf(s, "\tcard: %u <%s>\n", source->card->index, source->card->name);
if (source->module)
pa_strbuf_printf(s, "\tmodule: %u\n", source->module->index);
t = pa_proplist_to_string_sep(source->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
append_port_list(s, source->ports);
if (source->active_port)
pa_strbuf_printf(
s,
"\tactive port: <%s>\n",
source->active_port->name);
}
return pa_strbuf_tostring_free(s);
}
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;
}