[PATCH BlueZ v1 2/2] build: Remove health profiles support

@@ -93,7 +93,6 @@ tools/btgatt-server
 tools/create-image
 tools/test-runner
 tools/check-selftest
-tools/mcaptest
 tools/bneptest
 tools/isotest
 tools/iso-tester

@@ -486,8 +486,6 @@ EXTRA_DIST += doc/assigned-numbers.rst doc/supported-features.txt \
 				doc/test-runner.rst \
 				doc/settings-storage.txt
 
-EXTRA_DIST += doc/health-api.txt
-
 EXTRA_DIST += doc/hci-protocol.rst doc/mgmt-protocol.rst \
 	      doc/l2cap-protocol.rst doc/rfcomm-protocol.rst \
 	      doc/sco-protocol.rst doc/iso-protocol.rst

@@ -67,16 +67,6 @@ builtin_sources += profiles/input/hog.c \
 			profiles/input/suspend.h profiles/input/suspend-none.c
 endif
 
-if HEALTH
-builtin_modules += health
-builtin_sources += profiles/health/mcap.h profiles/health/mcap.c \
-			profiles/health/hdp_main.c profiles/health/hdp_types.h \
-			profiles/health/hdp_manager.h \
-			profiles/health/hdp_manager.c \
-			profiles/health/hdp.h profiles/health/hdp.c \
-			profiles/health/hdp_util.h profiles/health/hdp_util.c
-endif
-
 builtin_modules += gap
 builtin_sources += profiles/gap/gas.c
 

@@ -243,7 +243,7 @@ noinst_PROGRAMS += tools/bdaddr tools/avinfo tools/avtest \
 			tools/hcieventmask tools/hcisecfilter \
 			tools/btinfo tools/btconfig \
 			tools/btsnoop tools/btproxy \
-			tools/btiotest tools/bneptest tools/mcaptest \
+			tools/btiotest tools/bneptest \
 			tools/cltest tools/oobtest tools/advtest \
 			tools/seq2bseq tools/nokfw tools/rtlfw \
 			tools/bcmfw tools/create-image \

@@ -283,13 +283,6 @@ tools_btproxy_LDADD = src/libshared-mainloop.la
 tools_btiotest_SOURCES = tools/btiotest.c btio/btio.h btio/btio.c
 tools_btiotest_LDADD = lib/libbluetooth-internal.la $(GLIB_LIBS)
 
-tools_mcaptest_SOURCES = tools/mcaptest.c \
-				btio/btio.h btio/btio.c \
-				src/log.c src/log.h \
-				profiles/health/mcap.h profiles/health/mcap.c
-tools_mcaptest_LDADD = lib/libbluetooth-internal.la $(GLIB_LIBS) \
-				src/libshared-mainloop.la -lrt
-
 tools_bneptest_SOURCES = tools/bneptest.c \
 				btio/btio.h btio/btio.c \
 				src/log.h src/log.c \

@@ -580,8 +573,8 @@ test_scripts += test/bluezutils.py \
 		test/test-discovery test/test-manager test/test-adapter \
 		test/test-device test/simple-agent \
 		test/simple-endpoint \
-		test/test-network test/test-profile test/test-health \
-		test/test-health-sink test/service-record.dtd \
+		test/test-network test/test-profile \
+		test/service-record.dtd \
 		test/service-did.xml test/service-spp.xml test/service-opp.xml \
 		test/service-ftp.xml test/simple-player test/test-nap \
 		test/test-hfp test/opp-client test/ftp-client \

@@ -272,16 +272,6 @@ For a working system, certain configuration options need to be enabled:
 		The plugin is built into bluetoothd therefore it does not need
 		to be package separately.
 
-	--enable-health
-
-		This option enable health profiles.
-
-		By default health plugin is disabled since its profiles are
-		target for the health industry.
-
-		The plugin is built into bluetoothd therefore it does not need
-		to be package separately.
-
 	--enable-midi
 
 		This option enable MIDI support via ALSA Sequencer.

@@ -18,7 +18,6 @@ fi
 		--enable-experimental \
 		--enable-deprecated \
 		--enable-nfc \
-		--enable-health \
 		--enable-sixaxis \
 		--enable-hid2hci \
 		--enable-midi \

@@ -188,10 +188,6 @@ AC_ARG_ENABLE(hog, AS_HELP_STRING([--disable-hog],
 		[disable HoG profile]), [enable_hog=${enableval}])
 AM_CONDITIONAL(HOG, test "${enable_hog}" != "no")
 
-AC_ARG_ENABLE(health, AS_HELP_STRING([--enable-health],
-		[enable health profiles]), [enable_health=${enableval}])
-AM_CONDITIONAL(HEALTH, test "${enable_health}" = "yes")
-
 AC_ARG_ENABLE(bap, AS_HELP_STRING([--disable-bap],
 		[disable BAP profile]), [enable_bap=${enableval}])
 AM_CONDITIONAL(BAP, test "${enable_bap}" != "no")

@@ -1,152 +0,0 @@
-BlueZ D-Bus Health API description
-**********************************
-
-
-HealthManager hierarchy
-=======================
-
-Service		org.bluez
-Interface	org.bluez.HealthManager1
-Object path	/org/bluez/
-
-Methods		object CreateApplication(dict config)
-
-			Returns the path of the new registered application.
-			Application will be closed by the call or implicitly
-			when the programs leaves the bus.
-
-			config:
-				uint16 DataType:
-
-					Mandatory
-
-				string Role:
-
-					Mandatory. Possible values: "source",
-									"sink"
-
-				string Description:
-
-					Optional
-
-				ChannelType:
-
-					Optional, just for sources. Possible
-					values: "reliable", "streaming"
-
-			Possible Errors: org.bluez.Error.InvalidArguments
-
-		void DestroyApplication(object application)
-
-			Closes the HDP application identified by the object
-			path. Also application will be closed if the process
-			that started it leaves the bus. Only the creator of the
-			application will be able to destroy it.
-
-			Possible errors: org.bluez.Error.InvalidArguments
-					 org.bluez.Error.NotFound
-					 org.bluez.Error.NotAllowed
-
-
-HealthDevice hierarchy
-======================
-
-Service		org.bluez
-Interface	org.bluez.HealthDevice1
-Object path	[variable prefix]/{hci0,hci1,...}/dev_XX_XX_XX_XX_XX_XX
-
-Methods		boolean Echo()
-
-			Sends an echo petition to the remote service. Returns
-			True if response matches with the buffer sent. If some
-			error is detected False value is returned.
-
-			Possible errors: org.bluez.Error.InvalidArguments
-					 org.bluez.Error.OutOfRange
-
-		object CreateChannel(object application, string configuration)
-
-			Creates a new data channel.  The configuration should
-			indicate the channel quality of service using one of
-			this values "reliable", "streaming", "any".
-
-			Returns the object path that identifies the data
-			channel that is already connected.
-
-			Possible errors: org.bluez.Error.InvalidArguments
-					 org.bluez.Error.HealthError
-
-		void DestroyChannel(object channel)
-
-			Destroys the data channel object. Only the creator of
-			the channel or the creator of the HealthApplication
-			that received the data channel will be able to destroy
-			it.
-
-			Possible errors: org.bluez.Error.InvalidArguments
-					 org.bluez.Error.NotFound
-				         org.bluez.Error.NotAllowed
-
-Signals		void ChannelConnected(object channel)
-
-			This signal is launched when a new data channel is
-			created or when a known data channel is reconnected.
-
-		void ChannelDeleted(object channel)
-
-			This signal is launched when a data channel is deleted.
-
-			After this signal the data channel path will not be
-			valid and its path can be reused for future data
-			channels.
-
-Properties	object MainChannel [readonly]
-
-			The first reliable channel opened. It is needed by
-			upper applications in order to send specific protocol
-			data units. The first reliable can change after a
-			reconnection.
-
-
-HealthChannel hierarchy
-=======================
-
-Service		org.bluez
-Interface	org.bluez.HealthChannel1
-Object path	[variable prefix]/{hci0,hci1,...}/dev_XX_XX_XX_XX_XX_XX/chanZZZ
-
-Only the process that created the data channel or the creator of the
-HealthApplication that received it will be able to call these methods.
-
-Methods		fd Acquire()
-
-			Returns the file descriptor for this data channel. If
-			the data channel is not connected it will also
-			reconnect.
-
-			Possible Errors: org.bluez.Error.NotConnected
-					 org.bluez.Error.NotAllowed
-
-		void Release()
-
-			Releases the fd. Application should also need to
-			close() it.
-
-			Possible Errors: org.bluez.Error.NotAcquired
-					 org.bluez.Error.NotAllowed
-
-Properties	string Type [readonly]
-
-			The quality of service of the data channel. ("reliable"
-			or "streaming")
-
-		object Device [readonly]
-
-			Identifies the Remote Device that is connected with.
-			Maps with a HealthDevice object.
-
-		object Application [readonly]
-
-			Identifies the HealthApplication to which this channel
-			is related to (which indirectly defines its role and
-			data type).

@@ -1,2256 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define _GNU_SOURCE
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <unistd.h>
-
-#include <glib.h>
-
-#include "bluetooth/bluetooth.h"
-#include "bluetooth/l2cap.h"
-#include "bluetooth/sdp.h"
-
-#include "gdbus/gdbus.h"
-
-#include "src/dbus-common.h"
-#include "src/log.h"
-#include "src/error.h"
-#include "src/adapter.h"
-#include "src/device.h"
-#include "src/sdpd.h"
-#include "src/shared/timeout.h"
-#include "src/shared/util.h"
-#include "btio/btio.h"
-
-#include "hdp_types.h"
-#include "hdp_util.h"
-#include "hdp.h"
-#include "mcap.h"
-
-#define ECHO_TIMEOUT	1 /* second */
-#define HDP_ECHO_LEN	15
-
-static GSList *applications = NULL;
-static GSList *devices = NULL;
-static uint8_t next_app_id = HDP_MDEP_INITIAL;
-
-static GSList *adapters;
-
-static struct hdp_device *create_health_device(struct btd_device *device);
-static void free_echo_data(struct hdp_echo_data *edata);
-
-struct hdp_create_dc {
-	DBusMessage			*msg;
-	struct hdp_application		*app;
-	struct hdp_device		*dev;
-	uint8_t				config;
-	uint8_t				mdep;
-	guint				ref;
-	mcap_mdl_operation_cb		cb;
-};
-
-struct hdp_tmp_dc_data {
-	DBusMessage			*msg;
-	struct hdp_channel		*hdp_chann;
-	guint				ref;
-	mcap_mdl_operation_cb		cb;
-};
-
-struct hdp_echo_data {
-	gboolean		echo_done;	/* Is a echo was already done */
-	gpointer		buf;		/* echo packet sent */
-	unsigned int		tid;		/* echo timeout */
-};
-
-static struct hdp_channel *hdp_channel_ref(struct hdp_channel *chan)
-{
-	if (chan == NULL)
-		return NULL;
-
-	chan->ref++;
-
-	DBG("(%p): ref=%d", chan, chan->ref);
-	return chan;
-}
-
-static void free_health_channel(struct hdp_channel *chan)
-{
-	if (chan->mdep == HDP_MDEP_ECHO) {
-		free_echo_data(chan->edata);
-		chan->edata = NULL;
-	}
-
-	mcap_mdl_unref(chan->mdl);
-	hdp_application_unref(chan->app);
-	health_device_unref(chan->dev);
-	g_free(chan->path);
-	g_free(chan);
-}
-
-static void hdp_channel_unref(struct hdp_channel *chan)
-{
-	if (chan == NULL)
-		return;
-
-	chan->ref --;
-	DBG("(%p): ref=%d", chan, chan->ref);
-
-	if (chan->ref > 0)
-		return;
-
-	free_health_channel(chan);
-}
-
-static void free_hdp_create_dc(struct hdp_create_dc *dc_data)
-{
-	dbus_message_unref(dc_data->msg);
-	hdp_application_unref(dc_data->app);
-	health_device_unref(dc_data->dev);
-
-	g_free(dc_data);
-}
-
-static struct hdp_create_dc *hdp_create_data_ref(struct hdp_create_dc *dc_data)
-{
-	dc_data->ref++;
-
-	DBG("(%p): ref=%d", dc_data, dc_data->ref);
-
-	return dc_data;
-}
-
-static void hdp_create_data_unref(struct hdp_create_dc *dc_data)
-{
-	dc_data->ref--;
-
-	DBG("(%p): ref=%d", dc_data, dc_data->ref);
-
-	if (dc_data->ref > 0)
-		return;
-
-	free_hdp_create_dc(dc_data);
-}
-
-static void free_hdp_conn_dc(struct hdp_tmp_dc_data *data)
-{
-	dbus_message_unref(data->msg);
-	hdp_channel_unref(data->hdp_chann);
-
-	g_free(data);
-}
-
-static struct hdp_tmp_dc_data *hdp_tmp_dc_data_ref(struct hdp_tmp_dc_data *data)
-{
-	data->ref++;
-
-	DBG("hdp_conn_data_ref(%p): ref=%d", data, data->ref);
-
-	return data;
-}
-
-static void hdp_tmp_dc_data_unref(struct hdp_tmp_dc_data *data)
-{
-	data->ref--;
-
-	DBG("hdp_conn_data_unref(%p): ref=%d", data, data->ref);
-
-	if (data->ref > 0)
-		return;
-
-	free_hdp_conn_dc(data);
-}
-
-static int cmp_app_id(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_application *app = a;
-	const uint8_t *id = b;
-
-	return app->id - *id;
-}
-
-static int cmp_adapter(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_adapter *hdp_adapter = a;
-	const struct btd_adapter *adapter = b;
-
-	if (hdp_adapter->btd_adapter == adapter)
-		return 0;
-
-	return -1;
-}
-
-static int cmp_device(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_device *hdp_device = a;
-	const struct btd_device *device = b;
-
-	if (hdp_device->dev == device)
-		return 0;
-
-	return -1;
-}
-
-static int cmp_dev_addr(gconstpointer a, gconstpointer dst)
-{
-	const struct hdp_device *device = a;
-
-	return bacmp(device_get_address(device->dev), dst);
-}
-
-static int cmp_dev_mcl(gconstpointer a, gconstpointer mcl)
-{
-	const struct hdp_device *device = a;
-
-	if (mcl == device->mcl)
-		return 0;
-	return -1;
-}
-
-static int cmp_chan_mdlid(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_channel *chan = a;
-	const uint16_t *mdlid = b;
-
-	return chan->mdlid - *mdlid;
-}
-
-static int cmp_chan_path(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_channel *chan = a;
-	const char *path = b;
-
-	return g_ascii_strcasecmp(chan->path, path);
-}
-
-static int cmp_chan_mdl(gconstpointer a, gconstpointer mdl)
-{
-	const struct hdp_channel *chan = a;
-
-	if (chan->mdl == mdl)
-		return 0;
-	return -1;
-}
-
-static uint8_t get_app_id(void)
-{
-	uint8_t id = next_app_id;
-
-	do {
-		GSList *l = g_slist_find_custom(applications, &id, cmp_app_id);
-
-		if (l == NULL) {
-			next_app_id = (id % HDP_MDEP_FINAL) + 1;
-			return id;
-		} else
-			id = (id % HDP_MDEP_FINAL) + 1;
-	} while (id != next_app_id);
-
-	/* No more ids available */
-	return 0;
-}
-
-static int cmp_app(gconstpointer a, gconstpointer b)
-{
-	const struct hdp_application *app = a;
-
-	return g_strcmp0(app->path, b);
-}
-
-static gboolean set_app_path(struct hdp_application *app)
-{
-	app->id = get_app_id();
-	if (app->id == 0)
-		return FALSE;
-	app->path = g_strdup_printf(MANAGER_PATH "/health_app_%d", app->id);
-
-	return TRUE;
-};
-
-static void device_unref_mcl(struct hdp_device *hdp_device)
-{
-	if (hdp_device->mcl == NULL)
-		return;
-
-	mcap_close_mcl(hdp_device->mcl, FALSE);
-	mcap_mcl_unref(hdp_device->mcl);
-	hdp_device->mcl = NULL;
-	hdp_device->mcl_conn = FALSE;
-}
-
-static void free_health_device(struct hdp_device *device)
-{
-	if (device->dev != NULL) {
-		btd_device_unref(device->dev);
-		device->dev = NULL;
-	}
-
-	device_unref_mcl(device);
-
-	g_free(device);
-}
-
-static void update_adapter_cb(void *data, void *user_data);
-
-static void remove_application(struct hdp_application *app)
-{
-	DBG("Application %s deleted", app->path);
-	hdp_application_unref(app);
-
-	g_slist_foreach(adapters, update_adapter_cb, NULL);
-}
-
-static void client_disconnected(DBusConnection *conn, void *user_data)
-{
-	struct hdp_application *app = user_data;
-
-	DBG("Client disconnected from the bus, deleting hdp application");
-	applications = g_slist_remove(applications, app);
-
-	app->dbus_watcher = 0; /* Watcher shouldn't be freed in this case */
-	remove_application(app);
-}
-
-static DBusMessage *manager_create_application(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_application *app;
-	const char *name;
-	DBusMessageIter iter;
-	GError *err = NULL;
-
-	dbus_message_iter_init(msg, &iter);
-	app = hdp_get_app_config(&iter, &err);
-	if (err != NULL) {
-		g_error_free(err);
-		return btd_error_invalid_args(msg);
-	}
-
-	name = dbus_message_get_sender(msg);
-	if (name == NULL) {
-		hdp_application_unref(app);
-		return g_dbus_create_error(msg,
-					ERROR_INTERFACE ".HealthError",
-					"Can't get sender name");
-	}
-
-	if (!set_app_path(app)) {
-		hdp_application_unref(app);
-		return g_dbus_create_error(msg,
-				ERROR_INTERFACE ".HealthError",
-				"Can't get a valid id for the application");
-	}
-
-	app->oname = g_strdup(name);
-
-	applications = g_slist_prepend(applications, app);
-
-	app->dbus_watcher =
-			g_dbus_add_disconnect_watch(btd_get_dbus_connection(),
-					name, client_disconnected, app, NULL);
-	g_slist_foreach(adapters, update_adapter_cb, NULL);
-
-	DBG("Health application created with id %s", app->path);
-
-	return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &app->path,
-							DBUS_TYPE_INVALID);
-}
-
-static DBusMessage *manager_destroy_application(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	const char *path;
-	struct hdp_application *app;
-	GSList *l;
-
-	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
-						DBUS_TYPE_INVALID))
-		return btd_error_invalid_args(msg);
-
-	l = g_slist_find_custom(applications, path, cmp_app);
-
-	if (l == NULL)
-		return g_dbus_create_error(msg,
-					ERROR_INTERFACE ".InvalidArguments",
-					"Invalid arguments in method call, "
-					"no such application");
-
-	app = l->data;
-	applications = g_slist_remove(applications, app);
-
-	remove_application(app);
-
-	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
-}
-
-static void application_unref(void *data, void *user_data)
-{
-	hdp_application_unref(data);
-}
-
-static void manager_path_unregister(gpointer data)
-{
-	g_slist_foreach(applications, application_unref, NULL);
-
-	g_slist_free(applications);
-	applications = NULL;
-
-	g_slist_foreach(adapters, update_adapter_cb, NULL);
-}
-
-static const GDBusMethodTable health_manager_methods[] = {
-	{ GDBUS_METHOD("CreateApplication",
-			GDBUS_ARGS({ "config", "a{sv}" }),
-			GDBUS_ARGS({ "application", "o" }),
-			manager_create_application) },
-	{ GDBUS_METHOD("DestroyApplication",
-			GDBUS_ARGS({ "application", "o" }), NULL,
-			manager_destroy_application) },
-	{ }
-};
-
-static gboolean channel_property_get_device(const GDBusPropertyTable *property,
-					DBusMessageIter *iter, void *data)
-{
-	struct hdp_channel *chan = data;
-	const char *path = device_get_path(chan->dev->dev);
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
-
-	return TRUE;
-}
-
-static gboolean channel_property_get_application(
-					const GDBusPropertyTable *property,
-					DBusMessageIter *iter, void *data)
-{
-	struct hdp_channel *chan = data;
-	const char *path = chan->app->path;
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
-
-	return TRUE;
-}
-
-static gboolean channel_property_get_type(const GDBusPropertyTable *property,
-					DBusMessageIter *iter, void *data)
-{
-	struct hdp_channel *chan = data;
-	const char *type;
-
-	if (chan->config == HDP_RELIABLE_DC)
-		type = "reliable";
-	else
-		type = "streaming";
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &type);
-
-	return TRUE;
-}
-
-static void hdp_tmp_dc_data_destroy(gpointer data)
-{
-	struct hdp_tmp_dc_data *hdp_conn = data;
-
-	hdp_tmp_dc_data_unref(hdp_conn);
-}
-
-static void abort_mdl_cb(GError *err, gpointer data)
-{
-	if (err != NULL)
-		error("Aborting error: %s", err->message);
-}
-
-static void hdp_mdl_reconn_cb(struct mcap_mdl *mdl, GError *err, gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *dc_data = data;
-	DBusMessage *reply;
-	int fd;
-
-	if (err != NULL) {
-		struct hdp_channel *chan = dc_data->hdp_chann;
-		GError *gerr = NULL;
-
-		error("%s", err->message);
-		reply = g_dbus_create_error(dc_data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"Cannot reconnect: %s", err->message);
-		g_dbus_send_message(conn, reply);
-
-		/* Send abort request because remote side */
-		/* is now in PENDING state */
-		if (!mcap_mdl_abort(chan->mdl, abort_mdl_cb, NULL, NULL,
-								&gerr)) {
-			error("%s", gerr->message);
-			g_error_free(gerr);
-		}
-		return;
-	}
-
-	fd = mcap_mdl_get_fd(dc_data->hdp_chann->mdl);
-	if (fd < 0) {
-		reply = g_dbus_create_error(dc_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"Cannot get file descriptor");
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	reply = g_dbus_create_reply(dc_data->msg, DBUS_TYPE_UNIX_FD,
-							&fd, DBUS_TYPE_INVALID);
-	g_dbus_send_message(conn, reply);
-
-	g_dbus_emit_signal(conn, device_get_path(dc_data->hdp_chann->dev->dev),
-			HEALTH_DEVICE, "ChannelConnected",
-			DBUS_TYPE_OBJECT_PATH, &dc_data->hdp_chann->path,
-			DBUS_TYPE_INVALID);
-}
-
-static void hdp_get_dcpsm_cb(uint16_t dcpsm, gpointer user_data, GError *err)
-{
-	struct hdp_tmp_dc_data *hdp_conn = user_data;
-	struct hdp_channel *hdp_chann = hdp_conn->hdp_chann;
-	GError *gerr = NULL;
-	uint8_t mode;
-
-	if (err != NULL) {
-		hdp_conn->cb(hdp_chann->mdl, err, hdp_conn);
-		return;
-	}
-
-	if (hdp_chann->config == HDP_RELIABLE_DC)
-		mode = BT_IO_MODE_ERTM;
-	else
-		mode = BT_IO_MODE_STREAMING;
-
-	if (mcap_connect_mdl(hdp_chann->mdl, mode, dcpsm, hdp_conn->cb,
-					hdp_tmp_dc_data_ref(hdp_conn),
-					hdp_tmp_dc_data_destroy, &gerr))
-		return;
-
-	hdp_conn->cb(hdp_chann->mdl, err, hdp_conn);
-	g_error_free(gerr);
-	hdp_tmp_dc_data_unref(hdp_conn);
-}
-
-static void device_reconnect_mdl_cb(struct mcap_mdl *mdl, GError *err,
-								gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *dc_data = data;
-	GError *gerr = NULL;
-	DBusMessage *reply;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(dc_data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"Cannot reconnect: %s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	dc_data->cb = hdp_mdl_reconn_cb;
-
-	if (hdp_get_dcpsm(dc_data->hdp_chann->dev, hdp_get_dcpsm_cb,
-					hdp_tmp_dc_data_ref(dc_data),
-					hdp_tmp_dc_data_destroy, &gerr))
-		return;
-
-	error("%s", gerr->message);
-
-	reply = g_dbus_create_error(dc_data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"Cannot reconnect: %s", gerr->message);
-	g_dbus_send_message(conn, reply);
-	hdp_tmp_dc_data_unref(dc_data);
-	g_clear_error(&gerr);
-
-	/* Send abort request because remote side is now in PENDING state */
-	if (!mcap_mdl_abort(mdl, abort_mdl_cb, NULL, NULL, &gerr)) {
-		error("%s", gerr->message);
-		g_error_free(gerr);
-	}
-}
-
-static DBusMessage *channel_acquire_continue(struct hdp_tmp_dc_data *data,
-								GError *err)
-{
-	DBusMessage *reply;
-	GError *gerr = NULL;
-	int fd;
-
-	if (err != NULL) {
-		return g_dbus_create_error(data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", err->message);
-	}
-
-	fd = mcap_mdl_get_fd(data->hdp_chann->mdl);
-	if (fd >= 0)
-		return g_dbus_create_reply(data->msg, DBUS_TYPE_UNIX_FD, &fd,
-							DBUS_TYPE_INVALID);
-
-	hdp_tmp_dc_data_ref(data);
-	if (mcap_reconnect_mdl(data->hdp_chann->mdl, device_reconnect_mdl_cb,
-					data, hdp_tmp_dc_data_destroy, &gerr))
-		return NULL;
-
-	reply = g_dbus_create_error(data->msg, ERROR_INTERFACE ".HealthError",
-					"Cannot reconnect: %s", gerr->message);
-	g_error_free(gerr);
-	hdp_tmp_dc_data_unref(data);
-
-	return reply;
-}
-
-static void channel_acquire_cb(gpointer data, GError *err)
-{
-	DBusMessage *reply;
-
-	reply = channel_acquire_continue(data, err);
-
-	if (reply != NULL)
-		g_dbus_send_message(btd_get_dbus_connection(), reply);
-}
-
-static DBusMessage *channel_acquire(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_channel *chan = user_data;
-	struct hdp_tmp_dc_data *dc_data;
-	GError *gerr = NULL;
-	DBusMessage *reply;
-
-	dc_data = g_new0(struct hdp_tmp_dc_data, 1);
-	dc_data->msg = dbus_message_ref(msg);
-	dc_data->hdp_chann = hdp_channel_ref(chan);
-
-	if (chan->dev->mcl_conn) {
-		reply = channel_acquire_continue(hdp_tmp_dc_data_ref(dc_data),
-									NULL);
-		hdp_tmp_dc_data_unref(dc_data);
-		return reply;
-	}
-
-	if (hdp_establish_mcl(chan->dev, channel_acquire_cb,
-						hdp_tmp_dc_data_ref(dc_data),
-						hdp_tmp_dc_data_destroy, &gerr))
-		return NULL;
-
-	reply = g_dbus_create_error(msg, ERROR_INTERFACE ".HealthError",
-					"%s", gerr->message);
-	hdp_tmp_dc_data_unref(dc_data);
-	g_error_free(gerr);
-
-	return reply;
-}
-
-static void close_mdl(struct hdp_channel *hdp_chann)
-{
-	int fd;
-
-	fd = mcap_mdl_get_fd(hdp_chann->mdl);
-	if (fd < 0)
-		return;
-
-	close(fd);
-}
-
-static DBusMessage *channel_release(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_channel *hdp_chann = user_data;
-
-	close_mdl(hdp_chann);
-
-	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
-}
-
-static void free_echo_data(struct hdp_echo_data *edata)
-{
-	if (edata == NULL)
-		return;
-
-	if (edata->tid > 0)
-		timeout_remove(edata->tid);
-
-	if (edata->buf != NULL)
-		g_free(edata->buf);
-
-
-	g_free(edata);
-}
-
-static void health_channel_destroy(void *data)
-{
-	struct hdp_channel *hdp_chan = data;
-	struct hdp_device *dev = hdp_chan->dev;
-
-	DBG("Destroy Health Channel %s", hdp_chan->path);
-	if (g_slist_find(dev->channels, hdp_chan) == NULL)
-		goto end;
-
-	dev->channels = g_slist_remove(dev->channels, hdp_chan);
-
-	if (hdp_chan->mdep != HDP_MDEP_ECHO)
-		g_dbus_emit_signal(btd_get_dbus_connection(),
-					device_get_path(dev->dev),
-					HEALTH_DEVICE, "ChannelDeleted",
-					DBUS_TYPE_OBJECT_PATH, &hdp_chan->path,
-					DBUS_TYPE_INVALID);
-
-	if (hdp_chan == dev->fr) {
-		hdp_channel_unref(dev->fr);
-		dev->fr = NULL;
-	}
-
-end:
-	hdp_channel_unref(hdp_chan);
-}
-
-static const GDBusMethodTable health_channels_methods[] = {
-	{ GDBUS_ASYNC_METHOD("Acquire",
-			NULL, GDBUS_ARGS({ "fd", "h" }),
-			channel_acquire) },
-	{ GDBUS_METHOD("Release", NULL, NULL, channel_release) },
-	{ }
-};
-
-static const GDBusPropertyTable health_channels_properties[] = {
-	{ "Device", "o",  channel_property_get_device },
-	{ "Application", "o", channel_property_get_application },
-	{ "Type", "s", channel_property_get_type },
-	{ }
-};
-
-static struct hdp_channel *create_channel(struct hdp_device *dev,
-						uint8_t config,
-						struct mcap_mdl *mdl,
-						uint16_t mdlid,
-						struct hdp_application *app,
-						GError **err)
-{
-	struct hdp_channel *hdp_chann;
-
-	if (dev == NULL) {
-		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,
-					"HDP device uninitialized");
-		return NULL;
-	}
-
-	hdp_chann = g_new0(struct hdp_channel, 1);
-	hdp_chann->config = config;
-	hdp_chann->dev = health_device_ref(dev);
-	hdp_chann->mdlid = mdlid;
-
-	if (mdl != NULL)
-		hdp_chann->mdl = mcap_mdl_ref(mdl);
-
-	if (app != NULL) {
-		hdp_chann->mdep = app->id;
-		hdp_chann->app = hdp_application_ref(app);
-	} else
-		hdp_chann->edata = g_new0(struct hdp_echo_data, 1);
-
-	hdp_chann->path = g_strdup_printf("%s/chan%d",
-					device_get_path(hdp_chann->dev->dev),
-					hdp_chann->mdlid);
-
-	dev->channels = g_slist_append(dev->channels,
-						hdp_channel_ref(hdp_chann));
-
-	if (hdp_chann->mdep == HDP_MDEP_ECHO)
-		return hdp_channel_ref(hdp_chann);
-
-	if (!g_dbus_register_interface(btd_get_dbus_connection(),
-					hdp_chann->path, HEALTH_CHANNEL,
-					health_channels_methods, NULL,
-					health_channels_properties, hdp_chann,
-					health_channel_destroy)) {
-		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,
-					"Can't register the channel interface");
-		health_channel_destroy(hdp_chann);
-		return NULL;
-	}
-
-	return hdp_channel_ref(hdp_chann);
-}
-
-static void remove_channels(struct hdp_device *dev)
-{
-	struct hdp_channel *chan;
-	char *path;
-
-	while (dev->channels != NULL) {
-		chan = dev->channels->data;
-
-		path = g_strdup(chan->path);
-		if (!g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_CHANNEL))
-			health_channel_destroy(chan);
-		g_free(path);
-	}
-}
-
-static void close_device_con(struct hdp_device *dev, gboolean cache)
-{
-	if (dev->mcl == NULL)
-		return;
-
-	mcap_close_mcl(dev->mcl, cache);
-	dev->mcl_conn = FALSE;
-
-	if (cache)
-		return;
-
-	device_unref_mcl(dev);
-	remove_channels(dev);
-
-	if (!dev->sdp_present) {
-		const char *path;
-
-		path = device_get_path(dev->dev);
-		g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_DEVICE);
-	}
-}
-
-static int send_echo_data(int sock, const void *buf, uint32_t size)
-{
-	const uint8_t *buf_b = buf;
-	uint32_t sent = 0;
-
-	while (sent < size) {
-		int n = write(sock, buf_b + sent, size - sent);
-		if (n < 0)
-			return -1;
-		sent += n;
-	}
-
-	return 0;
-}
-
-static gboolean serve_echo(GIOChannel *io_chan, GIOCondition cond,
-								gpointer data)
-{
-	struct hdp_channel *chan = data;
-	uint8_t buf[MCAP_DC_MTU];
-	int fd, len;
-
-	if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
-		hdp_channel_unref(chan);
-		return FALSE;
-	}
-
-	if (chan->edata->echo_done)
-		goto fail;
-
-	chan->edata->echo_done = TRUE;
-
-	fd = g_io_channel_unix_get_fd(io_chan);
-
-	len = read(fd, buf, sizeof(buf));
-	if (len < 0)
-		goto fail;
-
-	if (send_echo_data(fd, buf, len)  >= 0)
-		return TRUE;
-
-fail:
-	close_device_con(chan->dev, FALSE);
-	hdp_channel_unref(chan);
-	return FALSE;
-}
-
-static gboolean check_channel_conf(struct hdp_channel *chan)
-{
-	GError *err = NULL;
-	GIOChannel *io;
-	uint8_t mode;
-	uint16_t imtu, omtu;
-	int fd;
-
-	fd = mcap_mdl_get_fd(chan->mdl);
-	if (fd < 0)
-		return FALSE;
-	io = g_io_channel_unix_new(fd);
-
-	if (!bt_io_get(io, &err,
-			BT_IO_OPT_MODE, &mode,
-			BT_IO_OPT_IMTU, &imtu,
-			BT_IO_OPT_OMTU, &omtu,
-			BT_IO_OPT_INVALID)) {
-		error("Error: %s", err->message);
-		g_io_channel_unref(io);
-		g_error_free(err);
-		return FALSE;
-	}
-
-	g_io_channel_unref(io);
-
-	switch (chan->config) {
-	case HDP_RELIABLE_DC:
-		if (mode != BT_IO_MODE_ERTM)
-			return FALSE;
-		break;
-	case HDP_STREAMING_DC:
-		if (mode != BT_IO_MODE_STREAMING)
-			return FALSE;
-		break;
-	default:
-		error("Error: Connected with unknown configuration");
-		return FALSE;
-	}
-
-	DBG("MDL imtu %d omtu %d Channel imtu %d omtu %d", imtu, omtu,
-						chan->imtu, chan->omtu);
-
-	if (chan->imtu == 0)
-		chan->imtu = imtu;
-	if (chan->omtu == 0)
-		chan->omtu = omtu;
-
-	if (chan->imtu != imtu || chan->omtu != omtu)
-		return FALSE;
-
-	return TRUE;
-}
-
-static void hdp_mcap_mdl_connected_cb(struct mcap_mdl *mdl, void *data)
-{
-	struct hdp_device *dev = data;
-	struct hdp_channel *chan;
-
-	DBG("");
-
-	if (dev->ndc == NULL)
-		return;
-
-	chan = dev->ndc;
-	if (chan->mdl == NULL)
-		chan->mdl = mcap_mdl_ref(mdl);
-
-	if (g_slist_find(dev->channels, chan) == NULL)
-		dev->channels = g_slist_prepend(dev->channels,
-							hdp_channel_ref(chan));
-
-	if (!check_channel_conf(chan)) {
-		close_mdl(chan);
-		goto end;
-	}
-
-	if (chan->mdep == HDP_MDEP_ECHO) {
-		GIOChannel *io;
-		int fd;
-
-		fd = mcap_mdl_get_fd(chan->mdl);
-		if (fd < 0)
-			goto end;
-
-		chan->edata->echo_done = FALSE;
-		io = g_io_channel_unix_new(fd);
-		g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL | G_IO_IN,
-				serve_echo, hdp_channel_ref(chan));
-		g_io_channel_unref(io);
-		goto end;
-	}
-
-	g_dbus_emit_signal(btd_get_dbus_connection(), device_get_path(dev->dev),
-				HEALTH_DEVICE, "ChannelConnected",
-				DBUS_TYPE_OBJECT_PATH, &chan->path,
-				DBUS_TYPE_INVALID);
-
-	if (dev->fr != NULL)
-		goto end;
-
-	dev->fr = hdp_channel_ref(chan);
-
-	g_dbus_emit_property_changed(btd_get_dbus_connection(),
-				device_get_path(dev->dev), HEALTH_DEVICE,
-				"MainChannel");
-
-end:
-	hdp_channel_unref(dev->ndc);
-	dev->ndc = NULL;
-}
-
-static void hdp_mcap_mdl_closed_cb(struct mcap_mdl *mdl, void *data)
-{
-	/* struct hdp_device *dev = data; */
-
-	DBG("");
-
-	/* Nothing to do */
-}
-
-static void hdp_mcap_mdl_deleted_cb(struct mcap_mdl *mdl, void *data)
-{
-	struct hdp_device *dev = data;
-	struct hdp_channel *chan;
-	char *path;
-	GSList *l;
-
-	DBG("");
-
-	l = g_slist_find_custom(dev->channels, mdl, cmp_chan_mdl);
-	if (l == NULL)
-		return;
-
-	chan = l->data;
-
-	path = g_strdup(chan->path);
-	if (!g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_CHANNEL))
-		health_channel_destroy(chan);
-	g_free(path);
-}
-
-static void hdp_mcap_mdl_aborted_cb(struct mcap_mdl *mdl, void *data)
-{
-	struct hdp_device *dev = data;
-
-	DBG("");
-
-	if (dev->ndc == NULL)
-		return;
-
-	dev->ndc->mdl = mcap_mdl_ref(mdl);
-
-	if (g_slist_find(dev->channels, dev->ndc) == NULL)
-		dev->channels = g_slist_prepend(dev->channels,
-						hdp_channel_ref(dev->ndc));
-
-	if (dev->ndc->mdep != HDP_MDEP_ECHO)
-		g_dbus_emit_signal(btd_get_dbus_connection(),
-					device_get_path(dev->dev),
-					HEALTH_DEVICE, "ChannelConnected",
-					DBUS_TYPE_OBJECT_PATH, &dev->ndc->path,
-					DBUS_TYPE_INVALID);
-
-	hdp_channel_unref(dev->ndc);
-	dev->ndc = NULL;
-}
-
-static uint8_t hdp2l2cap_mode(uint8_t hdp_mode)
-{
-	return hdp_mode == HDP_STREAMING_DC ? BT_IO_MODE_STREAMING :
-								BT_IO_MODE_ERTM;
-}
-
-static uint8_t hdp_mcap_mdl_conn_req_cb(struct mcap_mcl *mcl, uint8_t mdepid,
-				uint16_t mdlid, uint8_t *conf, void *data)
-{
-	struct hdp_device *dev = data;
-	struct hdp_application *app;
-	GError *err = NULL;
-	GSList *l;
-
-	DBG("Data channel request");
-
-	if (mdepid == HDP_MDEP_ECHO) {
-		switch (*conf) {
-		case HDP_NO_PREFERENCE_DC:
-			*conf = HDP_RELIABLE_DC;
-			break;
-		case HDP_RELIABLE_DC:
-			break;
-		case HDP_STREAMING_DC:
-			return MCAP_CONFIGURATION_REJECTED;
-		default:
-			/* Special case defined in HDP spec 3.4. When an invalid
-			* configuration is received we shall close the MCL when
-			* we are still processing the callback. */
-			close_device_con(dev, FALSE);
-			return MCAP_CONFIGURATION_REJECTED; /* not processed */
-		}
-
-		if (!mcap_set_data_chan_mode(dev->hdp_adapter->mi,
-						BT_IO_MODE_ERTM, &err)) {
-			error("Error: %s", err->message);
-			g_error_free(err);
-			return MCAP_MDL_BUSY;
-		}
-
-		dev->ndc = create_channel(dev, *conf, NULL, mdlid, NULL, NULL);
-		if (dev->ndc == NULL)
-			return MCAP_MDL_BUSY;
-
-		return MCAP_SUCCESS;
-	}
-
-	l = g_slist_find_custom(applications, &mdepid, cmp_app_id);
-	if (l == NULL)
-		return MCAP_INVALID_MDEP;
-
-	app = l->data;
-
-	/* Check if is the first dc if so,
-	* only reliable configuration is allowed */
-	switch (*conf) {
-	case HDP_NO_PREFERENCE_DC:
-		if (app->role == HDP_SINK)
-			return MCAP_CONFIGURATION_REJECTED;
-		else if (dev->fr && app->chan_type_set)
-			*conf = app->chan_type;
-		else
-			*conf = HDP_RELIABLE_DC;
-		break;
-	case HDP_STREAMING_DC:
-		if (!dev->fr || app->role == HDP_SOURCE)
-			return MCAP_CONFIGURATION_REJECTED;
-		break;
-	case HDP_RELIABLE_DC:
-		if (app->role == HDP_SOURCE)
-			return MCAP_CONFIGURATION_REJECTED;
-		break;
-	default:
-		/* Special case defined in HDP spec 3.4. When an invalid
-		* configuration is received we shall close the MCL when
-		* we are still processing the callback. */
-		close_device_con(dev, FALSE);
-		return MCAP_CONFIGURATION_REJECTED; /* not processed */
-	}
-
-	l = g_slist_find_custom(dev->channels, &mdlid, cmp_chan_mdlid);
-	if (l != NULL) {
-		struct hdp_channel *chan = l->data;
-		char *path;
-
-		path = g_strdup(chan->path);
-		g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_CHANNEL);
-		g_free(path);
-	}
-
-	if (!mcap_set_data_chan_mode(dev->hdp_adapter->mi,
-						hdp2l2cap_mode(*conf), &err)) {
-		error("Error: %s", err->message);
-		g_error_free(err);
-		return MCAP_MDL_BUSY;
-	}
-
-	dev->ndc = create_channel(dev, *conf, NULL, mdlid, app, NULL);
-	if (dev->ndc == NULL)
-		return MCAP_MDL_BUSY;
-
-	return MCAP_SUCCESS;
-}
-
-static uint8_t hdp_mcap_mdl_reconn_req_cb(struct mcap_mdl *mdl, void *data)
-{
-	struct hdp_device *dev = data;
-	struct hdp_channel *chan;
-	GError *err = NULL;
-	GSList *l;
-
-	l = g_slist_find_custom(dev->channels, mdl, cmp_chan_mdl);
-	if (l == NULL)
-		return MCAP_INVALID_MDL;
-
-	chan = l->data;
-
-	if (dev->fr == NULL && chan->config != HDP_RELIABLE_DC &&
-						chan->mdep != HDP_MDEP_ECHO)
-		return MCAP_UNSPECIFIED_ERROR;
-
-	if (!mcap_set_data_chan_mode(dev->hdp_adapter->mi,
-					hdp2l2cap_mode(chan->config), &err)) {
-		error("Error: %s", err->message);
-		g_error_free(err);
-		return MCAP_MDL_BUSY;
-	}
-
-	dev->ndc = hdp_channel_ref(chan);
-
-	return MCAP_SUCCESS;
-}
-
-gboolean hdp_set_mcl_cb(struct hdp_device *device, GError **err)
-{
-	gboolean ret;
-
-	if (device->mcl == NULL)
-		return FALSE;
-
-	ret = mcap_mcl_set_cb(device->mcl, device, err,
-		MCAP_MDL_CB_CONNECTED, hdp_mcap_mdl_connected_cb,
-		MCAP_MDL_CB_CLOSED, hdp_mcap_mdl_closed_cb,
-		MCAP_MDL_CB_DELETED, hdp_mcap_mdl_deleted_cb,
-		MCAP_MDL_CB_ABORTED, hdp_mcap_mdl_aborted_cb,
-		MCAP_MDL_CB_REMOTE_CONN_REQ, hdp_mcap_mdl_conn_req_cb,
-		MCAP_MDL_CB_REMOTE_RECONN_REQ, hdp_mcap_mdl_reconn_req_cb,
-		MCAP_MDL_CB_INVALID);
-	if (ret)
-		return TRUE;
-
-	error("Can't set mcl callbacks, closing mcl");
-	close_device_con(device, TRUE);
-
-	return FALSE;
-}
-
-static void mcl_connected(struct mcap_mcl *mcl, gpointer data)
-{
-	struct hdp_device *hdp_device;
-	bdaddr_t addr;
-	GSList *l;
-
-	mcap_mcl_get_addr(mcl, &addr);
-	l = g_slist_find_custom(devices, &addr, cmp_dev_addr);
-	if (l == NULL) {
-		struct hdp_adapter *hdp_adapter = data;
-		struct btd_device *device;
-
-		device = btd_adapter_get_device(hdp_adapter->btd_adapter,
-							&addr, BDADDR_BREDR);
-		if (!device)
-			return;
-		hdp_device = create_health_device(device);
-		if (!hdp_device)
-			return;
-		devices = g_slist_append(devices, hdp_device);
-	} else
-		hdp_device = l->data;
-
-	hdp_device->mcl = mcap_mcl_ref(mcl);
-	hdp_device->mcl_conn = TRUE;
-
-	DBG("New mcl connected from  %s", device_get_path(hdp_device->dev));
-
-	hdp_set_mcl_cb(hdp_device, NULL);
-}
-
-static void mcl_reconnected(struct mcap_mcl *mcl, gpointer data)
-{
-	struct hdp_device *hdp_device;
-	GSList *l;
-
-	l = g_slist_find_custom(devices, mcl, cmp_dev_mcl);
-	if (l == NULL)
-		return;
-
-	hdp_device = l->data;
-	hdp_device->mcl_conn = TRUE;
-
-	DBG("MCL reconnected %s", device_get_path(hdp_device->dev));
-
-	hdp_set_mcl_cb(hdp_device, NULL);
-}
-
-static void mcl_disconnected(struct mcap_mcl *mcl, gpointer data)
-{
-	struct hdp_device *hdp_device;
-	GSList *l;
-
-	l = g_slist_find_custom(devices, mcl, cmp_dev_mcl);
-	if (l == NULL)
-		return;
-
-	hdp_device = l->data;
-	hdp_device->mcl_conn = FALSE;
-
-	DBG("Mcl disconnected %s", device_get_path(hdp_device->dev));
-}
-
-static void mcl_uncached(struct mcap_mcl *mcl, gpointer data)
-{
-	struct hdp_device *hdp_device;
-	const char *path;
-	GSList *l;
-
-	l = g_slist_find_custom(devices, mcl, cmp_dev_mcl);
-	if (l == NULL)
-		return;
-
-	hdp_device = l->data;
-	device_unref_mcl(hdp_device);
-
-	if (hdp_device->sdp_present)
-		return;
-
-	/* Because remote device hasn't announced an HDP record */
-	/* the Bluetooth daemon won't notify when the device shall */
-	/* be removed. Then we have to remove the HealthDevice */
-	/* interface manually */
-	path = device_get_path(hdp_device->dev);
-	g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_DEVICE);
-	DBG("Mcl uncached %s", path);
-}
-
-static void check_devices_mcl(void)
-{
-	struct hdp_device *dev;
-	GSList *l, *to_delete = NULL;
-
-	for (l = devices; l; l = l->next) {
-		dev = l->data;
-		device_unref_mcl(dev);
-
-		if (!dev->sdp_present)
-			to_delete = g_slist_append(to_delete, dev);
-		else
-			remove_channels(dev);
-	}
-
-	for (l = to_delete; l; l = l->next) {
-		const char *path;
-
-		path = device_get_path(dev->dev);
-		g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_DEVICE);
-	}
-
-	g_slist_free(to_delete);
-}
-
-static void release_adapter_instance(struct hdp_adapter *hdp_adapter)
-{
-	if (hdp_adapter->mi == NULL)
-		return;
-
-	check_devices_mcl();
-	mcap_release_instance(hdp_adapter->mi);
-	mcap_instance_unref(hdp_adapter->mi);
-	hdp_adapter->mi = NULL;
-}
-
-static gboolean update_adapter(struct hdp_adapter *hdp_adapter)
-{
-	GError *err = NULL;
-	const bdaddr_t *src;
-
-	if (applications == NULL) {
-		release_adapter_instance(hdp_adapter);
-		goto update;
-	}
-
-	if (hdp_adapter->mi != NULL)
-		goto update;
-
-	src = btd_adapter_get_address(hdp_adapter->btd_adapter);
-
-	hdp_adapter->mi = mcap_create_instance(src,
-				BT_IO_SEC_MEDIUM, 0, 0,
-				mcl_connected, mcl_reconnected,
-				mcl_disconnected, mcl_uncached,
-				NULL, /* CSP is not used by now */
-				hdp_adapter, &err);
-	if (hdp_adapter->mi == NULL) {
-		error("Error creating the MCAP instance: %s", err->message);
-		g_error_free(err);
-		return FALSE;
-	}
-
-	hdp_adapter->ccpsm = mcap_get_ctrl_psm(hdp_adapter->mi, &err);
-	if (err != NULL) {
-		error("Error getting MCAP control PSM: %s", err->message);
-		goto fail;
-	}
-
-	hdp_adapter->dcpsm = mcap_get_data_psm(hdp_adapter->mi, &err);
-	if (err != NULL) {
-		error("Error getting MCAP data PSM: %s", err->message);
-		goto fail;
-	}
-
-update:
-	if (hdp_update_sdp_record(hdp_adapter, applications))
-		return TRUE;
-	error("Error updating the SDP record");
-
-fail:
-	release_adapter_instance(hdp_adapter);
-	if (err != NULL)
-		g_error_free(err);
-
-	return FALSE;
-}
-
-static void update_adapter_cb(void *data, void *user_data)
-{
-	update_adapter(data);
-}
-
-int hdp_adapter_register(struct btd_adapter *adapter)
-{
-	struct hdp_adapter *hdp_adapter;
-
-	hdp_adapter = g_new0(struct hdp_adapter, 1);
-	hdp_adapter->btd_adapter = btd_adapter_ref(adapter);
-
-	if(!update_adapter(hdp_adapter))
-		goto fail;
-
-	adapters = g_slist_append(adapters, hdp_adapter);
-
-	return 0;
-
-fail:
-	btd_adapter_unref(hdp_adapter->btd_adapter);
-	g_free(hdp_adapter);
-	return -1;
-}
-
-void hdp_adapter_unregister(struct btd_adapter *adapter)
-{
-	struct hdp_adapter *hdp_adapter;
-	GSList *l;
-
-	l = g_slist_find_custom(adapters, adapter, cmp_adapter);
-
-	if (l == NULL)
-		return;
-
-	hdp_adapter = l->data;
-	adapters = g_slist_remove(adapters, hdp_adapter);
-	if (hdp_adapter->sdp_handler > 0)
-		adapter_service_remove(adapter, hdp_adapter->sdp_handler);
-	release_adapter_instance(hdp_adapter);
-	btd_adapter_unref(hdp_adapter->btd_adapter);
-	g_free(hdp_adapter);
-}
-
-static void delete_echo_channel_cb(GError *err, gpointer chan)
-{
-	if (err != NULL && err->code != MCAP_INVALID_MDL) {
-		/* TODO: Decide if more action is required here */
-		error("Error deleting echo channel: %s", err->message);
-		return;
-	}
-
-	health_channel_destroy(chan);
-}
-
-static void delete_echo_channel(struct hdp_channel *chan)
-{
-	GError *err = NULL;
-
-	if (!chan->dev->mcl_conn) {
-		error("Echo channel cannot be deleted: mcl closed");
-		return;
-	}
-
-	if (mcap_delete_mdl(chan->mdl, delete_echo_channel_cb,
-				hdp_channel_ref(chan),
-				(GDestroyNotify) hdp_channel_unref, &err))
-		return;
-
-	hdp_channel_unref(chan);
-	error("Error deleting the echo channel: %s", err->message);
-	g_error_free(err);
-
-	/* TODO: Decide if more action is required here */
-}
-
-static void abort_echo_channel_cb(GError *err, gpointer data)
-{
-	struct hdp_channel *chan = data;
-
-	if (err != NULL && err->code != MCAP_ERROR_INVALID_OPERATION) {
-		error("Aborting error: %s", err->message);
-		if (err->code == MCAP_INVALID_MDL) {
-			/* MDL is removed from MCAP so we can */
-			/* free the data channel without sending */
-			/* a MD_DELETE_MDL_REQ */
-			/* TODO review the above comment */
-			/* hdp_channel_unref(chan); */
-		}
-		return;
-	}
-
-	delete_echo_channel(chan);
-}
-
-static void destroy_create_dc_data(gpointer data)
-{
-	struct hdp_create_dc *dc_data = data;
-
-	hdp_create_data_unref(dc_data);
-}
-
-static void *generate_echo_packet(void)
-{
-	uint8_t *buf;
-
-	buf = g_malloc(HDP_ECHO_LEN);
-	if (!buf)
-		return NULL;
-
-	if (util_getrandom(buf, HDP_ECHO_LEN, 0) < 0) {
-		g_free(buf);
-		return NULL;
-	}
-
-	return buf;
-}
-
-static gboolean check_echo(GIOChannel *io_chan, GIOCondition cond,
-								gpointer data)
-{
-	struct hdp_tmp_dc_data *hdp_conn =  data;
-	struct hdp_echo_data *edata = hdp_conn->hdp_chann->edata;
-	struct hdp_channel *chan = hdp_conn->hdp_chann;
-	uint8_t buf[MCAP_DC_MTU];
-	DBusMessage *reply;
-	gboolean value;
-	int fd, len;
-
-	if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
-		value = FALSE;
-		goto end;
-	}
-
-	fd = g_io_channel_unix_get_fd(io_chan);
-
-	len = read(fd, buf, sizeof(buf));
-	if (len != HDP_ECHO_LEN) {
-		value = FALSE;
-		goto end;
-	}
-
-	value = (memcmp(buf, edata->buf, len) == 0);
-
-end:
-	reply = g_dbus_create_reply(hdp_conn->msg, DBUS_TYPE_BOOLEAN, &value,
-							DBUS_TYPE_INVALID);
-	g_dbus_send_message(btd_get_dbus_connection(), reply);
-	timeout_remove(edata->tid);
-	edata->tid = 0;
-	g_free(edata->buf);
-	edata->buf = NULL;
-
-	if (!value)
-		close_device_con(chan->dev, FALSE);
-	else
-		delete_echo_channel(chan);
-	hdp_tmp_dc_data_unref(hdp_conn);
-
-	return FALSE;
-}
-
-static bool echo_timeout(gpointer data)
-{
-	struct hdp_channel *chan = data;
-	GIOChannel *io;
-	int fd;
-
-	error("Error: Echo request timeout");
-	chan->edata->tid = 0;
-
-	fd = mcap_mdl_get_fd(chan->mdl);
-	if (fd < 0)
-		return FALSE;
-
-	io = g_io_channel_unix_new(fd);
-	g_io_channel_shutdown(io, TRUE, NULL);
-
-	return FALSE;
-}
-
-static void hdp_echo_connect_cb(struct mcap_mdl *mdl, GError *err,
-								gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *hdp_conn =  data;
-	struct hdp_echo_data *edata;
-	GError *gerr = NULL;
-	DBusMessage *reply;
-	GIOChannel *io;
-	int fd;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(hdp_conn->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", err->message);
-		g_dbus_send_message(conn, reply);
-
-		/* Send abort request because remote */
-		/* side is now in PENDING state. */
-		if (!mcap_mdl_abort(hdp_conn->hdp_chann->mdl,
-					abort_echo_channel_cb,
-					hdp_channel_ref(hdp_conn->hdp_chann),
-					(GDestroyNotify) hdp_channel_unref,
-					&gerr)) {
-			error("%s", gerr->message);
-			g_error_free(gerr);
-			hdp_channel_unref(hdp_conn->hdp_chann);
-		}
-		return;
-	}
-
-	fd = mcap_mdl_get_fd(hdp_conn->hdp_chann->mdl);
-	if (fd < 0) {
-		reply = g_dbus_create_error(hdp_conn->msg,
-						ERROR_INTERFACE ".HealthError",
-						"Can't write in echo channel");
-		g_dbus_send_message(conn, reply);
-		delete_echo_channel(hdp_conn->hdp_chann);
-		return;
-	}
-
-	edata = hdp_conn->hdp_chann->edata;
-	edata->buf = generate_echo_packet();
-	send_echo_data(fd, edata->buf, HDP_ECHO_LEN);
-
-	io = g_io_channel_unix_new(fd);
-	g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL | G_IO_IN,
-			check_echo, hdp_tmp_dc_data_ref(hdp_conn));
-
-	edata->tid = timeout_add_seconds(ECHO_TIMEOUT, echo_timeout,
-				hdp_channel_ref(hdp_conn->hdp_chann),
-				(timeout_destroy_func_t) hdp_channel_unref);
-
-	g_io_channel_unref(io);
-}
-
-static void delete_mdl_cb(GError *err, gpointer data)
-{
-	if (err != NULL)
-		error("Deleting error: %s", err->message);
-}
-
-static void abort_and_del_mdl_cb(GError *err, gpointer data)
-{
-	struct mcap_mdl *mdl = data;
-	GError *gerr = NULL;
-
-	if (err != NULL) {
-		error("%s", err->message);
-		if (err->code == MCAP_INVALID_MDL) {
-			/* MDL is removed from MCAP so we don't */
-			/* need to delete it. */
-			return;
-		}
-	}
-
-	if (!mcap_delete_mdl(mdl, delete_mdl_cb, NULL, NULL, &gerr)) {
-		error("%s", gerr->message);
-		g_error_free(gerr);
-	}
-}
-
-static void abort_mdl_connection_cb(GError *err, gpointer data)
-{
-	struct hdp_tmp_dc_data *hdp_conn = data;
-	struct hdp_channel *hdp_chann = hdp_conn->hdp_chann;
-
-	if (err != NULL)
-		error("Aborting error: %s", err->message);
-
-	/* Connection operation has failed but we have to */
-	/* notify the channel created at MCAP level */
-	if (hdp_chann->mdep != HDP_MDEP_ECHO)
-		g_dbus_emit_signal(btd_get_dbus_connection(),
-					device_get_path(hdp_chann->dev->dev),
-					HEALTH_DEVICE, "ChannelConnected",
-					DBUS_TYPE_OBJECT_PATH, &hdp_chann->path,
-					DBUS_TYPE_INVALID);
-}
-
-static void hdp_mdl_conn_cb(struct mcap_mdl *mdl, GError *err, gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *hdp_conn =  data;
-	struct hdp_channel *hdp_chann = hdp_conn->hdp_chann;
-	struct hdp_device *dev = hdp_chann->dev;
-	DBusMessage *reply;
-	GError *gerr = NULL;
-
-	if (err != NULL) {
-		error("%s", err->message);
-		reply = g_dbus_create_reply(hdp_conn->msg,
-					DBUS_TYPE_OBJECT_PATH, &hdp_chann->path,
-					DBUS_TYPE_INVALID);
-		g_dbus_send_message(conn, reply);
-
-		/* Send abort request because remote side */
-		/* is now in PENDING state */
-		if (!mcap_mdl_abort(hdp_chann->mdl, abort_mdl_connection_cb,
-					hdp_tmp_dc_data_ref(hdp_conn),
-					hdp_tmp_dc_data_destroy, &gerr)) {
-			hdp_tmp_dc_data_unref(hdp_conn);
-			error("%s", gerr->message);
-			g_error_free(gerr);
-		}
-		return;
-	}
-
-	reply = g_dbus_create_reply(hdp_conn->msg,
-					DBUS_TYPE_OBJECT_PATH, &hdp_chann->path,
-					DBUS_TYPE_INVALID);
-	g_dbus_send_message(conn, reply);
-
-	g_dbus_emit_signal(conn, device_get_path(hdp_chann->dev->dev),
-				HEALTH_DEVICE, "ChannelConnected",
-				DBUS_TYPE_OBJECT_PATH, &hdp_chann->path,
-				DBUS_TYPE_INVALID);
-
-	if (!check_channel_conf(hdp_chann)) {
-		close_mdl(hdp_chann);
-		return;
-	}
-
-	if (dev->fr != NULL)
-		return;
-
-	dev->fr = hdp_channel_ref(hdp_chann);
-
-	g_dbus_emit_property_changed(btd_get_dbus_connection(),
-				device_get_path(dev->dev), HEALTH_DEVICE,
-				"MainChannel");
-}
-
-static void device_create_mdl_cb(struct mcap_mdl *mdl, uint8_t conf,
-						GError *err, gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_create_dc *user_data = data;
-	struct hdp_tmp_dc_data *hdp_conn;
-	struct hdp_channel *hdp_chan;
-	GError *gerr = NULL;
-	DBusMessage *reply;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(user_data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"%s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	if (user_data->mdep != HDP_MDEP_ECHO &&
-				user_data->config == HDP_NO_PREFERENCE_DC) {
-		if (user_data->dev->fr == NULL && conf != HDP_RELIABLE_DC) {
-			g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-					"Data channel aborted, first data "
-					"channel should be reliable");
-			goto fail;
-		} else if (conf == HDP_NO_PREFERENCE_DC ||
-						conf > HDP_STREAMING_DC) {
-			g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-							"Data channel aborted, "
-							"configuration error");
-			goto fail;
-		}
-	}
-
-	hdp_chan = create_channel(user_data->dev, conf, mdl,
-							mcap_mdl_get_mdlid(mdl),
-							user_data->app, &gerr);
-	if (hdp_chan == NULL)
-		goto fail;
-
-	hdp_conn = g_new0(struct hdp_tmp_dc_data, 1);
-	hdp_conn->msg = dbus_message_ref(user_data->msg);
-	hdp_conn->hdp_chann = hdp_chan;
-	hdp_conn->cb = user_data->cb;
-	hdp_chan->mdep = user_data->mdep;
-
-	if (hdp_get_dcpsm(hdp_chan->dev, hdp_get_dcpsm_cb,
-						hdp_tmp_dc_data_ref(hdp_conn),
-						hdp_tmp_dc_data_destroy, &gerr))
-		return;
-
-	error("%s", gerr->message);
-	g_clear_error(&gerr);
-
-	reply = g_dbus_create_reply(hdp_conn->msg,
-					DBUS_TYPE_OBJECT_PATH, &hdp_chan->path,
-					DBUS_TYPE_INVALID);
-	g_dbus_send_message(conn, reply);
-	hdp_tmp_dc_data_unref(hdp_conn);
-
-	/* Send abort request because remote side is now in PENDING state */
-	if (!mcap_mdl_abort(hdp_chan->mdl, abort_mdl_connection_cb,
-					hdp_tmp_dc_data_ref(hdp_conn),
-					hdp_tmp_dc_data_destroy, &gerr)) {
-		hdp_tmp_dc_data_unref(hdp_conn);
-		error("%s", gerr->message);
-		g_error_free(gerr);
-	}
-
-	return;
-
-fail:
-	reply = g_dbus_create_error(user_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", gerr->message);
-	g_dbus_send_message(conn, reply);
-	g_clear_error(&gerr);
-
-	/* Send abort request because remote side is now in PENDING */
-	/* state. Then we have to delete it because we couldn't */
-	/* register the HealthChannel interface */
-	if (!mcap_mdl_abort(mdl, abort_and_del_mdl_cb, mcap_mdl_ref(mdl),
-				(GDestroyNotify) mcap_mdl_unref, &gerr)) {
-		error("%s", gerr->message);
-		g_error_free(gerr);
-		mcap_mdl_unref(mdl);
-	}
-}
-
-static void device_create_dc_cb(gpointer user_data, GError *err)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_create_dc *data = user_data;
-	DBusMessage *reply;
-	GError *gerr = NULL;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"%s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	if (data->dev->mcl == NULL) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-				"Mcl was closed");
-		goto fail;
-	}
-
-	hdp_create_data_ref(data);
-
-	if (mcap_create_mdl(data->dev->mcl, data->mdep, data->config,
-						device_create_mdl_cb, data,
-						destroy_create_dc_data, &gerr))
-		return;
-	hdp_create_data_unref(data);
-
-fail:
-	reply = g_dbus_create_error(data->msg, ERROR_INTERFACE ".HealthError",
-							"%s", gerr->message);
-	g_error_free(gerr);
-	g_dbus_send_message(conn, reply);
-}
-
-static DBusMessage *device_echo(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_device *device = user_data;
-	struct hdp_create_dc *data;
-	DBusMessage *reply;
-	GError *err = NULL;
-
-	data = g_new0(struct hdp_create_dc, 1);
-	data->dev = health_device_ref(device);
-	data->mdep = HDP_MDEP_ECHO;
-	data->config = HDP_RELIABLE_DC;
-	data->msg = dbus_message_ref(msg);
-	data->cb = hdp_echo_connect_cb;
-	hdp_create_data_ref(data);
-
-	if (device->mcl_conn && device->mcl) {
-		if (mcap_create_mdl(device->mcl, data->mdep, data->config,
-						device_create_mdl_cb, data,
-						destroy_create_dc_data, &err))
-			return NULL;
-		goto fail;
-	}
-
-	if (hdp_establish_mcl(data->dev, device_create_dc_cb,
-					data, destroy_create_dc_data, &err))
-		return NULL;
-
-fail:
-	reply = g_dbus_create_error(msg, ERROR_INTERFACE ".HealthError",
-							"%s", err->message);
-	g_error_free(err);
-	hdp_create_data_unref(data);
-	return reply;
-}
-
-static void device_get_mdep_cb(uint8_t mdep, gpointer data, GError *err)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_create_dc *dc_data, *user_data = data;
-	DBusMessage *reply;
-	GError *gerr = NULL;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(user_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	dc_data = hdp_create_data_ref(user_data);
-	dc_data->mdep = mdep;
-
-	if (user_data->dev->mcl_conn) {
-		device_create_dc_cb(dc_data, NULL);
-		hdp_create_data_unref(dc_data);
-		return;
-	}
-
-	if (hdp_establish_mcl(dc_data->dev, device_create_dc_cb,
-					dc_data, destroy_create_dc_data, &gerr))
-		return;
-
-	reply = g_dbus_create_error(user_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", gerr->message);
-	hdp_create_data_unref(dc_data);
-	g_error_free(gerr);
-	g_dbus_send_message(conn, reply);
-}
-
-static DBusMessage *device_create_channel(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_device *device = user_data;
-	struct hdp_application *app;
-	struct hdp_create_dc *data;
-	char *app_path, *conf;
-	DBusMessage *reply;
-	GError *err = NULL;
-	uint8_t config;
-	GSList *l;
-
-	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &app_path,
-							DBUS_TYPE_STRING, &conf,
-							DBUS_TYPE_INVALID))
-		return btd_error_invalid_args(msg);
-
-	l = g_slist_find_custom(applications, app_path, cmp_app);
-	if (l == NULL)
-		return btd_error_invalid_args(msg);
-
-	app = l->data;
-
-	if (g_ascii_strcasecmp("reliable", conf) == 0)
-		config = HDP_RELIABLE_DC;
-	else if (g_ascii_strcasecmp("streaming", conf) == 0)
-		config = HDP_STREAMING_DC;
-	else if (g_ascii_strcasecmp("any", conf) == 0)
-		config = HDP_NO_PREFERENCE_DC;
-	else
-		return btd_error_invalid_args(msg);
-
-	if (app->role == HDP_SINK && config != HDP_NO_PREFERENCE_DC)
-		return btd_error_invalid_args(msg);
-
-	if (app->role == HDP_SOURCE && config == HDP_NO_PREFERENCE_DC)
-		return btd_error_invalid_args(msg);
-
-	if (!device->fr && config == HDP_STREAMING_DC)
-		return btd_error_invalid_args(msg);
-
-	data = g_new0(struct hdp_create_dc, 1);
-	data->dev = health_device_ref(device);
-	data->config = config;
-	data->app = hdp_application_ref(app);
-	data->msg = dbus_message_ref(msg);
-	data->cb = hdp_mdl_conn_cb;
-
-	if (hdp_get_mdep(device, l->data, device_get_mdep_cb,
-						hdp_create_data_ref(data),
-						destroy_create_dc_data, &err))
-		return NULL;
-
-	reply = g_dbus_create_error(msg, ERROR_INTERFACE ".HealthError",
-							"%s", err->message);
-	g_error_free(err);
-	hdp_create_data_unref(data);
-	return reply;
-}
-
-static void hdp_mdl_delete_cb(GError *err, gpointer data)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *del_data = data;
-	DBusMessage *reply;
-	char *path;
-
-	if (err != NULL && err->code != MCAP_INVALID_MDL) {
-		reply = g_dbus_create_error(del_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	path = g_strdup(del_data->hdp_chann->path);
-	g_dbus_unregister_interface(conn, path, HEALTH_CHANNEL);
-	g_free(path);
-
-	reply = g_dbus_create_reply(del_data->msg, DBUS_TYPE_INVALID);
-	g_dbus_send_message(conn, reply);
-}
-
-static void hdp_continue_del_cb(gpointer user_data, GError *err)
-{
-	DBusConnection *conn = btd_get_dbus_connection();
-	struct hdp_tmp_dc_data *del_data = user_data;
-	GError *gerr = NULL;
-	DBusMessage *reply;
-
-	if (err != NULL) {
-		reply = g_dbus_create_error(del_data->msg,
-					ERROR_INTERFACE ".HealthError",
-					"%s", err->message);
-		g_dbus_send_message(conn, reply);
-		return;
-	}
-
-	if (mcap_delete_mdl(del_data->hdp_chann->mdl, hdp_mdl_delete_cb,
-						hdp_tmp_dc_data_ref(del_data),
-						hdp_tmp_dc_data_destroy, &gerr))
-			return;
-
-	reply = g_dbus_create_error(del_data->msg,
-						ERROR_INTERFACE ".HealthError",
-						"%s", gerr->message);
-	hdp_tmp_dc_data_unref(del_data);
-	g_error_free(gerr);
-	g_dbus_send_message(conn, reply);
-}
-
-static DBusMessage *device_destroy_channel(DBusConnection *conn,
-					DBusMessage *msg, void *user_data)
-{
-	struct hdp_device *device = user_data;
-	struct hdp_tmp_dc_data *del_data;
-	struct hdp_channel *hdp_chan;
-	DBusMessage *reply;
-	GError *err = NULL;
-	char *path;
-	GSList *l;
-
-	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
-							DBUS_TYPE_INVALID)){
-		return btd_error_invalid_args(msg);
-	}
-
-	l = g_slist_find_custom(device->channels, path, cmp_chan_path);
-	if (l == NULL)
-		return btd_error_invalid_args(msg);
-
-	hdp_chan = l->data;
-	del_data = g_new0(struct hdp_tmp_dc_data, 1);
-	del_data->msg = dbus_message_ref(msg);
-	del_data->hdp_chann = hdp_channel_ref(hdp_chan);
-
-	if (device->mcl_conn) {
-		if (mcap_delete_mdl(hdp_chan->mdl, hdp_mdl_delete_cb,
-						hdp_tmp_dc_data_ref(del_data),
-						hdp_tmp_dc_data_destroy, &err))
-			return NULL;
-		goto fail;
-	}
-
-	if (hdp_establish_mcl(device, hdp_continue_del_cb,
-						hdp_tmp_dc_data_ref(del_data),
-						hdp_tmp_dc_data_destroy, &err))
-		return NULL;
-
-fail:
-	reply = g_dbus_create_error(msg, ERROR_INTERFACE ".HealthError",
-							"%s", err->message);
-	hdp_tmp_dc_data_unref(del_data);
-	g_error_free(err);
-	return reply;
-}
-
-static gboolean dev_property_exists_main_channel(
-				const GDBusPropertyTable *property, void *data)
-{
-	struct hdp_device *device = data;
-	return device->fr != NULL;
-}
-
-static gboolean dev_property_get_main_channel(
-					const GDBusPropertyTable *property,
-					DBusMessageIter *iter, void *data)
-{
-	struct hdp_device *device = data;
-
-	if (device->fr == NULL)
-		return FALSE;
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
-							&device->fr->path);
-
-	return TRUE;
-}
-
-static void health_device_destroy(void *data)
-{
-	struct hdp_device *device = data;
-
-	DBG("Unregistered interface %s on path %s", HEALTH_DEVICE,
-						device_get_path(device->dev));
-
-	remove_channels(device);
-	if (device->ndc != NULL) {
-		hdp_channel_unref(device->ndc);
-		device->ndc = NULL;
-	}
-
-	devices = g_slist_remove(devices, device);
-	health_device_unref(device);
-}
-
-static const GDBusMethodTable health_device_methods[] = {
-	{ GDBUS_ASYNC_METHOD("Echo",
-			NULL, GDBUS_ARGS({ "value", "b" }), device_echo) },
-	{ GDBUS_ASYNC_METHOD("CreateChannel",
-			GDBUS_ARGS({ "application", "o" },
-					{ "configuration", "s" }),
-			GDBUS_ARGS({ "channel", "o" }),
-			device_create_channel) },
-	{ GDBUS_ASYNC_METHOD("DestroyChannel",
-			GDBUS_ARGS({ "channel", "o" }), NULL,
-			device_destroy_channel) },
-	{ }
-};
-
-static const GDBusSignalTable health_device_signals[] = {
-	{ GDBUS_SIGNAL("ChannelConnected",
-			GDBUS_ARGS({ "channel", "o" })) },
-	{ GDBUS_SIGNAL("ChannelDeleted",
-			GDBUS_ARGS({ "channel", "o" })) },
-	{ }
-};
-
-static const GDBusPropertyTable health_device_properties[] = {
-	{ "MainChannel", "o", dev_property_get_main_channel, NULL,
-					dev_property_exists_main_channel },
-	{ }
-};
-
-static struct hdp_device *create_health_device(struct btd_device *device)
-{
-	struct btd_adapter *adapter = device_get_adapter(device);
-	const char *path = device_get_path(device);
-	struct hdp_device *dev;
-	GSList *l;
-
-	if (device == NULL)
-		return NULL;
-
-	dev = g_new0(struct hdp_device, 1);
-	dev->dev = btd_device_ref(device);
-	health_device_ref(dev);
-
-	l = g_slist_find_custom(adapters, adapter, cmp_adapter);
-	if (l == NULL)
-		goto fail;
-
-	dev->hdp_adapter = l->data;
-
-	if (!g_dbus_register_interface(btd_get_dbus_connection(),
-					path, HEALTH_DEVICE,
-					health_device_methods,
-					health_device_signals,
-					health_device_properties,
-					dev, health_device_destroy)) {
-		error("D-Bus failed to register %s interface", HEALTH_DEVICE);
-		goto fail;
-	}
-
-	DBG("Registered interface %s on path %s", HEALTH_DEVICE, path);
-	return dev;
-
-fail:
-	health_device_unref(dev);
-	return NULL;
-}
-
-int hdp_device_register(struct btd_device *device)
-{
-	struct hdp_device *hdev;
-	GSList *l;
-
-	l = g_slist_find_custom(devices, device, cmp_device);
-	if (l != NULL) {
-		hdev = l->data;
-		hdev->sdp_present = TRUE;
-		return 0;
-	}
-
-	hdev = create_health_device(device);
-	if (hdev == NULL)
-		return -1;
-
-	hdev->sdp_present = TRUE;
-
-	devices = g_slist_prepend(devices, hdev);
-	return 0;
-}
-
-void hdp_device_unregister(struct btd_device *device)
-{
-	struct hdp_device *hdp_dev;
-	const char *path;
-	GSList *l;
-
-	l = g_slist_find_custom(devices, device, cmp_device);
-	if (l == NULL)
-		return;
-
-	hdp_dev = l->data;
-	path = device_get_path(hdp_dev->dev);
-	g_dbus_unregister_interface(btd_get_dbus_connection(),
-							path, HEALTH_DEVICE);
-}
-
-int hdp_manager_start(void)
-{
-	DBG("Starting Health manager");
-
-	if (!g_dbus_register_interface(btd_get_dbus_connection(),
-					MANAGER_PATH, HEALTH_MANAGER,
-					health_manager_methods, NULL, NULL,
-					NULL, manager_path_unregister)) {
-		error("D-Bus failed to register %s interface", HEALTH_MANAGER);
-		return -1;
-	}
-
-	return 0;
-}
-
-void hdp_manager_stop(void)
-{
-	g_dbus_unregister_interface(btd_get_dbus_connection(),
-						MANAGER_PATH, HEALTH_MANAGER);
-
-	DBG("Stopped Health manager");
-}
-
-struct hdp_device *health_device_ref(struct hdp_device *hdp_dev)
-{
-	hdp_dev->ref++;
-
-	DBG("(%p): ref=%d", hdp_dev, hdp_dev->ref);
-
-	return hdp_dev;
-}
-
-void health_device_unref(struct hdp_device *hdp_dev)
-{
-	hdp_dev->ref--;
-
-	DBG("(%p): ref=%d", hdp_dev, hdp_dev->ref);
-
-	if (hdp_dev->ref > 0)
-		return;
-
-	free_health_device(hdp_dev);
-}

@@ -1,19 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-int hdp_adapter_register(struct btd_adapter *btd_adapter);
-void hdp_adapter_unregister(struct btd_adapter *btd_adapter);
-
-int hdp_device_register(struct btd_device *device);
-void hdp_device_unregister(struct btd_device *device);
-
-int hdp_manager_start(void);
-void hdp_manager_stop(void);
-
-gboolean hdp_set_mcl_cb(struct hdp_device *device, GError **err);

@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <errno.h>
-
-#include "gdbus/gdbus.h"
-
-#include "src/plugin.h"
-#include "hdp_manager.h"
-
-static int hdp_init(void)
-{
-	return hdp_manager_init();
-}
-
-static void hdp_exit(void)
-{
-	hdp_manager_exit();
-}
-
-BLUETOOTH_PLUGIN_DEFINE(health, VERSION,
-			BLUETOOTH_PLUGIN_PRIORITY_DEFAULT, hdp_init, hdp_exit)

@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdbool.h>
-
-#include "bluetooth/sdp.h"
-#include "bluetooth/sdp_lib.h"
-#include "bluetooth/uuid.h"
-
-#include "btio/btio.h"
-#include "src/adapter.h"
-#include "src/device.h"
-#include "src/profile.h"
-#include "src/service.h"
-#include "src/uuid-helper.h"
-#include "src/log.h"
-
-#include "hdp_types.h"
-#include "hdp_manager.h"
-#include "hdp.h"
-
-static int hdp_adapter_probe(struct btd_profile *p,
-						struct btd_adapter *adapter)
-{
-	return hdp_adapter_register(adapter);
-}
-
-static void hdp_adapter_remove(struct btd_profile *p,
-						struct btd_adapter *adapter)
-{
-	hdp_adapter_unregister(adapter);
-}
-
-static int hdp_driver_probe(struct btd_service *service)
-{
-	struct btd_device *device = btd_service_get_device(service);
-
-	return hdp_device_register(device);
-}
-
-static void hdp_driver_remove(struct btd_service *service)
-{
-	struct btd_device *device = btd_service_get_device(service);
-
-	hdp_device_unregister(device);
-}
-
-static struct btd_profile hdp_source_profile = {
-	.name		= "hdp-source",
-	.bearer		= BTD_PROFILE_BEARER_BREDR,
-	.remote_uuid	= HDP_SOURCE_UUID,
-
-	.device_probe	= hdp_driver_probe,
-	.device_remove	= hdp_driver_remove,
-
-	.adapter_probe	= hdp_adapter_probe,
-	.adapter_remove	= hdp_adapter_remove,
-};
-
-static struct btd_profile hdp_sink_profile = {
-	.name		= "hdp-sink",
-	.bearer		= BTD_PROFILE_BEARER_BREDR,
-	.remote_uuid	= HDP_SINK_UUID,
-
-	.device_probe	= hdp_driver_probe,
-	.device_remove	= hdp_driver_remove,
-};
-
-int hdp_manager_init(void)
-{
-	if (hdp_manager_start() < 0)
-		return -1;
-
-	btd_profile_register(&hdp_source_profile);
-	btd_profile_register(&hdp_sink_profile);
-
-	return 0;
-}
-
-void hdp_manager_exit(void)
-{
-	btd_profile_unregister(&hdp_sink_profile);
-	btd_profile_unregister(&hdp_source_profile);
-
-	hdp_manager_stop();
-}

@@ -1,11 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-int hdp_manager_init(void);
-void hdp_manager_exit(void);

@@ -1,107 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-#ifndef __HDP_TYPES_H__
-#define __HDP_TYPES_H__
-
-#define MANAGER_PATH		"/org/bluez"
-
-#define HEALTH_MANAGER		"org.bluez.HealthManager1"
-#define HEALTH_DEVICE		"org.bluez.HealthDevice1"
-#define HEALTH_CHANNEL		"org.bluez.HealthChannel1"
-
-#define HDP_VERSION		0x0100
-
-#define HDP_SERVICE_NAME	"Bluez HDP"
-#define HDP_SERVICE_DSC		"A Bluez health device profile implementation"
-#define HDP_SERVICE_PROVIDER	"Bluez"
-
-#define HDP_MDEP_ECHO		0x00
-#define HDP_MDEP_INITIAL	0x01
-#define HDP_MDEP_FINAL		0x7F
-
-#define HDP_ERROR		g_quark_from_static_string("hdp-error-quark")
-
-#define HDP_NO_PREFERENCE_DC	0x00
-#define HDP_RELIABLE_DC		0x01
-#define HDP_STREAMING_DC	0x02
-
-#define HDP_SINK_ROLE_AS_STRING		"sink"
-#define HDP_SOURCE_ROLE_AS_STRING	"source"
-
-typedef enum {
-	HDP_SOURCE = 0x00,
-	HDP_SINK = 0x01
-} HdpRole;
-
-typedef enum {
-	HDP_DIC_PARSE_ERROR,
-	HDP_DIC_ENTRY_PARSE_ERROR,
-	HDP_CONNECTION_ERROR,
-	HDP_UNSPECIFIED_ERROR,
-	HDP_UNKNOWN_ERROR
-} HdpError;
-
-enum data_specs {
-	DATA_EXCHANGE_SPEC_11073 = 0x01
-};
-
-struct hdp_application {
-	char			*path;		/* The path of the application */
-	uint16_t		data_type;	/* Data type handled for this application */
-	gboolean		data_type_set;	/* Flag for dictionary parsing */
-	uint8_t			role;		/* Role of this application */
-	gboolean		role_set;	/* Flag for dictionary parsing */
-	uint8_t			chan_type;	/* QoS preferred by source applications */
-	gboolean		chan_type_set;	/* Flag for dictionary parsing */
-	char			*description;	/* Options description for SDP record */
-	uint8_t			id;		/* The identification is also the mdepid */
-	char			*oname;		/* Name of the owner application */
-	guint			dbus_watcher;	/* Watch for clients disconnection */
-	int			ref;		/* Reference counter */
-};
-
-struct hdp_adapter {
-	struct btd_adapter	*btd_adapter;	/* Bluetooth adapter */
-	struct mcap_instance	*mi;		/* Mcap instance in */
-	uint16_t		ccpsm;		/* Control channel psm */
-	uint16_t		dcpsm;		/* Data channel psm */
-	uint32_t		sdp_handler;	/* SDP record handler */
-	uint32_t		record_state;	/* Service record state */
-};
-
-struct hdp_device {
-	struct btd_device	*dev;		/* Device reference */
-	struct hdp_adapter	*hdp_adapter;	/* hdp_adapater */
-	struct mcap_mcl		*mcl;		/* The mcap control channel */
-	gboolean		mcl_conn;	/* Mcl status */
-	gboolean		sdp_present;	/* Has an sdp record */
-	GSList			*channels;	/* Data Channel list */
-	struct hdp_channel	*ndc;		/* Data channel being negotiated */
-	struct hdp_channel	*fr;		/* First reliable data channel */
-	int			ref;		/* Reference counting */
-};
-
-struct hdp_echo_data;
-
-struct hdp_channel {
-	struct hdp_device	*dev;		/* Device where this channel belongs */
-	struct hdp_application	*app;		/* Application */
-	struct mcap_mdl		*mdl;		/* The data channel reference */
-	char			*path;		/* The path of the channel */
-	uint8_t			config;		/* Channel configuration */
-	uint8_t			mdep;		/* Remote MDEP */
-	uint16_t		mdlid;		/* Data channel Id */
-	uint16_t		imtu;		/* Channel incoming MTU */
-	uint16_t		omtu;		/* Channel outgoing MTU */
-	struct hdp_echo_data	*edata;		/* private data used by echo channels */
-	int			ref;		/* Reference counter */
-};
-
-#endif /* __HDP_TYPES_H__ */

@@ -1,1193 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- *
- *  BlueZ - Bluetooth protocol stack for Linux
- *
- *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define _GNU_SOURCE
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <glib.h>
-
-#include "bluetooth/bluetooth.h"
-#include "bluetooth/sdp.h"
-#include "bluetooth/sdp_lib.h"
-#include "bluetooth/uuid.h"
-
-#include "gdbus/gdbus.h"
-
-#include "btio/btio.h"
-#include "src/adapter.h"
-#include "src/device.h"
-#include "src/sdpd.h"
-#include "src/sdp-client.h"
-#include "src/uuid-helper.h"
-#include "src/log.h"
-#include "src/dbus-common.h"
-
-#include "mcap.h"
-#include "hdp_types.h"
-#include "hdp.h"
-#include "hdp_util.h"
-
-typedef gboolean (*parse_item_f)(DBusMessageIter *iter, gpointer user_data,
-								GError **err);
-
-struct dict_entry_func {
-	const char	*key;
-	parse_item_f	func;
-};
-
-struct get_mdep_data {
-	struct hdp_application	*app;
-	gpointer		data;
-	hdp_continue_mdep_f	func;
-	GDestroyNotify		destroy;
-};
-
-struct conn_mcl_data {
-	int			refs;
-	gpointer		data;
-	hdp_continue_proc_f	func;
-	GDestroyNotify		destroy;
-	struct hdp_device	*dev;
-};
-
-struct get_dcpsm_data {
-	gpointer		data;
-	hdp_continue_dcpsm_f	func;
-	GDestroyNotify		destroy;
-};
-
-static gboolean parse_dict_entry(const struct dict_entry_func dict_context[],
-							DBusMessageIter *iter,
-							GError **err,
-							gpointer user_data)
-{
-	DBusMessageIter entry;
-	char *key;
-	int ctype, i;
-
-	dbus_message_iter_recurse(iter, &entry);
-	ctype = dbus_message_iter_get_arg_type(&entry);
-	if (ctype != DBUS_TYPE_STRING) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-			"Dictionary entries should have a string as key");
-		return FALSE;
-	}
-
-	dbus_message_iter_get_basic(&entry, &key);
-	dbus_message_iter_next(&entry);
-	/* Find function and call it */
-	for (i = 0; dict_context[i].key; i++) {
-		if (g_ascii_strcasecmp(dict_context[i].key, key) == 0)
-			return dict_context[i].func(&entry, user_data, err);
-	}
-
-	g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-			"No function found for parsing value for key %s", key);
-	return FALSE;
-}
-
-static gboolean parse_dict(const struct dict_entry_func dict_context[],
-							DBusMessageIter *iter,
-							GError **err,
-							gpointer user_data)
-{
-	int ctype;
-	DBusMessageIter dict;
-
-	ctype = dbus_message_iter_get_arg_type(iter);
-	if (ctype != DBUS_TYPE_ARRAY) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_PARSE_ERROR,
-					"Dictionary should be an array");
-		return FALSE;
-	}
-
-	dbus_message_iter_recurse(iter, &dict);
-	while ((ctype = dbus_message_iter_get_arg_type(&dict)) !=
-							DBUS_TYPE_INVALID) {
-		if (ctype != DBUS_TYPE_DICT_ENTRY) {
-			g_set_error(err, HDP_ERROR, HDP_DIC_PARSE_ERROR,
-						"Dictionary array should "
-						"contain dict entries");
-			return FALSE;
-		}
-
-		/* Start parsing entry */
-		if (!parse_dict_entry(dict_context, &dict, err,
-							user_data))
-			return FALSE;
-		/* Finish entry parsing */
-
-		dbus_message_iter_next(&dict);
-	}
-
-	return TRUE;
-}
-
-static gboolean parse_data_type(DBusMessageIter *iter, gpointer data,
-								GError **err)
-{
-	struct hdp_application *app = data;
-	DBusMessageIter *value;
-	DBusMessageIter variant;
-	int ctype;
-
-	ctype = dbus_message_iter_get_arg_type(iter);
-	value = iter;
-	if (ctype == DBUS_TYPE_VARIANT) {
-		/* Get value inside the variable */
-		dbus_message_iter_recurse(iter, &variant);
-		ctype = dbus_message_iter_get_arg_type(&variant);
-		value = &variant;
-	}
-
-	if (ctype != DBUS_TYPE_UINT16) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-			"Final value for data type should be uint16");
-		return FALSE;
-	}
-
-	dbus_message_iter_get_basic(value, &app->data_type);
-	app->data_type_set = TRUE;
-	return TRUE;
-}
-
-static gboolean parse_role(DBusMessageIter *iter, gpointer data, GError **err)
-{
-	struct hdp_application *app = data;
-	DBusMessageIter *string;
-	DBusMessageIter value;
-	int ctype;
-	const char *role;
-
-	ctype = dbus_message_iter_get_arg_type(iter);
-	if (ctype == DBUS_TYPE_VARIANT) {
-		/* Get value inside the variable */
-		dbus_message_iter_recurse(iter, &value);
-		ctype = dbus_message_iter_get_arg_type(&value);
-		string = &value;
-	} else {
-		string = iter;
-	}
-
-	if (ctype != DBUS_TYPE_STRING) {
-		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,
-				"Value data spec should be variable or string");
-		return FALSE;
-	}
-
-	dbus_message_iter_get_basic(string, &role);
-	if (g_ascii_strcasecmp(role, HDP_SINK_ROLE_AS_STRING) == 0) {
-		app->role = HDP_SINK;
-	} else if (g_ascii_strcasecmp(role, HDP_SOURCE_ROLE_AS_STRING) == 0) {
-		app->role = HDP_SOURCE;
-	} else {
-		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,
-			"Role value should be \"source\" or \"sink\"");
-		return FALSE;
-	}
-
-	app->role_set = TRUE;
-
-	return TRUE;
-}
-
-static gboolean parse_desc(DBusMessageIter *iter, gpointer data, GError **err)
-{
-	struct hdp_application *app = data;
-	DBusMessageIter *string;
-	DBusMessageIter variant;
-	int ctype;
-	const char *desc;
-
-	ctype = dbus_message_iter_get_arg_type(iter);
-	if (ctype == DBUS_TYPE_VARIANT) {
-		/* Get value inside the variable */
-		dbus_message_iter_recurse(iter, &variant);
-		ctype = dbus_message_iter_get_arg_type(&variant);
-		string = &variant;
-	} else {
-		string = iter;
-	}
-
-	if (ctype != DBUS_TYPE_STRING) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-				"Value data spec should be variable or string");
-		return FALSE;
-	}
-
-	dbus_message_iter_get_basic(string, &desc);
-	app->description = g_strdup(desc);
-	return TRUE;
-}
-
-static gboolean parse_chan_type(DBusMessageIter *iter, gpointer data,
-								GError **err)
-{
-	struct hdp_application *app = data;
-	DBusMessageIter *value;
-	DBusMessageIter variant;
-	char *chan_type;
-	int ctype;
-
-	ctype = dbus_message_iter_get_arg_type(iter);
-	value = iter;
-	if (ctype == DBUS_TYPE_VARIANT) {
-		/* Get value inside the variable */
-		dbus_message_iter_recurse(iter, &variant);
-		ctype = dbus_message_iter_get_arg_type(&variant);
-		value = &variant;
-	}
-
-	if (ctype != DBUS_TYPE_STRING) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-			"Final value for channel type should be an string");
-		return FALSE;
-	}
-
-	dbus_message_iter_get_basic(value, &chan_type);
-
-	if (g_ascii_strcasecmp("reliable", chan_type) == 0)
-		app->chan_type = HDP_RELIABLE_DC;
-	else if (g_ascii_strcasecmp("streaming", chan_type) == 0)
-		app->chan_type = HDP_STREAMING_DC;
-	else {
-		g_set_error(err, HDP_ERROR, HDP_DIC_ENTRY_PARSE_ERROR,
-						"Invalid value for data type");
-		return FALSE;
-	}
-
-	app->chan_type_set = TRUE;
-
-	return TRUE;
-}
-
-static const struct dict_entry_func dict_parser[] = {
-	{"DataType",		parse_data_type},
-	{"Role",		parse_role},
-	{"Description",		parse_desc},
-	{"ChannelType",		parse_chan_type},
-	{NULL, NULL}
-};
-
-struct hdp_application *hdp_get_app_config(DBusMessageIter *iter, GError **err)
-{
-	struct hdp_application *app;
-
-	app = g_new0(struct hdp_application, 1);
-	app->ref = 1;
-	if (!parse_dict(dict_parser, iter, err, app))
-		goto fail;
-	if (!app->data_type_set || !app->role_set) {
-		g_set_error(err, HDP_ERROR, HDP_DIC_PARSE_ERROR,
-						"Mandatory fields aren't set");
-		goto fail;
-	}
-	return app;
-
-fail:
-	hdp_application_unref(app);
-	return NULL;
-}
-
-static gboolean is_app_role(GSList *app_list, HdpRole role)
-{
-	GSList *l;
-
-	for (l = app_list; l; l = l->next) {
-		struct hdp_application *app = l->data;
-
-		if (app->role == role)
-			return TRUE;
-	}
-
-	return FALSE;
-}
-
-static gboolean set_sdp_services_uuid(sdp_record_t *record, HdpRole role)
-{
-	uuid_t svc_uuid_source, svc_uuid_sink;
-	sdp_list_t *svc_list = NULL;
-
-	sdp_uuid16_create(&svc_uuid_sink, HDP_SINK_SVCLASS_ID);
-	sdp_uuid16_create(&svc_uuid_source, HDP_SOURCE_SVCLASS_ID);
-
-	sdp_get_service_classes(record, &svc_list);
-
-	if (role == HDP_SOURCE) {
-		if (!sdp_list_find(svc_list, &svc_uuid_source, sdp_uuid_cmp))
-			svc_list = sdp_list_append(svc_list, &svc_uuid_source);
-	} else if (role == HDP_SINK) {
-		if (!sdp_list_find(svc_list, &svc_uuid_sink, sdp_uuid_cmp))
-			svc_list = sdp_list_append(svc_list, &svc_uuid_sink);
-	}
-
-	if (sdp_set_service_classes(record, svc_list) < 0) {
-		sdp_list_free(svc_list, NULL);
-		return FALSE;
-	}
-
-	sdp_list_free(svc_list, NULL);
-
-	return TRUE;
-}
-
-static gboolean register_service_protocols(struct hdp_adapter *adapter,
-						sdp_record_t *sdp_record)
-{
-	gboolean ret;
-	uuid_t l2cap_uuid, mcap_c_uuid;
-	sdp_list_t *l2cap_list, *proto_list = NULL, *mcap_list = NULL;
-	sdp_list_t *access_proto_list = NULL;
-	sdp_data_t *psm = NULL, *mcap_ver = NULL;
-	uint16_t version = MCAP_VERSION;
-
-	/* set l2cap information */
-	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
-	l2cap_list = sdp_list_append(NULL, &l2cap_uuid);
-	if (l2cap_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	psm = sdp_data_alloc(SDP_UINT16, &adapter->ccpsm);
-	if (psm == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	if (sdp_list_append(l2cap_list, psm) == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	proto_list = sdp_list_append(NULL, l2cap_list);
-	if (proto_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	/* set mcap information */
-	sdp_uuid16_create(&mcap_c_uuid, MCAP_CTRL_UUID);
-	mcap_list = sdp_list_append(NULL, &mcap_c_uuid);
-	if (mcap_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	mcap_ver = sdp_data_alloc(SDP_UINT16, &version);
-	if (mcap_ver == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	if (sdp_list_append(mcap_list, mcap_ver) == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	if (sdp_list_append(proto_list, mcap_list) == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	/* attach protocol information to service record */
-	access_proto_list = sdp_list_append(NULL, proto_list);
-	if (access_proto_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	ret = TRUE;
-	sdp_set_access_protos(sdp_record, access_proto_list);
-
-end:
-	if (l2cap_list != NULL)
-		sdp_list_free(l2cap_list, NULL);
-	if (mcap_list != NULL)
-		sdp_list_free(mcap_list, NULL);
-	if (proto_list != NULL)
-		sdp_list_free(proto_list, NULL);
-	if (access_proto_list != NULL)
-		sdp_list_free(access_proto_list, NULL);
-	if (psm != NULL)
-		sdp_data_free(psm);
-	if (mcap_ver != NULL)
-		sdp_data_free(mcap_ver);
-
-	return ret;
-}
-
-static gboolean register_service_profiles(sdp_record_t *sdp_record)
-{
-	gboolean ret;
-	sdp_list_t *profile_list;
-	sdp_profile_desc_t hdp_profile;
-
-	/* set hdp information */
-	sdp_uuid16_create(&hdp_profile.uuid, HDP_SVCLASS_ID);
-	hdp_profile.version = HDP_VERSION;
-	profile_list = sdp_list_append(NULL, &hdp_profile);
-	if (profile_list == NULL)
-		return FALSE;
-
-	/* set profile descriptor list */
-	if (sdp_set_profile_descs(sdp_record, profile_list) < 0)
-		ret = FALSE;
-	else
-		ret = TRUE;
-
-	sdp_list_free(profile_list, NULL);
-
-	return ret;
-}
-
-static gboolean register_service_additional_protocols(
-						struct hdp_adapter *adapter,
-						sdp_record_t *sdp_record)
-{
-	gboolean ret = TRUE;
-	uuid_t l2cap_uuid, mcap_d_uuid;
-	sdp_list_t *l2cap_list, *proto_list = NULL, *mcap_list = NULL;
-	sdp_list_t *access_proto_list = NULL;
-	sdp_data_t *psm = NULL;
-
-	/* set l2cap information */
-	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
-	l2cap_list = sdp_list_append(NULL, &l2cap_uuid);
-	if (l2cap_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	psm = sdp_data_alloc(SDP_UINT16, &adapter->dcpsm);
-	if (psm == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	if (sdp_list_append(l2cap_list, psm) == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	proto_list = sdp_list_append(NULL, l2cap_list);
-	if (proto_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	/* set mcap information */
-	sdp_uuid16_create(&mcap_d_uuid, MCAP_DATA_UUID);
-	mcap_list = sdp_list_append(NULL, &mcap_d_uuid);
-	if (mcap_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	if (sdp_list_append(proto_list, mcap_list) == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	/* attach protocol information to service record */
-	access_proto_list = sdp_list_append(NULL, proto_list);
-	if (access_proto_list == NULL) {
-		ret = FALSE;
-		goto end;
-	}
-
-	sdp_set_add_access_protos(sdp_record, access_proto_list);
-
-end:
-	if (l2cap_list != NULL)
-		sdp_list_free(l2cap_list, NULL);
-	if (mcap_list != NULL)
-		sdp_list_free(mcap_list, NULL);
-	if (proto_list  != NULL)
-		sdp_list_free(proto_list, NULL);
-	if (access_proto_list != NULL)
-		sdp_list_free(access_proto_list, NULL);
-	if (psm != NULL)
-		sdp_data_free(psm);
-
-	return ret;
-}
-
-static sdp_list_t *app_to_sdplist(struct hdp_application *app)
-{
-	sdp_data_t *mdepid,
-		*dtype = NULL,
-		*role = NULL,
-		*desc = NULL;
-	sdp_list_t *f_list = NULL;
-
-	mdepid = sdp_data_alloc(SDP_UINT8, &app->id);
-	if (mdepid == NULL)
-		return NULL;
-
-	dtype = sdp_data_alloc(SDP_UINT16, &app->data_type);
-	if (dtype == NULL)
-		goto fail;
-
-	role = sdp_data_alloc(SDP_UINT8, &app->role);
-	if (role == NULL)
-		goto fail;
-
-	if (app->description != NULL) {
-		desc = sdp_data_alloc(SDP_TEXT_STR8, app->description);
-		if (desc == NULL)
-			goto fail;
-	}
-
-	f_list = sdp_list_append(NULL, mdepid);
-	if (f_list == NULL)
-		goto fail;
-
-	if (sdp_list_append(f_list, dtype) == NULL)
-		goto fail;
-
-	if (sdp_list_append(f_list, role) == NULL)
-		goto fail;
-
-	if (desc != NULL)
-		if (sdp_list_append(f_list, desc) == NULL)
-			goto fail;
-
-	return f_list;
-
-fail:
-	if (f_list != NULL)
-		sdp_list_free(f_list, NULL);
-	if (mdepid != NULL)
-		sdp_data_free(mdepid);
-	if (dtype != NULL)
-		sdp_data_free(dtype);
-	if (role != NULL)
-		sdp_data_free(role);
-	if (desc != NULL)
-		sdp_data_free(desc);
-
-	return NULL;
-}
-
-static void free_hdp_list(void *list)
-{
-	sdp_list_t *hdp_list = list;
-
-	sdp_list_free(hdp_list, (sdp_free_func_t)sdp_data_free);
-}
-
-static gboolean register_features(struct hdp_application *app,
-						sdp_list_t **sup_features)
-{
-	sdp_list_t *hdp_feature;
-
-	hdp_feature = app_to_sdplist(app);
-	if (hdp_feature == NULL)
-		goto fail;
-
-	if (*sup_features == NULL) {
-		*sup_features = sdp_list_append(NULL, hdp_feature);
-		if (*sup_features == NULL)
-			goto fail;
-	} else if (sdp_list_append(*sup_features, hdp_feature) == NULL) {
-		goto fail;
-	}
-
-	return TRUE;
-
-fail:
-	if (hdp_feature != NULL)
-		sdp_list_free(hdp_feature, (sdp_free_func_t)sdp_data_free);
-	if (*sup_features != NULL)
-		sdp_list_free(*sup_features, free_hdp_list);
-	return FALSE;
-}
-
-static gboolean register_service_sup_features(GSList *app_list,
-						sdp_record_t *sdp_record)
-{
-	GSList *l;
-	sdp_list_t *sup_features = NULL;
-
-	for (l = app_list; l; l = l->next) {
-		if (!register_features(l->data, &sup_features))
-			return FALSE;
-	}
-
-	if (sdp_set_supp_feat(sdp_record, sup_features) < 0) {
-		sdp_list_free(sup_features, free_hdp_list);
-		return FALSE;
-	}
-
-	sdp_list_free(sup_features, free_hdp_list);
-
-	return TRUE;
-}
-
-static gboolean register_data_exchange_spec(sdp_record_t *record)
-{
-	sdp_data_t *spec;
-	uint8_t data_spec = DATA_EXCHANGE_SPEC_11073;
-	/* As by now 11073 is the only supported we set it by default */
-
-	spec = sdp_data_alloc(SDP_UINT8, &data_spec);
-	if (spec == NULL)
-		return FALSE;
-
-	if (sdp_attr_add(record, SDP_ATTR_DATA_EXCHANGE_SPEC, spec) < 0) {
-		sdp_data_free(spec);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static gboolean register_mcap_features(sdp_record_t *sdp_record)
-{
-	sdp_data_t *mcap_proc;
-	uint8_t mcap_sup_proc = MCAP_SUP_PROC;
-
-	mcap_proc = sdp_data_alloc(SDP_UINT8, &mcap_sup_proc);
-	if (mcap_proc == NULL)
-		return FALSE;
-
-	if (sdp_attr_add(sdp_record, SDP_ATTR_MCAP_SUPPORTED_PROCEDURES,
-							mcap_proc) < 0) {
-		sdp_data_free(mcap_proc);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-gboolean hdp_update_sdp_record(struct hdp_adapter *adapter, GSList *app_list)
-{
-	sdp_record_t *sdp_record;
-
-	if (adapter->sdp_handler > 0)
-		adapter_service_remove(adapter->btd_adapter,
-					adapter->sdp_handler);
-
-	if (app_list == NULL) {
-		adapter->sdp_handler = 0;
-		return TRUE;
-	}
-
-	sdp_record = sdp_record_alloc();
-	if (sdp_record == NULL)
-		return FALSE;
-
-	if (adapter->sdp_handler > 0)
-		sdp_record->handle = adapter->sdp_handler;
-	else
-		sdp_record->handle = 0xffffffff; /* Set automatically */
-
-	if (is_app_role(app_list, HDP_SINK))
-		set_sdp_services_uuid(sdp_record, HDP_SINK);
-	if (is_app_role(app_list, HDP_SOURCE))
-		set_sdp_services_uuid(sdp_record, HDP_SOURCE);
-
-	if (!register_service_protocols(adapter, sdp_record))
-		goto fail;
-	if (!register_service_profiles(sdp_record))
-		goto fail;
-	if (!register_service_additional_protocols(adapter, sdp_record))
-		goto fail;
-
-	sdp_set_info_attr(sdp_record, HDP_SERVICE_NAME, HDP_SERVICE_PROVIDER,
-							HDP_SERVICE_DSC);
-	if (!register_service_sup_features(app_list, sdp_record))
-		goto fail;
-	if (!register_data_exchange_spec(sdp_record))
-		goto fail;
-
-	register_mcap_features(sdp_record);
-
-	if (sdp_set_record_state(sdp_record, adapter->record_state++) < 0)
-		goto fail;
-
-	if (adapter_service_add(adapter->btd_adapter, sdp_record) < 0)
-		goto fail;
-	adapter->sdp_handler = sdp_record->handle;
-	return TRUE;
-
-fail:
-	if (sdp_record != NULL)
-		sdp_record_free(sdp_record);
-	return FALSE;
-}
-
-static gboolean check_role(uint8_t rec_role, uint8_t app_role)
-{
-	if ((rec_role == HDP_SINK && app_role == HDP_SOURCE) ||
-			(rec_role == HDP_SOURCE && app_role == HDP_SINK))
-		return TRUE;
-
-	return FALSE;
-}
-
-static gboolean get_mdep_from_rec(const sdp_record_t *rec, uint8_t role,
-				uint16_t d_type, uint8_t *mdep, char **desc)
-{
-	sdp_data_t *list, *feat;
-
-	if (desc == NULL && mdep == NULL)
-		return TRUE;
-
-	list = sdp_data_get(rec, SDP_ATTR_SUPPORTED_FEATURES_LIST);
-	if (list == NULL || !SDP_IS_SEQ(list->dtd))
-		return FALSE;
-
-	for (feat = list->val.dataseq; feat; feat = feat->next) {
-		sdp_data_t *data_type, *mdepid, *role_t, *desc_t;
-
-		if (!SDP_IS_SEQ(feat->dtd))
-			continue;
-
-		mdepid = feat->val.dataseq;
-		if (mdepid == NULL)
-			continue;
-
-		data_type = mdepid->next;
-		if (data_type == NULL)
-			continue;
-
-		role_t = data_type->next;
-		if (role_t == NULL)
-			continue;
-
-		desc_t = role_t->next;
-
-		if (data_type->dtd != SDP_UINT16 || mdepid->dtd != SDP_UINT8 ||
-						role_t->dtd != SDP_UINT8)
-			continue;
-
-		if (data_type->val.uint16 != d_type ||
-					!check_role(role_t->val.uint8, role))
-			continue;
-
-		if (mdep != NULL)
-			*mdep = mdepid->val.uint8;
-
-		if (desc != NULL && desc_t != NULL &&
-						SDP_IS_TEXT_STR(desc_t->dtd))
-			*desc = g_strdup(desc_t->val.str);
-
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-static void get_mdep_cb(sdp_list_t *recs, int err, gpointer user_data)
-{
-	struct get_mdep_data *mdep_data = user_data;
-	GError *gerr = NULL;
-	uint8_t mdep;
-
-	if (err < 0 || recs == NULL) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-					"Error getting remote SDP records");
-		mdep_data->func(0, mdep_data->data, gerr);
-		g_error_free(gerr);
-		return;
-	}
-
-	if (!get_mdep_from_rec(recs->data, mdep_data->app->role,
-				mdep_data->app->data_type, &mdep, NULL)) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-					"No matching MDEP found");
-		mdep_data->func(0, mdep_data->data, gerr);
-		g_error_free(gerr);
-		return;
-	}
-
-	mdep_data->func(mdep, mdep_data->data, NULL);
-}
-
-static void free_mdep_data(gpointer data)
-{
-	struct get_mdep_data *mdep_data = data;
-
-	if (mdep_data->destroy)
-		mdep_data->destroy(mdep_data->data);
-	hdp_application_unref(mdep_data->app);
-
-	g_free(mdep_data);
-}
-
-gboolean hdp_get_mdep(struct hdp_device *device, struct hdp_application *app,
-				hdp_continue_mdep_f func, gpointer data,
-				GDestroyNotify destroy, GError **err)
-{
-	struct get_mdep_data *mdep_data;
-	const bdaddr_t *src;
-	const bdaddr_t *dst;
-	uuid_t uuid;
-
-	src = btd_adapter_get_address(device_get_adapter(device->dev));
-	dst = device_get_address(device->dev);
-
-	mdep_data = g_new0(struct get_mdep_data, 1);
-	mdep_data->app = hdp_application_ref(app);
-	mdep_data->func = func;
-	mdep_data->data = data;
-	mdep_data->destroy = destroy;
-
-	bt_string2uuid(&uuid, HDP_UUID);
-	if (bt_search_service(src, dst, &uuid, get_mdep_cb, mdep_data,
-						free_mdep_data, 0) < 0) {
-		g_set_error(err, HDP_ERROR, HDP_CONNECTION_ERROR,
-						"Can't get remote SDP record");
-		g_free(mdep_data);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static gboolean get_prot_desc_entry(sdp_data_t *entry, int type, guint16 *val)
-{
-	sdp_data_t *iter;
-	int proto;
-
-	if (entry == NULL || !SDP_IS_SEQ(entry->dtd))
-		return FALSE;
-
-	iter = entry->val.dataseq;
-	if (!(iter->dtd & SDP_UUID_UNSPEC))
-		return FALSE;
-
-	proto = sdp_uuid_to_proto(&iter->val.uuid);
-	if (proto != type)
-		return FALSE;
-
-	if (val == NULL)
-		return TRUE;
-
-	iter = iter->next;
-	if (iter->dtd != SDP_UINT16)
-		return FALSE;
-
-	*val = iter->val.uint16;
-
-	return TRUE;
-}
-
-static gboolean hdp_get_prot_desc_list(const sdp_record_t *rec, guint16 *psm,
-							guint16 *version)
-{
-	sdp_data_t *pdl, *p0, *p1;
-
-	if (psm == NULL && version == NULL)
-		return TRUE;
-
-	pdl = sdp_data_get(rec, SDP_ATTR_PROTO_DESC_LIST);
-	if (pdl == NULL || !SDP_IS_SEQ(pdl->dtd))
-		return FALSE;
-
-	p0 = pdl->val.dataseq;
-	if (!get_prot_desc_entry(p0, L2CAP_UUID, psm))
-		return FALSE;
-
-	p1 = p0->next;
-	if (!get_prot_desc_entry(p1, MCAP_CTRL_UUID, version))
-		return FALSE;
-
-	return TRUE;
-}
-
-static gboolean hdp_get_add_prot_desc_list(const sdp_record_t *rec,
-								guint16 *psm)
-{
-	sdp_data_t *pdl, *p0, *p1;
-
-	if (psm == NULL)
-		return TRUE;
-
-	pdl = sdp_data_get(rec, SDP_ATTR_ADD_PROTO_DESC_LIST);
-	if (pdl == NULL || pdl->dtd != SDP_SEQ8)
-		return FALSE;
-	pdl = pdl->val.dataseq;
-	if (pdl->dtd != SDP_SEQ8)
-		return FALSE;
-
-	p0 = pdl->val.dataseq;
-
-	if (!get_prot_desc_entry(p0, L2CAP_UUID, psm))
-		return FALSE;
-	p1 = p0->next;
-	if (!get_prot_desc_entry(p1, MCAP_DATA_UUID, NULL))
-		return FALSE;
-
-	return TRUE;
-}
-
-static gboolean get_ccpsm(sdp_list_t *recs, uint16_t *ccpsm)
-{
-	sdp_list_t *l;
-
-	for (l = recs; l; l = l->next) {
-		sdp_record_t *rec = l->data;
-
-		if (hdp_get_prot_desc_list(rec, ccpsm, NULL))
-			return TRUE;
-	}
-
-	return FALSE;
-}
-
-static gboolean get_dcpsm(sdp_list_t *recs, uint16_t *dcpsm)
-{
-	sdp_list_t *l;
-
-	for (l = recs; l; l = l->next) {
-		sdp_record_t *rec = l->data;
-
-		if (hdp_get_add_prot_desc_list(rec, dcpsm))
-			return TRUE;
-	}
-
-	return FALSE;
-}
-
-static void con_mcl_data_unref(struct conn_mcl_data *conn_data)
-{
-	if (conn_data == NULL)
-		return;
-
-	if (--conn_data->refs > 0)
-		return;
-
-	if (conn_data->destroy)
-		conn_data->destroy(conn_data->data);
-
-	health_device_unref(conn_data->dev);
-	g_free(conn_data);
-}
-
-static void destroy_con_mcl_data(gpointer data)
-{
-	con_mcl_data_unref(data);
-}
-
-static struct conn_mcl_data *con_mcl_data_ref(struct conn_mcl_data *conn_data)
-{
-	if (conn_data == NULL)
-		return NULL;
-
-	conn_data->refs++;
-	return conn_data;
-}
-
-static void create_mcl_cb(struct mcap_mcl *mcl, GError *err, gpointer data)
-{
-	struct conn_mcl_data *conn_data = data;
-	struct hdp_device *device = conn_data->dev;
-	GError *gerr = NULL;
-
-	if (err != NULL) {
-		conn_data->func(conn_data->data, err);
-		return;
-	}
-
-	if (device->mcl == NULL)
-		device->mcl = mcap_mcl_ref(mcl);
-	device->mcl_conn = TRUE;
-
-	hdp_set_mcl_cb(device, &gerr);
-
-	conn_data->func(conn_data->data, gerr);
-	if (gerr != NULL)
-		g_error_free(gerr);
-}
-
-static void search_cb(sdp_list_t *recs, int err, gpointer user_data)
-{
-	struct conn_mcl_data *conn_data = user_data;
-	GError *gerr = NULL;
-	uint16_t ccpsm;
-
-	if (conn_data->dev->hdp_adapter->mi == NULL) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-						"Mcap instance released");
-		goto fail;
-	}
-
-	if (err < 0 || recs == NULL) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-					"Error getting remote SDP records");
-		goto fail;
-	}
-
-	if (!get_ccpsm(recs, &ccpsm)) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-				"Can't get remote PSM for control channel");
-		goto fail;
-	}
-
-	conn_data = con_mcl_data_ref(conn_data);
-
-	if (!mcap_create_mcl(conn_data->dev->hdp_adapter->mi,
-					device_get_address(conn_data->dev->dev),
-					ccpsm, create_mcl_cb, conn_data,
-					destroy_con_mcl_data, &gerr)) {
-		con_mcl_data_unref(conn_data);
-		goto fail;
-	}
-	return;
-fail:
-	conn_data->func(conn_data->data, gerr);
-	g_error_free(gerr);
-}
-
-gboolean hdp_establish_mcl(struct hdp_device *device,
-						hdp_continue_proc_f func,
-						gpointer data,
-						GDestroyNotify destroy,
-						GError **err)
-{
-	struct conn_mcl_data *conn_data;
-	const bdaddr_t *src;
-	const bdaddr_t *dst;
-	uuid_t uuid;
-
-	src = btd_adapter_get_address(device_get_adapter(device->dev));
-	dst = device_get_address(device->dev);
-
-	conn_data = g_new0(struct conn_mcl_data, 1);
-	conn_data->refs = 1;
-	conn_data->func = func;
-	conn_data->data = data;
-	conn_data->destroy = destroy;
-	conn_data->dev = health_device_ref(device);
-
-	bt_string2uuid(&uuid, HDP_UUID);
-	if (bt_search_service(src, dst, &uuid, search_cb, conn_data,
-					destroy_con_mcl_data, 0) < 0) {
-		g_set_error(err, HDP_ERROR, HDP_CONNECTION_ERROR,
-						"Can't get remote SDP record");
-		g_free(conn_data);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static void get_dcpsm_cb(sdp_list_t *recs, int err, gpointer data)
-{
-	struct get_dcpsm_data *dcpsm_data = data;
-	GError *gerr = NULL;
-	uint16_t dcpsm;
-
-	if (err < 0 || recs == NULL) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-					"Error getting remote SDP records");
-		goto fail;
-	}
-
-	if (!get_dcpsm(recs, &dcpsm)) {
-		g_set_error(&gerr, HDP_ERROR, HDP_CONNECTION_ERROR,
-				"Can't get remote PSM for data channel");
-		goto fail;
-	}
-
-	dcpsm_data->func(dcpsm, dcpsm_data->data, NULL);
-	return;
-
-fail:
-	dcpsm_data->func(0, dcpsm_data->data, gerr);
-	g_error_free(gerr);
-}
-
-static void free_dcpsm_data(gpointer data)
-{
-	struct get_dcpsm_data *dcpsm_data = data;
-
-	if (dcpsm_data == NULL)
-		return;
-
-	if (dcpsm_data->destroy)
-		dcpsm_data->destroy(dcpsm_data->data);
-
-	g_free(dcpsm_data);
-}
-
-gboolean hdp_get_dcpsm(struct hdp_device *device, hdp_continue_dcpsm_f func,
-							gpointer data,
-							GDestroyNotify destroy,
-							GError **err)
-{
-	struct get_dcpsm_data *dcpsm_data;
-	const bdaddr_t *src;
-	const bdaddr_t *dst;
-	uuid_t uuid;
-
-	src = btd_adapter_get_address(device_get_adapter(device->dev));
-	dst = device_get_address(device->dev);
-
-	dcpsm_data = g_new0(struct get_dcpsm_data, 1);
-	dcpsm_data->func = func;
-	dcpsm_data->data = data;
-	dcpsm_data->destroy = destroy;
-
-	bt_string2uuid(&uuid, HDP_UUID);
-	if (bt_search_service(src, dst, &uuid, get_dcpsm_cb, dcpsm_data,
-						free_dcpsm_data, 0) < 0) {
-		g_set_error(err, HDP_ERROR, HDP_CONNECTION_ERROR,
-						"Can't get remote SDP record");
-		g_free(dcpsm_data);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static void hdp_free_application(struct hdp_application *app)
-{
-	if (app->dbus_watcher > 0)
-		g_dbus_remove_watch(btd_get_dbus_connection(),
-							app->dbus_watcher);
-
-	g_free(app->oname);
-	g_free(app->description);
-	g_free(app->path);
-	g_free(app);
-}
-
-struct hdp_application *hdp_application_ref(struct hdp_application *app)
-{
-	if (app == NULL)
-		return NULL;
-
-	app->ref++;
-
-	DBG("health_application_ref(%p): ref=%d", app, app->ref);
-	return app;
-}
-
-void hdp_application_unref(struct hdp_application *app)
-{
-	if (app == NULL)
-		return;
-
-	app->ref--;
-
-	DBG("health_application_unref(%p): ref=%d", app, app->ref);
-	if (app->ref > 0)
-		return;
-
-	hdp_free_application(app);
-}