Split D-Bus services and errors into separate files

8 files changed, 1216 insertions, 1147 deletions

diff --git a/hcid/Makefile.am b/hcid/Makefile.am
index a4189f5f..3b01cc6d 100644
--- a/hcid/Makefile.am
+++ b/hcid/Makefile.am
@@ -18,7 +18,7 @@ sbin_PROGRAMS = hcid
 noinst_SCRIPTS = dbus-test
 
 if DBUS
-dbus_hcid_sources = dbus.h dbus.c
+dbus_hcid_sources = dbus.h dbus.c dbus-error.c dbus-manager.c dbus-device.c
 dbus_hcid_libs    = @DBUS_LIBS@
 dbus_hcid_cflags  = -DENABLE_DBUS -DDBUS_API_SUBJECT_TO_CHANGE
 else
@@ -45,6 +45,7 @@ AM_YFLAGS = -d
 
 CLEANFILES = lexer.c parser.c parser.h
 
-EXTRA_DIST = $(man_MANS) $(conf_DATA) dbus.h dbus.c dbus-test bluez-hcid.conf
+EXTRA_DIST = $(man_MANS) $(conf_DATA) bluez-hcid.conf dbus-test \
+		dbus.h dbus.c dbus-error.c dbus-manager.c dbus-device.c
 
 MAINTAINERCLEANFILES = Makefile.in
diff --git a/hcid/dbus-device.c b/hcid/dbus-device.c
new file mode 100644
index 00000000..d129effc
--- /dev/null
+++ b/hcid/dbus-device.c
@@ -0,0 +1,822 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include <dbus/dbus.h>
+
+#include "hcid.h"
+#include "dbus.h"
+
+#include "textfile.h"
+
+static char *get_peer_name(const bdaddr_t *local, const bdaddr_t *peer)
+{
+	char filename[PATH_MAX + 1], addr[18];
+
+	ba2str(local, addr);
+	snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
+
+	ba2str(peer, addr);
+	return textfile_get(filename, addr);
+}
+
+static DBusMessage* handle_dev_get_address_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[18], *str_ptr = str;
+
+	get_device_address(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_version_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[20], *str_ptr = str;
+
+	get_device_version(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_revision_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[20], *str_ptr = str;
+
+	get_device_revision(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_manufacturer_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[64], *str_ptr = str;
+
+	get_device_manufacturer(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_company_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[64], *str_ptr = str;
+
+	get_device_company(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_features_req(DBusMessage *msg, void *data)
+{
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_get_name_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply;
+	char str[249], *str_ptr = str;
+
+	get_device_name(dbus_data->dev_id, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_set_name_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessageIter iter;
+	DBusMessage *reply;
+	char *str_ptr;
+
+	dbus_message_iter_init(msg, &iter);
+	dbus_message_iter_get_basic(&iter, &str_ptr);
+
+	if (strlen(str_ptr) == 0) {
+		syslog(LOG_ERR, "Name change failed: Invalid parameter");
+		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+	}
+
+	set_device_name(dbus_data->dev_id, str_ptr);
+
+	reply = dbus_message_new_method_return(msg);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_alias_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusMessageIter iter;
+	DBusMessage *reply;
+	char str[249], *str_ptr = str, *addr_ptr;
+	bdaddr_t bdaddr;
+
+	dbus_message_iter_init(msg, &iter);
+	dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+	str2ba(addr_ptr, &bdaddr);
+
+	get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_set_alias_req(DBusMessage *msg, void *data)
+{
+	struct hci_dbus_data *dbus_data = data;
+	DBusConnection *connection = get_dbus_connection();
+	DBusMessageIter iter;
+	DBusMessage *reply, *signal;
+	char *str_ptr, *addr_ptr;
+	bdaddr_t bdaddr;
+
+	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);
+
+	if (strlen(str_ptr) == 0) {
+		syslog(LOG_ERR, "Alias change failed: Invalid parameter");
+		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+	}
+
+	str2ba(addr_ptr, &bdaddr);
+
+	set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
+
+	signal = dev_signal_factory(dbus_data->dev_id, "AliasChanged",
+						DBUS_TYPE_STRING, &addr_ptr,
+						DBUS_TYPE_STRING, &str_ptr,
+						DBUS_TYPE_INVALID);
+	if (signal) {
+		dbus_connection_send(connection, signal, NULL);
+		dbus_connection_flush(connection);
+		dbus_message_unref(signal);
+	}
+
+	signal = dev_signal_factory(dbus_data->dev_id, "RemoteAlias",
+						DBUS_TYPE_STRING, &addr_ptr,
+						DBUS_TYPE_STRING, &str_ptr,
+						DBUS_TYPE_INVALID);
+	if (signal) {
+		dbus_connection_send(connection, signal, NULL);
+		dbus_connection_flush(connection);
+		dbus_message_unref(signal);
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_get_mode_req(DBusMessage *msg, void *data)
+{
+	const struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply = NULL;
+	const uint8_t hci_mode = dbus_data->path_data;
+	uint8_t scan_mode;
+
+	switch (hci_mode) {
+	case SCAN_DISABLED:
+		scan_mode = MODE_OFF;
+		break;
+	case SCAN_PAGE:
+		scan_mode = MODE_CONNECTABLE;
+		break;
+	case (SCAN_PAGE | SCAN_INQUIRY):
+		scan_mode = MODE_DISCOVERABLE;
+		break;
+	case SCAN_INQUIRY:
+	/* inquiry scan mode is not handled, return 0xff */
+	default:
+		/* reserved */
+		scan_mode = 0xff;
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_append_args(reply,
+					DBUS_TYPE_BYTE, &scan_mode,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_is_connectable_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_set_class_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_set_mode_req(DBusMessage *msg, void *data)
+{
+	const struct hci_dbus_data *dbus_data = data;
+	DBusMessage *reply = NULL;
+	struct hci_request rq;
+	int dd = -1;
+	const uint8_t scan_mode;
+	uint8_t hci_mode;
+	uint8_t status = 0;
+	const uint8_t current_mode = dbus_data->path_data;
+
+	dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_BYTE, &scan_mode,
+					DBUS_TYPE_INVALID);
+
+	switch (scan_mode) {
+	case MODE_OFF:
+		hci_mode = SCAN_DISABLED;
+		break;
+	case MODE_CONNECTABLE:
+		hci_mode = SCAN_PAGE;
+		break;
+	case MODE_DISCOVERABLE:
+		hci_mode = (SCAN_PAGE | SCAN_INQUIRY);
+		break;
+	default:
+		/* invalid mode */
+		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+		goto failed;
+	}
+
+	dd = hci_open_dev(dbus_data->dev_id);
+	if (dd < 0) {
+		syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+		goto failed;
+	}
+
+	/* Check if the new requested mode is different from the current */
+	if (current_mode != hci_mode) {
+		memset(&rq, 0, sizeof(rq));
+		rq.ogf    = OGF_HOST_CTL;
+		rq.ocf    = OCF_WRITE_SCAN_ENABLE;
+		rq.cparam = &hci_mode;
+		rq.clen   = sizeof(hci_mode);
+		rq.rparam = &status;
+		rq.rlen   = sizeof(status);
+
+		if (hci_send_req(dd, &rq, 100) < 0) {
+			syslog(LOG_ERR, "Sending write scan enable command failed: %s (%d)",
+							strerror(errno), errno);
+			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+			goto failed;
+		}
+		if (status) {
+			syslog(LOG_ERR, "Setting scan enable failed with status 0x%02x", status);
+			reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
+			goto failed;
+		}
+
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+failed:
+	if (dd >= 0)
+		close(dd);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_discover_req(DBusMessage *msg, void *data)
+{
+	DBusMessage *reply = NULL;
+	inquiry_cp cp;
+	evt_cmd_status rp;
+	struct hci_request rq;
+	struct hci_dbus_data *dbus_data = data;
+	int dd = -1;
+	uint8_t length = 8, num_rsp = 0;
+	uint32_t lap = 0x9e8b33;
+
+	dd = hci_open_dev(dbus_data->dev_id);
+	if (dd < 0) {
+		syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
+					dbus_data->dev_id, strerror(errno), errno);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	memset(&cp, 0, sizeof(cp));
+	cp.lap[0]  = lap & 0xff;
+	cp.lap[1]  = (lap >> 8) & 0xff;
+	cp.lap[2]  = (lap >> 16) & 0xff;
+	cp.length  = length;
+	cp.num_rsp = num_rsp;
+
+	memset(&rq, 0, sizeof(rq));
+	rq.ogf    = OGF_LINK_CTL;
+	rq.ocf    = OCF_INQUIRY;
+	rq.cparam = &cp;
+	rq.clen   = INQUIRY_CP_SIZE;
+	rq.rparam = &rp;
+	rq.rlen   = EVT_CMD_STATUS_SIZE;
+	rq.event  = EVT_CMD_STATUS;
+
+	if (hci_send_req(dd, &rq, 100) < 0) {
+		syslog(LOG_ERR, "Unable to start inquiry: %s (%d)",
+							strerror(errno), errno);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+failed:
+	if (dd >= 0)
+		hci_close_dev(dd);
+
+	return reply;
+
+}
+
+static DBusMessage* handle_dev_discover_cache_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_discover_cancel_req(DBusMessage *msg, void *data)
+{
+	DBusMessage *reply = NULL;
+	struct hci_request rq;
+	struct hci_dbus_data *dbus_data = data;
+	uint8_t status;
+	int dd = -1;
+
+	dd = hci_open_dev(dbus_data->dev_id);
+	if (dd < 0) {
+		syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
+					dbus_data->dev_id, strerror(errno), errno);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	memset(&rq, 0, sizeof(rq));
+	rq.ogf    = OGF_LINK_CTL;
+	rq.ocf    = OCF_INQUIRY_CANCEL;
+	rq.rparam = &status;
+	rq.rlen   = sizeof(status);
+
+	if (hci_send_req(dd, &rq, 100) < 0) {
+		syslog(LOG_ERR, "Sending cancel inquiry failed: %s (%d)",
+							strerror(errno), errno);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	if (status) {
+		syslog(LOG_ERR, "Cancel inquiry failed with status 0x%02x", status);
+		reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + status);
+		goto failed;
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+failed:
+	if (dd >= 0)
+		hci_close_dev(dd);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_discover_service_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_last_seen_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_last_used_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_remote_alias_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_remote_name_req(DBusMessage *msg, void *data)
+{
+	DBusConnection *connection = get_dbus_connection();
+	DBusMessage *reply = NULL;
+	DBusMessage *signal = NULL;
+	struct hci_dbus_data *dbus_data = data;
+	const char *str_bdaddr;
+	char *name;
+	char path[MAX_PATH_LENGTH];
+	bdaddr_t bdaddr;
+	struct hci_dev_info di;
+	struct hci_request rq;
+	remote_name_req_cp cp;
+	evt_cmd_status rp;
+	int dd = -1;
+
+	dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_STRING, &str_bdaddr,
+					DBUS_TYPE_INVALID);
+
+	str2ba(str_bdaddr, &bdaddr);
+	if (hci_devinfo(dbus_data->dev_id, &di) < 0) {
+		syslog(LOG_ERR, "Can't get device info");
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+		goto failed;
+	}
+
+	/* Try retrieve from local cache */
+	name = get_peer_name(&di.bdaddr, &bdaddr);
+	if (name) {
+
+		reply = dbus_message_new_method_return(msg);
+
+		snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, dbus_data->dev_id);
+
+		signal = dbus_message_new_signal(path, DEVICE_INTERFACE,
+							DEV_SIG_REMOTE_NAME);
+
+		dbus_message_append_args(signal,
+						DBUS_TYPE_STRING, &str_bdaddr,
+						DBUS_TYPE_STRING, &name,
+						DBUS_TYPE_INVALID);
+
+		if (dbus_connection_send(connection, signal, NULL) == FALSE) {
+			syslog(LOG_ERR, "Can't send D-BUS remote name signal message");
+			goto failed;
+		}
+
+		dbus_message_unref(signal);
+		free(name);
+
+	} else {
+
+		/* Send HCI command */
+		dd = hci_open_dev(dbus_data->dev_id);
+		if (dd < 0) {
+			syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
+						dbus_data->dev_id, strerror(errno), errno);
+			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+			goto failed;
+		}
+
+		memset(&cp, 0, sizeof(cp));
+		cp.bdaddr = bdaddr;
+		cp.pscan_rep_mode = 0x02;
+
+		memset(&rq, 0, sizeof(rq));
+		rq.ogf    = OGF_LINK_CTL;
+		rq.ocf    = OCF_REMOTE_NAME_REQ;
+		rq.cparam = &cp;
+		rq.clen   = REMOTE_NAME_REQ_CP_SIZE;
+		rq.rparam = &rp;
+		rq.rlen   = EVT_CMD_STATUS_SIZE;
+		rq.event  = EVT_CMD_STATUS;
+
+		if (hci_send_req(dd, &rq, 100) < 0) {
+			syslog(LOG_ERR, "Unable to send remote name request: %s (%d)",
+						strerror(errno), errno);
+			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+			goto failed;
+		}
+
+		if (rp.status) {
+			syslog(LOG_ERR, "Remote name request failed");
+			reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | rp.status);
+			goto failed;
+		}
+	}
+
+	reply = dbus_message_new_method_return(msg);
+failed:
+	if (dd >= 0)
+		hci_close_dev(dd);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_remote_version_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_create_bonding_req(DBusMessage *msg, void *data)
+{
+	struct hci_request rq;
+	auth_requested_cp cp;
+	evt_cmd_status rp;
+	DBusMessage *reply = NULL;
+	char *str_bdaddr = NULL;
+	struct hci_dbus_data *dbus_data = data;
+	struct hci_conn_info_req *cr = NULL;
+	bdaddr_t bdaddr;
+	int dev_id = -1;
+	int dd = -1;
+
+	dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_STRING, &str_bdaddr,
+					DBUS_TYPE_INVALID);
+
+	str2ba(str_bdaddr, &bdaddr);
+
+	dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
+
+	if (dev_id < 0) {
+		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+		goto failed;
+	}
+
+	if (dbus_data->dev_id != dev_id) {
+		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+		goto failed;
+	}
+
+	dd = hci_open_dev(dev_id);
+	if (dd < 0) {
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+		goto failed;
+	}
+
+	cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
+	if (!cr) {
+		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
+		goto failed;
+	}
+
+	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 failed;
+	}
+
+	memset(&cp, 0, sizeof(cp));
+	cp.handle = cr->conn_info->handle;
+
+	memset(&rq, 0, sizeof(rq));
+	rq.ogf    = OGF_LINK_CTL;
+	rq.ocf    = OCF_AUTH_REQUESTED;
+	rq.cparam = &cp;
+	rq.clen   = AUTH_REQUESTED_CP_SIZE;
+	rq.rparam = &rp;
+	rq.rlen   = EVT_CMD_STATUS_SIZE;
+	rq.event  = EVT_CMD_STATUS;
+
+	if (hci_send_req(dd, &rq, 100) < 0) {
+		syslog(LOG_ERR, "Unable to send authentication request: %s (%d)",
+							strerror(errno), errno);
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+failed:
+	if (dd >= 0)
+		close(dd);
+
+	if (cr)
+		free(cr);
+
+	return reply;
+}
+
+static DBusMessage* handle_dev_list_bondings_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_has_bonding_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+
+static DBusMessage* handle_dev_pin_code_length_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage* handle_dev_encryption_key_size_req(DBusMessage *msg, void *data)
+{
+	/*FIXME: */
+	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static const struct service_data dev_services[] = {
+	{ DEV_GET_ADDRESS,		handle_dev_get_address_req,		DEV_GET_ADDRESS_SIGNATURE		},
+	{ DEV_GET_ALIAS,		handle_dev_get_alias_req,		DEV_GET_ALIAS_SIGNATURE			},
+	{ DEV_GET_COMPANY,		handle_dev_get_company_req,		DEV_GET_COMPANY_SIGNATURE		},
+	{ DEV_GET_DISCOVERABLE_TO,	handle_dev_get_discoverable_to_req,	DEV_GET_DISCOVERABLE_TO_SIGNATURE	},
+	{ DEV_GET_FEATURES,		handle_dev_get_features_req,		DEV_GET_FEATURES_SIGNATURE		},
+	{ DEV_GET_MANUFACTURER,		handle_dev_get_manufacturer_req,	DEV_GET_MANUFACTURER_SIGNATURE		},
+	{ DEV_GET_MODE,			handle_dev_get_mode_req,		DEV_GET_MODE_SIGNATURE			},
+	{ DEV_GET_NAME,			handle_dev_get_name_req,		DEV_GET_NAME_SIGNATURE			},
+	{ DEV_GET_REVISION,		handle_dev_get_revision_req,		DEV_GET_REVISION_SIGNATURE		},
+	{ DEV_GET_VERSION,		handle_dev_get_version_req,		DEV_GET_VERSION_SIGNATURE		},
+
+	{ DEV_IS_CONNECTABLE,		handle_dev_is_connectable_req,		DEV_IS_CONNECTABLE_SIGNATURE		},
+	{ DEV_IS_DISCOVERABLE,		handle_dev_is_discoverable_req,		DEV_IS_DISCOVERABLE_SIGNATURE		},
+
+	{ DEV_SET_ALIAS,		handle_dev_set_alias_req,		DEV_SET_ALIAS_SIGNATURE			},
+	{ DEV_SET_CLASS,		handle_dev_set_class_req,		DEV_SET_CLASS_SIGNATURE			},
+	{ DEV_SET_DISCOVERABLE_TO,	handle_dev_set_discoverable_to_req,	DEV_SET_DISCOVERABLE_TO_SIGNATURE	},
+	{ DEV_SET_MODE,			handle_dev_set_mode_req,		DEV_SET_MODE_SIGNATURE			},
+	{ DEV_SET_NAME,			handle_dev_set_name_req,		DEV_SET_NAME_SIGNATURE			},
+
+	{ DEV_DISCOVER,			handle_dev_discover_req,		DEV_DISCOVER_SIGNATURE			},
+	{ DEV_DISCOVER_CACHE,		handle_dev_discover_cache_req,		DEV_DISCOVER_CACHE_SIGNATURE		},
+	{ DEV_DISCOVER_CANCEL,		handle_dev_discover_cancel_req,		DEV_DISCOVER_CANCEL_SIGNATURE		},
+	{ DEV_DISCOVER_SERVICE,		handle_dev_discover_service_req,	DEV_DISCOVER_SERVICE_SIGNATURE		},
+
+	{ DEV_LAST_SEEN,		handle_dev_last_seen_req,		DEV_LAST_SEEN_SIGNATURE			},
+	{ DEV_LAST_USED,		handle_dev_last_used_req,		DEV_LAST_USED_SIGNATURE			},
+
+	{ DEV_REMOTE_ALIAS,		handle_dev_remote_alias_req,		DEV_REMOTE_ALIAS_SIGNATURE		},
+	{ DEV_REMOTE_NAME,		handle_dev_remote_name_req,		DEV_REMOTE_NAME_SIGNATURE		},
+	{ DEV_REMOTE_VERSION,		handle_dev_remote_version_req,		DEV_REMOTE_VERSION_SIGNATURE		},
+
+	{ DEV_CREATE_BONDING,		handle_dev_create_bonding_req,		DEV_CREATE_BONDING_SIGNATURE		},
+	{ DEV_LIST_BONDINGS,		handle_dev_list_bondings_req,		DEV_LIST_BONDINGS_SIGNATURE		},
+	{ DEV_HAS_BONDING_NAME,		handle_dev_has_bonding_req,		DEV_HAS_BONDING_SIGNATURE		},
+	{ DEV_REMOVE_BONDING,		handle_dev_remove_bonding_req,		DEV_REMOVE_BONDING_SIGNATURE		},
+
+	{ DEV_PIN_CODE_LENGTH,		handle_dev_pin_code_length_req,		DEV_PIN_CODE_LENGTH_SIGNATURE		},
+	{ DEV_ENCRYPTION_KEY_SIZE,	handle_dev_encryption_key_size_req,	DEV_ENCRYPTION_KEY_SIZE_SIGNATURE	},
+
+	{ NULL, NULL, NULL}
+};
+
+DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	const struct service_data *handlers = dev_services;
+	DBusMessage *reply = NULL;
+	struct hci_dbus_data *dbus_data = data;
+	const char *method;
+	const char *signature;
+	uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
+	DBusHandlerResult ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+	method = dbus_message_get_member(msg);
+	signature = dbus_message_get_signature(msg);
+
+	syslog(LOG_INFO, "[%s,%d] path:%s, method:%s", __PRETTY_FUNCTION__, __LINE__, dbus_message_get_path(msg), method);
+
+	if (dbus_data->path_id == DEVICE_ROOT_ID) {
+		/* Device is down(path unregistered) or the path is wrong */
+		ret = DBUS_HANDLER_RESULT_HANDLED;
+		error = BLUEZ_EDBUS_UNKNOWN_PATH;
+		goto failed;
+	}
+
+	/* It's a device path id */
+	for (; handlers->name != NULL; handlers++) {
+		if (strcmp(handlers->name, method))
+			continue;
+
+		ret = DBUS_HANDLER_RESULT_HANDLED;
+
+		if (!strcmp(handlers->signature, signature)) {
+			reply = handlers->handler_func(msg, data);
+			error = 0;
+			break;
+		} else {
+			/* Set the error, but continue looping incase there is
+			 * another method with the same name but a different
+			 * signature */
+			error = BLUEZ_EDBUS_WRONG_SIGNATURE;
+			continue;
+		}
+	}
+
+failed:
+	if (error)
+		reply = bluez_new_failure_msg(msg, error);
+
+	if (reply) {
+		if (!dbus_connection_send (conn, reply, NULL))
+			syslog(LOG_ERR, "Can't send reply message!");
+		dbus_message_unref(reply);
+	}
+
+	return ret;
+}
diff --git a/hcid/dbus-error.c b/hcid/dbus-error.c
new file mode 100644
index 00000000..df8913ad
--- /dev/null
+++ b/hcid/dbus-error.c
@@ -0,0 +1,158 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <sys/socket.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+
+#include <dbus/dbus.h>
+
+#include "hcid.h"
+#include "dbus.h"
+
+typedef struct  {
+	uint32_t code;
+	const char *str;
+} bluez_error_t;
+
+static const bluez_error_t dbus_error_array[] = {
+	{ BLUEZ_EDBUS_UNKNOWN_METHOD,	"Method not found"		},
+	{ BLUEZ_EDBUS_WRONG_SIGNATURE,	"Wrong method signature"	},
+	{ BLUEZ_EDBUS_WRONG_PARAM,	"Invalid parameters"		},
+	{ BLUEZ_EDBUS_RECORD_NOT_FOUND,	"No record found"		},
+	{ BLUEZ_EDBUS_NO_MEM,		"No memory"			},
+	{ BLUEZ_EDBUS_CONN_NOT_FOUND,	"Connection not found"		},
+	{ BLUEZ_EDBUS_UNKNOWN_PATH,	"Unknown D-BUS path"		},
+	{ BLUEZ_EDBUS_NOT_IMPLEMENTED,	"Method not implemented"	},
+	{ 0, NULL }
+};
+
+static const bluez_error_t hci_error_array[] = {
+	{ HCI_UNKNOWN_COMMAND,			"Unknown HCI Command"						},
+	{ HCI_NO_CONNECTION,			"Unknown Connection Identifier"					},
+	{ HCI_HARDWARE_FAILURE,			"Hardware Failure"						},
+	{ HCI_PAGE_TIMEOUT,			"Page Timeout"							},
+	{ HCI_AUTHENTICATION_FAILURE,		"Authentication Failure"					},
+	{ HCI_PIN_OR_KEY_MISSING,		"PIN Missing"							},
+	{ HCI_MEMORY_FULL,			"Memory Capacity Exceeded"					},
+	{ HCI_CONNECTION_TIMEOUT,		"Connection Timeout"						},
+	{ HCI_MAX_NUMBER_OF_CONNECTIONS,	"Connection Limit Exceeded"					},
+	{ HCI_MAX_NUMBER_OF_SCO_CONNECTIONS,	"Synchronous Connection Limit To A Device Exceeded"		},
+	{ HCI_ACL_CONNECTION_EXISTS,		"ACL Connection Already Exists"					},
+	{ HCI_COMMAND_DISALLOWED,		"Command Disallowed"						},
+	{ HCI_REJECTED_LIMITED_RESOURCES,	"Connection Rejected due to Limited Resources"			},
+	{ HCI_REJECTED_SECURITY,		"Connection Rejected Due To Security Reasons"			},
+	{ HCI_REJECTED_PERSONAL,		"Connection Rejected due to Unacceptable BD_ADDR"		},
+	{ HCI_HOST_TIMEOUT,			"Connection Accept Timeout Exceeded"				},
+	{ HCI_UNSUPPORTED_FEATURE,		"Unsupported Feature or Parameter Value"			},
+	{ HCI_INVALID_PARAMETERS,		"Invalid HCI Command Parameters"				},
+	{ HCI_OE_USER_ENDED_CONNECTION,		"Remote User Terminated Connection"				},
+	{ HCI_OE_LOW_RESOURCES,			"Remote Device Terminated Connection due to Low Resources"	},
+	{ HCI_OE_POWER_OFF,			"Remote Device Terminated Connection due to Power Off"		},
+	{ HCI_CONNECTION_TERMINATED,		"Connection Terminated By Local Host"				},
+	{ HCI_REPEATED_ATTEMPTS,		"Repeated Attempts"						},
+	{ HCI_PAIRING_NOT_ALLOWED,		"Pairing Not Allowed"						},
+	{ HCI_UNKNOWN_LMP_PDU,			"Unknown LMP PDU"						},
+	{ HCI_UNSUPPORTED_REMOTE_FEATURE,	"Unsupported Remote Feature"					},
+	{ HCI_SCO_OFFSET_REJECTED,		"SCO Offset Rejected"						},
+	{ HCI_SCO_INTERVAL_REJECTED,		"SCO Interval Rejected"						},
+	{ HCI_AIR_MODE_REJECTED,		"SCO Air Mode Rejected"						},
+	{ HCI_INVALID_LMP_PARAMETERS,		"Invalid LMP Parameters"					},
+	{ HCI_UNSPECIFIED_ERROR,		"Unspecified Error"						},
+	{ HCI_UNSUPPORTED_LMP_PARAMETER_VALUE,	"Unsupported LMP Parameter Value"				},
+	{ HCI_ROLE_CHANGE_NOT_ALLOWED,		"Role Change Not Allowed"					},
+	{ HCI_LMP_RESPONSE_TIMEOUT,		"LMP Response Timeout"						},
+	{ HCI_LMP_ERROR_TRANSACTION_COLLISION,	"LMP Error Transaction Collision"				},
+	{ HCI_LMP_PDU_NOT_ALLOWED,		"LMP PDU Not Allowed"						},
+	{ HCI_ENCRYPTION_MODE_NOT_ACCEPTED,	"Encryption Mode Not Acceptable"				},
+	{ HCI_UNIT_LINK_KEY_USED,		"Link Key Can Not be Changed"					},
+	{ HCI_QOS_NOT_SUPPORTED,		"Requested QoS Not Supported"					},
+	{ HCI_INSTANT_PASSED,			"Instant Passed"						},
+	{ HCI_PAIRING_NOT_SUPPORTED,		"Pairing With Unit Key Not Supported"				},
+	{ HCI_TRANSACTION_COLLISION,		"Different Transaction Collision"				},
+	{ HCI_QOS_UNACCEPTABLE_PARAMETER,	"QoS Unacceptable Parameter"					},
+	{ HCI_QOS_REJECTED,			"QoS Rejected"							},
+	{ HCI_CLASSIFICATION_NOT_SUPPORTED,	"Channel Classification Not Supported"				},
+	{ HCI_INSUFFICIENT_SECURITY,		"Insufficient Security"						},
+	{ HCI_PARAMETER_OUT_OF_RANGE,		"Parameter Out Of Mandatory Range"				},
+	{ HCI_ROLE_SWITCH_PENDING,		"Role Switch Pending"						},
+	{ HCI_SLOT_VIOLATION,			"Reserved Slot Violation"					},
+	{ HCI_ROLE_SWITCH_FAILED,		"Role Switch Failed"						},
+	{ 0, NULL },
+};
+
+static const char *bluez_dbus_error_to_str(const uint32_t ecode) 
+{
+	const bluez_error_t *ptr;
+	uint32_t raw_code = 0;
+
+	if (ecode & BLUEZ_ESYSTEM_OFFSET) {
+		/* System error */
+		raw_code = (~BLUEZ_ESYSTEM_OFFSET) & ecode;
+		syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, strerror(raw_code));
+		return strerror(raw_code);
+	} else if (ecode & BLUEZ_EDBUS_OFFSET) {
+		/* D-Bus error */
+		for (ptr = dbus_error_array; ptr->code; ptr++) {
+			if (ptr->code == ecode) {
+				syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
+				return ptr->str;
+			}
+		}
+	} else {
+		/* BLUEZ_EBT_OFFSET - Bluetooth HCI errors */
+		for (ptr = hci_error_array; ptr->code; ptr++) {
+			if (ptr->code == ecode) {
+				syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
+				return ptr->str;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode)
+{
+	DBusMessageIter iter;
+	DBusMessage *reply;
+	const char *error_msg;
+
+	error_msg = bluez_dbus_error_to_str(ecode);
+	if (!error_msg)
+		return NULL;
+
+	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;
+}
diff --git a/hcid/dbus-manager.c b/hcid/dbus-manager.c
new file mode 100644
index 00000000..dfb00022
--- /dev/null
+++ b/hcid/dbus-manager.c
@@ -0,0 +1,183 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include <dbus/dbus.h>
+
+#include "hcid.h"
+#include "dbus.h"
+
+static DBusMessage* handle_mgr_device_list_req(DBusMessage *msg, void *data)
+{
+	DBusMessageIter iter;
+	DBusMessageIter array_iter;
+	DBusMessage *reply;
+	struct hci_dev_list_req *dl;
+	struct hci_dev_req *dr;
+	int i, sk = -1;
+
+	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
+	if (sk < 0) {
+		syslog(LOG_ERR, "Can't open HCI socket: %s (%d)", strerror(errno), errno);
+		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+	}
+
+	dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
+	if (!dl) {
+		syslog(LOG_ERR, "Can't allocate memory");
+		close(sk);
+		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
+	}
+
+	dl->dev_num = HCI_MAX_DEV;
+	dr = dl->dev_req;
+
+	if (ioctl(sk, HCIGETDEVLIST, dl) < 0) {
+		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+		goto failed;
+	}
+
+	dr = dl->dev_req;
+
+	reply = dbus_message_new_method_return(msg);
+	if (reply == NULL) {
+		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
+		goto failed;
+	}
+
+	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 < dl->dev_num; i++, dr++) {
+		char path[MAX_PATH_LENGTH], *path_ptr = path;
+		struct hci_dev_info di;
+
+		memset(&di, 0 , sizeof(struct hci_dev_info));
+		di.dev_id = dr->dev_id;
+
+		if (ioctl(sk, HCIGETDEVINFO, &di) < 0)
+			continue;
+
+		snprintf(path, sizeof(path), "%s/%s", DEVICE_PATH, di.name);
+
+		dbus_message_iter_append_basic(&array_iter,
+						DBUS_TYPE_STRING, &path_ptr);
+	}
+
+	dbus_message_iter_close_container(&iter, &array_iter);
+
+failed:
+	free(dl);
+
+	close(sk);
+
+	return reply;
+}
+
+static DBusMessage* handle_mgr_default_device_req(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 bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply) {
+		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
+		return reply;
+	}
+
+	snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, default_dev);
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &path_ptr,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static const struct service_data mgr_services[] = {
+	{ MGR_DEVICE_LIST,	handle_mgr_device_list_req,		MGR_DEVICE_LIST_SIGNATURE	},
+	{ MGR_DEFAULT_DEVICE,	handle_mgr_default_device_req,		MGR_DEFAULT_DEVICE_SIGNATURE	},
+	{ NULL, NULL, NULL }
+};
+
+DBusHandlerResult msg_func_manager(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	const struct service_data *handlers;
+	DBusMessage *reply = NULL;
+	const char *iface;
+	const char *method;
+	const char *signature;
+	uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
+	DBusHandlerResult ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+	iface = dbus_message_get_interface(msg);
+	method = dbus_message_get_member(msg);
+	signature = dbus_message_get_signature(msg);
+
+	syslog(LOG_INFO, "[%s,%d] path:%s, method:%s", __PRETTY_FUNCTION__, __LINE__, dbus_message_get_path(msg), method);
+
+	if (strcmp(iface, MANAGER_INTERFACE) != 0)
+		return ret;
+
+	for (handlers = mgr_services; handlers->name != NULL; handlers++) {
+		if (strcmp(handlers->name, method))
+			continue;
+
+		if (strcmp(handlers->signature, signature) != 0)
+			error = BLUEZ_EDBUS_WRONG_SIGNATURE;
+		else {
+			reply = handlers->handler_func(msg, data);
+			error = 0;
+		}
+
+		ret = DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	if (error)
+		reply = bluez_new_failure_msg(msg, error);
+
+	if (reply) {
+		if (!dbus_connection_send (conn, reply, NULL))
+			syslog(LOG_ERR, "Can't send reply message!");
+		dbus_message_unref(reply);
+	}
+
+	return ret;
+}
diff --git a/hcid/dbus.c b/hcid/dbus.c
index f123a993..fadc98d8 100644
--- a/hcid/dbus.c
+++ b/hcid/dbus.c
@@ -45,7 +45,6 @@
 
 #include "hcid.h"
 #include "dbus.h"
-#include "textfile.h"
 
 #ifndef DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT
 #define DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT	0x00
@@ -56,7 +55,6 @@ static int default_dev = -1;
 
 #define TIMEOUT				(30 * 1000)		/* 30 seconds */
 #define DBUS_RECONNECT_TIMER		(5 * 1000 * 1000)	/* 5 sec */
-#define MAX_PATH_LENGTH			64
 #define MAX_CONN_NUMBER			10
 
 #define PINAGENT_SERVICE_NAME BASE_INTERFACE ".PinAgent"
@@ -69,35 +67,14 @@ struct pin_request {
 	bdaddr_t bda;
 };
 
-typedef DBusMessage* (service_handler_func_t) (DBusMessage *, void *);
-
-struct service_data {
-	const char		*name;
-	service_handler_func_t	*handler_func;
-	const char		*signature;
-};
-
-struct hci_dbus_data {
-	uint16_t dev_id;
-	uint16_t path_id;
-	uint32_t path_data;
-};
-
-typedef int register_function_t(DBusConnection *conn, uint16_t id);
-typedef int unregister_function_t(DBusConnection *conn, uint16_t id);
-
-/*
- * Utility functions
- */
-static char *get_peer_name(const bdaddr_t *local, const bdaddr_t *peer)
+DBusConnection *get_dbus_connection(void)
 {
-	char filename[PATH_MAX + 1], addr[18];
-
-	ba2str(local, addr);
-	snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
+	return connection;
+}
 
-	ba2str(peer, addr);
-	return textfile_get(filename, addr);
+int get_default_dev_id(void)
+{
+	return default_dev;
 }
 
 static int8_t dev_append_signal_args(DBusMessage *signal, int first, va_list var_args)
@@ -126,7 +103,7 @@ failed:
 	return retval;
 }
 
-static DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const int first, ...)
+DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const int first, ...)
 {
 	DBusMessage *signal = NULL;
 	char path[MAX_PATH_LENGTH];
@@ -152,137 +129,8 @@ static DBusMessage *dev_signal_factory(const int devid, const char *prop_name, c
 }
 
 /*
- * D-Bus error messages functions and declarations.
- * This section should be moved to a common file 
- * in the future
- *
- */
-
-typedef struct  {
-	uint32_t code;
-	const char *str;
-} bluez_error_t;
-
-static const bluez_error_t dbus_error_array[] = {
-	{ BLUEZ_EDBUS_UNKNOWN_METHOD,	"Method not found"		},
-	{ BLUEZ_EDBUS_WRONG_SIGNATURE,	"Wrong method signature"	},
-	{ BLUEZ_EDBUS_WRONG_PARAM,	"Invalid parameters"		},
-	{ BLUEZ_EDBUS_RECORD_NOT_FOUND,	"No record found"		},
-	{ BLUEZ_EDBUS_NO_MEM,		"No memory"			},
-	{ BLUEZ_EDBUS_CONN_NOT_FOUND,	"Connection not found"		},
-	{ BLUEZ_EDBUS_UNKNOWN_PATH,	"Unknown D-BUS path"		},
-	{ BLUEZ_EDBUS_NOT_IMPLEMENTED,	"Method not implemented"	},
-	{ 0, NULL }
-};
-
-static const bluez_error_t hci_error_array[] = {
-	{ HCI_UNKNOWN_COMMAND,			"Unknown HCI Command"						},
-	{ HCI_NO_CONNECTION,			"Unknown Connection Identifier"					},
-	{ HCI_HARDWARE_FAILURE,			"Hardware Failure"						},
-	{ HCI_PAGE_TIMEOUT,			"Page Timeout"							},
-	{ HCI_AUTHENTICATION_FAILURE,		"Authentication Failure"					},
-	{ HCI_PIN_OR_KEY_MISSING,		"PIN Missing"							},
-	{ HCI_MEMORY_FULL,			"Memory Capacity Exceeded"					},
-	{ HCI_CONNECTION_TIMEOUT,		"Connection Timeout"						},
-	{ HCI_MAX_NUMBER_OF_CONNECTIONS,	"Connection Limit Exceeded"					},
-	{ HCI_MAX_NUMBER_OF_SCO_CONNECTIONS,	"Synchronous Connection Limit To A Device Exceeded"		},
-	{ HCI_ACL_CONNECTION_EXISTS,		"ACL Connection Already Exists"					},
-	{ HCI_COMMAND_DISALLOWED,		"Command Disallowed"						},
-	{ HCI_REJECTED_LIMITED_RESOURCES,	"Connection Rejected due to Limited Resources"			},
-	{ HCI_REJECTED_SECURITY,		"Connection Rejected Due To Security Reasons"			},
-	{ HCI_REJECTED_PERSONAL,		"Connection Rejected due to Unacceptable BD_ADDR"		},
-	{ HCI_HOST_TIMEOUT,			"Connection Accept Timeout Exceeded"				},
-	{ HCI_UNSUPPORTED_FEATURE,		"Unsupported Feature or Parameter Value"			},
-	{ HCI_INVALID_PARAMETERS,		"Invalid HCI Command Parameters"				},
-	{ HCI_OE_USER_ENDED_CONNECTION,		"Remote User Terminated Connection"				},
-	{ HCI_OE_LOW_RESOURCES,			"Remote Device Terminated Connection due to Low Resources"	},
-	{ HCI_OE_POWER_OFF,			"Remote Device Terminated Connection due to Power Off"		},
-	{ HCI_CONNECTION_TERMINATED,		"Connection Terminated By Local Host"				},
-	{ HCI_REPEATED_ATTEMPTS,		"Repeated Attempts"						},
-	{ HCI_PAIRING_NOT_ALLOWED,		"Pairing Not Allowed"						},
-	{ HCI_UNKNOWN_LMP_PDU,			"Unknown LMP PDU"						},
-	{ HCI_UNSUPPORTED_REMOTE_FEATURE,	"Unsupported Remote Feature"					},
-	{ HCI_SCO_OFFSET_REJECTED,		"SCO Offset Rejected"						},
-	{ HCI_SCO_INTERVAL_REJECTED,		"SCO Interval Rejected"						},
-	{ HCI_AIR_MODE_REJECTED,		"SCO Air Mode Rejected"						},
-	{ HCI_INVALID_LMP_PARAMETERS,		"Invalid LMP Parameters"					},
-	{ HCI_UNSPECIFIED_ERROR,		"Unspecified Error"						},
-	{ HCI_UNSUPPORTED_LMP_PARAMETER_VALUE,	"Unsupported LMP Parameter Value"				},
-	{ HCI_ROLE_CHANGE_NOT_ALLOWED,		"Role Change Not Allowed"					},
-	{ HCI_LMP_RESPONSE_TIMEOUT,		"LMP Response Timeout"						},
-	{ HCI_LMP_ERROR_TRANSACTION_COLLISION,	"LMP Error Transaction Collision"				},
-	{ HCI_LMP_PDU_NOT_ALLOWED,		"LMP PDU Not Allowed"						},
-	{ HCI_ENCRYPTION_MODE_NOT_ACCEPTED,	"Encryption Mode Not Acceptable"				},
-	{ HCI_UNIT_LINK_KEY_USED,		"Link Key Can Not be Changed"					},
-	{ HCI_QOS_NOT_SUPPORTED,		"Requested QoS Not Supported"					},
-	{ HCI_INSTANT_PASSED,			"Instant Passed"						},
-	{ HCI_PAIRING_NOT_SUPPORTED,		"Pairing With Unit Key Not Supported"				},
-	{ HCI_TRANSACTION_COLLISION,		"Different Transaction Collision"				},
-	{ HCI_QOS_UNACCEPTABLE_PARAMETER,	"QoS Unacceptable Parameter"					},
-	{ HCI_QOS_REJECTED,			"QoS Rejected"							},
-	{ HCI_CLASSIFICATION_NOT_SUPPORTED,	"Channel Classification Not Supported"				},
-	{ HCI_INSUFFICIENT_SECURITY,		"Insufficient Security"						},
-	{ HCI_PARAMETER_OUT_OF_RANGE,		"Parameter Out Of Mandatory Range"				},
-	{ HCI_ROLE_SWITCH_PENDING,		"Role Switch Pending"						},
-	{ HCI_SLOT_VIOLATION,			"Reserved Slot Violation"					},
-	{ HCI_ROLE_SWITCH_FAILED,		"Role Switch Failed"						},
-	{ 0, NULL },
-};
-
-static const char *bluez_dbus_error_to_str(const uint32_t ecode) 
-{
-	const bluez_error_t *ptr;
-	uint32_t raw_code = 0;
-
-	if (ecode & BLUEZ_ESYSTEM_OFFSET) {
-		/* System error */
-		raw_code = (~BLUEZ_ESYSTEM_OFFSET) & ecode;
-		syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, strerror(raw_code));
-		return strerror(raw_code);
-	} else if (ecode & BLUEZ_EDBUS_OFFSET) {
-		/* D-Bus error */
-		for (ptr = dbus_error_array; ptr->code; ptr++) {
-			if (ptr->code == ecode) {
-				syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
-				return ptr->str;
-			}
-		}
-	} else {
-		/* BLUEZ_EBT_OFFSET - Bluetooth HCI errors */
-		for (ptr = hci_error_array; ptr->code; ptr++) {
-			if (ptr->code == ecode) {
-				syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
-				return ptr->str;
-			}
-		}
-	}
-
-	return NULL;
-}
-
-static DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode)
-{
-	DBusMessageIter iter;
-	DBusMessage *reply;
-	const char *error_msg;
-
-	error_msg = bluez_dbus_error_to_str(ecode);
-	if (!error_msg)
-		return NULL;
-
-	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;
-}
-
-/*
  * Virtual table that handle the object path hierarchy
  */
-static DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data);
-static DBusHandlerResult msg_func_manager(DBusConnection *conn, DBusMessage *msg, void *data);
 
 static const DBusObjectPathVTable obj_dev_vtable = {
 	.message_function	= &msg_func_device,
@@ -295,108 +143,6 @@ static const DBusObjectPathVTable obj_mgr_vtable = {
 };
 
 /*
- * Services provided under the path DEVICE_PATH
- */
-
-static DBusMessage* handle_dev_get_address_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_alias_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_company_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_features_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_manufacturer_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_mode_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_name_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_get_revision_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_get_version_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_is_connectable_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_is_discoverable_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_set_alias_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_set_class_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_set_mode_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_set_name_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_discover_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_discover_cache_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_discover_cancel_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_discover_service_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_last_seen_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_last_used_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_remote_alias_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_remote_name_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_remote_version_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_create_bonding_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_list_bondings_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_has_bonding_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_remove_bonding_req(DBusMessage *msg, void *data);
-
-static DBusMessage* handle_dev_pin_code_length_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_dev_encryption_key_size_req(DBusMessage *msg, void *data);
-
-
-static const struct service_data dev_services[] = {
-	{ DEV_GET_ADDRESS,		handle_dev_get_address_req,		DEV_GET_ADDRESS_SIGNATURE		},
-	{ DEV_GET_ALIAS,		handle_dev_get_alias_req,		DEV_GET_ALIAS_SIGNATURE			},
-	{ DEV_GET_COMPANY,		handle_dev_get_company_req,		DEV_GET_COMPANY_SIGNATURE		},
-	{ DEV_GET_DISCOVERABLE_TO,	handle_dev_get_discoverable_to_req,	DEV_GET_DISCOVERABLE_TO_SIGNATURE	},
-	{ DEV_GET_FEATURES,		handle_dev_get_features_req,		DEV_GET_FEATURES_SIGNATURE		},
-	{ DEV_GET_MANUFACTURER,		handle_dev_get_manufacturer_req,	DEV_GET_MANUFACTURER_SIGNATURE		},
-	{ DEV_GET_MODE,			handle_dev_get_mode_req,		DEV_GET_MODE_SIGNATURE			},
-	{ DEV_GET_NAME,			handle_dev_get_name_req,		DEV_GET_NAME_SIGNATURE			},
-	{ DEV_GET_REVISION,		handle_dev_get_revision_req,		DEV_GET_REVISION_SIGNATURE		},
-	{ DEV_GET_VERSION,		handle_dev_get_version_req,		DEV_GET_VERSION_SIGNATURE		},
-
-	{ DEV_IS_CONNECTABLE,		handle_dev_is_connectable_req,		DEV_IS_CONNECTABLE_SIGNATURE		},
-	{ DEV_IS_DISCOVERABLE,		handle_dev_is_discoverable_req,		DEV_IS_DISCOVERABLE_SIGNATURE		},
-
-	{ DEV_SET_ALIAS,		handle_dev_set_alias_req,		DEV_SET_ALIAS_SIGNATURE			},
-	{ DEV_SET_CLASS,		handle_dev_set_class_req,		DEV_SET_CLASS_SIGNATURE			},
-	{ DEV_SET_DISCOVERABLE_TO,	handle_dev_set_discoverable_to_req,	DEV_SET_DISCOVERABLE_TO_SIGNATURE	},
-	{ DEV_SET_MODE,			handle_dev_set_mode_req,		DEV_SET_MODE_SIGNATURE			},
-	{ DEV_SET_NAME,			handle_dev_set_name_req,		DEV_SET_NAME_SIGNATURE			},
-
-	{ DEV_DISCOVER,			handle_dev_discover_req,		DEV_DISCOVER_SIGNATURE			},
-	{ DEV_DISCOVER_CACHE,		handle_dev_discover_cache_req,		DEV_DISCOVER_CACHE_SIGNATURE		},
-	{ DEV_DISCOVER_CANCEL,		handle_dev_discover_cancel_req,		DEV_DISCOVER_CANCEL_SIGNATURE		},
-	{ DEV_DISCOVER_SERVICE,		handle_dev_discover_service_req,	DEV_DISCOVER_SERVICE_SIGNATURE		},
-
-	{ DEV_LAST_SEEN,		handle_dev_last_seen_req,		DEV_LAST_SEEN_SIGNATURE			},
-	{ DEV_LAST_USED,		handle_dev_last_used_req,		DEV_LAST_USED_SIGNATURE			},
-
-	{ DEV_REMOTE_ALIAS,		handle_dev_remote_alias_req,		DEV_REMOTE_ALIAS_SIGNATURE		},
-	{ DEV_REMOTE_NAME,		handle_dev_remote_name_req,		DEV_REMOTE_NAME_SIGNATURE		},
-	{ DEV_REMOTE_VERSION,		handle_dev_remote_version_req,		DEV_REMOTE_VERSION_SIGNATURE		},
-
-	{ DEV_CREATE_BONDING,		handle_dev_create_bonding_req,		DEV_CREATE_BONDING_SIGNATURE		},
-	{ DEV_LIST_BONDINGS,		handle_dev_list_bondings_req,		DEV_LIST_BONDINGS_SIGNATURE		},
-	{ DEV_HAS_BONDING_NAME,		handle_dev_has_bonding_req,		DEV_HAS_BONDING_SIGNATURE		},
-	{ DEV_REMOVE_BONDING,		handle_dev_remove_bonding_req,		DEV_REMOVE_BONDING_SIGNATURE		},
-
-	{ DEV_PIN_CODE_LENGTH,		handle_dev_pin_code_length_req,		DEV_PIN_CODE_LENGTH_SIGNATURE		},
-	{ DEV_ENCRYPTION_KEY_SIZE,	handle_dev_encryption_key_size_req,	DEV_ENCRYPTION_KEY_SIZE_SIGNATURE	},
-
-	{ NULL, NULL, NULL}
-};
-
-/*
- * Services provided under the path MANAGER_PATH
- */
-static DBusMessage* handle_mgr_device_list_req(DBusMessage *msg, void *data);
-static DBusMessage* handle_mgr_default_device_req(DBusMessage *msg, void *data);
-
-static const struct service_data mgr_services[] = {
-	{ MGR_DEVICE_LIST,	handle_mgr_device_list_req,		MGR_DEVICE_LIST_SIGNATURE	},
-	{ MGR_DEFAULT_DEVICE,	handle_mgr_default_device_req,		MGR_DEFAULT_DEVICE_SIGNATURE	},
-	{ NULL, NULL, NULL }
-};
-
-/*
  * HCI D-Bus services
  */
 static DBusHandlerResult hci_dbus_signal_filter(DBusConnection *conn, DBusMessage *msg, void *data);
@@ -734,7 +480,7 @@ failed:
 	bt_free(peer_addr);
 }
 
-void hcid_dbus_discover_start(bdaddr_t *local)
+void hcid_dbus_inquiry_start(bdaddr_t *local)
 {
 	DBusMessage *message = NULL;
 	char path[MAX_PATH_LENGTH];
@@ -771,7 +517,7 @@ failed:
 	bt_free(local_addr);
 }
 
-void hcid_dbus_discover_complete(bdaddr_t *local)
+void hcid_dbus_inquiry_complete(bdaddr_t *local)
 {
 	DBusMessage *message = NULL;
 	char path[MAX_PATH_LENGTH];
@@ -808,7 +554,7 @@ failed:
 	bt_free(local_addr);
 }
 
-void hcid_dbus_discover_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi)
+void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi)
 {
 	DBusMessage *message = NULL;
 	char path[MAX_PATH_LENGTH];
@@ -1164,7 +910,6 @@ failed:
 
 	if (dl)
 		free(dl);
-
 }
 
 static void reconnect_timer_start(void)
@@ -1225,780 +970,6 @@ static DBusHandlerResult hci_dbus_signal_filter (DBusConnection *conn, DBusMessa
 	return ret;
 }
 
-static DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data)
-{
-	const struct service_data *handlers = dev_services;
-	DBusMessage *reply = NULL;
-	struct hci_dbus_data *dbus_data = data;
-	const char *method;
-	const char *signature;
-	uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
-	DBusHandlerResult ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
-	method = dbus_message_get_member(msg);
-	signature = dbus_message_get_signature(msg);
-
-	syslog(LOG_INFO, "[%s,%d] path:%s, method:%s", __PRETTY_FUNCTION__, __LINE__, dbus_message_get_path(msg), method);
-	       
-	if (dbus_data->path_id == DEVICE_ROOT_ID) {
-		/* Device is down(path unregistered) or the path is wrong */
-		ret = DBUS_HANDLER_RESULT_HANDLED;
-		error = BLUEZ_EDBUS_UNKNOWN_PATH;
-		goto failed;
-	}
-
-	/* It's a device path id */
-	for (; handlers->name != NULL; handlers++) {
-		if (strcmp(handlers->name, method))
-			continue;
-
-		ret = DBUS_HANDLER_RESULT_HANDLED;
-
-		if (!strcmp(handlers->signature, signature)) {
-			reply = handlers->handler_func(msg, data);
-			error = 0;
-			break;
-		} else {
-			/* Set the error, but continue looping incase there is
-			 * another method with the same name but a different
-			 * signature */
-			error = BLUEZ_EDBUS_WRONG_SIGNATURE;
-			continue;
-		}
-	}
-
-failed:
-	if (error)
-		reply = bluez_new_failure_msg(msg, error);
-
-	if (reply) {
-		if (!dbus_connection_send (conn, reply, NULL))
-			syslog(LOG_ERR, "Can't send reply message!");
-		dbus_message_unref(reply);
-	}
-
-	return ret;
-}
-
-static DBusHandlerResult msg_func_manager(DBusConnection *conn, DBusMessage *msg, void *data)
-{
-	const struct service_data *handlers;
-	DBusMessage *reply = NULL;
-	const char *iface;
-	const char *method;
-	const char *signature;
-	uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
-	DBusHandlerResult ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
-	iface = dbus_message_get_interface(msg);
-	method = dbus_message_get_member(msg);
-	signature = dbus_message_get_signature(msg);
-
-	syslog(LOG_INFO, "[%s,%d] path:%s, method:%s", __PRETTY_FUNCTION__, __LINE__, dbus_message_get_path(msg), method);
-
-	if (strcmp(iface, MANAGER_INTERFACE) != 0)
-		return ret;
-
-	for (handlers = mgr_services; handlers->name != NULL; handlers++) {
-		if (strcmp(handlers->name, method))
-			continue;
-
-		if (strcmp(handlers->signature, signature) != 0)
-			error = BLUEZ_EDBUS_WRONG_SIGNATURE;
-		else {
-			reply = handlers->handler_func(msg, data);
-			error = 0;
-		}
-
-		ret = DBUS_HANDLER_RESULT_HANDLED;
-	}
-
-	if (error)
-		reply = bluez_new_failure_msg(msg, error);
-
-	if (reply) {
-		if (!dbus_connection_send (conn, reply, NULL))
-			syslog(LOG_ERR, "Can't send reply message!");
-		dbus_message_unref(reply);
-	}
-
-	return ret;
-}
-
-/*****************************************************************
- *
- *  Section reserved to device D-Bus services implementation
- *
- *****************************************************************/
-
-static DBusMessage* handle_dev_get_address_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[18], *str_ptr = str;
-
-	get_device_address(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_version_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[20], *str_ptr = str;
-
-	get_device_version(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_revision_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[20], *str_ptr = str;
-
-	get_device_revision(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_manufacturer_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[64], *str_ptr = str;
-
-	get_device_manufacturer(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_company_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[64], *str_ptr = str;
-
-	get_device_company(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_features_req(DBusMessage *msg, void *data)
-{
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_get_name_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply;
-	char str[249], *str_ptr = str;
-
-	get_device_name(dbus_data->dev_id, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_set_name_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
-	DBusMessage *reply;
-	char *str_ptr;
-
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &str_ptr);
-
-	if (strlen(str_ptr) == 0) {
-		syslog(LOG_ERR, "Name change failed: Invalid parameter");
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-	}
-
-	set_device_name(dbus_data->dev_id, str_ptr);
-
-	reply = dbus_message_new_method_return(msg);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_alias_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
-	DBusMessage *reply;
-	char str[249], *str_ptr = str, *addr_ptr;
-	bdaddr_t bdaddr;
-
-	dbus_message_iter_init(msg, &iter);
-	dbus_message_iter_get_basic(&iter, &addr_ptr);
-
-	str2ba(addr_ptr, &bdaddr);
-
-	get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_set_alias_req(DBusMessage *msg, void *data)
-{
-	struct hci_dbus_data *dbus_data = data;
-	DBusMessageIter iter;
-	DBusMessage *reply, *signal;
-	char *str_ptr, *addr_ptr;
-	bdaddr_t bdaddr;
-
-	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);
-
-	if (strlen(str_ptr) == 0) {
-		syslog(LOG_ERR, "Alias change failed: Invalid parameter");
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-	}
-
-	str2ba(addr_ptr, &bdaddr);
-
-	set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
-
-	signal = dev_signal_factory(dbus_data->dev_id, "AliasChanged",
-						DBUS_TYPE_STRING, &addr_ptr,
-						DBUS_TYPE_STRING, &str_ptr,
-						DBUS_TYPE_INVALID);
-	if (signal) {
-		dbus_connection_send(connection, signal, NULL);
-		dbus_connection_flush(connection);
-		dbus_message_unref(signal);
-	}
-
-	signal = dev_signal_factory(dbus_data->dev_id, "RemoteAlias",
-						DBUS_TYPE_STRING, &addr_ptr,
-						DBUS_TYPE_STRING, &str_ptr,
-						DBUS_TYPE_INVALID);
-	if (signal) {
-		dbus_connection_send(connection, signal, NULL);
-		dbus_connection_flush(connection);
-		dbus_message_unref(signal);
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_get_mode_req(DBusMessage *msg, void *data)
-{
-	const struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply = NULL;
-	const uint8_t hci_mode = dbus_data->path_data;
-	uint8_t scan_mode;
-
-	switch (hci_mode) {
-	case SCAN_DISABLED:
-		scan_mode = MODE_OFF;
-		break;
-	case SCAN_PAGE:
-		scan_mode = MODE_CONNECTABLE;
-		break;
-	case (SCAN_PAGE | SCAN_INQUIRY):
-		scan_mode = MODE_DISCOVERABLE;
-		break;
-	case SCAN_INQUIRY:
-	/* inquiry scan mode is not handled, return 0xff */
-	default:
-		/* reserved */
-		scan_mode = 0xff;
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-	dbus_message_append_args(reply,
-					DBUS_TYPE_BYTE, &scan_mode,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_is_connectable_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_set_class_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_set_mode_req(DBusMessage *msg, void *data)
-{
-	const struct hci_dbus_data *dbus_data = data;
-	DBusMessage *reply = NULL;
-	struct hci_request rq;
-	int dd = -1;
-	const uint8_t scan_mode;
-	uint8_t hci_mode;
-	uint8_t status = 0;
-	const uint8_t current_mode = dbus_data->path_data;
-
-	dbus_message_get_args(msg, NULL,
-					DBUS_TYPE_BYTE, &scan_mode,
-					DBUS_TYPE_INVALID);
-
-	switch (scan_mode) {
-	case MODE_OFF:
-		hci_mode = SCAN_DISABLED;
-		break;
-	case MODE_CONNECTABLE:
-		hci_mode = SCAN_PAGE;
-		break;
-	case MODE_DISCOVERABLE:
-		hci_mode = (SCAN_PAGE | SCAN_INQUIRY);
-		break;
-	default:
-		/* invalid mode */
-		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-		goto failed;
-	}
-
-	dd = hci_open_dev(dbus_data->dev_id);
-	if (dd < 0) {
-		syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
-		goto failed;
-	}
-
-	/* Check if the new requested mode is different from the current */
-	if (current_mode != hci_mode) {
-		memset(&rq, 0, sizeof(rq));
-		rq.ogf    = OGF_HOST_CTL;
-		rq.ocf    = OCF_WRITE_SCAN_ENABLE;
-		rq.cparam = &hci_mode;
-		rq.clen   = sizeof(hci_mode);
-		rq.rparam = &status;
-		rq.rlen   = sizeof(status);
-
-		if (hci_send_req(dd, &rq, 100) < 0) {
-			syslog(LOG_ERR, "Sending write scan enable command failed: %s (%d)",
-							strerror(errno), errno);
-			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-			goto failed;
-		}
-		if (status) {
-			syslog(LOG_ERR, "Setting scan enable failed with status 0x%02x", status);
-			reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
-			goto failed;
-		}
-
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-failed:
-	if (dd >= 0)
-		close(dd);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_discover_req(DBusMessage *msg, void *data)
-{
-	DBusMessage *reply = NULL;
-	inquiry_cp cp;
-	evt_cmd_status rp;
-	struct hci_request rq;
-	struct hci_dbus_data *dbus_data = data;
-	int dd = -1;
-	uint8_t length = 8, num_rsp = 0;
-	uint32_t lap = 0x9e8b33;
-
-	dd = hci_open_dev(dbus_data->dev_id);
-	if (dd < 0) {
-		syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
-					dbus_data->dev_id, strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	memset(&cp, 0, sizeof(cp));
-	cp.lap[0]  = lap & 0xff;
-	cp.lap[1]  = (lap >> 8) & 0xff;
-	cp.lap[2]  = (lap >> 16) & 0xff;
-	cp.length  = length;
-	cp.num_rsp = num_rsp;
-
-	memset(&rq, 0, sizeof(rq));
-	rq.ogf    = OGF_LINK_CTL;
-	rq.ocf    = OCF_INQUIRY;
-	rq.cparam = &cp;
-	rq.clen   = INQUIRY_CP_SIZE;
-	rq.rparam = &rp;
-	rq.rlen   = EVT_CMD_STATUS_SIZE;
-	rq.event  = EVT_CMD_STATUS;
-
-	if (hci_send_req(dd, &rq, 100) < 0) {
-		syslog(LOG_ERR, "Unable to start inquiry: %s (%d)",
-							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-failed:
-	if (dd >= 0)
-		hci_close_dev(dd);
-
-	return reply;
-
-}
-
-static DBusMessage* handle_dev_discover_cache_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_discover_cancel_req(DBusMessage *msg, void *data)
-{
-	DBusMessage *reply = NULL;
-	struct hci_request rq;
-	struct hci_dbus_data *dbus_data = data;
-	uint8_t status;
-	int dd = -1;
-
-	dd = hci_open_dev(dbus_data->dev_id);
-	if (dd < 0) {
-		syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
-					dbus_data->dev_id, strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	memset(&rq, 0, sizeof(rq));
-	rq.ogf    = OGF_LINK_CTL;
-	rq.ocf    = OCF_INQUIRY_CANCEL;
-	rq.rparam = &status;
-	rq.rlen   = sizeof(status);
-
-	if (hci_send_req(dd, &rq, 100) < 0) {
-		syslog(LOG_ERR, "Sending cancel inquiry failed: %s (%d)",
-							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	if (status) {
-		syslog(LOG_ERR, "Cancel inquiry failed with status 0x%02x", status);
-		reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + status);
-		goto failed;
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-failed:
-	if (dd >= 0)
-		hci_close_dev(dd);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_discover_service_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_last_seen_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_last_used_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_remote_alias_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_remote_name_req(DBusMessage *msg, void *data)
-{
-	DBusMessage *reply = NULL;
-	DBusMessage *signal = NULL;
-	struct hci_dbus_data *dbus_data = data;
-	const char *str_bdaddr;
-	char *name;
-	char path[MAX_PATH_LENGTH];
-	bdaddr_t bdaddr;
-	struct hci_dev_info di;
-	struct hci_request rq;
-	remote_name_req_cp cp;
-	evt_cmd_status rp;
-	int dd = -1;
-
-	dbus_message_get_args(msg, NULL,
-					DBUS_TYPE_STRING, &str_bdaddr,
-					DBUS_TYPE_INVALID);
-
-	str2ba(str_bdaddr, &bdaddr);
-	if (hci_devinfo(dbus_data->dev_id, &di) < 0) {
-		syslog(LOG_ERR, "Can't get device info");
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
-		goto failed;
-	}
-
-	/* Try retrieve from local cache */
-	name = get_peer_name(&di.bdaddr, &bdaddr);
-	if (name) {
-
-		reply = dbus_message_new_method_return(msg);
-
-		snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, dbus_data->dev_id);
-
-		signal = dbus_message_new_signal(path, DEVICE_INTERFACE,
-							DEV_SIG_REMOTE_NAME);
-
-		dbus_message_append_args(signal,
-						DBUS_TYPE_STRING, &str_bdaddr,
-						DBUS_TYPE_STRING, &name,
-						DBUS_TYPE_INVALID);
-
-		if (dbus_connection_send(connection, signal, NULL) == FALSE) {
-			syslog(LOG_ERR, "Can't send D-BUS remote name signal message");
-			goto failed;
-		}
-
-		dbus_message_unref(signal);
-		free(name);
-
-	} else {
-
-		/* Send HCI command */
-		dd = hci_open_dev(dbus_data->dev_id);
-		if (dd < 0) {
-			syslog(LOG_ERR, "Unable to open device %d: %s (%d)",
-						dbus_data->dev_id, strerror(errno), errno);
-			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-			goto failed;
-		}
-
-		memset(&cp, 0, sizeof(cp));
-		cp.bdaddr = bdaddr;
-		cp.pscan_rep_mode = 0x02;
-
-		memset(&rq, 0, sizeof(rq));
-		rq.ogf    = OGF_LINK_CTL;
-		rq.ocf    = OCF_REMOTE_NAME_REQ;
-		rq.cparam = &cp;
-		rq.clen   = REMOTE_NAME_REQ_CP_SIZE;
-		rq.rparam = &rp;
-		rq.rlen   = EVT_CMD_STATUS_SIZE;
-		rq.event  = EVT_CMD_STATUS;
-
-		if (hci_send_req(dd, &rq, 100) < 0) {
-			syslog(LOG_ERR, "Unable to send remote name request: %s (%d)",
-						strerror(errno), errno);
-			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
-			goto failed;
-		}
-
-		if (rp.status) {
-			syslog(LOG_ERR, "Remote name request failed");
-			reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | rp.status);
-			goto failed;
-		}
-	}
-
-	reply = dbus_message_new_method_return(msg);
-failed:
-	if (dd >= 0)
-		hci_close_dev(dd);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_remote_version_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_create_bonding_req(DBusMessage *msg, void *data)
-{
-	struct hci_request rq;
-	auth_requested_cp cp;
-	evt_cmd_status rp;
-	DBusMessage *reply = NULL;
-	char *str_bdaddr = NULL;
-	struct hci_dbus_data *dbus_data = data;
-	struct hci_conn_info_req *cr = NULL;
-	bdaddr_t bdaddr;
-	int dev_id = -1;
-	int dd = -1;
-
-	dbus_message_get_args(msg, NULL,
-					DBUS_TYPE_STRING, &str_bdaddr,
-					DBUS_TYPE_INVALID);
-
-	str2ba(str_bdaddr, &bdaddr);
-
-	dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
-
-	if (dev_id < 0) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
-		goto failed;
-	}
-
-	if (dbus_data->dev_id != dev_id) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
-		goto failed;
-	}
-
-	dd = hci_open_dev(dev_id);
-	if (dd < 0) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
-		goto failed;
-	}
-
-	cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
-	if (!cr) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
-		goto failed;
-	}
-
-	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 failed;
-	}
-
-	memset(&cp, 0, sizeof(cp));
-	cp.handle = cr->conn_info->handle;
-
-	memset(&rq, 0, sizeof(rq));
-	rq.ogf    = OGF_LINK_CTL;
-	rq.ocf    = OCF_AUTH_REQUESTED;
-	rq.cparam = &cp;
-	rq.clen   = AUTH_REQUESTED_CP_SIZE;
-	rq.rparam = &rp;
-	rq.rlen   = EVT_CMD_STATUS_SIZE;
-	rq.event  = EVT_CMD_STATUS;
-
-	if (hci_send_req(dd, &rq, 100) < 0) {
-		syslog(LOG_ERR, "Unable to send authentication request: %s (%d)",
-							strerror(errno), errno);
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	reply = dbus_message_new_method_return(msg);
-
-failed:
-	if (dd >= 0)
-		close(dd);
-
-	if (cr)
-		free(cr);
-
-	return reply;
-}
-
-static DBusMessage* handle_dev_list_bondings_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_has_bonding_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-
-static DBusMessage* handle_dev_pin_code_length_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage* handle_dev_encryption_key_size_req(DBusMessage *msg, void *data)
-{
-	/*FIXME: */
-	return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
 /*****************************************************************
  *  
  *  Section reserved to device HCI callbacks
@@ -2173,99 +1144,3 @@ failed:
 
 	bt_free(local_addr);
 }
-
-/*****************************************************************
- *  
- *  Section reserved to Manager D-Bus services implementation
- *  
- *****************************************************************/
-static DBusMessage* handle_mgr_device_list_req(DBusMessage *msg, void *data)
-{
-	DBusMessageIter iter;
-	DBusMessageIter array_iter;
-	DBusMessage *reply;
-	struct hci_dev_list_req *dl = NULL;
-	struct hci_dev_req *dr      = NULL;
-	int i, sk = -1;
-
-	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
-	if (sk < 0) {
-		syslog(LOG_ERR, "Can't open HCI socket: %s (%d)", strerror(errno), errno);
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-	}
-
-	dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
-	if (!dl) {
-		syslog(LOG_ERR, "Can't allocate memory");
-		close(sk);
-		return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
-	}
-
-	dl->dev_num = HCI_MAX_DEV;
-	dr = dl->dev_req;
-
-	if (ioctl(sk, HCIGETDEVLIST, dl) < 0) {
-		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
-		goto failed;
-	}
-
-	dr = dl->dev_req;
-
-	reply = dbus_message_new_method_return(msg);
-	if (reply == NULL) {
-		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
-		goto failed;
-	}
-
-	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 < dl->dev_num; i++, dr++) {
-		char path[MAX_PATH_LENGTH], *path_ptr = path;
-		struct hci_dev_info di;
-
-		memset(&di, 0 , sizeof(struct hci_dev_info));
-		di.dev_id = dr->dev_id;
-
-		if (ioctl(sk, HCIGETDEVINFO, &di) < 0)
-			continue;
-
-		snprintf(path, sizeof(path), "%s/%s", DEVICE_PATH, di.name);
-
-		dbus_message_iter_append_basic(&array_iter,
-						DBUS_TYPE_STRING, &path_ptr);
-	}
-
-	dbus_message_iter_close_container(&iter, &array_iter);
-
-failed:
-	free(dl);
-
-	close(sk);
-
-	return reply;
-}
-
-static DBusMessage* handle_mgr_default_device_req(DBusMessage *msg, void *data)
-{
-	DBusMessage *reply;
-	char path[MAX_PATH_LENGTH], *path_ptr = path;
-
-	if (default_dev < 0)
-		return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
-
-	reply = dbus_message_new_method_return(msg);
-	if (!reply) {
-		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
-		return reply;
-	}
-
-	snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, default_dev);
-
-	dbus_message_append_args(reply, DBUS_TYPE_STRING, &path_ptr,
-					DBUS_TYPE_INVALID);
-
-	return reply;
-}
diff --git a/hcid/dbus.h b/hcid/dbus.h
index 668302c3..913733f7 100644
--- a/hcid/dbus.h
+++ b/hcid/dbus.h
@@ -52,6 +52,36 @@
 #define INVALID_PATH_ID		0xFFFF
 #define INVALID_DEV_ID		0xFFFF
 
+#define MAX_PATH_LENGTH		64
+
+typedef DBusMessage* (service_handler_func_t) (DBusMessage *, void *);
+
+struct service_data {
+	const char		*name;
+	service_handler_func_t	*handler_func;
+	const char		*signature;
+};
+
+struct hci_dbus_data {
+	uint16_t dev_id;
+	uint16_t path_id;
+	uint32_t path_data;
+};
+
+typedef int register_function_t(DBusConnection *conn, uint16_t id);
+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);
+
+DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const int first, ...);
+
+DBusConnection *get_dbus_connection(void);
+
+int get_default_dev_id(void);
+
 /*======================================================================== 
     BlueZ D-Bus Manager service definitions "/org/bluez/Manager"
  *========================================================================*/
diff --git a/hcid/hcid.h b/hcid/hcid.h
index dc7d71e9..52e44f32 100644
--- a/hcid/hcid.h
+++ b/hcid/hcid.h
@@ -124,9 +124,9 @@ gboolean hcid_dbus_dev_up(uint16_t id);
 gboolean hcid_dbus_dev_down(uint16_t id);
 void hcid_dbus_request_pin(int dev, struct hci_conn_info *ci);
 
-void hcid_dbus_discover_start(bdaddr_t *local);
-void hcid_dbus_discover_complete(bdaddr_t *local);
-void hcid_dbus_discover_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi);
+void hcid_dbus_inquiry_start(bdaddr_t *local);
+void hcid_dbus_inquiry_complete(bdaddr_t *local);
+void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi);
 void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, char *name);
 void hcid_dbus_remote_name_failed(bdaddr_t *local, bdaddr_t *peer, uint8_t status);
 void hcid_dbus_conn_complete(bdaddr_t *local, bdaddr_t *peer);
diff --git a/hcid/security.c b/hcid/security.c
index 36774f2b..58b049ed 100644
--- a/hcid/security.c
+++ b/hcid/security.c
@@ -389,7 +389,7 @@ static inline void cmd_status(int dev, bdaddr_t *sba, void *ptr)
 		return;
 
 	if (evt->opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY))
-		hcid_dbus_discover_start(sba);
+		hcid_dbus_inquiry_start(sba);
 }
 
 static inline void cmd_complete(int dev, bdaddr_t *sba, void *ptr)
@@ -397,7 +397,7 @@ static inline void cmd_complete(int dev, bdaddr_t *sba, void *ptr)
 	evt_cmd_complete *evt = ptr;
 	switch (evt->opcode) {
 	case cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY_CANCEL):
-		hcid_dbus_discover_complete(sba);
+		hcid_dbus_inquiry_complete(sba);
 		break;
 	case cmd_opcode_pack(OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME):
 		hcid_dbus_setname_complete(sba);
@@ -442,7 +442,7 @@ static inline void remote_version_information(int dev, bdaddr_t *sba, void *ptr)
 
 static inline void inquiry_complete(int dev, bdaddr_t *sba, void *ptr)
 {
-	hcid_dbus_discover_complete(sba);
+	hcid_dbus_inquiry_complete(sba);
 }
 
 static inline void inquiry_result(int dev, bdaddr_t *sba, int plen, void *ptr)
@@ -456,7 +456,7 @@ static inline void inquiry_result(int dev, bdaddr_t *sba, int plen, void *ptr)
 			| (info->dev_class[1] << 8)
 			| (info->dev_class[2] << 16);
 
-		hcid_dbus_discover_result(sba, &info->bdaddr, class, 0);
+		hcid_dbus_inquiry_result(sba, &info->bdaddr, class, 0);
 
 		update_lastseen(sba, &info->bdaddr);
 
@@ -479,7 +479,7 @@ static inline void inquiry_result_with_rssi(int dev, bdaddr_t *sba, int plen, vo
 				| (info->dev_class[1] << 8)
 				| (info->dev_class[2] << 16);
 
-			hcid_dbus_discover_result(sba, &info->bdaddr,
+			hcid_dbus_inquiry_result(sba, &info->bdaddr,
 							class, info->rssi);
 
 			update_lastseen(sba, &info->bdaddr);
@@ -493,7 +493,7 @@ static inline void inquiry_result_with_rssi(int dev, bdaddr_t *sba, int plen, vo
 				| (info->dev_class[1] << 8)
 				| (info->dev_class[2] << 16);
 
-			hcid_dbus_discover_result(sba, &info->bdaddr,
+			hcid_dbus_inquiry_result(sba, &info->bdaddr,
 							class, info->rssi);
 
 			update_lastseen(sba, &info->bdaddr);
@@ -514,7 +514,7 @@ static inline void extended_inquiry_result(int dev, bdaddr_t *sba, int plen, voi
 			| (info->dev_class[1] << 8)
 			| (info->dev_class[2] << 16);
 
-		hcid_dbus_discover_result(sba, &info->bdaddr, class, info->rssi);
+		hcid_dbus_inquiry_result(sba, &info->bdaddr, class, info->rssi);
 
 		update_lastseen(sba, &info->bdaddr);