static void profile_done(pa_bluetooth_backend *b, pa_bluetooth_profile_t profile) {
pa_assert(b);
switch (profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_AG_PROFILE);
break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_HS_PROFILE);
break;
default:
pa_assert_not_reached();
break;
}
}
static void profile_init(pa_bluetooth_backend *b, pa_bluetooth_profile_t profile) {
static const DBusObjectPathVTable vtable_profile = {
.message_function = profile_handler,
};
const char *object_name;
const char *uuid;
pa_assert(b);
switch (profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
object_name = HSP_AG_PROFILE;
uuid = PA_BLUETOOTH_UUID_HSP_AG;
break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY:
object_name = HSP_HS_PROFILE;
uuid = PA_BLUETOOTH_UUID_HSP_HS;
break;
default:
pa_assert_not_reached();
break;
}
pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(b->connection), object_name, &vtable_profile, b));
register_profile(b, object_name, uuid);
}
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;
}
static pa_dbus_pending* send_and_add_to_pending(pa_bluetooth_backend *backend, DBusMessage *m,
DBusPendingCallNotifyFunction func, void *call_data) {
pa_dbus_pending *p;
DBusPendingCall *call;
pa_assert(backend);
pa_assert(m);
pa_assert_se(dbus_connection_send_with_reply(pa_dbus_connection_get(backend->connection), m, &call, -1));
p = pa_dbus_pending_new(pa_dbus_connection_get(backend->connection), m, call, backend, call_data);
PA_LLIST_PREPEND(pa_dbus_pending, backend->pending, p);
dbus_pending_call_set_notify(call, func, p, NULL);
return p;
}
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;
}
void pa_dbusobj_server_lookup_free(pa_dbusobj_server_lookup *sl) {
pa_assert(sl);
if (sl->path_registered) {
pa_assert(sl->conn);
if (!dbus_connection_unregister_object_path(pa_dbus_connection_get(sl->conn), OBJECT_PATH))
pa_log_debug("dbus_connection_unregister_object_path() failed for " OBJECT_PATH ".");
}
if (sl->conn)
pa_dbus_connection_unref(sl->conn);
pa_xfree(sl);
}
void cmtspeech_dbus_unload(struct userdata *u)
{
DBusConnection *dbusconn;
struct cmtspeech_dbus_conn *e = &u->dbus_conn;
if (!e->dbus_conn)
return;
dbusconn = pa_dbus_connection_get(e->dbus_conn);
dbus_connection_remove_filter(dbusconn, cmtspeech_dbus_filter, u);
clear_dbus_matches(e, dbusconn);
pa_dbus_connection_unref(e->dbus_conn);
}
static DBusHandlerResult profile_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
pa_bluetooth_backend *b = userdata;
DBusMessage *r = NULL;
const char *path, *interface, *member;
pa_assert(b);
path = dbus_message_get_path(m);
interface = dbus_message_get_interface(m);
member = dbus_message_get_member(m);
pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
if (!pa_streq(path, HSP_AG_PROFILE) && !pa_streq(path, HSP_HS_PROFILE))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
const char *xml = PROFILE_INTROSPECT_XML;
pa_assert_se(r = dbus_message_new_method_return(m));
pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "Release")) {
pa_log_debug("Release not handled");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "RequestDisconnection")) {
r = profile_request_disconnection(c, m, userdata);
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "NewConnection"))
r = profile_new_connection(c, m, userdata);
else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (r) {
pa_assert_se(dbus_connection_send(pa_dbus_connection_get(b->connection), r, NULL));
dbus_message_unref(r);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
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
}
