From 1badf196a83fb8d32e212c49b7487b08962c18f0 Mon Sep 17 00:00:00 2001 From: Johan Hedberg Date: Wed, 1 Nov 2006 12:58:31 +0000 Subject: More cleanup. Move common dbus stuff to common/dbus.c. hcid/dbus.c -> hcid/dbus-hci.c --- common/Makefile.am | 5 +- common/dbus.c | 563 +++++++++++ common/dbus.h | 50 + hcid/Makefile.am | 2 +- hcid/dbus-adapter.c | 1 + hcid/dbus-common.c | 430 +++------ hcid/dbus-common.h | 22 +- hcid/dbus-hci.c | 2233 +++++++++++++++++++++++++++++++++++++++++++ hcid/dbus-hci.h | 83 ++ hcid/dbus-manager.c | 17 +- hcid/dbus-manager.h | 4 + hcid/dbus-rfcomm.c | 2 + hcid/dbus-sdp.c | 3 + hcid/dbus-security.c | 1 + hcid/dbus-test.c | 3 + hcid/dbus.c | 2591 -------------------------------------------------- hcid/dbus.h | 53 -- hcid/hcid.h | 26 - hcid/main.c | 2 + hcid/security.c | 1 + 20 files changed, 3127 insertions(+), 2965 deletions(-) create mode 100644 common/dbus.c create mode 100644 common/dbus.h create mode 100644 hcid/dbus-hci.c create mode 100644 hcid/dbus-hci.h delete mode 100644 hcid/dbus.c delete mode 100644 hcid/dbus.h diff --git a/common/Makefile.am b/common/Makefile.am index b2f6fb33..83ec45f4 100644 --- a/common/Makefile.am +++ b/common/Makefile.am @@ -1,9 +1,12 @@ +AM_CFLAGS = @DBUS_CFLAGS@ + noinst_LIBRARIES = libhelper.a libhelper_a_SOURCES = oui.h oui.c list.h list.c \ textfile.h textfile.c helper.h helper.c \ - glib-ectomy.h glib-ectomy.c logging.h logging.c + glib-ectomy.h glib-ectomy.c logging.h logging.c \ + dbus.h dbus.c noinst_PROGRAMS = test_textfile diff --git a/common/dbus.c b/common/dbus.c new file mode 100644 index 00000000..5ef1725e --- /dev/null +++ b/common/dbus.c @@ -0,0 +1,563 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2006 Marcel Holtmann + * + * + * 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 +#endif + +#include +#include +#include +#include +#include + +#include + +#include "glib-ectomy.h" +#include "dbus.h" +#include "logging.h" +#include "list.h" + +#define DISPATCH_TIMEOUT 0 + +static int name_listener_initialized = 0; + +static struct slist *name_listeners = NULL; + +typedef struct { + uint32_t id; + DBusTimeout *timeout; +} timeout_handler_t; + +struct watch_info { + guint watch_id; + GIOChannel *io; + DBusConnection *conn; +}; + +struct disconnect_data { + void (*disconnect_cb)(void *); + void *user_data; +}; + +struct name_callback { + name_cb_t func; + void *user_data; +}; + +struct name_data { + char *name; + struct slist *callbacks; +}; + +static struct name_data *name_data_find(const char *name) +{ + struct slist *current; + + for (current = name_listeners; current != NULL; current = current->next) { + struct name_data *data = current->data; + if (strcmp(name, data->name) == 0) + return data; + } + + return NULL; +} + +static struct name_callback *name_callback_find(struct slist *callbacks, + name_cb_t func, void *user_data) +{ + struct slist *current; + + for (current = callbacks; current != NULL; current = current->next) { + struct name_callback *cb = current->data; + if (cb->func == func && cb->user_data == user_data) + return cb; + } + + return NULL; +} + +static void name_data_free(struct name_data *data) +{ + struct slist *l; + + for (l = data->callbacks; l != NULL; l = l->next) + free(l->data); + + slist_free(data->callbacks); + + if (data->name) + free(data->name); + + free(data); +} + +static int name_data_add(const char *name, name_cb_t func, void *user_data) +{ + int first = 1; + struct name_data *data = NULL; + struct name_callback *cb = NULL; + + cb = malloc(sizeof(struct name_callback)); + if (!cb) + goto failed; + + cb->func = func; + cb->user_data = user_data; + + data = name_data_find(name); + if (data) { + first = 0; + goto done; + } + + data = malloc(sizeof(struct name_data)); + if (!data) + goto failed; + + memset(data, 0, sizeof(struct name_data)); + + data->name = strdup(name); + if (!data->name) + goto failed; + + name_listeners = slist_append(name_listeners, data); + +done: + data->callbacks = slist_append(data->callbacks, cb); + return first; + +failed: + if (data) + name_data_free(data); + + if (cb) + free(cb); + + return 0; +} + +static void name_data_remove(const char *name, name_cb_t func, void *user_data) +{ + struct name_data *data; + struct name_callback *cb = NULL; + + data = name_data_find(name); + if (!data) + return; + + cb = name_callback_find(data->callbacks, func, user_data); + if (cb) { + data->callbacks = slist_remove(data->callbacks, cb); + free(cb); + } + + if (!data->callbacks) { + name_listeners = slist_remove(name_listeners, data); + name_data_free(data); + } +} + +static DBusHandlerResult name_exit_filter(DBusConnection *connection, + DBusMessage *message, void *user_data) +{ + struct slist *l; + struct name_data *data; + char *name, *old, *new; + + if (!dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, + "NameOwnerChanged")) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + if (!dbus_message_get_args(message, NULL, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &old, + DBUS_TYPE_STRING, &new, + DBUS_TYPE_INVALID)) { + error("Invalid arguments for NameOwnerChanged signal"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + /* We are not interested of service creations */ + if (*new != '\0') + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + data = name_data_find(name); + if (!data) { + error("Got NameOwnerChanged signal for %s which has no listeners", name); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + for (l = data->callbacks; l != NULL; l = l->next) { + struct name_callback *cb = l->data; + cb->func(name, cb->user_data); + } + + name_listeners = slist_remove(name_listeners, data); + name_data_free(data); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +int name_listener_add(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data) +{ + DBusError err; + char match_string[128]; + int first; + + if (!name_listener_initialized) { + if (!dbus_connection_add_filter(connection, name_exit_filter, NULL, NULL)) { + error("dbus_connection_add_filter() failed"); + return -1; + } + name_listener_initialized = 1; + } + + first = name_data_add(name, func, user_data); + /* The filter is already added if this is not the first callback + * registration for the name */ + if (!first) + return 0; + + debug("name_listener_add(%s)", name); + + snprintf(match_string, sizeof(match_string), + "interface=%s,member=NameOwnerChanged,arg0=%s", + DBUS_INTERFACE_DBUS, name); + + dbus_error_init(&err); + dbus_bus_add_match(connection, match_string, &err); + + if (dbus_error_is_set(&err)) { + error("Adding match rule \"%s\" failed: %s", match_string, + err.message); + dbus_error_free(&err); + name_data_remove(name, func, user_data); + return -1; + } + + return 0; +} + +int name_listener_remove(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data) +{ + struct name_data *data; + struct name_callback *cb; + DBusError err; + char match_string[128]; + + debug("name_listener_remove(%s)", name); + + data = name_data_find(name); + if (!data) { + error("remove_name_listener: no listener for %s", name); + return -1; + } + + cb = name_callback_find(data->callbacks, func, user_data); + if (!cb) { + error("No matching callback found for %s", name); + return -1; + } + + data->callbacks = slist_remove(data->callbacks, cb); + free(cb); + + /* Don't remove the filter if other callbacks exist */ + if (data->callbacks) + return 0; + + snprintf(match_string, sizeof(match_string), + "interface=%s,member=NameOwnerChanged,arg0=%s", + DBUS_INTERFACE_DBUS, name); + + dbus_error_init(&err); + dbus_bus_remove_match(connection, match_string, &err); + + if (dbus_error_is_set(&err)) { + error("Removing owner match rule for %s failed: %s", + name, err.message); + dbus_error_free(&err); + return -1; + } + + name_data_remove(name, func, user_data); + + return 0; +} + +static DBusHandlerResult disconnect_filter(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *iface,*method; + struct disconnect_data *dc_data = data; + + if (dbus_message_get_type (msg) != DBUS_MESSAGE_TYPE_SIGNAL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + iface = dbus_message_get_interface(msg); + method = dbus_message_get_member(msg); + + if ((strcmp(iface, DBUS_INTERFACE_LOCAL) == 0) && + (strcmp(method, "Disconnected") == 0)) { + error("Got disconnected from the system message bus"); + dbus_connection_unref(conn); + dc_data->disconnect_cb(dc_data->user_data); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static gboolean message_dispatch_cb(void *data) +{ + DBusConnection *connection = data; + + dbus_connection_ref(connection); + + /* Dispatch messages */ + while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS); + + dbus_connection_unref(connection); + + return FALSE; +} + +static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data) +{ + DBusWatch *watch = data; + struct watch_info *info = dbus_watch_get_data(watch); + int flags = 0; + + if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE; + if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE; + if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP; + if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR; + + dbus_watch_handle(watch, flags); + + if (dbus_connection_get_dispatch_status(info->conn) == DBUS_DISPATCH_DATA_REMAINS) + g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, info->conn); + + return TRUE; +} + +static dbus_bool_t add_watch(DBusWatch *watch, void *data) +{ + GIOCondition cond = G_IO_HUP | G_IO_ERR; + DBusConnection *conn = data; + struct watch_info *info; + int fd, flags; + + if (!dbus_watch_get_enabled(watch)) + return TRUE; + + info = malloc(sizeof(struct watch_info)); + if (info == NULL) + return FALSE; + + fd = dbus_watch_get_fd(watch); + info->io = g_io_channel_unix_new(fd); + info->conn = dbus_connection_ref(conn); + + dbus_watch_set_data(watch, info, NULL); + + flags = dbus_watch_get_flags(watch); + + if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN; + if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT; + + info->watch_id = g_io_add_watch(info->io, cond, watch_func, watch); + + return TRUE; +} + +static void remove_watch(DBusWatch *watch, void *data) +{ + struct watch_info *info = dbus_watch_get_data(watch); + + dbus_watch_set_data(watch, NULL, NULL); + + if (info) { + g_io_remove_watch(info->watch_id); + g_io_channel_unref(info->io); + dbus_connection_unref(info->conn); + free(info); + } +} + +static void watch_toggled(DBusWatch *watch, void *data) +{ + /* Because we just exit on OOM, enable/disable is + * no different from add/remove */ + if (dbus_watch_get_enabled(watch)) + add_watch(watch, data); + else + remove_watch(watch, data); +} + +static gboolean timeout_handler_dispatch(gpointer data) +{ + timeout_handler_t *handler = data; + + /* if not enabled should not be polled by the main loop */ + if (dbus_timeout_get_enabled(handler->timeout) != TRUE) + return FALSE; + + dbus_timeout_handle(handler->timeout); + + return FALSE; +} + +static void timeout_handler_free(void *data) +{ + timeout_handler_t *handler = data; + if (!handler) + return; + + g_timeout_remove(handler->id); + free(handler); +} + +static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) +{ + timeout_handler_t *handler; + + if (!dbus_timeout_get_enabled (timeout)) + return TRUE; + + handler = malloc(sizeof(timeout_handler_t)); + memset(handler, 0, sizeof(timeout_handler_t)); + + handler->timeout = timeout; + handler->id = g_timeout_add(dbus_timeout_get_interval(timeout), + timeout_handler_dispatch, handler); + + dbus_timeout_set_data(timeout, handler, timeout_handler_free); + + return TRUE; +} + +static void remove_timeout(DBusTimeout *timeout, void *data) +{ + +} + +static void timeout_toggled(DBusTimeout *timeout, void *data) +{ + if (dbus_timeout_get_enabled(timeout)) + add_timeout(timeout, data); + else + remove_timeout(timeout, data); +} + +static void dispatch_status_cb(DBusConnection *conn, + DBusDispatchStatus new_status, + void *data) +{ + if (!dbus_connection_get_is_connected(conn)) + return; + + if (new_status == DBUS_DISPATCH_DATA_REMAINS) + g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, data); +} + +DBusConnection *init_dbus(void (*disconnect_cb)(void *), void *user_data) +{ + DBusConnection *conn; + DBusError err; + struct disconnect_data *dc_data; + + dbus_error_init(&err); + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + + if (dbus_error_is_set(&err)) { + error("Can't open system message bus connection: %s", + err.message); + dbus_error_free(&err); + return NULL; + } + + dbus_connection_set_watch_functions(conn, add_watch, remove_watch, + watch_toggled, conn, NULL); + + dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, + timeout_toggled, conn, NULL); + + dbus_connection_set_dispatch_status_function(conn, dispatch_status_cb, + conn, NULL); + + if (!disconnect_cb) + return conn; + + dc_data = malloc(sizeof(struct disconnect_data)); + if (!dc_data) { + error("Allocating disconnect data failed"); + dbus_connection_unref(conn); + return NULL; + } + + dc_data->disconnect_cb = disconnect_cb; + dc_data->user_data = user_data; + + dbus_connection_set_exit_on_disconnect(conn, FALSE); + + if (!dbus_connection_add_filter(conn, disconnect_filter, + dc_data, free)) { + error("Can't add D-Bus disconnect filter"); + free(dc_data); + dbus_connection_unref(conn); + return NULL; + } + + return conn; +} + +static char simple_xml[] = DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ""; + +DBusHandlerResult simple_introspect(DBusConnection *conn, DBusMessage *msg, void *data) +{ + DBusMessage *reply; + const char *path, *ptr = simple_xml; + + path = dbus_message_get_path(msg); + + info("Introspect path:%s", path); + + if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING)) { + error("Unexpected signature to introspect call"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + reply = dbus_message_new_method_return(msg); + if (!reply) + return DBUS_HANDLER_RESULT_NEED_MEMORY; + + dbus_message_append_args(reply, DBUS_TYPE_STRING, &ptr, + DBUS_TYPE_INVALID); + + return send_message_and_unref(conn, reply); +} + diff --git a/common/dbus.h b/common/dbus.h new file mode 100644 index 00000000..59afd6e6 --- /dev/null +++ b/common/dbus.h @@ -0,0 +1,50 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2006 Marcel Holtmann + * + * + * 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 + * + */ + +#ifndef __H_BLUEZ_DBUS_H__ +#define __H_BLUEZ_DBUS_H__ + +#include + +DBusConnection *init_dbus(void (*disconnect_cb)(void *), void *user_data); + +typedef void (*name_cb_t)(const char *name, void *user_data); + +int name_listener_add(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data); +int name_listener_remove(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data); + +DBusHandlerResult simple_introspect(DBusConnection *conn, DBusMessage *msg, void *data); + +static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, DBusMessage *msg) +{ + if (msg) { + dbus_connection_send(conn, msg, NULL); + dbus_message_unref(msg); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +#endif /* __H_BLUEZ_DBUS_H__ */ diff --git a/hcid/Makefile.am b/hcid/Makefile.am index 498e0589..560238c0 100644 --- a/hcid/Makefile.am +++ b/hcid/Makefile.am @@ -20,7 +20,7 @@ noinst_PROGRAMS = passkey-agent service-agent auth-agent hcid_SOURCES = main.c security.c device.c storage.c \ sdp.c sdp.h hcid.h parser.h parser.y \ lexer.l kword.c kword.h \ - dbus.h dbus.c dbus-common.c dbus-common.h \ + dbus-hci.h dbus-hci.c dbus-common.c dbus-common.h \ dbus-error.c dbus-error.h dbus-manager.c dbus-manager.h \ dbus-adapter.c dbus-adapter.h \ dbus-device.c dbus-device.h dbus-service.c dbus-service.h \ diff --git a/hcid/dbus-adapter.c b/hcid/dbus-adapter.c index 8fecc265..fef77456 100644 --- a/hcid/dbus-adapter.c +++ b/hcid/dbus-adapter.c @@ -48,6 +48,7 @@ #include "oui.h" #include "list.h" #include "dbus-common.h" +#include "dbus-hci.h" #include "dbus-sdp.h" #include "dbus-error.h" #include "dbus-adapter.h" diff --git a/hcid/dbus-common.c b/hcid/dbus-common.c index 0c8d0339..c25156af 100644 --- a/hcid/dbus-common.c +++ b/hcid/dbus-common.c @@ -35,6 +35,7 @@ #include #include #include +#include #include @@ -49,288 +50,24 @@ #include "list.h" #include "dbus.h" #include "dbus-error.h" +#include "dbus-hci.h" +#include "dbus-manager.h" #include "dbus-adapter.h" +#include "dbus-service.h" #include "dbus-security.h" #include "dbus-test.h" #include "dbus-rfcomm.h" #include "dbus-sdp.h" #include "dbus-common.h" -static int name_listener_initialized = 0; +#define BLUEZ_NAME "org.bluez" -struct name_callback { - name_cb_t func; - void *user_data; -}; - -struct name_data { - char *name; - struct slist *callbacks; -}; - -static struct slist *name_listeners = NULL; - -static struct name_data *name_data_find(const char *name) -{ - struct slist *current; - - for (current = name_listeners; current != NULL; current = current->next) { - struct name_data *data = current->data; - if (strcmp(name, data->name) == 0) - return data; - } - - return NULL; -} - -static struct name_callback *name_callback_find(struct slist *callbacks, - name_cb_t func, void *user_data) -{ - struct slist *current; - - for (current = callbacks; current != NULL; current = current->next) { - struct name_callback *cb = current->data; - if (cb->func == func && cb->user_data == user_data) - return cb; - } - - return NULL; -} - -static void name_data_free(struct name_data *data) -{ - struct slist *l; - - for (l = data->callbacks; l != NULL; l = l->next) - free(l->data); - - slist_free(data->callbacks); - - if (data->name) - free(data->name); - - free(data); -} - -static int name_data_add(const char *name, name_cb_t func, void *user_data) -{ - int first = 1; - struct name_data *data = NULL; - struct name_callback *cb = NULL; - - cb = malloc(sizeof(struct name_callback)); - if (!cb) - goto failed; - - cb->func = func; - cb->user_data = user_data; - - data = name_data_find(name); - if (data) { - first = 0; - goto done; - } - - data = malloc(sizeof(struct name_data)); - if (!data) - goto failed; - - memset(data, 0, sizeof(struct name_data)); - - data->name = strdup(name); - if (!data->name) - goto failed; - - name_listeners = slist_append(name_listeners, data); - -done: - data->callbacks = slist_append(data->callbacks, cb); - return first; - -failed: - if (data) - name_data_free(data); - - if (cb) - free(cb); - - return 0; -} - -static void name_data_remove(const char *name, name_cb_t func, void *user_data) -{ - struct name_data *data; - struct name_callback *cb = NULL; - - data = name_data_find(name); - if (!data) - return; - - cb = name_callback_find(data->callbacks, func, user_data); - if (cb) { - data->callbacks = slist_remove(data->callbacks, cb); - free(cb); - } - - if (!data->callbacks) { - name_listeners = slist_remove(name_listeners, data); - name_data_free(data); - } -} - -static DBusHandlerResult name_exit_filter(DBusConnection *connection, - DBusMessage *message, void *user_data) -{ - struct slist *l; - struct name_data *data; - char *name, *old, *new; - - if (!dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, - "NameOwnerChanged")) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - if (!dbus_message_get_args(message, NULL, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_STRING, &old, - DBUS_TYPE_STRING, &new, - DBUS_TYPE_INVALID)) { - error("Invalid arguments for NameOwnerChanged signal"); - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - } - - /* We are not interested of service creations */ - if (*new != '\0') - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - data = name_data_find(name); - if (!data) { - error("Got NameOwnerChanged signal for %s which has no listeners", name); - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - } - - for (l = data->callbacks; l != NULL; l = l->next) { - struct name_callback *cb = l->data; - cb->func(name, cb->user_data); - } - - name_listeners = slist_remove(name_listeners, data); - name_data_free(data); - - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; -} - -int name_listener_add(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data) -{ - DBusError err; - char match_string[128]; - int first; - - if (!name_listener_initialized) { - if (!dbus_connection_add_filter(connection, name_exit_filter, NULL, NULL)) { - error("dbus_connection_add_filter() failed"); - return -1; - } - name_listener_initialized = 1; - } - - first = name_data_add(name, func, user_data); - /* The filter is already added if this is not the first callback - * registration for the name */ - if (!first) - return 0; - - debug("name_listener_add(%s)", name); - - snprintf(match_string, sizeof(match_string), - "interface=%s,member=NameOwnerChanged,arg0=%s", - DBUS_INTERFACE_DBUS, name); - - dbus_error_init(&err); - dbus_bus_add_match(connection, match_string, &err); - - if (dbus_error_is_set(&err)) { - error("Adding match rule \"%s\" failed: %s", match_string, - err.message); - dbus_error_free(&err); - name_data_remove(name, func, user_data); - return -1; - } - - return 0; -} - -int name_listener_remove(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data) -{ - struct name_data *data; - struct name_callback *cb; - DBusError err; - char match_string[128]; - - debug("name_listener_remove(%s)", name); - - data = name_data_find(name); - if (!data) { - error("remove_name_listener: no listener for %s", name); - return -1; - } - - cb = name_callback_find(data->callbacks, func, user_data); - if (!cb) { - error("No matching callback found for %s", name); - return -1; - } - - data->callbacks = slist_remove(data->callbacks, cb); - free(cb); +#define MAX_CONN_NUMBER 10 +#define RECONNECT_RETRY_TIMEOUT 5000 - /* Don't remove the filter if other callbacks exist */ - if (data->callbacks) - return 0; +static DBusConnection *conn = NULL; - snprintf(match_string, sizeof(match_string), - "interface=%s,member=NameOwnerChanged,arg0=%s", - DBUS_INTERFACE_DBUS, name); - - dbus_error_init(&err); - dbus_bus_remove_match(connection, match_string, &err); - - if (dbus_error_is_set(&err)) { - error("Removing owner match rule for %s failed: %s", - name, err.message); - dbus_error_free(&err); - return -1; - } - - name_data_remove(name, func, user_data); - - return 0; -} - -static char simple_xml[] = DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ""; - -DBusHandlerResult simple_introspect(DBusConnection *conn, DBusMessage *msg, void *data) -{ - DBusMessage *reply; - const char *path, *ptr = simple_xml; - - path = dbus_message_get_path(msg); - - info("Introspect path:%s", path); - - if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING)) - return error_invalid_arguments(conn, msg); - - reply = dbus_message_new_method_return(msg); - if (!reply) - return DBUS_HANDLER_RESULT_NEED_MEMORY; - - dbus_message_append_args(reply, DBUS_TYPE_STRING, &ptr, - DBUS_TYPE_INVALID); - - return send_message_and_unref(conn, reply); -} +static int experimental = 0; service_handler_func_t find_service_handler(struct service_data *handlers, DBusMessage *msg) { @@ -501,3 +238,152 @@ DBusHandlerResult handle_method_call(DBusConnection *conn, DBusMessage *msg, voi return error_unknown_method(conn, msg); } +void hcid_dbus_set_experimental(void) +{ + experimental = 1; +} + +int hcid_dbus_use_experimental(void) +{ + return experimental; +} + +static gboolean system_bus_reconnect(void *data) +{ + struct hci_dev_list_req *dl = NULL; + struct hci_dev_req *dr; + int sk, i; + gboolean ret_val = TRUE; + + if (dbus_connection_get_is_connected(conn)) + return FALSE; + + if (hcid_dbus_init() < 0) + return TRUE; + + /* Create and bind HCI socket */ + sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); + if (sk < 0) { + error("Can't open HCI socket: %s (%d)", + strerror(errno), errno); + return TRUE; + } + + dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl)); + if (!dl) { + error("Can't allocate memory"); + goto failed; + } + + dl->dev_num = HCI_MAX_DEV; + dr = dl->dev_req; + + if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) { + info("Can't get device list: %s (%d)", + strerror(errno), errno); + goto failed; + } + + /* reset the default device */ + set_default_adapter(-1); + + for (i = 0; i < dl->dev_num; i++, dr++) + hcid_dbus_register_device(dr->dev_id); + + ret_val = FALSE; + +failed: + if (sk >= 0) + close(sk); + + if (dl) + free(dl); + + return ret_val; +} + +static void disconnect_callback(void *user_data) +{ + set_dbus_connection(NULL); + g_timeout_add(RECONNECT_RETRY_TIMEOUT, system_bus_reconnect, + NULL); +} + +static const DBusObjectPathVTable manager_vtable = { + .message_function = &handle_manager_method, + .unregister_function = NULL +}; + +void hcid_dbus_exit(void) +{ + char **children; + DBusConnection *conn = get_dbus_connection(); + int i; + + if (!conn || !dbus_connection_get_is_connected(conn)) + return; + + release_default_agent(); + release_default_auth_agent(); + release_service_agents(conn); + + /* Unregister all paths in Adapter path hierarchy */ + if (!dbus_connection_list_registered(conn, BASE_PATH, &children)) + goto done; + + for (i = 0; children[i]; i++) { + char dev_path[MAX_PATH_LENGTH]; + + snprintf(dev_path, sizeof(dev_path), "%s/%s", BASE_PATH, + children[i]); + + unregister_adapter_path(dev_path); + } + + dbus_free_string_array(children); + +done: + unregister_adapter_path(BASE_PATH); + + dbus_connection_unref(conn); + set_dbus_connection(NULL); +} + +int hcid_dbus_init(void) +{ + DBusError err; + DBusConnection *conn; + int ret_val; + + conn = init_dbus(disconnect_callback, NULL); + if (!conn) + return -1; + + dbus_error_init(&err); + + ret_val = dbus_bus_request_name(conn, BLUEZ_NAME, 0, &err); + + if (ret_val != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER ) { + error("Could not become the primary owner of %s.", BLUEZ_NAME); + return -1; + } + + if (dbus_error_is_set(&err)) { + error("Can't get system bus name %s: %s", BLUEZ_NAME, + err.message); + dbus_error_free(&err); + return -1; + } + + if (!dbus_connection_register_fallback(conn, BASE_PATH, + &manager_vtable, NULL)) { + error("D-Bus failed to register %s fallback", BASE_PATH); + return -1; + } + + set_dbus_connection(conn); + + dbus_connection_unref(conn); + + return 0; +} diff --git a/hcid/dbus-common.h b/hcid/dbus-common.h index 6bfbe33b..b9065982 100644 --- a/hcid/dbus-common.h +++ b/hcid/dbus-common.h @@ -26,6 +26,7 @@ #include #include +#include #define BASE_PATH "/org/bluez" @@ -40,15 +41,6 @@ struct service_data { service_handler_func_t handler_func; }; -typedef void (*name_cb_t)(const char *name, void *user_data); - -int name_listener_add(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data); -int name_listener_remove(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data); - -DBusHandlerResult simple_introspect(DBusConnection *conn, DBusMessage *msg, void *data); - service_handler_func_t find_service_handler(struct service_data *services, DBusMessage *msg); int str2uuid(uuid_t *uuid, const char *string); @@ -57,16 +49,10 @@ int l2raw_connect(const char *local, const bdaddr_t *remote); int check_address(const char *addr); -static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, DBusMessage *msg) -{ - if (msg) { - dbus_connection_send(conn, msg, NULL); - dbus_message_unref(msg); - } +DBusHandlerResult handle_method_call(DBusConnection *conn, DBusMessage *msg, void *data); - return DBUS_HANDLER_RESULT_HANDLED; -} +void hcid_dbus_exit(void); -DBusHandlerResult handle_method_call(DBusConnection *conn, DBusMessage *msg, void *data); +int hcid_dbus_init(void); #endif /* __BLUEZ_DBUS_COMMON_H */ diff --git a/hcid/dbus-hci.c b/hcid/dbus-hci.c new file mode 100644 index 00000000..e39a0968 --- /dev/null +++ b/hcid/dbus-hci.c @@ -0,0 +1,2233 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2006 Marcel Holtmann + * + * + * 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 +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include "glib-ectomy.h" + +#include "hcid.h" +#include "dbus.h" +#include "textfile.h" +#include "list.h" +#include "dbus-common.h" +#include "dbus-error.h" +#include "dbus-test.h" +#include "dbus-security.h" +#include "dbus-service.h" +#include "dbus-manager.h" +#include "dbus-adapter.h" +#include "dbus-hci.h" + +static DBusConnection *connection = NULL; + +void bonding_request_free(struct bonding_request_info *bonding) +{ + if (!bonding) + return; + + if (bonding->rq) + dbus_message_unref(bonding->rq); + + if (bonding->conn) + dbus_connection_unref(bonding->conn); + + if (bonding->io) + g_io_channel_unref(bonding->io); + + free(bonding); +} + +int found_device_cmp(const struct remote_dev_info *d1, + const struct remote_dev_info *d2) +{ + int ret; + + if (bacmp(&d2->bdaddr, BDADDR_ANY)) { + ret = bacmp(&d1->bdaddr, &d2->bdaddr); + if (ret) + return ret; + } + + if (d2->name_status != NAME_ANY) { + ret = (d1->name_status - d2->name_status); + if (ret) + return ret; + } + + return 0; +} + +int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2) +{ + int rssi1, rssi2; + + rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi; + rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi; + + return rssi1 - rssi2; +} + +int found_device_add(struct slist **list, bdaddr_t *bdaddr, int8_t rssi, + name_status_t name_status) +{ + struct remote_dev_info *dev, match; + struct slist *l; + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, bdaddr); + match.name_status = NAME_ANY; + + /* ignore repeated entries */ + l = slist_find(*list, &match, (cmp_func_t) found_device_cmp); + if (l) { + /* device found, update the attributes */ + dev = l->data; + + dev->rssi = rssi; + + /* Get remote name can be received while inquiring. + * Keep in mind that multiple inquiry result events can + * be received from the same remote device. + */ + if (name_status != NAME_NOT_REQUIRED) + dev->name_status = name_status; + + *list = slist_sort(*list, (cmp_func_t) dev_rssi_cmp); + + return -EALREADY; + } + + dev = malloc(sizeof(*dev)); + if (!dev) + return -ENOMEM; + + memset(dev, 0, sizeof(*dev)); + bacpy(&dev->bdaddr, bdaddr); + dev->rssi = rssi; + dev->name_status = name_status; + + *list = slist_insert_sorted(*list, dev, (cmp_func_t) dev_rssi_cmp); + + return 0; +} + +static int found_device_remove(struct slist **list, bdaddr_t *bdaddr) +{ + struct remote_dev_info *dev, match; + struct slist *l; + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, bdaddr); + + l = slist_find(*list, &match, (cmp_func_t) found_device_cmp); + if (!l) + return -1; + + dev = l->data; + *list = slist_remove(*list, dev); + free(dev); + + return 0; +} + +int active_conn_find_by_bdaddr(const void *data, const void *user_data) +{ + const struct active_conn_info *con = data; + const bdaddr_t *bdaddr = user_data; + + return bacmp(&con->bdaddr, bdaddr); +} + +static int active_conn_find_by_handle(const void *data, const void *user_data) +{ + const struct active_conn_info *dev = data; + const uint16_t *handle = user_data; + + if (dev->handle == *handle) + return 0; + + return -1; +} + +static int active_conn_append(struct slist **list, bdaddr_t *bdaddr, + uint16_t handle) +{ + struct active_conn_info *dev; + + dev = malloc(sizeof(*dev)); + if (!dev) + return -1; + + memset(dev, 0 , sizeof(*dev)); + bacpy(&dev->bdaddr, bdaddr); + dev->handle = handle; + + *list = slist_append(*list, dev); + return 0; +} + +static int active_conn_remove(struct slist **list, uint16_t handle) +{ + struct active_conn_info *dev; + struct slist *l; + + l = slist_find(*list, &handle, active_conn_find_by_handle); + if (!l) + return -1; + + dev = l->data; + + *list = slist_remove(*list, dev); + + free(dev); + + return 0; +} + +DBusMessage *new_authentication_return(DBusMessage *msg, uint8_t status) +{ + switch (status) { + case 0x00: /* success */ + return dbus_message_new_method_return(msg); + + case 0x04: /* page timeout */ + case 0x08: /* connection timeout */ + case 0x10: /* connection accept timeout */ + case 0x22: /* LMP response timeout */ + case 0x28: /* instant passed - is this a timeout? */ + return dbus_message_new_error(msg, + ERROR_INTERFACE ".AuthenticationTimeout", + "Authentication Timeout"); + case 0x17: /* too frequent pairing attempts */ + return dbus_message_new_error(msg, + ERROR_INTERFACE ".RepeatedAttemps", + "Repeated Attempts"); + + case 0x06: + case 0x18: /* pairing not allowed (e.g. gw rejected attempt) */ + return dbus_message_new_error(msg, + ERROR_INTERFACE ".AuthenticationRejected", + "Authentication Rejected"); + + case 0x07: /* memory capacity */ + case 0x09: /* connection limit */ + case 0x0a: /* synchronous connection limit */ + case 0x0d: /* limited resources */ + case 0x14: /* terminated due to low resources */ + return dbus_message_new_error(msg, + ERROR_INTERFACE ".AuthenticationCanceled", + "Authentication Canceled"); + + case 0x05: /* authentication failure */ + case 0x0E: /* rejected due to security reasons - is this auth failure? */ + case 0x25: /* encryption mode not acceptable - is this auth failure? */ + case 0x26: /* link key cannot be changed - is this auth failure? */ + case 0x29: /* pairing with unit key unsupported - is this auth failure? */ + case 0x2f: /* insufficient security - is this auth failure? */ + default: + return dbus_message_new_error(msg, + ERROR_INTERFACE ".AuthenticationFailed", + "Authentication Failed"); + } +} + +static inline int dev_append_signal_args(DBusMessage *signal, int first, + va_list var_args) +{ + void *value; + DBusMessageIter iter; + int type = first; + + dbus_message_iter_init_append(signal, &iter); + + while (type != DBUS_TYPE_INVALID) { + value = va_arg(var_args, void *); + + if (!dbus_message_iter_append_basic(&iter, type, value)) { + error("Append property argument error (type %d)", type); + return -1; + } + + type = va_arg(var_args, int); + } + + return 0; +} + +DBusMessage *dev_signal_factory(int devid, const char *prop_name, int first, + ...) +{ + va_list var_args; + DBusMessage *signal; + char path[MAX_PATH_LENGTH]; + + snprintf(path, sizeof(path)-1, "%s/hci%d", BASE_PATH, devid); + + signal = dbus_message_new_signal(path, ADAPTER_INTERFACE, prop_name); + if (!signal) { + error("Can't allocate D-BUS message"); + return NULL; + } + + va_start(var_args, first); + + if (dev_append_signal_args(signal, first, var_args) < 0) { + dbus_message_unref(signal); + signal = NULL; + } + + va_end(var_args); + + return signal; +} + +/* + * Virtual table that handle the object path hierarchy + */ + +static const DBusObjectPathVTable adapter_vtable = { + .message_function = &handle_method_call, + .unregister_function = NULL +}; + +/* + * HCI D-Bus services + */ +static void reply_pending_requests(const char *path, struct adapter *adapter) +{ + DBusMessage *message; + + if (!path || !adapter) + return; + + /* pending bonding */ + if (adapter->bonding) { + error_authentication_canceled(connection, adapter->bonding->rq); + name_listener_remove(connection, + dbus_message_get_sender(adapter->bonding->rq), + (name_cb_t) create_bond_req_exit, + adapter); + if (adapter->bonding->io_id) + g_io_remove_watch(adapter->bonding->io_id); + g_io_channel_close(adapter->bonding->io); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; + } + + /* If there is a pending reply for discovery cancel */ + if (adapter->discovery_cancel) { + message = dbus_message_new_method_return(adapter->discovery_cancel); + send_message_and_unref(connection, message); + dbus_message_unref(adapter->discovery_cancel); + adapter->discovery_cancel = NULL; + } + + if (adapter->discov_active) { + /* Send discovery completed signal if there isn't name + * to resolve */ + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "DiscoveryCompleted"); + send_message_and_unref(connection, message); + + /* Cancel inquiry initiated by D-Bus client */ + if (adapter->discov_requestor) + cancel_discovery(adapter); + } + + if (adapter->pdiscov_active) { + /* Send periodic discovery stopped signal exit or stop + * the device */ + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "PeriodicDiscoveryStopped"); + send_message_and_unref(connection, message); + + /* Stop periodic inquiry initiated by D-Bus client */ + if (adapter->pdiscov_requestor) + cancel_periodic_discovery(adapter); + } +} + +int unregister_adapter_path(const char *path) +{ + struct adapter *adapter = NULL; + + info("Unregister path: %s", path); + + dbus_connection_get_object_path_data(connection, path, + (void *) &adapter); + + if (!adapter) + goto unreg; + + /* check pending requests */ + reply_pending_requests(path, adapter); + + cancel_passkey_agent_requests(adapter->passkey_agents, path, NULL); + + release_passkey_agents(adapter, NULL); + + if (adapter->discov_requestor) { + name_listener_remove(connection, + adapter->discov_requestor, + (name_cb_t) discover_devices_req_exit, adapter); + free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + } + + if (adapter->pdiscov_requestor) { + name_listener_remove(connection, + adapter->pdiscov_requestor, + (name_cb_t) periodic_discover_req_exit, + adapter); + free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + if (adapter->found_devices) { + slist_foreach(adapter->found_devices, + (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + } + + if (adapter->oor_devices) { + slist_foreach(adapter->oor_devices, + (slist_func_t) free, NULL); + slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + } + + if (adapter->pin_reqs) { + slist_foreach(adapter->pin_reqs, + (slist_func_t) free, NULL); + slist_free(adapter->pin_reqs); + adapter->pin_reqs = NULL; + } + + if (adapter->active_conn) { + slist_foreach(adapter->active_conn, + (slist_func_t) free, NULL); + slist_free(adapter->active_conn); + adapter->active_conn = NULL; + } + + free (adapter); + +unreg: + if (!dbus_connection_unregister_object_path (connection, path)) { + error("D-Bus failed to unregister %s object", path); + return -1; + } + + return 0; +} + +/***************************************************************** + * + * Section reserved to HCI commands confirmation handling and low + * level events(eg: device attached/dettached. + * + *****************************************************************/ + +int hcid_dbus_register_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + char *pptr = path; + DBusMessage *message; + struct adapter *adapter; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + adapter = malloc(sizeof(struct adapter)); + if (!adapter) { + error("Failed to alloc memory to D-Bus path register data (%s)", + path); + return -1; + } + + memset(adapter, 0, sizeof(struct adapter)); + + adapter->dev_id = id; + adapter->pdiscov_resolve_names = 1; + + if (!dbus_connection_register_object_path(connection, path, + &adapter_vtable, adapter)) { + error("D-Bus failed to register %s object", path); + free(adapter); + return -1; + } + + /* + * Send the adapter added signal + */ + message = dbus_message_new_signal(BASE_PATH, MANAGER_INTERFACE, + "AdapterAdded"); + if (message == NULL) { + error("Can't allocate D-Bus message"); + dbus_connection_unregister_object_path(connection, path); + return -1; + } + + dbus_message_append_args(message, + DBUS_TYPE_STRING, &pptr, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + + return 0; +} + +int hcid_dbus_unregister_device(uint16_t id) +{ + DBusMessage *message; + char path[MAX_PATH_LENGTH]; + char *pptr = path; + int ret; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + message = dbus_message_new_signal(BASE_PATH, MANAGER_INTERFACE, + "AdapterRemoved"); + if (message == NULL) { + error("Can't allocate D-Bus message"); + goto failed; + } + + dbus_message_append_args(message, + DBUS_TYPE_STRING, &pptr, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + +failed: + ret = unregister_adapter_path(path); + + if (ret == 0 && get_default_adapter() == id) { + int new_default = hci_get_route(NULL); + set_default_adapter(new_default); + if (new_default >= 0) { + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, + new_default); + message = dbus_message_new_signal(BASE_PATH, + MANAGER_INTERFACE, + "DefaultAdapterChanged"); + if (!message) { + error("Can't allocate D-Bus message"); + /* Return success since actual unregistering + * succeeded */ + return ret; + } + + dbus_message_append_args(message, + DBUS_TYPE_STRING, &pptr, + DBUS_TYPE_INVALID); + send_message_and_unref(connection, message); + } + } + + return ret; +} + +int hcid_dbus_start_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + int i, err, dd = -1, ret = -1; + read_scan_enable_rp rp; + struct hci_dev_info di; + struct hci_request rq; + struct adapter* adapter; + struct hci_conn_list_req *cl = NULL; + struct hci_conn_info *ci; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + /* FIXME: check dupplicated code - configure_device() */ + if (hci_devinfo(id, &di) < 0) { + error("Getting device info failed: hci%d", id); + return -1; + } + + if (hci_test_bit(HCI_RAW, &di.flags)) + return -1; + + dd = hci_open_dev(id); + if (dd < 0) { + error("HCI device open failed: hci%d", id); + rp.enable = SCAN_PAGE | SCAN_INQUIRY; + } else { + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_HOST_CTL; + rq.ocf = OCF_READ_SCAN_ENABLE; + rq.rparam = &rp; + rq.rlen = READ_SCAN_ENABLE_RP_SIZE; + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, 1000) < 0) { + error("Sending read scan enable command failed: %s (%d)", + strerror(errno), errno); + rp.enable = SCAN_PAGE | SCAN_INQUIRY; + } else if (rp.status) { + error("Getting scan enable failed with status 0x%02x", + rp.status); + rp.enable = SCAN_PAGE | SCAN_INQUIRY; + } + } + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto failed; + } + + if (hci_test_bit(HCI_INQUIRY, &di.flags)) + adapter->discov_active = 1; + else + adapter->discov_active = 0; + + adapter->mode = rp.enable; /* Keep the current scan status */ + adapter->up = 1; + adapter->discov_timeout = get_discoverable_timeout(id); + adapter->discov_type = DISCOVER_TYPE_NONE; + + /* + * Get the adapter Bluetooth address + */ + err = get_device_address(adapter->dev_id, adapter->address, + sizeof(adapter->address)); + if (err < 0) + goto failed; + + /* + * retrieve the active connections: address the scenario where + * the are active connections before the daemon've started + */ + + cl = malloc(10 * sizeof(*ci) + sizeof(*cl)); + if (!cl) + goto failed; + + cl->dev_id = id; + cl->conn_num = 10; + ci = cl->conn_info; + + if (ioctl(dd, HCIGETCONNLIST, (void *) cl) < 0) { + free(cl); + cl = NULL; + goto failed; + } + + for (i = 0; i < cl->conn_num; i++, ci++) + active_conn_append(&adapter->active_conn, + &ci->bdaddr, ci->handle); + + ret = 0; + +failed: + if (ret == 0 && get_default_adapter() < 0) + set_default_adapter(id); + + if (dd >= 0) + hci_close_dev(dd); + + if (cl) + free(cl); + + return ret; +} + +int hcid_dbus_stop_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + struct adapter *adapter; + const char *scan_mode = MODE_OFF; + DBusMessage *message; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + return -1; + } + /* cancel pending timeout */ + if (adapter->timeout_id) { + g_timeout_remove(adapter->timeout_id); + adapter->timeout_id = 0; + } + + /* check pending requests */ + reply_pending_requests(path, adapter); + + message = dev_signal_factory(adapter->dev_id, "ModeChanged", + DBUS_TYPE_STRING, &scan_mode, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + + + cancel_passkey_agent_requests(adapter->passkey_agents, path, NULL); + + release_passkey_agents(adapter, NULL); + + if (adapter->discov_requestor) { + name_listener_remove(connection, adapter->discov_requestor, + (name_cb_t) discover_devices_req_exit, + adapter); + free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + } + + if (adapter->pdiscov_requestor) { + name_listener_remove(connection, adapter->pdiscov_requestor, + (name_cb_t) periodic_discover_req_exit, + adapter); + free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + if (adapter->found_devices) { + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + } + + if (adapter->oor_devices) { + slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); + slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + } + + if (adapter->pin_reqs) { + slist_foreach(adapter->pin_reqs, (slist_func_t) free, NULL); + slist_free(adapter->pin_reqs); + adapter->pin_reqs = NULL; + } + + if (adapter->active_conn) { + slist_foreach(adapter->active_conn, (slist_func_t) free, NULL); + slist_free(adapter->active_conn); + adapter->active_conn = NULL; + } + + adapter->up = 0; + adapter->mode = SCAN_DISABLED; + adapter->discov_active = 0; + adapter->pdiscov_active = 0; + adapter->pinq_idle = 0; + adapter->discov_type = DISCOVER_TYPE_NONE; + + return 0; +} + +int pin_req_cmp(const void *p1, const void *p2) +{ + const struct pending_pin_info *pb1 = p1; + const struct pending_pin_info *pb2 = p2; + + return p2 ? bacmp(&pb1->bdaddr, &pb2->bdaddr) : -1; +} + +void hcid_dbus_pending_pin_req_add(bdaddr_t *sba, bdaddr_t *dba) +{ + char path[MAX_PATH_LENGTH], addr[18]; + struct adapter *adapter; + struct pending_pin_info *info; + int id; + + ba2str(sba, addr); + + id = hci_devid(addr); + if (id < 0) { + error("No matching device id for %s", addr); + return; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + return; + } + + info = malloc(sizeof(struct pending_pin_info)); + if (!info) { + error("Out of memory when adding new pin request"); + return; + } + + memset(info, 0, sizeof(struct pending_pin_info)); + bacpy(&info->bdaddr, dba); + adapter->pin_reqs = slist_append(adapter->pin_reqs, info); + + if (adapter->bonding && !bacmp(dba, &adapter->bonding->bdaddr)) + adapter->bonding->auth_active = 1; +} + +int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci) +{ + char path[MAX_PATH_LENGTH], addr[18]; + int id; + + ba2str(sba, addr); + + id = hci_devid(addr); + if (id < 0) { + error("No matching device id for %s", addr); + return -1; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + return handle_passkey_request(connection, dev, path, sba, &ci->bdaddr); +} + +int hcid_dbus_confirm_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci, char *pin) +{ + char path[MAX_PATH_LENGTH], addr[18]; + int id; + + ba2str(sba, addr); + + id = hci_devid(addr); + if (id < 0) { + error("No matching device id for %s", addr); + return -1; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + return handle_confirm_request(connection, dev, path, sba, &ci->bdaddr, pin); +} + +void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, + uint8_t status) +{ + struct adapter *adapter; + DBusMessage *message; + char *local_addr, *peer_addr; + struct slist *l; + bdaddr_t tmp; + char path[MAX_PATH_LENGTH]; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + baswap(&tmp, peer); peer_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + /* create the authentication reply */ + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto failed; + } + + if (status) + cancel_passkey_agent_requests(adapter->passkey_agents, path, + peer); + + l = slist_find(adapter->pin_reqs, peer, pin_req_cmp); + if (l) { + void *d = l->data; + adapter->pin_reqs = slist_remove(adapter->pin_reqs, l->data); + free(d); + + if (!status) { + message = dev_signal_factory(adapter->dev_id, + "BondingCreated", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + send_message_and_unref(connection, message); + } + } + + release_passkey_agents(adapter, peer); + + if (!adapter->bonding || bacmp(&adapter->bonding->bdaddr, peer)) + goto failed; /* skip: no bonding req pending */ + + if (adapter->bonding->cancel) { + /* reply authentication canceled */ + error_authentication_canceled(connection, adapter->bonding->rq); + } else { + /* reply authentication success or an error */ + message = new_authentication_return(adapter->bonding->rq, + status); + send_message_and_unref(connection, message); + } + + name_listener_remove(connection, + dbus_message_get_sender(adapter->bonding->rq), + (name_cb_t) create_bond_req_exit, adapter); + + if (adapter->bonding->io_id) + g_io_remove_watch(adapter->bonding->io_id); + g_io_channel_close(adapter->bonding->io); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; + +failed: + bt_free(local_addr); + bt_free(peer_addr); +} + +void hcid_dbus_inquiry_start(bdaddr_t *local) +{ + struct adapter *adapter; + DBusMessage *message; + char path[MAX_PATH_LENGTH]; + char *local_addr; + bdaddr_t tmp; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + adapter->discov_active = 1; + /* + * Cancel pending remote name request and clean the device list + * when inquiry is supported in periodic inquiry idle state. + */ + if (adapter->pdiscov_active) + pending_remote_name_cancel(adapter); + + /* Disable name resolution for non D-Bus clients */ + if (!adapter->discov_requestor) + adapter->discov_type &= ~RESOLVE_NAME; + } + + message = dev_signal_factory(adapter->dev_id, "DiscoveryStarted", + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + +failed: + bt_free(local_addr); +} + +int found_device_req_name(struct adapter *adapter) +{ + struct hci_request rq; + evt_cmd_status rp; + remote_name_req_cp cp; + struct remote_dev_info match; + struct slist *l; + int dd, req_sent = 0; + + /* get the next remote address */ + if (!adapter->found_devices) + return -ENODATA; + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, BDADDR_ANY); + match.name_status = NAME_REQUIRED; + + l = slist_find(adapter->found_devices, &match, + (cmp_func_t) found_device_cmp); + if (!l) + return -ENODATA; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) + return -errno; + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_LINK_CTL; + rq.ocf = OCF_REMOTE_NAME_REQ; + rq.cparam = &cp; + rq.clen = REMOTE_NAME_REQ_CP_SIZE; + rq.rparam = &rp; + rq.rlen = EVT_CMD_STATUS_SIZE; + rq.event = EVT_CMD_STATUS; + + /* send at least one request or return failed if the list is empty */ + do { + DBusMessage *failed_signal = NULL; + struct remote_dev_info *dev = l->data; + char *peer_addr; + bdaddr_t tmp; + + /* flag to indicate the current remote name requested */ + dev->name_status = NAME_REQUESTED; + + memset(&cp, 0, sizeof(cp)); + bacpy(&cp.bdaddr, &dev->bdaddr); + cp.pscan_rep_mode = 0x02; + + baswap(&tmp, &dev->bdaddr); peer_addr = batostr(&tmp); + + if (hci_send_req(dd, &rq, 500) < 0) { + error("Unable to send the HCI remote name request: %s (%d)", + strerror(errno), errno); + failed_signal = dev_signal_factory(adapter->dev_id, + "RemoteNameFailed", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + } + + if (rp.status) { + error("Remote name request failed with status 0x%02x", + rp.status); + failed_signal = dev_signal_factory(adapter->dev_id, + "RemoteNameFailed", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + } + + free(peer_addr); + + if (!failed_signal) { + req_sent = 1; + break; + } + + send_message_and_unref(connection, failed_signal); + failed_signal = NULL; + + /* if failed, request the next element */ + /* remove the element from the list */ + adapter->found_devices = slist_remove(adapter->found_devices, dev); + free(dev); + + /* get the next element */ + l = slist_find(adapter->found_devices, &match, + (cmp_func_t) found_device_cmp); + + } while (l); + + hci_close_dev(dd); + + if (!req_sent) + return -ENODATA; + + return 0; +} + +static void send_out_of_range(const char *path, struct slist *l) +{ + DBusMessage *message; + const char *peer_addr; + + while (l) { + peer_addr = l->data; + + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "RemoteDeviceDisappeared"); + dbus_message_append_args(message, + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + l = l->next; + } +} + +void hcid_dbus_inquiry_complete(bdaddr_t *local) +{ + DBusMessage *message; + struct adapter *adapter; + struct slist *l; + char path[MAX_PATH_LENGTH]; + char *local_addr; + struct remote_dev_info *dev; + bdaddr_t tmp; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + bt_free(local_addr); + return; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto done; + } + + /* Out of range verification */ + if (adapter->pdiscov_active && !adapter->discov_active) { + send_out_of_range(path, adapter->oor_devices); + + slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); + slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + + l = adapter->found_devices; + while (l) { + dev = l->data; + baswap(&tmp, &dev->bdaddr); + adapter->oor_devices = slist_append(adapter->oor_devices, + batostr(&tmp)); + l = l->next; + } + } + + adapter->pinq_idle = 1; + + /* + * Enable resolution again: standard inquiry can be + * received in the periodic inquiry idle state. + */ + if (adapter->pdiscov_requestor && adapter->pdiscov_resolve_names) + adapter->discov_type |= RESOLVE_NAME; + + /* + * The following scenarios can happen: + * 1. standard inquiry: always send discovery completed signal + * 2. standard inquiry + name resolving: send discovery completed + * after name resolving + * 3. periodic inquiry: skip discovery completed signal + * 4. periodic inquiry + standard inquiry: always send discovery + * completed signal + * + * Keep in mind that non D-Bus requests can arrive. + */ + + if (!found_device_req_name(adapter)) + goto done; /* skip - there is name to resolve */ + + if (adapter->discov_active) { + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "DiscoveryCompleted"); + send_message_and_unref(connection, message); + + adapter->discov_active = 0; + } + + /* free discovered devices list */ + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + if (adapter->discov_requestor) { + name_listener_remove(connection, adapter->discov_requestor, + (name_cb_t) discover_devices_req_exit, adapter); + free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + + /* If there is a pending reply for discovery cancel */ + if (adapter->discovery_cancel) { + message = dbus_message_new_method_return(adapter->discovery_cancel); + send_message_and_unref(connection, message); + dbus_message_unref(adapter->discovery_cancel); + adapter->discovery_cancel = NULL; + } + + /* reset the discover type for standard inquiry only */ + adapter->discov_type &= ~STD_INQUIRY; + } + +done: + /* Proceed with any queued up audits */ + process_audits_list(path); + + bt_free(local_addr); +} + +void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status) +{ + struct adapter *adapter; + DBusMessage *message; + char path[MAX_PATH_LENGTH]; + char *local_addr; + bdaddr_t tmp; + int id; + + /* Don't send the signal if the cmd failed */ + if (status) + return; + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + adapter->pdiscov_active = 1; + + /* Disable name resolution for non D-Bus clients */ + if (!adapter->pdiscov_requestor) + adapter->discov_type &= ~RESOLVE_NAME; + } + + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "PeriodicDiscoveryStarted"); + send_message_and_unref(connection, message); + +failed: + bt_free(local_addr); +} + +void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status) +{ + DBusMessage *message; + struct adapter *adapter; + char path[MAX_PATH_LENGTH]; + char *local_addr; + bdaddr_t tmp; + int id; + + /* Don't send the signal if the cmd failed */ + if (status) + return; + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto done; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto done; + } + + /* reset the discover type to be able to handle D-Bus and non D-Bus + * requests */ + adapter->pdiscov_active = 0; + adapter->discov_type &= ~(PERIODIC_INQUIRY | RESOLVE_NAME); + + /* free discovered devices list */ + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + /* free out of range devices list */ + slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); + slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + + if (adapter->pdiscov_requestor) { + name_listener_remove(connection, adapter->pdiscov_requestor, + (name_cb_t) periodic_discover_req_exit, + adapter); + free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + /* workaround: inquiry completed is not sent when exiting from + * periodic inquiry */ + if (adapter->discov_active) { + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "DiscoveryCompleted"); + send_message_and_unref(connection, message); + + adapter->discov_active = 0; + } + + /* Send discovery completed signal if there isn't name to resolve */ + message = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "PeriodicDiscoveryStopped"); + send_message_and_unref(connection, message); +done: + bt_free(local_addr); +} + +static char *extract_eir_name(uint8_t *data, uint8_t *type) +{ + if (!data || !type) + return NULL; + + if (data[0] == 0) + return NULL; + + *type = data[1]; + + switch (*type) { + case 0x08: + case 0x09: + return strndup((char *) (data + 2), data[0] - 1); + } + + return NULL; +} + +void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, + int8_t rssi, uint8_t *data) +{ + char filename[PATH_MAX + 1]; + DBusMessage *signal_device; + DBusMessage *signal_name; + char path[MAX_PATH_LENGTH]; + struct adapter *adapter; + struct slist *l; + struct remote_dev_info match; + char *local_addr, *peer_addr, *name, *tmp_name; + dbus_int16_t tmp_rssi = rssi; + bdaddr_t tmp; + uint8_t name_type = 0x00; + name_status_t name_status; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + baswap(&tmp, peer); peer_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto done; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto done; + } + + write_remote_class(local, peer, class); + + /* + * workaround to identify situation when the daemon started and + * a standard inquiry or periodic inquiry was already running + */ + if (!adapter->discov_active && !adapter->pdiscov_active) + adapter->pdiscov_active = 1; + + /* reset the idle flag when the inquiry complete event arrives */ + if (adapter->pdiscov_active) { + adapter->pinq_idle = 0; + + /* Out of range list update */ + l = slist_find(adapter->oor_devices, peer_addr, + (cmp_func_t) strcmp); + if (l) + adapter->oor_devices = slist_remove(adapter->oor_devices, + l->data); + } + + /* send the device found signal */ + signal_device = dev_signal_factory(adapter->dev_id, "RemoteDeviceFound", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_UINT32, &class, + DBUS_TYPE_INT16, &tmp_rssi, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, signal_device); + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, peer); + match.name_status = NAME_SENT; + /* if found: don't sent the name again */ + l = slist_find(adapter->found_devices, &match, + (cmp_func_t) found_device_cmp); + if (l) + goto done; + + /* the inquiry result can be triggered by NON D-Bus client */ + if (adapter->discov_type & RESOLVE_NAME) + name_status = NAME_REQUIRED; + else + name_status = NAME_NOT_REQUIRED; + + create_name(filename, PATH_MAX, STORAGEDIR, local_addr, "names"); + name = textfile_get(filename, peer_addr); + + tmp_name = extract_eir_name(data, &name_type); + if (tmp_name) { + if (name_type == 0x09) { + write_device_name(local, peer, tmp_name); + name_status = NAME_NOT_REQUIRED; + + if (name) + free(name); + + name = tmp_name; + } else { + if (name) + free(tmp_name); + else + name = tmp_name; + } + } + + if (name) { + signal_name = dev_signal_factory(adapter->dev_id, "RemoteNameUpdated", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + send_message_and_unref(connection, signal_name); + + free(name); + + if (name_type != 0x08) + name_status = NAME_SENT; + } + + /* add in the list to track name sent/pending */ + found_device_add(&adapter->found_devices, peer, rssi, name_status); + +done: + bt_free(local_addr); + bt_free(peer_addr); +} + +void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class) +{ + DBusMessage *message; + char *local_addr, *peer_addr; + bdaddr_t tmp; + uint32_t old_class = 0; + int id; + + read_remote_class(local, peer, &old_class); + + if (old_class == class) + return; + + baswap(&tmp, local); local_addr = batostr(&tmp); + baswap(&tmp, peer); peer_addr = batostr(&tmp); + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + message = dev_signal_factory(id, "RemoteClassUpdated", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_UINT32, &class, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + +failed: + bt_free(local_addr); + bt_free(peer_addr); +} + +void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, + char *name) +{ + struct adapter *adapter; + DBusMessage *message; + char path[MAX_PATH_LENGTH]; + char *local_addr, *peer_addr; + bdaddr_t tmp; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + baswap(&tmp, peer); peer_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto done; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto done; + } + + if (status) + message = dev_signal_factory(adapter->dev_id, + "RemoteNameFailed", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + else + message = dev_signal_factory(adapter->dev_id, + "RemoteNameUpdated", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + + /* remove from remote name request list */ + found_device_remove(&adapter->found_devices, peer); + + /* check if there is more devices to request names */ + if (!found_device_req_name(adapter)) + goto done; /* skip if a new request has been sent */ + + /* free discovered devices list */ + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + /* + * The discovery completed signal must be sent only for discover + * devices request WITH name resolving + */ + if (adapter->discov_requestor) { + name_listener_remove(connection, adapter->discov_requestor, + (name_cb_t) discover_devices_req_exit, adapter); + free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + + /* If there is a pending reply for discovery cancel */ + if (adapter->discovery_cancel) { + message = dbus_message_new_method_return(adapter->discovery_cancel); + send_message_and_unref(connection, message); + dbus_message_unref(adapter->discovery_cancel); + adapter->discovery_cancel = NULL; + } + + /* Disable name resolution for non D-Bus clients */ + if (!adapter->pdiscov_requestor) + adapter->discov_type &= ~RESOLVE_NAME; + } + + if (adapter->discov_active) { + message = dbus_message_new_signal(path, + ADAPTER_INTERFACE, "DiscoveryCompleted"); + send_message_and_unref(connection, message); + + adapter->discov_active = 0; + } + +done: + bt_free(local_addr); + bt_free(peer_addr); +} + +void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, + bdaddr_t *peer) +{ + char path[MAX_PATH_LENGTH]; + DBusMessage *message; + struct adapter *adapter; + char *local_addr, *peer_addr; + bdaddr_t tmp; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + baswap(&tmp, peer); peer_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto done; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto done; + } + + if (status) { + struct slist *l; + + cancel_passkey_agent_requests(adapter->passkey_agents, path, + peer); + release_passkey_agents(adapter, peer); + + l = slist_find(adapter->pin_reqs, peer, pin_req_cmp); + if (l) { + struct pending_pin_req *p = l->data; + adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); + free(p); + } + + if (adapter->bonding) + adapter->bonding->hci_status = status; + } else { + /* Sent the remote device connected signal */ + message = dev_signal_factory(adapter->dev_id, + "RemoteDeviceConnected", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + + /* add in the active connetions list */ + active_conn_append(&adapter->active_conn, peer, handle); + } + +done: + bt_free(local_addr); + bt_free(peer_addr); +} + +void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, + uint16_t handle, uint8_t reason) +{ + char path[MAX_PATH_LENGTH]; + struct adapter *adapter; + struct active_conn_info *dev; + DBusMessage *message; + struct slist *l; + char *local_addr, *peer_addr = NULL; + bdaddr_t tmp; + int id; + + if (status) { + error("Disconnection failed: 0x%02x", status); + return; + } + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto failed; + } + + l = slist_find(adapter->active_conn, &handle, + active_conn_find_by_handle); + + if (!l) + goto failed; + + dev = l->data; + + baswap(&tmp, &dev->bdaddr); peer_addr = batostr(&tmp); + + /* clean pending HCI cmds */ + hci_req_queue_remove(adapter->dev_id, &dev->bdaddr); + + /* Cancel D-Bus/non D-Bus requests */ + cancel_passkey_agent_requests(adapter->passkey_agents, path, + &dev->bdaddr); + release_passkey_agents(adapter, &dev->bdaddr); + + l = slist_find(adapter->pin_reqs, &dev->bdaddr, pin_req_cmp); + if (l) { + struct pending_pin_req *p = l->data; + adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); + free(p); + } + + /* Check if there is a pending CreateBonding request */ + if (adapter->bonding && (bacmp(&adapter->bonding->bdaddr, &dev->bdaddr) == 0)) { + if (adapter->bonding->cancel) { + /* reply authentication canceled */ + error_authentication_canceled(connection, + adapter->bonding->rq); + } else { + message = new_authentication_return(adapter->bonding->rq, + HCI_AUTHENTICATION_FAILURE); + send_message_and_unref(connection, message); + } + + name_listener_remove(connection, + dbus_message_get_sender(adapter->bonding->rq), + (name_cb_t) create_bond_req_exit, + adapter); + if (adapter->bonding->io_id) + g_io_remove_watch(adapter->bonding->io_id); + g_io_channel_close(adapter->bonding->io); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; + } + /* Sent the remote device disconnected signal */ + message = dev_signal_factory(adapter->dev_id, + "RemoteDeviceDisconnected", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + + send_message_and_unref(connection, message); + active_conn_remove(&adapter->active_conn, handle); + +failed: + if (peer_addr) + free(peer_addr); + + free(local_addr); +} + +gboolean discov_timeout_handler(void *data) +{ + struct adapter *adapter = data; + struct hci_request rq; + int dd; + uint8_t hci_mode = adapter->mode; + uint8_t status = 0; + gboolean retval = TRUE; + + hci_mode &= ~SCAN_INQUIRY; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("HCI device open failed: hci%d", adapter->dev_id); + return TRUE; + } + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_HOST_CTL; + rq.ocf = OCF_WRITE_SCAN_ENABLE; + rq.cparam = &hci_mode; + rq.clen = sizeof(hci_mode); + rq.rparam = &status; + rq.rlen = sizeof(status); + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, 1000) < 0) { + error("Sending write scan enable command to hci%d failed: %s (%d)", + adapter->dev_id, strerror(errno), errno); + goto failed; + } + if (status) { + error("Setting scan enable failed with status 0x%02x", status); + goto failed; + } + + adapter->timeout_id = 0; + retval = FALSE; + +failed: + if (dd >= 0) + hci_close_dev(dd); + + return retval; +} + +/***************************************************************** + * + * Section reserved to device HCI callbacks + * + *****************************************************************/ +void hcid_dbus_setname_complete(bdaddr_t *local) +{ + DBusMessage *signal; + char *local_addr; + bdaddr_t tmp; + int id; + int dd = -1; + read_local_name_rp rp; + struct hci_request rq; + const char *pname = (char *) rp.name; + char name[249]; + + baswap(&tmp, local); local_addr = batostr(&tmp); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + dd = hci_open_dev(id); + if (dd < 0) { + error("HCI device open failed: hci%d", id); + memset(&rp, 0, sizeof(rp)); + } else { + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_HOST_CTL; + rq.ocf = OCF_READ_LOCAL_NAME; + rq.rparam = &rp; + rq.rlen = READ_LOCAL_NAME_RP_SIZE; + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, 1000) < 0) { + error("Sending getting name command failed: %s (%d)", + strerror(errno), errno); + rp.name[0] = '\0'; + } + + if (rp.status) { + error("Getting name failed with status 0x%02x", + rp.status); + rp.name[0] = '\0'; + } + } + + strncpy(name, pname, sizeof(name) - 1); + name[248] = '\0'; + pname = name; + + signal = dev_signal_factory(id, "NameChanged", + DBUS_TYPE_STRING, &pname, DBUS_TYPE_INVALID); + send_message_and_unref(connection, signal); + +failed: + if (dd >= 0) + hci_close_dev(dd); + + bt_free(local_addr); +} + +void hcid_dbus_setscan_enable_complete(bdaddr_t *local) +{ + DBusMessage *message; + struct adapter *adapter; + char *local_addr; + char path[MAX_PATH_LENGTH]; + bdaddr_t tmp; + read_scan_enable_rp rp; + struct hci_request rq; + int id; + int dd = -1; + const char *scan_mode; + + baswap(&tmp, local); local_addr = batostr(&tmp); + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + dd = hci_open_dev(id); + if (dd < 0) { + error("HCI device open failed: hci%d", id); + goto failed; + } + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_HOST_CTL; + rq.ocf = OCF_READ_SCAN_ENABLE; + rq.rparam = &rp; + rq.rlen = READ_SCAN_ENABLE_RP_SIZE; + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, 1000) < 0) { + error("Sending read scan enable command failed: %s (%d)", + strerror(errno), errno); + goto failed; + } + + if (rp.status) { + error("Getting scan enable failed with status 0x%02x", + rp.status); + goto failed; + } + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto failed; + } + + /* update the current scan mode value */ + adapter->mode = rp.enable; + + if (adapter->timeout_id) { + g_timeout_remove(adapter->timeout_id); + adapter->timeout_id = 0; + } + + switch (rp.enable) { + case SCAN_DISABLED: + scan_mode = MODE_OFF; + break; + case SCAN_PAGE: + scan_mode = MODE_CONNECTABLE; + break; + case (SCAN_PAGE | SCAN_INQUIRY): + scan_mode = MODE_DISCOVERABLE; + if (adapter->discov_timeout != 0) + adapter->timeout_id = g_timeout_add(adapter->discov_timeout * 1000, + discov_timeout_handler, + adapter); + break; + case SCAN_INQUIRY: + /* Address the scenario when another app changed the scan + * mode */ + if (adapter->discov_timeout != 0) + adapter->timeout_id = g_timeout_add(adapter->discov_timeout * 1000, + discov_timeout_handler, + adapter); + /* ignore, this event should not be sent*/ + default: + /* ignore, reserved */ + goto failed; + } + + write_device_mode(local, scan_mode); + + message = dev_signal_factory(adapter->dev_id, "ModeChanged", + DBUS_TYPE_STRING, &scan_mode, + DBUS_TYPE_INVALID); + send_message_and_unref(connection, message); + +failed: + if (dd >= 0) + hci_close_dev(dd); + + bt_free(local_addr); +} + +void hcid_dbus_pin_code_reply(bdaddr_t *local, void *ptr) +{ + + typedef struct { + uint8_t status; + bdaddr_t bdaddr; + } __attribute__ ((packed)) ret_pin_code_req_reply; + + struct adapter *adapter; + char *local_addr; + ret_pin_code_req_reply *ret = ptr + EVT_CMD_COMPLETE_SIZE; + struct slist *l; + char path[MAX_PATH_LENGTH]; + bdaddr_t tmp; + int id; + + baswap(&tmp, local); local_addr = batostr(&tmp); + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + goto failed; + } + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &adapter)) { + error("Getting %s path data failed!", path); + goto failed; + } + + l = slist_find(adapter->pin_reqs, &ret->bdaddr, pin_req_cmp); + if (l) { + struct pending_pin_info *p = l->data; + p->replied = 1; + } + +failed: + bt_free(local_addr); +} + +void create_bond_req_exit(const char *name, struct adapter *adapter) +{ + char path[MAX_PATH_LENGTH]; + struct slist *l; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, adapter->dev_id); + + debug("CreateConnection requestor (%s) exited before bonding was completed", + name); + + cancel_passkey_agent_requests(adapter->passkey_agents, path, + &adapter->bonding->bdaddr); + release_passkey_agents(adapter, &adapter->bonding->bdaddr); + + l = slist_find(adapter->pin_reqs, &adapter->bonding->bdaddr, + pin_req_cmp); + if (l) { + struct pending_pin_info *p = l->data; + + if (!p->replied) { + int dd; + + dd = hci_open_dev(adapter->dev_id); + if (dd >= 0) { + hci_send_cmd(dd, OGF_LINK_CTL, + OCF_PIN_CODE_NEG_REPLY, + 6, &adapter->bonding->bdaddr); + hci_close_dev(dd); + } + } + + adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); + free(p); + } + + g_io_channel_close(adapter->bonding->io); + if (adapter->bonding->io_id) + g_io_remove_watch(adapter->bonding->io_id); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; +} + +void discover_devices_req_exit(const char *name, struct adapter *adapter) +{ + debug("DiscoverDevices requestor (%s) exited", name); + + /* + * Cleanup the discovered devices list and send the command to + * cancel inquiry or cancel remote name request. The return + * can be ignored. + */ + cancel_discovery(adapter); +} + +static int inquiry_cancel(int dd, int to) +{ + struct hci_request rq; + uint8_t status; + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_LINK_CTL; + rq.ocf = OCF_INQUIRY_CANCEL; + rq.rparam = &status; + rq.rlen = sizeof(status); + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, to) < 0) + return -1; + + if (status) { + errno = bt_error(status); + return -1; + } + + return 0; +} + +static int remote_name_cancel(int dd, bdaddr_t *dba, int to) +{ + remote_name_req_cancel_cp cp; + struct hci_request rq; + uint8_t status; + + memset(&rq, 0, sizeof(rq)); + memset(&cp, 0, sizeof(cp)); + + bacpy(&cp.bdaddr, dba); + + rq.ogf = OGF_LINK_CTL; + rq.ocf = OCF_REMOTE_NAME_REQ_CANCEL; + rq.cparam = &cp; + rq.clen = REMOTE_NAME_REQ_CANCEL_CP_SIZE; + rq.rparam = &status; + rq.rlen = sizeof(status); + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, to) < 0) + return -1; + + if (status) { + errno = bt_error(status); + return -1; + } + + return 0; +} + +int cancel_discovery(struct adapter *adapter) +{ + struct remote_dev_info *dev, match; + struct slist *l; + int dd, err = 0; + + if (!adapter->discov_active) + goto cleanup; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + err = -ENODEV; + goto cleanup; + } + + /* + * If there is a pending read remote name request means + * that the inquiry complete event was already received + */ + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, BDADDR_ANY); + match.name_status = NAME_REQUESTED; + + l = slist_find(adapter->found_devices, &match, + (cmp_func_t) found_device_cmp); + if (l) { + dev = l->data; + if (remote_name_cancel(dd, &dev->bdaddr, 1000) < 0) { + error("Read remote name cancel failed: %s, (%d)", + strerror(errno), errno); + err = -errno; + } + } else { + if (inquiry_cancel(dd, 1000) < 0) { + error("Inquiry cancel failed:%s (%d)", + strerror(errno), errno); + err = -errno; + } + } + + hci_close_dev(dd); + +cleanup: + /* + * Reset discov_requestor and discover_state in the remote name + * request event handler or in the inquiry complete handler. + */ + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + /* Disable name resolution for non D-Bus clients */ + if (!adapter->pdiscov_requestor) + adapter->discov_type &= ~RESOLVE_NAME; + + return err; +} + +void periodic_discover_req_exit(const char *name, struct adapter *adapter) +{ + debug("PeriodicDiscovery requestor (%s) exited", name); + + /* + * Cleanup the discovered devices list and send the cmd to exit from + * periodic inquiry or cancel remote name request. The return value can + * be ignored. + */ + + cancel_periodic_discovery(adapter); +} + +static int periodic_inquiry_exit(int dd, int to) +{ + struct hci_request rq; + uint8_t status; + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_LINK_CTL; + rq.ocf = OCF_EXIT_PERIODIC_INQUIRY; + rq.rparam = &status; + rq.rlen = sizeof(status); + rq.event = EVT_CMD_COMPLETE; + + if (hci_send_req(dd, &rq, to) < 0) + return -1; + + if (status) { + errno = status; + return -1; + } + + return 0; +} + +int cancel_periodic_discovery(struct adapter *adapter) +{ + struct remote_dev_info *dev, match; + struct slist *l; + int dd, err = 0; + + if (!adapter->pdiscov_active) + goto cleanup; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + err = -ENODEV; + goto cleanup; + } + /* find the pending remote name request */ + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, BDADDR_ANY); + match.name_status = NAME_REQUESTED; + + l = slist_find(adapter->found_devices, &match, + (cmp_func_t) found_device_cmp); + if (l) { + dev = l->data; + if (remote_name_cancel(dd, &dev->bdaddr, 1000) < 0) { + error("Read remote name cancel failed: %s, (%d)", + strerror(errno), errno); + err = -errno; + } + } + + /* ovewrite err if necessary: stop periodic inquiry has higher + * priority */ + if (periodic_inquiry_exit(dd, 1000) < 0) { + error("Periodic Inquiry exit failed:%s (%d)", + strerror(errno), errno); + err = -errno; + } + + hci_close_dev(dd); + +cleanup: + /* + * Reset pdiscov_requestor and pdiscov_active is done when the + * cmd complete event for exit periodic inquiry mode cmd arrives. + */ + slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); + slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + return err; +} + +/* Most of the functions in this module require easy access to a connection so + * we keep it global here and provide these access functions the other (few) + * modules that require access to it */ + +void set_dbus_connection(DBusConnection *conn) +{ + connection = conn; +} + +DBusConnection *get_dbus_connection(void) +{ + return connection; +} diff --git a/hcid/dbus-hci.h b/hcid/dbus-hci.h new file mode 100644 index 00000000..56572b35 --- /dev/null +++ b/hcid/dbus-hci.h @@ -0,0 +1,83 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2006 Marcel Holtmann + * + * + * 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 + * + */ + +#ifndef __H_BLUEZ_DBUS_HCI_H__ +#define __H_BLUEZ_DBUS_HCI_H__ + +#include +#include "dbus-adapter.h" + +void hcid_dbus_set_experimental(); +int hcid_dbus_use_experimental(); +int hcid_dbus_register_device(uint16_t id); +int hcid_dbus_unregister_device(uint16_t id); +int hcid_dbus_start_device(uint16_t id); +int hcid_dbus_stop_device(uint16_t id); +void hcid_dbus_pending_pin_req_add(bdaddr_t *sba, bdaddr_t *dba); +int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci); +int hcid_dbus_confirm_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci, char *pin); + +void hcid_dbus_inquiry_start(bdaddr_t *local); +void hcid_dbus_inquiry_complete(bdaddr_t *local); +void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status); +void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status); +void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi, uint8_t *data); +void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class); +void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, char *name); +void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, bdaddr_t *peer); +void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, uint8_t reason); +void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, uint8_t status); +void hcid_dbus_setname_complete(bdaddr_t *local); +void hcid_dbus_setscan_enable_complete(bdaddr_t *local); +void hcid_dbus_pin_code_reply(bdaddr_t *local, void *ptr); + +int unregister_adapter_path(const char *path); + +DBusMessage *dev_signal_factory(int devid, const char *prop_name, int first, ...); + +DBusMessage *new_authentication_return(DBusMessage *msg, uint8_t status); + +int get_default_dev_id(void); + +void create_bond_req_exit(const char *name, struct adapter *adapter); +void discover_devices_req_exit(const char *name, struct adapter *adapter); +int cancel_discovery(struct adapter *adapter); +void periodic_discover_req_exit(const char *name, struct adapter *adapter); +int cancel_periodic_discovery(struct adapter *adapter); + +int active_conn_find_by_bdaddr(const void *data, const void *user_data); +void bonding_request_free(struct bonding_request_info *dev); +int pin_req_cmp(const void *p1, const void *p2); +int found_device_cmp(const struct remote_dev_info *d1, + const struct remote_dev_info *d2); +int found_device_add(struct slist **list, bdaddr_t *bdaddr, int8_t rssi, + name_status_t name_status); +int found_device_req_name(struct adapter *dbus_data); + +int discov_timeout_handler(void *data); + +void set_dbus_connection(DBusConnection *conn); + +DBusConnection *get_dbus_connection(void); + +#endif /* __H_BLUEZ_DBUS_HCI_H__ */ diff --git a/hcid/dbus-manager.c b/hcid/dbus-manager.c index 0def0476..4833e05f 100644 --- a/hcid/dbus-manager.c +++ b/hcid/dbus-manager.c @@ -46,6 +46,8 @@ #include "dbus-service.h" #include "dbus-manager.h" +static int default_adapter_id = -1; + static DBusHandlerResult interface_version(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -70,19 +72,18 @@ static DBusHandlerResult default_adapter(DBusConnection *conn, { DBusMessage *reply; char path[MAX_PATH_LENGTH], *path_ptr = path; - int default_dev = get_default_dev_id(); if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING)) return error_invalid_arguments(conn, msg); - if (default_dev < 0) + if (default_adapter_id < 0) return error_no_such_adapter(conn, msg); reply = dbus_message_new_method_return(msg); if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, default_dev); + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, default_adapter_id); dbus_message_append_args(reply, DBUS_TYPE_STRING, &path_ptr, DBUS_TYPE_INVALID); @@ -350,3 +351,13 @@ DBusHandlerResult handle_manager_method(DBusConnection *conn, return error_unknown_method(conn, msg); } + +int get_default_adapter(void) +{ + return default_adapter_id; +} + +void set_default_adapter(int new_default) +{ + default_adapter_id = new_default; +} diff --git a/hcid/dbus-manager.h b/hcid/dbus-manager.h index 17b34052..f95af777 100644 --- a/hcid/dbus-manager.h +++ b/hcid/dbus-manager.h @@ -28,4 +28,8 @@ DBusHandlerResult handle_manager_method(DBusConnection *conn, DBusMessage *msg, void *data); +int get_default_adapter(void); + +void set_default_adapter(int new_default); + #endif /* __MANAGER_H */ diff --git a/hcid/dbus-rfcomm.c b/hcid/dbus-rfcomm.c index 0217ef96..479763fa 100644 --- a/hcid/dbus-rfcomm.c +++ b/hcid/dbus-rfcomm.c @@ -48,6 +48,8 @@ #include "glib-ectomy.h" #include "dbus.h" #include "dbus-common.h" +#include "dbus-hci.h" +#include "dbus-adapter.h" #include "dbus-error.h" #include "dbus-sdp.h" #include "dbus-rfcomm.h" diff --git a/hcid/dbus-sdp.c b/hcid/dbus-sdp.c index 1d3d9f1d..f4f462f6 100644 --- a/hcid/dbus-sdp.c +++ b/hcid/dbus-sdp.c @@ -46,10 +46,13 @@ #include +#include "list.h" #include "dbus.h" #include "hcid.h" #include "textfile.h" +#include "dbus-hci.h" #include "dbus-common.h" +#include "dbus-adapter.h" #include "dbus-error.h" #include "dbus-sdp.h" diff --git a/hcid/dbus-security.c b/hcid/dbus-security.c index ae93aadf..4d39e2f6 100644 --- a/hcid/dbus-security.c +++ b/hcid/dbus-security.c @@ -39,6 +39,7 @@ #include "dbus.h" #include "hcid.h" #include "dbus-common.h" +#include "dbus-adapter.h" #include "dbus-service.h" #include "dbus-error.h" #include "dbus-security.h" diff --git a/hcid/dbus-test.c b/hcid/dbus-test.c index 2153aed7..4dea5780 100644 --- a/hcid/dbus-test.c +++ b/hcid/dbus-test.c @@ -33,9 +33,12 @@ #include #include +#include "list.h" #include "hcid.h" #include "dbus.h" #include "dbus-common.h" +#include "dbus-hci.h" +#include "dbus-adapter.h" #include "dbus-error.h" #include "dbus-test.h" diff --git a/hcid/dbus.c b/hcid/dbus.c deleted file mode 100644 index f2d55548..00000000 --- a/hcid/dbus.c +++ /dev/null @@ -1,2591 +0,0 @@ -/* - * - * BlueZ - Bluetooth protocol stack for Linux - * - * Copyright (C) 2004-2006 Marcel Holtmann - * - * - * 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 -#endif - -#define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include - -#include "glib-ectomy.h" - -#include "hcid.h" -#include "dbus.h" -#include "textfile.h" -#include "list.h" -#include "dbus-common.h" -#include "dbus-error.h" -#include "dbus-test.h" -#include "dbus-security.h" -#include "dbus-service.h" -#include "dbus-manager.h" -#include "dbus-adapter.h" - -#define BLUEZ_NAME "org.bluez" - -static DBusConnection *connection; - -static int default_dev = -1; - -static int experimental = 0; - -#define MAX_CONN_NUMBER 10 -#define RECONNECT_RETRY_TIMEOUT 5000 -#define DISPATCH_TIMEOUT 0 - -typedef struct { - uint32_t id; - DBusTimeout *timeout; -} timeout_handler_t; - -struct watch_info { - guint watch_id; - GIOChannel *io; -}; - -void hcid_dbus_set_experimental(void) -{ - experimental = 1; -} - -int hcid_dbus_use_experimental(void) -{ - return experimental; -} - -void bonding_request_free(struct bonding_request_info *bonding) -{ - if (!bonding) - return; - - if (bonding->rq) - dbus_message_unref(bonding->rq); - - if (bonding->conn) - dbus_connection_unref(bonding->conn); - - if (bonding->io) - g_io_channel_unref(bonding->io); - - free(bonding); -} - -int found_device_cmp(const struct remote_dev_info *d1, - const struct remote_dev_info *d2) -{ - int ret; - - if (bacmp(&d2->bdaddr, BDADDR_ANY)) { - ret = bacmp(&d1->bdaddr, &d2->bdaddr); - if (ret) - return ret; - } - - if (d2->name_status != NAME_ANY) { - ret = (d1->name_status - d2->name_status); - if (ret) - return ret; - } - - return 0; -} - -int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2) -{ - int rssi1, rssi2; - - rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi; - rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi; - - return rssi1 - rssi2; -} - -int found_device_add(struct slist **list, bdaddr_t *bdaddr, int8_t rssi, - name_status_t name_status) -{ - struct remote_dev_info *dev, match; - struct slist *l; - - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, bdaddr); - match.name_status = NAME_ANY; - - /* ignore repeated entries */ - l = slist_find(*list, &match, (cmp_func_t) found_device_cmp); - if (l) { - /* device found, update the attributes */ - dev = l->data; - - dev->rssi = rssi; - - /* Get remote name can be received while inquiring. - * Keep in mind that multiple inquiry result events can - * be received from the same remote device. - */ - if (name_status != NAME_NOT_REQUIRED) - dev->name_status = name_status; - - *list = slist_sort(*list, (cmp_func_t) dev_rssi_cmp); - - return -EALREADY; - } - - dev = malloc(sizeof(*dev)); - if (!dev) - return -ENOMEM; - - memset(dev, 0, sizeof(*dev)); - bacpy(&dev->bdaddr, bdaddr); - dev->rssi = rssi; - dev->name_status = name_status; - - *list = slist_insert_sorted(*list, dev, (cmp_func_t) dev_rssi_cmp); - - return 0; -} - -static int found_device_remove(struct slist **list, bdaddr_t *bdaddr) -{ - struct remote_dev_info *dev, match; - struct slist *l; - - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, bdaddr); - - l = slist_find(*list, &match, (cmp_func_t) found_device_cmp); - if (!l) - return -1; - - dev = l->data; - *list = slist_remove(*list, dev); - free(dev); - - return 0; -} - -int active_conn_find_by_bdaddr(const void *data, const void *user_data) -{ - const struct active_conn_info *con = data; - const bdaddr_t *bdaddr = user_data; - - return bacmp(&con->bdaddr, bdaddr); -} - -static int active_conn_find_by_handle(const void *data, const void *user_data) -{ - const struct active_conn_info *dev = data; - const uint16_t *handle = user_data; - - if (dev->handle == *handle) - return 0; - - return -1; -} - -static int active_conn_append(struct slist **list, bdaddr_t *bdaddr, - uint16_t handle) -{ - struct active_conn_info *dev; - - dev = malloc(sizeof(*dev)); - if (!dev) - return -1; - - memset(dev, 0 , sizeof(*dev)); - bacpy(&dev->bdaddr, bdaddr); - dev->handle = handle; - - *list = slist_append(*list, dev); - return 0; -} - -static int active_conn_remove(struct slist **list, uint16_t *handle) -{ - struct active_conn_info *dev; - struct slist *l; - int ret_val = -1; - - l = slist_find(*list, handle, active_conn_find_by_handle); - - if (l) { - dev = l->data; - *list = slist_remove(*list, dev); - free(dev); - ret_val = 0; - } - - return ret_val; -} - -DBusMessage *new_authentication_return(DBusMessage *msg, uint8_t status) -{ - switch (status) { - case 0x00: /* success */ - return dbus_message_new_method_return(msg); - - case 0x04: /* page timeout */ - case 0x08: /* connection timeout */ - case 0x10: /* connection accept timeout */ - case 0x22: /* LMP response timeout */ - case 0x28: /* instant passed - is this a timeout? */ - return dbus_message_new_error(msg, - ERROR_INTERFACE ".AuthenticationTimeout", - "Authentication Timeout"); - case 0x17: /* too frequent pairing attempts */ - return dbus_message_new_error(msg, - ERROR_INTERFACE ".RepeatedAttemps", - "Repeated Attempts"); - - case 0x06: - case 0x18: /* pairing not allowed (e.g. gw rejected attempt) */ - return dbus_message_new_error(msg, - ERROR_INTERFACE ".AuthenticationRejected", - "Authentication Rejected"); - - case 0x07: /* memory capacity */ - case 0x09: /* connection limit */ - case 0x0a: /* synchronous connection limit */ - case 0x0d: /* limited resources */ - case 0x14: /* terminated due to low resources */ - return dbus_message_new_error(msg, - ERROR_INTERFACE ".AuthenticationCanceled", - "Authentication Canceled"); - - case 0x05: /* authentication failure */ - case 0x0E: /* rejected due to security reasons - is this auth failure? */ - case 0x25: /* encryption mode not acceptable - is this auth failure? */ - case 0x26: /* link key cannot be changed - is this auth failure? */ - case 0x29: /* pairing with unit key unsupported - is this auth failure? */ - case 0x2f: /* insufficient security - is this auth failure? */ - default: - return dbus_message_new_error(msg, - ERROR_INTERFACE ".AuthenticationFailed", - "Authentication Failed"); - } -} - -int get_default_dev_id(void) -{ - return default_dev; -} - -static inline int dev_append_signal_args(DBusMessage *signal, int first, - va_list var_args) -{ - void *value; - DBusMessageIter iter; - int type = first; - - dbus_message_iter_init_append(signal, &iter); - - while (type != DBUS_TYPE_INVALID) { - value = va_arg(var_args, void *); - - if (!dbus_message_iter_append_basic(&iter, type, value)) { - error("Append property argument error (type %d)", type); - return -1; - } - - type = va_arg(var_args, int); - } - - return 0; -} - -DBusMessage *dev_signal_factory(int devid, const char *prop_name, int first, - ...) -{ - va_list var_args; - DBusMessage *signal; - char path[MAX_PATH_LENGTH]; - - snprintf(path, sizeof(path)-1, "%s/hci%d", BASE_PATH, devid); - - signal = dbus_message_new_signal(path, ADAPTER_INTERFACE, prop_name); - if (!signal) { - error("Can't allocate D-BUS message"); - return NULL; - } - - va_start(var_args, first); - - if (dev_append_signal_args(signal, first, var_args) < 0) { - dbus_message_unref(signal); - signal = NULL; - } - - va_end(var_args); - - return signal; -} - -/* - * Virtual table that handle the object path hierarchy - */ - -static const DBusObjectPathVTable adapter_vtable = { - .message_function = &handle_method_call, - .unregister_function = NULL -}; - -static const DBusObjectPathVTable manager_vtable = { - .message_function = &handle_manager_method, - .unregister_function = NULL -}; - -/* - * HCI D-Bus services - */ -static DBusHandlerResult hci_dbus_signal_filter(DBusConnection *conn, - DBusMessage *msg, void *data); - -static void reply_pending_requests(const char *path, struct adapter *adapter) -{ - DBusMessage *message; - - if (!path || !adapter) - return; - - /* pending bonding */ - if (adapter->bonding) { - error_authentication_canceled(connection, adapter->bonding->rq); - name_listener_remove(connection, - dbus_message_get_sender(adapter->bonding->rq), - (name_cb_t) create_bond_req_exit, - adapter); - if (adapter->bonding->io_id) - g_io_remove_watch(adapter->bonding->io_id); - g_io_channel_close(adapter->bonding->io); - bonding_request_free(adapter->bonding); - adapter->bonding = NULL; - } - - /* If there is a pending reply for discovery cancel */ - if (adapter->discovery_cancel) { - message = dbus_message_new_method_return(adapter->discovery_cancel); - send_message_and_unref(connection, message); - dbus_message_unref(adapter->discovery_cancel); - adapter->discovery_cancel = NULL; - } - - if (adapter->discov_active) { - /* Send discovery completed signal if there isn't name - * to resolve */ - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "DiscoveryCompleted"); - send_message_and_unref(connection, message); - - /* Cancel inquiry initiated by D-Bus client */ - if (adapter->discov_requestor) - cancel_discovery(adapter); - } - - if (adapter->pdiscov_active) { - /* Send periodic discovery stopped signal exit or stop - * the device */ - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "PeriodicDiscoveryStopped"); - send_message_and_unref(connection, message); - - /* Stop periodic inquiry initiated by D-Bus client */ - if (adapter->pdiscov_requestor) - cancel_periodic_discovery(adapter); - } -} - -static int unregister_dbus_path(const char *path) -{ - struct adapter *adapter = NULL; - - info("Unregister path: %s", path); - - dbus_connection_get_object_path_data(connection, path, - (void *) &adapter); - - if (!adapter) - goto unreg; - - /* check pending requests */ - reply_pending_requests(path, adapter); - - cancel_passkey_agent_requests(adapter->passkey_agents, path, NULL); - - release_passkey_agents(adapter, NULL); - - if (adapter->discov_requestor) { - name_listener_remove(connection, - adapter->discov_requestor, - (name_cb_t) discover_devices_req_exit, adapter); - free(adapter->discov_requestor); - adapter->discov_requestor = NULL; - } - - if (adapter->pdiscov_requestor) { - name_listener_remove(connection, - adapter->pdiscov_requestor, - (name_cb_t) periodic_discover_req_exit, - adapter); - free(adapter->pdiscov_requestor); - adapter->pdiscov_requestor = NULL; - } - - if (adapter->found_devices) { - slist_foreach(adapter->found_devices, - (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - } - - if (adapter->oor_devices) { - slist_foreach(adapter->oor_devices, - (slist_func_t) free, NULL); - slist_free(adapter->oor_devices); - adapter->oor_devices = NULL; - } - - if (adapter->pin_reqs) { - slist_foreach(adapter->pin_reqs, - (slist_func_t) free, NULL); - slist_free(adapter->pin_reqs); - adapter->pin_reqs = NULL; - } - - if (adapter->active_conn) { - slist_foreach(adapter->active_conn, - (slist_func_t) free, NULL); - slist_free(adapter->active_conn); - adapter->active_conn = NULL; - } - - free (adapter); - -unreg: - if (!dbus_connection_unregister_object_path (connection, path)) { - error("D-Bus failed to unregister %s object", path); - return -1; - } - - return 0; -} - -/***************************************************************** - * - * Section reserved to HCI commands confirmation handling and low - * level events(eg: device attached/dettached. - * - *****************************************************************/ - -int hcid_dbus_register_device(uint16_t id) -{ - char path[MAX_PATH_LENGTH]; - char *pptr = path; - DBusMessage *message; - struct adapter *adapter; - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - adapter = malloc(sizeof(struct adapter)); - if (!adapter) { - error("Failed to alloc memory to D-Bus path register data (%s)", - path); - return -1; - } - - memset(adapter, 0, sizeof(struct adapter)); - - adapter->dev_id = id; - adapter->pdiscov_resolve_names = 1; - - if (!dbus_connection_register_object_path(connection, path, - &adapter_vtable, adapter)) { - error("D-Bus failed to register %s object", path); - free(adapter); - return -1; - } - - /* - * Send the adapter added signal - */ - message = dbus_message_new_signal(BASE_PATH, MANAGER_INTERFACE, - "AdapterAdded"); - if (message == NULL) { - error("Can't allocate D-Bus message"); - dbus_connection_unregister_object_path(connection, path); - return -1; - } - - dbus_message_append_args(message, - DBUS_TYPE_STRING, &pptr, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - - return 0; -} - -int hcid_dbus_unregister_device(uint16_t id) -{ - DBusMessage *message; - char path[MAX_PATH_LENGTH]; - char *pptr = path; - int ret; - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - message = dbus_message_new_signal(BASE_PATH, MANAGER_INTERFACE, - "AdapterRemoved"); - if (message == NULL) { - error("Can't allocate D-Bus message"); - goto failed; - } - - dbus_message_append_args(message, - DBUS_TYPE_STRING, &pptr, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - -failed: - ret = unregister_dbus_path(path); - - if (ret == 0 && default_dev == id) { - default_dev = hci_get_route(NULL); - if (default_dev >= 0) { - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, - default_dev); - message = dbus_message_new_signal(BASE_PATH, - MANAGER_INTERFACE, - "DefaultAdapterChanged"); - if (!message) { - error("Can't allocate D-Bus message"); - /* Return success since actual unregistering - * succeeded */ - return ret; - } - - dbus_message_append_args(message, - DBUS_TYPE_STRING, &pptr, - DBUS_TYPE_INVALID); - send_message_and_unref(connection, message); - } - } - - return ret; -} - -int hcid_dbus_start_device(uint16_t id) -{ - char path[MAX_PATH_LENGTH]; - int i, err, dd = -1, ret = -1; - read_scan_enable_rp rp; - struct hci_dev_info di; - struct hci_request rq; - struct adapter* adapter; - struct hci_conn_list_req *cl = NULL; - struct hci_conn_info *ci; - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - /* FIXME: check dupplicated code - configure_device() */ - if (hci_devinfo(id, &di) < 0) { - error("Getting device info failed: hci%d", id); - return -1; - } - - if (hci_test_bit(HCI_RAW, &di.flags)) - return -1; - - dd = hci_open_dev(id); - if (dd < 0) { - error("HCI device open failed: hci%d", id); - rp.enable = SCAN_PAGE | SCAN_INQUIRY; - } else { - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_HOST_CTL; - rq.ocf = OCF_READ_SCAN_ENABLE; - rq.rparam = &rp; - rq.rlen = READ_SCAN_ENABLE_RP_SIZE; - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, 1000) < 0) { - error("Sending read scan enable command failed: %s (%d)", - strerror(errno), errno); - rp.enable = SCAN_PAGE | SCAN_INQUIRY; - } else if (rp.status) { - error("Getting scan enable failed with status 0x%02x", - rp.status); - rp.enable = SCAN_PAGE | SCAN_INQUIRY; - } - } - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto failed; - } - - if (hci_test_bit(HCI_INQUIRY, &di.flags)) - adapter->discov_active = 1; - else - adapter->discov_active = 0; - - adapter->mode = rp.enable; /* Keep the current scan status */ - adapter->up = 1; - adapter->discov_timeout = get_discoverable_timeout(id); - adapter->discov_type = DISCOVER_TYPE_NONE; - - /* - * Get the adapter Bluetooth address - */ - err = get_device_address(adapter->dev_id, adapter->address, - sizeof(adapter->address)); - if (err < 0) - goto failed; - - /* - * retrieve the active connections: address the scenario where - * the are active connections before the daemon've started - */ - - cl = malloc(10 * sizeof(*ci) + sizeof(*cl)); - if (!cl) - goto failed; - - cl->dev_id = id; - cl->conn_num = 10; - ci = cl->conn_info; - - if (ioctl(dd, HCIGETCONNLIST, (void *) cl) < 0) { - free(cl); - cl = NULL; - goto failed; - } - - for (i = 0; i < cl->conn_num; i++, ci++) - active_conn_append(&adapter->active_conn, - &ci->bdaddr, ci->handle); - - ret = 0; - -failed: - if (ret == 0 && default_dev < 0) - default_dev = id; - - if (dd >= 0) - hci_close_dev(dd); - - if (cl) - free(cl); - - return ret; -} - -int hcid_dbus_stop_device(uint16_t id) -{ - char path[MAX_PATH_LENGTH]; - struct adapter *adapter; - const char *scan_mode = MODE_OFF; - DBusMessage *message; - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - return -1; - } - /* cancel pending timeout */ - if (adapter->timeout_id) { - g_timeout_remove(adapter->timeout_id); - adapter->timeout_id = 0; - } - - /* check pending requests */ - reply_pending_requests(path, adapter); - - message = dev_signal_factory(adapter->dev_id, "ModeChanged", - DBUS_TYPE_STRING, &scan_mode, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - - - cancel_passkey_agent_requests(adapter->passkey_agents, path, NULL); - - release_passkey_agents(adapter, NULL); - - if (adapter->discov_requestor) { - name_listener_remove(connection, adapter->discov_requestor, - (name_cb_t) discover_devices_req_exit, - adapter); - free(adapter->discov_requestor); - adapter->discov_requestor = NULL; - } - - if (adapter->pdiscov_requestor) { - name_listener_remove(connection, adapter->pdiscov_requestor, - (name_cb_t) periodic_discover_req_exit, - adapter); - free(adapter->pdiscov_requestor); - adapter->pdiscov_requestor = NULL; - } - - if (adapter->found_devices) { - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - } - - if (adapter->oor_devices) { - slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); - slist_free(adapter->oor_devices); - adapter->oor_devices = NULL; - } - - if (adapter->pin_reqs) { - slist_foreach(adapter->pin_reqs, (slist_func_t) free, NULL); - slist_free(adapter->pin_reqs); - adapter->pin_reqs = NULL; - } - - if (adapter->active_conn) { - slist_foreach(adapter->active_conn, (slist_func_t) free, NULL); - slist_free(adapter->active_conn); - adapter->active_conn = NULL; - } - - adapter->up = 0; - adapter->mode = SCAN_DISABLED; - adapter->discov_active = 0; - adapter->pdiscov_active = 0; - adapter->pinq_idle = 0; - adapter->discov_type = DISCOVER_TYPE_NONE; - - return 0; -} - -int pin_req_cmp(const void *p1, const void *p2) -{ - const struct pending_pin_info *pb1 = p1; - const struct pending_pin_info *pb2 = p2; - - return p2 ? bacmp(&pb1->bdaddr, &pb2->bdaddr) : -1; -} - -void hcid_dbus_pending_pin_req_add(bdaddr_t *sba, bdaddr_t *dba) -{ - char path[MAX_PATH_LENGTH], addr[18]; - struct adapter *adapter; - struct pending_pin_info *info; - int id; - - ba2str(sba, addr); - - id = hci_devid(addr); - if (id < 0) { - error("No matching device id for %s", addr); - return; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - return; - } - - info = malloc(sizeof(struct pending_pin_info)); - if (!info) { - error("Out of memory when adding new pin request"); - return; - } - - memset(info, 0, sizeof(struct pending_pin_info)); - bacpy(&info->bdaddr, dba); - adapter->pin_reqs = slist_append(adapter->pin_reqs, info); - - if (adapter->bonding && !bacmp(dba, &adapter->bonding->bdaddr)) - adapter->bonding->auth_active = 1; -} - -int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci) -{ - char path[MAX_PATH_LENGTH], addr[18]; - int id; - - ba2str(sba, addr); - - id = hci_devid(addr); - if (id < 0) { - error("No matching device id for %s", addr); - return -1; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - return handle_passkey_request(connection, dev, path, sba, &ci->bdaddr); -} - -int hcid_dbus_confirm_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci, char *pin) -{ - char path[MAX_PATH_LENGTH], addr[18]; - int id; - - ba2str(sba, addr); - - id = hci_devid(addr); - if (id < 0) { - error("No matching device id for %s", addr); - return -1; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - return handle_confirm_request(connection, dev, path, sba, &ci->bdaddr, pin); -} - -void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, - uint8_t status) -{ - struct adapter *adapter; - DBusMessage *message; - char *local_addr, *peer_addr; - struct slist *l; - bdaddr_t tmp; - char path[MAX_PATH_LENGTH]; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - baswap(&tmp, peer); peer_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - /* create the authentication reply */ - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto failed; - } - - if (status) - cancel_passkey_agent_requests(adapter->passkey_agents, path, - peer); - - l = slist_find(adapter->pin_reqs, peer, pin_req_cmp); - if (l) { - void *d = l->data; - adapter->pin_reqs = slist_remove(adapter->pin_reqs, l->data); - free(d); - - if (!status) { - message = dev_signal_factory(adapter->dev_id, - "BondingCreated", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - send_message_and_unref(connection, message); - } - } - - release_passkey_agents(adapter, peer); - - if (!adapter->bonding || bacmp(&adapter->bonding->bdaddr, peer)) - goto failed; /* skip: no bonding req pending */ - - if (adapter->bonding->cancel) { - /* reply authentication canceled */ - error_authentication_canceled(connection, adapter->bonding->rq); - } else { - /* reply authentication success or an error */ - message = new_authentication_return(adapter->bonding->rq, - status); - send_message_and_unref(connection, message); - } - - name_listener_remove(connection, - dbus_message_get_sender(adapter->bonding->rq), - (name_cb_t) create_bond_req_exit, adapter); - - if (adapter->bonding->io_id) - g_io_remove_watch(adapter->bonding->io_id); - g_io_channel_close(adapter->bonding->io); - bonding_request_free(adapter->bonding); - adapter->bonding = NULL; - -failed: - bt_free(local_addr); - bt_free(peer_addr); -} - -void hcid_dbus_inquiry_start(bdaddr_t *local) -{ - struct adapter *adapter; - DBusMessage *message; - char path[MAX_PATH_LENGTH]; - char *local_addr; - bdaddr_t tmp; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - adapter->discov_active = 1; - /* - * Cancel pending remote name request and clean the device list - * when inquiry is supported in periodic inquiry idle state. - */ - if (adapter->pdiscov_active) - pending_remote_name_cancel(adapter); - - /* Disable name resolution for non D-Bus clients */ - if (!adapter->discov_requestor) - adapter->discov_type &= ~RESOLVE_NAME; - } - - message = dev_signal_factory(adapter->dev_id, "DiscoveryStarted", - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - -failed: - bt_free(local_addr); -} - -int found_device_req_name(struct adapter *adapter) -{ - struct hci_request rq; - evt_cmd_status rp; - remote_name_req_cp cp; - struct remote_dev_info match; - struct slist *l; - int dd, req_sent = 0; - - /* get the next remote address */ - if (!adapter->found_devices) - return -ENODATA; - - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, BDADDR_ANY); - match.name_status = NAME_REQUIRED; - - l = slist_find(adapter->found_devices, &match, - (cmp_func_t) found_device_cmp); - if (!l) - return -ENODATA; - - dd = hci_open_dev(adapter->dev_id); - if (dd < 0) - return -errno; - - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_LINK_CTL; - rq.ocf = OCF_REMOTE_NAME_REQ; - rq.cparam = &cp; - rq.clen = REMOTE_NAME_REQ_CP_SIZE; - rq.rparam = &rp; - rq.rlen = EVT_CMD_STATUS_SIZE; - rq.event = EVT_CMD_STATUS; - - /* send at least one request or return failed if the list is empty */ - do { - DBusMessage *failed_signal = NULL; - struct remote_dev_info *dev = l->data; - char *peer_addr; - bdaddr_t tmp; - - /* flag to indicate the current remote name requested */ - dev->name_status = NAME_REQUESTED; - - memset(&cp, 0, sizeof(cp)); - bacpy(&cp.bdaddr, &dev->bdaddr); - cp.pscan_rep_mode = 0x02; - - baswap(&tmp, &dev->bdaddr); peer_addr = batostr(&tmp); - - if (hci_send_req(dd, &rq, 500) < 0) { - error("Unable to send the HCI remote name request: %s (%d)", - strerror(errno), errno); - failed_signal = dev_signal_factory(adapter->dev_id, - "RemoteNameFailed", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - } - - if (rp.status) { - error("Remote name request failed with status 0x%02x", - rp.status); - failed_signal = dev_signal_factory(adapter->dev_id, - "RemoteNameFailed", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - } - - free(peer_addr); - - if (!failed_signal) { - req_sent = 1; - break; - } - - send_message_and_unref(connection, failed_signal); - failed_signal = NULL; - - /* if failed, request the next element */ - /* remove the element from the list */ - adapter->found_devices = slist_remove(adapter->found_devices, dev); - free(dev); - - /* get the next element */ - l = slist_find(adapter->found_devices, &match, - (cmp_func_t) found_device_cmp); - - } while (l); - - hci_close_dev(dd); - - if (!req_sent) - return -ENODATA; - - return 0; -} - -static void send_out_of_range(const char *path, struct slist *l) -{ - DBusMessage *message; - const char *peer_addr; - - while (l) { - peer_addr = l->data; - - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "RemoteDeviceDisappeared"); - dbus_message_append_args(message, - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - l = l->next; - } -} - -void hcid_dbus_inquiry_complete(bdaddr_t *local) -{ - DBusMessage *message; - struct adapter *adapter; - struct slist *l; - char path[MAX_PATH_LENGTH]; - char *local_addr; - struct remote_dev_info *dev; - bdaddr_t tmp; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - bt_free(local_addr); - return; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto done; - } - - /* Out of range verification */ - if (adapter->pdiscov_active && !adapter->discov_active) { - send_out_of_range(path, adapter->oor_devices); - - slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); - slist_free(adapter->oor_devices); - adapter->oor_devices = NULL; - - l = adapter->found_devices; - while (l) { - dev = l->data; - baswap(&tmp, &dev->bdaddr); - adapter->oor_devices = slist_append(adapter->oor_devices, - batostr(&tmp)); - l = l->next; - } - } - - adapter->pinq_idle = 1; - - /* - * Enable resolution again: standard inquiry can be - * received in the periodic inquiry idle state. - */ - if (adapter->pdiscov_requestor && adapter->pdiscov_resolve_names) - adapter->discov_type |= RESOLVE_NAME; - - /* - * The following scenarios can happen: - * 1. standard inquiry: always send discovery completed signal - * 2. standard inquiry + name resolving: send discovery completed - * after name resolving - * 3. periodic inquiry: skip discovery completed signal - * 4. periodic inquiry + standard inquiry: always send discovery - * completed signal - * - * Keep in mind that non D-Bus requests can arrive. - */ - - if (!found_device_req_name(adapter)) - goto done; /* skip - there is name to resolve */ - - if (adapter->discov_active) { - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "DiscoveryCompleted"); - send_message_and_unref(connection, message); - - adapter->discov_active = 0; - } - - /* free discovered devices list */ - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - - if (adapter->discov_requestor) { - name_listener_remove(connection, adapter->discov_requestor, - (name_cb_t) discover_devices_req_exit, adapter); - free(adapter->discov_requestor); - adapter->discov_requestor = NULL; - - /* If there is a pending reply for discovery cancel */ - if (adapter->discovery_cancel) { - message = dbus_message_new_method_return(adapter->discovery_cancel); - send_message_and_unref(connection, message); - dbus_message_unref(adapter->discovery_cancel); - adapter->discovery_cancel = NULL; - } - - /* reset the discover type for standard inquiry only */ - adapter->discov_type &= ~STD_INQUIRY; - } - -done: - /* Proceed with any queued up audits */ - process_audits_list(path); - - bt_free(local_addr); -} - -void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status) -{ - struct adapter *adapter; - DBusMessage *message; - char path[MAX_PATH_LENGTH]; - char *local_addr; - bdaddr_t tmp; - int id; - - /* Don't send the signal if the cmd failed */ - if (status) - return; - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - adapter->pdiscov_active = 1; - - /* Disable name resolution for non D-Bus clients */ - if (!adapter->pdiscov_requestor) - adapter->discov_type &= ~RESOLVE_NAME; - } - - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "PeriodicDiscoveryStarted"); - send_message_and_unref(connection, message); - -failed: - bt_free(local_addr); -} - -void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status) -{ - DBusMessage *message; - struct adapter *adapter; - char path[MAX_PATH_LENGTH]; - char *local_addr; - bdaddr_t tmp; - int id; - - /* Don't send the signal if the cmd failed */ - if (status) - return; - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto done; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto done; - } - - /* reset the discover type to be able to handle D-Bus and non D-Bus - * requests */ - adapter->pdiscov_active = 0; - adapter->discov_type &= ~(PERIODIC_INQUIRY | RESOLVE_NAME); - - /* free discovered devices list */ - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - - /* free out of range devices list */ - slist_foreach(adapter->oor_devices, (slist_func_t) free, NULL); - slist_free(adapter->oor_devices); - adapter->oor_devices = NULL; - - if (adapter->pdiscov_requestor) { - name_listener_remove(connection, adapter->pdiscov_requestor, - (name_cb_t) periodic_discover_req_exit, - adapter); - free(adapter->pdiscov_requestor); - adapter->pdiscov_requestor = NULL; - } - - /* workaround: inquiry completed is not sent when exiting from - * periodic inquiry */ - if (adapter->discov_active) { - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "DiscoveryCompleted"); - send_message_and_unref(connection, message); - - adapter->discov_active = 0; - } - - /* Send discovery completed signal if there isn't name to resolve */ - message = dbus_message_new_signal(path, ADAPTER_INTERFACE, - "PeriodicDiscoveryStopped"); - send_message_and_unref(connection, message); -done: - bt_free(local_addr); -} - -static char *extract_eir_name(uint8_t *data, uint8_t *type) -{ - if (!data || !type) - return NULL; - - if (data[0] == 0) - return NULL; - - *type = data[1]; - - switch (*type) { - case 0x08: - case 0x09: - return strndup((char *) (data + 2), data[0] - 1); - } - - return NULL; -} - -void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, - int8_t rssi, uint8_t *data) -{ - char filename[PATH_MAX + 1]; - DBusMessage *signal_device; - DBusMessage *signal_name; - char path[MAX_PATH_LENGTH]; - struct adapter *adapter; - struct slist *l; - struct remote_dev_info match; - char *local_addr, *peer_addr, *name, *tmp_name; - dbus_int16_t tmp_rssi = rssi; - bdaddr_t tmp; - uint8_t name_type = 0x00; - name_status_t name_status; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - baswap(&tmp, peer); peer_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto done; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto done; - } - - write_remote_class(local, peer, class); - - /* - * workaround to identify situation when the daemon started and - * a standard inquiry or periodic inquiry was already running - */ - if (!adapter->discov_active && !adapter->pdiscov_active) - adapter->pdiscov_active = 1; - - /* reset the idle flag when the inquiry complete event arrives */ - if (adapter->pdiscov_active) { - adapter->pinq_idle = 0; - - /* Out of range list update */ - l = slist_find(adapter->oor_devices, peer_addr, - (cmp_func_t) strcmp); - if (l) - adapter->oor_devices = slist_remove(adapter->oor_devices, - l->data); - } - - /* send the device found signal */ - signal_device = dev_signal_factory(adapter->dev_id, "RemoteDeviceFound", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_UINT32, &class, - DBUS_TYPE_INT16, &tmp_rssi, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, signal_device); - - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, peer); - match.name_status = NAME_SENT; - /* if found: don't sent the name again */ - l = slist_find(adapter->found_devices, &match, - (cmp_func_t) found_device_cmp); - if (l) - goto done; - - /* the inquiry result can be triggered by NON D-Bus client */ - if (adapter->discov_type & RESOLVE_NAME) - name_status = NAME_REQUIRED; - else - name_status = NAME_NOT_REQUIRED; - - create_name(filename, PATH_MAX, STORAGEDIR, local_addr, "names"); - name = textfile_get(filename, peer_addr); - - tmp_name = extract_eir_name(data, &name_type); - if (tmp_name) { - if (name_type == 0x09) { - write_device_name(local, peer, tmp_name); - name_status = NAME_NOT_REQUIRED; - - if (name) - free(name); - - name = tmp_name; - } else { - if (name) - free(tmp_name); - else - name = tmp_name; - } - } - - if (name) { - signal_name = dev_signal_factory(adapter->dev_id, "RemoteNameUpdated", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_INVALID); - send_message_and_unref(connection, signal_name); - - free(name); - - if (name_type != 0x08) - name_status = NAME_SENT; - } - - /* add in the list to track name sent/pending */ - found_device_add(&adapter->found_devices, peer, rssi, name_status); - -done: - bt_free(local_addr); - bt_free(peer_addr); -} - -void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class) -{ - DBusMessage *message; - char *local_addr, *peer_addr; - bdaddr_t tmp; - uint32_t old_class = 0; - int id; - - read_remote_class(local, peer, &old_class); - - if (old_class == class) - return; - - baswap(&tmp, local); local_addr = batostr(&tmp); - baswap(&tmp, peer); peer_addr = batostr(&tmp); - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - message = dev_signal_factory(id, "RemoteClassUpdated", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_UINT32, &class, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - -failed: - bt_free(local_addr); - bt_free(peer_addr); -} - -void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, - char *name) -{ - struct adapter *adapter; - DBusMessage *message; - char path[MAX_PATH_LENGTH]; - char *local_addr, *peer_addr; - bdaddr_t tmp; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - baswap(&tmp, peer); peer_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto done; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto done; - } - - if (status) - message = dev_signal_factory(adapter->dev_id, - "RemoteNameFailed", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - else - message = dev_signal_factory(adapter->dev_id, - "RemoteNameUpdated", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - - /* remove from remote name request list */ - found_device_remove(&adapter->found_devices, peer); - - /* check if there is more devices to request names */ - if (!found_device_req_name(adapter)) - goto done; /* skip if a new request has been sent */ - - /* free discovered devices list */ - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - - /* - * The discovery completed signal must be sent only for discover - * devices request WITH name resolving - */ - if (adapter->discov_requestor) { - name_listener_remove(connection, adapter->discov_requestor, - (name_cb_t) discover_devices_req_exit, adapter); - free(adapter->discov_requestor); - adapter->discov_requestor = NULL; - - /* If there is a pending reply for discovery cancel */ - if (adapter->discovery_cancel) { - message = dbus_message_new_method_return(adapter->discovery_cancel); - send_message_and_unref(connection, message); - dbus_message_unref(adapter->discovery_cancel); - adapter->discovery_cancel = NULL; - } - - /* Disable name resolution for non D-Bus clients */ - if (!adapter->pdiscov_requestor) - adapter->discov_type &= ~RESOLVE_NAME; - } - - if (adapter->discov_active) { - message = dbus_message_new_signal(path, - ADAPTER_INTERFACE, "DiscoveryCompleted"); - send_message_and_unref(connection, message); - - adapter->discov_active = 0; - } - -done: - bt_free(local_addr); - bt_free(peer_addr); -} - -void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, - bdaddr_t *peer) -{ - char path[MAX_PATH_LENGTH]; - DBusMessage *message; - struct adapter *adapter; - char *local_addr, *peer_addr; - bdaddr_t tmp; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - baswap(&tmp, peer); peer_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto done; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto done; - } - - if (status) { - struct slist *l; - - cancel_passkey_agent_requests(adapter->passkey_agents, path, - peer); - release_passkey_agents(adapter, peer); - - l = slist_find(adapter->pin_reqs, peer, pin_req_cmp); - if (l) { - struct pending_pin_req *p = l->data; - adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); - free(p); - } - - if (adapter->bonding) - adapter->bonding->hci_status = status; - } else { - /* Sent the remote device connected signal */ - message = dev_signal_factory(adapter->dev_id, - "RemoteDeviceConnected", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - - /* add in the active connetions list */ - active_conn_append(&adapter->active_conn, peer, handle); - } - -done: - bt_free(local_addr); - bt_free(peer_addr); -} - -void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, - uint16_t handle, uint8_t reason) -{ - char path[MAX_PATH_LENGTH]; - struct adapter *adapter; - struct active_conn_info *dev; - DBusMessage *message; - struct slist *l; - char *local_addr, *peer_addr = NULL; - bdaddr_t tmp; - int id; - - if (status) { - error("Disconnection failed: 0x%02x", status); - return; - } - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto failed; - } - - l = slist_find(adapter->active_conn, &handle, - active_conn_find_by_handle); - - if (!l) - goto failed; - - dev = l->data; - - baswap(&tmp, &dev->bdaddr); peer_addr = batostr(&tmp); - - /* clean pending HCI cmds */ - hci_req_queue_remove(adapter->dev_id, &dev->bdaddr); - - /* Cancel D-Bus/non D-Bus requests */ - cancel_passkey_agent_requests(adapter->passkey_agents, path, - &dev->bdaddr); - release_passkey_agents(adapter, &dev->bdaddr); - - l = slist_find(adapter->pin_reqs, &dev->bdaddr, pin_req_cmp); - if (l) { - struct pending_pin_req *p = l->data; - adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); - free(p); - } - - /* Check if there is a pending CreateBonding request */ - if (adapter->bonding && (bacmp(&adapter->bonding->bdaddr, &dev->bdaddr) == 0)) { - if (adapter->bonding->cancel) { - /* reply authentication canceled */ - error_authentication_canceled(connection, - adapter->bonding->rq); - } else { - message = new_authentication_return(adapter->bonding->rq, - HCI_AUTHENTICATION_FAILURE); - send_message_and_unref(connection, message); - } - - name_listener_remove(connection, - dbus_message_get_sender(adapter->bonding->rq), - (name_cb_t) create_bond_req_exit, - adapter); - if (adapter->bonding->io_id) - g_io_remove_watch(adapter->bonding->io_id); - g_io_channel_close(adapter->bonding->io); - bonding_request_free(adapter->bonding); - adapter->bonding = NULL; - } - /* Sent the remote device disconnected signal */ - message = dev_signal_factory(adapter->dev_id, - "RemoteDeviceDisconnected", - DBUS_TYPE_STRING, &peer_addr, - DBUS_TYPE_INVALID); - - send_message_and_unref(connection, message); - active_conn_remove(&adapter->active_conn, &handle); - -failed: - if (peer_addr) - free(peer_addr); - - free(local_addr); -} - -/***************************************************************** - * - * Section reserved to D-Bus watch functions - * - *****************************************************************/ -static gboolean message_dispatch_cb(void *data) -{ - dbus_connection_ref(connection); - - /* Dispatch messages */ - while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS); - - dbus_connection_unref(connection); - - return FALSE; -} - -static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data) -{ - DBusWatch *watch = data; - int flags = 0; - - if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE; - if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE; - if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP; - if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR; - - dbus_watch_handle(watch, flags); - - if (dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS) - g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, NULL); - - return TRUE; -} - -static dbus_bool_t add_watch(DBusWatch *watch, void *data) -{ - GIOCondition cond = G_IO_HUP | G_IO_ERR; - struct watch_info *info; - int fd, flags; - - if (!dbus_watch_get_enabled(watch)) - return TRUE; - - info = malloc(sizeof(struct watch_info)); - if (info == NULL) - return FALSE; - - fd = dbus_watch_get_fd(watch); - info->io = g_io_channel_unix_new(fd); - flags = dbus_watch_get_flags(watch); - - if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN; - if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT; - - info->watch_id = g_io_add_watch(info->io, cond, watch_func, watch); - - dbus_watch_set_data(watch, info, NULL); - - return TRUE; -} - -static void remove_watch(DBusWatch *watch, void *data) -{ - struct watch_info *info = dbus_watch_get_data(watch); - - dbus_watch_set_data(watch, NULL, NULL); - - if (info) { - g_io_remove_watch(info->watch_id); - g_io_channel_unref(info->io); - free(info); - } -} - -static void watch_toggled(DBusWatch *watch, void *data) -{ - /* Because we just exit on OOM, enable/disable is - * no different from add/remove */ - if (dbus_watch_get_enabled(watch)) - add_watch(watch, data); - else - remove_watch(watch, data); -} - -static gboolean timeout_handler_dispatch(gpointer data) -{ - timeout_handler_t *handler = data; - - /* if not enabled should not be polled by the main loop */ - if (dbus_timeout_get_enabled(handler->timeout) != TRUE) - return FALSE; - - dbus_timeout_handle(handler->timeout); - - return FALSE; -} - -static void timeout_handler_free(void *data) -{ - timeout_handler_t *handler = data; - if (!handler) - return; - - g_timeout_remove(handler->id); - free(handler); -} - -static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) -{ - timeout_handler_t *handler; - - if (!dbus_timeout_get_enabled (timeout)) - return TRUE; - - handler = malloc(sizeof(timeout_handler_t)); - memset(handler, 0, sizeof(timeout_handler_t)); - - handler->timeout = timeout; - handler->id = g_timeout_add(dbus_timeout_get_interval(timeout), - timeout_handler_dispatch, handler); - - dbus_timeout_set_data(timeout, handler, timeout_handler_free); - - return TRUE; -} - -static void remove_timeout(DBusTimeout *timeout, void *data) -{ - -} - -static void timeout_toggled(DBusTimeout *timeout, void *data) -{ - if (dbus_timeout_get_enabled(timeout)) - add_timeout(timeout, data); - else - remove_timeout(timeout, data); -} - -static void dispatch_status_cb(DBusConnection *conn, - DBusDispatchStatus new_status, - void *data) -{ - if (!dbus_connection_get_is_connected(conn)) - return; - - if (new_status == DBUS_DISPATCH_DATA_REMAINS) - g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, NULL); -} - -int hcid_dbus_init(void) -{ - int ret_val; - DBusError err; - - dbus_error_init(&err); - - connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err); - - if (dbus_error_is_set(&err)) { - error("Can't open system message bus connection: %s", - err.message); - dbus_error_free(&err); - return -1; - } - - dbus_connection_set_exit_on_disconnect(connection, FALSE); - - ret_val = dbus_bus_request_name(connection, BLUEZ_NAME, 0, &err); - - if (ret_val != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER ) { - error("Service could not become the primary owner."); - return -1; - } - - if (dbus_error_is_set(&err)) { - error("Can't get system message bus name: %s", err.message); - dbus_error_free(&err); - return -1; - } - - if (!dbus_connection_register_fallback(connection, BASE_PATH, - &manager_vtable, NULL)) { - error("D-Bus failed to register %s fallback", BASE_PATH); - return -1; - } - - if (!dbus_connection_add_filter(connection, hci_dbus_signal_filter, - NULL, NULL)) { - error("Can't add new HCI filter"); - return -1; - } - - dbus_connection_set_watch_functions(connection, - add_watch, remove_watch, watch_toggled, NULL, NULL); - - dbus_connection_set_timeout_functions(connection, - add_timeout, remove_timeout, timeout_toggled, NULL, - NULL); - - dbus_connection_set_dispatch_status_function(connection, - dispatch_status_cb, NULL, NULL); - - return 0; -} - -void hcid_dbus_exit(void) -{ - char **children; - int i; - - if (!dbus_connection_get_is_connected(connection)) - return; - - release_default_agent(); - release_default_auth_agent(); - release_service_agents(connection); - - /* Unregister all paths in Adapter path hierarchy */ - if (!dbus_connection_list_registered(connection, BASE_PATH, &children)) - goto done; - - for (i = 0; children[i]; i++) { - char dev_path[MAX_PATH_LENGTH]; - - snprintf(dev_path, sizeof(dev_path), "%s/%s", BASE_PATH, - children[i]); - - unregister_dbus_path(dev_path); - } - - dbus_free_string_array(children); - -done: - unregister_dbus_path(BASE_PATH); - - dbus_connection_unref(connection); -} - -/***************************************************************** - * - * Section reserved to re-connection timer - * - *****************************************************************/ - -gboolean discov_timeout_handler(void *data) -{ - struct adapter *adapter = data; - struct hci_request rq; - int dd; - uint8_t hci_mode = adapter->mode; - uint8_t status = 0; - gboolean retval = TRUE; - - hci_mode &= ~SCAN_INQUIRY; - - dd = hci_open_dev(adapter->dev_id); - if (dd < 0) { - error("HCI device open failed: hci%d", adapter->dev_id); - return TRUE; - } - - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_HOST_CTL; - rq.ocf = OCF_WRITE_SCAN_ENABLE; - rq.cparam = &hci_mode; - rq.clen = sizeof(hci_mode); - rq.rparam = &status; - rq.rlen = sizeof(status); - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, 1000) < 0) { - error("Sending write scan enable command to hci%d failed: %s (%d)", - adapter->dev_id, strerror(errno), errno); - goto failed; - } - if (status) { - error("Setting scan enable failed with status 0x%02x", status); - goto failed; - } - - adapter->timeout_id = 0; - retval = FALSE; - -failed: - if (dd >= 0) - hci_close_dev(dd); - - return retval; -} - -static gboolean system_bus_reconnect(void *data) -{ - struct hci_dev_list_req *dl = NULL; - struct hci_dev_req *dr; - int sk, i; - gboolean ret_val = TRUE; - - if (dbus_connection_get_is_connected(connection)) - return FALSE; - - if (hcid_dbus_init() == FALSE) - return TRUE; - - /* Create and bind HCI socket */ - sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); - if (sk < 0) { - error("Can't open HCI socket: %s (%d)", - strerror(errno), errno); - return TRUE; - } - - dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl)); - if (!dl) { - error("Can't allocate memory"); - goto failed; - } - - dl->dev_num = HCI_MAX_DEV; - dr = dl->dev_req; - - if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) { - info("Can't get device list: %s (%d)", - strerror(errno), errno); - goto failed; - } - - /* reset the default device */ - default_dev = -1; - - for (i = 0; i < dl->dev_num; i++, dr++) - hcid_dbus_register_device(dr->dev_id); - - ret_val = FALSE; - -failed: - if (sk >= 0) - close(sk); - - if (dl) - free(dl); - - return ret_val; -} - -/***************************************************************** - * - * Section reserved to D-Bus signal/messages handling function - * - *****************************************************************/ -static DBusHandlerResult hci_dbus_signal_filter(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - DBusHandlerResult ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - const char *iface; - const char *method; - - if (!msg || !conn) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - if (dbus_message_get_type (msg) != DBUS_MESSAGE_TYPE_SIGNAL) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - iface = dbus_message_get_interface(msg); - method = dbus_message_get_member(msg); - - if ((strcmp(iface, DBUS_INTERFACE_LOCAL) == 0) && - (strcmp(method, "Disconnected") == 0)) { - error("Got disconnected from the system message bus"); - dbus_connection_unref(conn); - g_timeout_add(RECONNECT_RETRY_TIMEOUT, system_bus_reconnect, - NULL); - } - - return ret; -} - -/***************************************************************** - * - * Section reserved to device HCI callbacks - * - *****************************************************************/ -void hcid_dbus_setname_complete(bdaddr_t *local) -{ - DBusMessage *signal; - char *local_addr; - bdaddr_t tmp; - int id; - int dd = -1; - read_local_name_rp rp; - struct hci_request rq; - const char *pname = (char *) rp.name; - char name[249]; - - baswap(&tmp, local); local_addr = batostr(&tmp); - - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - dd = hci_open_dev(id); - if (dd < 0) { - error("HCI device open failed: hci%d", id); - memset(&rp, 0, sizeof(rp)); - } else { - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_HOST_CTL; - rq.ocf = OCF_READ_LOCAL_NAME; - rq.rparam = &rp; - rq.rlen = READ_LOCAL_NAME_RP_SIZE; - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, 1000) < 0) { - error("Sending getting name command failed: %s (%d)", - strerror(errno), errno); - rp.name[0] = '\0'; - } - - if (rp.status) { - error("Getting name failed with status 0x%02x", - rp.status); - rp.name[0] = '\0'; - } - } - - strncpy(name, pname, sizeof(name) - 1); - name[248] = '\0'; - pname = name; - - signal = dev_signal_factory(id, "NameChanged", - DBUS_TYPE_STRING, &pname, DBUS_TYPE_INVALID); - send_message_and_unref(connection, signal); - -failed: - if (dd >= 0) - hci_close_dev(dd); - - bt_free(local_addr); -} - -void hcid_dbus_setscan_enable_complete(bdaddr_t *local) -{ - DBusMessage *message; - struct adapter *adapter; - char *local_addr; - char path[MAX_PATH_LENGTH]; - bdaddr_t tmp; - read_scan_enable_rp rp; - struct hci_request rq; - int id; - int dd = -1; - const char *scan_mode; - - baswap(&tmp, local); local_addr = batostr(&tmp); - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - dd = hci_open_dev(id); - if (dd < 0) { - error("HCI device open failed: hci%d", id); - goto failed; - } - - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_HOST_CTL; - rq.ocf = OCF_READ_SCAN_ENABLE; - rq.rparam = &rp; - rq.rlen = READ_SCAN_ENABLE_RP_SIZE; - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, 1000) < 0) { - error("Sending read scan enable command failed: %s (%d)", - strerror(errno), errno); - goto failed; - } - - if (rp.status) { - error("Getting scan enable failed with status 0x%02x", - rp.status); - goto failed; - } - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto failed; - } - - /* update the current scan mode value */ - adapter->mode = rp.enable; - - if (adapter->timeout_id) { - g_timeout_remove(adapter->timeout_id); - adapter->timeout_id = 0; - } - - switch (rp.enable) { - case SCAN_DISABLED: - scan_mode = MODE_OFF; - break; - case SCAN_PAGE: - scan_mode = MODE_CONNECTABLE; - break; - case (SCAN_PAGE | SCAN_INQUIRY): - scan_mode = MODE_DISCOVERABLE; - if (adapter->discov_timeout != 0) - adapter->timeout_id = g_timeout_add(adapter->discov_timeout * 1000, - discov_timeout_handler, - adapter); - break; - case SCAN_INQUIRY: - /* Address the scenario when another app changed the scan - * mode */ - if (adapter->discov_timeout != 0) - adapter->timeout_id = g_timeout_add(adapter->discov_timeout * 1000, - discov_timeout_handler, - adapter); - /* ignore, this event should not be sent*/ - default: - /* ignore, reserved */ - goto failed; - } - - write_device_mode(local, scan_mode); - - message = dev_signal_factory(adapter->dev_id, "ModeChanged", - DBUS_TYPE_STRING, &scan_mode, - DBUS_TYPE_INVALID); - send_message_and_unref(connection, message); - -failed: - if (dd >= 0) - hci_close_dev(dd); - - bt_free(local_addr); -} - -void hcid_dbus_pin_code_reply(bdaddr_t *local, void *ptr) -{ - - typedef struct { - uint8_t status; - bdaddr_t bdaddr; - } __attribute__ ((packed)) ret_pin_code_req_reply; - - struct adapter *adapter; - char *local_addr; - ret_pin_code_req_reply *ret = ptr + EVT_CMD_COMPLETE_SIZE; - struct slist *l; - char path[MAX_PATH_LENGTH]; - bdaddr_t tmp; - int id; - - baswap(&tmp, local); local_addr = batostr(&tmp); - id = hci_devid(local_addr); - if (id < 0) { - error("No matching device id for %s", local_addr); - goto failed; - } - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &adapter)) { - error("Getting %s path data failed!", path); - goto failed; - } - - l = slist_find(adapter->pin_reqs, &ret->bdaddr, pin_req_cmp); - if (l) { - struct pending_pin_info *p = l->data; - p->replied = 1; - } - -failed: - bt_free(local_addr); -} - -void create_bond_req_exit(const char *name, struct adapter *adapter) -{ - char path[MAX_PATH_LENGTH]; - struct slist *l; - - snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, adapter->dev_id); - - debug("CreateConnection requestor (%s) exited before bonding was completed", - name); - - cancel_passkey_agent_requests(adapter->passkey_agents, path, - &adapter->bonding->bdaddr); - release_passkey_agents(adapter, &adapter->bonding->bdaddr); - - l = slist_find(adapter->pin_reqs, &adapter->bonding->bdaddr, - pin_req_cmp); - if (l) { - struct pending_pin_info *p = l->data; - - if (!p->replied) { - int dd; - - dd = hci_open_dev(adapter->dev_id); - if (dd >= 0) { - hci_send_cmd(dd, OGF_LINK_CTL, - OCF_PIN_CODE_NEG_REPLY, - 6, &adapter->bonding->bdaddr); - hci_close_dev(dd); - } - } - - adapter->pin_reqs = slist_remove(adapter->pin_reqs, p); - free(p); - } - - g_io_channel_close(adapter->bonding->io); - if (adapter->bonding->io_id) - g_io_remove_watch(adapter->bonding->io_id); - bonding_request_free(adapter->bonding); - adapter->bonding = NULL; -} - -void discover_devices_req_exit(const char *name, struct adapter *adapter) -{ - debug("DiscoverDevices requestor (%s) exited", name); - - /* - * Cleanup the discovered devices list and send the command to - * cancel inquiry or cancel remote name request. The return - * can be ignored. - */ - cancel_discovery(adapter); -} - -static int inquiry_cancel(int dd, int to) -{ - struct hci_request rq; - uint8_t status; - - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_LINK_CTL; - rq.ocf = OCF_INQUIRY_CANCEL; - rq.rparam = &status; - rq.rlen = sizeof(status); - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, to) < 0) - return -1; - - if (status) { - errno = bt_error(status); - return -1; - } - - return 0; -} - -static int remote_name_cancel(int dd, bdaddr_t *dba, int to) -{ - remote_name_req_cancel_cp cp; - struct hci_request rq; - uint8_t status; - - memset(&rq, 0, sizeof(rq)); - memset(&cp, 0, sizeof(cp)); - - bacpy(&cp.bdaddr, dba); - - rq.ogf = OGF_LINK_CTL; - rq.ocf = OCF_REMOTE_NAME_REQ_CANCEL; - rq.cparam = &cp; - rq.clen = REMOTE_NAME_REQ_CANCEL_CP_SIZE; - rq.rparam = &status; - rq.rlen = sizeof(status); - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, to) < 0) - return -1; - - if (status) { - errno = bt_error(status); - return -1; - } - - return 0; -} - -int cancel_discovery(struct adapter *adapter) -{ - struct remote_dev_info *dev, match; - struct slist *l; - int dd, err = 0; - - if (!adapter->discov_active) - goto cleanup; - - dd = hci_open_dev(adapter->dev_id); - if (dd < 0) { - err = -ENODEV; - goto cleanup; - } - - /* - * If there is a pending read remote name request means - * that the inquiry complete event was already received - */ - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, BDADDR_ANY); - match.name_status = NAME_REQUESTED; - - l = slist_find(adapter->found_devices, &match, - (cmp_func_t) found_device_cmp); - if (l) { - dev = l->data; - if (remote_name_cancel(dd, &dev->bdaddr, 1000) < 0) { - error("Read remote name cancel failed: %s, (%d)", - strerror(errno), errno); - err = -errno; - } - } else { - if (inquiry_cancel(dd, 1000) < 0) { - error("Inquiry cancel failed:%s (%d)", - strerror(errno), errno); - err = -errno; - } - } - - hci_close_dev(dd); - -cleanup: - /* - * Reset discov_requestor and discover_state in the remote name - * request event handler or in the inquiry complete handler. - */ - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - - /* Disable name resolution for non D-Bus clients */ - if (!adapter->pdiscov_requestor) - adapter->discov_type &= ~RESOLVE_NAME; - - return err; -} - -void periodic_discover_req_exit(const char *name, struct adapter *adapter) -{ - debug("PeriodicDiscovery requestor (%s) exited", name); - - /* - * Cleanup the discovered devices list and send the cmd to exit from - * periodic inquiry or cancel remote name request. The return value can - * be ignored. - */ - - cancel_periodic_discovery(adapter); -} - -static int periodic_inquiry_exit(int dd, int to) -{ - struct hci_request rq; - uint8_t status; - - memset(&rq, 0, sizeof(rq)); - rq.ogf = OGF_LINK_CTL; - rq.ocf = OCF_EXIT_PERIODIC_INQUIRY; - rq.rparam = &status; - rq.rlen = sizeof(status); - rq.event = EVT_CMD_COMPLETE; - - if (hci_send_req(dd, &rq, to) < 0) - return -1; - - if (status) { - errno = status; - return -1; - } - - return 0; -} - -int cancel_periodic_discovery(struct adapter *adapter) -{ - struct remote_dev_info *dev, match; - struct slist *l; - int dd, err = 0; - - if (!adapter->pdiscov_active) - goto cleanup; - - dd = hci_open_dev(adapter->dev_id); - if (dd < 0) { - err = -ENODEV; - goto cleanup; - } - /* find the pending remote name request */ - memset(&match, 0, sizeof(struct remote_dev_info)); - bacpy(&match.bdaddr, BDADDR_ANY); - match.name_status = NAME_REQUESTED; - - l = slist_find(adapter->found_devices, &match, - (cmp_func_t) found_device_cmp); - if (l) { - dev = l->data; - if (remote_name_cancel(dd, &dev->bdaddr, 1000) < 0) { - error("Read remote name cancel failed: %s, (%d)", - strerror(errno), errno); - err = -errno; - } - } - - /* ovewrite err if necessary: stop periodic inquiry has higher - * priority */ - if (periodic_inquiry_exit(dd, 1000) < 0) { - error("Periodic Inquiry exit failed:%s (%d)", - strerror(errno), errno); - err = -errno; - } - - hci_close_dev(dd); -cleanup: - /* - * Reset pdiscov_requestor and pdiscov_active is done when the - * cmd complete event for exit periodic inquiry mode cmd arrives. - */ - slist_foreach(adapter->found_devices, (slist_func_t) free, NULL); - slist_free(adapter->found_devices); - adapter->found_devices = NULL; - - return err; -} diff --git a/hcid/dbus.h b/hcid/dbus.h deleted file mode 100644 index 695633db..00000000 --- a/hcid/dbus.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * - * BlueZ - Bluetooth protocol stack for Linux - * - * Copyright (C) 2004-2006 Marcel Holtmann - * - * - * 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 - * - */ - -#ifndef __H_BLUEZ_DBUS_H__ -#define __H_BLUEZ_DBUS_H__ - -#include -#include "dbus-adapter.h" - -DBusMessage *dev_signal_factory(const int devid, const char *prop_name, const int first, ...); - -DBusMessage *new_authentication_return(DBusMessage *msg, uint8_t status); - -int get_default_dev_id(void); - -void create_bond_req_exit(const char *name, struct adapter *adapter); -void discover_devices_req_exit(const char *name, struct adapter *adapter); -int cancel_discovery(struct adapter *adapter); -void periodic_discover_req_exit(const char *name, struct adapter *adapter); -int cancel_periodic_discovery(struct adapter *adapter); - -int active_conn_find_by_bdaddr(const void *data, const void *user_data); -void bonding_request_free(struct bonding_request_info *dev); -int pin_req_cmp(const void *p1, const void *p2); -int found_device_cmp(const struct remote_dev_info *d1, - const struct remote_dev_info *d2); -int found_device_add(struct slist **list, bdaddr_t *bdaddr, int8_t rssi, - name_status_t name_status); -int found_device_req_name(struct adapter *dbus_data); - -int discov_timeout_handler(void *data); - -#endif /* __H_BLUEZ_DBUS_H__ */ diff --git a/hcid/hcid.h b/hcid/hcid.h index 3950abcd..e1465cce 100644 --- a/hcid/hcid.h +++ b/hcid/hcid.h @@ -140,32 +140,6 @@ void toggle_pairing(int enable); void set_pin_length(bdaddr_t *sba, int length); -int hcid_dbus_init(void); -void hcid_dbus_exit(void); -void hcid_dbus_set_experimental(); -int hcid_dbus_use_experimental(); -int hcid_dbus_register_device(uint16_t id); -int hcid_dbus_unregister_device(uint16_t id); -int hcid_dbus_start_device(uint16_t id); -int hcid_dbus_stop_device(uint16_t id); -void hcid_dbus_pending_pin_req_add(bdaddr_t *sba, bdaddr_t *dba); -int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci); -int hcid_dbus_confirm_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci, char *pin); - -void hcid_dbus_inquiry_start(bdaddr_t *local); -void hcid_dbus_inquiry_complete(bdaddr_t *local); -void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status); -void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status); -void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi, uint8_t *data); -void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class); -void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, char *name); -void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, bdaddr_t *peer); -void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, uint8_t reason); -void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, uint8_t status); -void hcid_dbus_setname_complete(bdaddr_t *local); -void hcid_dbus_setscan_enable_complete(bdaddr_t *local); -void hcid_dbus_pin_code_reply(bdaddr_t *local, void *ptr); - void init_devices(void); int add_device(uint16_t dev_id); int remove_device(uint16_t dev_id); diff --git a/hcid/main.c b/hcid/main.c index 38a4efe0..2ca34681 100644 --- a/hcid/main.c +++ b/hcid/main.c @@ -46,6 +46,8 @@ #include "hcid.h" #include "sdp.h" +#include "dbus-common.h" +#include "dbus-hci.h" struct hcid_opts hcid; struct device_opts default_device; diff --git a/hcid/security.c b/hcid/security.c index 7d2ff9c1..2bf4ce1d 100644 --- a/hcid/security.c +++ b/hcid/security.c @@ -51,6 +51,7 @@ #include "hcid.h" #include "textfile.h" #include "list.h" +#include "dbus-hci.h" struct g_io_info { GIOChannel *channel; -- cgit