Cleanup hci adapter.

1 files changed, 23 insertions, 2400 deletions

diff --git a/hcid/adapter.c b/hcid/adapter.c
index 29bf51ca..dce1f6c8 100644
--- a/hcid/adapter.c
+++ b/hcid/adapter.c
@@ -397,24 +397,19 @@ static struct bonding_request_info *bonding_request_new(DBusConnection *conn,
 {
 	struct bonding_request_info *bonding;
 	struct device *device;
+	const char *name = dbus_message_get_sender(msg);
 
 	debug("bonding_request_new(%s)", address);
 
-	if (hcid_dbus_use_experimental() && agent_path) {
-		const char *name = dbus_message_get_sender(msg);
-
-		device = adapter_get_device(conn, adapter, address);
-		if (!device)
-			return NULL;
+	device = adapter_get_device(conn, adapter, address);
+	if (!device)
+		return NULL;
 
-		device->agent = agent_create(adapter, name, agent_path,
-						capability,
-						device_agent_removed,
-						device);
-		debug("Temporary agent registered for hci%d/%s at %s:%s",
-				adapter->dev_id, device->address, name,
-				agent_path);
-	}
+	device->agent = agent_create(adapter, name, agent_path,
+				capability, device_agent_removed, device);
+	debug("Temporary agent registered for hci%d/%s at %s:%s",
+			adapter->dev_id, device->address, name,
+			agent_path);
 
 	bonding = g_new0(struct bonding_request_info, 1);
 
@@ -472,262 +467,6 @@ uint8_t str2mode(const char *addr, const char *mode)
 		return MODE_UNKNOWN;
 }
 
-static DBusMessage *adapter_get_info(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *property;
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter dict;
-	bdaddr_t ba;
-	char str[249];
-	uint8_t cls[3];
-
-	if (check_address(adapter->address) < 0)
-		return adapter_not_ready(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
-			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
-
-	property = adapter->address;
-	dbus_message_iter_append_dict_entry(&dict, "address",
-			DBUS_TYPE_STRING, &property);
-
-	memset(str, 0, sizeof(str));
-	property = str;
-	str2ba(adapter->address, &ba);
-
-	if (!read_local_name(&ba, str))
-		dbus_message_iter_append_dict_entry(&dict, "name",
-			DBUS_TYPE_STRING, &property);
-
-	get_device_version(adapter->dev_id, str, sizeof(str));
-	dbus_message_iter_append_dict_entry(&dict, "version",
-			DBUS_TYPE_STRING, &property);
-
-	get_device_revision(adapter->dev_id, str, sizeof(str));
-	dbus_message_iter_append_dict_entry(&dict, "revision",
-			DBUS_TYPE_STRING, &property);
-
-	get_device_manufacturer(adapter->dev_id, str, sizeof(str));
-	dbus_message_iter_append_dict_entry(&dict, "manufacturer",
-			DBUS_TYPE_STRING, &property);
-
-	get_device_company(adapter->dev_id, str, sizeof(str));
-	dbus_message_iter_append_dict_entry(&dict, "company",
-			DBUS_TYPE_STRING, &property);
-
-	property = mode2str(adapter->mode);
-
-	dbus_message_iter_append_dict_entry(&dict, "mode",
-			DBUS_TYPE_STRING, &property);
-
-	dbus_message_iter_append_dict_entry(&dict, "discoverable_timeout",
-				DBUS_TYPE_UINT32, &adapter->discov_timeout);
-
-	if (!read_local_class(&ba, cls)) {
-		uint32_t class;
-
-		memcpy(&class, cls, 3);
-		dbus_message_iter_append_dict_entry(&dict, "class",
-			DBUS_TYPE_UINT32, &class);
-
-		property = major_class_str(class);
-		dbus_message_iter_append_dict_entry(&dict, "major_class",
-			DBUS_TYPE_STRING, &property);
-
-		property = minor_class_str(class);
-		dbus_message_iter_append_dict_entry(&dict, "minor_class",
-			DBUS_TYPE_STRING, &property);
-	}
-
-	dbus_message_iter_close_container(&iter, &dict);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_address(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *paddr = adapter->address;
-	DBusMessage *reply;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	if (check_address(paddr) < 0)
-		return adapter_not_ready(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &paddr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_version(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[20], *str_ptr = str;
-	int err;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	err = get_device_version(adapter->dev_id, str, sizeof(str));
-	if (err < 0)
-		return failed_strerror(msg, -err);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_revision(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[64], *str_ptr = str;
-	int err;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	err = get_device_revision(adapter->dev_id, str, sizeof(str));
-	if (err < 0)
-		return failed_strerror(msg, -err);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_manufacturer(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[64], *str_ptr = str;
-	int err;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	err = get_device_manufacturer(adapter->dev_id, str, sizeof(str));
-	if (err < 0)
-		return failed_strerror(msg, -err);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_company(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[64], *str_ptr = str;
-	int err;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	err = get_device_company(adapter->dev_id, str, sizeof(str));
-	if (err < 0)
-		return failed_strerror(msg, -err);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_list_modes(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	const char *mode_ptr[] = { "off", "connectable", "discoverable", "limited" };
-	int i;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-						DBUS_TYPE_STRING_AS_STRING, &array_iter);
-	for (i = 0; i < 4; i++)
-		dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING,
-								&mode_ptr[i]);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_mode(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply = NULL;
-	const char *mode;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	mode = mode2str(adapter->mode);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &mode,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
 static DBusMessage *set_mode(DBusConnection *conn, DBusMessage *msg,
 				uint8_t new_mode, void *data)
 {
@@ -918,81 +657,6 @@ static DBusMessage *confirm_mode(DBusConnection *conn, DBusMessage *msg,
 	return NULL;
 }
 
-static DBusMessage *adapter_set_mode(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *mode;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &mode,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (!mode)
-		return invalid_args(msg);
-
-	adapter->global_mode = str2mode(adapter->address, mode);
-
-	if (adapter->global_mode == adapter->mode)
-		return dbus_message_new_method_return(msg);
-
-	if (adapter->sessions && adapter->global_mode < adapter->mode)
-		return confirm_mode(conn, msg, mode, data);
-
-	return set_mode(conn, msg, str2mode(adapter->address, mode), data);
-}
-
-static DBusMessage *adapter_get_discoverable_to(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_UINT32, &adapter->discov_timeout,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static void resolve_paths(DBusMessage *msg, char **old_path, char **new_path)
-{
-	const char *path = dbus_message_get_path(msg);
-
-	if (!path)
-		return;
-
-	if (old_path)
-		*old_path = NULL;
-
-	if (new_path)
-		*new_path = NULL;
-
-	/* old path calls */
-	if (g_str_has_prefix(path, BASE_PATH)) {
-		if (old_path)
-			*old_path = g_strdup(path);
-
-		if (hcid_dbus_use_experimental() && new_path)
-			*new_path = g_strdup(path + ADAPTER_PATH_INDEX);
-
-		return;
-	}
-
-	if (old_path)
-		*old_path = g_strconcat(BASE_PATH, path, NULL);
-
-	if (new_path)
-		*new_path = g_strdup(path);
-}
-
 static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
 							DBusMessage *msg,
 							uint32_t timeout,
@@ -1000,7 +664,7 @@ static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
 {
 	struct adapter *adapter = data;
 	bdaddr_t bdaddr;
-	char *old_path, *new_path;
+	const char *path;
 
 	if (adapter->timeout_id) {
 		g_source_remove(adapter->timeout_id);
@@ -1017,409 +681,23 @@ static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
 	str2ba(adapter->address, &bdaddr);
 	write_discoverable_timeout(&bdaddr, timeout);
 
-	resolve_paths(msg, &old_path, &new_path);
+	path = dbus_message_get_path(msg);
 
-	g_dbus_emit_signal(conn, old_path,
+	dbus_connection_emit_property_changed(conn, path,
 					ADAPTER_INTERFACE,
-					"DiscoverableTimeoutChanged",
-					DBUS_TYPE_UINT32, &timeout,
-					DBUS_TYPE_INVALID);
-	if (new_path) {
-		dbus_connection_emit_property_changed(conn, new_path,
-						ADAPTER_INTERFACE,
-						"DiscoverableTimeout",
-						DBUS_TYPE_UINT32, &timeout);
-	}
-
-	g_free(old_path);
-	g_free(new_path);
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_set_discoverable_to(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	uint32_t timeout;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_UINT32, &timeout,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	return set_discoverable_timeout(conn, msg, timeout, data);
-}
-
-static DBusMessage *adapter_is_connectable(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply;
-	const uint8_t scan_enable = adapter->scan_enable;
-	dbus_bool_t connectable = FALSE;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	if (scan_enable & SCAN_PAGE)
-		connectable = TRUE;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connectable,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_is_discoverable(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply;
-	const uint8_t scan_enable = adapter->scan_enable;
-	dbus_bool_t discoverable = FALSE;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	if (scan_enable & SCAN_INQUIRY)
-		discoverable = TRUE;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &discoverable,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_is_connected(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	dbus_bool_t connected = FALSE;
-
-	struct adapter *adapter = data;
-	GSList *l = adapter->active_conn;
-
-	const char *peer_addr;
-	bdaddr_t peer_bdaddr;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &peer_addr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(peer_addr) < 0)
-		return invalid_args(msg);
-
-	str2ba(peer_addr, &peer_bdaddr);
-
-	l = g_slist_find_custom(l, &peer_bdaddr, active_conn_find_by_bdaddr);
-	if (l)
-		connected = TRUE;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_list_connections(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	struct adapter *adapter = data;
-	GSList *l = adapter->active_conn;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-					DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	while (l) {
-		char peer_addr[18];
-		const char *paddr = peer_addr;
-		struct active_conn_info *dev = l->data;
-
-		ba2str(&dev->bdaddr, peer_addr);
-
-		dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING,
-						&paddr);
-
-		l = l->next;
-	}
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_major_class(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply;
-	const char *str_ptr = "computer";
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	/* FIXME: Currently, only computer major class is supported */
-	if ((adapter->class[1] & 0x1f) != 1)
-		return unsupported_major_class(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_list_minor_classes(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	const struct adapter *adapter = data;
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	const char **minor_ptr;
-	uint8_t major_class;
-	int size, i;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	major_class = adapter->class[1] & 0x1F;
-
-	switch (major_class) {
-	case 1: /* computer */
-		minor_ptr = computer_minor_cls;
-		size = sizeof(computer_minor_cls) / sizeof(*computer_minor_cls);
-		break;
-	case 2: /* phone */
-		minor_ptr = phone_minor_cls;
-		size = sizeof(phone_minor_cls) / sizeof(*phone_minor_cls);
-		break;
-	default:
-		return unsupported_major_class(msg);
-	}
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-						DBUS_TYPE_STRING_AS_STRING, &array_iter);
-	for (i = 0; i < size; i++)
-		dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING,
-						&minor_ptr[i]);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_minor_class(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	const char *str_ptr = "";
-	uint8_t minor_class;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	/* FIXME: Currently, only computer major class is supported */
-	if ((adapter->class[1] & 0x1f) != 1)
-		return unsupported_major_class(msg);
-
-	minor_class = adapter->class[0] >> 2;
-
-	/* Validate computer minor class */
-	if (minor_class > (sizeof(computer_minor_cls) / sizeof(*computer_minor_cls)))
-		goto failed;
-
-	str_ptr = computer_minor_cls[minor_class];
-
-failed:
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_set_minor_class(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *minor;
-	uint32_t dev_class = 0xFFFFFFFF;
-	int i, dd;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &minor,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (!minor)
-		return invalid_args(msg);
-
-	dd = hci_open_dev(adapter->dev_id);
-	if (dd < 0)
-		return no_such_adapter(msg);
-
-	/* Currently, only computer major class is supported */
-	if ((adapter->class[1] & 0x1f) != 1) {
-		hci_close_dev(dd);
-		return unsupported_major_class(msg);
-	}
-	for (i = 0; i < sizeof(computer_minor_cls) / sizeof(*computer_minor_cls); i++)
-		if (!strcasecmp(minor, computer_minor_cls[i])) {
-			/* Remove the format type */
-			dev_class = i << 2;
-			break;
-		}
-
-	/* Check if it's a valid minor class */
-	if (dev_class == 0xFFFFFFFF) {
-		hci_close_dev(dd);
-		return invalid_args(msg);
-	}
-
-	/* set the service class and major class  */
-	dev_class |= (adapter->class[2] << 16) | (adapter->class[1] << 8);
-
-	if (hci_write_class_of_dev(dd, dev_class, 2000) < 0) {
-		int err = errno;
-		error("Can't write class of device on hci%d: %s(%d)",
-				adapter->dev_id, strerror(errno), errno);
-		hci_close_dev(dd);
-		return failed_strerror(msg, err);
-	}
-
-	g_dbus_emit_signal(conn, dbus_message_get_path(msg),
-					ADAPTER_INTERFACE, "MinorClassChanged",
-					DBUS_TYPE_STRING, &minor,
-					DBUS_TYPE_INVALID);
-
-	hci_close_dev(dd);
+					"DiscoverableTimeout",
+					DBUS_TYPE_UINT32, &timeout);
 
 	return dbus_message_new_method_return(msg);
 }
 
-static DBusMessage *adapter_get_service_classes(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	const char *str_ptr;
-	int i;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-				DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	for (i = 0; i < (sizeof(service_cls) / sizeof(*service_cls)); i++) {
-		if (adapter->class[2] & (1 << i)) {
-			str_ptr = service_cls[i];
-			dbus_message_iter_append_basic(&array_iter,
-						DBUS_TYPE_STRING, &str_ptr);
-		}
-	}
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_name(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[249], *str_ptr = str;
-	int err;
-	bdaddr_t ba;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	str2ba(adapter->address, &ba);
-
-	err = read_local_name(&ba, str);
-	if (err < 0) {
-		if (!adapter->up)
-			return adapter_not_ready(msg);
-
-		err = get_device_name(adapter->dev_id, str, sizeof(str));
-		if (err < 0)
-			return failed_strerror(msg, -err);
-	}
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
 static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
 					const char *name, void *data)
 {
 	struct adapter *adapter = data;
 	bdaddr_t bdaddr;
 	int ecode;
-	char *new_path;
+	const char *path;
 
 	if (!g_utf8_validate(name, -1, NULL)) {
 		error("Name change failed: the supplied name isn't valid UTF-8");
@@ -1437,841 +715,16 @@ static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
 	if (ecode < 0)
 		return failed_strerror(msg, -ecode);
 done:
-	resolve_paths(msg, NULL, &new_path);
-
-	if (new_path) {
-		dbus_connection_emit_property_changed(conn, new_path,
-						ADAPTER_INTERFACE,
-						"Name", DBUS_TYPE_STRING,
-						&name);
-	}
-
-	g_free(new_path);
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_set_name(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	char *str_ptr;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &str_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	return set_name(conn, msg, str_ptr, data);
-}
-
-static DBusMessage *adapter_get_remote_info(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter dict;
-	bdaddr_t src, dst;
-	const char *addr_ptr;
-	char filename[PATH_MAX + 1];
-	char buf[64];
-	const char *ptr;
-	char *str;
-	dbus_bool_t boolean;
-	uint32_t class;
-	int compid, ver, subver;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
-			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
-
-	/* Name */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "names");
-	str = textfile_caseget(filename, addr_ptr);
-	if (str) {
-		dbus_message_iter_append_dict_entry(&dict, "name",
-				DBUS_TYPE_STRING, &str);
-		free(str);
-	}
-
-	str2ba(adapter->address, &src);
-	str2ba(addr_ptr, &dst);
-
-	/* Remote device class */
-	if (read_remote_class(&src, &dst, &class) == 0) {
-
-		dbus_message_iter_append_dict_entry(&dict, "class",
-				DBUS_TYPE_UINT32, &class);
-
-		ptr = major_class_str(class);
-		dbus_message_iter_append_dict_entry(&dict, "major_class",
-				DBUS_TYPE_STRING, &ptr);
-
-		ptr = minor_class_str(class);
-		dbus_message_iter_append_dict_entry(&dict, "minor_class",
-				DBUS_TYPE_STRING, &ptr);
-	}
-
-	/* Alias */
-	if (get_device_alias(adapter->dev_id, &dst, buf, sizeof(buf)) > 0) {
-		ptr = buf;
-		dbus_message_iter_append_dict_entry(&dict, "alias",
-				DBUS_TYPE_STRING, &ptr);
-	}
-
-	/* Bonded */
-	create_name(filename, PATH_MAX, STORAGEDIR,
-			adapter->address, "linkkeys");
-	str = textfile_caseget(filename, addr_ptr);
-	if (str) {
-		boolean = TRUE;
-		free(str);
-	} else {
-		boolean = FALSE;
-	}
-
-	dbus_message_iter_append_dict_entry(&dict, "bonded",
-			DBUS_TYPE_BOOLEAN, &boolean);
-
-	/* Trusted */
-	boolean = read_trust(&src, addr_ptr, GLOBAL_TRUST);
-	dbus_message_iter_append_dict_entry(&dict, "trusted",
-			DBUS_TYPE_BOOLEAN, &boolean);
-
-	/* Connected */
-	if (g_slist_find_custom(adapter->active_conn, &dst,
-				active_conn_find_by_bdaddr))
-		boolean = TRUE;
-	else
-		boolean = FALSE;
-
-	dbus_message_iter_append_dict_entry(&dict, "connected",
-			DBUS_TYPE_BOOLEAN, &boolean);
-
-	/* HCI Revision/Manufacturer/Version */
-	create_name(filename, PATH_MAX, STORAGEDIR,
-			adapter->address, "manufacturers");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		goto done;
-
-	if (sscanf(str, "%d %d %d", &compid, &ver, &subver) != 3) {
-		/* corrupted file data */
-		free(str);
-		goto done;
-	}
-
-	free(str);
-
-	ptr = buf;
-	snprintf(buf, 16, "HCI 0x%X", subver);
-	dbus_message_iter_append_dict_entry(&dict, "revision",
-			DBUS_TYPE_STRING, &ptr);
-
-	ptr = bt_compidtostr(compid);
-	dbus_message_iter_append_dict_entry(&dict, "manufacturer",
-			DBUS_TYPE_STRING, &ptr);
-
-	str = lmp_vertostr(ver);
-	snprintf(buf, 64, "Bluetooth %s", str);
-	bt_free(str);
-
-	create_name(filename, PATH_MAX, STORAGEDIR,
-			adapter->address, "features");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (str) {
-		if (strlen(str) == 16) {
-			uint8_t features;
-			/* Getting the third byte */
-			features  = ((str[6] - 48) << 4) | (str[7] - 48);
-			if (features & (LMP_EDR_ACL_2M | LMP_EDR_ACL_3M))
-				snprintf(buf, 64, "Bluetooth %s + EDR", ptr);
-
-		}
-		free(str);
-	}
-	ptr = buf;
-	dbus_message_iter_append_dict_entry(&dict, "version",
-			DBUS_TYPE_STRING, &ptr);
-
-done:
-	dbus_message_iter_close_container(&iter, &dict);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_svc(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	return get_remote_svc_rec(conn, msg, data, SDP_FORMAT_BINARY);
-}
-
-static DBusMessage *adapter_get_remote_svc_xml(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	return get_remote_svc_rec(conn, msg, data, SDP_FORMAT_XML);
-}
-
-static DBusMessage *adapter_get_remote_svc_handles(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	return get_remote_svc_handles(conn, msg, data);
-}
-
-static DBusMessage *adapter_get_remote_svc_identifiers(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	return get_remote_svc_identifiers(conn, msg, data);
-}
-
-static DBusMessage *adapter_finish_sdp_transact(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	return finish_remote_svc_transact(conn, msg, data);
-}
-
-static DBusMessage *adapter_get_remote_version(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-	char *str_ver = NULL;
-	char info_array[64], *info = info_array;
-	int compid, ver, subver;
-
-	memset(info_array, 0, 64);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"manufacturers");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		return not_available(msg);
-
-	if (sscanf(str, "%d %d %d", &compid, &ver, &subver) != 3) {
-		/* corrupted file data */
-		free(str);
-		goto failed;
-	}
-
-	free(str);
-
-	str_ver = lmp_vertostr(ver);
-
-	/* Default value */
-	snprintf(info, 64, "Bluetooth %s", str_ver);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"features");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		goto failed;
-
-	/* Check if the data is not corrupted */
-	if (strlen(str) == 16) {
-		uint8_t features;
-		/* Getting the third byte */
-		features  = ((str[6] - 48) << 4) | (str[7] - 48);
-		if (features & (LMP_EDR_ACL_2M | LMP_EDR_ACL_3M))
-			snprintf(info, 64, "Bluetooth %s + EDR", str_ver);
-	}
-
-	free(str);
-
-failed:
-	if (str_ver)
-		bt_free(str_ver);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &info,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_revision(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-	char info_array[16], *info = info_array;
-	int compid, ver, subver;
-
-	memset(info_array, 0, 16);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"manufacturers");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		return not_available(msg);
-
-	if (sscanf(str, "%d %d %d", &compid, &ver, &subver) == 3)
-		snprintf(info, 16, "HCI 0x%X", subver);
-
-	free(str);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &info,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_manufacturer(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-	char info_array[64], *info = info_array;
-	int compid, ver, subver;
-
-	memset(info_array, 0, 64);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
+	path = dbus_message_get_path(msg);
 
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"manufacturers");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		return not_available(msg);
-
-	if (sscanf(str, "%d %d %d", &compid, &ver, &subver) == 3)
-		info = bt_compidtostr(compid);
-
-	free(str);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &info,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_company(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	bdaddr_t bdaddr;
-	char oui[9], *str_bdaddr, *tmp;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &str_bdaddr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	str2ba(str_bdaddr, &bdaddr);
-	ba2oui(&bdaddr, oui);
-
-	tmp = ouitocomp(oui);
-	if (!tmp)
-		return not_available(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply) {
-		free(tmp);
-		return NULL;
-	}
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &tmp,
-					DBUS_TYPE_INVALID);
-
-	free(tmp);
-
-	return reply;
-}
-
-static DBusMessage *get_remote_class(DBusConnection *conn, DBusMessage *msg,
-						void *data, uint32_t *class)
-{
-	struct adapter *adapter = data;
-	char *addr_peer;
-	bdaddr_t local, peer;
-	int ecode;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_peer,
-				DBUS_TYPE_INVALID)) {
-		return invalid_args(msg);
-	}
-
-	if (check_address(addr_peer) < 0)
-		return invalid_args(msg);
-
-	str2ba(addr_peer, &peer);
-	str2ba(adapter->address, &local);
-
-	ecode = read_remote_class(&local, &peer, class);
-	if (ecode < 0)
-		return not_available(msg);
-
-	return NULL;
-}
-
-static DBusMessage *adapter_get_remote_major_class(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	const char *major_class;
-	uint32_t class;
-
-	reply = get_remote_class(conn, msg, data, &class);
-	if (reply)
-		return reply;
-
-	major_class = major_class_str(class);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &major_class,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_minor_class(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	const char *minor_class;
-	uint32_t class;
-
-	reply = get_remote_class(conn, msg, data, &class);
-	if (reply)
-		return reply;
-
-	minor_class = minor_class_str(class);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &minor_class,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static void append_class_string(const char *class, DBusMessageIter *iter)
-{
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &class);
-}
-
-static DBusMessage *adapter_get_remote_service_cls(DBusConnection *conn,
-							DBusMessage *msg,
-							void *data)
-{
-	DBusMessage *reply;
-	DBusMessageIter iter, array_iter;
-	GSList *service_classes;
-	uint32_t class;
-
-	reply = get_remote_class(conn, msg, data, &class);
-	if (reply)
-		return reply;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	service_classes = service_classes_str(class);
-
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-						DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	g_slist_foreach(service_classes, (GFunc) append_class_string,
-			&array_iter);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	g_slist_free(service_classes);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_class(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	uint32_t class;
-
-	reply = get_remote_class(conn, msg, data, &class);
-	if (reply)
-		return reply;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_UINT32, &class,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_features(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	char filename[PATH_MAX + 1];
-	struct adapter *adapter = data;
-	DBusMessage *reply = NULL;
-	DBusMessageIter iter, array_iter;
-	uint8_t features[8], *ptr = features;
-	const char *addr;
-	char *str;
-	int i;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr) < 0)
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "features");
-
-	str = textfile_caseget(filename, addr);
-	if (!str)
-		return not_available(msg);
-
-	memset(features, 0, sizeof(features));
-	for (i = 0; i < sizeof(features); i++) {
-		char tmp[3];
-
-		memcpy(tmp, str + (i * 2), 2);
-		tmp[2] = '\0';
-
-		features[i] = (uint8_t) strtol(tmp, NULL, 16);
-	}
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply) {
-		free(str);
-		return NULL;
-	}
-
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-				DBUS_TYPE_BYTE_AS_STRING, &array_iter);
-
-	dbus_message_iter_append_fixed_array(&array_iter,
-				DBUS_TYPE_BYTE, &ptr, sizeof(features));
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	free(str);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_remote_name(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	char filename[PATH_MAX + 1];
-	struct adapter *adapter = data;
-	DBusMessage *reply = NULL;
-	const char *peer_addr;
-	bdaddr_t peer_bdaddr;
-	char *str;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &peer_addr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(peer_addr) < 0)
-		return invalid_args(msg);
-
-	/* check if it is in the cache */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "names");
-
-	str = textfile_caseget(filename, peer_addr);
-
-	if (str) {
-		reply = dbus_message_new_method_return(msg);
-		if (!reply) {
-			free(str);
-			return NULL;
-		}
-
-		/* send the cached name */
-		dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
-						DBUS_TYPE_INVALID);
-
-		free(str);
-		return reply;
-	}
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	/* If the discover process is not running, return an error */
-	if (!adapter->discov_active && !adapter->pdiscov_active)
-		return not_available(msg);
-
-	/* Queue the request when there is a discovery running */
-	str2ba(peer_addr, &peer_bdaddr);
-	found_device_add(&adapter->found_devices, &peer_bdaddr, 0, NAME_REQUIRED);
-
-        return g_dbus_create_error(msg,
-			ERROR_INTERFACE ".RequestDeferred",
-			"Request Deferred");
-}
-
-static DBusMessage *adapter_get_remote_alias(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char str[249], *str_ptr = str, *addr_ptr;
-	bdaddr_t bdaddr;
-	int ecode;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	str2ba(addr_ptr, &bdaddr);
-
-	ecode = get_device_alias(adapter->dev_id, &bdaddr, str, sizeof(str));
-	if (ecode < 0)
-		return not_available(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_set_remote_alias(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	char *alias, *addr, *old_path, *new_path;
-	bdaddr_t bdaddr;
-	int ecode;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr,
-				DBUS_TYPE_STRING, &alias,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if ((strlen(alias) == 0) || (check_address(addr) < 0)) {
-		error("Alias change failed: Invalid parameter");
-		return invalid_args(msg);
-	}
-
-	str2ba(addr, &bdaddr);
-
-	ecode = set_device_alias(adapter->dev_id, &bdaddr, alias);
-	if (ecode < 0)
-		return failed_strerror(msg, -ecode);
-
-	resolve_paths(msg, &old_path, &new_path);
-
-	g_dbus_emit_signal(conn, old_path,
-					ADAPTER_INTERFACE, "RemoteAliasChanged",
-					DBUS_TYPE_STRING, &addr,
-					DBUS_TYPE_STRING, &alias,
-					DBUS_TYPE_INVALID);
-
-	if (new_path) {
-		struct device *device;
-
-		device = adapter_find_device(adapter, addr);
-		if (device) {
-			dbus_connection_emit_property_changed(conn,
-					device->path, DEVICE_INTERFACE,
-					"Alias", DBUS_TYPE_STRING, &alias);
-		}
-	}
-
-	g_free(old_path);
-	g_free(new_path);
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_clear_remote_alias(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	char *addr_ptr;
-	bdaddr_t bdaddr;
-	int ecode, had_alias = 1;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0) {
-		error("Alias clear failed: Invalid parameter");
-		return invalid_args(msg);
-	}
-
-	str2ba(addr_ptr, &bdaddr);
-
-	ecode = get_device_alias(adapter->dev_id, &bdaddr, NULL, 0);
-	if (ecode == -ENXIO)
-		had_alias = 0;
-
-	ecode = set_device_alias(adapter->dev_id, &bdaddr, NULL);
-	if (ecode < 0)
-		return failed_strerror(msg, -ecode);
-
-	if (had_alias)
-		g_dbus_emit_signal(conn, dbus_message_get_path(msg),
-						ADAPTER_INTERFACE,
-						"RemoteAliasCleared",
-						DBUS_TYPE_STRING, &addr_ptr,
-						DBUS_TYPE_INVALID);
+	dbus_connection_emit_property_changed(conn, path,
+					ADAPTER_INTERFACE,
+					"Name", DBUS_TYPE_STRING,
+					&name);
 
 	return dbus_message_new_method_return(msg);
 }
 
-static DBusMessage *adapter_last_seen(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"lastseen");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		return not_available(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply) {
-		free(str);
-		return NULL;
-	}
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
-					DBUS_TYPE_INVALID);
-
-	free(str);
-
-	return reply;
-}
-
-static DBusMessage *adapter_last_used(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"lastused");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (!str)
-		return not_available(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply) {
-		free(str);
-		return NULL;
-	}
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
-					DBUS_TYPE_INVALID);
-
-	free(str);
-
-	return reply;
-}
-
 gboolean dc_pending_timeout_handler(void *data)
 {
 	int dd;
@@ -2318,63 +771,6 @@ void dc_pending_timeout_cleanup(struct adapter *adapter)
 	adapter->pending_dc = NULL;
 }
 
-static DBusMessage *adapter_dc_remote_device(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	GSList *l = adapter->active_conn;
-	const char *peer_addr;
-	bdaddr_t peer_bdaddr;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &peer_addr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(peer_addr) < 0)
-		return invalid_args(msg);
-
-	str2ba(peer_addr, &peer_bdaddr);
-
-	l = g_slist_find_custom(l, &peer_bdaddr, active_conn_find_by_bdaddr);
-	if (!l)
-		return g_dbus_create_error(msg,
-				ERROR_INTERFACE ".NotConnected",
-				"Device not connected");
-
-	if (adapter->pending_dc)
-		return in_progress(msg, "Disconnection in progress");
-
-	adapter->pending_dc = g_new0(struct pending_dc_info, 1);
-
-	/* Start waiting... */
-	adapter->pending_dc->timeout_id =
-		g_timeout_add(DC_PENDING_TIMEOUT,
-			      dc_pending_timeout_handler,
-			      adapter);
-
-	if (!adapter->pending_dc->timeout_id) {
-		g_free(adapter->pending_dc);
-		adapter->pending_dc = NULL;
-		return NULL;
-	}
-
-	adapter->pending_dc->conn = dbus_connection_ref(conn);
-	adapter->pending_dc->msg = dbus_message_ref(msg);
-	adapter->pending_dc->conn_handle =
-		((struct active_conn_info *) l->data)->handle;
-
-	g_dbus_emit_signal(conn, dbus_message_get_path(msg),
-					ADAPTER_INTERFACE,
-					"RemoteDeviceDisconnectRequested",
-					DBUS_TYPE_STRING, &peer_addr,
-					DBUS_TYPE_INVALID);
-
-	return NULL;
-}
 
 static void reply_authentication_failure(struct bonding_request_info *bonding)
 {
@@ -2844,243 +1240,6 @@ static DBusMessage *create_bonding(DBusConnection *conn, DBusMessage *msg,
 	return NULL;
 }
 
-static DBusMessage *adapter_create_bonding(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	char *address;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &address,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	return create_bonding(conn, msg, address, NULL,
-				IO_CAPABILITY_INVALID, data);
-}
-static DBusMessage *adapter_cancel_bonding(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *address;
-	bdaddr_t bdaddr;
-	struct bonding_request_info *bonding = adapter->bonding;
-	struct pending_auth_info *auth_req;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &address,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	str2ba(address, &bdaddr);
-	if (!bonding || bacmp(&bonding->bdaddr, &bdaddr))
-		return not_in_progress(msg, "Bonding is not in progress");
-
-	if (strcmp(dbus_message_get_sender(adapter->bonding->msg),
-				dbus_message_get_sender(msg)))
-		return not_authorized(msg);
-
-	adapter->bonding->cancel = 1;
-
-	auth_req = adapter_find_auth_request(adapter, &bdaddr);
-	if (auth_req) {
-		if (auth_req->replied) {
-			/*
-			 * If disconnect can't be applied and the PIN code
-			 * request was already replied it doesn't make sense
-			 * cancel the remote passkey: return not authorized.
-			 */
-			g_io_channel_close(adapter->bonding->io);
-			return not_authorized(msg);
-		}
-
-		cancel_auth_request(auth_req, adapter->dev_id);
-		if (auth_req->agent)
-			agent_cancel(auth_req->agent);
-		adapter_remove_auth_request(adapter, &bdaddr);
-	}
-
-	g_io_channel_close(adapter->bonding->io);
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_remove_bonding(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	char *address;
-
-	if (!adapter->up)
-		return adapter_not_ready(msg);
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &address,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	return remove_bonding(conn, msg, address, data);
-}
-
-static DBusMessage *adapter_has_bonding(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	char *addr_ptr, *str;
-	dbus_bool_t result;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"linkkeys");
-
-	str = textfile_caseget(filename, addr_ptr);
-	if (str) {
-		result = TRUE;
-		free(str);
-	} else
-		result = FALSE;
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &result,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static void list_bondings_do_append(char *key, char *value, void *data)
-{
-	DBusMessageIter *iter = data;
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
-}
-
-static DBusMessage *adapter_list_bondings(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address,
-			"linkkeys");
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-				DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	textfile_foreach(filename, list_bondings_do_append, &array_iter);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_pin_code_length(DBusConnection *conn,
-							DBusMessage *msg,
-							void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	bdaddr_t local, peer;
-	char *addr_ptr;
-	uint8_t length;
-	int len;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	str2ba(adapter->address, &local);
-
-	str2ba(addr_ptr, &peer);
-
-	len = read_pin_length(&local, &peer);
-	if (len < 0)
-		return g_dbus_create_error(msg,
-				ERROR_INTERFACE ".DoesNotExist",
-				"Record does not exist");
-
-	reply = dbus_message_new_method_return(msg);
-
-	length = len;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BYTE, &length,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_get_encryption_key_size(DBusConnection *conn,
-							DBusMessage *msg,
-							void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	bdaddr_t bdaddr;
-	char *addr_ptr;
-	uint8_t size;
-	int val;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &addr_ptr,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(addr_ptr) < 0)
-		return invalid_args(msg);
-
-	str2ba(addr_ptr, &bdaddr);
-
-	val = get_encryption_key_size(adapter->dev_id, &bdaddr);
-	if (val < 0)
-		return failed_strerror(msg, -val);
-
-	reply = dbus_message_new_method_return(msg);
-
-	size = val;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BYTE, &size,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
 static void periodic_discover_req_exit(void *user_data)
 {
 	struct adapter *adapter = user_data;
@@ -3209,70 +1368,6 @@ static DBusMessage *adapter_stop_periodic(DBusConnection *conn,
 	return dbus_message_new_method_return(msg);
 }
 
-static DBusMessage *adapter_is_periodic(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	struct adapter *adapter = data;
-	dbus_bool_t active = adapter->pdiscov_active;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &active,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_set_pdiscov_resolve(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	dbus_bool_t resolve;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_BOOLEAN, &resolve,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	debug("SetPeriodicDiscoveryNameResolving(%s)",
-			resolve ? "TRUE" : "FALSE");
-
-	adapter->pdiscov_resolve_names = resolve;
-
-	if (adapter->pdiscov_active) {
-		if (resolve)
-			adapter->discov_type |= RESOLVE_NAME;
-		else
-			adapter->discov_type &= ~RESOLVE_NAME;
-	}
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_get_pdiscov_resolve(DBusConnection *conn,
-							DBusMessage *msg,
-							void *data)
-{
-	DBusMessage *reply;
-	struct adapter *adapter = data;
-	dbus_bool_t resolve = adapter->pdiscov_resolve_names;
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &resolve,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
 static void discover_devices_req_exit(void *user_data)
 {
 	struct adapter *adapter = user_data;
@@ -3410,300 +1505,6 @@ struct remote_device_list_t {
 	time_t time;
 };
 
-static void list_remote_devices_do_append(char *key, char *value, void *data)
-{
-	struct remote_device_list_t *param = data;
-	char *address;
-	struct tm date;
-
-	if (g_slist_find_custom(param->list, key, (GCompareFunc) strcasecmp))
-		return;
-
-	if (param->time){
-		strptime(value, "%Y-%m-%d %H:%M:%S %Z", &date);
-		if (difftime(mktime(&date), param->time) < 0)
-			return;
-	}
-
-	address = g_strdup(key);
-
-	param->list = g_slist_append(param->list, address);
-}
-
-static void remote_devices_do_append(void *data, void *user_data)
-{
-	DBusMessageIter *iter = user_data;
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data);
-}
-
-static DBusMessage *adapter_list_remote_devices(DBusConnection *conn,
-							DBusMessage *msg,
-							void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	struct remote_device_list_t param = { NULL, 0 };
-
-	if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
-		return invalid_args(msg);
-
-	/* Add Bonded devices to the list */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "linkkeys");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	/* Add Trusted devices to the list */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "trusts");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	/* Add Last Used devices to the list */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "lastused");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-				DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	g_slist_foreach(param.list, remote_devices_do_append, &array_iter);
-
-	g_slist_foreach(param.list, (GFunc) free, NULL);
-	g_slist_free(param.list);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-static void append_connected(struct active_conn_info *dev, GSList *list)
-{
-	char address[18];
-
-	ba2str(&dev->bdaddr, address);
-	if (g_slist_find_custom(list, address, (GCompareFunc) strcasecmp))
-		return;
-
-	list = g_slist_append(list, g_strdup(address));
-}
-
-static DBusMessage *adapter_list_recent_remote_devices(DBusConnection *conn,
-						DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	struct tm date;
-	const char *string;
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	DBusMessage *reply;
-	char filename[PATH_MAX + 1];
-	struct remote_device_list_t param = { NULL, 0 };
-	int len;
-
-	if (!dbus_message_get_args(msg, NULL,
-				DBUS_TYPE_STRING, &string,
-				DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	/* Date format is "YYYY-MM-DD HH:MM:SS GMT" */
-	len = strlen(string);
-	if (len && (strptime(string, "%Y-%m-%d %H:%M:%S", &date) == NULL))
-		return invalid_args(msg);
-
-	/* Bonded and trusted: mandatory entries(no matter the date/time) */
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "linkkeys");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "trusts");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	/* Last seen/used: append devices since the date informed */
-	if (len)
-		param.time = mktime(&date);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "lastseen");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "lastused");
-	textfile_foreach(filename, list_remote_devices_do_append, &param);
-
-	/* connected: force appending connected devices, lastused might not match */
-	g_slist_foreach(adapter->active_conn, (GFunc) append_connected, param.list);
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_iter_init_append(reply, &iter);
-
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-				DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
-	g_slist_foreach(param.list, remote_devices_do_append, &array_iter);
-
-	g_slist_foreach(param.list, (GFunc) free, NULL);
-	g_slist_free(param.list);
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-	return reply;
-}
-
-
-static DBusMessage *adapter_set_trusted(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	bdaddr_t local;
-	const char *address;
-	char *old_path, *new_path;
-
-	if (!dbus_message_get_args(msg, NULL,
-			DBUS_TYPE_STRING, &address,
-			DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	str2ba(adapter->address, &local);
-
-	write_trust(&local, address, GLOBAL_TRUST, TRUE);
-
-	resolve_paths(msg, &old_path, &new_path);
-
-	g_dbus_emit_signal(conn, old_path,
-					ADAPTER_INTERFACE, "TrustAdded",
-					DBUS_TYPE_STRING, &address,
-					DBUS_TYPE_INVALID);
-
-	if (new_path) {
-		struct device *device;
-		gboolean trust = TRUE;
-
-		device = adapter_find_device(adapter, address);
-		if (device) {
-			dbus_connection_emit_property_changed(conn,
-					device->path, DEVICE_INTERFACE,
-					"Trusted", DBUS_TYPE_BOOLEAN, &trust);
-		}
-	}
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_is_trusted(DBusConnection *conn,
-				DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	const char *address;
-	dbus_bool_t trusted;
-	bdaddr_t local;
-
-	if (!dbus_message_get_args(msg, NULL,
-			DBUS_TYPE_STRING, &address,
-			DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	str2ba(adapter->address, &local);
-
-	trusted = read_trust(&local, address, GLOBAL_TRUST);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	dbus_message_append_args(reply,
-				DBUS_TYPE_BOOLEAN, &trusted,
-				DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage *adapter_remove_trust(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	struct adapter *adapter = data;
-	const char *address;
-	bdaddr_t local;
-	char *old_path, *new_path;
-
-	if (!dbus_message_get_args(msg, NULL,
-			DBUS_TYPE_STRING, &address,
-			DBUS_TYPE_INVALID))
-		return invalid_args(msg);
-
-	if (check_address(address) < 0)
-		return invalid_args(msg);
-
-	str2ba(adapter->address, &local);
-
-	write_trust(&local, address, GLOBAL_TRUST, FALSE);
-
-	resolve_paths(msg, &old_path, &new_path);
-
-	g_dbus_emit_signal(conn, old_path,
-					ADAPTER_INTERFACE, "TrustRemoved",
-					DBUS_TYPE_STRING, &address,
-					DBUS_TYPE_INVALID);
-
-	if (new_path) {
-		struct device *device;
-		gboolean trust = FALSE;
-
-		device = adapter_find_device(adapter, address);
-		if (device) {
-			dbus_connection_emit_property_changed(conn,
-					device->path, DEVICE_INTERFACE,
-					"Trusted", DBUS_TYPE_BOOLEAN, &trust);
-		}
-	}
-
-	return dbus_message_new_method_return(msg);
-}
-
-static DBusMessage *adapter_list_trusts(DBusConnection *conn,
-						DBusMessage *msg,
-						void *data)
-{
-	struct adapter *adapter = data;
-	DBusMessage *reply;
-	GSList *trusts, *l;
-	char **addrs;
-	bdaddr_t local;
-	int len;
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
-
-	str2ba(adapter->address, &local);
-
-	trusts = list_trusts(&local, GLOBAL_TRUST);
-
-	addrs = g_new(char *, g_slist_length(trusts));
-
-	for (l = trusts, len = 0; l; l = l->next, len++)
-		addrs[len] = l->data;
-
-	dbus_message_append_args(reply,
-			DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
-			&addrs, len,
-			DBUS_TYPE_INVALID);
-
-	g_free(addrs);
-	g_slist_foreach(trusts, (GFunc) g_free, NULL);
-	g_slist_free(trusts);
-
-	return reply;
-}
-
 static DBusMessage *get_properties(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
@@ -4284,149 +2085,6 @@ static GDBusMethodTable adapter_methods[] = {
 	{ }
 };
 
-/* Deprecated */
-static GDBusMethodTable old_adapter_methods[] = {
-	{ "GetInfo",			"",	"a{sv}",
-						adapter_get_info		},
-	{ "GetAddress",			"",	"s",
-						adapter_get_address		},
-	{ "GetVersion",			"",	"s",
-						adapter_get_version		},
-	{ "GetRevision",		"",	"s",
-						adapter_get_revision		},
-	{ "GetManufacturer",		"",	"s",
-						adapter_get_manufacturer	},
-	{ "GetCompany",			"",	"s",
-						adapter_get_company		},
-	{ "ListAvailableModes",		"",	"as",
-						adapter_list_modes		},
-	{ "GetMode",			"",	"s",
-						adapter_get_mode		},
-	{ "SetMode",			"s",	"",
-						adapter_set_mode		},
-	{ "GetDiscoverableTimeout",	"",	"u",
-						adapter_get_discoverable_to	},
-	{ "SetDiscoverableTimeout",	"u",	"",
-						adapter_set_discoverable_to	},
-	{ "IsConnectable",		"",	"b",
-						adapter_is_connectable		},
-	{ "IsDiscoverable",		"",	"b",
-						adapter_is_discoverable		},
-	{ "IsConnected",		"s",	"b",
-						adapter_is_connected		},
-	{ "ListConnections",		"",	"as",
-						adapter_list_connections	},
-	{ "GetMajorClass",		"",	"s",
-						adapter_get_major_class		},
-	{ "ListAvailableMinorClasses",	"",	"as",
-						adapter_list_minor_classes	},
-	{ "GetMinorClass",		"",	"s",
-						adapter_get_minor_class		},
-	{ "SetMinorClass",		"s",	"",
-						adapter_set_minor_class		},
-	{ "GetServiceClasses",		"",	"as",
-						adapter_get_service_classes	},
-	{ "GetName",			"",	"s",
-						adapter_get_name		},
-	{ "SetName",			"s",	"",
-						adapter_set_name		},
-
-	{ "GetRemoteInfo",			"s",	"a{sv}",
-						adapter_get_remote_info		},
-	{ "GetRemoteServiceRecord",		"su",	"ay",
-		adapter_get_remote_svc,		G_DBUS_METHOD_FLAG_ASYNC	},
-	{ "GetRemoteServiceRecordAsXML",	"su",	"s",
-		adapter_get_remote_svc_xml,	G_DBUS_METHOD_FLAG_ASYNC	},
-	{ "GetRemoteServiceHandles",		"ss",	"au",
-		adapter_get_remote_svc_handles,	G_DBUS_METHOD_FLAG_ASYNC	},
-	{ "GetRemoteServiceIdentifiers",	"s",	"as",
-		adapter_get_remote_svc_identifiers, G_DBUS_METHOD_FLAG_ASYNC	},
-	{ "FinishRemoteServiceTransaction",	"s",	"",
-						adapter_finish_sdp_transact	},
-	{ "GetRemoteVersion",			"s",	"s",
-						adapter_get_remote_version	},
-	{ "GetRemoteRevision",			"s",	"s",
-						adapter_get_remote_revision	},
-	{ "GetRemoteManufacturer",		"s",	"s",
-						adapter_get_remote_manufacturer	},
-	{ "GetRemoteCompany",			"s",	"s",
-						adapter_get_remote_company	},
-	{ "GetRemoteMajorClass",		"s",	"s",
-						adapter_get_remote_major_class	},
-	{ "GetRemoteMinorClass",		"s",	"s",
-						adapter_get_remote_minor_class	},
-	{ "GetRemoteServiceClasses",		"s",	"as",
-						adapter_get_remote_service_cls	},
-	{ "GetRemoteClass",			"s",	"u",
-						adapter_get_remote_class	},
-	{ "GetRemoteFeatures",			"s",	"ay",
-						adapter_get_remote_features	},
-	{ "GetRemoteName",			"s",	"s",
-						adapter_get_remote_name		},
-	{ "GetRemoteAlias",			"s",	"s",
-						adapter_get_remote_alias	},
-	{ "SetRemoteAlias",			"ss",	"",
-						adapter_set_remote_alias	},
-	{ "ClearRemoteAlias",			"s",	"",
-						adapter_clear_remote_alias	},
-
-	{ "LastSeen",		"s",	"s",
-						adapter_last_seen		},
-	{ "LastUsed",		"s",	"s",
-						adapter_last_used		},
-
-	{ "DisconnectRemoteDevice",	"s",	"",
-			adapter_dc_remote_device,	G_DBUS_METHOD_FLAG_ASYNC},
-
-	{ "CreateBonding",		"s",	"",
-			adapter_create_bonding,		G_DBUS_METHOD_FLAG_ASYNC},
-	{ "CancelBondingProcess",	"s",	"",
-						adapter_cancel_bonding		},
-	{ "RemoveBonding",		"s",	"",
-						adapter_remove_bonding		},
-	{ "HasBonding",			"s",	"b",
-						adapter_has_bonding		},
-	{ "ListBondings",		"",	"as",
-						adapter_list_bondings		},
-	{ "GetPinCodeLength",		"s",	"y",
-						adapter_get_pin_code_length	},
-	{ "GetEncryptionKeySize",	"s",	"y",
-						adapter_get_encryption_key_size	},
-
-	{ "StartPeriodicDiscovery",	"",	"",
-						adapter_start_periodic		},
-	{ "StopPeriodicDiscovery",	"",	"",
-						adapter_stop_periodic		},
-	{ "IsPeriodicDiscovery",	"",	"b",
-						adapter_is_periodic		},
-	{ "SetPeriodicDiscoveryNameResolving",	"b",	"",
-						adapter_set_pdiscov_resolve	},
-	{ "GetPeriodicDiscoveryNameResolving",	"",	"b",
-						adapter_get_pdiscov_resolve	},
-	{ "DiscoverDevices",			"",	"",
-						adapter_discover_devices	},
-	{ "CancelDiscovery",			"",	"",
-			adapter_cancel_discovery, G_DBUS_METHOD_FLAG_ASYNC	},
-	{ "DiscoverDevicesWithoutNameResolving","",	"",
-						adapter_discover_devices	},
-	{ "ListRemoteDevices",			"",	"as",
-						adapter_list_remote_devices	},
-	{ "ListRecentRemoteDevices",		"s",	"as",
-						adapter_list_recent_remote_devices},
-
-	{ "SetTrusted",		"s",	"",
-						adapter_set_trusted		},
-	{ "IsTrusted",		"s",	"b",
-						adapter_is_trusted		},
-	{ "RemoveTrust",	"s",	"",
-						adapter_remove_trust		},
-	{ "ListTrusts",		"",	"as",
-						adapter_list_trusts		},
-
-	{ }
-};
-
-/* BlueZ 4.X */
 static GDBusSignalTable adapter_signals[] = {
 	{ "DiscoveryStarted",		""		},
 	{ "DiscoveryCompleted",		""		},
@@ -4438,47 +2096,12 @@ static GDBusSignalTable adapter_signals[] = {
 	{ }
 };
 
-/* Deprecated */
-static GDBusSignalTable old_adapter_signals[] = {
-	{ "DiscoveryStarted",			""	},
-	{ "DiscoveryCompleted",			""	},
-	{ "ModeChanged",			"s"	},
-	{ "DiscoverableTimeoutChanged",		"u"	},
-	{ "MinorClassChanged",			"s"	},
-	{ "NameChanged",			"s"	},
-	{ "PeriodicDiscoveryStarted",		""	},
-	{ "PeriodicDiscoveryStopped",		""	},
-	{ "RemoteDeviceFound",			"sun"	},
-	{ "RemoteDeviceDisappeared",		"s"	},
-	{ "RemoteClassUpdated",			"su"	},
-	{ "RemoteNameUpdated",			"ss"	},
-	{ "RemoteNameFailed",			"s"	},
-	{ "RemoteNameRequested",		"s"	},
-	{ "RemoteAliasChanged",			"ss"	},
-	{ "RemoteAliasCleared",			"s"	},
-	{ "RemoteDeviceConnected",		"s"	},
-	{ "RemoteDeviceDisconnectRequested",	"s"	},
-	{ "RemoteDeviceDisconnected",		"s"	},
-	{ "RemoteIdentifiersUpdated",		"sas"	},
-	{ "BondingCreated",			"s"	},
-	{ "BondingRemoved",			"s"	},
-	{ "TrustAdded",				"s"	},
-	{ "TrustRemoved",			"s"	},
-	{ }
-};
-
 dbus_bool_t adapter_init(DBusConnection *conn,
 		const char *path, struct adapter *adapter)
 {
-	if (hcid_dbus_use_experimental())
-		g_dbus_register_interface(conn, path + ADAPTER_PATH_INDEX,
-				ADAPTER_INTERFACE, adapter_methods,
-				adapter_signals, NULL, adapter, NULL);
-
-	return g_dbus_register_interface(conn,
-			path, ADAPTER_INTERFACE,
-			old_adapter_methods, old_adapter_signals,
-			NULL, adapter, NULL);
+	return g_dbus_register_interface(conn, path + ADAPTER_PATH_INDEX,
+			ADAPTER_INTERFACE, adapter_methods,
+			adapter_signals, NULL, adapter, NULL);
 }
 
 dbus_bool_t adapter_cleanup(DBusConnection *conn, const char *path)