pa_bluetooth_backend *pa_bluetooth_native_backend_new(pa_core *c, pa_bluetooth_discovery *y, bool enable_hs_role) {
pa_bluetooth_backend *backend;
DBusError err;
pa_log_debug("Bluetooth Headset Backend API support using the native backend");
backend = pa_xnew0(pa_bluetooth_backend, 1);
backend->core = c;
dbus_error_init(&err);
if (!(backend->connection = pa_dbus_bus_get(c, DBUS_BUS_SYSTEM, &err))) {
pa_log("Failed to get D-Bus connection: %s", err.message);
dbus_error_free(&err);
pa_xfree(backend);
return NULL;
}
backend->discovery = y;
backend->enable_hs_role = enable_hs_role;
if (enable_hs_role)
profile_init(backend, PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY);
profile_init(backend, PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT);
return backend;
}
static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
DBusError error;
pa_dbus_connection *conn;
dbus_error_init(&error);
if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
goto fail;
}
if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
pa_log_debug("Got %s!", name);
return conn;
}
if (dbus_error_is_set(&error))
pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
else
pa_log_error("D-Bus name %s already taken.", name);
/* PA cannot be started twice by the same user and hence we can
* ignore mostly the case that a name is already taken. */
fail:
if (conn)
pa_dbus_connection_unref(conn);
dbus_error_free(&error);
return NULL;
}
pa_dbusobj_server_lookup *pa_dbusobj_server_lookup_new(pa_core *c) {
pa_dbusobj_server_lookup *sl;
DBusError error;
dbus_error_init(&error);
sl = pa_xnew(pa_dbusobj_server_lookup, 1);
sl->core = c;
sl->path_registered = false;
if (!(sl->conn = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
goto fail;
}
if (!dbus_connection_register_object_path(pa_dbus_connection_get(sl->conn), OBJECT_PATH, &vtable, sl)) {
pa_log("dbus_connection_register_object_path() failed for " OBJECT_PATH ".");
goto fail;
}
sl->path_registered = true;
return sl;
fail:
dbus_error_free(&error);
pa_dbusobj_server_lookup_free(sl);
return NULL;
}
static pa_dbus_connection *register_dbus(pa_core *c) {
DBusError error;
pa_dbus_connection *conn;
dbus_error_init(&error);
if (!(conn = pa_dbus_bus_get(c, pa_in_system_mode() ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
goto fail;
}
if (dbus_bus_request_name(pa_dbus_connection_get(conn), "org.pulseaudio.Server", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
pa_log_debug("Got org.pulseaudio.Server!");
return conn;
}
if (dbus_error_is_set(&error))
pa_log_warn("Failed to acquire org.pulseaudio.Server: %s: %s", error.name, error.message);
else
pa_log_warn("D-Bus name org.pulseaudio.Server already taken. Weird shit!");
/* PA cannot be started twice by the same user and hence we can
* ignore mostly the case that org.pulseaudio.Server is already
* taken. */
fail:
if (conn)
pa_dbus_connection_unref(conn);
dbus_error_free(&error);
return NULL;
}
int cmtspeech_dbus_init(struct userdata *u, const char *dbus_type)
{
struct cmtspeech_dbus_conn *e = &u->dbus_conn;
DBusConnection *dbusconn;
DBusError error;
char rule[512];
if (0 == strcasecmp(dbus_type, "system"))
e->dbus_type = DBUS_BUS_SYSTEM;
else
e->dbus_type = DBUS_BUS_SESSION;
#define STRBUSTYPE(DBusType) ((DBusType) == DBUS_BUS_SYSTEM ? "system" : "session")
pa_log_info("DBus connection to %s bus.", STRBUSTYPE(e->dbus_type));
dbus_error_init(&error);
e->dbus_conn = pa_dbus_bus_get(u->core, e->dbus_type, &error);
if (e->dbus_conn == NULL || dbus_error_is_set(&error)) {
pa_log_error("Failed to get %s Bus: %s: %s", STRBUSTYPE(e->dbus_type), error.name, error.message);
goto fail;
}
memset(&e->dbus_match_rules, 0, sizeof(e->dbus_match_rules));
dbusconn = pa_dbus_connection_get(e->dbus_conn);
if (!dbus_connection_add_filter(dbusconn, cmtspeech_dbus_filter, u, NULL)) {
pa_log("failed to add filter function");
goto fail;
}
snprintf(rule, sizeof(rule), "type='signal',interface='%s'", CMTSPEECH_DBUS_CSCALL_CONNECT_IF);
if (add_dbus_match(e, dbusconn, rule)) {
goto fail;
}
snprintf(rule, sizeof(rule), "type='signal',interface='%s'", CMTSPEECH_DBUS_CSCALL_STATUS_IF);
if (add_dbus_match(e, dbusconn, rule)) {
goto fail;
}
snprintf(rule, sizeof(rule), "type='signal',interface='%s'", CMTSPEECH_DBUS_PHONE_SSC_STATE_IF);
if (add_dbus_match(e, dbusconn, rule)) {
goto fail;
}
snprintf(rule, sizeof(rule), "type='signal',interface='%s'", OFONO_DBUS_VOICECALL_IF);
if (add_dbus_match(e, dbusconn, rule))
goto fail;
return 0;
fail:
cmtspeech_dbus_unload(u);
dbus_error_free(&error);
return -1;
}
pa_reserve_monitor_wrapper* pa_reserve_monitor_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_monitor_wrapper *w;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-monitor-wrapper@%s", device_name);
if ((w = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(w) >= 1);
PA_REFCNT_INC(w);
return w;
}
w = pa_xnew0(pa_reserve_monitor_wrapper, 1);
PA_REFCNT_INIT(w);
w->core = c;
pa_hook_init(&w->hook, w);
w->shared_name = t;
pa_assert_se(pa_shared_set(c, w->shared_name, w) >= 0);
#ifdef HAVE_DBUS
if (!(w->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return w;
}
if ((k = rm_watch(
&w->monitor,
pa_dbus_connection_get(w->connection),
device_name,
change_cb,
NULL)) < 0) {
pa_log_debug("Failed to create watch on device '%s': %s", device_name, pa_cstrerror(-k));
goto fail;
}
pa_log_debug("Successfully create reservation lock monitor for device '%s'", device_name);
rm_set_userdata(w->monitor, w);
return w;
fail:
dbus_error_free(&error);
reserve_monitor_wrapper_free(w);
return NULL;
#else
return w;
#endif
}
pa_reserve_wrapper* pa_reserve_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_wrapper *r;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-wrapper@%s", device_name);
if ((r = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(r) >= 1);
PA_REFCNT_INC(r);
return r;
}
r = pa_xnew0(pa_reserve_wrapper, 1);
PA_REFCNT_INIT(r);
r->core = c;
pa_hook_init(&r->hook, r);
r->shared_name = t;
pa_assert_se(pa_shared_set(c, r->shared_name, r) >= 0);
#ifdef HAVE_DBUS
if (!(r->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return r;
}
if ((k = rd_acquire(
&r->device,
pa_dbus_connection_get(r->connection),
device_name,
_("PulseAudio Sound Server"),
0,
request_cb,
NULL)) < 0) {
if (k == -EBUSY) {
pa_log_debug("Device '%s' already locked.", device_name);
goto fail;
} else {
pa_log_debug("Failed to acquire reservation lock on device '%s': %s", device_name, pa_cstrerror(-k));
return r;
}
}
pa_log_debug("Successfully acquired reservation lock on device '%s'", device_name);
rd_set_userdata(r->device, r);
return r;
fail:
dbus_error_free(&error);
reserve_wrapper_free(r);
return NULL;
#else
return r;
#endif
}
