diff options
Diffstat (limited to 'hcid/dbus-hci.c')
| -rw-r--r-- | hcid/dbus-hci.c | 2713 |
1 files changed, 2713 insertions, 0 deletions
diff --git a/hcid/dbus-hci.c b/hcid/dbus-hci.c new file mode 100644 index 00000000..617ded21 --- /dev/null +++ b/hcid/dbus-hci.c @@ -0,0 +1,2713 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2006-2007 Nokia Corporation + * Copyright (C) 2004-2008 Marcel Holtmann <marcel@holtmann.org> + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#define _GNU_SOURCE +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <sys/param.h> +#include <sys/ioctl.h> +#include <sys/socket.h> + +#include <bluetooth/bluetooth.h> +#include <bluetooth/hci.h> +#include <bluetooth/hci_lib.h> +#include <bluetooth/sdp.h> + +#include <glib.h> +#include <dbus/dbus.h> +#include <gdbus.h> + +#include "hcid.h" +#include "textfile.h" +#include "manager.h" +#include "adapter.h" +#include "device.h" +#include "error.h" +#include "glib-helper.h" +#include "dbus-common.h" +#include "dbus-error.h" +#include "dbus-service.h" +#include "dbus-security.h" +#include "agent.h" +#include "dbus-hci.h" + +static DBusConnection *connection = NULL; + +void bonding_request_free(struct bonding_request_info *bonding) +{ + struct device *device; + char address[18]; + + if (!bonding) + return; + + if (bonding->msg) + dbus_message_unref(bonding->msg); + + if (bonding->conn) + dbus_connection_unref(bonding->conn); + + if (bonding->io) + g_io_channel_unref(bonding->io); + + ba2str(&bonding->bdaddr, address); + + device = adapter_find_device(bonding->adapter, address); + if (device && device->agent) { + agent_destroy(device->agent, FALSE); + device->agent = NULL; + } + + g_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(GSList **list, bdaddr_t *bdaddr, int8_t rssi, + name_status_t name_status) +{ + struct remote_dev_info *dev, match; + GSList *l; + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, bdaddr); + match.name_status = NAME_ANY; + + /* ignore repeated entries */ + l = g_slist_find_custom(*list, &match, (GCompareFunc) found_device_cmp); + if (l) { + /* device found, update the attributes */ + dev = l->data; + + if (rssi != 0) + 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 = g_slist_sort(*list, (GCompareFunc) dev_rssi_cmp); + + return -EALREADY; + } + + dev = g_new0(struct remote_dev_info, 1); + + bacpy(&dev->bdaddr, bdaddr); + dev->rssi = rssi; + dev->name_status = name_status; + + *list = g_slist_insert_sorted(*list, dev, (GCompareFunc) dev_rssi_cmp); + + return 0; +} + +static int found_device_remove(GSList **list, bdaddr_t *bdaddr) +{ + struct remote_dev_info *dev, match; + GSList *l; + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, bdaddr); + + l = g_slist_find_custom(*list, &match, (GCompareFunc) found_device_cmp); + if (!l) + return -1; + + dev = l->data; + *list = g_slist_remove(*list, dev); + g_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(GSList **list, bdaddr_t *bdaddr, + uint16_t handle) +{ + struct active_conn_info *dev; + + dev = g_new0(struct active_conn_info, 1); + + bacpy(&dev->bdaddr, bdaddr); + dev->handle = handle; + + *list = g_slist_append(*list, 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 ".RepeatedAttempts", + "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 dbus_bool_t send_adapter_signal(DBusConnection *conn, int devid, + const char *name, int first, ...) +{ + va_list var_args; + dbus_bool_t ret; + char path[MAX_PATH_LENGTH]; + + snprintf(path, sizeof(path)-1, "%s/hci%d", BASE_PATH, devid); + + va_start(var_args, first); + ret = g_dbus_emit_signal_valist(conn, path, ADAPTER_INTERFACE, + name, first, var_args); + va_end(var_args); + + return ret; +} + +static void adapter_mode_changed(struct adapter *adapter, uint8_t scan_enable) +{ + const char *mode; + + adapter->scan_enable = scan_enable; + + switch (scan_enable) { + case SCAN_DISABLED: + mode = "off"; + adapter->mode = MODE_OFF; + break; + case SCAN_PAGE: + mode = "connectable"; + adapter->mode = MODE_CONNECTABLE; + break; + case (SCAN_PAGE | SCAN_INQUIRY): + + if (adapter->discov_timeout != 0) + adapter->timeout_id = g_timeout_add(adapter->discov_timeout * 1000, + discov_timeout_handler, adapter); + + if (adapter->mode == MODE_LIMITED) { + mode = "limited"; + } else { + adapter->mode = MODE_DISCOVERABLE; + mode = "discoverable"; + } + break; + case SCAN_INQUIRY: + /* Address the scenario where 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 */ + return; + } + + g_dbus_emit_signal(connection, adapter->path, ADAPTER_INTERFACE, + "ModeChanged", + DBUS_TYPE_STRING, &mode, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + const char *ptr = adapter->path + ADAPTER_PATH_INDEX; + dbus_connection_emit_property_changed(connection, ptr, + ADAPTER_INTERFACE, "Mode", + DBUS_TYPE_STRING, &mode); + } +} + +/* + * HCI D-Bus services + */ +static void reply_pending_requests(const char *path, struct adapter *adapter) +{ + if (!path || !adapter) + return; + + /* pending bonding */ + if (adapter->bonding) { + error_authentication_canceled(connection, adapter->bonding->msg); + + remove_pending_device(adapter); + + g_dbus_remove_watch(adapter->bonding->conn, + adapter->bonding->listener_id); + + if (adapter->bonding->io_id) + g_source_remove(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) { + DBusMessage *reply; + reply = dbus_message_new_method_return(adapter->discovery_cancel); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + 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 */ + if (hcid_dbus_use_experimental()) { + const char *ptr = path + ADAPTER_PATH_INDEX; + + g_dbus_emit_signal(connection, ptr, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + + } + + g_dbus_emit_signal(connection, path, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + + /* 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 */ + g_dbus_emit_signal(connection, path, + ADAPTER_INTERFACE, + "PeriodicDiscoveryStopped", + DBUS_TYPE_INVALID); + + /* Stop periodic inquiry initiated by D-Bus client */ + if (adapter->pdiscov_requestor) + cancel_periodic_discovery(adapter); + } +} + +static void do_unregister(gpointer data, gpointer user_data) +{ + DBusConnection *conn = user_data; + struct device *device = data; + + device_remove(conn, device); +} + +int unregister_adapter_path(const char *path) +{ + struct adapter *adapter; + + info("Unregister path: %s", path); + + __remove_servers(path); + + adapter = manager_find_adapter_by_path(path); + 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->agent) { + agent_destroy(adapter->agent, FALSE); + adapter->agent = NULL; + } + + if (adapter->discov_requestor) { + g_dbus_remove_watch(connection, adapter->discov_listener); + adapter->discov_listener = 0; + g_free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + } + + if (adapter->pdiscov_requestor) { + g_dbus_remove_watch(connection, adapter->pdiscov_listener); + adapter->pdiscov_listener = 0; + g_free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + if (adapter->found_devices) { + g_slist_foreach(adapter->found_devices, + (GFunc) g_free, NULL); + g_slist_free(adapter->found_devices); + adapter->found_devices = NULL; + } + + if (adapter->oor_devices) { + g_slist_foreach(adapter->oor_devices, + (GFunc) free, NULL); + g_slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + } + + if (adapter->auth_reqs) { + g_slist_foreach(adapter->auth_reqs, + (GFunc) g_free, NULL); + g_slist_free(adapter->auth_reqs); + adapter->auth_reqs = NULL; + } + + if (adapter->active_conn) { + g_slist_foreach(adapter->active_conn, + (GFunc) free, NULL); + g_slist_free(adapter->active_conn); + adapter->active_conn = NULL; + } + + /* Check if there is a pending RemoteDeviceDisconnect request */ + if (adapter->pending_dc) { + error_no_such_adapter(adapter->pending_dc->conn, + adapter->pending_dc->msg); + g_source_remove(adapter->pending_dc->timeout_id); + dc_pending_timeout_cleanup(adapter); + } + + if (adapter->devices) { + g_slist_foreach(adapter->devices, do_unregister, + connection); + g_slist_free(adapter->devices); + } + + manager_remove_adapter(adapter); + + g_free(adapter->path); + g_free(adapter); + +unreg: + if (!adapter_cleanup(connection, path)) { + error("Failed to unregister adapter interface on %s object", + path); + return -1; + } + + if (!security_cleanup(connection, path)) { + error("Failed to unregister security interface on %s object", + path); + return -1; + } + + if (hcid_dbus_use_experimental()) { + const char *ptr = path + ADAPTER_PATH_INDEX; + + adapter_cleanup(connection, ptr); + } + + 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 *ptr = path + ADAPTER_PATH_INDEX; + struct adapter *adapter; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + adapter = g_try_new0(struct adapter, 1); + if (!adapter) { + error("Failed to alloc memory to D-Bus path register data (%s)", + path); + return -1; + } + + adapter->dev_id = id; + adapter->pdiscov_resolve_names = 1; + + if (!adapter_init(connection, path, adapter)) { + error("Adapter interface init failed on path %s", path); + g_free(adapter); + return -1; + } + + adapter->path = g_strdup(path); + + if (!security_init(connection, path)) { + error("Security interface init failed on path %s", path); + goto failed; + } + + __probe_servers(path); + + manager_add_adapter(adapter); + + return 0; + +failed: + if (hcid_dbus_use_experimental()) + g_dbus_unregister_interface(connection, ptr, ADAPTER_INTERFACE); + + g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE); + + g_free(adapter->path); + g_free(adapter); + + return -1; +} + +int hcid_dbus_unregister_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + return unregister_adapter_path(path); +} + +static void create_stored_device_from_profiles(char *key, char *value, + void *user_data) +{ + struct adapter *adapter = user_data; + GSList *uuids = bt_string2list(value); + struct device *device; + + device = device_create(connection, adapter, key); + if (device) { + device->temporary = FALSE; + adapter->devices = g_slist_append(adapter->devices, device); + device_probe_drivers(device, uuids); + g_slist_free(uuids); + } +} + +static void create_stored_device_from_linkkeys(char *key, char *value, + void *user_data) +{ + struct adapter *adapter = user_data; + struct device *device; + + if (g_slist_find_custom(adapter->devices, + key, (GCompareFunc) device_address_cmp)) + return; + + device = device_create(connection, adapter, key); + if (device) { + device->temporary = FALSE; + adapter->devices = g_slist_append(adapter->devices, device); + } +} + +static void register_devices(bdaddr_t *src, struct adapter *adapter) +{ + char filename[PATH_MAX + 1]; + char addr[18]; + + ba2str(src, addr); + + create_name(filename, PATH_MAX, STORAGEDIR, addr, "profiles"); + textfile_foreach(filename, create_stored_device_from_profiles, adapter); + + create_name(filename, PATH_MAX, STORAGEDIR, addr, "linkkeys"); + textfile_foreach(filename, create_stored_device_from_linkkeys, adapter); +} + +int hcid_dbus_start_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + char *ptr = path + ADAPTER_PATH_INDEX; + struct hci_dev_info di; + struct adapter* adapter; + struct hci_conn_list_req *cl = NULL; + struct hci_conn_info *ci; + const char *mode; + int i, err, dd = -1, ret = -1; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + 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; + + adapter = manager_find_adapter_by_path(path); + if (!adapter) { + error("Getting %s path data failed!", path); + return -1; + } + + if (hci_test_bit(HCI_INQUIRY, &di.flags)) + adapter->discov_active = 1; + else + adapter->discov_active = 0; + + adapter->up = 1; + adapter->discov_timeout = get_discoverable_timeout(id); + adapter->discov_type = DISCOVER_TYPE_NONE; + + dd = hci_open_dev(id); + if (dd < 0) + goto failed; + + adapter->scan_enable = get_startup_scan(id); + hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, + 1, &adapter->scan_enable); + /* + * Get the adapter Bluetooth address + */ + err = get_device_address(adapter->dev_id, adapter->address, + sizeof(adapter->address)); + if (err < 0) + goto failed; + + err = get_device_class(adapter->dev_id, adapter->class); + if (err < 0) + goto failed; + + adapter->mode = get_startup_mode(id); + if (adapter->mode == MODE_LIMITED) + set_limited_discoverable(dd, adapter->class, TRUE); + + /* + * retrieve the active connections: address the scenario where + * the are active connections before the daemon've started + */ + + cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl)); + + cl->dev_id = id; + cl->conn_num = 10; + ci = cl->conn_info; + + if (ioctl(dd, HCIGETCONNLIST, cl) < 0) + goto failed; + + for (i = 0; i < cl->conn_num; i++, ci++) + active_conn_append(&adapter->active_conn, + &ci->bdaddr, ci->handle); + + ret = 0; + + mode = mode2str(adapter->mode); + g_dbus_emit_signal(connection, path, ADAPTER_INTERFACE, + "ModeChanged", + DBUS_TYPE_STRING, &mode, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + dbus_connection_emit_property_changed(connection, ptr, + ADAPTER_INTERFACE, "Mode", + DBUS_TYPE_STRING, &mode); + } + + if (manager_get_default_adapter() < 0) + manager_set_default_adapter(id); + + if (hcid_dbus_use_experimental()) + register_devices(&di.bdaddr, adapter); + +failed: + if (dd >= 0) + hci_close_dev(dd); + + g_free(cl); + + return ret; +} + +static void send_dc_signal(struct active_conn_info *dev, const char *path) +{ + char addr[18]; + const char *paddr = addr; + + ba2str(&dev->bdaddr, addr); + + g_dbus_emit_signal(connection, path, ADAPTER_INTERFACE, + "RemoteDeviceDisconnected", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_INVALID); +} + +int hcid_dbus_stop_device(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + struct adapter *adapter; + const char *mode = "off"; + + snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, id); + + adapter = manager_find_adapter_by_path(path); + if (!adapter) { + error("Getting %s path data failed!", path); + return -1; + } + + /* cancel pending timeout */ + if (adapter->timeout_id) { + g_source_remove(adapter->timeout_id); + adapter->timeout_id = 0; + } + + /* 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) { + g_dbus_remove_watch(connection, adapter->discov_listener); + adapter->discov_listener = 0; + g_free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + } + + if (adapter->pdiscov_requestor) { + g_dbus_remove_watch(connection, adapter->pdiscov_listener); + adapter->pdiscov_listener = 0; + g_free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + if (adapter->found_devices) { + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_slist_free(adapter->found_devices); + adapter->found_devices = NULL; + } + + if (adapter->oor_devices) { + g_slist_foreach(adapter->oor_devices, (GFunc) free, NULL); + g_slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + } + + if (adapter->auth_reqs) { + g_slist_foreach(adapter->auth_reqs, (GFunc) g_free, NULL); + g_slist_free(adapter->auth_reqs); + adapter->auth_reqs = NULL; + } + + if (adapter->active_conn) { + g_slist_foreach(adapter->active_conn, (GFunc) send_dc_signal, path); + g_slist_foreach(adapter->active_conn, (GFunc) g_free, NULL); + g_slist_free(adapter->active_conn); + adapter->active_conn = NULL; + } + + send_adapter_signal(connection, adapter->dev_id, "ModeChanged", + DBUS_TYPE_STRING, &mode, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + const char *ptr = path + ADAPTER_PATH_INDEX; + dbus_connection_emit_property_changed(connection, ptr, + ADAPTER_INTERFACE, "Mode", + DBUS_TYPE_STRING, &mode); + } + + adapter->up = 0; + adapter->scan_enable = SCAN_DISABLED; + adapter->mode = MODE_OFF; + adapter->discov_active = 0; + adapter->pdiscov_active = 0; + adapter->pinq_idle = 0; + adapter->discov_type = DISCOVER_TYPE_NONE; + + return 0; +} + +static void pincode_cb(struct agent *agent, DBusError *err, const char *pincode, + struct device *device) +{ + struct adapter *adapter = device->adapter; + pin_code_reply_cp pr; + bdaddr_t sba, dba; + size_t len; + int dev; + struct pending_auth_info *auth; + + /* No need to reply anything if the authentication already failed */ + if (adapter->bonding && adapter->bonding->hci_status) + return; + + dev = hci_open_dev(adapter->dev_id); + if (dev < 0) { + error("hci_open_dev(%d): %s (%d)", adapter->dev_id, + strerror(errno), errno); + return; + } + + str2ba(adapter->address, &sba); + str2ba(device->address, &dba); + + auth = adapter_find_auth_request(adapter, &dba); + + if (err) { + hci_send_cmd(dev, OGF_LINK_CTL, + OCF_PIN_CODE_NEG_REPLY, 6, &dba); + goto done; + } + + len = strlen(pincode); + + set_pin_length(&sba, len); + + memset(&pr, 0, sizeof(pr)); + bacpy(&pr.bdaddr, &dba); + memcpy(pr.pin_code, pincode, len); + pr.pin_len = len; + hci_send_cmd(dev, OGF_LINK_CTL, OCF_PIN_CODE_REPLY, PIN_CODE_REPLY_CP_SIZE, &pr); + +done: + if (auth) { + auth->replied = TRUE; + auth->agent = NULL; + } + hci_close_dev(dev); +} + +int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci) +{ + char addr[18]; + struct adapter *adapter; + struct device *device; + struct agent *agent; + int ret; + + adapter = manager_find_adapter(sba); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + if (!hcid_dbus_use_experimental()) + goto old_fallback; + + ba2str(&ci->bdaddr, addr); + + device = adapter_find_device(adapter, addr); + agent = device && device->agent ? device->agent : adapter->agent; + if (!agent) + goto old_fallback; + + if (!device) { + device = adapter_create_device(connection, adapter, addr); + if (!device) + return -ENODEV; + } + + ret = agent_request_pincode(agent, device, + (agent_pincode_cb) pincode_cb, + device); + if (ret == 0) { + struct pending_auth_info *auth; + auth = adapter_new_auth_request(adapter, &ci->bdaddr, + AUTH_TYPE_PINCODE); + auth->agent = agent; + } + + + return ret; + +old_fallback: + ret = handle_passkey_request_old(connection, dev, adapter, sba, + &ci->bdaddr); + if (ret == 0) + adapter_new_auth_request(adapter, &ci->bdaddr, + AUTH_TYPE_PINCODE); + return ret; +} + +static void confirm_cb(struct agent *agent, DBusError *err, void *user_data) +{ + struct device *device = user_data; + struct adapter *adapter = device->adapter; + user_confirm_reply_cp cp; + int dd; + struct pending_auth_info *auth; + + /* No need to reply anything if the authentication already failed */ + if (adapter->bonding && adapter->bonding->hci_status) + return; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("Unable to open hci%d", adapter->dev_id); + return; + } + + memset(&cp, 0, sizeof(cp)); + str2ba(device->address, &cp.bdaddr); + + auth = adapter_find_auth_request(adapter, &cp.bdaddr); + + if (err) + hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_CONFIRM_NEG_REPLY, + USER_CONFIRM_REPLY_CP_SIZE, &cp); + else + hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_CONFIRM_REPLY, + USER_CONFIRM_REPLY_CP_SIZE, &cp); + + if (auth) { + auth->replied = TRUE; + auth->agent = FALSE; + } + + hci_close_dev(dd); +} + +static void passkey_cb(struct agent *agent, DBusError *err, uint32_t passkey, + void *user_data) +{ + struct device *device = user_data; + struct adapter *adapter = device->adapter; + user_passkey_reply_cp cp; + bdaddr_t dba; + int dd; + struct pending_auth_info *auth; + + /* No need to reply anything if the authentication already failed */ + if (adapter->bonding && adapter->bonding->hci_status) + return; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("Unable to open hci%d", adapter->dev_id); + return; + } + + str2ba(device->address, &dba); + + memset(&cp, 0, sizeof(cp)); + bacpy(&cp.bdaddr, &dba); + cp.passkey = passkey; + + auth = adapter_find_auth_request(adapter, &dba); + + if (err) + hci_send_cmd(dd, OGF_LINK_CTL, + OCF_USER_PASSKEY_NEG_REPLY, 6, &dba); + else + hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_PASSKEY_REPLY, + USER_PASSKEY_REPLY_CP_SIZE, &cp); + + if (auth) { + auth->replied = TRUE; + auth->agent = NULL; + } + + hci_close_dev(dd); +} + +static int get_auth_requirements(bdaddr_t *local, bdaddr_t *remote, + uint8_t *auth) +{ + struct hci_auth_info_req req; + char addr[18]; + int err, dd, dev_id; + + ba2str(local, addr); + + dev_id = hci_devid(addr); + if (dev_id < 0) + return dev_id; + + dd = hci_open_dev(dev_id); + if (dd < 0) + return dd; + + memset(&req, 0, sizeof(req)); + bacpy(&req.bdaddr, remote); + + err = ioctl(dd, HCIGETAUTHINFO, (unsigned long) &req); + if (err < 0) { + debug("HCIGETAUTHINFO failed: %s (%d)", + strerror(errno), errno); + hci_close_dev(dd); + return err; + } + + hci_close_dev(dd); + + if (auth) + *auth = req.type; + + return 0; +} + +int hcid_dbus_user_confirm(bdaddr_t *sba, bdaddr_t *dba, uint32_t passkey) +{ + struct adapter *adapter; + struct device *device; + struct agent *agent; + char addr[18]; + uint8_t type; + struct pending_auth_info *auth; + + adapter = manager_find_adapter(sba); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + if (get_auth_requirements(sba, dba, &type) < 0) { + int dd; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("Unable to open hci%d", adapter->dev_id); + return -1; + } + + hci_send_cmd(dd, OGF_LINK_CTL, + OCF_USER_CONFIRM_NEG_REPLY, 6, dba); + + hci_close_dev(dd); + + return 0; + } + + ba2str(dba, addr); + + device = adapter_get_device(connection, adapter, addr); + if (!device) { + error("Device creation failed"); + return -1; + } + + /* If no MITM protection required, auto-accept */ + if (!(device->auth & 0x01) && !(type & 0x01)) { + int dd; + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("Unable to open hci%d", adapter->dev_id); + return -1; + } + + hci_send_cmd(dd, OGF_LINK_CTL, + OCF_USER_CONFIRM_REPLY, 6, dba); + + hci_close_dev(dd); + + return 0; + } + + if (device->agent) + agent = device->agent; + else + agent = adapter->agent; + + if (!agent) { + error("No agent available for user confirm request"); + return -1; + } + + if (agent_request_confirmation(agent, device, passkey, + confirm_cb, device) < 0) { + error("Requesting passkey failed"); + return -1; + } + + auth = adapter_new_auth_request(adapter, dba, AUTH_TYPE_CONFIRM); + auth->agent = agent; + + return 0; +} + +int hcid_dbus_user_passkey(bdaddr_t *sba, bdaddr_t *dba) +{ + struct adapter *adapter; + struct device *device; + struct agent *agent; + char addr[18]; + struct pending_auth_info *auth; + + adapter = manager_find_adapter(sba); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + ba2str(dba, addr); + + device = adapter_get_device(connection, adapter, addr); + if (device && device->agent) + agent = device->agent; + else + agent = adapter->agent; + + if (!agent) { + error("No agent available for user confirm request"); + return -1; + } + + if (agent_request_passkey(agent, device, passkey_cb, device) < 0) { + error("Requesting passkey failed"); + return -1; + } + + auth = adapter_new_auth_request(adapter, dba, AUTH_TYPE_PASSKEY); + auth->agent = agent; + + return 0; +} + +int hcid_dbus_user_notify(bdaddr_t *sba, bdaddr_t *dba, uint32_t passkey) +{ + struct adapter *adapter; + struct device *device; + struct agent *agent; + char addr[18]; + struct pending_auth_info *auth; + + adapter = manager_find_adapter(sba); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + ba2str(dba, addr); + + device = adapter_get_device(connection, adapter, addr); + if (device && device->agent) + agent = device->agent; + else + agent = adapter->agent; + + if (!agent) { + error("No agent available for user confirm request"); + return -1; + } + + if (agent_display_passkey(agent, device, passkey) < 0) { + error("Displaying passkey failed"); + return -1; + } + + auth = adapter_new_auth_request(adapter, dba, AUTH_TYPE_NOTIFY); + auth->agent = agent; + + return 0; +} + +void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, + uint8_t status) +{ + struct adapter *adapter; + char peer_addr[18]; + const char *paddr = peer_addr; + DBusMessage *reply; + struct device *device; + struct bonding_request_info *bonding; + gboolean paired = TRUE; + struct pending_auth_info *auth; + + debug("hcid_dbus_bonding_process_complete: status=%02x", status); + + ba2str(peer, peer_addr); + + adapter = manager_find_adapter(local); + if (!adapter) { + error("Unable to find matching adapter"); + return; + } + + if (status) { + if (adapter->bonding) + adapter->bonding->hci_status = status; + cancel_passkey_agent_requests(adapter->passkey_agents, + adapter->path, peer); + } + + auth = adapter_find_auth_request(adapter, peer); + if (!auth) { + debug("hcid_dbus_bonding_process_complete: no pending auth request"); + goto proceed; + } + + if (auth->agent) + agent_cancel(auth->agent); + + adapter_remove_auth_request(adapter, peer); + + if (status) + goto proceed; + + send_adapter_signal(connection, adapter->dev_id, "BondingCreated", + DBUS_TYPE_STRING, &paddr, DBUS_TYPE_INVALID); + + device = adapter_get_device(connection, adapter, paddr); + if (device) { + char *ptr = adapter->path + ADAPTER_PATH_INDEX; + + debug("hcid_dbus_bonding_process_complete: removing temporary flag"); + + device->temporary = FALSE; + + g_dbus_emit_signal(connection, ptr, + ADAPTER_INTERFACE, + "DeviceCreated", + DBUS_TYPE_OBJECT_PATH, + &device->path, + DBUS_TYPE_INVALID); + + dbus_connection_emit_property_changed(connection, device->path, + DEVICE_INTERFACE, "Paired", + DBUS_TYPE_BOOLEAN, &paired); + } + +proceed: + + release_passkey_agents(adapter, peer); + + bonding = adapter->bonding; + if (!bonding || bacmp(&bonding->bdaddr, peer)) + return; /* skip: no bonding req pending */ + + if (bonding->cancel) { + /* reply authentication canceled */ + error_authentication_canceled(connection, bonding->msg); + goto cleanup; + } + + /* reply authentication success or an error */ + if (dbus_message_is_method_call(bonding->msg, ADAPTER_INTERFACE, + "CreateBonding")) { + reply = new_authentication_return(bonding->msg, status); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + } else if ((device = adapter_find_device(adapter, paddr))) { + if (status) { + reply = new_authentication_return(bonding->msg, status); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + } else { + device->temporary = FALSE; + device_browse(device, bonding->conn, + bonding->msg, NULL); + } + } + +cleanup: + g_dbus_remove_watch(connection, adapter->bonding->listener_id); + + if (adapter->bonding->io_id) + g_source_remove(adapter->bonding->io_id); + g_io_channel_close(adapter->bonding->io); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; +} + +void hcid_dbus_inquiry_start(bdaddr_t *local) +{ + struct adapter *adapter; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("Unable to find matching adapter"); + return; + } + + 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; + + if (hcid_dbus_use_experimental()) + dbus_connection_emit_property_changed(connection, + adapter->path + ADAPTER_PATH_INDEX, + ADAPTER_INTERFACE, "PeriodicDiscovery", + DBUS_TYPE_BOOLEAN, &adapter->discov_active); + + send_adapter_signal(connection, adapter->dev_id, "DiscoveryStarted", + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) + g_dbus_emit_signal(connection, + adapter->path + ADAPTER_PATH_INDEX, + ADAPTER_INTERFACE, + "DiscoveryStarted", + DBUS_TYPE_INVALID); +} + +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; + GSList *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 = g_slist_find_custom(adapter->found_devices, &match, + (GCompareFunc) 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 { + struct remote_dev_info *dev = l->data; + char peer_addr[18]; + const char *signal = NULL, *paddr = peer_addr; + + /* flag to indicate the current remote name requested */ + dev->name_status = NAME_REQUESTED; + + memset(&rp, 0, sizeof(rp)); + memset(&cp, 0, sizeof(cp)); + bacpy(&cp.bdaddr, &dev->bdaddr); + cp.pscan_rep_mode = 0x02; + + ba2str(&dev->bdaddr, peer_addr); + + if (hci_send_req(dd, &rq, 500) < 0) { + error("Unable to send the HCI remote name request: %s (%d)", + strerror(errno), errno); + signal = "RemoteNameFailed"; + } + + if (rp.status) { + error("Remote name request failed with status 0x%02x", + rp.status); + signal = "RemoteNameFailed"; + } + + if (!signal) { + req_sent = 1; + /* if we are in discovery, inform application of getting name */ + if (adapter->discov_type & (STD_INQUIRY | PERIODIC_INQUIRY)) + signal = "RemoteNameRequested"; + } + + if (signal) + send_adapter_signal(connection, adapter->dev_id, signal, + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_INVALID); + + if (req_sent) + break; + + /* if failed, request the next element */ + /* remove the element from the list */ + adapter->found_devices = g_slist_remove(adapter->found_devices, dev); + g_free(dev); + + /* get the next element */ + l = g_slist_find_custom(adapter->found_devices, &match, + (GCompareFunc) 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, GSList *l) +{ + while (l) { + const char *peer_addr = l->data; + + g_dbus_emit_signal(connection, path, + ADAPTER_INTERFACE, + "RemoteDeviceDisappeared", + DBUS_TYPE_STRING, &peer_addr, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + const char *ptr = path + ADAPTER_PATH_INDEX; + g_dbus_emit_signal(connection, ptr, + ADAPTER_INTERFACE, + "DeviceDisappeared", + DBUS_TYPE_STRING, + &peer_addr, + DBUS_TYPE_INVALID); + } + + l = l->next; + } +} + +void hcid_dbus_inquiry_complete(bdaddr_t *local) +{ + struct adapter *adapter; + struct remote_dev_info *dev; + bdaddr_t tmp; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("Unable to find matching adapter"); + return; + } + + /* Out of range verification */ + if (adapter->pdiscov_active && !adapter->discov_active) { + GSList *l; + + send_out_of_range(adapter->path, adapter->oor_devices); + + g_slist_foreach(adapter->oor_devices, (GFunc) free, NULL); + g_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 = g_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)) + return; /* skip - there is name to resolve */ + + if (adapter->discov_active) { + if (hcid_dbus_use_experimental()) { + const char *ptr = adapter->path + ADAPTER_PATH_INDEX; + g_dbus_emit_signal(connection, ptr, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + + } + + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + adapter->discov_active = 0; + } + + /* free discovered devices list */ + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + if (adapter->discov_requestor) { + g_dbus_remove_watch(connection, adapter->discov_listener); + adapter->discov_listener = 0; + g_free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + + /* If there is a pending reply for discovery cancel */ + if (adapter->discovery_cancel) { + DBusMessage *reply; + reply = dbus_message_new_method_return(adapter->discovery_cancel); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + dbus_message_unref(adapter->discovery_cancel); + adapter->discovery_cancel = NULL; + } + + /* reset the discover type for standard inquiry only */ + adapter->discov_type &= ~STD_INQUIRY; + } +} + +void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status) +{ + struct adapter *adapter; + + /* Don't send the signal if the cmd failed */ + if (status) + return; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + adapter->pdiscov_active = 1; + + /* Disable name resolution for non D-Bus clients */ + if (!adapter->pdiscov_requestor) + adapter->discov_type &= ~RESOLVE_NAME; + + if (hcid_dbus_use_experimental()) + dbus_connection_emit_property_changed(connection, + adapter->path + ADAPTER_PATH_INDEX, + ADAPTER_INTERFACE, + "PeriodicDiscovery", + DBUS_TYPE_BOOLEAN, + &adapter->pdiscov_active); + + g_dbus_emit_signal(connection, adapter->path, ADAPTER_INTERFACE, + "PeriodicDiscoveryStarted", + DBUS_TYPE_INVALID); +} + +void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status) +{ + struct adapter *adapter; + char *ptr; + + /* Don't send the signal if the cmd failed */ + if (status) + return; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + ptr = adapter->path + ADAPTER_PATH_INDEX; + + /* 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 */ + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_slist_free(adapter->found_devices); + adapter->found_devices = NULL; + + /* free out of range devices list */ + g_slist_foreach(adapter->oor_devices, (GFunc) free, NULL); + g_slist_free(adapter->oor_devices); + adapter->oor_devices = NULL; + + if (adapter->pdiscov_requestor) { + g_dbus_remove_watch(connection, adapter->pdiscov_listener); + adapter->pdiscov_listener = 0; + g_free(adapter->pdiscov_requestor); + adapter->pdiscov_requestor = NULL; + } + + /* workaround: inquiry completed is not sent when exiting from + * periodic inquiry */ + if (adapter->discov_active) { + if (hcid_dbus_use_experimental()) + g_dbus_emit_signal(connection, ptr, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + adapter->discov_active = 0; + } + + /* Send discovery completed signal if there isn't name to resolve */ + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "PeriodicDiscoveryStopped", + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) + dbus_connection_emit_property_changed(connection, ptr, + ADAPTER_INTERFACE, + "PeriodicDiscovery", + DBUS_TYPE_BOOLEAN, + &adapter->discov_active); +} + +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; +} + +static void append_dict_valist(DBusMessageIter *iter, + const char *first_key, + va_list var_args) +{ + DBusMessageIter dict; + const char *key; + int type; + void *val; + + dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); + + key = first_key; + while (key) { + type = va_arg(var_args, int); + val = va_arg(var_args, void *); + dbus_message_iter_append_dict_entry(&dict, key, type, val); + key = va_arg(var_args, char *); + } + + dbus_message_iter_close_container(iter, &dict); +} + +static void emit_device_found(const char *path, const char *address, + const char *first_key, ...) +{ + DBusMessage *signal; + DBusMessageIter iter; + va_list var_args; + + signal = dbus_message_new_signal(path, ADAPTER_INTERFACE, + "DeviceFound"); + if (!signal) { + error("Unable to allocate new %s.DeviceFound signal", + ADAPTER_INTERFACE); + return; + } + dbus_message_iter_init_append(signal, &iter); + dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &address); + + va_start(var_args, first_key); + append_dict_valist(&iter, first_key, var_args); + va_end(var_args); + + dbus_connection_send(connection, signal, NULL); + + dbus_message_unref(signal); +} + +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]; + struct adapter *adapter; + GSList *l; + char local_addr[18], peer_addr[18], *name, *tmp_name; + const char *paddr = peer_addr; + struct remote_dev_info match; + dbus_int16_t tmp_rssi = rssi; + uint8_t name_type = 0x00; + name_status_t name_status; + + ba2str(local, local_addr); + ba2str(peer, peer_addr); + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + write_remote_class(local, peer, class); + + if (data) + write_remote_eir(local, peer, data); + + /* + * 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 = g_slist_find_custom(adapter->oor_devices, peer_addr, + (GCompareFunc) strcmp); + if (l) { + char *dev = l->data; + adapter->oor_devices = g_slist_remove(adapter->oor_devices, + dev); + g_free(dev); + } + } + + /* send the device found signal */ + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteDeviceFound", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_UINT32, &class, + DBUS_TYPE_INT16, &tmp_rssi, + DBUS_TYPE_INVALID); + + memset(&match, 0, sizeof(struct remote_dev_info)); + bacpy(&match.bdaddr, peer); + match.name_status = NAME_SENT; + /* if found: don't send the name again */ + l = g_slist_find_custom(adapter->found_devices, &match, + (GCompareFunc) found_device_cmp); + if (l) + return; + + /* 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) + g_free(name); + + name = tmp_name; + } else { + if (name) + free(tmp_name); + else + name = tmp_name; + } + } + + if (name) { + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteNameUpdated", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + + if (name_type != 0x08) + name_status = NAME_SENT; + + if (hcid_dbus_use_experimental()) { + emit_device_found(adapter->path + ADAPTER_PATH_INDEX, + paddr, + "Address", DBUS_TYPE_STRING, &paddr, + "Class", DBUS_TYPE_UINT32, &class, + "RSSI", DBUS_TYPE_INT16, &tmp_rssi, + "Name", DBUS_TYPE_STRING, &name, + NULL); + } + + g_free(name); + } else if (hcid_dbus_use_experimental()) { + emit_device_found(adapter->path + ADAPTER_PATH_INDEX, + paddr, + "Address", DBUS_TYPE_STRING, &paddr, + "Class", DBUS_TYPE_UINT32, &class, + "RSSI", DBUS_TYPE_INT16, &tmp_rssi, + NULL); + } + + /* add in the list to track name sent/pending */ + found_device_add(&adapter->found_devices, peer, rssi, name_status); +} + +void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class) +{ + char peer_addr[18]; + const char *paddr = peer_addr; + uint32_t old_class = 0; + struct adapter *adapter; + + read_remote_class(local, peer, &old_class); + + if (old_class == class) + return; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + ba2str(peer, peer_addr); + + send_adapter_signal(connection, adapter->dev_id, + "RemoteClassUpdated", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_UINT32, &class, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + GSList *l; + struct device *device; + + l = g_slist_find_custom(adapter->devices, paddr, + (GCompareFunc) device_address_cmp); + if (!l) + return; + + device = l->data; + dbus_connection_emit_property_changed(connection, + device->path, DEVICE_INTERFACE, + "Class", DBUS_TYPE_UINT32, &class); + } +} + +void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, + char *name) +{ + struct adapter *adapter; + char peer_addr[18]; + const char *paddr = peer_addr; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + ba2str(peer, peer_addr); + + if (status) + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteNameFailed", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_INVALID); + else { + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteNameUpdated", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + struct device *device; + + device = adapter_find_device(adapter, paddr); + if (device) { + dbus_connection_emit_property_changed(connection, + device->path, DEVICE_INTERFACE, + "Name", DBUS_TYPE_STRING, &name); + } + } + } + + /* 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)) + return; /* skip if a new request has been sent */ + + /* free discovered devices list */ + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_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) { + g_dbus_remove_watch(connection, adapter->discov_listener); + adapter->discov_listener = 0; + g_free(adapter->discov_requestor); + adapter->discov_requestor = NULL; + + /* If there is a pending reply for discovery cancel */ + if (adapter->discovery_cancel) { + DBusMessage *reply; + reply = dbus_message_new_method_return(adapter->discovery_cancel); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + 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) { + if (hcid_dbus_use_experimental()) + g_dbus_emit_signal(connection, + adapter->path + ADAPTER_PATH_INDEX, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "DiscoveryCompleted", + DBUS_TYPE_INVALID); + adapter->discov_active = 0; + } +} + +void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, + bdaddr_t *peer) +{ + char peer_addr[18]; + const char *paddr = peer_addr; + struct adapter *adapter; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + ba2str(peer, peer_addr); + + if (status) { + struct pending_auth_info *auth; + + cancel_passkey_agent_requests(adapter->passkey_agents, + adapter->path, peer); + release_passkey_agents(adapter, peer); + + auth = adapter_find_auth_request(adapter, peer); + if (auth && auth->agent) + agent_cancel(auth->agent); + + adapter_remove_auth_request(adapter, peer); + + if (adapter->bonding) + adapter->bonding->hci_status = status; + } else { + /* Send the remote device connected signal */ + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteDeviceConnected", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_INVALID); + + if (hcid_dbus_use_experimental()) { + struct device *device; + gboolean connected = TRUE; + + device = adapter_find_device(adapter, paddr); + if (device) { + dbus_connection_emit_property_changed(connection, + device->path, DEVICE_INTERFACE, + "Connected", DBUS_TYPE_BOOLEAN, + &connected); + } + } + + /* add in the active connetions list */ + active_conn_append(&adapter->active_conn, peer, handle); + } +} + +void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, + uint16_t handle, uint8_t reason) +{ + DBusMessage *reply; + char peer_addr[18]; + const char *paddr = peer_addr; + struct adapter *adapter; + struct device *device; + struct active_conn_info *dev; + GSList *l; + gboolean connected = FALSE; + struct pending_auth_info *auth; + + if (status) { + error("Disconnection failed: 0x%02x", status); + return; + } + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + l = g_slist_find_custom(adapter->active_conn, &handle, + active_conn_find_by_handle); + + if (!l) + return; + + dev = l->data; + + ba2str(&dev->bdaddr, peer_addr); + + /* 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, adapter->path, + &dev->bdaddr); + release_passkey_agents(adapter, &dev->bdaddr); + + auth = adapter_find_auth_request(adapter, &dev->bdaddr); + if (auth && auth->agent) + agent_cancel(auth->agent); + + adapter_remove_auth_request(adapter, &dev->bdaddr); + + /* 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->msg); + } else { + reply = new_authentication_return(adapter->bonding->msg, + HCI_AUTHENTICATION_FAILURE); + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + } + + g_dbus_remove_watch(adapter->bonding->conn, + adapter->bonding->listener_id); + + if (adapter->bonding->io_id) + g_source_remove(adapter->bonding->io_id); + g_io_channel_close(adapter->bonding->io); + bonding_request_free(adapter->bonding); + adapter->bonding = NULL; + } + + /* Check if there is a pending RemoteDeviceDisconnect request */ + if (adapter->pending_dc) { + reply = dbus_message_new_method_return(adapter->pending_dc->msg); + if (reply) { + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + } else + error("Failed to allocate disconnect reply"); + + g_source_remove(adapter->pending_dc->timeout_id); + dc_pending_timeout_cleanup(adapter); + } + + /* Send the remote device disconnected signal */ + g_dbus_emit_signal(connection, adapter->path, + ADAPTER_INTERFACE, + "RemoteDeviceDisconnected", + DBUS_TYPE_STRING, &paddr, + DBUS_TYPE_INVALID); + + adapter->active_conn = g_slist_remove(adapter->active_conn, dev); + g_free(dev); + + device = adapter_find_device(adapter, paddr); + if (device) { + dbus_connection_emit_property_changed(connection, + device->path, DEVICE_INTERFACE, + "Connected", DBUS_TYPE_BOOLEAN, + &connected); + if (device->temporary) { + debug("Removing temporary device %s", device->address); + adapter_remove_device(connection, adapter, device); + } + } +} + +int set_limited_discoverable(int dd, const uint8_t *cls, gboolean limited) +{ + uint32_t dev_class; + int err; + int num = (limited ? 2 : 1); + uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e }; + /* + * 1: giac + * 2: giac + liac + */ + if (hci_write_current_iac_lap(dd, num, lap, 1000) < 0) { + err = errno; + error("Can't write current IAC LAP: %s(%d)", + strerror(err), err); + return -err; + } + + if (limited) { + if (cls[1] & 0x20) + return 0; /* Already limited */ + + dev_class = (cls[2] << 16) | ((cls[1] | 0x20) << 8) | cls[0]; + } else { + if (!(cls[1] & 0x20)) + return 0; /* Already clear */ + + dev_class = (cls[2] << 16) | ((cls[1] & 0xdf) << 8) | cls[0]; + } + + if (hci_write_class_of_dev(dd, dev_class, 1000) < 0) { + err = errno; + error("Can't write class of device: %s (%d)", + strerror(err), err); + return -err; + } + + return 0; +} + +int set_service_classes(int dd, const uint8_t *cls, uint8_t value) +{ + uint32_t dev_class; + int err; + + if (cls[2] == value) + return 0; /* Already set */ + + dev_class = (value << 16) | (cls[1] << 8) | cls[0]; + + if (hci_write_class_of_dev(dd, dev_class, 1000) < 0) { + err = errno; + error("Can't write class of device: %s (%d)", + strerror(err), err); + return -err; + } + + return 0; +} + +gboolean discov_timeout_handler(void *data) +{ + struct adapter *adapter = data; + struct hci_request rq; + int dd; + uint8_t scan_enable = adapter->scan_enable; + uint8_t status = 0; + gboolean retval = TRUE; + + scan_enable &= ~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 = &scan_enable; + rq.clen = sizeof(scan_enable); + 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; + } + + set_limited_discoverable(dd, adapter->class, FALSE); + + 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) +{ + int id, dd = -1; + read_local_name_rp rp; + struct hci_request rq; + const char *pname = (char *) rp.name; + char local_addr[18], name[249]; + + ba2str(local, local_addr); + + id = hci_devid(local_addr); + if (id < 0) { + error("No matching device id for %s", local_addr); + return; + } + + 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'; + } else if (rp.status) { + error("Getting name failed with status 0x%02x", + rp.status); + rp.name[0] = '\0'; + } + hci_close_dev(dd); + } + + strncpy(name, pname, sizeof(name) - 1); + name[248] = '\0'; + pname = name; + + send_adapter_signal(connection, id, "NameChanged", + DBUS_TYPE_STRING, &pname, DBUS_TYPE_INVALID); +} + +void hcid_dbus_setscan_enable_complete(bdaddr_t *local) +{ + struct adapter *adapter; + read_scan_enable_rp rp; + struct hci_request rq; + int dd = -1; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("HCI device open failed: hci%d", adapter->dev_id); + return; + } + + 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 (adapter->timeout_id) { + g_source_remove(adapter->timeout_id); + adapter->timeout_id = 0; + } + + if (adapter->scan_enable != rp.enable) + adapter_mode_changed(adapter, rp.enable); + +failed: + if (dd >= 0) + hci_close_dev(dd); +} + +void hcid_dbus_write_class_complete(bdaddr_t *local) +{ + struct adapter *adapter; + int dd; + uint8_t cls[3]; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return; + } + + dd = hci_open_dev(adapter->dev_id); + if (dd < 0) { + error("HCI device open failed: hci%d", adapter->dev_id); + return; + } + + if (hci_read_class_of_dev(dd, cls, 1000) < 0) { + error("Can't read class of device on hci%d: %s (%d)", + adapter->dev_id, strerror(errno), errno); + hci_close_dev(dd); + return; + } + + write_local_class(local, cls); + set_device_class(adapter->dev_id, cls); + memcpy(adapter->class, cls, 3); + + hci_close_dev(dd); +} + +void hcid_dbus_write_simple_pairing_mode_complete(bdaddr_t *local) +{ + char addr[18]; + int dev_id, dd; + uint8_t mode; + + ba2str(local, addr); + + dev_id = hci_devid(addr); + if (dev_id < 0) { + error("No matching device id for %s", addr); + return; + } + + dd = hci_open_dev(dev_id); + if (dd < 0) { + error("HCI device open failed: hci%d", dev_id); + return; + } + + if (hci_read_simple_pairing_mode(dd, &mode, 1000) < 0) { + error("Can't read class of device on hci%d: %s(%d)", + dev_id, strerror(errno), errno); + hci_close_dev(dd); + return; + } + + set_simple_pairing_mode(dev_id, mode); + + hci_close_dev(dd); +} + +int hcid_dbus_get_io_cap(bdaddr_t *local, bdaddr_t *remote, + uint8_t *cap, uint8_t *auth) +{ + struct adapter *adapter; + struct device *device; + struct agent *agent; + char addr[18]; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + if (get_auth_requirements(local, remote, auth) < 0) + return -1; + + ba2str(remote, addr); + + device = adapter_find_device(adapter, addr); + if (device && device->agent) { + agent = device->agent; + *auth = 0x03; + } else + agent = adapter->agent; + + if (!agent) { + if (!(*auth & 0x01)) { + /* No input, no output */ + *cap = 0x03; + return 0; + } + error("No agent available for IO capability"); + return -1; + } + + *cap = agent_get_io_capability(agent); + + return 0; +} + +int hcid_dbus_set_io_cap(bdaddr_t *local, bdaddr_t *remote, + uint8_t cap, uint8_t auth) +{ + struct adapter *adapter; + struct device *device; + char addr[18]; + + adapter = manager_find_adapter(local); + if (!adapter) { + error("No matching adapter found"); + return -1; + } + + ba2str(remote, addr); + + device = adapter_get_device(connection, adapter, addr); + if (device) { + device->cap = cap; + device->auth = auth; + } + + return 0; +} + +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; + GSList *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 = g_slist_find_custom(adapter->found_devices, &match, + (GCompareFunc) 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. + */ + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_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; +} + +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; + GSList *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 = g_slist_find_custom(adapter->found_devices, &match, + (GCompareFunc) 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. + */ + g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL); + g_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; +} |