added signature verification and code cleanup

3 files changed, 298 insertions, 175 deletions

diff --git a/hcid/dbus-adapter.c b/hcid/dbus-adapter.c
index fffb6fd4..ebc532dc 100644
--- a/hcid/dbus-adapter.c
+++ b/hcid/dbus-adapter.c
@@ -96,35 +96,20 @@ int find_connection_handle(int dd, bdaddr_t *peer)
 	return handle;
 }
 
-static int bonding_requests_find(const void *a, const void *b)
+static int bonding_requests_append(struct slist **list, bdaddr_t *bdaddr, DBusMessage *msg, bonding_state_t bonding_state)
 {
-	const struct bonding_request_info *dev = a;
-	const bdaddr_t *peer = b;
+	struct bonding_request_info *dev;
 
+	dev = malloc(sizeof(*dev));
 	if (!dev)
 		return -1;
 
-	if (memcmp(dev->addr, peer, sizeof(*peer)) == 0) {
-		return 0;
-	}
-
-	return -1;
-}
-
-static int bonding_requests_append(struct slist **list, bdaddr_t *addr, DBusMessage *msg, bonding_state_t bonding_state)
-{
-	struct bonding_request_info *data;
-
-	data = malloc(sizeof(*data));
-	if (!data)
-		return -1;
-
-	data->addr = malloc(sizeof(*data->addr));
-	memcpy(data->addr, addr, sizeof(*data->addr));
-	data->msg = msg;
-	data->bonding_state = bonding_state;
+	dev->bdaddr = malloc(sizeof(*dev->bdaddr));
+	memcpy(dev->bdaddr, bdaddr, sizeof(*dev->bdaddr));
+	dev->msg = msg;
+	dev->bonding_state = bonding_state;
 
-	*list = slist_append(*list, data);
+	*list = slist_append(*list, dev);
 
 	return 0;
 }
@@ -272,13 +257,22 @@ static DBusHandlerResult handle_dev_set_mode_req(DBusConnection *conn, DBusMessa
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
+	DBusError err;
 	const char* scan_mode;
 	uint8_t hci_mode;
 	const uint8_t current_mode = dbus_data->mode;
 	int dd;
 
-	dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &scan_mode,
-							DBUS_TYPE_INVALID);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &scan_mode,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	if (!scan_mode)
 		return error_invalid_arguments(conn, msg);
@@ -351,11 +345,19 @@ static DBusHandlerResult handle_dev_set_discoverable_to_req(DBusConnection *conn
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
-	DBusMessageIter iter;
+	DBusError err;
 	uint32_t timeout;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &timeout);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_UINT32, &timeout,
+				DBUS_TYPE_INVALID);
+ 
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	dbus_data->discoverable_timeout = timeout;
 
@@ -525,16 +527,24 @@ static DBusHandlerResult handle_dev_set_minor_class_req(DBusConnection *conn, DB
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
-	DBusMessageIter iter;
 	DBusMessage *reply, *signal;
+	DBusError err;
 	bdaddr_t bdaddr;
 	const char *minor;
 	uint8_t cls[3];
 	uint32_t dev_class = 0xFFFFFFFF;
 	int i, dd;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &minor);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &minor,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	if (!minor)
 		return error_invalid_arguments(conn, msg);
@@ -662,14 +672,22 @@ static DBusHandlerResult handle_dev_get_name_req(DBusConnection *conn, DBusMessa
 static DBusHandlerResult handle_dev_set_name_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	bdaddr_t bdaddr;
 	char *str_ptr;
-	int err;
+	int ecode;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &str_ptr);
+	dbus_error_init(&err);	
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &str_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	if (strlen(str_ptr) == 0) {
 		error("Name change failed: Invalid parameter");
@@ -680,9 +698,9 @@ static DBusHandlerResult handle_dev_set_name_req(DBusConnection *conn, DBusMessa
 
 	write_local_name(&bdaddr, str_ptr);
 
-	err = set_device_name(dbus_data->dev_id, str_ptr);
-	if (err < 0)
-		return error_failed(conn, msg, -err);
+	ecode = set_device_name(dbus_data->dev_id, str_ptr);
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
@@ -704,18 +722,29 @@ static DBusHandlerResult handle_dev_get_remote_revision_req(DBusConnection *conn
 static DBusHandlerResult handle_dev_get_remote_manufacturer_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	char filename[PATH_MAX + 1];
 	char addr[18], *addr_ptr, *str;
 	int compid;
+	int ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/manufacturers", STORAGEDIR, addr);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
@@ -740,12 +769,20 @@ static DBusHandlerResult handle_dev_get_remote_manufacturer_req(DBusConnection *
 static DBusHandlerResult handle_dev_get_remote_company_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
+	DBusError err;
 	bdaddr_t bdaddr;
 	char oui[9], *str_bdaddr, *tmp;
 
-	dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
-							DBUS_TYPE_INVALID);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &str_bdaddr,
+				DBUS_TYPE_INVALID);
 
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str2ba(str_bdaddr, &bdaddr);
 	ba2oui(&bdaddr, oui);
@@ -773,16 +810,25 @@ static DBusHandlerResult handle_dev_get_remote_name_req(DBusConnection *conn, DB
 	char filename[PATH_MAX + 1], addr[18];
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply = NULL;
+	DBusError err;
 	const char *str_bdaddr;
 	char *name;
-	int err;
+	int ecode;
 
-	dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
-							DBUS_TYPE_INVALID);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &str_bdaddr,
+				DBUS_TYPE_INVALID);
 
-	err = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-	if (err < 0)
-		return error_failed(conn, msg, -err);
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
+
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode< 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
 
@@ -808,20 +854,28 @@ static DBusHandlerResult handle_dev_get_remote_name_req(DBusConnection *conn, DB
 static DBusHandlerResult handle_dev_get_remote_alias_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	char str[249], *str_ptr = str, *addr_ptr;
 	bdaddr_t bdaddr;
-	int err;
+	int ecode;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str2ba(addr_ptr, &bdaddr);
 
-	err = get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
-	if (err < 0)
-		return error_failed(conn, msg, -err);
+	ecode = get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
@@ -837,16 +891,23 @@ static DBusHandlerResult handle_dev_set_remote_alias_req(DBusConnection *conn, D
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
-	DBusMessageIter iter;
 	DBusMessage *reply, *signal;
+	DBusError err;
 	char *str_ptr, *addr_ptr;
 	bdaddr_t bdaddr;
-	int err;
+	int ecode;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
-	dbus_message_iter_next(&iter);
-	dbus_message_iter_get_basic(&iter, &str_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_STRING, &str_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	if (strlen(str_ptr) == 0) {
 		error("Alias change failed: Invalid parameter");
@@ -855,9 +916,9 @@ static DBusHandlerResult handle_dev_set_remote_alias_req(DBusConnection *conn, D
 
 	str2ba(addr_ptr, &bdaddr);
 
-	err = set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
-	if (err < 0)
-		return error_failed(conn, msg, -err);
+	ecode = set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	signal = dev_signal_factory(dbus_data->dev_id, "RemoteAliasChanged",
 						DBUS_TYPE_STRING, &addr_ptr,
@@ -879,17 +940,28 @@ static DBusHandlerResult handle_dev_set_remote_alias_req(DBusConnection *conn, D
 static DBusHandlerResult handle_dev_last_seen_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	char filename[PATH_MAX + 1];
 	char addr[18], *addr_ptr, *str;
+	int ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/lastseen", STORAGEDIR, addr);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
@@ -912,17 +984,28 @@ static DBusHandlerResult handle_dev_last_seen_req(DBusConnection *conn, DBusMess
 static DBusHandlerResult handle_dev_last_used_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	char filename[PATH_MAX + 1];
 	char addr[18], *addr_ptr, *str;
+	int ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/lastused", STORAGEDIR, addr);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
@@ -952,9 +1035,9 @@ static DBusHandlerResult handle_dev_create_bonding_req(DBusConnection *conn, DBu
 	char *peer_addr;
 	char *str;
 	struct hci_dbus_data *dbus_data = data;
-	struct slist *tmp_list;
+	struct slist *l;
 	bdaddr_t peer_bdaddr;
-	int dd, handle;
+	int dd, handle, ecode;
 	bonding_state_t bonding_state;
 
 	dbus_error_init(&err);
@@ -971,12 +1054,14 @@ static DBusHandlerResult handle_dev_create_bonding_req(DBusConnection *conn, DBu
 	str2ba(peer_addr, &peer_bdaddr);
 	
 	/* check if there is a pending bonding request */
-	tmp_list = slist_find(dbus_data->bonding_requests, &peer_bdaddr, bonding_requests_find);
+	l = slist_find(dbus_data->bonding_requests, &peer_bdaddr, bonding_requests_find);
 
-	if (tmp_list)
+	if (l)
 		return error_bonding_in_progress(conn, msg);
 
-	get_device_address(dbus_data->dev_id, local_addr, sizeof(local_addr));
+	ecode = get_device_address(dbus_data->dev_id, local_addr, sizeof(local_addr));
+	if (ecode < 0) /* FIXME: remove the peer bdaddr from the list */
+		return error_failed(conn, msg, -ecode);
 
 	/* check if a link key already exists */
 	snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, local_addr);
@@ -1069,9 +1154,9 @@ static DBusHandlerResult handle_dev_remove_bonding_req(DBusConnection *conn, DBu
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
-	DBusMessageIter iter;
 	DBusMessage *reply;
 	DBusMessage *signal;
+	DBusError err;
 	char filename[PATH_MAX + 1];
 	char addr[18], *addr_ptr;
 	struct hci_conn_info_req *cr;
@@ -1086,8 +1171,16 @@ static DBusHandlerResult handle_dev_remove_bonding_req(DBusConnection *conn, DBu
 
 	snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	/* Delete the link key from storage */
 	textfile_del(filename, addr_ptr);
@@ -1144,18 +1237,29 @@ static DBusHandlerResult handle_dev_remove_bonding_req(DBusConnection *conn, DBu
 static DBusHandlerResult handle_dev_has_bonding_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	char filename[PATH_MAX + 1];
 	char addr[18], *addr_ptr, *str;
 	dbus_bool_t result;
+	int ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str = textfile_get(filename, addr_ptr);
 	if (str) {
@@ -1187,8 +1291,11 @@ static DBusHandlerResult handle_dev_list_bondings_req(DBusConnection *conn, DBus
 	DBusMessage *reply;
 	char filename[PATH_MAX + 1];
 	char addr[18];
+	int ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
 
@@ -1209,19 +1316,29 @@ static DBusHandlerResult handle_dev_list_bondings_req(DBusConnection *conn, DBus
 static DBusHandlerResult handle_dev_get_pin_code_length_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	bdaddr_t local, peer;
 	char addr[18], *addr_ptr;
 	uint8_t length;
-	int len;
+	int len, ecode;
 
-	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	ecode = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+	if (ecode < 0)
+		return error_failed(conn, msg, -ecode);
 
 	str2ba(addr, &local);
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str2ba(addr_ptr, &peer);
 
@@ -1242,15 +1359,23 @@ static DBusHandlerResult handle_dev_get_pin_code_length_req(DBusConnection *conn
 static DBusHandlerResult handle_dev_get_encryption_key_size_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
 	DBusMessage *reply;
+	DBusError err;
 	bdaddr_t bdaddr;
 	char *addr_ptr;
 	uint8_t size;
 	int val;
 
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
+	dbus_error_init(&err);
+	dbus_message_get_args(msg, &err,
+				DBUS_TYPE_STRING, &addr_ptr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&err)) {
+		error("Can't extract message arguments:%s", err.message);
+		dbus_error_free(&err);
+		return error_invalid_arguments(conn, msg);
+	}
 
 	str2ba(addr_ptr, &bdaddr);
 
diff --git a/hcid/dbus.c b/hcid/dbus.c
index 64f0ad18..31ca507c 100644
--- a/hcid/dbus.c
+++ b/hcid/dbus.c
@@ -105,27 +105,39 @@ static const char *phone_minor_cls[] = {
 void discovered_device_free(void *data, void *user_data)
 {
 	struct discovered_dev_info *dev = data;
+
 	if (dev) {
-		free(dev->addr);
+		free(dev->bdaddr);
 		free(dev);
 	}
 }
 
-int remote_name_find_by_address(const void *a, const void *b)
+int bonding_requests_find(const void *data, const void *user_data)
+{
+	const struct bonding_request_info *dev = data;
+	const bdaddr_t *bdaddr = user_data;
+
+	if (memcmp(dev->bdaddr, bdaddr, sizeof(*bdaddr)) == 0)
+		return 0;
+
+	return -1;
+}
+
+int remote_name_find_by_bdaddr(const void *data, const void *user_data)
 {
-	const struct discovered_dev_info *dev = a;
-	const bdaddr_t *addr = b;
+	const struct discovered_dev_info *dev = data;
+	const bdaddr_t *baddr = user_data;
 
-	if (memcmp(dev->addr, addr, sizeof(*addr)) == 0)
+	if (memcmp(dev->bdaddr, baddr, sizeof(*baddr)) == 0)
 		return 0;
 
 	return -1;
 }
 
-int remote_name_find_by_name_status(const void *a, const void *b)
+int remote_name_find_by_name_status(const void *data, const void *user_data)
 {
-	const struct discovered_dev_info *dev = a;
-	const name_status_t *name_status = b;
+	const struct discovered_dev_info *dev = data;
+	const name_status_t *name_status = user_data;
 
 	if (dev->name_status == *name_status)
 		return 0;
@@ -133,67 +145,53 @@ int remote_name_find_by_name_status(const void *a, const void *b)
 	return -1;
 }
 
-static int remote_name_append(struct slist **list, bdaddr_t *addr, name_status_t name_status)
+static int remote_name_append(struct slist **list, bdaddr_t *bdaddr, name_status_t name_status)
 {
-	struct discovered_dev_info *data = NULL;
-	struct slist *tmp_list;
+	struct discovered_dev_info *dev = NULL;
+	struct slist *l;
 
 	/* ignore repeated entries */
-	tmp_list = slist_find(*list, addr, remote_name_find_by_address);
+	l = slist_find(*list, bdaddr, remote_name_find_by_bdaddr);
 
-	if (tmp_list) {
+	if (l) {
 		/* device found, update the attributes */
-		data = tmp_list->data;
-		data->name_status = name_status;
+		dev = l->data;
+		dev->name_status = name_status;
 		return -1;
 	}
 
-	data = malloc(sizeof(*data));
-	if (!data)
+	dev = malloc(sizeof(*dev));
+	if (!dev)
 		return -1;
 
-	data->addr = malloc(sizeof(*data->addr));
-	memcpy(data->addr, addr, sizeof(*data->addr));
-	data->name_status = name_status;
+	dev->bdaddr = malloc(sizeof(*dev->bdaddr));
+	memcpy(dev->bdaddr, bdaddr, sizeof(*dev->bdaddr));
+	dev->name_status = name_status;
 
-	*list = slist_append(*list, data);
+	*list = slist_append(*list, dev);
 
 	return 0;
 }
 
-static int remote_name_remove(struct slist **list, bdaddr_t *addr)
+static int remote_name_remove(struct slist **list, bdaddr_t *bdaddr)
 {
-	struct discovered_dev_info *data;
-	struct slist *tmp_list;
+	struct discovered_dev_info *dev;
+	struct slist *l;
 	int ret_val = -1;
 
-	tmp_list = slist_find(*list, addr, remote_name_find_by_address);
+	l = slist_find(*list, bdaddr, remote_name_find_by_bdaddr);
 
-	if (tmp_list) {
-		data = tmp_list->data;
-		*list = slist_remove(*list, data);
-		free(data->addr);
-		free(data);
+	if (l) {
+		dev = l->data;
+		*list = slist_remove(*list, dev);
+		free(dev->bdaddr);
+		free(dev);
 		ret_val = 0;
 	}
 
 	return ret_val;
 }
 
-static int bonding_requests_find(const void *a, const void *b)
-{
-	const struct bonding_request_info *dev = a;
-	const bdaddr_t *peer = b;
-
-	if (!dev)
-		return -1;
-
-	if (memcmp(dev->addr, peer, sizeof(*peer)) == 0)
-		return 0;
-
-	return -1;
-}
-
 static DBusMessage *dbus_msg_new_authentication_return(DBusMessage *msg, uint8_t status)
 {
 
@@ -284,7 +282,7 @@ DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const in
 
 	signal = dbus_message_new_signal(path, ADAPTER_INTERFACE, prop_name);
 	if (!signal) {
-		error("Can't allocate D-BUS inquiry complete message");
+		error("Can't allocate D-BUS message");
 		return NULL;
 	}
 
@@ -439,7 +437,7 @@ gboolean hcid_dbus_register_device(uint16_t id)
 	message = dbus_message_new_signal(MANAGER_PATH, MANAGER_INTERFACE,
 							"AdapterAdded");
 	if (message == NULL) {
-		error("Can't allocate D-BUS remote name message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -449,7 +447,7 @@ gboolean hcid_dbus_register_device(uint16_t id)
 					DBUS_TYPE_INVALID);
 
 	if (!dbus_connection_send(connection, message, NULL)) {
-		error("Can't send D-BUS added device message");
+		error("Can't send D-BUS adapter added message");
 		goto failed;
 	}
 
@@ -480,7 +478,7 @@ gboolean hcid_dbus_unregister_device(uint16_t id)
 	message = dbus_message_new_signal(MANAGER_PATH, MANAGER_INTERFACE,
 							"AdapterRemoved");
 	if (message == NULL) {
-		error("Can't allocate D-Bus remote name message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -550,7 +548,7 @@ void hcid_dbus_bonding_created_complete(bdaddr_t *local, bdaddr_t *peer, const u
 	msg_signal = dbus_message_new_signal(path, ADAPTER_INTERFACE, name);
 
 	if (msg_signal == NULL) {
-		error("Can't allocate D-Bus remote name message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -582,7 +580,7 @@ void hcid_dbus_bonding_created_complete(bdaddr_t *local, bdaddr_t *peer, const u
 
 			dbus_message_unref(dev->msg);
 			pdata->bonding_requests = slist_remove(pdata->bonding_requests, dev);
-			free(dev->addr);
+			free(dev->bdaddr);
 			free(dev);
 		}
 	}
@@ -619,7 +617,7 @@ void hcid_dbus_inquiry_start(bdaddr_t *local)
 	message = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"DiscoveryStarted");
 	if (message == NULL) {
-		error("Can't allocate D-Bus inquiry start message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -637,8 +635,8 @@ failed:
 
 static inline int remote_name_resolve(struct hci_dbus_data *dbus_data)
 {
-	struct discovered_dev_info *data;
-	struct slist *tmp_list = NULL;
+	struct discovered_dev_info *dev;
+	struct slist *l = NULL;
 	remote_name_req_cp cp;
 	int dd;
 	name_status_t name_status = NAME_PENDING;
@@ -647,13 +645,13 @@ static inline int remote_name_resolve(struct hci_dbus_data *dbus_data)
 	if (!dbus_data->discovered_devices)
 		return -1;
 
-	tmp_list = slist_find(dbus_data->discovered_devices, &name_status, remote_name_find_by_name_status);
+	l = slist_find(dbus_data->discovered_devices, &name_status, remote_name_find_by_name_status);
 
-	if (!tmp_list)
+	if (!l)
 		return -1;
 
-	data = tmp_list->data;
-	if (!data)
+	dev = l->data;
+	if (!dev)
 		return -1;
 
 	dd = hci_open_dev(dbus_data->dev_id);
@@ -661,7 +659,7 @@ static inline int remote_name_resolve(struct hci_dbus_data *dbus_data)
 		return -1;
 
 	memset(&cp, 0, sizeof(cp));
-	bacpy(&cp.bdaddr, data->addr);
+	bacpy(&cp.bdaddr, dev->bdaddr);
 	cp.pscan_rep_mode = 0x02;
 
 	hci_send_cmd(dd, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ,
@@ -717,7 +715,7 @@ void hcid_dbus_inquiry_complete(bdaddr_t *local)
 	message = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"DiscoveryCompleted");
 	if (message == NULL) {
-		error("Can't allocate D-Bus inquiry complete message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -743,7 +741,7 @@ void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, i
 	DBusMessageIter array_iter;
 	char path[MAX_PATH_LENGTH];
 	struct hci_dbus_data *pdata = NULL;
-	struct slist *list = NULL;
+	struct slist *l = NULL;
 	struct discovered_dev_info *dev;
 	char *local_addr, *peer_addr, *name = NULL;
 	const char *major_ptr;
@@ -775,7 +773,7 @@ void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, i
 	signal_device = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"RemoteDeviceFound");
 	if (signal_device == NULL) {
-		error("Can't allocate D-Bus inquiry result message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -815,15 +813,15 @@ void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, i
 	dbus_message_iter_close_container(&iter, &array_iter);
 
 	if (dbus_connection_send(connection, signal_device, NULL) == FALSE) {
-		error("Can't send D-Bus inquiry result message");
+		error("Can't send D-Bus remote device found signal");
 		goto failed;
 	}
 
 	/* send the remote name signal */
-	list = slist_find(pdata->discovered_devices, peer, remote_name_find_by_address);
+	l = slist_find(pdata->discovered_devices, peer, remote_name_find_by_bdaddr);
 
-	if (list) {
-		dev = list->data;
+	if (l) {
+		dev = l->data;
 		if (dev->name_status == NAME_SENT)
 			goto failed; /* don't sent the name again */
 	}
@@ -831,7 +829,7 @@ void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, i
 	signal_name = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"RemoteNameUpdated");
 	if (signal_name == NULL) {
-		error("Can't allocate D-Bus inquiry result message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -846,7 +844,7 @@ void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, i
 					 DBUS_TYPE_INVALID);
 
 		if (dbus_connection_send(connection, signal_name, NULL) == FALSE)
-			error("Can't send D-Bus inquiry result message");
+			error("Can't send D-Bus remote name updated signal");
 
 		name_status = NAME_SENT;
 	}
@@ -904,7 +902,7 @@ void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, char
 	message = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"RemoteNameUpdated");
 	if (message == NULL) {
-		error("Can't allocate D-Bus remote name message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -914,7 +912,7 @@ void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, char
 					DBUS_TYPE_INVALID);
 
 	if (dbus_connection_send(connection, message, NULL) == FALSE) {
-		error("Can't send D-Bus remote name message");
+		error("Can't send D-Bus remote name updated signal");
 		goto failed;
 	}
 
@@ -938,12 +936,12 @@ request_next:
 	message = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"DiscoveryCompleted");
 	if (message == NULL) {
-		error("Can't allocate D-Bus inquiry complete message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
 	if (dbus_connection_send(connection, message, NULL) == FALSE) {
-		error("Can't send D-Bus inquiry complete message");
+		error("Can't send D-Bus discovery completed signal");
 		goto failed;
 	}
 
@@ -973,7 +971,7 @@ void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, b
 	struct bonding_request_info *dev = NULL;
 	char *local_addr, *peer_addr;
 	bdaddr_t tmp;
-	int dd, id;
+	int dd = -1, id;
 
 	baswap(&tmp, local); local_addr = batostr(&tmp);
 	baswap(&tmp, peer); peer_addr = batostr(&tmp);
@@ -1052,7 +1050,7 @@ failed:
 		if (dev->bonding_state != PAIRING) {
 			dbus_message_unref(dev->msg);
 			pdata->bonding_requests = slist_remove(pdata->bonding_requests, dev);
-			free(dev->addr);
+			free(dev->bdaddr);
 			free(dev);
 		}
 	}
@@ -1296,7 +1294,7 @@ static void system_bus_reconnect(void)
 
 	if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) {
 		info("Can't get device list: %s (%d)",
-							strerror(errno), errno);
+			strerror(errno), errno);
 		goto failed;
 	}
 
@@ -1483,7 +1481,7 @@ void hcid_dbus_setname_complete(bdaddr_t *local)
 	signal = dev_signal_factory(id, "NameChanged",
 				DBUS_TYPE_STRING, &pname, DBUS_TYPE_INVALID);
 	if (dbus_connection_send(connection, signal, NULL) == FALSE) {
-		error("Can't send D-Bus signal");
+		error("Can't send D-Bus name changed signal");
 		goto failed;
 	}
 
@@ -1577,7 +1575,7 @@ void hcid_dbus_setscan_enable_complete(bdaddr_t *local)
 	message = dbus_message_new_signal(path, ADAPTER_INTERFACE,
 						"ModeChanged");
 	if (message == NULL) {
-		error("Can't allocate D-Bus inquiry complete message");
+		error("Can't allocate D-Bus message");
 		goto failed;
 	}
 
@@ -1586,7 +1584,7 @@ void hcid_dbus_setscan_enable_complete(bdaddr_t *local)
 					DBUS_TYPE_INVALID);
 
 	if (dbus_connection_send(connection, message, NULL) == FALSE) {
-		error("Can't send D-Bus ModeChanged signal");
+		error("Can't send D-Bus mode changed signal");
 		goto failed;
 	}
 
diff --git a/hcid/dbus.h b/hcid/dbus.h
index 71d436b8..98d89658 100644
--- a/hcid/dbus.h
+++ b/hcid/dbus.h
@@ -85,7 +85,7 @@ typedef enum {
 }name_status_t;
 
 struct discovered_dev_info {
-	bdaddr_t *addr;
+	bdaddr_t *bdaddr;
 	name_status_t name_status;
 };
 
@@ -95,7 +95,7 @@ typedef enum {
 } bonding_state_t;
 
 struct bonding_request_info {
-	bdaddr_t *addr;
+	bdaddr_t *bdaddr;
 	DBusMessage *msg;
 	bonding_state_t bonding_state;
 };
@@ -184,7 +184,7 @@ static inline DBusHandlerResult send_reply_and_unref(DBusConnection *conn, DBusM
 }
 
 void discovered_device_free(void *data, void *user_data);
-
+int bonding_requests_find(const void *data, const void *user_data);
 /*
  * Scanning modes, used by DEV_SET_MODE
  * off: remote devices are not allowed to find or connect to this device