src/manager.c - vendor/opensource/bluez - Git at Google

 /*
  *
  *  BlueZ - Bluetooth protocol stack for Linux
  *
  *  Copyright (C) 2006-2010  Nokia Corporation
  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */

 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif

 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>

 #include <bluetooth/bluetooth.h>
 #include <bluetooth/sdp.h>
 #include <bluetooth/sdp_lib.h>

 #include <glib.h>

 #include <dbus/dbus.h>

 #include <gdbus.h>

 #include "glib-helper.h"
 #include "hcid.h"
 #include "dbus-common.h"
 #include "log.h"
 #include "adapter.h"
 #include "device.h"
 #include "profile.h"
 #include "error.h"
 #include "manager.h"

 static const char *base_path = "/org/bluez";

 static int default_adapter_id = -1;
 static GSList *adapters = NULL;

 const char *manager_get_base_path(void)
 {
 	return base_path;
 }

 static DBusMessage *default_adapter(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	struct btd_adapter *adapter;
 	const gchar *path;

 	adapter = manager_find_adapter_by_id(default_adapter_id);
 	if (!adapter)
 		return btd_error_no_such_adapter(msg);

 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
 		return NULL;

 	path = adapter_get_path(adapter);

 	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
 				DBUS_TYPE_INVALID);

 	return reply;
 }

 static DBusMessage *find_adapter(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
 	DBusMessage *reply;
 	struct btd_adapter *adapter;
 	const char *pattern;
 	int dev_id;
 	const gchar *path;

 	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
 							DBUS_TYPE_INVALID))
 		return btd_error_invalid_args(msg);

 	/* hci_devid() would make sense to use here, except it is
 	 * restricted to devices which are up */
 	if (!strcmp(pattern, "any") || !strcmp(pattern, "00:00:00:00:00:00")) {
 		path = adapter_any_get_path();
 		if (path != NULL)
 			goto done;
 		return btd_error_no_such_adapter(msg);
 	} else if (!strncmp(pattern, "hci", 3) && strlen(pattern) >= 4) {
 		dev_id = atoi(pattern + 3);
 		adapter = manager_find_adapter_by_id(dev_id);
 	} else {
 		bdaddr_t bdaddr;
 		str2ba(pattern, &bdaddr);
 		adapter = manager_find_adapter(&bdaddr);
 	}

 	if (!adapter)
 		return btd_error_no_such_adapter(msg);

 	path = adapter_get_path(adapter);

 done:
 	reply = dbus_message_new_method_return(msg);
 	if (!reply)
 		return NULL;

 	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
 							DBUS_TYPE_INVALID);

 	return reply;
 }

 static gboolean manager_property_get_adapters(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
 	DBusMessageIter entry;
 	GSList *l;

 	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 				DBUS_TYPE_OBJECT_PATH_AS_STRING, &entry);

 	for (l = adapters; l != NULL; l = l->next) {
 		struct btd_adapter *adapter = l->data;
 		const char *path = adapter_get_path(adapter);

 		dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
 								&path);
 	}

 	dbus_message_iter_close_container(iter, &entry);

 	return TRUE;
 }

 static const GDBusMethodTable manager_methods[] = {
 	{ GDBUS_METHOD("DefaultAdapter",
 			NULL, GDBUS_ARGS({ "adapter", "o" }),
 			default_adapter) },
 	{ GDBUS_METHOD("FindAdapter",
 			GDBUS_ARGS({ "pattern", "s" }),
 			GDBUS_ARGS({ "adapter", "o" }),
 			find_adapter) },
 	{ }
 };

 static const GDBusSignalTable manager_signals[] = {
 	{ GDBUS_SIGNAL("AdapterAdded",
 			GDBUS_ARGS({ "adapter", "o" })) },
 	{ GDBUS_SIGNAL("AdapterRemoved",
 			GDBUS_ARGS({ "adapter", "o" })) },
 	{ GDBUS_SIGNAL("DefaultAdapterChanged",
 			GDBUS_ARGS({ "adapter", "o" })) },
 	{ }
 };

 static const GDBusPropertyTable manager_properties[] = {
 	{ "Adapters", "ao", manager_property_get_adapters },
 	{ }
 };

 bool manager_init(const char *path)
 {
 	if (!g_dbus_register_interface(btd_get_dbus_connection(),
 					"/", MANAGER_INTERFACE,
 					manager_methods, manager_signals,
 					manager_properties, NULL, NULL))
 		return false;

 	btd_profile_init();

 	return true;
 }

 static void manager_set_default_adapter(int id)
 {
 	struct btd_adapter *adapter;
 	const gchar *path;

 	default_adapter_id = id;

 	adapter = manager_find_adapter_by_id(id);
 	if (!adapter)
 		return;

 	path = adapter_get_path(adapter);

 	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
 				MANAGER_INTERFACE, "DefaultAdapterChanged",
 				DBUS_TYPE_OBJECT_PATH, &path,
 				DBUS_TYPE_INVALID);
 }

 struct btd_adapter *manager_get_default_adapter(void)
 {
 	return manager_find_adapter_by_id(default_adapter_id);
 }

 static void manager_remove_adapter(struct btd_adapter *adapter)
 {
 	uint16_t dev_id = adapter_get_dev_id(adapter);
 	const gchar *path = adapter_get_path(adapter);

 	adapters = g_slist_remove(adapters, adapter);

 	g_dbus_emit_property_changed(btd_get_dbus_connection(), "/",
 					MANAGER_INTERFACE, "Adapters");

 	if (default_adapter_id == dev_id || default_adapter_id < 0) {
 		int new_default = hci_get_route(NULL);

 		manager_set_default_adapter(new_default);
 	}

 	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
 				MANAGER_INTERFACE, "AdapterRemoved",
 				DBUS_TYPE_OBJECT_PATH, &path,
 				DBUS_TYPE_INVALID);

 	adapter_remove(adapter);
 	btd_adapter_unref(adapter);

 	if (adapters == NULL)
 		btd_start_exit_timer();
 }

 void manager_cleanup(const char *path)
 {
 	btd_profile_cleanup();

 	while (adapters) {
 		struct btd_adapter *adapter = adapters->data;

 		adapter_remove(adapter);
 		adapters = g_slist_remove(adapters, adapter);
 		btd_adapter_unref(adapter);
 	}

 	btd_start_exit_timer();

 	g_dbus_unregister_interface(btd_get_dbus_connection(),
 						"/", MANAGER_INTERFACE);
 }

 static gint adapter_id_cmp(gconstpointer a, gconstpointer b)
 {
 	struct btd_adapter *adapter = (struct btd_adapter *) a;
 	uint16_t id = GPOINTER_TO_UINT(b);
 	uint16_t dev_id = adapter_get_dev_id(adapter);

 	return dev_id == id ? 0 : -1;
 }

 static gint adapter_cmp(gconstpointer a, gconstpointer b)
 {
 	struct btd_adapter *adapter = (struct btd_adapter *) a;
 	const bdaddr_t *bdaddr = b;

 	return bacmp(adapter_get_address(adapter), bdaddr);
 }

 struct btd_adapter *manager_find_adapter(const bdaddr_t *sba)
 {
 	GSList *match;

 	match = g_slist_find_custom(adapters, sba, adapter_cmp);
 	if (!match)
 		return NULL;

 	return match->data;
 }

 struct btd_adapter *manager_find_adapter_by_id(int id)
 {
 	GSList *match;

 	match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
 							adapter_id_cmp);
 	if (!match)
 		return NULL;

 	return match->data;
 }

 void manager_foreach_adapter(adapter_cb func, gpointer user_data)
 {
 	g_slist_foreach(adapters, (GFunc) func, user_data);
 }

 GSList *manager_get_adapters(void)
 {
 	return adapters;
 }

 struct btd_adapter *btd_manager_register_adapter(int id, gboolean up)
 {
 	struct btd_adapter *adapter;
 	const char *path;

 	adapter = manager_find_adapter_by_id(id);
 	if (adapter) {
 		error("Unable to register adapter: hci%d already exist", id);
 		return NULL;
 	}

 	adapter = adapter_create(id);
 	if (!adapter)
 		return NULL;

 	adapters = g_slist_append(adapters, adapter);

 	if (!adapter_init(adapter, up)) {
 		adapters = g_slist_remove(adapters, adapter);
 		btd_adapter_unref(adapter);
 		return NULL;
 	}

 	path = adapter_get_path(adapter);
 	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
 				MANAGER_INTERFACE, "AdapterAdded",
 				DBUS_TYPE_OBJECT_PATH, &path,
 				DBUS_TYPE_INVALID);

 	g_dbus_emit_property_changed(btd_get_dbus_connection(),  "/",
 					MANAGER_INTERFACE, "Adapters");

 	btd_stop_exit_timer();

 	if (default_adapter_id < 0)
 		manager_set_default_adapter(id);

 	if (main_opts.did_source)
 		btd_adapter_set_did(adapter, main_opts.did_vendor,
 						main_opts.did_product,
 						main_opts.did_version,
 						main_opts.did_source);

 	DBG("Adapter %s registered", path);

 	return btd_adapter_ref(adapter);
 }

 int btd_manager_unregister_adapter(int id)
 {
 	struct btd_adapter *adapter;
 	const gchar *path;

 	adapter = manager_find_adapter_by_id(id);
 	if (!adapter)
 		return -1;

 	path = adapter_get_path(adapter);

 	info("Unregister path: %s", path);

 	manager_remove_adapter(adapter);

 	return 0;
 }
	/*
	*
	* BlueZ - Bluetooth protocol stack for Linux
	*
	* Copyright (C) 2006-2010 Nokia Corporation
	* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
	*
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*
	*/

	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif

	#include <stdlib.h>
	#include <stdio.h>
	#include <stdbool.h>
	#include <errno.h>
	#include <unistd.h>
	#include <sys/ioctl.h>
	#include <sys/socket.h>

	#include <bluetooth/bluetooth.h>
	#include <bluetooth/sdp.h>
	#include <bluetooth/sdp_lib.h>

	#include <glib.h>

	#include <dbus/dbus.h>

	#include <gdbus.h>

	#include "glib-helper.h"
	#include "hcid.h"
	#include "dbus-common.h"
	#include "log.h"
	#include "adapter.h"
	#include "device.h"
	#include "profile.h"
	#include "error.h"
	#include "manager.h"

	static const char *base_path = "/org/bluez";

	static int default_adapter_id = -1;
	static GSList *adapters = NULL;

	const char *manager_get_base_path(void)
	{
	return base_path;
	}

	static DBusMessage default_adapter(DBusConnection conn,
	DBusMessage msg, void data)
	{
	DBusMessage *reply;
	struct btd_adapter *adapter;
	const gchar *path;

	adapter = manager_find_adapter_by_id(default_adapter_id);
	if (!adapter)
	return btd_error_no_such_adapter(msg);

	reply = dbus_message_new_method_return(msg);
	if (!reply)
	return NULL;

	path = adapter_get_path(adapter);

	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
	DBUS_TYPE_INVALID);

	return reply;
	}

	static DBusMessage find_adapter(DBusConnection conn,
	DBusMessage msg, void data)
	{
	DBusMessage *reply;
	struct btd_adapter *adapter;
	const char *pattern;
	int dev_id;
	const gchar *path;

	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
	DBUS_TYPE_INVALID))
	return btd_error_invalid_args(msg);

	/* hci_devid() would make sense to use here, except it is
	* restricted to devices which are up */
	if (!strcmp(pattern, "any") \|\| !strcmp(pattern, "00:00:00:00:00:00")) {
	path = adapter_any_get_path();
	if (path != NULL)
	goto done;
	return btd_error_no_such_adapter(msg);
	} else if (!strncmp(pattern, "hci", 3) && strlen(pattern) >= 4) {
	dev_id = atoi(pattern + 3);
	adapter = manager_find_adapter_by_id(dev_id);
	} else {
	bdaddr_t bdaddr;
	str2ba(pattern, &bdaddr);
	adapter = manager_find_adapter(&bdaddr);
	}

	if (!adapter)
	return btd_error_no_such_adapter(msg);

	path = adapter_get_path(adapter);

	done:
	reply = dbus_message_new_method_return(msg);
	if (!reply)
	return NULL;

	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
	DBUS_TYPE_INVALID);

	return reply;
	}

	static gboolean manager_property_get_adapters(
	const GDBusPropertyTable *property,
	DBusMessageIter iter, void data)
	{
	DBusMessageIter entry;
	GSList *l;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
	DBUS_TYPE_OBJECT_PATH_AS_STRING, &entry);

	for (l = adapters; l != NULL; l = l->next) {
	struct btd_adapter *adapter = l->data;
	const char *path = adapter_get_path(adapter);

	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
	&path);
	}

	dbus_message_iter_close_container(iter, &entry);

	return TRUE;
	}

	static const GDBusMethodTable manager_methods[] = {
	{ GDBUS_METHOD("DefaultAdapter",
	NULL, GDBUS_ARGS({ "adapter", "o" }),
	default_adapter) },
	{ GDBUS_METHOD("FindAdapter",
	GDBUS_ARGS({ "pattern", "s" }),
	GDBUS_ARGS({ "adapter", "o" }),
	find_adapter) },
	{ }
	};

	static const GDBusSignalTable manager_signals[] = {
	{ GDBUS_SIGNAL("AdapterAdded",
	GDBUS_ARGS({ "adapter", "o" })) },
	{ GDBUS_SIGNAL("AdapterRemoved",
	GDBUS_ARGS({ "adapter", "o" })) },
	{ GDBUS_SIGNAL("DefaultAdapterChanged",
	GDBUS_ARGS({ "adapter", "o" })) },
	{ }
	};

	static const GDBusPropertyTable manager_properties[] = {
	{ "Adapters", "ao", manager_property_get_adapters },
	{ }
	};

	bool manager_init(const char *path)
	{
	if (!g_dbus_register_interface(btd_get_dbus_connection(),
	"/", MANAGER_INTERFACE,
	manager_methods, manager_signals,
	manager_properties, NULL, NULL))
	return false;

	btd_profile_init();

	return true;
	}

	static void manager_set_default_adapter(int id)
	{
	struct btd_adapter *adapter;
	const gchar *path;

	default_adapter_id = id;

	adapter = manager_find_adapter_by_id(id);
	if (!adapter)
	return;

	path = adapter_get_path(adapter);

	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
	MANAGER_INTERFACE, "DefaultAdapterChanged",
	DBUS_TYPE_OBJECT_PATH, &path,
	DBUS_TYPE_INVALID);
	}

	struct btd_adapter *manager_get_default_adapter(void)
	{
	return manager_find_adapter_by_id(default_adapter_id);
	}

	static void manager_remove_adapter(struct btd_adapter *adapter)
	{
	uint16_t dev_id = adapter_get_dev_id(adapter);
	const gchar *path = adapter_get_path(adapter);

	adapters = g_slist_remove(adapters, adapter);

	g_dbus_emit_property_changed(btd_get_dbus_connection(), "/",
	MANAGER_INTERFACE, "Adapters");

	if (default_adapter_id == dev_id \|\| default_adapter_id < 0) {
	int new_default = hci_get_route(NULL);

	manager_set_default_adapter(new_default);
	}

	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
	MANAGER_INTERFACE, "AdapterRemoved",
	DBUS_TYPE_OBJECT_PATH, &path,
	DBUS_TYPE_INVALID);

	adapter_remove(adapter);
	btd_adapter_unref(adapter);

	if (adapters == NULL)
	btd_start_exit_timer();
	}

	void manager_cleanup(const char *path)
	{
	btd_profile_cleanup();

	while (adapters) {
	struct btd_adapter *adapter = adapters->data;

	adapter_remove(adapter);
	adapters = g_slist_remove(adapters, adapter);
	btd_adapter_unref(adapter);
	}

	btd_start_exit_timer();

	g_dbus_unregister_interface(btd_get_dbus_connection(),
	"/", MANAGER_INTERFACE);
	}

	static gint adapter_id_cmp(gconstpointer a, gconstpointer b)
	{
	struct btd_adapter adapter = (struct btd_adapter ) a;
	uint16_t id = GPOINTER_TO_UINT(b);
	uint16_t dev_id = adapter_get_dev_id(adapter);

	return dev_id == id ? 0 : -1;
	}

	static gint adapter_cmp(gconstpointer a, gconstpointer b)
	{
	struct btd_adapter adapter = (struct btd_adapter ) a;
	const bdaddr_t *bdaddr = b;

	return bacmp(adapter_get_address(adapter), bdaddr);
	}

	struct btd_adapter manager_find_adapter(const bdaddr_t sba)
	{
	GSList *match;

	match = g_slist_find_custom(adapters, sba, adapter_cmp);
	if (!match)
	return NULL;

	return match->data;
	}

	struct btd_adapter *manager_find_adapter_by_id(int id)
	{
	GSList *match;

	match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
	adapter_id_cmp);
	if (!match)
	return NULL;

	return match->data;
	}

	void manager_foreach_adapter(adapter_cb func, gpointer user_data)
	{
	g_slist_foreach(adapters, (GFunc) func, user_data);
	}

	GSList *manager_get_adapters(void)
	{
	return adapters;
	}

	struct btd_adapter *btd_manager_register_adapter(int id, gboolean up)
	{
	struct btd_adapter *adapter;
	const char *path;

	adapter = manager_find_adapter_by_id(id);
	if (adapter) {
	error("Unable to register adapter: hci%d already exist", id);
	return NULL;
	}

	adapter = adapter_create(id);
	if (!adapter)
	return NULL;

	adapters = g_slist_append(adapters, adapter);

	if (!adapter_init(adapter, up)) {
	adapters = g_slist_remove(adapters, adapter);
	btd_adapter_unref(adapter);
	return NULL;
	}

	path = adapter_get_path(adapter);
	g_dbus_emit_signal(btd_get_dbus_connection(), "/",
	MANAGER_INTERFACE, "AdapterAdded",
	DBUS_TYPE_OBJECT_PATH, &path,
	DBUS_TYPE_INVALID);

	g_dbus_emit_property_changed(btd_get_dbus_connection(), "/",
	MANAGER_INTERFACE, "Adapters");

	btd_stop_exit_timer();

	if (default_adapter_id < 0)
	manager_set_default_adapter(id);

	if (main_opts.did_source)
	btd_adapter_set_did(adapter, main_opts.did_vendor,
	main_opts.did_product,
	main_opts.did_version,
	main_opts.did_source);

	DBG("Adapter %s registered", path);

	return btd_adapter_ref(adapter);
	}

	int btd_manager_unregister_adapter(int id)
	{
	struct btd_adapter *adapter;
	const gchar *path;

	adapter = manager_find_adapter_by_id(id);
	if (!adapter)
	return -1;

	path = adapter_get_path(adapter);

	info("Unregister path: %s", path);

	manager_remove_adapter(adapter);

	return 0;
	}