Import bluez-utils-3.36 revision history

1 files changed, 1571 insertions, 0 deletions

diff --git a/audio/manager.c b/audio/manager.c
new file mode 100644
index 00000000..18ef9eb4
--- /dev/null
+++ b/audio/manager.c
@@ -0,0 +1,1571 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2006-2007  Nokia Corporation
+ *  Copyright (C) 2004-2008  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 <stdlib.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <signal.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#include <bluetooth/rfcomm.h>
+#include <bluetooth/sdp.h>
+#include <bluetooth/sdp_lib.h>
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <gdbus.h>
+
+#include "glib-helper.h"
+
+#include "dbus-service.h"
+#include "logging.h"
+#include "textfile.h"
+#include "ipc.h"
+#include "device.h"
+#include "error.h"
+#include "avdtp.h"
+#include "a2dp.h"
+#include "headset.h"
+#include "gateway.h"
+#include "sink.h"
+#include "control.h"
+#include "manager.h"
+#include "sdpd.h"
+
+typedef enum {
+	HEADSET	= 1 << 0,
+	GATEWAY	= 1 << 1,
+	SINK	= 1 << 2,
+	SOURCE	= 1 << 3,
+	CONTROL	= 1 << 4,
+	TARGET	= 1 << 5,
+	INVALID	= 1 << 6
+} audio_service_type;
+
+typedef enum {
+		GENERIC_AUDIO = 0,
+		ADVANCED_AUDIO,
+		AV_REMOTE,
+		GET_RECORDS
+} audio_sdp_state_t;
+
+struct audio_sdp_data {
+	struct audio_device *device;
+
+	DBusMessage *msg;	/* Method call or NULL */
+
+	GSList *records;	/* sdp_record_t * */
+
+	audio_sdp_state_t state;
+
+	create_dev_cb_t cb;
+	void *cb_data;
+};
+
+static DBusConnection *connection = NULL;
+
+static struct audio_device *default_hs = NULL;
+static struct audio_device *default_dev = NULL;
+
+static GSList *devices = NULL;
+
+static uint32_t hsp_ag_record_id = 0;
+static uint32_t hfp_ag_record_id = 0;
+
+static uint32_t hsp_hs_record_id = 0;
+
+static GIOChannel *hsp_ag_server = NULL;
+static GIOChannel *hfp_ag_server = NULL;
+
+static GIOChannel *hsp_hs_server = NULL;
+
+static struct enabled_interfaces enabled = {
+	.headset	= TRUE,
+	.gateway	= FALSE,
+	.sink		= TRUE,
+	.source		= FALSE,
+	.control	= TRUE,
+};
+
+static DBusMessage *get_records(uuid_t *uuid, struct audio_sdp_data *data);
+
+static struct audio_device *create_device(const bdaddr_t *bda)
+{
+	static int device_id = 0;
+	char path[128];
+
+	snprintf(path, sizeof(path) - 1,
+			"%s/device%d", AUDIO_MANAGER_PATH, device_id++);
+
+	return device_register(connection, path, bda);
+}
+
+static void destroy_device(struct audio_device *device)
+{
+	g_dbus_unregister_all_interfaces(connection, device->path);
+}
+
+static void remove_device(struct audio_device *device)
+{
+	if (device == default_dev) {
+		debug("Removing default device");
+		default_dev = NULL;
+	}
+
+	if (device == default_hs) {
+		debug("Removing default headset");
+		default_hs = NULL;
+	}
+
+	devices = g_slist_remove(devices, device);
+
+	destroy_device(device);
+}
+
+static gboolean add_device(struct audio_device *device, gboolean send_signals)
+{
+	if (!send_signals)
+		goto add;
+
+	g_dbus_emit_signal(connection, AUDIO_MANAGER_PATH,
+					AUDIO_MANAGER_INTERFACE,
+					"DeviceCreated",
+					DBUS_TYPE_STRING, &device->path,
+					DBUS_TYPE_INVALID);
+
+	if (device->headset)
+		g_dbus_emit_signal(connection,
+				AUDIO_MANAGER_PATH,
+				AUDIO_MANAGER_INTERFACE,
+				"HeadsetCreated",
+				DBUS_TYPE_STRING, &device->path,
+				DBUS_TYPE_INVALID);
+add:
+
+	if (default_dev == NULL && g_slist_length(devices) == 0) {
+		debug("Selecting default device");
+		default_dev = device;
+	}
+
+	if (!default_hs && device->headset && !devices)
+		default_hs = device;
+
+	devices = g_slist_append(devices, device);
+
+	return TRUE;
+}
+
+static uint16_t get_service_uuid(const sdp_record_t *record)
+{
+	sdp_list_t *classes;
+	uuid_t uuid;
+	uint16_t uuid16 = 0;
+
+	if (sdp_get_service_classes(record, &classes) < 0) {
+		error("Unable to get service classes from record");
+		return 0;
+	}
+
+	memcpy(&uuid, classes->data, sizeof(uuid));
+
+	if (!sdp_uuid128_to_uuid(&uuid)) {
+		error("Not a 16 bit UUID");
+		sdp_list_free(classes, free);
+		return 0;
+	}
+
+	if (uuid.type == SDP_UUID32) {
+		if (uuid.value.uuid32 > 0xFFFF) {
+			error("Not a 16 bit UUID");
+			goto done;
+		}
+		uuid16 = (uint16_t) uuid.value.uuid32;
+	} else
+		uuid16 = uuid.value.uuid16;
+
+done:
+	sdp_list_free(classes, free);
+
+	return uuid16;
+}
+
+gboolean server_is_enabled(uint16_t svc)
+{
+	gboolean ret;
+
+	switch (svc) {
+	case HEADSET_SVCLASS_ID:
+		ret = (hsp_ag_server != NULL);
+		break;
+	case HEADSET_AGW_SVCLASS_ID:
+		ret = (hsp_hs_server != NULL);
+		break;
+	case HANDSFREE_SVCLASS_ID:
+		ret = (hfp_ag_server != NULL);
+		break;
+	case HANDSFREE_AGW_SVCLASS_ID:
+		ret = FALSE;
+		break;
+	case AUDIO_SINK_SVCLASS_ID:
+		return enabled.sink;
+	case AV_REMOTE_TARGET_SVCLASS_ID:
+	case AV_REMOTE_SVCLASS_ID:
+		return enabled.control;
+	default:
+		ret = FALSE;
+		break;
+	}
+
+	return ret;
+}
+
+static void handle_record(sdp_record_t *record, struct audio_device *device)
+{
+	gboolean is_default;
+	uint16_t uuid16;
+
+	uuid16 = get_service_uuid(record);
+
+	if (!server_is_enabled(uuid16))
+		return;
+
+	switch (uuid16) {
+	case HEADSET_SVCLASS_ID:
+		debug("Found Headset record");
+		if (device->headset)
+			headset_update(device, record, uuid16);
+		else
+			device->headset = headset_init(device,
+							record, uuid16);
+		break;
+	case HEADSET_AGW_SVCLASS_ID:
+		debug("Found Headset AG record");
+		break;
+	case HANDSFREE_SVCLASS_ID:
+		debug("Found Hansfree record");
+		if (device->headset)
+			headset_update(device, record, uuid16);
+		else
+			device->headset = headset_init(device,
+							record, uuid16);
+		break;
+	case HANDSFREE_AGW_SVCLASS_ID:
+		debug("Found Handsfree AG record");
+		break;
+	case AUDIO_SINK_SVCLASS_ID:
+		debug("Found Audio Sink");
+		if (device->sink == NULL)
+			device->sink = sink_init(device);
+		break;
+	case AUDIO_SOURCE_SVCLASS_ID:
+		debug("Found Audio Source");
+		break;
+	case AV_REMOTE_SVCLASS_ID:
+		debug("Found AV Remote");
+		if (device->control == NULL)
+			device->control = control_init(device);
+		if (device->sink && sink_is_active(device))
+			avrcp_connect(device);
+		break;
+	case AV_REMOTE_TARGET_SVCLASS_ID:
+		debug("Found AV Target");
+		if (device->control == NULL)
+			device->control = control_init(device);
+		if (device->sink && sink_is_active(device))
+			avrcp_connect(device);
+		break;
+	default:
+		debug("Unrecognized UUID: 0x%04X", uuid16);
+		break;
+	}
+
+	is_default = (default_dev == device) ? TRUE : FALSE;
+
+	device_store(device, is_default);
+}
+
+static void finish_sdp(struct audio_sdp_data *data, gboolean success)
+{
+	const char *addr;
+	DBusMessage *reply = NULL;
+	DBusError derr;
+
+	debug("Audio service discovery completed with %s",
+			success ? "success" : "failure");
+
+	if (!success)
+		goto done;
+
+	if (!data->msg)
+		goto update;
+
+	dbus_error_init(&derr);
+	dbus_message_get_args(data->msg, &derr,
+				DBUS_TYPE_STRING, &addr,
+				DBUS_TYPE_INVALID);
+
+	if (dbus_error_is_set(&derr)) {
+		error("Unable to get message args");
+		success = FALSE;
+		error_failed(connection, data->msg, derr.message);
+		dbus_error_free(&derr);
+		goto done;
+	}
+
+	/* Return error if no audio related service records were found */
+	if (!data->records) {
+		debug("No audio audio related service records were found");
+		success = FALSE;
+		error_not_supported(connection, data->msg);
+		goto done;
+	}
+
+	reply = dbus_message_new_method_return(data->msg);
+	if (!reply) {
+		success = FALSE;
+		error_failed(connection, data->msg, "Out of memory");
+		goto done;
+	}
+
+update:
+	g_slist_foreach(data->records, (GFunc) handle_record, data->device);
+
+	if (!g_slist_find(devices, data->device))
+		add_device(data->device, TRUE);
+
+	if (reply) {
+		dbus_message_append_args(reply, DBUS_TYPE_STRING,
+					&data->device->path,
+					DBUS_TYPE_INVALID);
+		dbus_connection_send(connection, reply, NULL);
+		dbus_message_unref(reply);
+	}
+
+done:
+	if (success) {
+		if (data->cb)
+			data->cb(data->device, data->cb_data);
+	} else {
+		if (data->cb)
+			data->cb(NULL, data->cb_data);
+		if (!g_slist_find(devices, data->device))
+			destroy_device(data->device);
+	}
+	if (data->msg)
+		dbus_message_unref(data->msg);
+	g_slist_foreach(data->records, (GFunc) sdp_record_free, NULL);
+	g_slist_free(data->records);
+	g_free(data);
+}
+
+static void get_records_cb(sdp_list_t *recs, int err, gpointer user_data)
+{
+	struct audio_sdp_data *data = user_data;
+	sdp_list_t *seq;
+	uuid_t uuid;
+
+	if (err < 0) {
+		error_connection_attempt_failed(connection, data->msg, -err);
+		finish_sdp(data, FALSE);
+		return;
+	}
+
+	for (seq = recs; seq; seq = seq->next) {
+		sdp_record_t *rec = (sdp_record_t *) seq->data;
+
+		if (!rec)
+			break;
+
+		data->records = g_slist_append(data->records, rec);
+	}
+
+	sdp_list_free(recs, NULL);
+
+	data->state++;
+
+	switch (data->state) {
+	case ADVANCED_AUDIO:
+		sdp_uuid16_create(&uuid, ADVANCED_AUDIO_SVCLASS_ID);
+		break;
+	case AV_REMOTE:
+		sdp_uuid16_create(&uuid, AV_REMOTE_SVCLASS_ID);
+		break;
+	default:
+		finish_sdp(data, TRUE);
+		return;
+	}
+
+	get_records(&uuid, data);
+}
+
+static DBusMessage *get_records(uuid_t *uuid, struct audio_sdp_data *data)
+{
+	struct audio_device *device = data->device;
+	DBusMessage *reply = NULL;
+	int err;
+
+	err = bt_search_service(&device->src, &device->dst, uuid,
+				get_records_cb, data, NULL);
+	if (!err)
+		return NULL;
+
+	if (data->msg)
+		reply = g_dbus_create_error(data->msg,
+				ERROR_INTERFACE ".ConnectionAttemptFailed",
+				strerror(-err));
+
+	finish_sdp(data, FALSE);
+
+	return reply;
+}
+
+static DBusMessage *resolve_services(DBusMessage *msg,
+					struct audio_device *device,
+					create_dev_cb_t cb,
+					void *user_data)
+{
+	struct audio_sdp_data *sdp_data;
+	uuid_t uuid;
+
+	sdp_data = g_new0(struct audio_sdp_data, 1);
+	if (msg)
+		sdp_data->msg = dbus_message_ref(msg);
+	sdp_data->device = device;
+	sdp_data->cb = cb;
+	sdp_data->cb_data = user_data;
+
+	sdp_uuid16_create(&uuid, GENERIC_AUDIO_SVCLASS_ID);
+
+	return get_records(&uuid, sdp_data);
+}
+
+struct audio_device *manager_device_connected(const bdaddr_t *bda, const char *uuid)
+{
+	struct audio_device *device;
+	const char *path;
+	gboolean headset = FALSE, created = FALSE;
+
+	device = manager_find_device(bda, NULL, FALSE);
+	if (!device) {
+		device = create_device(bda);
+		if (!device)
+			return NULL;
+		if (!add_device(device, TRUE)) {
+			destroy_device(device);
+			return NULL;
+		}
+		created = TRUE;
+	}
+
+	if (!strcmp(uuid, HSP_AG_UUID) || !strcmp(uuid, HFP_AG_UUID)) {
+		if (device->headset)
+			return device;
+
+		device->headset = headset_init(device, NULL, 0);
+
+		if (!device->headset)
+			return NULL;
+
+		headset = TRUE;
+	} else if (!strcmp(uuid, A2DP_SOURCE_UUID)) {
+		if (device->sink)
+			return device;
+
+		device->sink = sink_init(device);
+
+		if (!device->sink)
+			return NULL;
+	} else if (!strcmp(uuid, AVRCP_TARGET_UUID)) {
+		if (device->control)
+			return device;
+
+		device->control = control_init(device);
+
+		if (!device->control)
+			return NULL;
+	} else
+		return NULL;
+
+	path = device->path;
+
+	if (created) {
+		g_dbus_emit_signal(connection, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DeviceCreated",
+						DBUS_TYPE_STRING, &path,
+						DBUS_TYPE_INVALID);
+		resolve_services(NULL, device, NULL, NULL);
+	}
+
+	if (headset)
+		g_dbus_emit_signal(connection, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"HeadsetCreated",
+						DBUS_TYPE_STRING, &path,
+						DBUS_TYPE_INVALID);
+
+	if (headset && !default_hs) {
+		default_hs = device;
+		g_dbus_emit_signal(connection, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultHeadsetChanged",
+						DBUS_TYPE_STRING, &path,
+						DBUS_TYPE_INVALID);
+	}
+
+	if (!default_dev) {
+		default_dev = device;
+		g_dbus_emit_signal(connection, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultDeviceChanged",
+						DBUS_TYPE_STRING, &path,
+						DBUS_TYPE_INVALID);
+	}
+
+	return device;
+}
+
+gboolean manager_create_device(bdaddr_t *bda, create_dev_cb_t cb,
+				void *user_data)
+{
+	struct audio_device *dev;
+
+	dev = create_device(bda);
+	if (!dev)
+		return FALSE;
+
+	resolve_services(NULL, dev, cb, user_data);
+
+	return TRUE;
+}
+
+static DBusMessage *am_create_device(DBusConnection *conn,
+					DBusMessage *msg,
+					void *data)
+{
+	const char *address, *path;
+	bdaddr_t bda;
+	struct audio_device *device;
+	DBusMessage *reply;
+
+	if (!dbus_message_get_args(msg, NULL,
+				DBUS_TYPE_STRING, &address,
+				DBUS_TYPE_INVALID))
+		return NULL;
+
+	str2ba(address, &bda);
+
+	device = manager_find_device(&bda, NULL, FALSE);
+	if (!device) {
+		device = create_device(&bda);
+		return resolve_services(msg, device, NULL, NULL);
+	}
+
+	path = device->path;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &path,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *am_list_devices(DBusConnection *conn,
+						DBusMessage *msg,
+						void *data)
+{
+	DBusMessageIter iter, array_iter;
+	DBusMessage *reply;
+	DBusError derr;
+	GSList *l;
+	gboolean hs_only = FALSE;
+
+	dbus_error_init(&derr);
+
+	if (dbus_message_is_method_call(msg, AUDIO_MANAGER_INTERFACE,
+					"ListHeadsets"))
+		hs_only = TRUE;
+	else
+		hs_only = FALSE;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+				DBUS_TYPE_STRING_AS_STRING, &array_iter);
+
+	for (l = devices; l != NULL; l = l->next) {
+		struct audio_device *device = l->data;
+
+		if (hs_only && !device->headset)
+			continue;
+
+		dbus_message_iter_append_basic(&array_iter,
+						DBUS_TYPE_STRING, &device->path);
+	}
+
+	dbus_message_iter_close_container(&iter, &array_iter);
+
+	return reply;
+}
+
+static gint device_path_cmp(gconstpointer a, gconstpointer b)
+{
+	const struct audio_device *device = a;
+	const char *path = b;
+
+	return strcmp(device->path, path);
+}
+
+static DBusMessage *am_remove_device(DBusConnection *conn,
+					DBusMessage *msg,
+					void *data)
+{
+	DBusMessage *reply;
+	GSList *match;
+	const char *path;
+	struct audio_device *device;
+
+	if (!dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_STRING, &path,
+					DBUS_TYPE_INVALID))
+		return NULL;
+
+	match = g_slist_find_custom(devices, path, device_path_cmp);
+	if (!match)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	device = match->data;
+	device_remove_stored(device);
+	remove_device(device);
+
+	/* Fallback to a valid default */
+	if (default_dev == NULL) {
+		const char *param;
+		GSList *l;
+
+		default_dev = manager_find_device(BDADDR_ANY, NULL, TRUE);
+
+		if (!default_dev && devices) {
+			l = devices;
+			default_dev = (g_slist_last(l))->data;
+		}
+
+		param = default_dev ? default_dev->path : "";
+
+		g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultHeadsetChanged",
+						DBUS_TYPE_STRING, &param,
+						DBUS_TYPE_INVALID);
+
+		g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultDeviceChanged",
+						DBUS_TYPE_STRING, &param,
+						DBUS_TYPE_INVALID);
+
+		if (default_dev)
+			device_store(default_dev, TRUE);
+	}
+
+	g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+					AUDIO_MANAGER_INTERFACE,
+					"HeadsetRemoved",
+					DBUS_TYPE_STRING, &path,
+					DBUS_TYPE_INVALID);
+
+	g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+					AUDIO_MANAGER_INTERFACE,
+					"DeviceRemoved",
+					DBUS_TYPE_STRING, &path,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *am_find_by_addr(DBusConnection *conn,
+					DBusMessage *msg,
+					void *data)
+{
+	const char *address;
+	DBusMessage *reply;
+	struct audio_device *device;
+	bdaddr_t bda;
+
+	if (!dbus_message_get_args(msg, NULL,
+				DBUS_TYPE_STRING, &address,
+				DBUS_TYPE_INVALID))
+		return NULL;
+
+	str2ba(address, &bda);
+	device = manager_find_device(&bda, NULL, FALSE);
+
+	if (!device)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &device->path,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *am_default_device(DBusConnection *conn,
+					DBusMessage *msg,
+					void *data)
+{
+	DBusMessage *reply;
+
+	if (!default_dev)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	if (default_dev->headset == NULL &&
+		dbus_message_is_method_call(msg, AUDIO_MANAGER_INTERFACE,
+							"DefaultHeadset"))
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_append_args(reply, DBUS_TYPE_STRING, &default_dev->path,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *am_change_default_device(DBusConnection *conn,
+						DBusMessage *msg,
+						void *data)
+{
+	DBusMessage *reply;
+	GSList *match;
+	const char *path;
+	struct audio_device *device;
+
+	if (!dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_STRING, &path,
+					DBUS_TYPE_INVALID))
+		return NULL;
+
+	match = g_slist_find_custom(devices, path, device_path_cmp);
+	if (!match)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	device = match->data;
+
+	if (!dbus_message_is_method_call(msg, AUDIO_MANAGER_INTERFACE,
+		"ChangeDefaultHeadset"))
+		g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultDeviceChanged",
+						DBUS_TYPE_STRING, &device->path,
+						DBUS_TYPE_INVALID);
+	else if (device->headset)
+		g_dbus_emit_signal(conn, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE,
+						"DefaultHeadsetChanged",
+						DBUS_TYPE_STRING, &device->path,
+						DBUS_TYPE_INVALID);
+	else
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExists",
+						"Device does not exists");
+
+	default_dev = device;
+	device_store(device, TRUE);
+
+	return reply;
+}
+
+static GDBusMethodTable manager_methods[] = {
+	{ "CreateDevice",		"s",	"s",	am_create_device,
+							G_DBUS_METHOD_FLAG_ASYNC },
+	{ "RemoveDevice",		"s",	"",	am_remove_device },
+	{ "ListDevices",		"",	"as",	am_list_devices },
+	{ "DefaultDevice",		"",	"s",	am_default_device },
+	{ "ChangeDefaultDevice",	"s",	"",	am_change_default_device },
+	{ "CreateHeadset",		"s",	"s",	am_create_device,
+							G_DBUS_METHOD_FLAG_ASYNC },
+	{ "RemoveHeadset",		"s",	"",	am_remove_device },
+	{ "ListHeadsets",		"",	"as",	am_list_devices },
+	{ "FindDeviceByAddress",	"s",	"s",	am_find_by_addr },
+	{ "DefaultHeadset",		"",	"s",	am_default_device },
+	{ "ChangeDefaultHeadset",	"s",	"",	am_change_default_device },
+	{ }
+};
+
+static GDBusSignalTable manager_signals[] = {
+	{ "DeviceCreated",		"s"	},
+	{ "DeviceRemoved",		"s"	},
+	{ "HeadsetCreated",		"s"	},
+	{ "HeadsetRemoved",		"s"	},
+	{ "DefaultDeviceChanged",	"s"	},
+	{ "DefaultHeadsetChanged",	"s"	},
+	{ }
+};
+
+static void parse_stored_devices(char *key, char *value, void *data)
+{
+	bdaddr_t *src = data;
+	struct audio_device *device;
+	bdaddr_t dst;
+
+	if (!key || !value || strcmp(key, "default") == 0)
+		return;
+
+	str2ba(key, &dst);
+	device = manager_find_device(&dst, NULL, FALSE);
+
+	if (device)
+		return;
+
+	info("Loading device %s (%s)", key, value);
+
+	device = create_device(&dst);
+	if (!device)
+		return;
+
+	/* Change storage to source adapter */
+	bacpy(&device->store, src);
+
+	if (enabled.headset && strstr(value, "headset"))
+		device->headset = headset_init(device, NULL, 0);
+	if (enabled.sink && strstr(value, "sink"))
+		device->sink = sink_init(device);
+	if (enabled.control && strstr(value, "control"))
+		device->control = control_init(device);
+	add_device(device, FALSE);
+}
+
+static void register_devices_stored(const char *adapter)
+{
+	char filename[PATH_MAX + 1];
+	struct stat st;
+	struct audio_device *device;
+	bdaddr_t default_src;
+	bdaddr_t dst;
+	bdaddr_t src;
+	char *addr;
+	int dev_id;
+
+	create_name(filename, PATH_MAX, STORAGEDIR, adapter, "audio");
+
+	str2ba(adapter, &src);
+
+	if (stat(filename, &st) < 0)
+		return;
+
+	if (!(st.st_mode & __S_IFREG))
+		return;
+
+	textfile_foreach(filename, parse_stored_devices, &src);
+
+	bacpy(&default_src, BDADDR_ANY);
+	dev_id = hci_get_route(&default_src);
+	if (dev_id < 0 || hci_devba(dev_id, &default_src) < 0)
+		return;
+
+	if (bacmp(&default_src, &src) != 0)
+		return;
+
+	addr = textfile_get(filename, "default");
+	if (!addr)
+		return;
+
+	str2ba(addr, &dst);
+	device = manager_find_device(&dst, NULL, FALSE);
+
+	if (device) {
+		info("Setting %s as default device", addr);
+		default_dev = device;
+	}
+
+	free(addr);
+}
+
+static void register_stored(void)
+{
+	char dirname[PATH_MAX + 1];
+	struct dirent *de;
+	DIR *dir;
+
+	snprintf(dirname, PATH_MAX, "%s", STORAGEDIR);
+
+	dir = opendir(dirname);
+	if (!dir)
+		return;
+
+	while ((de = readdir(dir)) != NULL) {
+		if (!isdigit(de->d_name[0]))
+			continue;
+
+		/* Device objects */
+		register_devices_stored(de->d_name);
+	}
+
+	closedir(dir);
+}
+
+static void manager_unregister(void *data)
+{
+	info("Unregistered manager path");
+
+	if (devices) {
+		g_slist_foreach(devices, (GFunc) remove_device, NULL);
+		g_slist_free(devices);
+		devices = NULL;
+	}
+}
+
+static sdp_record_t *hsp_ag_record(uint8_t ch)
+{
+	sdp_list_t *svclass_id, *pfseq, *apseq, *root;
+	uuid_t root_uuid, svclass_uuid, ga_svclass_uuid;
+	uuid_t l2cap_uuid, rfcomm_uuid;
+	sdp_profile_desc_t profile;
+	sdp_record_t *record;
+	sdp_list_t *aproto, *proto[2];
+	sdp_data_t *channel;
+
+	record = sdp_record_alloc();
+	if (!record)
+		return NULL;
+
+	sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
+	root = sdp_list_append(0, &root_uuid);
+	sdp_set_browse_groups(record, root);
+
+	sdp_uuid16_create(&svclass_uuid, HEADSET_AGW_SVCLASS_ID);
+	svclass_id = sdp_list_append(0, &svclass_uuid);
+	sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
+	svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
+	sdp_set_service_classes(record, svclass_id);
+
+	sdp_uuid16_create(&profile.uuid, HEADSET_PROFILE_ID);
+	profile.version = 0x0100;
+	pfseq = sdp_list_append(0, &profile);
+	sdp_set_profile_descs(record, pfseq);
+
+	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
+	proto[0] = sdp_list_append(0, &l2cap_uuid);
+	apseq = sdp_list_append(0, proto[0]);
+
+	sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
+	proto[1] = sdp_list_append(0, &rfcomm_uuid);
+	channel = sdp_data_alloc(SDP_UINT8, &ch);
+	proto[1] = sdp_list_append(proto[1], channel);
+	apseq = sdp_list_append(apseq, proto[1]);
+
+	aproto = sdp_list_append(0, apseq);
+	sdp_set_access_protos(record, aproto);
+
+	sdp_set_info_attr(record, "Headset Audio Gateway", 0, 0);
+
+	sdp_data_free(channel);
+	sdp_list_free(proto[0], 0);
+	sdp_list_free(proto[1], 0);
+	sdp_list_free(apseq, 0);
+	sdp_list_free(pfseq, 0);
+	sdp_list_free(aproto, 0);
+	sdp_list_free(root, 0);
+	sdp_list_free(svclass_id, 0);
+
+	return record;
+}
+
+static sdp_record_t *hsp_hs_record(uint8_t ch)
+{
+	sdp_list_t *svclass_id, *pfseq, *apseq, *root;
+	uuid_t root_uuid, svclass_uuid, ga_svclass_uuid;
+	uuid_t l2cap_uuid, rfcomm_uuid;
+	sdp_profile_desc_t profile;
+	sdp_record_t *record;
+	sdp_list_t *aproto, *proto[2];
+	sdp_data_t *channel;
+
+	record = sdp_record_alloc();
+	if (!record)
+		return NULL;
+
+	sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
+	root = sdp_list_append(0, &root_uuid);
+	sdp_set_browse_groups(record, root);
+
+	sdp_uuid16_create(&svclass_uuid, HEADSET_SVCLASS_ID);
+	svclass_id = sdp_list_append(0, &svclass_uuid);
+	sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
+	svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
+	sdp_set_service_classes(record, svclass_id);
+
+	sdp_uuid16_create(&profile.uuid, HEADSET_PROFILE_ID);
+	profile.version = 0x0100;
+	pfseq = sdp_list_append(0, &profile);
+	sdp_set_profile_descs(record, pfseq);
+
+	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
+	proto[0] = sdp_list_append(0, &l2cap_uuid);
+	apseq = sdp_list_append(0, proto[0]);
+
+	sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
+	proto[1] = sdp_list_append(0, &rfcomm_uuid);
+	channel = sdp_data_alloc(SDP_UINT8, &ch);
+	proto[1] = sdp_list_append(proto[1], channel);
+	apseq = sdp_list_append(apseq, proto[1]);
+
+	aproto = sdp_list_append(0, apseq);
+	sdp_set_access_protos(record, aproto);
+
+	sdp_set_info_attr(record, "Headset", 0, 0);
+
+	sdp_data_free(channel);
+	sdp_list_free(proto[0], 0);
+	sdp_list_free(proto[1], 0);
+	sdp_list_free(apseq, 0);
+	sdp_list_free(pfseq, 0);
+	sdp_list_free(aproto, 0);
+	sdp_list_free(root, 0);
+	sdp_list_free(svclass_id, 0);
+
+	return record;
+}
+
+static sdp_record_t *hfp_ag_record(uint8_t ch, uint32_t feat)
+{
+	sdp_list_t *svclass_id, *pfseq, *apseq, *root;
+	uuid_t root_uuid, svclass_uuid, ga_svclass_uuid;
+	uuid_t l2cap_uuid, rfcomm_uuid;
+	sdp_profile_desc_t profile;
+	sdp_list_t *aproto, *proto[2];
+	sdp_record_t *record;
+	sdp_data_t *channel, *features;
+	uint8_t netid = 0x01;
+	uint16_t sdpfeat;
+	sdp_data_t *network = sdp_data_alloc(SDP_UINT8, &netid);
+
+	record = sdp_record_alloc();
+	if (!record)
+		return NULL;
+
+	sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
+	root = sdp_list_append(0, &root_uuid);
+	sdp_set_browse_groups(record, root);
+
+	sdp_uuid16_create(&svclass_uuid, HANDSFREE_AGW_SVCLASS_ID);
+	svclass_id = sdp_list_append(0, &svclass_uuid);
+	sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
+	svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
+	sdp_set_service_classes(record, svclass_id);
+
+	sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID);
+	profile.version = 0x0105;
+	pfseq = sdp_list_append(0, &profile);
+	sdp_set_profile_descs(record, pfseq);
+
+	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
+	proto[0] = sdp_list_append(0, &l2cap_uuid);
+	apseq = sdp_list_append(0, proto[0]);
+
+	sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
+	proto[1] = sdp_list_append(0, &rfcomm_uuid);
+	channel = sdp_data_alloc(SDP_UINT8, &ch);
+	proto[1] = sdp_list_append(proto[1], channel);
+	apseq = sdp_list_append(apseq, proto[1]);
+
+	sdpfeat = (uint16_t) feat & 0xF;
+	features = sdp_data_alloc(SDP_UINT16, &sdpfeat);
+	sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
+
+	aproto = sdp_list_append(0, apseq);
+	sdp_set_access_protos(record, aproto);
+
+	sdp_set_info_attr(record, "Hands-Free Audio Gateway", 0, 0);
+
+	sdp_attr_add(record, SDP_ATTR_EXTERNAL_NETWORK, network);
+
+	sdp_data_free(channel);
+	sdp_list_free(proto[0], 0);
+	sdp_list_free(proto[1], 0);
+	sdp_list_free(apseq, 0);
+	sdp_list_free(pfseq, 0);
+	sdp_list_free(aproto, 0);
+	sdp_list_free(root, 0);
+	sdp_list_free(svclass_id, 0);
+
+	return record;
+}
+
+static void auth_cb(DBusError *derr, void *user_data)
+{
+	struct audio_device *device = user_data;
+	const char *uuid;
+
+	if (get_hfp_active(device))
+		uuid = HFP_AG_UUID;
+	else
+		uuid = HSP_AG_UUID;
+
+	if (derr && dbus_error_is_set(derr)) {
+		error("Access denied: %s", derr->message);
+		if (dbus_error_has_name(derr, DBUS_ERROR_NO_REPLY)) {
+			debug("Canceling authorization request");
+			service_cancel_auth(&device->src, &device->dst);
+		}
+
+		headset_set_state(device, HEADSET_STATE_DISCONNECTED);
+	} else {
+		char hs_address[18];
+
+		headset_set_authorized(device);
+
+		ba2str(&device->dst, hs_address);
+
+		debug("Accepted headset connection from %s for %s",
+						hs_address, device->path);
+		headset_set_state(device, HEADSET_STATE_CONNECTED);
+	}
+}
+
+static void ag_io_cb(GIOChannel *chan, int err, const bdaddr_t *src,
+			const bdaddr_t *dst, gpointer data)
+{
+	const char *uuid;
+	struct audio_device *device;
+	gboolean hfp_active;
+
+	if (err < 0) {
+		error("accept: %s (%d)", strerror(-err), -err);
+		return;
+	}
+
+	if (chan == hsp_ag_server) {
+		hfp_active = FALSE;
+		uuid = HSP_AG_UUID;
+	} else {
+		hfp_active = TRUE;
+		uuid = HFP_AG_UUID;
+	}
+
+	device = manager_device_connected(dst, uuid);
+	if (!device)
+		goto drop;
+
+	if (headset_get_state(device) > HEADSET_STATE_DISCONNECTED) {
+		debug("Refusing new connection since one already exists");
+		goto drop;
+	}
+
+	set_hfp_active(device, hfp_active);
+
+	if (headset_connect_rfcomm(device, chan) < 0) {
+		error("Allocating new GIOChannel failed!");
+		goto drop;
+	}
+
+	err = service_req_auth(&device->src, &device->dst, uuid, auth_cb,
+				device);
+	if (err < 0) {
+		debug("Authorization denied: %s", strerror(-err));
+		headset_close_rfcomm(device);
+		return;
+	}
+
+	headset_set_state(device, HEADSET_STATE_CONNECT_IN_PROGRESS);
+
+	return;
+
+drop:
+	g_io_channel_close(chan);
+	g_io_channel_unref(chan);
+	return;
+}
+
+static void hs_io_cb(GIOChannel *chan, int err, const bdaddr_t *src,
+		const bdaddr_t *dst, void *data)
+{
+	/*Stub*/
+	return;
+}
+
+static int headset_server_init(DBusConnection *conn, GKeyFile *config)
+{
+	uint8_t chan = DEFAULT_HS_AG_CHANNEL;
+	sdp_record_t *record;
+	gboolean hfp = TRUE, master = TRUE;
+	GError *err = NULL;
+	uint32_t features, flags;
+
+	if (!enabled.headset)
+		return 0;
+
+	if (config) {
+		gboolean tmp;
+
+		tmp = g_key_file_get_boolean(config, "General", "Master",
+						&err);
+		if (err) {
+			debug("audio.conf: %s", err->message);
+			g_error_free(err);
+			err = NULL;
+		} else
+			master = tmp;
+
+		tmp = g_key_file_get_boolean(config, "Headset", "HFP",
+						&err);
+		if (err) {
+			debug("audio.conf: %s", err->message);
+			g_error_free(err);
+			err = NULL;
+		} else
+			hfp = tmp;
+	}
+
+	flags = RFCOMM_LM_SECURE;
+
+	if (master)
+		flags |= RFCOMM_LM_MASTER;
+
+	hsp_ag_server = bt_rfcomm_listen(BDADDR_ANY, chan, flags, ag_io_cb,
+				NULL);
+	if (!hsp_ag_server)
+		return -1;
+
+	record = hsp_ag_record(chan);
+	if (!record) {
+		error("Unable to allocate new service record");
+		return -1;
+	}
+
+	if (add_record_to_server(BDADDR_ANY, record) < 0) {
+		error("Unable to register HS AG service record");
+		sdp_record_free(record);
+		g_io_channel_unref(hsp_ag_server);
+		hsp_ag_server = NULL;
+		return -1;
+	}
+	hsp_ag_record_id = record->handle;
+
+	features = headset_config_init(config);
+
+	if (!hfp)
+		return 0;
+
+	chan = DEFAULT_HF_AG_CHANNEL;
+
+	hfp_ag_server = bt_rfcomm_listen(BDADDR_ANY, chan, flags, ag_io_cb,
+				NULL);
+	if (!hfp_ag_server)
+		return -1;
+
+	record = hfp_ag_record(chan, features);
+	if (!record) {
+		error("Unable to allocate new service record");
+		return -1;
+	}
+
+	if (add_record_to_server(BDADDR_ANY, record) < 0) {
+		error("Unable to register HF AG service record");
+		sdp_record_free(record);
+		g_io_channel_unref(hfp_ag_server);
+		hfp_ag_server = NULL;
+		return -1;
+	}
+	hfp_ag_record_id = record->handle;
+
+	return 0;
+}
+
+static int gateway_server_init(DBusConnection *conn, GKeyFile *config)
+{
+	uint8_t chan = DEFAULT_HSP_HS_CHANNEL;
+	sdp_record_t *record;
+	gboolean master = TRUE;
+	GError *err = NULL;
+	uint32_t flags;
+
+	if (!enabled.gateway)
+		return 0;
+
+	if (config) {
+		gboolean tmp;
+
+		tmp = g_key_file_get_boolean(config, "General", "Master",
+						&err);
+		if (err) {
+			debug("audio.conf: %s", err->message);
+			g_error_free(err);
+			err = NULL;
+		} else
+			master = tmp;
+	}
+
+	flags = RFCOMM_LM_SECURE;
+
+	if (master)
+		flags |= RFCOMM_LM_MASTER;
+
+	hsp_hs_server = bt_rfcomm_listen(BDADDR_ANY, chan, flags, hs_io_cb,
+				NULL);
+	if (!hsp_hs_server)
+		return -1;
+
+	record = hsp_hs_record(chan);
+	if (!record) {
+		error("Unable to allocate new service record");
+		return -1;
+	}
+
+	if (add_record_to_server(BDADDR_ANY, record) < 0) {
+		error("Unable to register HSP HS service record");
+		sdp_record_free(record);
+		g_io_channel_unref(hsp_hs_server);
+		hsp_hs_server = NULL;
+		return -1;
+	}
+
+	hsp_hs_record_id = record->handle;
+
+	return 0;
+}
+
+static void server_exit(void)
+{
+	if (hsp_ag_record_id) {
+		remove_record_from_server(hsp_ag_record_id);
+		hsp_ag_record_id = 0;
+	}
+
+	if (hsp_ag_server) {
+		g_io_channel_unref(hsp_ag_server);
+		hsp_ag_server = NULL;
+	}
+
+	if (hsp_hs_record_id) {
+		remove_record_from_server(hsp_hs_record_id);
+		hsp_hs_record_id = 0;
+	}
+
+	if (hsp_hs_server) {
+		g_io_channel_unref(hsp_hs_server);
+		hsp_hs_server = NULL;
+	}
+
+	if (hfp_ag_record_id) {
+		remove_record_from_server(hfp_ag_record_id);
+		hfp_ag_record_id = 0;
+	}
+
+	if (hfp_ag_server) {
+		g_io_channel_unref(hfp_ag_server);
+		hfp_ag_server = NULL;
+	}
+}
+
+int audio_manager_init(DBusConnection *conn, GKeyFile *config)
+{
+	char **list;
+	int i;
+
+	connection = dbus_connection_ref(conn);
+
+	if (!config)
+		goto proceed;
+
+	list = g_key_file_get_string_list(config, "General", "Enable",
+						NULL, NULL);
+	for (i = 0; list && list[i] != NULL; i++) {
+		if (g_str_equal(list[i], "Headset"))
+			enabled.headset = TRUE;
+		else if (g_str_equal(list[i], "Gateway"))
+			enabled.gateway = TRUE;
+		else if (g_str_equal(list[i], "Sink"))
+			enabled.sink = TRUE;
+		else if (g_str_equal(list[i], "Source"))
+			enabled.source = TRUE;
+		else if (g_str_equal(list[i], "Control"))
+			enabled.control = TRUE;
+	}
+	g_strfreev(list);
+
+	list = g_key_file_get_string_list(config, "General", "Disable",
+						NULL, NULL);
+	for (i = 0; list && list[i] != NULL; i++) {
+		if (g_str_equal(list[i], "Headset"))
+			enabled.headset = FALSE;
+		else if (g_str_equal(list[i], "Gateway"))
+			enabled.gateway = FALSE;
+		else if (g_str_equal(list[i], "Sink"))
+			enabled.sink = FALSE;
+		else if (g_str_equal(list[i], "Source"))
+			enabled.source = FALSE;
+		else if (g_str_equal(list[i], "Control"))
+			enabled.control = FALSE;
+	}
+	g_strfreev(list);
+
+proceed:
+	if (enabled.headset) {
+		if (headset_server_init(conn, config) < 0)
+			goto failed;
+	}
+
+	if (enabled.gateway) {
+		if (gateway_server_init(conn, config) < 0)
+			goto failed;
+	}
+
+	if (enabled.source || enabled.sink) {
+		if (a2dp_init(conn, config) < 0)
+			goto failed;
+	}
+
+	if (enabled.control && avrcp_init(conn, config) < 0)
+		goto failed;
+
+	if (!g_dbus_register_interface(conn, AUDIO_MANAGER_PATH,
+					AUDIO_MANAGER_INTERFACE,
+					manager_methods, manager_signals,
+					NULL, NULL, manager_unregister)) {
+		error("Failed to register %s interface to %s",
+				AUDIO_MANAGER_INTERFACE, AUDIO_MANAGER_PATH);
+		goto failed;
+	}
+
+	info("Registered manager path:%s", AUDIO_MANAGER_PATH);
+
+	register_stored();
+
+	return 0;
+failed:
+	audio_manager_exit();
+	return -1;
+}
+
+void audio_manager_exit(void)
+{
+	server_exit();
+
+	g_dbus_unregister_interface(connection, AUDIO_MANAGER_PATH,
+						AUDIO_MANAGER_INTERFACE);
+
+	dbus_connection_unref(connection);
+
+	connection = NULL;
+}
+
+struct audio_device *manager_default_device(void)
+{
+	return default_dev;
+}
+
+struct audio_device *manager_get_connected_device(void)
+{
+	GSList *l;
+
+	for (l = devices; l != NULL; l = g_slist_next(l)) {
+		struct audio_device *device = l->data;
+
+		if ((device->sink || device->source) &&
+				avdtp_is_connected(&device->src, &device->dst))
+			return device;
+
+		if (device->headset && headset_is_active(device))
+			return device;
+	}
+
+	return NULL;
+}
+
+struct audio_device *manager_find_device(const bdaddr_t *bda, const char *interface,
+					gboolean connected)
+{
+	GSList *l;
+
+	if (!bacmp(bda, BDADDR_ANY) && !interface && !connected)
+		return default_dev;
+
+	for (l = devices; l != NULL; l = l->next) {
+		struct audio_device *dev = l->data;
+
+		if (bacmp(bda, BDADDR_ANY) && bacmp(&dev->dst, bda))
+			continue;
+
+		if (interface && !strcmp(AUDIO_HEADSET_INTERFACE, interface)
+				&& !dev->headset)
+			continue;
+
+		if (interface && !strcmp(AUDIO_SINK_INTERFACE, interface)
+				&& !dev->sink)
+			continue;
+
+		if (interface && !strcmp(AUDIO_SOURCE_INTERFACE, interface)
+				&& !dev->source)
+			continue;
+
+		if (interface && !strcmp(AUDIO_CONTROL_INTERFACE, interface)
+				&& !dev->control)
+			continue;
+
+		if (connected && !device_is_connected(dev, interface))
+			continue;
+
+		return dev;
+	}
+
+	return NULL;
+}