Try unbreak to break everything

6 files changed, 298 insertions, 286 deletions

diff --git a/hcid/dbus-adapter.c b/hcid/dbus-adapter.c
index e1627a6e..2da2ae78 100644
--- a/hcid/dbus-adapter.c
+++ b/hcid/dbus-adapter.c
@@ -72,7 +72,7 @@ static const char *phone_minor_cls[] = {
 	"isdn"
 };
 
-static DBusMessage *handle_dev_get_address_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_address_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -81,19 +81,19 @@ static DBusMessage *handle_dev_get_address_req(DBusMessage *msg, void *data)
 
 	err = get_device_address(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_version_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_version_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -102,19 +102,19 @@ static DBusMessage *handle_dev_get_version_req(DBusMessage *msg, void *data)
 
 	err = get_device_version(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_revision_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_revision_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -123,19 +123,19 @@ static DBusMessage *handle_dev_get_revision_req(DBusMessage *msg, void *data)
 
 	err = get_device_revision(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_manufacturer_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_manufacturer_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -144,19 +144,19 @@ static DBusMessage *handle_dev_get_manufacturer_req(DBusMessage *msg, void *data
 
 	err = get_device_manufacturer(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_company_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_company_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -165,19 +165,19 @@ static DBusMessage *handle_dev_get_company_req(DBusMessage *msg, void *data)
 
 	err = get_device_company(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_features_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_features_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	DBusMessageIter iter;
@@ -185,7 +185,7 @@ static DBusMessage *handle_dev_get_features_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_iter_init_append(reply, &iter);
 
@@ -194,10 +194,10 @@ static DBusMessage *handle_dev_get_features_req(DBusMessage *msg, void *data)
 
 	dbus_message_iter_close_container(&iter, &array_iter);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_mode_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_mode_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply = NULL;
@@ -223,15 +223,15 @@ static DBusMessage *handle_dev_get_mode_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &scan_mode,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_list_minor_classes_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_list_minor_classes_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply = NULL;
@@ -244,15 +244,17 @@ static DBusMessage *handle_dev_list_minor_classes_req(DBusMessage *msg, void *da
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
 		error("Can't read class of device on hci%d: %s(%d)",
 				dbus_data->dev_id, strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
+	hci_close_dev(dd);
+
 	major_class = cls[1] & 0x1F;
 
 	switch (major_class) {
@@ -265,13 +267,12 @@ static DBusMessage *handle_dev_list_minor_classes_req(DBusMessage *msg, void *da
 		size = sizeof(phone_minor_cls) / sizeof(*phone_minor_cls);
 		break;
 	default:
-		reply = error_unsupported_major_class(msg);
-		goto failed;
+		return error_unsupported_major_class(conn, msg);
 	}
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_iter_init_append(reply, &iter);
 	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
@@ -281,13 +282,10 @@ static DBusMessage *handle_dev_list_minor_classes_req(DBusMessage *msg, void *da
 
 	dbus_message_iter_close_container(&iter, &array_iter);
 
-failed:
-	hci_close_dev(dd);
-
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_set_mode_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -300,7 +298,7 @@ static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
 							DBUS_TYPE_INVALID);
 
 	if (!scan_mode)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 
 	if (strcasecmp(MODE_OFF, scan_mode) == 0)
 		hci_mode = SCAN_DISABLED;
@@ -309,11 +307,11 @@ static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
 	else if (strcasecmp(MODE_DISCOVERABLE, scan_mode) == 0)
 		hci_mode = (SCAN_PAGE | SCAN_INQUIRY);
 	else
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	/* Check if the new requested mode is different from the current */
 	if (current_mode != hci_mode) {
@@ -332,13 +330,13 @@ static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
 			error("Sending write scan enable command failed: %s (%d)",
 							strerror(errno), errno);
 			hci_close_dev(dd);
-			return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+			return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 		}
 
 		if (status) {
 			error("Setting scan enable failed with status 0x%02x", status);
 			hci_close_dev(dd);
-			return bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
+			return bluez_new_failure_msg(conn, msg, BLUEZ_EBT_OFFSET | status);
 		}
 	}
 
@@ -346,27 +344,27 @@ static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_discoverable_to_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_UINT32, &dbus_data->discoverable_timeout,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_set_discoverable_to_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -380,12 +378,12 @@ static DBusMessage *handle_dev_set_discoverable_to_req(DBusMessage *msg, void *d
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_is_connectable_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_is_connectable_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -397,15 +395,15 @@ static DBusMessage *handle_dev_is_connectable_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connectable,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_is_discoverable_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	const struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -417,31 +415,31 @@ static DBusMessage *handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &discoverable,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_major_class_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_major_class_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	const char *str_ptr = "computer";
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	/*FIXME: Check the real device major class */
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_minor_class_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_minor_class_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -452,20 +450,20 @@ static DBusMessage *handle_dev_get_minor_class_req(DBusMessage *msg, void *data)
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
 		error("Can't read class of device on hci%d: %s(%d)",
 				dbus_data->dev_id, strerror(errno), errno);
 		hci_close_dev(dd);
-		return error_failed(msg, -errno);
+		return error_failed(conn, msg, -errno);
 	}
 
 	hci_close_dev(dd);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	/* FIXME: Currently, only computer major class is supported */
 	if ((cls[1] & 0x1f) != 1)
@@ -483,10 +481,10 @@ failed:
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_set_minor_class_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
@@ -502,7 +500,7 @@ static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
 	dbus_message_iter_get_basic(&iter, &minor);
 
 	if (!minor)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 
 	/* FIXME: currently, only computer minor classes are allowed */
 	for (i = 0; i < sizeof(computer_minor_cls) / sizeof(*computer_minor_cls); i++)
@@ -514,17 +512,17 @@ static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
 
 	/* Check if it's a valid minor class */
 	if (dev_class == 0xFFFFFFFF)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
 		error("Can't read class of device on hci%d: %s(%d)",
 				dbus_data->dev_id, strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	dev_class |= (cls[2] << 16) | (cls[1] << 8);
@@ -540,8 +538,8 @@ static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
 	if (hci_write_class_of_dev(dd, dev_class, 2000) < 0) {
 		error("Can't write class of device on hci%d: %s(%d)",
 				dbus_data->dev_id, strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_MINOR_CLASS_CHANGED,
@@ -555,13 +553,12 @@ static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 
-failed:
 	hci_close_dev(dd);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_service_classes_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_service_classes_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -573,13 +570,13 @@ static DBusMessage *handle_dev_get_service_classes_req(DBusMessage *msg, void *d
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
 		error("Can't read class of device on hci%d: %s(%d)",
 				dbus_data->dev_id, strerror(errno), errno);
 		hci_close_dev(dd);
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	reply = dbus_message_new_method_return(msg);
@@ -601,10 +598,10 @@ static DBusMessage *handle_dev_get_service_classes_req(DBusMessage *msg, void *d
 
 	hci_close_dev(dd);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_name_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_name_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessage *reply;
@@ -613,19 +610,19 @@ static DBusMessage *handle_dev_get_name_req(DBusMessage *msg, void *data)
 
 	err = get_device_name(dbus_data->dev_id, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_set_name_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_set_name_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -639,7 +636,7 @@ static DBusMessage *handle_dev_set_name_req(DBusMessage *msg, void *data)
 
 	if (strlen(str_ptr) == 0) {
 		error("Name change failed: Invalid parameter");
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 	}
 
 	hci_devba(dbus_data->dev_id, &bdaddr);
@@ -648,28 +645,28 @@ static DBusMessage *handle_dev_set_name_req(DBusMessage *msg, void *data)
 
 	err = set_device_name(dbus_data->dev_id, str_ptr);
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_remote_version_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_version_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+	return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
 }
 
-static DBusMessage *handle_dev_get_remote_revision_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_revision_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+	return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
 }
 
-static DBusMessage *handle_dev_get_remote_manufacturer_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_manufacturer_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -687,7 +684,7 @@ static DBusMessage *handle_dev_get_remote_manufacturer_req(DBusMessage *msg, voi
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
 
 	compid = atoi(str);
 
@@ -697,15 +694,15 @@ static DBusMessage *handle_dev_get_remote_manufacturer_req(DBusMessage *msg, voi
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_remote_company_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_company_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	bdaddr_t bdaddr;
@@ -720,24 +717,23 @@ static DBusMessage *handle_dev_get_remote_company_req(DBusMessage *msg, void *da
 
 	tmp = ouitocomp(oui);
 	if (!tmp)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply) {
-		reply = error_out_of_memory(msg);
-		goto done;
+		free(tmp);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &tmp,
 					DBUS_TYPE_INVALID);
 
-done:
 	free(tmp);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_remote_name_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_name_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	char filename[PATH_MAX + 1], addr[18];
 	struct hci_dbus_data *dbus_data = data;
@@ -751,32 +747,30 @@ static DBusMessage *handle_dev_get_remote_name_req(DBusMessage *msg, void *data)
 
 	err = get_device_address(dbus_data->dev_id, addr, sizeof(addr));
 	if (err < 0)
-		return error_failed(msg, -err);
-
+		return error_failed(conn, msg, -err);
 
 	snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
 
 	name = textfile_get(filename, str_bdaddr);
 
 	if (!name)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply) {
-		reply = error_out_of_memory(msg);
-		goto done;
+		free(name);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &name,
 					DBUS_TYPE_INVALID);
 
-done:
 	free(name);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_remote_alias_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_remote_alias_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -792,19 +786,19 @@ static DBusMessage *handle_dev_get_remote_alias_req(DBusMessage *msg, void *data
 
 	err = get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_set_remote_alias_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_set_remote_alias_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
@@ -821,14 +815,14 @@ static DBusMessage *handle_dev_set_remote_alias_req(DBusMessage *msg, void *data
 
 	if (strlen(str_ptr) == 0) {
 		error("Alias change failed: Invalid parameter");
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_WRONG_PARAM);
 	}
 
 	str2ba(addr_ptr, &bdaddr);
 
 	err = set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
 	if (err < 0)
-		return error_failed(msg, -err);
+		return error_failed(conn, msg, -err);
 
 	signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_REMOTE_ALIAS_CHANGED,
 						DBUS_TYPE_STRING, &addr_ptr,
@@ -842,12 +836,12 @@ static DBusMessage *handle_dev_set_remote_alias_req(DBusMessage *msg, void *data
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_last_seen_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_last_seen_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -864,24 +858,23 @@ static DBusMessage *handle_dev_last_seen_req(DBusMessage *msg, void *data)
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply) {
-		reply = error_out_of_memory(msg);
-		goto done;
+		free(str);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
 					DBUS_TYPE_INVALID);
 
-done:
 	free(str);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_last_used_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_last_used_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -898,24 +891,23 @@ static DBusMessage *handle_dev_last_used_req(DBusMessage *msg, void *data)
 
 	str = textfile_get(filename, addr_ptr);
 	if (!str)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply) {
-		reply = error_out_of_memory(msg);
-		goto done;
+		free(str);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
 					DBUS_TYPE_INVALID);
 
-done:
 	free(str);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_create_bonding_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_create_bonding_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_request rq;
 	auth_requested_cp cp;
@@ -935,27 +927,28 @@ static DBusMessage *handle_dev_create_bonding_req(DBusMessage *msg, void *data)
 	dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
 
 	if (dev_id < 0)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
 
 	if (dbus_data->dev_id != dev_id)
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
 
 	dd = hci_open_dev(dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
 	if (!cr) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NO_MEM);
 	}
 
 	bacpy(&cr->bdaddr, &bdaddr);
 	cr->type = ACL_LINK;
 
 	if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto done;
+		hci_close_dev(dd);
+		free(cr);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	memset(&cp, 0, sizeof(cp));
@@ -973,22 +966,21 @@ static DBusMessage *handle_dev_create_bonding_req(DBusMessage *msg, void *data)
 	if (hci_send_req(dd, &rq, 100) < 0) {
 		error("Unable to send authentication request: %s (%d)",
 							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto done;
+		hci_close_dev(dd);
+		free(cr);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	reply = dbus_message_new_method_return(msg);
 
-done:
 	free(cr);
 
-failed:
 	close(dd);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_remove_bonding_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusConnection *connection = get_dbus_connection();
@@ -1003,7 +995,7 @@ static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	get_device_address(dbus_data->dev_id, addr, sizeof(addr));
 
@@ -1025,22 +1017,24 @@ static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
 	if (!cr) {
 		error("Can't allocate memory");
 		hci_close_dev(dd);
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NO_MEM);
 	}
 
 	bacpy(&cr->bdaddr, &bdaddr);
 	cr->type = ACL_LINK;
 	if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
 		/* Ignore when there isn't active connections, return success */
-		reply = dbus_message_new_method_return(msg);
-		goto failed;
+		hci_close_dev(dd);
+		free(cr);
+		return send_reply_and_unref(conn, dbus_message_new_method_return(msg));
 	}
 
 	/* Send the HCI disconnect command */
 	if (hci_disconnect(dd, htobs(cr->conn_info->handle), HCI_OE_USER_ENDED_CONNECTION, 1000) < 0) {
 		error("Disconnect failed");
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		free(cr);
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	/* FIXME: which condition must be verified before send the signal */
@@ -1056,15 +1050,14 @@ static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
 
 	reply = dbus_message_new_method_return(msg);
 
-failed:
 	free(cr);
 
-	close(dd);
+	hci_close_dev(dd);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_has_bonding_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_has_bonding_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -1092,10 +1085,10 @@ static DBusMessage *handle_dev_has_bonding_req(DBusMessage *msg, void *data)
 	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &result,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_list_bondings_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_list_bondings_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	void do_append(char *key, char *value, void *data)
 	{
@@ -1126,10 +1119,10 @@ static DBusMessage *handle_dev_list_bondings_req(DBusMessage *msg, void *data)
 
 	dbus_message_iter_close_container(&iter, &array_iter);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_pin_code_length_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_pin_code_length_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -1150,7 +1143,7 @@ static DBusMessage *handle_dev_get_pin_code_length_req(DBusMessage *msg, void *d
 
 	len = read_pin_length(&local, &peer);
 	if (len < 0)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -len);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | -len);
 
 	reply = dbus_message_new_method_return(msg);
 
@@ -1159,10 +1152,10 @@ static DBusMessage *handle_dev_get_pin_code_length_req(DBusMessage *msg, void *d
 	dbus_message_append_args(reply, DBUS_TYPE_BYTE, &length,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_get_encryption_key_size_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_get_encryption_key_size_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	struct hci_dbus_data *dbus_data = data;
 	DBusMessageIter iter;
@@ -1179,7 +1172,7 @@ static DBusMessage *handle_dev_get_encryption_key_size_req(DBusMessage *msg, voi
 
 	val = get_encryption_key_size(dbus_data->dev_id, &bdaddr);
 	if (val < 0)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -val);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | -val);
 
 	reply = dbus_message_new_method_return(msg);
 
@@ -1188,10 +1181,10 @@ static DBusMessage *handle_dev_get_encryption_key_size_req(DBusMessage *msg, voi
 	dbus_message_append_args(reply, DBUS_TYPE_BYTE, &size,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_discover_devices_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_discover_devices_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply = NULL;
 	const char *requestor_name;
@@ -1204,11 +1197,11 @@ static DBusMessage *handle_dev_discover_devices_req(DBusMessage *msg, void *data
 	int dd;
 
 	if (dbus_data->requestor_name)
-		return error_discover_in_progress(msg);
+		return error_discover_in_progress(conn, msg);
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	memset(&cp, 0, sizeof(cp));
 	cp.lap[0]  = lap & 0xff;
@@ -1229,8 +1222,8 @@ static DBusMessage *handle_dev_discover_devices_req(DBusMessage *msg, void *data
 	if (hci_send_req(dd, &rq, 100) < 0) {
 		error("Unable to start inquiry: %s (%d)",
 							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
 	requestor_name = dbus_message_get_sender(msg);
@@ -1238,13 +1231,12 @@ static DBusMessage *handle_dev_discover_devices_req(DBusMessage *msg, void *data
 
 	reply = dbus_message_new_method_return(msg);
 
-failed:
 	hci_close_dev(dd);
 
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_cancel_discovery_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_cancel_discovery_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply = NULL;
 	const char *requestor_name;
@@ -1257,15 +1249,15 @@ static DBusMessage *handle_dev_cancel_discovery_req(DBusMessage *msg, void *data
 
 	/* is there discover pending? */
 	if (!dbus_data->requestor_name)
-		return error_not_authorized(msg);
-		
+		return error_not_authorized(conn, msg);
+
 	/* only the discover requestor can cancel the inquiry process */
 	if (strcmp(dbus_data->requestor_name, requestor_name))
-		return error_not_authorized(msg);
+		return error_not_authorized(conn, msg);
 
 	dd = hci_open_dev(dbus_data->dev_id);
 	if (dd < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	memset(&rq, 0, sizeof(rq));
 	rq.ogf    = OGF_LINK_CTL;
@@ -1276,14 +1268,15 @@ static DBusMessage *handle_dev_cancel_discovery_req(DBusMessage *msg, void *data
 	if (hci_send_req(dd, &rq, 100) < 0) {
 		error("Sending cancel inquiry failed: %s (%d)",
 							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-		goto failed;
+		hci_close_dev(dd);
+		return bluez_new_failure_msg(conn, msg, BLUEZ_ESYSTEM_OFFSET | errno);
 	}
 
+	hci_close_dev(dd);
+
 	if (status) {
 		error("Cancel inquiry failed with status 0x%02x", status);
-		reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
-		goto failed;
+		return bluez_new_failure_msg(conn, msg, BLUEZ_EBT_OFFSET | status);
 	}
 
 	free(dbus_data->requestor_name);
@@ -1291,25 +1284,22 @@ static DBusMessage *handle_dev_cancel_discovery_req(DBusMessage *msg, void *data
 
 	reply = dbus_message_new_method_return(msg);
 
-failed:
-	hci_close_dev(dd);
-
-	return reply;
+	return send_reply_and_unref(conn, msg);
 }
 
-static DBusMessage *handle_dev_discover_cache_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_discover_cache_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+	return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
 }
 
-static DBusMessage *handle_dev_discover_service_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_dev_discover_service_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+	return bluez_new_failure_msg(conn, msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
 }
 
-static const struct service_data dev_services[] = {
+static struct service_data dev_services[] = {
 	{ DEV_GET_ADDRESS,		handle_dev_get_address_req,		},
 	{ DEV_GET_VERSION,		handle_dev_get_version_req,		},
 	{ DEV_GET_REVISION,		handle_dev_get_revision_req,		},
@@ -1358,8 +1348,10 @@ static const struct service_data dev_services[] = {
 
 DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data)
 {
+	service_handler_func_t handler;
 	struct hci_dbus_data *dbus_data = data;
 	const char *iface;
+	uint32_t err = 0;
 
 	iface = dbus_message_get_interface(msg);
 
@@ -1379,6 +1371,7 @@ DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *
 	return handler(conn, msg, data);
 
 failed:
+#if 0
 	if (err) {
 		DBusMessage *reply = bluez_new_failure_msg(msg, err);
 
@@ -1389,6 +1382,7 @@ failed:
 			dbus_message_unref(reply);
 		}
 	}
+#endif
 
-	return DBUS_HANDLER_RESULT_HANDLED;
+	return bluez_new_failure_msg(conn, msg, err);
 }
diff --git a/hcid/dbus-common.c b/hcid/dbus-common.c
index 41a9ce3e..360501e0 100644
--- a/hcid/dbus-common.c
+++ b/hcid/dbus-common.c
@@ -282,15 +282,15 @@ int name_listener_remove(DBusConnection *connection, const char *name,
 	return 0;
 }
 
-service_hanbdler_func_t *find_service_handler(const service_data *handlers, DBusMessage *msg)
+service_handler_func_t find_service_handler(struct service_data *handlers, DBusMessage *msg)
 {
 	struct service_data *current;
-	const char *name, *sig;
+	const char *name;
 
-	member = dbus_message_get_member(msg);
+	name = dbus_message_get_member(msg);
 
 	for (current = handlers; current->name != NULL; current++) {
-		if (!strcmp(current->name, member))
+		if (!strcmp(current->name, name))
 			return current->handler_func;
 	}
 
diff --git a/hcid/dbus-error.c b/hcid/dbus-error.c
index 988d3b34..f893d130 100644
--- a/hcid/dbus-error.c
+++ b/hcid/dbus-error.c
@@ -139,7 +139,7 @@ static const char *bluez_dbus_error_to_str(const uint32_t ecode)
 	return NULL;
 }
 
-DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode)
+DBusHandlerResult bluez_new_failure_msg(DBusConnection *conn, DBusMessage *msg, const uint32_t ecode)
 {
 	DBusMessageIter iter;
 	DBusMessage *reply;
@@ -147,112 +147,124 @@ DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode)
 
 	error_msg = bluez_dbus_error_to_str(ecode);
 	if (!error_msg)
-		return NULL;
+		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
 	reply = dbus_message_new_error(msg, ERROR_INTERFACE, error_msg);
 
 	dbus_message_iter_init_append(reply, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32 ,&ecode);
 
-	return reply;
+	return send_reply_and_unref(conn, reply);
 }
 
-DBusMessage *error_failed(DBusMessage *msg, int err)
+DBusHandlerResult error_failed(DBusConnection *conn, DBusMessage *msg, int err)
 {
 	const char *str = strerror(err);
 
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".Failed", str);
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".Failed", str));
 }
 
-DBusMessage *error_invalid_arguments(DBusMessage *msg)
+DBusHandlerResult error_invalid_arguments(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".InvalidArguments",
-							"Invalid arguments");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".InvalidArguments",
+							"Invalid arguments"));
 }
 
-DBusMessage *error_not_authorized(DBusMessage *msg)
+DBusHandlerResult error_not_authorized(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".NotAuthorized",
-							"Not authorized");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".NotAuthorized",
+							"Not authorized"));
 }
 
-DBusMessage *error_out_of_memory(DBusMessage *msg)
+DBusHandlerResult error_out_of_memory(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".OutOfMemory",
-							"Out of memory");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".OutOfMemory",
+							"Out of memory"));
 }
 
-DBusMessage *error_no_such_adapter(DBusMessage *msg)
+DBusHandlerResult error_no_such_adapter(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".NoSuchAdapter",
-							"No such adapter");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".NoSuchAdapter",
+							"No such adapter"));
 }
 
-DBusMessage *error_unknown_address(DBusMessage *msg)
+DBusHandlerResult error_unknown_address(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".UnknownAddress",
-							"Unknown address");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".UnknownAddress",
+							"Unknown address"));
 }
 
-DBusMessage *error_not_available(DBusMessage *msg)
+DBusHandlerResult error_not_available(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".NotAvailable",
-							"Not available");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".NotAvailable",
+							"Not available"));
 }
 
-DBusMessage *error_not_connected(DBusMessage *msg)
+DBusHandlerResult error_not_connected(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".NotConnected",
-							"Not connected");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".NotConnected",
+							"Not connected"));
 }
 
-DBusMessage *error_unsupported_major_class(DBusMessage *msg)
+DBusHandlerResult error_unsupported_major_class(DBusConnection *conn, DBusMessage *msg)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".UnsupportedMajorClass",
-							"Unsupported Major Class");
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".UnsupportedMajorClass",
+							"Unsupported Major Class"));
 }
 
-static DBusMessage *error_already_exists(DBusMessage *msg, const char *str)
+static DBusHandlerResult error_already_exists(DBusConnection *conn, DBusMessage *msg, const char *str)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".AlreadyExists", str);
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".AlreadyExists", str));
 }
 
-static DBusMessage *error_does_not_exist(DBusMessage *msg, const char *str)
+static DBusHandlerResult error_does_not_exist(DBusConnection *conn, DBusMessage *msg, const char *str)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".DoesNotExist", str);
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".DoesNotExist", str));
 }
 
-static DBusMessage *error_in_progress(DBusMessage *msg, const char *str)
+static DBusHandlerResult error_in_progress(DBusConnection *conn, DBusMessage *msg, const char *str)
 {
-	return dbus_message_new_error(msg, ERROR_INTERFACE ".InProgress", str);
+	return send_reply_and_unref(conn,
+		dbus_message_new_error(msg, ERROR_INTERFACE ".InProgress", str));
 }
 
-DBusMessage *error_bonding_already_exists(DBusMessage *msg)
+DBusHandlerResult error_bonding_already_exists(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_already_exists(msg, "Bonding already exists");
+	return error_already_exists(conn, msg, "Bonding already exists");
 }
 
-DBusMessage *error_bonding_does_not_exist(DBusMessage *msg)
+DBusHandlerResult error_bonding_does_not_exist(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_does_not_exist(msg, "Bonding does not exist");
+	return error_does_not_exist(conn, msg, "Bonding does not exist");
 }
 
-DBusMessage *error_bonding_in_progress(DBusMessage *msg)
+DBusHandlerResult error_bonding_in_progress(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_in_progress(msg, "Bonding in progress");
+	return error_in_progress(conn, msg, "Bonding in progress");
 }
 
-DBusMessage *error_discover_in_progress(DBusMessage *msg)
+DBusHandlerResult error_discover_in_progress(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_in_progress(msg, "Discover in progress");
+	return error_in_progress(conn, msg, "Discover in progress");
 }
 
-DBusMessage *error_passkey_agent_already_exists(DBusMessage *msg)
+DBusHandlerResult error_passkey_agent_already_exists(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_already_exists(msg, "Passkey agent already exists");
+	return error_already_exists(conn, msg, "Passkey agent already exists");
 }
 
-DBusMessage *error_passkey_agent_does_not_exist(DBusMessage *msg)
+DBusHandlerResult error_passkey_agent_does_not_exist(DBusConnection *conn, DBusMessage *msg)
 {
-	return error_does_not_exist(msg, "Passkey agent does not exist");
+	return error_does_not_exist(conn, msg, "Passkey agent does not exist");
 }
diff --git a/hcid/dbus-manager.c b/hcid/dbus-manager.c
index ffbdc943..f86fb1b3 100644
--- a/hcid/dbus-manager.c
+++ b/hcid/dbus-manager.c
@@ -39,7 +39,7 @@
 #include "hcid.h"
 #include "dbus.h"
 
-static DBusMessage *handle_mgr_list_devices_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_mgr_list_devices_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessageIter iter;
 	DBusMessageIter array_iter;
@@ -50,28 +50,30 @@ static DBusMessage *handle_mgr_list_devices_req(DBusMessage *msg, void *data)
 
 	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 	if (sk < 0)
-		return error_failed(msg, errno);
+		return error_failed(conn, msg, errno);
 
 	dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
 	if (!dl) {
 		close(sk);
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dl->dev_num = HCI_MAX_DEV;
 	dr = dl->dev_req;
 
 	if (ioctl(sk, HCIGETDEVLIST, dl) < 0) {
-		reply = error_failed(msg, errno);
-		goto failed;
+		close(sk);
+		free(dl);
+		return error_failed(conn, msg, errno);
 	}
 
 	dr = dl->dev_req;
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply) {
-		reply = error_out_of_memory(msg);
-		goto failed;
+		close(sk);
+		free(dl);
+		return error_out_of_memory(conn, msg);
 	}
 
 	dbus_message_iter_init_append(reply, &iter);
@@ -97,45 +99,44 @@ static DBusMessage *handle_mgr_list_devices_req(DBusMessage *msg, void *data)
 
 	dbus_message_iter_close_container(&iter, &array_iter);
 
-failed:
 	free(dl);
 
 	close(sk);
 
-	return reply;
+	return send_reply_and_unref(conn, reply);
 }
 
-static DBusMessage *handle_mgr_default_device_req(DBusMessage *msg, void *data)
+static DBusHandlerResult handle_mgr_default_adapter_req(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	char path[MAX_PATH_LENGTH], *path_ptr = path;
 	int default_dev = get_default_dev_id();
 
 	if (default_dev < 0)
-		return error_no_such_adapter(msg);
+		return error_no_such_adapter(conn, msg);
 
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
-		return error_out_of_memory(msg);
+		return error_out_of_memory(conn, msg);
 
 	snprintf(path, sizeof(path), "%s/hci%d", ADAPTER_PATH, default_dev);
 
 	dbus_message_append_args(reply, DBUS_TYPE_STRING, &path_ptr,
 					DBUS_TYPE_INVALID);
 
-	return reply;
+	return send_reply_and_unref(conn, reply);
 }
 
-static const struct service_data mgr_services[] = {
+static struct service_data mgr_services[] = {
 	{ MGR_LIST_ADAPTERS,	handle_mgr_list_devices_req	},
-	{ MGR_DEFAULT_ADAPTER,	handle_mgr_default_device_req	},
+	{ MGR_DEFAULT_ADAPTER,	handle_mgr_default_adapter_req	},
 	{ NULL, NULL }
 };
 
 static DBusHandlerResult handle_manager_method(DBusConnection *conn,
 						DBusMessage *msg, void *data)
 {
-	service_handler_func_t *handler;
+	service_handler_func_t handler;
 
 	handler = find_service_handler(mgr_services, msg);
 
diff --git a/hcid/dbus-security.c b/hcid/dbus-security.c
index eec34272..bc5ce039 100644
--- a/hcid/dbus-security.c
+++ b/hcid/dbus-security.c
@@ -31,17 +31,10 @@
 #include <dbus/dbus.h>
 
 #include "dbus.h"
-#include "dbus-error.h"
-#include "dbus-common.h"
+#include "hcid.h"
 
 static struct passkey_agent *default_agent = NULL;
 
-static const struct service_data sec_services[] = {
-	{ "RegisterDefault",	register_default_agent		},
-	{ "UnregisterDefault",	unregister_default_agent	},
-	{ NULL, NULL }
-};
-
 static void default_agent_exited(const char *name, void *data)
 {
 	debug("%s exited without unregistering the default passkey agent", name);
@@ -174,6 +167,12 @@ done:
 	return DBUS_HANDLER_RESULT_HANDLED;
 }
 
+static struct service_data sec_services[] = {
+	{ "RegisterDefault",	register_default_agent		},
+	{ "UnregisterDefault",	unregister_default_agent	},
+	{ NULL, NULL }
+};
+
 DBusHandlerResult handle_security_method(DBusConnection *conn, DBusMessage *msg, void *data)
 {
 	service_handler_func_t *handler;
diff --git a/hcid/dbus.h b/hcid/dbus.h
index 82a1d675..fb6f322a 100644
--- a/hcid/dbus.h
+++ b/hcid/dbus.h
@@ -25,6 +25,7 @@
 #define __H_BLUEZ_DBUS_H__
 
 #include <stdint.h>
+#include <dbus/dbus.h>
 
 #define __END_SIG__ DBUS_TYPE_INVALID_AS_STRING
 
@@ -39,6 +40,8 @@
 
 #define ERROR_INTERFACE		BASE_INTERFACE ".Error"
 
+#define SECURITY_INTERFACE	BASE_INTERFACE ".Security"
+
 #define MANAGER_PATH_MASK	(1 << 15)
 #define ADAPTER_PATH_MASK	(1 << 14)
 
@@ -56,13 +59,13 @@
 
 #define MAX_PATH_LENGTH		64
 
-typedef DBusHandlerResult (service_handler_func_t) (DBusConnection *conn,
+typedef DBusHandlerResult (*service_handler_func_t) (DBusConnection *conn,
 							DBusMessage *msg,
 							void *user_data);
 
 struct service_data {
 	const char		*name;
-	service_handler_func_t	*handler_func;
+	service_handler_func_t	handler_func;
 };
 
 typedef int (timeout_handler_func_t) (void *data);
@@ -89,7 +92,7 @@ typedef int unregister_function_t(DBusConnection *conn, uint16_t id);
 DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data);
 DBusHandlerResult msg_func_manager(DBusConnection *conn, DBusMessage *msg, void *data);
 
-DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode);
+DBusHandlerResult bluez_new_failure_msg(DBusConnection *conn, DBusMessage *msg, const uint32_t ecode);
 
 DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const int first, ...);
 
@@ -97,23 +100,21 @@ DBusConnection *get_dbus_connection(void);
 
 int get_default_dev_id(void);
 
-DBusMessage *error_failed(DBusMessage *msg, int err);
-DBusMessage *error_invalid_arguments(DBusMessage *msg);
-DBusMessage *error_not_authorized(DBusMessage *msg);
-DBusMessage *error_out_of_memory(DBusMessage *msg);
-DBusMessage *error_no_such_adapter(DBusMessage *msg);
-DBusMessage *error_unknown_address(DBusMessage *msg);
-DBusMessage *error_not_available(DBusMessage *msg);
-DBusMessage *error_not_connected(DBusMessage *msg);
-DBusMessage *error_unsupported_major_class(DBusMessage *msg);
-
-DBusMessage *error_bonding_already_exists(DBusMessage *msg);
-DBusMessage *error_bonding_does_not_exist(DBusMessage *msg);
-DBusMessage *error_bonding_in_progress(DBusMessage *msg);
-DBusMessage *error_discover_in_progress(DBusMessage *msg);
-
-DBusMessage *error_passkey_agent_already_exists(DBusMessage *msg);
-DBusMessage *error_passkey_agent_does_not_exist(DBusMessage *msg);
+DBusHandlerResult error_failed(DBusConnection *conn, DBusMessage *msg, int err);
+DBusHandlerResult error_invalid_arguments(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_not_authorized(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_out_of_memory(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_no_such_adapter(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_unknown_address(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_not_available(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_not_connected(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_unsupported_major_class(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_bonding_already_exists(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_bonding_does_not_exist(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_bonding_in_progress(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_discover_in_progress(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_passkey_agent_already_exists(DBusConnection *conn, DBusMessage *msg);
+DBusHandlerResult error_passkey_agent_does_not_exist(DBusConnection *conn, DBusMessage *msg);
 
 typedef void (*name_cb_t)(const char *name, void *user_data);
 
@@ -124,7 +125,12 @@ int name_listener_remove(DBusConnection *connection, const char *name,
 
 DBusHandlerResult handle_security_method(DBusConnection *conn, DBusMessage *msg, void *data);
 
-service_hanbdler_func_t *find_service_handler(service_data *services, DBusMessage *msg);
+service_handler_func_t find_service_handler(struct service_data *services, DBusMessage *msg);
+
+static inline DBusHandlerResult send_reply_and_unref(DBusConnection *conn, DBusMessage *msg)
+{
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
 
 /*======================================================================== 
     BlueZ D-Bus Manager service definitions "/org/bluez/Manager"