| /* |
| BlueZ - Bluetooth protocol stack for Linux |
| |
| Copyright (C) 2010 Nokia Corporation |
| Copyright (C) 2011-2012 Intel Corporation |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License version 2 as |
| published by the Free Software Foundation; |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. |
| IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY |
| CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES |
| WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| |
| ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, |
| COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS |
| SOFTWARE IS DISCLAIMED. |
| */ |
| |
| /* Bluetooth HCI Management interface */ |
| |
| #include <linux/module.h> |
| #include <asm/unaligned.h> |
| |
| #include <net/bluetooth/bluetooth.h> |
| #include <net/bluetooth/hci_core.h> |
| #include <net/bluetooth/hci_sock.h> |
| #include <net/bluetooth/l2cap.h> |
| #include <net/bluetooth/mgmt.h> |
| |
| #include "hci_request.h" |
| #include "smp.h" |
| #include "mgmt_util.h" |
| |
| #define MGMT_VERSION 1 |
| #define MGMT_REVISION 11 |
| |
| static const u16 mgmt_commands[] = { |
| MGMT_OP_READ_INDEX_LIST, |
| MGMT_OP_READ_INFO, |
| MGMT_OP_SET_POWERED, |
| MGMT_OP_SET_DISCOVERABLE, |
| MGMT_OP_SET_CONNECTABLE, |
| MGMT_OP_SET_FAST_CONNECTABLE, |
| MGMT_OP_SET_BONDABLE, |
| MGMT_OP_SET_LINK_SECURITY, |
| MGMT_OP_SET_SSP, |
| MGMT_OP_SET_HS, |
| MGMT_OP_SET_LE, |
| MGMT_OP_SET_DEV_CLASS, |
| MGMT_OP_SET_LOCAL_NAME, |
| MGMT_OP_ADD_UUID, |
| MGMT_OP_REMOVE_UUID, |
| MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_OP_LOAD_LONG_TERM_KEYS, |
| MGMT_OP_DISCONNECT, |
| MGMT_OP_GET_CONNECTIONS, |
| MGMT_OP_PIN_CODE_REPLY, |
| MGMT_OP_PIN_CODE_NEG_REPLY, |
| MGMT_OP_SET_IO_CAPABILITY, |
| MGMT_OP_PAIR_DEVICE, |
| MGMT_OP_CANCEL_PAIR_DEVICE, |
| MGMT_OP_UNPAIR_DEVICE, |
| MGMT_OP_USER_CONFIRM_REPLY, |
| MGMT_OP_USER_CONFIRM_NEG_REPLY, |
| MGMT_OP_USER_PASSKEY_REPLY, |
| MGMT_OP_USER_PASSKEY_NEG_REPLY, |
| MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_OP_ADD_REMOTE_OOB_DATA, |
| MGMT_OP_REMOVE_REMOTE_OOB_DATA, |
| MGMT_OP_START_DISCOVERY, |
| MGMT_OP_STOP_DISCOVERY, |
| MGMT_OP_CONFIRM_NAME, |
| MGMT_OP_BLOCK_DEVICE, |
| MGMT_OP_UNBLOCK_DEVICE, |
| MGMT_OP_SET_DEVICE_ID, |
| MGMT_OP_SET_ADVERTISING, |
| MGMT_OP_SET_BREDR, |
| MGMT_OP_SET_STATIC_ADDRESS, |
| MGMT_OP_SET_SCAN_PARAMS, |
| MGMT_OP_SET_SECURE_CONN, |
| MGMT_OP_SET_DEBUG_KEYS, |
| MGMT_OP_SET_PRIVACY, |
| MGMT_OP_LOAD_IRKS, |
| MGMT_OP_GET_CONN_INFO, |
| MGMT_OP_GET_CLOCK_INFO, |
| MGMT_OP_ADD_DEVICE, |
| MGMT_OP_REMOVE_DEVICE, |
| MGMT_OP_LOAD_CONN_PARAM, |
| MGMT_OP_READ_UNCONF_INDEX_LIST, |
| MGMT_OP_READ_CONFIG_INFO, |
| MGMT_OP_SET_EXTERNAL_CONFIG, |
| MGMT_OP_SET_PUBLIC_ADDRESS, |
| MGMT_OP_START_SERVICE_DISCOVERY, |
| MGMT_OP_READ_LOCAL_OOB_EXT_DATA, |
| MGMT_OP_READ_EXT_INDEX_LIST, |
| MGMT_OP_READ_ADV_FEATURES, |
| MGMT_OP_ADD_ADVERTISING, |
| MGMT_OP_REMOVE_ADVERTISING, |
| MGMT_OP_GET_ADV_SIZE_INFO, |
| MGMT_OP_START_LIMITED_DISCOVERY, |
| }; |
| |
| static const u16 mgmt_events[] = { |
| MGMT_EV_CONTROLLER_ERROR, |
| MGMT_EV_INDEX_ADDED, |
| MGMT_EV_INDEX_REMOVED, |
| MGMT_EV_NEW_SETTINGS, |
| MGMT_EV_CLASS_OF_DEV_CHANGED, |
| MGMT_EV_LOCAL_NAME_CHANGED, |
| MGMT_EV_NEW_LINK_KEY, |
| MGMT_EV_NEW_LONG_TERM_KEY, |
| MGMT_EV_DEVICE_CONNECTED, |
| MGMT_EV_DEVICE_DISCONNECTED, |
| MGMT_EV_CONNECT_FAILED, |
| MGMT_EV_PIN_CODE_REQUEST, |
| MGMT_EV_USER_CONFIRM_REQUEST, |
| MGMT_EV_USER_PASSKEY_REQUEST, |
| MGMT_EV_AUTH_FAILED, |
| MGMT_EV_DEVICE_FOUND, |
| MGMT_EV_DISCOVERING, |
| MGMT_EV_DEVICE_BLOCKED, |
| MGMT_EV_DEVICE_UNBLOCKED, |
| MGMT_EV_DEVICE_UNPAIRED, |
| MGMT_EV_PASSKEY_NOTIFY, |
| MGMT_EV_NEW_IRK, |
| MGMT_EV_NEW_CSRK, |
| MGMT_EV_DEVICE_ADDED, |
| MGMT_EV_DEVICE_REMOVED, |
| MGMT_EV_NEW_CONN_PARAM, |
| MGMT_EV_UNCONF_INDEX_ADDED, |
| MGMT_EV_UNCONF_INDEX_REMOVED, |
| MGMT_EV_NEW_CONFIG_OPTIONS, |
| MGMT_EV_EXT_INDEX_ADDED, |
| MGMT_EV_EXT_INDEX_REMOVED, |
| MGMT_EV_LOCAL_OOB_DATA_UPDATED, |
| MGMT_EV_ADVERTISING_ADDED, |
| MGMT_EV_ADVERTISING_REMOVED, |
| }; |
| |
| static const u16 mgmt_untrusted_commands[] = { |
| MGMT_OP_READ_INDEX_LIST, |
| MGMT_OP_READ_INFO, |
| MGMT_OP_READ_UNCONF_INDEX_LIST, |
| MGMT_OP_READ_CONFIG_INFO, |
| MGMT_OP_READ_EXT_INDEX_LIST, |
| }; |
| |
| static const u16 mgmt_untrusted_events[] = { |
| MGMT_EV_INDEX_ADDED, |
| MGMT_EV_INDEX_REMOVED, |
| MGMT_EV_NEW_SETTINGS, |
| MGMT_EV_CLASS_OF_DEV_CHANGED, |
| MGMT_EV_LOCAL_NAME_CHANGED, |
| MGMT_EV_UNCONF_INDEX_ADDED, |
| MGMT_EV_UNCONF_INDEX_REMOVED, |
| MGMT_EV_NEW_CONFIG_OPTIONS, |
| MGMT_EV_EXT_INDEX_ADDED, |
| MGMT_EV_EXT_INDEX_REMOVED, |
| }; |
| |
| #define CACHE_TIMEOUT msecs_to_jiffies(2 * 1000) |
| |
| #define ZERO_KEY "\x00\x00\x00\x00\x00\x00\x00\x00" \ |
| "\x00\x00\x00\x00\x00\x00\x00\x00" |
| |
| /* HCI to MGMT error code conversion table */ |
| static u8 mgmt_status_table[] = { |
| MGMT_STATUS_SUCCESS, |
| MGMT_STATUS_UNKNOWN_COMMAND, /* Unknown Command */ |
| MGMT_STATUS_NOT_CONNECTED, /* No Connection */ |
| MGMT_STATUS_FAILED, /* Hardware Failure */ |
| MGMT_STATUS_CONNECT_FAILED, /* Page Timeout */ |
| MGMT_STATUS_AUTH_FAILED, /* Authentication Failed */ |
| MGMT_STATUS_AUTH_FAILED, /* PIN or Key Missing */ |
| MGMT_STATUS_NO_RESOURCES, /* Memory Full */ |
| MGMT_STATUS_TIMEOUT, /* Connection Timeout */ |
| MGMT_STATUS_NO_RESOURCES, /* Max Number of Connections */ |
| MGMT_STATUS_NO_RESOURCES, /* Max Number of SCO Connections */ |
| MGMT_STATUS_ALREADY_CONNECTED, /* ACL Connection Exists */ |
| MGMT_STATUS_BUSY, /* Command Disallowed */ |
| MGMT_STATUS_NO_RESOURCES, /* Rejected Limited Resources */ |
| MGMT_STATUS_REJECTED, /* Rejected Security */ |
| MGMT_STATUS_REJECTED, /* Rejected Personal */ |
| MGMT_STATUS_TIMEOUT, /* Host Timeout */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Feature */ |
| MGMT_STATUS_INVALID_PARAMS, /* Invalid Parameters */ |
| MGMT_STATUS_DISCONNECTED, /* OE User Ended Connection */ |
| MGMT_STATUS_NO_RESOURCES, /* OE Low Resources */ |
| MGMT_STATUS_DISCONNECTED, /* OE Power Off */ |
| MGMT_STATUS_DISCONNECTED, /* Connection Terminated */ |
| MGMT_STATUS_BUSY, /* Repeated Attempts */ |
| MGMT_STATUS_REJECTED, /* Pairing Not Allowed */ |
| MGMT_STATUS_FAILED, /* Unknown LMP PDU */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Remote Feature */ |
| MGMT_STATUS_REJECTED, /* SCO Offset Rejected */ |
| MGMT_STATUS_REJECTED, /* SCO Interval Rejected */ |
| MGMT_STATUS_REJECTED, /* Air Mode Rejected */ |
| MGMT_STATUS_INVALID_PARAMS, /* Invalid LMP Parameters */ |
| MGMT_STATUS_FAILED, /* Unspecified Error */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Unsupported LMP Parameter Value */ |
| MGMT_STATUS_FAILED, /* Role Change Not Allowed */ |
| MGMT_STATUS_TIMEOUT, /* LMP Response Timeout */ |
| MGMT_STATUS_FAILED, /* LMP Error Transaction Collision */ |
| MGMT_STATUS_FAILED, /* LMP PDU Not Allowed */ |
| MGMT_STATUS_REJECTED, /* Encryption Mode Not Accepted */ |
| MGMT_STATUS_FAILED, /* Unit Link Key Used */ |
| MGMT_STATUS_NOT_SUPPORTED, /* QoS Not Supported */ |
| MGMT_STATUS_TIMEOUT, /* Instant Passed */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Pairing Not Supported */ |
| MGMT_STATUS_FAILED, /* Transaction Collision */ |
| MGMT_STATUS_INVALID_PARAMS, /* Unacceptable Parameter */ |
| MGMT_STATUS_REJECTED, /* QoS Rejected */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Classification Not Supported */ |
| MGMT_STATUS_REJECTED, /* Insufficient Security */ |
| MGMT_STATUS_INVALID_PARAMS, /* Parameter Out Of Range */ |
| MGMT_STATUS_BUSY, /* Role Switch Pending */ |
| MGMT_STATUS_FAILED, /* Slot Violation */ |
| MGMT_STATUS_FAILED, /* Role Switch Failed */ |
| MGMT_STATUS_INVALID_PARAMS, /* EIR Too Large */ |
| MGMT_STATUS_NOT_SUPPORTED, /* Simple Pairing Not Supported */ |
| MGMT_STATUS_BUSY, /* Host Busy Pairing */ |
| MGMT_STATUS_REJECTED, /* Rejected, No Suitable Channel */ |
| MGMT_STATUS_BUSY, /* Controller Busy */ |
| MGMT_STATUS_INVALID_PARAMS, /* Unsuitable Connection Interval */ |
| MGMT_STATUS_TIMEOUT, /* Directed Advertising Timeout */ |
| MGMT_STATUS_AUTH_FAILED, /* Terminated Due to MIC Failure */ |
| MGMT_STATUS_CONNECT_FAILED, /* Connection Establishment Failed */ |
| MGMT_STATUS_CONNECT_FAILED, /* MAC Connection Failed */ |
| }; |
| |
| static u8 mgmt_status(u8 hci_status) |
| { |
| if (hci_status < ARRAY_SIZE(mgmt_status_table)) |
| return mgmt_status_table[hci_status]; |
| |
| return MGMT_STATUS_FAILED; |
| } |
| |
| static int mgmt_index_event(u16 event, struct hci_dev *hdev, void *data, |
| u16 len, int flag) |
| { |
| return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len, |
| flag, NULL); |
| } |
| |
| static int mgmt_limited_event(u16 event, struct hci_dev *hdev, void *data, |
| u16 len, int flag, struct sock *skip_sk) |
| { |
| return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len, |
| flag, skip_sk); |
| } |
| |
| static int mgmt_generic_event(u16 event, struct hci_dev *hdev, void *data, |
| u16 len, struct sock *skip_sk) |
| { |
| return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len, |
| HCI_MGMT_GENERIC_EVENTS, skip_sk); |
| } |
| |
| static int mgmt_event(u16 event, struct hci_dev *hdev, void *data, u16 len, |
| struct sock *skip_sk) |
| { |
| return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len, |
| HCI_SOCK_TRUSTED, skip_sk); |
| } |
| |
| static u8 le_addr_type(u8 mgmt_addr_type) |
| { |
| if (mgmt_addr_type == BDADDR_LE_PUBLIC) |
| return ADDR_LE_DEV_PUBLIC; |
| else |
| return ADDR_LE_DEV_RANDOM; |
| } |
| |
| static int read_version(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 data_len) |
| { |
| struct mgmt_rp_read_version rp; |
| |
| BT_DBG("sock %p", sk); |
| |
| rp.version = MGMT_VERSION; |
| rp.revision = cpu_to_le16(MGMT_REVISION); |
| |
| return mgmt_cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_VERSION, 0, |
| &rp, sizeof(rp)); |
| } |
| |
| static int read_commands(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 data_len) |
| { |
| struct mgmt_rp_read_commands *rp; |
| u16 num_commands, num_events; |
| size_t rp_size; |
| int i, err; |
| |
| BT_DBG("sock %p", sk); |
| |
| if (hci_sock_test_flag(sk, HCI_SOCK_TRUSTED)) { |
| num_commands = ARRAY_SIZE(mgmt_commands); |
| num_events = ARRAY_SIZE(mgmt_events); |
| } else { |
| num_commands = ARRAY_SIZE(mgmt_untrusted_commands); |
| num_events = ARRAY_SIZE(mgmt_untrusted_events); |
| } |
| |
| rp_size = sizeof(*rp) + ((num_commands + num_events) * sizeof(u16)); |
| |
| rp = kmalloc(rp_size, GFP_KERNEL); |
| if (!rp) |
| return -ENOMEM; |
| |
| rp->num_commands = cpu_to_le16(num_commands); |
| rp->num_events = cpu_to_le16(num_events); |
| |
| if (hci_sock_test_flag(sk, HCI_SOCK_TRUSTED)) { |
| __le16 *opcode = rp->opcodes; |
| |
| for (i = 0; i < num_commands; i++, opcode++) |
| put_unaligned_le16(mgmt_commands[i], opcode); |
| |
| for (i = 0; i < num_events; i++, opcode++) |
| put_unaligned_le16(mgmt_events[i], opcode); |
| } else { |
| __le16 *opcode = rp->opcodes; |
| |
| for (i = 0; i < num_commands; i++, opcode++) |
| put_unaligned_le16(mgmt_untrusted_commands[i], opcode); |
| |
| for (i = 0; i < num_events; i++, opcode++) |
| put_unaligned_le16(mgmt_untrusted_events[i], opcode); |
| } |
| |
| err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_COMMANDS, 0, |
| rp, rp_size); |
| kfree(rp); |
| |
| return err; |
| } |
| |
| static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 data_len) |
| { |
| struct mgmt_rp_read_index_list *rp; |
| struct hci_dev *d; |
| size_t rp_len; |
| u16 count; |
| int err; |
| |
| BT_DBG("sock %p", sk); |
| |
| read_lock(&hci_dev_list_lock); |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (d->dev_type == HCI_BREDR && |
| !hci_dev_test_flag(d, HCI_UNCONFIGURED)) |
| count++; |
| } |
| |
| rp_len = sizeof(*rp) + (2 * count); |
| rp = kmalloc(rp_len, GFP_ATOMIC); |
| if (!rp) { |
| read_unlock(&hci_dev_list_lock); |
| return -ENOMEM; |
| } |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (hci_dev_test_flag(d, HCI_SETUP) || |
| hci_dev_test_flag(d, HCI_CONFIG) || |
| hci_dev_test_flag(d, HCI_USER_CHANNEL)) |
| continue; |
| |
| /* Devices marked as raw-only are neither configured |
| * nor unconfigured controllers. |
| */ |
| if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks)) |
| continue; |
| |
| if (d->dev_type == HCI_BREDR && |
| !hci_dev_test_flag(d, HCI_UNCONFIGURED)) { |
| rp->index[count++] = cpu_to_le16(d->id); |
| BT_DBG("Added hci%u", d->id); |
| } |
| } |
| |
| rp->num_controllers = cpu_to_le16(count); |
| rp_len = sizeof(*rp) + (2 * count); |
| |
| read_unlock(&hci_dev_list_lock); |
| |
| err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_INDEX_LIST, |
| 0, rp, rp_len); |
| |
| kfree(rp); |
| |
| return err; |
| } |
| |
| static int read_unconf_index_list(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 data_len) |
| { |
| struct mgmt_rp_read_unconf_index_list *rp; |
| struct hci_dev *d; |
| size_t rp_len; |
| u16 count; |
| int err; |
| |
| BT_DBG("sock %p", sk); |
| |
| read_lock(&hci_dev_list_lock); |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (d->dev_type == HCI_BREDR && |
| hci_dev_test_flag(d, HCI_UNCONFIGURED)) |
| count++; |
| } |
| |
| rp_len = sizeof(*rp) + (2 * count); |
| rp = kmalloc(rp_len, GFP_ATOMIC); |
| if (!rp) { |
| read_unlock(&hci_dev_list_lock); |
| return -ENOMEM; |
| } |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (hci_dev_test_flag(d, HCI_SETUP) || |
| hci_dev_test_flag(d, HCI_CONFIG) || |
| hci_dev_test_flag(d, HCI_USER_CHANNEL)) |
| continue; |
| |
| /* Devices marked as raw-only are neither configured |
| * nor unconfigured controllers. |
| */ |
| if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks)) |
| continue; |
| |
| if (d->dev_type == HCI_BREDR && |
| hci_dev_test_flag(d, HCI_UNCONFIGURED)) { |
| rp->index[count++] = cpu_to_le16(d->id); |
| BT_DBG("Added hci%u", d->id); |
| } |
| } |
| |
| rp->num_controllers = cpu_to_le16(count); |
| rp_len = sizeof(*rp) + (2 * count); |
| |
| read_unlock(&hci_dev_list_lock); |
| |
| err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE, |
| MGMT_OP_READ_UNCONF_INDEX_LIST, 0, rp, rp_len); |
| |
| kfree(rp); |
| |
| return err; |
| } |
| |
| static int read_ext_index_list(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 data_len) |
| { |
| struct mgmt_rp_read_ext_index_list *rp; |
| struct hci_dev *d; |
| size_t rp_len; |
| u16 count; |
| int err; |
| |
| BT_DBG("sock %p", sk); |
| |
| read_lock(&hci_dev_list_lock); |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (d->dev_type == HCI_BREDR || d->dev_type == HCI_AMP) |
| count++; |
| } |
| |
| rp_len = sizeof(*rp) + (sizeof(rp->entry[0]) * count); |
| rp = kmalloc(rp_len, GFP_ATOMIC); |
| if (!rp) { |
| read_unlock(&hci_dev_list_lock); |
| return -ENOMEM; |
| } |
| |
| count = 0; |
| list_for_each_entry(d, &hci_dev_list, list) { |
| if (hci_dev_test_flag(d, HCI_SETUP) || |
| hci_dev_test_flag(d, HCI_CONFIG) || |
| hci_dev_test_flag(d, HCI_USER_CHANNEL)) |
| continue; |
| |
| /* Devices marked as raw-only are neither configured |
| * nor unconfigured controllers. |
| */ |
| if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks)) |
| continue; |
| |
| if (d->dev_type == HCI_BREDR) { |
| if (hci_dev_test_flag(d, HCI_UNCONFIGURED)) |
| rp->entry[count].type = 0x01; |
| else |
| rp->entry[count].type = 0x00; |
| } else if (d->dev_type == HCI_AMP) { |
| rp->entry[count].type = 0x02; |
| } else { |
| continue; |
| } |
| |
| rp->entry[count].bus = d->bus; |
| rp->entry[count++].index = cpu_to_le16(d->id); |
| BT_DBG("Added hci%u", d->id); |
| } |
| |
| rp->num_controllers = cpu_to_le16(count); |
| rp_len = sizeof(*rp) + (sizeof(rp->entry[0]) * count); |
| |
| read_unlock(&hci_dev_list_lock); |
| |
| /* If this command is called at least once, then all the |
| * default index and unconfigured index events are disabled |
| * and from now on only extended index events are used. |
| */ |
| hci_sock_set_flag(sk, HCI_MGMT_EXT_INDEX_EVENTS); |
| hci_sock_clear_flag(sk, HCI_MGMT_INDEX_EVENTS); |
| hci_sock_clear_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS); |
| |
| err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE, |
| MGMT_OP_READ_EXT_INDEX_LIST, 0, rp, rp_len); |
| |
| kfree(rp); |
| |
| return err; |
| } |
| |
| static bool is_configured(struct hci_dev *hdev) |
| { |
| if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) && |
| !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED)) |
| return false; |
| |
| if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) && |
| !bacmp(&hdev->public_addr, BDADDR_ANY)) |
| return false; |
| |
| return true; |
| } |
| |
| static __le32 get_missing_options(struct hci_dev *hdev) |
| { |
| u32 options = 0; |
| |
| if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) && |
| !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED)) |
| options |= MGMT_OPTION_EXTERNAL_CONFIG; |
| |
| if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) && |
| !bacmp(&hdev->public_addr, BDADDR_ANY)) |
| options |= MGMT_OPTION_PUBLIC_ADDRESS; |
| |
| return cpu_to_le32(options); |
| } |
| |
| static int new_options(struct hci_dev *hdev, struct sock *skip) |
| { |
| __le32 options = get_missing_options(hdev); |
| |
| return mgmt_generic_event(MGMT_EV_NEW_CONFIG_OPTIONS, hdev, &options, |
| sizeof(options), skip); |
| } |
| |
| static int send_options_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev) |
| { |
| __le32 options = get_missing_options(hdev); |
| |
| return mgmt_cmd_complete(sk, hdev->id, opcode, 0, &options, |
| sizeof(options)); |
| } |
| |
| static int read_config_info(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 data_len) |
| { |
| struct mgmt_rp_read_config_info rp; |
| u32 options = 0; |
| |
| BT_DBG("sock %p %s", sk, hdev->name); |
| |
| hci_dev_lock(hdev); |
| |
| memset(&rp, 0, sizeof(rp)); |
| rp.manufacturer = cpu_to_le16(hdev->manufacturer); |
| |
| if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks)) |
| options |= MGMT_OPTION_EXTERNAL_CONFIG; |
| |
| if (hdev->set_bdaddr) |
| options |= MGMT_OPTION_PUBLIC_ADDRESS; |
| |
| rp.supported_options = cpu_to_le32(options); |
| rp.missing_options = get_missing_options(hdev); |
| |
| hci_dev_unlock(hdev); |
| |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_CONFIG_INFO, 0, |
| &rp, sizeof(rp)); |
| } |
| |
| static u32 get_supported_settings(struct hci_dev *hdev) |
| { |
| u32 settings = 0; |
| |
| settings |= MGMT_SETTING_POWERED; |
| settings |= MGMT_SETTING_BONDABLE; |
| settings |= MGMT_SETTING_DEBUG_KEYS; |
| settings |= MGMT_SETTING_CONNECTABLE; |
| settings |= MGMT_SETTING_DISCOVERABLE; |
| |
| if (lmp_bredr_capable(hdev)) { |
| if (hdev->hci_ver >= BLUETOOTH_VER_1_2) |
| settings |= MGMT_SETTING_FAST_CONNECTABLE; |
| settings |= MGMT_SETTING_BREDR; |
| settings |= MGMT_SETTING_LINK_SECURITY; |
| |
| if (lmp_ssp_capable(hdev)) { |
| settings |= MGMT_SETTING_SSP; |
| settings |= MGMT_SETTING_HS; |
| } |
| |
| if (lmp_sc_capable(hdev)) |
| settings |= MGMT_SETTING_SECURE_CONN; |
| } |
| |
| if (lmp_le_capable(hdev)) { |
| settings |= MGMT_SETTING_LE; |
| settings |= MGMT_SETTING_ADVERTISING; |
| settings |= MGMT_SETTING_SECURE_CONN; |
| settings |= MGMT_SETTING_PRIVACY; |
| settings |= MGMT_SETTING_STATIC_ADDRESS; |
| } |
| |
| if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || |
| hdev->set_bdaddr) |
| settings |= MGMT_SETTING_CONFIGURATION; |
| |
| return settings; |
| } |
| |
| static u32 get_current_settings(struct hci_dev *hdev) |
| { |
| u32 settings = 0; |
| |
| if (hdev_is_powered(hdev)) |
| settings |= MGMT_SETTING_POWERED; |
| |
| if (hci_dev_test_flag(hdev, HCI_CONNECTABLE)) |
| settings |= MGMT_SETTING_CONNECTABLE; |
| |
| if (hci_dev_test_flag(hdev, HCI_FAST_CONNECTABLE)) |
| settings |= MGMT_SETTING_FAST_CONNECTABLE; |
| |
| if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE)) |
| settings |= MGMT_SETTING_DISCOVERABLE; |
| |
| if (hci_dev_test_flag(hdev, HCI_BONDABLE)) |
| settings |= MGMT_SETTING_BONDABLE; |
| |
| if (hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| settings |= MGMT_SETTING_BREDR; |
| |
| if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| settings |= MGMT_SETTING_LE; |
| |
| if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) |
| settings |= MGMT_SETTING_LINK_SECURITY; |
| |
| if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) |
| settings |= MGMT_SETTING_SSP; |
| |
| if (hci_dev_test_flag(hdev, HCI_HS_ENABLED)) |
| settings |= MGMT_SETTING_HS; |
| |
| if (hci_dev_test_flag(hdev, HCI_ADVERTISING)) |
| settings |= MGMT_SETTING_ADVERTISING; |
| |
| if (hci_dev_test_flag(hdev, HCI_SC_ENABLED)) |
| settings |= MGMT_SETTING_SECURE_CONN; |
| |
| if (hci_dev_test_flag(hdev, HCI_KEEP_DEBUG_KEYS)) |
| settings |= MGMT_SETTING_DEBUG_KEYS; |
| |
| if (hci_dev_test_flag(hdev, HCI_PRIVACY)) |
| settings |= MGMT_SETTING_PRIVACY; |
| |
| /* The current setting for static address has two purposes. The |
| * first is to indicate if the static address will be used and |
| * the second is to indicate if it is actually set. |
| * |
| * This means if the static address is not configured, this flag |
| * will never be set. If the address is configured, then if the |
| * address is actually used decides if the flag is set or not. |
| * |
| * For single mode LE only controllers and dual-mode controllers |
| * with BR/EDR disabled, the existence of the static address will |
| * be evaluated. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || |
| !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) || |
| !bacmp(&hdev->bdaddr, BDADDR_ANY)) { |
| if (bacmp(&hdev->static_addr, BDADDR_ANY)) |
| settings |= MGMT_SETTING_STATIC_ADDRESS; |
| } |
| |
| return settings; |
| } |
| |
| static struct mgmt_pending_cmd *pending_find(u16 opcode, struct hci_dev *hdev) |
| { |
| return mgmt_pending_find(HCI_CHANNEL_CONTROL, opcode, hdev); |
| } |
| |
| static struct mgmt_pending_cmd *pending_find_data(u16 opcode, |
| struct hci_dev *hdev, |
| const void *data) |
| { |
| return mgmt_pending_find_data(HCI_CHANNEL_CONTROL, opcode, hdev, data); |
| } |
| |
| u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| /* If there's a pending mgmt command the flags will not yet have |
| * their final values, so check for this first. |
| */ |
| cmd = pending_find(MGMT_OP_SET_DISCOVERABLE, hdev); |
| if (cmd) { |
| struct mgmt_mode *cp = cmd->param; |
| if (cp->val == 0x01) |
| return LE_AD_GENERAL; |
| else if (cp->val == 0x02) |
| return LE_AD_LIMITED; |
| } else { |
| if (hci_dev_test_flag(hdev, HCI_LIMITED_DISCOVERABLE)) |
| return LE_AD_LIMITED; |
| else if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE)) |
| return LE_AD_GENERAL; |
| } |
| |
| return 0; |
| } |
| |
| bool mgmt_get_connectable(struct hci_dev *hdev) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| /* If there's a pending mgmt command the flag will not yet have |
| * it's final value, so check for this first. |
| */ |
| cmd = pending_find(MGMT_OP_SET_CONNECTABLE, hdev); |
| if (cmd) { |
| struct mgmt_mode *cp = cmd->param; |
| |
| return cp->val; |
| } |
| |
| return hci_dev_test_flag(hdev, HCI_CONNECTABLE); |
| } |
| |
| static void service_cache_off(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| service_cache.work); |
| struct hci_request req; |
| |
| if (!hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) |
| return; |
| |
| hci_req_init(&req, hdev); |
| |
| hci_dev_lock(hdev); |
| |
| __hci_req_update_eir(&req); |
| __hci_req_update_class(&req); |
| |
| hci_dev_unlock(hdev); |
| |
| hci_req_run(&req, NULL); |
| } |
| |
| static void rpa_expired(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| rpa_expired.work); |
| struct hci_request req; |
| |
| BT_DBG(""); |
| |
| hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); |
| |
| if (!hci_dev_test_flag(hdev, HCI_ADVERTISING)) |
| return; |
| |
| /* The generation of a new RPA and programming it into the |
| * controller happens in the hci_req_enable_advertising() |
| * function. |
| */ |
| hci_req_init(&req, hdev); |
| __hci_req_enable_advertising(&req); |
| hci_req_run(&req, NULL); |
| } |
| |
| static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev) |
| { |
| if (hci_dev_test_and_set_flag(hdev, HCI_MGMT)) |
| return; |
| |
| INIT_DELAYED_WORK(&hdev->service_cache, service_cache_off); |
| INIT_DELAYED_WORK(&hdev->rpa_expired, rpa_expired); |
| |
| /* Non-mgmt controlled devices get this bit set |
| * implicitly so that pairing works for them, however |
| * for mgmt we require user-space to explicitly enable |
| * it |
| */ |
| hci_dev_clear_flag(hdev, HCI_BONDABLE); |
| } |
| |
| static int read_controller_info(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 data_len) |
| { |
| struct mgmt_rp_read_info rp; |
| |
| BT_DBG("sock %p %s", sk, hdev->name); |
| |
| hci_dev_lock(hdev); |
| |
| memset(&rp, 0, sizeof(rp)); |
| |
| bacpy(&rp.bdaddr, &hdev->bdaddr); |
| |
| rp.version = hdev->hci_ver; |
| rp.manufacturer = cpu_to_le16(hdev->manufacturer); |
| |
| rp.supported_settings = cpu_to_le32(get_supported_settings(hdev)); |
| rp.current_settings = cpu_to_le32(get_current_settings(hdev)); |
| |
| memcpy(rp.dev_class, hdev->dev_class, 3); |
| |
| memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name)); |
| memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name)); |
| |
| hci_dev_unlock(hdev); |
| |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp, |
| sizeof(rp)); |
| } |
| |
| static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev) |
| { |
| __le32 settings = cpu_to_le32(get_current_settings(hdev)); |
| |
| return mgmt_cmd_complete(sk, hdev->id, opcode, 0, &settings, |
| sizeof(settings)); |
| } |
| |
| static void clean_up_hci_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| BT_DBG("%s status 0x%02x", hdev->name, status); |
| |
| if (hci_conn_count(hdev) == 0) { |
| cancel_delayed_work(&hdev->power_off); |
| queue_work(hdev->req_workqueue, &hdev->power_off.work); |
| } |
| } |
| |
| void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev, u8 instance) |
| { |
| struct mgmt_ev_advertising_added ev; |
| |
| ev.instance = instance; |
| |
| mgmt_event(MGMT_EV_ADVERTISING_ADDED, hdev, &ev, sizeof(ev), sk); |
| } |
| |
| void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev, |
| u8 instance) |
| { |
| struct mgmt_ev_advertising_removed ev; |
| |
| ev.instance = instance; |
| |
| mgmt_event(MGMT_EV_ADVERTISING_REMOVED, hdev, &ev, sizeof(ev), sk); |
| } |
| |
| static void cancel_adv_timeout(struct hci_dev *hdev) |
| { |
| if (hdev->adv_instance_timeout) { |
| hdev->adv_instance_timeout = 0; |
| cancel_delayed_work(&hdev->adv_instance_expire); |
| } |
| } |
| |
| static int clean_up_hci_state(struct hci_dev *hdev) |
| { |
| struct hci_request req; |
| struct hci_conn *conn; |
| bool discov_stopped; |
| int err; |
| |
| hci_req_init(&req, hdev); |
| |
| if (test_bit(HCI_ISCAN, &hdev->flags) || |
| test_bit(HCI_PSCAN, &hdev->flags)) { |
| u8 scan = 0x00; |
| hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); |
| } |
| |
| hci_req_clear_adv_instance(hdev, NULL, 0x00, false); |
| |
| if (hci_dev_test_flag(hdev, HCI_LE_ADV)) |
| __hci_req_disable_advertising(&req); |
| |
| discov_stopped = hci_req_stop_discovery(&req); |
| |
| list_for_each_entry(conn, &hdev->conn_hash.list, list) { |
| /* 0x15 == Terminated due to Power Off */ |
| __hci_abort_conn(&req, conn, 0x15); |
| } |
| |
| err = hci_req_run(&req, clean_up_hci_complete); |
| if (!err && discov_stopped) |
| hci_discovery_set_state(hdev, DISCOVERY_STOPPING); |
| |
| return err; |
| } |
| |
| static int set_powered(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (pending_find(MGMT_OP_SET_POWERED, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| if (!!cp->val == hdev_is_powered(hdev)) { |
| err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| if (cp->val) { |
| queue_work(hdev->req_workqueue, &hdev->power_on); |
| err = 0; |
| } else { |
| /* Disconnect connections, stop scans, etc */ |
| err = clean_up_hci_state(hdev); |
| if (!err) |
| queue_delayed_work(hdev->req_workqueue, &hdev->power_off, |
| HCI_POWER_OFF_TIMEOUT); |
| |
| /* ENODATA means there were no HCI commands queued */ |
| if (err == -ENODATA) { |
| cancel_delayed_work(&hdev->power_off); |
| queue_work(hdev->req_workqueue, &hdev->power_off.work); |
| err = 0; |
| } |
| } |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int new_settings(struct hci_dev *hdev, struct sock *skip) |
| { |
| __le32 ev = cpu_to_le32(get_current_settings(hdev)); |
| |
| return mgmt_generic_event(MGMT_EV_NEW_SETTINGS, hdev, &ev, |
| sizeof(ev), skip); |
| } |
| |
| int mgmt_new_settings(struct hci_dev *hdev) |
| { |
| return new_settings(hdev, NULL); |
| } |
| |
| struct cmd_lookup { |
| struct sock *sk; |
| struct hci_dev *hdev; |
| u8 mgmt_status; |
| }; |
| |
| static void settings_rsp(struct mgmt_pending_cmd *cmd, void *data) |
| { |
| struct cmd_lookup *match = data; |
| |
| send_settings_rsp(cmd->sk, cmd->opcode, match->hdev); |
| |
| list_del(&cmd->list); |
| |
| if (match->sk == NULL) { |
| match->sk = cmd->sk; |
| sock_hold(match->sk); |
| } |
| |
| mgmt_pending_free(cmd); |
| } |
| |
| static void cmd_status_rsp(struct mgmt_pending_cmd *cmd, void *data) |
| { |
| u8 *status = data; |
| |
| mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode, *status); |
| mgmt_pending_remove(cmd); |
| } |
| |
| static void cmd_complete_rsp(struct mgmt_pending_cmd *cmd, void *data) |
| { |
| if (cmd->cmd_complete) { |
| u8 *status = data; |
| |
| cmd->cmd_complete(cmd, *status); |
| mgmt_pending_remove(cmd); |
| |
| return; |
| } |
| |
| cmd_status_rsp(cmd, data); |
| } |
| |
| static int generic_cmd_complete(struct mgmt_pending_cmd *cmd, u8 status) |
| { |
| return mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, status, |
| cmd->param, cmd->param_len); |
| } |
| |
| static int addr_cmd_complete(struct mgmt_pending_cmd *cmd, u8 status) |
| { |
| return mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, status, |
| cmd->param, sizeof(struct mgmt_addr_info)); |
| } |
| |
| static u8 mgmt_bredr_support(struct hci_dev *hdev) |
| { |
| if (!lmp_bredr_capable(hdev)) |
| return MGMT_STATUS_NOT_SUPPORTED; |
| else if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return MGMT_STATUS_REJECTED; |
| else |
| return MGMT_STATUS_SUCCESS; |
| } |
| |
| static u8 mgmt_le_support(struct hci_dev *hdev) |
| { |
| if (!lmp_le_capable(hdev)) |
| return MGMT_STATUS_NOT_SUPPORTED; |
| else if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| return MGMT_STATUS_REJECTED; |
| else |
| return MGMT_STATUS_SUCCESS; |
| } |
| |
| void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("status 0x%02x", status); |
| |
| hci_dev_lock(hdev); |
| |
| cmd = pending_find(MGMT_OP_SET_DISCOVERABLE, hdev); |
| if (!cmd) |
| goto unlock; |
| |
| if (status) { |
| u8 mgmt_err = mgmt_status(status); |
| mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode, mgmt_err); |
| hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); |
| goto remove_cmd; |
| } |
| |
| if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE) && |
| hdev->discov_timeout > 0) { |
| int to = msecs_to_jiffies(hdev->discov_timeout * 1000); |
| queue_delayed_work(hdev->req_workqueue, &hdev->discov_off, to); |
| } |
| |
| send_settings_rsp(cmd->sk, MGMT_OP_SET_DISCOVERABLE, hdev); |
| new_settings(hdev, cmd->sk); |
| |
| remove_cmd: |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int set_discoverable(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_set_discoverable *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| u16 timeout; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) && |
| !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_REJECTED); |
| |
| if (cp->val != 0x00 && cp->val != 0x01 && cp->val != 0x02) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| timeout = __le16_to_cpu(cp->timeout); |
| |
| /* Disabling discoverable requires that no timeout is set, |
| * and enabling limited discoverable requires a timeout. |
| */ |
| if ((cp->val == 0x00 && timeout > 0) || |
| (cp->val == 0x02 && timeout == 0)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev) && timeout > 0) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_NOT_POWERED); |
| goto failed; |
| } |
| |
| if (pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) || |
| pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| if (!hci_dev_test_flag(hdev, HCI_CONNECTABLE)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE, |
| MGMT_STATUS_REJECTED); |
| goto failed; |
| } |
| |
| if (!hdev_is_powered(hdev)) { |
| bool changed = false; |
| |
| /* Setting limited discoverable when powered off is |
| * not a valid operation since it requires a timeout |
| * and so no need to check HCI_LIMITED_DISCOVERABLE. |
| */ |
| if (!!cp->val != hci_dev_test_flag(hdev, HCI_DISCOVERABLE)) { |
| hci_dev_change_flag(hdev, HCI_DISCOVERABLE); |
| changed = true; |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev); |
| if (err < 0) |
| goto failed; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| goto failed; |
| } |
| |
| /* If the current mode is the same, then just update the timeout |
| * value with the new value. And if only the timeout gets updated, |
| * then no need for any HCI transactions. |
| */ |
| if (!!cp->val == hci_dev_test_flag(hdev, HCI_DISCOVERABLE) && |
| (cp->val == 0x02) == hci_dev_test_flag(hdev, |
| HCI_LIMITED_DISCOVERABLE)) { |
| cancel_delayed_work(&hdev->discov_off); |
| hdev->discov_timeout = timeout; |
| |
| if (cp->val && hdev->discov_timeout > 0) { |
| int to = msecs_to_jiffies(hdev->discov_timeout * 1000); |
| queue_delayed_work(hdev->req_workqueue, |
| &hdev->discov_off, to); |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| /* Cancel any potential discoverable timeout that might be |
| * still active and store new timeout value. The arming of |
| * the timeout happens in the complete handler. |
| */ |
| cancel_delayed_work(&hdev->discov_off); |
| hdev->discov_timeout = timeout; |
| |
| if (cp->val) |
| hci_dev_set_flag(hdev, HCI_DISCOVERABLE); |
| else |
| hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); |
| |
| /* Limited discoverable mode */ |
| if (cp->val == 0x02) |
| hci_dev_set_flag(hdev, HCI_LIMITED_DISCOVERABLE); |
| else |
| hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); |
| |
| queue_work(hdev->req_workqueue, &hdev->discoverable_update); |
| err = 0; |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("status 0x%02x", status); |
| |
| hci_dev_lock(hdev); |
| |
| cmd = pending_find(MGMT_OP_SET_CONNECTABLE, hdev); |
| if (!cmd) |
| goto unlock; |
| |
| if (status) { |
| u8 mgmt_err = mgmt_status(status); |
| mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode, mgmt_err); |
| goto remove_cmd; |
| } |
| |
| send_settings_rsp(cmd->sk, MGMT_OP_SET_CONNECTABLE, hdev); |
| new_settings(hdev, cmd->sk); |
| |
| remove_cmd: |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int set_connectable_update_settings(struct hci_dev *hdev, |
| struct sock *sk, u8 val) |
| { |
| bool changed = false; |
| int err; |
| |
| if (!!val != hci_dev_test_flag(hdev, HCI_CONNECTABLE)) |
| changed = true; |
| |
| if (val) { |
| hci_dev_set_flag(hdev, HCI_CONNECTABLE); |
| } else { |
| hci_dev_clear_flag(hdev, HCI_CONNECTABLE); |
| hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev); |
| if (err < 0) |
| return err; |
| |
| if (changed) { |
| hci_req_update_scan(hdev); |
| hci_update_background_scan(hdev); |
| return new_settings(hdev, sk); |
| } |
| |
| return 0; |
| } |
| |
| static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) && |
| !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE, |
| MGMT_STATUS_REJECTED); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = set_connectable_update_settings(hdev, sk, cp->val); |
| goto failed; |
| } |
| |
| if (pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) || |
| pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| if (cp->val) { |
| hci_dev_set_flag(hdev, HCI_CONNECTABLE); |
| } else { |
| if (hdev->discov_timeout > 0) |
| cancel_delayed_work(&hdev->discov_off); |
| |
| hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); |
| hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); |
| hci_dev_clear_flag(hdev, HCI_CONNECTABLE); |
| } |
| |
| queue_work(hdev->req_workqueue, &hdev->connectable_update); |
| err = 0; |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int set_bondable(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| bool changed; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BONDABLE, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (cp->val) |
| changed = !hci_dev_test_and_set_flag(hdev, HCI_BONDABLE); |
| else |
| changed = hci_dev_test_and_clear_flag(hdev, HCI_BONDABLE); |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_BONDABLE, hdev); |
| if (err < 0) |
| goto unlock; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int set_link_security(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| u8 val, status; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| status = mgmt_bredr_support(hdev); |
| if (status) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY, |
| status); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| bool changed = false; |
| |
| if (!!cp->val != hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { |
| hci_dev_change_flag(hdev, HCI_LINK_SECURITY); |
| changed = true; |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev); |
| if (err < 0) |
| goto failed; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| goto failed; |
| } |
| |
| if (pending_find(MGMT_OP_SET_LINK_SECURITY, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| val = !!cp->val; |
| |
| if (test_bit(HCI_AUTH, &hdev->flags) == val) { |
| err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_LINK_SECURITY, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| err = hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(val), &val); |
| if (err < 0) { |
| mgmt_pending_remove(cmd); |
| goto failed; |
| } |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int set_ssp(struct sock *sk, struct hci_dev *hdev, void *data, u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| u8 status; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| status = mgmt_bredr_support(hdev); |
| if (status) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, status); |
| |
| if (!lmp_ssp_capable(hdev)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, |
| MGMT_STATUS_NOT_SUPPORTED); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| bool changed; |
| |
| if (cp->val) { |
| changed = !hci_dev_test_and_set_flag(hdev, |
| HCI_SSP_ENABLED); |
| } else { |
| changed = hci_dev_test_and_clear_flag(hdev, |
| HCI_SSP_ENABLED); |
| if (!changed) |
| changed = hci_dev_test_and_clear_flag(hdev, |
| HCI_HS_ENABLED); |
| else |
| hci_dev_clear_flag(hdev, HCI_HS_ENABLED); |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev); |
| if (err < 0) |
| goto failed; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| goto failed; |
| } |
| |
| if (pending_find(MGMT_OP_SET_SSP, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| if (!!cp->val == hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { |
| err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_SSP, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| if (!cp->val && hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) |
| hci_send_cmd(hdev, HCI_OP_WRITE_SSP_DEBUG_MODE, |
| sizeof(cp->val), &cp->val); |
| |
| err = hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, 1, &cp->val); |
| if (err < 0) { |
| mgmt_pending_remove(cmd); |
| goto failed; |
| } |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int set_hs(struct sock *sk, struct hci_dev *hdev, void *data, u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| bool changed; |
| u8 status; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| status = mgmt_bredr_support(hdev); |
| if (status) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, status); |
| |
| if (!lmp_ssp_capable(hdev)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, |
| MGMT_STATUS_NOT_SUPPORTED); |
| |
| if (!hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, |
| MGMT_STATUS_REJECTED); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| hci_dev_lock(hdev); |
| |
| if (pending_find(MGMT_OP_SET_SSP, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, |
| MGMT_STATUS_BUSY); |
| goto unlock; |
| } |
| |
| if (cp->val) { |
| changed = !hci_dev_test_and_set_flag(hdev, HCI_HS_ENABLED); |
| } else { |
| if (hdev_is_powered(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS, |
| MGMT_STATUS_REJECTED); |
| goto unlock; |
| } |
| |
| changed = hci_dev_test_and_clear_flag(hdev, HCI_HS_ENABLED); |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_HS, hdev); |
| if (err < 0) |
| goto unlock; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static void le_enable_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| struct cmd_lookup match = { NULL, hdev }; |
| |
| hci_dev_lock(hdev); |
| |
| if (status) { |
| u8 mgmt_err = mgmt_status(status); |
| |
| mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, cmd_status_rsp, |
| &mgmt_err); |
| goto unlock; |
| } |
| |
| mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, settings_rsp, &match); |
| |
| new_settings(hdev, match.sk); |
| |
| if (match.sk) |
| sock_put(match.sk); |
| |
| /* Make sure the controller has a good default for |
| * advertising data. Restrict the update to when LE |
| * has actually been enabled. During power on, the |
| * update in powered_update_hci will take care of it. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { |
| struct hci_request req; |
| |
| hci_req_init(&req, hdev); |
| __hci_req_update_adv_data(&req, 0x00); |
| __hci_req_update_scan_rsp_data(&req, 0x00); |
| hci_req_run(&req, NULL); |
| hci_update_background_scan(hdev); |
| } |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len) |
| { |
| struct mgmt_mode *cp = data; |
| struct hci_cp_write_le_host_supported hci_cp; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_request req; |
| int err; |
| u8 val, enabled; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (!lmp_le_capable(hdev)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE, |
| MGMT_STATUS_NOT_SUPPORTED); |
| |
| if (cp->val != 0x00 && cp->val != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| /* Bluetooth single mode LE only controllers or dual-mode |
| * controllers configured as LE only devices, do not allow |
| * switching LE off. These have either LE enabled explicitly |
| * or BR/EDR has been previously switched off. |
| * |
| * When trying to enable an already enabled LE, then gracefully |
| * send a positive response. Trying to disable it however will |
| * result into rejection. |
| */ |
| if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { |
| if (cp->val == 0x01) |
| return send_settings_rsp(sk, MGMT_OP_SET_LE, hdev); |
| |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE, |
| MGMT_STATUS_REJECTED); |
| } |
| |
| hci_dev_lock(hdev); |
| |
| val = !!cp->val; |
| enabled = lmp_host_le_capable(hdev); |
| |
| if (!val) |
| hci_req_clear_adv_instance(hdev, NULL, 0x00, true); |
| |
| if (!hdev_is_powered(hdev) || val == enabled) { |
| bool changed = false; |
| |
| if (val != hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { |
| hci_dev_change_flag(hdev, HCI_LE_ENABLED); |
| changed = true; |
| } |
| |
| if (!val && hci_dev_test_flag(hdev, HCI_ADVERTISING)) { |
| hci_dev_clear_flag(hdev, HCI_ADVERTISING); |
| changed = true; |
| } |
| |
| err = send_settings_rsp(sk, MGMT_OP_SET_LE, hdev); |
| if (err < 0) |
| goto unlock; |
| |
| if (changed) |
| err = new_settings(hdev, sk); |
| |
| goto unlock; |
| } |
| |
| if (pending_find(MGMT_OP_SET_LE, hdev) || |
| pending_find(MGMT_OP_SET_ADVERTISING, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE, |
| MGMT_STATUS_BUSY); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_LE, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| |
| hci_req_init(&req, hdev); |
| |
| memset(&hci_cp, 0, sizeof(hci_cp)); |
| |
| if (val) { |
| hci_cp.le = val; |
| hci_cp.simul = 0x00; |
| } else { |
| if (hci_dev_test_flag(hdev, HCI_LE_ADV)) |
| __hci_req_disable_advertising(&req); |
| } |
| |
| hci_req_add(&req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(hci_cp), |
| &hci_cp); |
| |
| err = hci_req_run(&req, le_enable_complete); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| /* This is a helper function to test for pending mgmt commands that can |
| * cause CoD or EIR HCI commands. We can only allow one such pending |
| * mgmt command at a time since otherwise we cannot easily track what |
| * the current values are, will be, and based on that calculate if a new |
| * HCI command needs to be sent and if yes with what value. |
| */ |
| static bool pending_eir_or_class(struct hci_dev *hdev) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| list_for_each_entry(cmd, &hdev->mgmt_pending, list) { |
| switch (cmd->opcode) { |
| case MGMT_OP_ADD_UUID: |
| case MGMT_OP_REMOVE_UUID: |
| case MGMT_OP_SET_DEV_CLASS: |
| case MGMT_OP_SET_POWERED: |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| static const u8 bluetooth_base_uuid[] = { |
| 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, |
| 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }; |
| |
| static u8 get_uuid_size(const u8 *uuid) |
| { |
| u32 val; |
| |
| if (memcmp(uuid, bluetooth_base_uuid, 12)) |
| return 128; |
| |
| val = get_unaligned_le32(&uuid[12]); |
| if (val > 0xffff) |
| return 32; |
| |
| return 16; |
| } |
| |
| static void mgmt_class_complete(struct hci_dev *hdev, u16 mgmt_op, u8 status) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| hci_dev_lock(hdev); |
| |
| cmd = pending_find(mgmt_op, hdev); |
| if (!cmd) |
| goto unlock; |
| |
| mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, |
| mgmt_status(status), hdev->dev_class, 3); |
| |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static void add_uuid_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| BT_DBG("status 0x%02x", status); |
| |
| mgmt_class_complete(hdev, MGMT_OP_ADD_UUID, status); |
| } |
| |
| static int add_uuid(struct sock *sk, struct hci_dev *hdev, void *data, u16 len) |
| { |
| struct mgmt_cp_add_uuid *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_request req; |
| struct bt_uuid *uuid; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| hci_dev_lock(hdev); |
| |
| if (pending_eir_or_class(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_UUID, |
| MGMT_STATUS_BUSY); |
| goto failed; |
| } |
| |
| uuid = kmalloc(sizeof(*uuid), GFP_KERNEL); |
| if (!uuid) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| memcpy(uuid->uuid, cp->uuid, 16); |
| uuid->svc_hint = cp->svc_hint; |
| uuid->size = get_uuid_size(cp->uuid); |
| |
| list_add_tail(&uuid->list, &hdev->uuids); |
| |
| hci_req_init(&req, hdev); |
| |
| __hci_req_update_class(&req); |
| __hci_req_update_eir(&req); |
| |
| err = hci_req_run(&req, add_uuid_complete); |
| if (err < 0) { |
| if (err != -ENODATA) |
| goto failed; |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_UUID, 0, |
| hdev->dev_class, 3); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_ADD_UUID, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| err = 0; |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static bool enable_service_cache(struct hci_dev *hdev) |
| { |
| if (!hdev_is_powered(hdev)) |
| return false; |
| |
| if (!hci_dev_test_and_set_flag(hdev, HCI_SERVICE_CACHE)) { |
| queue_delayed_work(hdev->workqueue, &hdev->service_cache, |
| CACHE_TIMEOUT); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static void remove_uuid_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| BT_DBG("status 0x%02x", status); |
| |
| mgmt_class_complete(hdev, MGMT_OP_REMOVE_UUID, status); |
| } |
| |
| static int remove_uuid(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_remove_uuid *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| struct bt_uuid *match, *tmp; |
| u8 bt_uuid_any[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| struct hci_request req; |
| int err, found; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| hci_dev_lock(hdev); |
| |
| if (pending_eir_or_class(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID, |
| MGMT_STATUS_BUSY); |
| goto unlock; |
| } |
| |
| if (memcmp(cp->uuid, bt_uuid_any, 16) == 0) { |
| hci_uuids_clear(hdev); |
| |
| if (enable_service_cache(hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, |
| MGMT_OP_REMOVE_UUID, |
| 0, hdev->dev_class, 3); |
| goto unlock; |
| } |
| |
| goto update_class; |
| } |
| |
| found = 0; |
| |
| list_for_each_entry_safe(match, tmp, &hdev->uuids, list) { |
| if (memcmp(match->uuid, cp->uuid, 16) != 0) |
| continue; |
| |
| list_del(&match->list); |
| kfree(match); |
| found++; |
| } |
| |
| if (found == 0) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID, |
| MGMT_STATUS_INVALID_PARAMS); |
| goto unlock; |
| } |
| |
| update_class: |
| hci_req_init(&req, hdev); |
| |
| __hci_req_update_class(&req); |
| __hci_req_update_eir(&req); |
| |
| err = hci_req_run(&req, remove_uuid_complete); |
| if (err < 0) { |
| if (err != -ENODATA) |
| goto unlock; |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID, 0, |
| hdev->dev_class, 3); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_UUID, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| |
| err = 0; |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static void set_class_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| BT_DBG("status 0x%02x", status); |
| |
| mgmt_class_complete(hdev, MGMT_OP_SET_DEV_CLASS, status); |
| } |
| |
| static int set_dev_class(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_set_dev_class *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_request req; |
| int err; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (!lmp_bredr_capable(hdev)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, |
| MGMT_STATUS_NOT_SUPPORTED); |
| |
| hci_dev_lock(hdev); |
| |
| if (pending_eir_or_class(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, |
| MGMT_STATUS_BUSY); |
| goto unlock; |
| } |
| |
| if ((cp->minor & 0x03) != 0 || (cp->major & 0xe0) != 0) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, |
| MGMT_STATUS_INVALID_PARAMS); |
| goto unlock; |
| } |
| |
| hdev->major_class = cp->major; |
| hdev->minor_class = cp->minor; |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0, |
| hdev->dev_class, 3); |
| goto unlock; |
| } |
| |
| hci_req_init(&req, hdev); |
| |
| if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) { |
| hci_dev_unlock(hdev); |
| cancel_delayed_work_sync(&hdev->service_cache); |
| hci_dev_lock(hdev); |
| __hci_req_update_eir(&req); |
| } |
| |
| __hci_req_update_class(&req); |
| |
| err = hci_req_run(&req, set_class_complete); |
| if (err < 0) { |
| if (err != -ENODATA) |
| goto unlock; |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0, |
| hdev->dev_class, 3); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_DEV_CLASS, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| |
| err = 0; |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int load_link_keys(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_load_link_keys *cp = data; |
| const u16 max_key_count = ((U16_MAX - sizeof(*cp)) / |
| sizeof(struct mgmt_link_key_info)); |
| u16 key_count, expected_len; |
| bool changed; |
| int i; |
| |
| BT_DBG("request for %s", hdev->name); |
| |
| if (!lmp_bredr_capable(hdev)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_STATUS_NOT_SUPPORTED); |
| |
| key_count = __le16_to_cpu(cp->key_count); |
| if (key_count > max_key_count) { |
| BT_ERR("load_link_keys: too big key_count value %u", |
| key_count); |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_STATUS_INVALID_PARAMS); |
| } |
| |
| expected_len = sizeof(*cp) + key_count * |
| sizeof(struct mgmt_link_key_info); |
| if (expected_len != len) { |
| BT_ERR("load_link_keys: expected %u bytes, got %u bytes", |
| expected_len, len); |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_STATUS_INVALID_PARAMS); |
| } |
| |
| if (cp->debug_keys != 0x00 && cp->debug_keys != 0x01) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| BT_DBG("%s debug_keys %u key_count %u", hdev->name, cp->debug_keys, |
| key_count); |
| |
| for (i = 0; i < key_count; i++) { |
| struct mgmt_link_key_info *key = &cp->keys[i]; |
| |
| if (key->addr.type != BDADDR_BREDR || key->type > 0x08) |
| return mgmt_cmd_status(sk, hdev->id, |
| MGMT_OP_LOAD_LINK_KEYS, |
| MGMT_STATUS_INVALID_PARAMS); |
| } |
| |
| hci_dev_lock(hdev); |
| |
| hci_link_keys_clear(hdev); |
| |
| if (cp->debug_keys) |
| changed = !hci_dev_test_and_set_flag(hdev, HCI_KEEP_DEBUG_KEYS); |
| else |
| changed = hci_dev_test_and_clear_flag(hdev, |
| HCI_KEEP_DEBUG_KEYS); |
| |
| if (changed) |
| new_settings(hdev, NULL); |
| |
| for (i = 0; i < key_count; i++) { |
| struct mgmt_link_key_info *key = &cp->keys[i]; |
| |
| /* Always ignore debug keys and require a new pairing if |
| * the user wants to use them. |
| */ |
| if (key->type == HCI_LK_DEBUG_COMBINATION) |
| continue; |
| |
| hci_add_link_key(hdev, NULL, &key->addr.bdaddr, key->val, |
| key->type, key->pin_len, NULL); |
| } |
| |
| mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, 0, NULL, 0); |
| |
| hci_dev_unlock(hdev); |
| |
| return 0; |
| } |
| |
| static int device_unpaired(struct hci_dev *hdev, bdaddr_t *bdaddr, |
| u8 addr_type, struct sock *skip_sk) |
| { |
| struct mgmt_ev_device_unpaired ev; |
| |
| bacpy(&ev.addr.bdaddr, bdaddr); |
| ev.addr.type = addr_type; |
| |
| return mgmt_event(MGMT_EV_DEVICE_UNPAIRED, hdev, &ev, sizeof(ev), |
| skip_sk); |
| } |
| |
| static int unpair_device(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_unpair_device *cp = data; |
| struct mgmt_rp_unpair_device rp; |
| struct hci_conn_params *params; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_conn *conn; |
| u8 addr_type; |
| int err; |
| |
| memset(&rp, 0, sizeof(rp)); |
| bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr); |
| rp.addr.type = cp->addr.type; |
| |
| if (!bdaddr_type_is_valid(cp->addr.type)) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS, |
| &rp, sizeof(rp)); |
| |
| if (cp->disconnect != 0x00 && cp->disconnect != 0x01) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS, |
| &rp, sizeof(rp)); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, |
| MGMT_STATUS_NOT_POWERED, &rp, |
| sizeof(rp)); |
| goto unlock; |
| } |
| |
| if (cp->addr.type == BDADDR_BREDR) { |
| /* If disconnection is requested, then look up the |
| * connection. If the remote device is connected, it |
| * will be later used to terminate the link. |
| * |
| * Setting it to NULL explicitly will cause no |
| * termination of the link. |
| */ |
| if (cp->disconnect) |
| conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, |
| &cp->addr.bdaddr); |
| else |
| conn = NULL; |
| |
| err = hci_remove_link_key(hdev, &cp->addr.bdaddr); |
| if (err < 0) { |
| err = mgmt_cmd_complete(sk, hdev->id, |
| MGMT_OP_UNPAIR_DEVICE, |
| MGMT_STATUS_NOT_PAIRED, &rp, |
| sizeof(rp)); |
| goto unlock; |
| } |
| |
| goto done; |
| } |
| |
| /* LE address type */ |
| addr_type = le_addr_type(cp->addr.type); |
| |
| hci_remove_irk(hdev, &cp->addr.bdaddr, addr_type); |
| |
| err = hci_remove_ltk(hdev, &cp->addr.bdaddr, addr_type); |
| if (err < 0) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, |
| MGMT_STATUS_NOT_PAIRED, &rp, |
| sizeof(rp)); |
| goto unlock; |
| } |
| |
| conn = hci_conn_hash_lookup_le(hdev, &cp->addr.bdaddr, addr_type); |
| if (!conn) { |
| hci_conn_params_del(hdev, &cp->addr.bdaddr, addr_type); |
| goto done; |
| } |
| |
| /* Abort any ongoing SMP pairing */ |
| smp_cancel_pairing(conn); |
| |
| /* Defer clearing up the connection parameters until closing to |
| * give a chance of keeping them if a repairing happens. |
| */ |
| set_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags); |
| |
| /* Disable auto-connection parameters if present */ |
| params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr, addr_type); |
| if (params) { |
| if (params->explicit_connect) |
| params->auto_connect = HCI_AUTO_CONN_EXPLICIT; |
| else |
| params->auto_connect = HCI_AUTO_CONN_DISABLED; |
| } |
| |
| /* If disconnection is not requested, then clear the connection |
| * variable so that the link is not terminated. |
| */ |
| if (!cp->disconnect) |
| conn = NULL; |
| |
| done: |
| /* If the connection variable is set, then termination of the |
| * link is requested. |
| */ |
| if (!conn) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, 0, |
| &rp, sizeof(rp)); |
| device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, sk); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_UNPAIR_DEVICE, hdev, cp, |
| sizeof(*cp)); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| |
| cmd->cmd_complete = addr_cmd_complete; |
| |
| err = hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int disconnect(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_disconnect *cp = data; |
| struct mgmt_rp_disconnect rp; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_conn *conn; |
| int err; |
| |
| BT_DBG(""); |
| |
| memset(&rp, 0, sizeof(rp)); |
| bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr); |
| rp.addr.type = cp->addr.type; |
| |
| if (!bdaddr_type_is_valid(cp->addr.type)) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT, |
| MGMT_STATUS_INVALID_PARAMS, |
| &rp, sizeof(rp)); |
| |
| hci_dev_lock(hdev); |
| |
| if (!test_bit(HCI_UP, &hdev->flags)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT, |
| MGMT_STATUS_NOT_POWERED, &rp, |
| sizeof(rp)); |
| goto failed; |
| } |
| |
| if (pending_find(MGMT_OP_DISCONNECT, hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT, |
| MGMT_STATUS_BUSY, &rp, sizeof(rp)); |
| goto failed; |
| } |
| |
| if (cp->addr.type == BDADDR_BREDR) |
| conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, |
| &cp->addr.bdaddr); |
| else |
| conn = hci_conn_hash_lookup_le(hdev, &cp->addr.bdaddr, |
| le_addr_type(cp->addr.type)); |
| |
| if (!conn || conn->state == BT_OPEN || conn->state == BT_CLOSED) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT, |
| MGMT_STATUS_NOT_CONNECTED, &rp, |
| sizeof(rp)); |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| cmd->cmd_complete = generic_cmd_complete; |
| |
| err = hci_disconnect(conn, HCI_ERROR_REMOTE_USER_TERM); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static u8 link_to_bdaddr(u8 link_type, u8 addr_type) |
| { |
| switch (link_type) { |
| case LE_LINK: |
| switch (addr_type) { |
| case ADDR_LE_DEV_PUBLIC: |
| return BDADDR_LE_PUBLIC; |
| |
| default: |
| /* Fallback to LE Random address type */ |
| return BDADDR_LE_RANDOM; |
| } |
| |
| default: |
| /* Fallback to BR/EDR type */ |
| return BDADDR_BREDR; |
| } |
| } |
| |
| static int get_connections(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 data_len) |
| { |
| struct mgmt_rp_get_connections *rp; |
| struct hci_conn *c; |
| size_t rp_len; |
| int err; |
| u16 i; |
| |
| BT_DBG(""); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, |
| MGMT_STATUS_NOT_POWERED); |
| goto unlock; |
| } |
| |
| i = 0; |
| list_for_each_entry(c, &hdev->conn_hash.list, list) { |
| if (test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags)) |
| i++; |
| } |
| |
| rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info)); |
| rp = kmalloc(rp_len, GFP_KERNEL); |
| if (!rp) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| |
| i = 0; |
| list_for_each_entry(c, &hdev->conn_hash.list, list) { |
| if (!test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags)) |
| continue; |
| bacpy(&rp->addr[i].bdaddr, &c->dst); |
| rp->addr[i].type = link_to_bdaddr(c->type, c->dst_type); |
| if (c->type == SCO_LINK || c->type == ESCO_LINK) |
| continue; |
| i++; |
| } |
| |
| rp->conn_count = cpu_to_le16(i); |
| |
| /* Recalculate length in case of filtered SCO connections, etc */ |
| rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info)); |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp, |
| rp_len); |
| |
| kfree(rp); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int send_pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev, |
| struct mgmt_cp_pin_code_neg_reply *cp) |
| { |
| struct mgmt_pending_cmd *cmd; |
| int err; |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp, |
| sizeof(*cp)); |
| if (!cmd) |
| return -ENOMEM; |
| |
| err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY, |
| sizeof(cp->addr.bdaddr), &cp->addr.bdaddr); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| return err; |
| } |
| |
| static int pin_code_reply(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct hci_conn *conn; |
| struct mgmt_cp_pin_code_reply *cp = data; |
| struct hci_cp_pin_code_reply reply; |
| struct mgmt_pending_cmd *cmd; |
| int err; |
| |
| BT_DBG(""); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY, |
| MGMT_STATUS_NOT_POWERED); |
| goto failed; |
| } |
| |
| conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr); |
| if (!conn) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY, |
| MGMT_STATUS_NOT_CONNECTED); |
| goto failed; |
| } |
| |
| if (conn->pending_sec_level == BT_SECURITY_HIGH && cp->pin_len != 16) { |
| struct mgmt_cp_pin_code_neg_reply ncp; |
| |
| memcpy(&ncp.addr, &cp->addr, sizeof(ncp.addr)); |
| |
| BT_ERR("PIN code is not 16 bytes long"); |
| |
| err = send_pin_code_neg_reply(sk, hdev, &ncp); |
| if (err >= 0) |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| cmd->cmd_complete = addr_cmd_complete; |
| |
| bacpy(&reply.bdaddr, &cp->addr.bdaddr); |
| reply.pin_len = cp->pin_len; |
| memcpy(reply.pin_code, cp->pin_code, sizeof(reply.pin_code)); |
| |
| err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_REPLY, sizeof(reply), &reply); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int set_io_capability(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_set_io_capability *cp = data; |
| |
| BT_DBG(""); |
| |
| if (cp->io_capability > SMP_IO_KEYBOARD_DISPLAY) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, |
| MGMT_STATUS_INVALID_PARAMS, NULL, 0); |
| |
| hci_dev_lock(hdev); |
| |
| hdev->io_capability = cp->io_capability; |
| |
| BT_DBG("%s IO capability set to 0x%02x", hdev->name, |
| hdev->io_capability); |
| |
| hci_dev_unlock(hdev); |
| |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, 0, |
| NULL, 0); |
| } |
| |
| static struct mgmt_pending_cmd *find_pairing(struct hci_conn *conn) |
| { |
| struct hci_dev *hdev = conn->hdev; |
| struct mgmt_pending_cmd *cmd; |
| |
| list_for_each_entry(cmd, &hdev->mgmt_pending, list) { |
| if (cmd->opcode != MGMT_OP_PAIR_DEVICE) |
| continue; |
| |
| if (cmd->user_data != conn) |
| continue; |
| |
| return cmd; |
| } |
| |
| return NULL; |
| } |
| |
| static int pairing_complete(struct mgmt_pending_cmd *cmd, u8 status) |
| { |
| struct mgmt_rp_pair_device rp; |
| struct hci_conn *conn = cmd->user_data; |
| int err; |
| |
| bacpy(&rp.addr.bdaddr, &conn->dst); |
| rp.addr.type = link_to_bdaddr(conn->type, conn->dst_type); |
| |
| err = mgmt_cmd_complete(cmd->sk, cmd->index, MGMT_OP_PAIR_DEVICE, |
| status, &rp, sizeof(rp)); |
| |
| /* So we don't get further callbacks for this connection */ |
| conn->connect_cfm_cb = NULL; |
| conn->security_cfm_cb = NULL; |
| conn->disconn_cfm_cb = NULL; |
| |
| hci_conn_drop(conn); |
| |
| /* The device is paired so there is no need to remove |
| * its connection parameters anymore. |
| */ |
| clear_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags); |
| |
| hci_conn_put(conn); |
| |
| return err; |
| } |
| |
| void mgmt_smp_complete(struct hci_conn *conn, bool complete) |
| { |
| u8 status = complete ? MGMT_STATUS_SUCCESS : MGMT_STATUS_FAILED; |
| struct mgmt_pending_cmd *cmd; |
| |
| cmd = find_pairing(conn); |
| if (cmd) { |
| cmd->cmd_complete(cmd, status); |
| mgmt_pending_remove(cmd); |
| } |
| } |
| |
| static void pairing_complete_cb(struct hci_conn *conn, u8 status) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("status %u", status); |
| |
| cmd = find_pairing(conn); |
| if (!cmd) { |
| BT_DBG("Unable to find a pending command"); |
| return; |
| } |
| |
| cmd->cmd_complete(cmd, mgmt_status(status)); |
| mgmt_pending_remove(cmd); |
| } |
| |
| static void le_pairing_complete_cb(struct hci_conn *conn, u8 status) |
| { |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("status %u", status); |
| |
| if (!status) |
| return; |
| |
| cmd = find_pairing(conn); |
| if (!cmd) { |
| BT_DBG("Unable to find a pending command"); |
| return; |
| } |
| |
| cmd->cmd_complete(cmd, mgmt_status(status)); |
| mgmt_pending_remove(cmd); |
| } |
| |
| static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_pair_device *cp = data; |
| struct mgmt_rp_pair_device rp; |
| struct mgmt_pending_cmd *cmd; |
| u8 sec_level, auth_type; |
| struct hci_conn *conn; |
| int err; |
| |
| BT_DBG(""); |
| |
| memset(&rp, 0, sizeof(rp)); |
| bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr); |
| rp.addr.type = cp->addr.type; |
| |
| if (!bdaddr_type_is_valid(cp->addr.type)) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS, |
| &rp, sizeof(rp)); |
| |
| if (cp->io_cap > SMP_IO_KEYBOARD_DISPLAY) |
| return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS, |
| &rp, sizeof(rp)); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| MGMT_STATUS_NOT_POWERED, &rp, |
| sizeof(rp)); |
| goto unlock; |
| } |
| |
| if (hci_bdaddr_is_paired(hdev, &cp->addr.bdaddr, cp->addr.type)) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| MGMT_STATUS_ALREADY_PAIRED, &rp, |
| sizeof(rp)); |
| goto unlock; |
| } |
| |
| sec_level = BT_SECURITY_MEDIUM; |
| auth_type = HCI_AT_DEDICATED_BONDING; |
| |
| if (cp->addr.type == BDADDR_BREDR) { |
| conn = hci_connect_acl(hdev, &cp->addr.bdaddr, sec_level, |
| auth_type); |
| } else { |
| u8 addr_type = le_addr_type(cp->addr.type); |
| struct hci_conn_params *p; |
| |
| /* When pairing a new device, it is expected to remember |
| * this device for future connections. Adding the connection |
| * parameter information ahead of time allows tracking |
| * of the slave preferred values and will speed up any |
| * further connection establishment. |
| * |
| * If connection parameters already exist, then they |
| * will be kept and this function does nothing. |
| */ |
| p = hci_conn_params_add(hdev, &cp->addr.bdaddr, addr_type); |
| |
| if (p->auto_connect == HCI_AUTO_CONN_EXPLICIT) |
| p->auto_connect = HCI_AUTO_CONN_DISABLED; |
| |
| conn = hci_connect_le_scan(hdev, &cp->addr.bdaddr, |
| addr_type, sec_level, |
| HCI_LE_CONN_TIMEOUT); |
| } |
| |
| if (IS_ERR(conn)) { |
| int status; |
| |
| if (PTR_ERR(conn) == -EBUSY) |
| status = MGMT_STATUS_BUSY; |
| else if (PTR_ERR(conn) == -EOPNOTSUPP) |
| status = MGMT_STATUS_NOT_SUPPORTED; |
| else if (PTR_ERR(conn) == -ECONNREFUSED) |
| status = MGMT_STATUS_REJECTED; |
| else |
| status = MGMT_STATUS_CONNECT_FAILED; |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| status, &rp, sizeof(rp)); |
| goto unlock; |
| } |
| |
| if (conn->connect_cfm_cb) { |
| hci_conn_drop(conn); |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE, |
| MGMT_STATUS_BUSY, &rp, sizeof(rp)); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| hci_conn_drop(conn); |
| goto unlock; |
| } |
| |
| cmd->cmd_complete = pairing_complete; |
| |
| /* For LE, just connecting isn't a proof that the pairing finished */ |
| if (cp->addr.type == BDADDR_BREDR) { |
| conn->connect_cfm_cb = pairing_complete_cb; |
| conn->security_cfm_cb = pairing_complete_cb; |
| conn->disconn_cfm_cb = pairing_complete_cb; |
| } else { |
| conn->connect_cfm_cb = le_pairing_complete_cb; |
| conn->security_cfm_cb = le_pairing_complete_cb; |
| conn->disconn_cfm_cb = le_pairing_complete_cb; |
| } |
| |
| conn->io_capability = cp->io_cap; |
| cmd->user_data = hci_conn_get(conn); |
| |
| if ((conn->state == BT_CONNECTED || conn->state == BT_CONFIG) && |
| hci_conn_security(conn, sec_level, auth_type, true)) { |
| cmd->cmd_complete(cmd, 0); |
| mgmt_pending_remove(cmd); |
| } |
| |
| err = 0; |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int cancel_pair_device(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_addr_info *addr = data; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_conn *conn; |
| int err; |
| |
| BT_DBG(""); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, |
| MGMT_STATUS_NOT_POWERED); |
| goto unlock; |
| } |
| |
| cmd = pending_find(MGMT_OP_PAIR_DEVICE, hdev); |
| if (!cmd) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS); |
| goto unlock; |
| } |
| |
| conn = cmd->user_data; |
| |
| if (bacmp(&addr->bdaddr, &conn->dst) != 0) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, |
| MGMT_STATUS_INVALID_PARAMS); |
| goto unlock; |
| } |
| |
| cmd->cmd_complete(cmd, MGMT_STATUS_CANCELLED); |
| mgmt_pending_remove(cmd); |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0, |
| addr, sizeof(*addr)); |
| unlock: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int user_pairing_resp(struct sock *sk, struct hci_dev *hdev, |
| struct mgmt_addr_info *addr, u16 mgmt_op, |
| u16 hci_op, __le32 passkey) |
| { |
| struct mgmt_pending_cmd *cmd; |
| struct hci_conn *conn; |
| int err; |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_complete(sk, hdev->id, mgmt_op, |
| MGMT_STATUS_NOT_POWERED, addr, |
| sizeof(*addr)); |
| goto done; |
| } |
| |
| if (addr->type == BDADDR_BREDR) |
| conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &addr->bdaddr); |
| else |
| conn = hci_conn_hash_lookup_le(hdev, &addr->bdaddr, |
| le_addr_type(addr->type)); |
| |
| if (!conn) { |
| err = mgmt_cmd_complete(sk, hdev->id, mgmt_op, |
| MGMT_STATUS_NOT_CONNECTED, addr, |
| sizeof(*addr)); |
| goto done; |
| } |
| |
| if (addr->type == BDADDR_LE_PUBLIC || addr->type == BDADDR_LE_RANDOM) { |
| err = smp_user_confirm_reply(conn, mgmt_op, passkey); |
| if (!err) |
| err = mgmt_cmd_complete(sk, hdev->id, mgmt_op, |
| MGMT_STATUS_SUCCESS, addr, |
| sizeof(*addr)); |
| else |
| err = mgmt_cmd_complete(sk, hdev->id, mgmt_op, |
| MGMT_STATUS_FAILED, addr, |
| sizeof(*addr)); |
| |
| goto done; |
| } |
| |
| cmd = mgmt_pending_add(sk, mgmt_op, hdev, addr, sizeof(*addr)); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto done; |
| } |
| |
| cmd->cmd_complete = addr_cmd_complete; |
| |
| /* Continue with pairing via HCI */ |
| if (hci_op == HCI_OP_USER_PASSKEY_REPLY) { |
| struct hci_cp_user_passkey_reply cp; |
| |
| bacpy(&cp.bdaddr, &addr->bdaddr); |
| cp.passkey = passkey; |
| err = hci_send_cmd(hdev, hci_op, sizeof(cp), &cp); |
| } else |
| err = hci_send_cmd(hdev, hci_op, sizeof(addr->bdaddr), |
| &addr->bdaddr); |
| |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| done: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static int pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 len) |
| { |
| struct mgmt_cp_pin_code_neg_reply *cp = data; |
| |
| BT_DBG(""); |
| |
| return user_pairing_resp(sk, hdev, &cp->addr, |
| MGMT_OP_PIN_CODE_NEG_REPLY, |
| HCI_OP_PIN_CODE_NEG_REPLY, 0); |
| } |
| |
| static int user_confirm_reply(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_user_confirm_reply *cp = data; |
| |
| BT_DBG(""); |
| |
| if (len != sizeof(*cp)) |
| return mgmt_cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY, |
| MGMT_STATUS_INVALID_PARAMS); |
| |
| return user_pairing_resp(sk, hdev, &cp->addr, |
| MGMT_OP_USER_CONFIRM_REPLY, |
| HCI_OP_USER_CONFIRM_REPLY, 0); |
| } |
| |
| static int user_confirm_neg_reply(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 len) |
| { |
| struct mgmt_cp_user_confirm_neg_reply *cp = data; |
| |
| BT_DBG(""); |
| |
| return user_pairing_resp(sk, hdev, &cp->addr, |
| MGMT_OP_USER_CONFIRM_NEG_REPLY, |
| HCI_OP_USER_CONFIRM_NEG_REPLY, 0); |
| } |
| |
| static int user_passkey_reply(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_user_passkey_reply *cp = data; |
| |
| BT_DBG(""); |
| |
| return user_pairing_resp(sk, hdev, &cp->addr, |
| MGMT_OP_USER_PASSKEY_REPLY, |
| HCI_OP_USER_PASSKEY_REPLY, cp->passkey); |
| } |
| |
| static int user_passkey_neg_reply(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 len) |
| { |
| struct mgmt_cp_user_passkey_neg_reply *cp = data; |
| |
| BT_DBG(""); |
| |
| return user_pairing_resp(sk, hdev, &cp->addr, |
| MGMT_OP_USER_PASSKEY_NEG_REPLY, |
| HCI_OP_USER_PASSKEY_NEG_REPLY, 0); |
| } |
| |
| static void set_name_complete(struct hci_dev *hdev, u8 status, u16 opcode) |
| { |
| struct mgmt_cp_set_local_name *cp; |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("status 0x%02x", status); |
| |
| hci_dev_lock(hdev); |
| |
| cmd = pending_find(MGMT_OP_SET_LOCAL_NAME, hdev); |
| if (!cmd) |
| goto unlock; |
| |
| cp = cmd->param; |
| |
| if (status) |
| mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, |
| mgmt_status(status)); |
| else |
| mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0, |
| cp, sizeof(*cp)); |
| |
| mgmt_pending_remove(cmd); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int set_local_name(struct sock *sk, struct hci_dev *hdev, void *data, |
| u16 len) |
| { |
| struct mgmt_cp_set_local_name *cp = data; |
| struct mgmt_pending_cmd *cmd; |
| struct hci_request req; |
| int err; |
| |
| BT_DBG(""); |
| |
| hci_dev_lock(hdev); |
| |
| /* If the old values are the same as the new ones just return a |
| * direct command complete event. |
| */ |
| if (!memcmp(hdev->dev_name, cp->name, sizeof(hdev->dev_name)) && |
| !memcmp(hdev->short_name, cp->short_name, |
| sizeof(hdev->short_name))) { |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0, |
| data, len); |
| goto failed; |
| } |
| |
| memcpy(hdev->short_name, cp->short_name, sizeof(hdev->short_name)); |
| |
| if (!hdev_is_powered(hdev)) { |
| memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name)); |
| |
| err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0, |
| data, len); |
| if (err < 0) |
| goto failed; |
| |
| err = mgmt_generic_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, |
| data, len, sk); |
| |
| goto failed; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len); |
| if (!cmd) { |
| err = -ENOMEM; |
| goto failed; |
| } |
| |
| memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name)); |
| |
| hci_req_init(&req, hdev); |
| |
| if (lmp_bredr_capable(hdev)) { |
| __hci_req_update_name(&req); |
| __hci_req_update_eir(&req); |
| } |
| |
| /* The name is stored in the scan response data and so |
| * no need to udpate the advertising data here. |
| */ |
| if (lmp_le_capable(hdev)) |
| __hci_req_update_scan_rsp_data(&req, hdev->cur_adv_instance); |
| |
| err = hci_req_run(&req, set_name_complete); |
| if (err < 0) |
| mgmt_pending_remove(cmd); |
| |
| failed: |
| hci_dev_unlock(hdev); |
| return err; |
| } |
| |
| static void read_local_oob_data_complete(struct hci_dev *hdev, u8 status, |
| u16 opcode, struct sk_buff *skb) |
| { |
| struct mgmt_rp_read_local_oob_data mgmt_rp; |
| size_t rp_size = sizeof(mgmt_rp); |
| struct mgmt_pending_cmd *cmd; |
| |
| BT_DBG("%s status %u", hdev->name, status); |
| |
| cmd = pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev); |
| if (!cmd) |
| return; |
| |
| if (status || !skb) { |
| mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, |
| status ? mgmt_status(status) : MGMT_STATUS_FAILED); |
| goto remove; |
| } |
| |
| memset(&mgmt_rp, 0, sizeof(mgmt_rp)); |
| |
| if (opcode == HCI_OP_READ_LOCAL_OOB_DATA) { |
| struct hci_rp_read_local_oob_data *rp = (void *) skb->data; |
| |
| if (skb->len < sizeof(*rp)) { |
| mgmt_cmd_status(cmd->sk, hdev->id, |
| MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_FAILED); |
| goto remove; |
| } |
| |
| memcpy(mgmt_rp.hash192, rp->hash, sizeof(rp->hash)); |
| memcpy(mgmt_rp.rand192, rp->rand, sizeof(rp->rand)); |
| |
| rp_size -= sizeof(mgmt_rp.hash256) + sizeof(mgmt_rp.rand256); |
| } else { |
| struct hci_rp_read_local_oob_ext_data *rp = (void *) skb->data; |
| |
| if (skb->len < sizeof(*rp)) { |
| mgmt_cmd_status(cmd->sk, hdev->id, |
| MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_FAILED); |
| goto remove; |
| } |
| |
| memcpy(mgmt_rp.hash192, rp->hash192, sizeof(rp->hash192)); |
| memcpy(mgmt_rp.rand192, rp->rand192, sizeof(rp->rand192)); |
| |
| memcpy(mgmt_rp.hash256, rp->hash256, sizeof(rp->hash256)); |
| memcpy(mgmt_rp.rand256, rp->rand256, sizeof(rp->rand256)); |
| } |
| |
| mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_SUCCESS, &mgmt_rp, rp_size); |
| |
| remove: |
| mgmt_pending_remove(cmd); |
| } |
| |
| static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev, |
| void *data, u16 data_len) |
| { |
| struct mgmt_pending_cmd *cmd; |
| struct hci_request req; |
| int err; |
| |
| BT_DBG("%s", hdev->name); |
| |
| hci_dev_lock(hdev); |
| |
| if (!hdev_is_powered(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_NOT_POWERED); |
| goto unlock; |
| } |
| |
| if (!lmp_ssp_capable(hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_NOT_SUPPORTED); |
| goto unlock; |
| } |
| |
| if (pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev)) { |
| err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, |
| MGMT_STATUS_BUSY); |
| goto unlock; |
| } |
| |
| cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0); |
| if (!cmd) { |
|