diff --git a/audio/manager.c b/audio/manager.c
index 99fcaf8..3b105ed 100644
--- a/audio/manager.c
+++ b/audio/manager.c
ba2str(dst, addr);
- device = adapter_get_device(connection, adapter, addr);
+ device = adapter_get_device(adapter, addr);
if (!device) {
error("Unable to get btd_device object for %s", addr);
return NULL;
diff --git a/profiles/health/hdp.c b/profiles/health/hdp.c
index 351fe1e..489e1eb 100644
--- a/profiles/health/hdp.c
+++ b/profiles/health/hdp.c
char str[18];
ba2str(&addr, str);
- device = adapter_get_device(connection,
- hdp_adapter->btd_adapter, str);
+ device = adapter_get_device(hdp_adapter->btd_adapter, str);
if (!device)
return;
hdp_device = create_health_device(connection, device);
diff --git a/src/adapter.c b/src/adapter.c
index 7550eb2..f9acbd5 100644
--- a/src/adapter.c
+++ b/src/adapter.c
#define OFF_TIMER 3
-static DBusConnection *connection = NULL;
static GSList *adapter_drivers = NULL;
struct session_req {
struct btd_adapter *adapter;
- DBusConnection *conn; /* Connection reference */
DBusMessage *msg; /* Unreplied message ref */
char *owner; /* Bus name of the owner */
guint id; /* Listener id */
}
static struct session_req *create_session(struct btd_adapter *adapter,
- DBusConnection *conn, DBusMessage *msg,
- uint8_t mode, GDBusWatchFunction cb)
+ DBusMessage *msg, uint8_t mode,
+ GDBusWatchFunction cb)
{
const char *sender = dbus_message_get_sender(msg);
struct session_req *req;
req = g_new0(struct session_req, 1);
req->adapter = adapter;
- req->conn = dbus_connection_ref(conn);
req->msg = dbus_message_ref(msg);
req->mode = mode;
return session_ref(req);
req->owner = g_strdup(sender);
- req->id = g_dbus_add_disconnect_watch(conn, sender, cb, req, NULL);
+ req->id = g_dbus_add_disconnect_watch(btd_get_dbus_connection(),
+ sender, cb, req, NULL);
info("%s session %p with %s activated",
req->mode ? "Mode" : "Discovery", req, sender);
session_ref(req);
} else
/* Wait for mode change to reply */
- adapter->pending_mode = create_session(adapter,
- connection, msg, new_mode, NULL);
+ adapter->pending_mode = create_session(adapter, msg,
+ new_mode, NULL);
} else
/* Nothing to reply just write the new mode */
adapter->mode = new_mode;
return 0;
}
-static DBusMessage *set_discoverable(DBusConnection *conn, DBusMessage *msg,
- gboolean discoverable, void *data)
+static DBusMessage *set_discoverable(DBusMessage *msg,
+ gboolean discoverable, void *data)
{
struct btd_adapter *adapter = data;
uint8_t mode;
return NULL;
}
-static DBusMessage *set_powered(DBusConnection *conn, DBusMessage *msg,
- gboolean powered, void *data)
+static DBusMessage *set_powered(DBusMessage *msg, gboolean powered, void *data)
{
struct btd_adapter *adapter = data;
uint8_t mode;
if (powered) {
mode = get_mode(&adapter->bdaddr, "on");
- return set_discoverable(conn, msg, mode == MODE_DISCOVERABLE,
- data);
+ return set_discoverable(msg, mode == MODE_DISCOVERABLE, data);
}
mode = MODE_OFF;
return NULL;
}
-static DBusMessage *set_pairable(DBusConnection *conn, DBusMessage *msg,
- gboolean pairable, void *data)
+static DBusMessage *set_pairable(DBusMessage *msg,
+ gboolean pairable, void *data)
{
struct btd_adapter *adapter = data;
int err;
static gboolean pairable_timeout_handler(void *data)
{
- set_pairable(NULL, NULL, FALSE, data);
+ set_pairable(NULL, FALSE, data);
return FALSE;
}
struct session_req *req = data;
if (req->id)
- g_dbus_remove_watch(req->conn, req->id);
+ g_dbus_remove_watch(btd_get_dbus_connection(), req->id);
if (req->msg) {
dbus_message_unref(req->msg);
agent_cancel(req->adapter->agent);
}
- if (req->conn)
- dbus_connection_unref(req->conn);
g_free(req->owner);
g_free(req);
}
static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct session_req *req = data;
int err;
DBusMessage *reply;
if (derr && dbus_error_is_set(derr)) {
reply = dbus_message_new_error(req->msg, derr->name,
derr->message);
- g_dbus_send_message(req->conn, reply);
+ g_dbus_send_message(conn, reply);
session_unref(req);
return;
}
* mode, or change is not needed. Otherwise, reply is sent in
* set_mode_complete.
*/
- g_dbus_send_message(req->conn, reply);
+ g_dbus_send_message(conn, reply);
dbus_message_unref(req->msg);
req->msg = NULL;
session_unref(req);
}
-static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
- DBusMessage *msg,
- uint32_t timeout,
- void *data)
+static DBusMessage *set_discoverable_timeout(DBusMessage *msg,
+ uint32_t timeout, void *data)
{
struct btd_adapter *adapter = data;
const char *path;
return dbus_message_new_method_return(msg);
}
-static DBusMessage *set_pairable_timeout(DBusConnection *conn,
- DBusMessage *msg,
- uint32_t timeout,
- void *data)
+static DBusMessage *set_pairable_timeout(DBusMessage *msg,
+ uint32_t timeout, void *data)
{
struct btd_adapter *adapter = data;
const char *path;
adapter->name = g_strdup(name);
emit_property_changed(adapter->path,
- ADAPTER_INTERFACE, "Name",
- DBUS_TYPE_STRING, &name);
+ ADAPTER_INTERFACE, "Name",
+ DBUS_TYPE_STRING, &name);
if (main_opts.gatt_enabled)
attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
return 0;
}
-static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
- const char *name, void *data)
+static DBusMessage *set_name(DBusMessage *msg, const char *name, void *data)
{
struct btd_adapter *adapter = data;
int ret;
adapter_emit_uuids_updated(adapter);
}
-static struct btd_device *adapter_create_device(DBusConnection *conn,
- struct btd_adapter *adapter,
+static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
const char *address,
uint8_t bdaddr_type)
{
adapter->devices = g_slist_append(adapter->devices, device);
path = device_get_path(device);
- g_dbus_emit_signal(conn, adapter->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), adapter->path,
ADAPTER_INTERFACE, "DeviceCreated",
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
return device;
}
-void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
+void adapter_remove_device(struct btd_adapter *adapter,
struct btd_device *device,
gboolean remove_storage)
{
adapter_update_devices(adapter);
- g_dbus_emit_signal(conn, adapter->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), adapter->path,
ADAPTER_INTERFACE, "DeviceRemoved",
DBUS_TYPE_OBJECT_PATH, &dev_path,
DBUS_TYPE_INVALID);
device_remove(device, remove_storage);
}
-struct btd_device *adapter_get_device(DBusConnection *conn,
- struct btd_adapter *adapter,
- const gchar *address)
+struct btd_device *adapter_get_device(struct btd_adapter *adapter,
+ const gchar *address)
{
struct btd_device *device;
if (device)
return device;
- return adapter_create_device(conn, adapter, address,
- BDADDR_BREDR);
+ return adapter_create_device(adapter, address, BDADDR_BREDR);
}
static gboolean discovery_cb(gpointer user_data)
return btd_error_failed(msg, strerror(-err));
done:
- req = create_session(adapter, conn, msg, 0,
- session_owner_exit);
+ req = create_session(adapter, msg, 0, session_owner_exit);
adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
return btd_error_invalid_args(msg);
dbus_message_iter_get_basic(&sub, &name);
- return set_name(conn, msg, name, data);
+ return set_name(msg, name, data);
} else if (g_str_equal("Powered", property)) {
gboolean powered;
dbus_message_iter_get_basic(&sub, &powered);
- return set_powered(conn, msg, powered, data);
+ return set_powered(msg, powered, data);
} else if (g_str_equal("Discoverable", property)) {
gboolean discoverable;
dbus_message_iter_get_basic(&sub, &discoverable);
- return set_discoverable(conn, msg, discoverable, data);
+ return set_discoverable(msg, discoverable, data);
} else if (g_str_equal("DiscoverableTimeout", property)) {
uint32_t timeout;
dbus_message_iter_get_basic(&sub, &timeout);
- return set_discoverable_timeout(conn, msg, timeout, data);
+ return set_discoverable_timeout(msg, timeout, data);
} else if (g_str_equal("Pairable", property)) {
gboolean pairable;
dbus_message_iter_get_basic(&sub, &pairable);
- return set_pairable(conn, msg, pairable, data);
+ return set_pairable(msg, pairable, data);
} else if (g_str_equal("PairableTimeout", property)) {
uint32_t timeout;
dbus_message_iter_get_basic(&sub, &timeout);
- return set_pairable_timeout(conn, msg, timeout, data);
+ return set_pairable_timeout(msg, timeout, data);
}
return btd_error_invalid_args(msg);
session_ref(req);
return dbus_message_new_method_return(msg);
} else {
- req = create_session(adapter, conn, msg, new_mode,
- session_owner_exit);
+ req = create_session(adapter, msg, new_mode,
+ session_owner_exit);
adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
req);
}
return NULL;
}
- adapter_remove_device(conn, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
return dbus_message_new_method_return(msg);
}
-static struct btd_device *create_device_internal(DBusConnection *conn,
- struct btd_adapter *adapter,
+static struct btd_device *create_device_internal(struct btd_adapter *adapter,
const char *address, int *err)
{
struct remote_dev_info *dev;
else
bdaddr_type = BDADDR_BREDR;
- device = adapter_create_device(conn, adapter, address, bdaddr_type);
+ device = adapter_create_device(adapter, address, bdaddr_type);
if (!device && err)
*err = -ENOMEM;
DBG("%s", address);
- device = create_device_internal(conn, adapter, address, &err);
+ device = create_device_internal(adapter, address, &err);
if (!device)
goto failed;
err = device_browse_primary(device, msg, FALSE);
if (err < 0) {
- adapter_remove_device(conn, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
return btd_error_failed(msg, strerror(-err));
}
device = adapter_find_device(adapter, address);
if (!device) {
- device = create_device_internal(conn, adapter, address, &err);
+ device = create_device_internal(adapter, address, &err);
if (!device)
return btd_error_failed(msg, strerror(-err));
}
device_set_temporary(device, TRUE);
if (!device_is_connected(device)) {
- adapter_remove_device(conn, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
return dbus_message_new_method_return(msg);
}
ba2str(bdaddr, address);
DBG("Adding existing connection to %s", address);
- device = adapter_get_device(connection, adapter, address);
+ device = adapter_get_device(adapter, address);
if (device)
adapter_add_connection(adapter, device);
}
ba2str(&dev->bdaddr, address);
- g_dbus_emit_signal(connection, adapter->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), adapter->path,
ADAPTER_INTERFACE, "DeviceDisappeared",
DBUS_TYPE_STRING, &paddr,
DBUS_TYPE_INVALID);
reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
- g_dbus_send_message(connection, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
if (err != 0)
path = g_strdup(adapter->path);
- g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE);
+ g_dbus_unregister_interface(btd_get_dbus_connection(),
+ path, ADAPTER_INTERFACE);
g_free(path);
}
return TRUE;
}
-struct btd_adapter *adapter_create(DBusConnection *conn, int id)
+struct btd_adapter *adapter_create(int id)
{
char path[MAX_PATH_LENGTH];
struct btd_adapter *adapter;
const char *base_path = manager_get_base_path();
- if (!connection)
- connection = conn;
-
adapter = g_try_new0(struct btd_adapter, 1);
if (!adapter) {
error("adapter_create: failed to alloc memory for hci%d", id);
snprintf(path, sizeof(path), "%s/hci%d", base_path, id);
adapter->path = g_strdup(path);
- if (!g_dbus_register_interface(conn, path, ADAPTER_INTERFACE,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(),
+ path, ADAPTER_INTERFACE,
adapter_methods, adapter_signals, NULL,
adapter, adapter_free)) {
error("Adapter interface init failed on path %s", path);
append_dict_valist(&iter, first_key, var_args);
va_end(var_args);
- g_dbus_send_message(connection, signal);
+ g_dbus_send_message(btd_get_dbus_connection(), signal);
}
static char **strlist2array(GSList *list)
const char *path = device_get_path(device);
DBG("Removing temporary device %s", path);
- adapter_remove_device(connection, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
}
}
ba2str(bdaddr, addr);
if (status == 0)
- device = adapter_get_device(connection, adapter, addr);
+ device = adapter_get_device(adapter, addr);
else
device = adapter_find_device(adapter, addr);
diff --git a/src/adapter.h b/src/adapter.h
index cd37b15..eece6f5 100644
--- a/src/adapter.h
+++ b/src/adapter.h
void btd_adapter_get_class(struct btd_adapter *adapter, uint8_t *major,
uint8_t *minor);
const char *btd_adapter_get_name(struct btd_adapter *adapter);
-struct btd_device *adapter_get_device(DBusConnection *conn,
- struct btd_adapter *adapter, const char *address);
+struct btd_device *adapter_get_device(struct btd_adapter *adapter,
+ const char *address);
struct btd_device *adapter_find_device(struct btd_adapter *adapter, const char *dest);
-void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
+void adapter_remove_device(struct btd_adapter *adapter,
struct btd_device *device,
gboolean remove_storage);
-struct btd_adapter *adapter_create(DBusConnection *conn, int id);
+struct btd_adapter *adapter_create(int id);
gboolean adapter_init(struct btd_adapter *adapter, gboolean up);
void adapter_remove(struct btd_adapter *adapter);
void adapter_set_allow_name_changes(struct btd_adapter *adapter,
diff --git a/src/event.c b/src/event.c
index f1f5aaf..1db73be 100644
--- a/src/event.c
+++ b/src/event.c
struct btd_device **device,
gboolean create)
{
- DBusConnection *conn = btd_get_dbus_connection();
char peer_addr[18];
*adapter = manager_find_adapter(src);
ba2str(dst, peer_addr);
if (create)
- *device = adapter_get_device(conn, *adapter, peer_addr);
+ *device = adapter_get_device(*adapter, peer_addr);
else
*device = adapter_find_device(*adapter, peer_addr);
{
struct btd_adapter *adapter;
struct btd_device *device;
- DBusConnection *conn = btd_get_dbus_connection();
DBG("status 0x%02x", status);
device_cancel_bonding(device, status);
if (device_is_temporary(device))
- adapter_remove_device(conn, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
}
void btd_event_disconn_complete(bdaddr_t *local, bdaddr_t *peer)
{
struct btd_adapter *adapter;
struct btd_device *device;
- DBusConnection *conn = btd_get_dbus_connection();
if (!get_adapter_and_device(local, peer, &adapter, &device, FALSE))
return;
if (device_is_connected(device))
device_request_disconnect(device, NULL);
else
- adapter_remove_device(conn, adapter, device, TRUE);
+ adapter_remove_device(adapter, device, TRUE);
}
/* Section reserved to device HCI callbacks */
diff --git a/src/manager.c b/src/manager.c
index fe8706b..15a2571 100644
--- a/src/manager.c
+++ b/src/manager.c
return NULL;
}
- adapter = adapter_create(btd_get_dbus_connection(), id);
+ adapter = adapter_create(id);
if (!adapter)
return NULL;