blob: cbbca1e6d53b40b7ec6e8b2b89d7fdba868cf41c [file] [log] [blame]
/*
*
* 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 <errno.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <glib.h>
#include <dbus/dbus.h>
#include <gdbus.h>
#include "hcid.h"
#include "dbus-common.h"
#include "log.h"
#include "adapter.h"
#include "error.h"
#include "manager.h"
static char base_path[50] = "/org/bluez";
static DBusConnection *connection = NULL;
static int default_adapter_id = -1;
static GSList *adapters = NULL;
const char *manager_get_base_path(void)
{
return base_path;
}
void manager_update_svc(struct btd_adapter* adapter, uint8_t svc)
{
adapter_update(adapter, svc);
}
static inline DBusMessage *invalid_args(DBusMessage *msg)
{
return g_dbus_create_error(msg,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
}
static inline DBusMessage *no_such_adapter(DBusMessage *msg)
{
return g_dbus_create_error(msg,
ERROR_INTERFACE ".NoSuchAdapter",
"No such adapter");
}
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 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 NULL;
/* 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 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
adapter = manager_find_adapter_by_address(pattern);
if (!adapter)
return 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 DBusMessage *list_adapters(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessageIter iter;
DBusMessageIter array_iter;
DBusMessage *reply;
GSList *l;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
for (l = adapters; l; l = l->next) {
struct btd_adapter *adapter = l->data;
const gchar *path = adapter_get_path(adapter);
dbus_message_iter_append_basic(&array_iter,
DBUS_TYPE_OBJECT_PATH, &path);
}
dbus_message_iter_close_container(&iter, &array_iter);
return reply;
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
GSList *list;
char **array;
int i;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
array = g_new0(char *, g_slist_length(adapters) + 1);
for (i = 0, list = adapters; list; list = list->next, i++) {
struct btd_adapter *adapter = list->data;
if (!adapter_is_ready(adapter))
continue;
array[i] = (char *) adapter_get_path(adapter);
}
dict_append_array(&dict, "Adapters", DBUS_TYPE_OBJECT_PATH, &array, i);
g_free(array);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static GDBusMethodTable manager_methods[] = {
{ "GetProperties", "", "a{sv}",get_properties },
{ "DefaultAdapter", "", "o", default_adapter },
{ "FindAdapter", "s", "o", find_adapter },
{ "ListAdapters", "", "ao", list_adapters,
G_DBUS_METHOD_FLAG_DEPRECATED},
{ }
};
static GDBusSignalTable manager_signals[] = {
{ "PropertyChanged", "sv" },
{ "AdapterAdded", "o" },
{ "AdapterRemoved", "o" },
{ "DefaultAdapterChanged", "o" },
{ }
};
dbus_bool_t manager_init(DBusConnection *conn, const char *path)
{
connection = conn;
snprintf(base_path, sizeof(base_path), "/org/bluez/%d", getpid());
return g_dbus_register_interface(conn, "/", MANAGER_INTERFACE,
manager_methods, manager_signals,
NULL, NULL, NULL);
}
static void manager_update_adapters(void)
{
GSList *list;
char **array;
int i;
array = g_new0(char *, g_slist_length(adapters) + 1);
for (i = 0, list = adapters; list; list = list->next, i++) {
struct btd_adapter *adapter = list->data;
if (!adapter_is_ready(adapter))
continue;
array[i] = (char *) adapter_get_path(adapter);
}
emit_array_property_changed(connection, "/",
MANAGER_INTERFACE, "Adapters",
DBUS_TYPE_OBJECT_PATH, &array);
g_free(array);
}
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);
manager_update_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(connection, "/",
MANAGER_INTERFACE, "AdapterRemoved",
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
adapter_remove(adapter);
if (adapters == NULL)
btd_start_exit_timer();
}
void manager_cleanup(DBusConnection *conn, const char *path)
{
g_slist_foreach(adapters, (GFunc) manager_remove_adapter, NULL);
g_slist_free(adapters);
g_dbus_unregister_interface(conn, "/", 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_path_cmp(gconstpointer a, gconstpointer b)
{
struct btd_adapter *adapter = (struct btd_adapter *) a;
const char *path = b;
const gchar *adapter_path = adapter_get_path(adapter);
return strcmp(adapter_path, path);
}
static gint adapter_cmp(gconstpointer a, gconstpointer b)
{
struct btd_adapter *adapter = (struct btd_adapter *) a;
const bdaddr_t *bdaddr = b;
bdaddr_t src;
adapter_get_address(adapter, &src);
return bacmp(&src, bdaddr);
}
static gint adapter_address_cmp(gconstpointer a, gconstpointer b)
{
struct btd_adapter *adapter = (struct btd_adapter *) a;
const char *address = b;
bdaddr_t bdaddr;
char addr[18];
adapter_get_address(adapter, &bdaddr);
ba2str(&bdaddr, addr);
return strcmp(addr, address);
}
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_address(const char *address)
{
GSList *match;
match = g_slist_find_custom(adapters, address, adapter_address_cmp);
if (!match)
return NULL;
return match->data;
}
struct btd_adapter *manager_find_adapter_by_path(const char *path)
{
GSList *match;
match = g_slist_find_custom(adapters, path, adapter_path_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;
}
GSList *manager_get_adapters(void)
{
return adapters;
}
void manager_add_adapter(const char *path)
{
g_dbus_emit_signal(connection, "/",
MANAGER_INTERFACE, "AdapterAdded",
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
manager_update_adapters();
btd_stop_exit_timer();
}
int manager_register_adapter(int id, gboolean devup)
{
struct btd_adapter *adapter;
adapter = manager_find_adapter_by_id(id);
if (adapter) {
error("Unable to register adapter: hci%d already exist", id);
return -1;
}
adapter = adapter_create(connection, id, devup);
if (!adapter)
return -1;
adapters = g_slist_append(adapters, adapter);
return 0;
}
int 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;
}
int manager_start_adapter(int id)
{
struct btd_adapter *adapter;
int ret;
adapter = manager_find_adapter_by_id(id);
if (!adapter) {
error("Getting device data failed: hci%d", id);
return -EINVAL;
}
ret = adapter_start(adapter);
if (ret < 0)
return ret;
if (default_adapter_id < 0)
manager_set_default_adapter(id);
return ret;
}
int manager_stop_adapter(int id)
{
struct btd_adapter *adapter;
adapter = manager_find_adapter_by_id(id);
if (!adapter) {
error("Getting device data failed: hci%d", id);
return -EINVAL;
}
return adapter_stop(adapter);
}
int manager_get_default_adapter()
{
return default_adapter_id;
}
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(connection, "/",
MANAGER_INTERFACE,
"DefaultAdapterChanged",
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
}
void btd_manager_set_offline(gboolean offline)
{
GSList *l;
for (l = adapters; l != NULL; l = g_slist_next(l)) {
struct btd_adapter *adapter = l->data;
if (offline)
btd_adapter_switch_offline(adapter);
else
btd_adapter_restore_powered(adapter);
}
}