--- /dev/null
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2022 Intel Corporation.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <poll.h>
+#include <stdbool.h>
+
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+
+#include "lib/bluetooth.h"
+#include "lib/mgmt.h"
+#include "lib/hci.h"
+#include "lib/hci_lib.h"
+
+#include "monitor/bt.h"
+#include "emulator/bthost.h"
+#include "emulator/hciemu.h"
+
+#include "src/shared/tester.h"
+#include "src/shared/mgmt.h"
+#include "src/shared/util.h"
+
+struct test_data {
+ const void *test_data;
+ int sock_fd;
+ struct hciemu *hciemu;
+ enum hciemu_type hciemu_type;
+ uint8_t client_num;
+ uint16_t hci_dev_id;
+
+ struct mgmt *mgmt;
+ uint16_t mgmt_index;
+ struct mgmt *mgmt_alt;
+ unsigned int mgmt_alt_ev_id;
+
+ uint16_t handle;
+ uint16_t acl_handle;
+ GIOChannel *io;
+ unsigned int io_id[2];
+ int step;
+ bool reconnect;
+
+ int unmet_conditions;
+};
+
+struct ioctl_data {
+ uint32_t cmd;
+ const uint32_t opt;
+ const void *param;
+ int (*cmd_param_func)(void *param, uint32_t *length);
+ int expected_ioctl_err;
+ const void *block_bdaddr;
+ const void *expected_data;
+ int (*expect_data_check_func)(const void *param, uint32_t length);
+};
+
+static void print_debug(const char *str, void *user_data)
+{
+ const char *prefix = user_data;
+
+ tester_print("%s%s", prefix, str);
+}
+
+static void test_add_condition(struct test_data *data)
+{
+ data->unmet_conditions++;
+
+ tester_print("Test condition added, total %d", data->unmet_conditions);
+}
+
+static void test_condition_complete(struct test_data *data)
+{
+ data->unmet_conditions--;
+
+ tester_print("Test condition complete, %d left",
+ data->unmet_conditions);
+
+ if (data->unmet_conditions > 0)
+ return;
+
+ tester_test_passed();
+}
+
+static int update_hci_dev_id(struct test_data *data)
+{
+ struct hci_dev_list_req *dl;
+ struct hci_dev_req *dr;
+ int ret = 0;
+
+ dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(uint16_t));
+ if (!dl)
+ return -ENOMEM;
+
+ dl->dev_num = HCI_MAX_DEV;
+ dr = dl->dev_req;
+
+ if (ioctl(data->sock_fd, HCIGETDEVLIST, (void *) dl) < 0) {
+ ret = -EIO;
+ goto exit;
+ }
+
+ if (dl->dev_num != 1) {
+ tester_warn("dev num mismatch returned %d:expected 1",
+ dl->dev_num);
+ ret = -ENODEV;
+ goto exit;
+ }
+
+ data->hci_dev_id = dr->dev_id;
+ tester_print("HCI device id: %d", data->hci_dev_id);
+
+exit:
+ free(dl);
+ return ret;
+}
+
+static void read_info_callback(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct mgmt_rp_read_info *rp = param;
+ char addr[18];
+ uint16_t manufacturer;
+ uint32_t supported_settings, current_settings;
+
+ tester_print("Read Info callback");
+ tester_print(" Status: 0x%02x", status);
+
+ if (status || !param) {
+ tester_pre_setup_failed();
+ return;
+ }
+
+ ba2str(&rp->bdaddr, addr);
+ manufacturer = btohs(rp->manufacturer);
+ supported_settings = btohl(rp->supported_settings);
+ current_settings = btohl(rp->current_settings);
+
+ tester_print(" Address: %s", addr);
+ tester_print(" Version: 0x%02x", rp->version);
+ tester_print(" Manufacturer: 0x%04x", manufacturer);
+ tester_print(" Supported settings: 0x%08x", supported_settings);
+ tester_print(" Current settings: 0x%08x", current_settings);
+ tester_print(" Class: 0x%02x%02x%02x",
+ rp->dev_class[2], rp->dev_class[1], rp->dev_class[0]);
+ tester_print(" Name: %s", rp->name);
+ tester_print(" Short name: %s", rp->short_name);
+
+ if (strcmp(hciemu_get_address(data->hciemu), addr)) {
+ tester_pre_setup_failed();
+ return;
+ }
+
+ tester_pre_setup_complete();
+}
+
+static void index_added_callback(uint16_t index, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ tester_print("Index Added callback");
+ tester_print(" Index: 0x%04x", index);
+
+ data->mgmt_index = index;
+
+ mgmt_send(data->mgmt, MGMT_OP_READ_INFO, data->mgmt_index, 0, NULL,
+ read_info_callback, NULL, NULL);
+}
+
+static void index_removed_callback(uint16_t index, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ tester_print("Index Removed callback");
+ tester_print(" Index: 0x%04x", index);
+
+ if (index != data->mgmt_index)
+ return;
+
+ mgmt_unregister_index(data->mgmt, data->mgmt_index);
+ mgmt_unregister_index(data->mgmt_alt, data->mgmt_index);
+
+ mgmt_unref(data->mgmt);
+ data->mgmt = NULL;
+
+ mgmt_unref(data->mgmt_alt);
+ data->mgmt_alt = NULL;
+
+ tester_post_teardown_complete();
+}
+
+static void read_index_list_callback(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ tester_print("Read Index List callback");
+ tester_print(" Status: 0x%02x", status);
+
+ if (status || !param) {
+ tester_pre_setup_failed();
+ return;
+ }
+
+ mgmt_register(data->mgmt, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
+ index_added_callback, NULL, NULL);
+
+ mgmt_register(data->mgmt, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
+ index_removed_callback, NULL, NULL);
+
+ data->hciemu = hciemu_new(data->hciemu_type);
+ if (!data->hciemu) {
+ tester_warn("Failed to setup HCI emulation");
+ tester_pre_setup_failed();
+ }
+
+ if (tester_use_debug())
+ hciemu_set_debug(data->hciemu, print_debug, "hciemu: ", NULL);
+
+ tester_print("New hciemu instance created");
+
+ data->sock_fd = hci_open_dev(0);
+ if (data->sock_fd < 0) {
+ tester_warn("Failed to open socket for ioctl");
+ tester_pre_setup_failed();
+ return;
+ }
+
+ update_hci_dev_id(data);
+}
+
+static void test_pre_setup(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ data->mgmt = mgmt_new_default();
+ if (!data->mgmt) {
+ tester_warn("Failed to setup mgmt interface");
+ tester_pre_setup_failed();
+ return;
+ }
+
+ data->mgmt_alt = mgmt_new_default();
+ if (!data->mgmt_alt) {
+ tester_warn("Failed to setup alternate management interface");
+ tester_pre_setup_failed();
+
+ mgmt_unref(data->mgmt);
+ data->mgmt = NULL;
+ return;
+ }
+
+
+ if (tester_use_debug()) {
+ mgmt_set_debug(data->mgmt, print_debug, "mgmt: ", NULL);
+ mgmt_set_debug(data->mgmt_alt, print_debug, "mgmt-alt: ", NULL);
+ }
+
+ mgmt_send(data->mgmt, MGMT_OP_READ_INDEX_LIST, MGMT_INDEX_NONE, 0, NULL,
+ read_index_list_callback, NULL, NULL);
+}
+
+static void test_post_teardown(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ if (data->sock_fd >= 0) {
+ tester_print("Socket closed");
+ hci_close_dev(data->sock_fd);
+ }
+
+ hciemu_unref(data->hciemu);
+ data->hciemu = NULL;
+}
+
+static void test_data_free(void *test_data)
+{
+ struct test_data *data = test_data;
+
+ // TODO: free any data allocated during pre-setup
+
+ free(data);
+}
+
+#define test_ioctl_full(name, data, setup, func, num) \
+ do { \
+ struct test_data *user; \
+ user = new0(struct test_data, 1); \
+ if (!user) \
+ break; \
+ user->hciemu_type = HCIEMU_TYPE_BREDRLE; \
+ user->test_data = data; \
+ user->client_num = num; \
+ tester_add_full(name, data, \
+ test_pre_setup, setup, func, NULL, \
+ test_post_teardown, 2, user, test_data_free); \
+ } while (0)
+
+#define test_ioctl(name, data, setup, func) \
+ test_ioctl_full(name, data, setup, func, 1)
+
+static void setup_powered_callback(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ if (status != MGMT_STATUS_SUCCESS) {
+ tester_setup_failed();
+ return;
+ }
+
+ tester_print("Controller powered on");
+
+ tester_setup_complete();
+}
+
+static void setup_powered(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+ unsigned char param[] = { 0x01 };
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_BONDABLE, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
+ sizeof(param), param,
+ setup_powered_callback, NULL, NULL);
+}
+
+static void setup_add_block_bdaddr(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+
+ if (!ioctl_data->block_bdaddr) {
+ tester_warn("Invalid test data: block bdaddr");
+ tester_setup_failed();
+ return;
+ }
+
+ if (ioctl(data->sock_fd, HCIBLOCKADDR, ioctl_data->block_bdaddr) < 0) {
+ tester_warn("Failed to add block bdaddr");
+ tester_setup_failed();
+ return;
+ }
+
+ tester_print("Added block BDADDR");
+
+ tester_setup_complete();
+}
+
+static int conn_list_empty_check_func(const void *param, uint32_t length)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+ const struct hci_conn_list_req *cl_input = ioctl_data->expected_data;
+ const struct hci_conn_list_req *cl = param;
+
+ if (cl->conn_num != cl_input->conn_num)
+ return -1;
+
+ return 0;
+}
+
+static int conn_info_cmd_param_func(void *param, uint32_t *length)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+ const struct hci_conn_info_req *cr_input = ioctl_data->param;
+ struct hci_conn_info_req *cr = param;
+
+ memcpy(&cr->bdaddr, &cr_input->bdaddr, sizeof(bdaddr_t));
+ cr->type = cr_input->type;
+
+ return 0;
+}
+
+static int auth_info_cmd_param_func(void *param, uint32_t *length)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+ const struct hci_auth_info_req *ar_input = ioctl_data->param;
+ struct hci_auth_info_req *ar = param;
+
+ memcpy(&ar->bdaddr, &ar_input->bdaddr, sizeof(bdaddr_t));
+ if (ar_input->type)
+ ar->type = ar_input->type;
+
+ return 0;
+}
+
+static const struct ioctl_data dev_down = {
+ .cmd = HCIDEVDOWN,
+};
+
+static const struct hci_dev_list_req dev_list_1 = {
+ .dev_num = 0x01,
+ .dev_req = {{
+ .dev_id = 0x00,
+ .dev_opt = 0x04,
+ }},
+};
+
+static const struct ioctl_data dev_list = {
+ .cmd = HCIGETDEVLIST,
+ .expected_data = (void *)&dev_list_1,
+};
+
+static const struct hci_dev_list_req dev_list_invalid_1_param = {
+ .dev_num = 0x00,
+};
+
+static const struct ioctl_data dev_list_invalid_1 = {
+ .cmd = HCIGETDEVLIST,
+ .param = (void *)&dev_list_invalid_1_param,
+ .expected_ioctl_err = EINVAL,
+};
+
+static const struct ioctl_data dev_info = {
+ .cmd = HCIGETDEVINFO,
+};
+
+static const struct ioctl_data reset_stat = {
+ .cmd = HCIDEVRESTAT,
+};
+
+static const struct ioctl_data set_link_mode_master = {
+ .cmd = HCISETLINKMODE,
+ .opt = HCI_LM_MASTER,
+};
+
+static const struct ioctl_data set_link_mode_accept = {
+ .cmd = HCISETLINKMODE,
+ .opt = HCI_LM_ACCEPT,
+};
+
+static const struct ioctl_data set_pkt_type_dm = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_DM1 | HCI_DM3 | HCI_DM5,
+};
+
+static const struct ioctl_data set_pkt_type_dh = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_DH1 | HCI_DH3 | HCI_DH5,
+};
+
+static const struct ioctl_data set_pkt_type_hv = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_HV1 | HCI_HV2 | HCI_HV3,
+};
+
+static const struct ioctl_data set_pkt_type_2dh = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_2DH1 | HCI_2DH3 | HCI_2DH5,
+};
+
+static const struct ioctl_data set_pkt_type_3dh = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_3DH1 | HCI_3DH3 | HCI_3DH5,
+};
+
+static const struct ioctl_data set_pkt_type_all = {
+ .cmd = HCISETPTYPE,
+ .opt = HCI_DM1 | HCI_DM3 | HCI_DM5 | HCI_DH1 | HCI_DH3 | HCI_DH5 |
+ HCI_HV1 | HCI_HV2 | HCI_HV3 | HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
+ HCI_3DH1 | HCI_3DH3 | HCI_3DH5,
+};
+
+static const struct ioctl_data set_acl_mtu_1 = {
+ .cmd = HCISETACLMTU,
+ .opt = 0x1 | (0x3FE << 16),
+};
+
+static const struct ioctl_data set_acl_mtu_2 = {
+ .cmd = HCISETACLMTU,
+ .opt = 0x4 | (0x63 << 16),
+};
+
+static const struct ioctl_data set_sco_mtu_1 = {
+ .cmd = HCISETSCOMTU,
+ .opt = 0x1 | (0x3FE << 16),
+};
+
+static const struct ioctl_data set_sco_mtu_2 = {
+ .cmd = HCISETSCOMTU,
+ .opt = 0x4 | (0x63 << 16),
+};
+
+static const uint8_t bdaddr1[] = {
+ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66
+};
+
+static const struct ioctl_data block_bdaddr_success = {
+ .cmd = HCIBLOCKADDR,
+ .param = bdaddr1,
+};
+
+static const struct ioctl_data block_bdaddr_fail = {
+ .cmd = HCIBLOCKADDR,
+ .param = bdaddr1,
+ .expected_ioctl_err = EEXIST,
+ .block_bdaddr = bdaddr1,
+};
+
+static const struct ioctl_data unblock_bdaddr_success = {
+ .cmd = HCIUNBLOCKADDR,
+ .param = bdaddr1,
+ .block_bdaddr = bdaddr1,
+};
+
+static const struct ioctl_data unblock_bdaddr_fail = {
+ .cmd = HCIUNBLOCKADDR,
+ .param = bdaddr1,
+ .expected_ioctl_err = ENOENT,
+};
+
+static const struct hci_conn_list_req conn_list_empty = {
+ .dev_id = 0x00,
+ .conn_num = 0x00,
+};
+
+static const struct ioctl_data conn_list_no_conn = {
+ .cmd = HCIGETCONNLIST,
+ .expected_data = (void *)&conn_list_empty,
+ .expect_data_check_func = conn_list_empty_check_func,
+};
+
+static const struct hci_conn_list_req conn_list_req_1 = {
+ .dev_id = 0x00,
+ .conn_num = 0x01,
+ .conn_info = {{
+ .handle = 0x002a,
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = 0x01,
+ .out = 0x00,
+ .state = 0x0001,
+ .link_mode = 0x00000000,
+ }},
+};
+
+static const struct ioctl_data conn_list = {
+ .cmd = HCIGETCONNLIST,
+ .expected_data = (void *)&conn_list_req_1,
+};
+
+static const struct hci_conn_info_req conn_info_req = {
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = ACL_LINK,
+ .conn_info = {{
+ .handle = 0x002a,
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = 0x01,
+ .out = 0x00,
+ .state = 0x0001,
+ .link_mode = 0x00000000,
+ }},
+};
+
+static const struct hci_conn_info_req conn_info_req_acl = {
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = ACL_LINK,
+};
+
+static const struct hci_conn_info_req conn_info_req_sco = {
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = SCO_LINK,
+};
+
+static const struct ioctl_data conn_info = {
+ .cmd = HCIGETCONNINFO,
+ .param = (void *)&conn_info_req_acl,
+ .cmd_param_func = conn_info_cmd_param_func,
+ .expected_data = (void *)&conn_info_req,
+};
+
+static const struct ioctl_data conn_info_no_conn = {
+ .cmd = HCIGETCONNINFO,
+ .param = (void *)&conn_info_req_acl,
+ .expected_ioctl_err = ENOENT,
+ .cmd_param_func = conn_info_cmd_param_func,
+};
+
+static const struct ioctl_data conn_info_wrong_type = {
+ .cmd = HCIGETCONNINFO,
+ .param = (void *)&conn_info_req_sco,
+ .expected_ioctl_err = ENOENT,
+ .cmd_param_func = conn_info_cmd_param_func,
+};
+
+static const struct hci_auth_info_req auth_info_req = {
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+};
+
+static const struct hci_auth_info_req auth_info_connected = {
+ .bdaddr = {{ 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00 }},
+ .type = 0x04,
+};
+
+static const struct ioctl_data auth_info_no_conn = {
+ .cmd = HCIGETAUTHINFO,
+ .param = (void *)&auth_info_req,
+ .expected_ioctl_err = ENOENT,
+ .cmd_param_func = auth_info_cmd_param_func,
+};
+
+static const struct ioctl_data auth_info = {
+ .cmd = HCIGETAUTHINFO,
+ .param = (void *)&auth_info_req,
+ .cmd_param_func = auth_info_cmd_param_func,
+ .expected_data = (void *)&auth_info_connected,
+};
+
+/* Allocate the command request parameters based on the command.
+ * returns the allocated request buffer and its length
+ */
+static int test_alloc_cmd_param(void **req, uint32_t *req_len)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+ struct hci_dev_req *dr = NULL;
+ struct hci_dev_info *di = NULL;
+ struct hci_dev_list_req *dl = NULL;
+ struct hci_conn_list_req *cl = NULL;
+ struct hci_conn_info *ci = NULL;
+ struct hci_conn_info_req *cr = NULL;
+ struct hci_auth_info_req *ar = NULL;
+ bdaddr_t *bdaddr = NULL;
+ uint32_t len;
+
+ switch (ioctl_data->cmd) {
+ case HCISETAUTH:
+ case HCISETENCRYPT:
+ case HCISETLINKMODE:
+ case HCISETPTYPE:
+ case HCISETACLMTU:
+ case HCISETSCOMTU:
+ len = sizeof(*dr);
+ dr = malloc(len);
+ if (!dr)
+ return -ENOMEM;
+ memset(dr, 0, len);
+ dr->dev_id = data->hci_dev_id;
+ dr->dev_opt = ioctl_data->opt;
+ *req = dr;
+ *req_len = len;
+ break;
+ case HCIGETDEVINFO:
+ len = sizeof(*di);
+ di = malloc(len);
+ if (!di)
+ return -ENOMEM;
+ memset(di, 0, len);
+ di->dev_id = data->hci_dev_id;
+ *req = di;
+ *req_len = len;
+ break;
+ case HCIGETDEVLIST:
+ len = sizeof(*dr) + sizeof(uint16_t);
+ dl = malloc(len);
+ if (!dl)
+ return -ENOMEM;
+ memset(dl, 0, len);
+ dl->dev_num = 1;
+ *req = dl;
+ *req_len = len;
+ break;
+ case HCIGETCONNLIST:
+ len = sizeof(*cl) + sizeof(*ci);
+ cl = malloc(len);
+ if (!cl)
+ return -ENOMEM;
+ memset(cl, 0, len);
+ cl->dev_id = data->hci_dev_id;
+ cl->conn_num = 1;
+ *req = cl;
+ *req_len = len;
+ break;
+ case HCIGETCONNINFO:
+ len = sizeof(*cr) + sizeof(*ci);
+ cr = malloc(len);
+ if (!cr)
+ return -ENOMEM;
+ memset(cr, 0, len);
+ *req = cr;
+ *req_len = len;
+ break;
+ case HCIGETAUTHINFO:
+ len = sizeof(*ar);
+ ar = malloc(len);
+ if (!ar)
+ return -ENOMEM;
+ memset(ar, 0, len);
+ *req = ar;
+ *req_len = len;
+ break;
+ case HCIBLOCKADDR:
+ case HCIUNBLOCKADDR:
+ len = sizeof(bdaddr_t);
+ bdaddr = malloc(len);
+ if (!bdaddr)
+ return -ENOMEM;
+ memset(bdaddr, 0, len);
+ *req = bdaddr;
+ *req_len = len;
+ break;
+ case HCIDEVUP:
+ case HCIDEVDOWN:
+ case HCIDEVRESET:
+ case HCIDEVRESTAT:
+ /* These command uses the HCI dev id for param */
+ return -ENODATA;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static void test_ioctl_common(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct ioctl_data *ioctl_data = data->test_data;
+ bool use_dev_id = false;
+ void *req = NULL;
+ uint32_t req_len = 0;
+ int ret;
+
+ ret = test_alloc_cmd_param(&req, &req_len);
+ if (ret < 0) {
+ if (ret == -ENODATA)
+ use_dev_id = true;
+ else {
+ tester_warn("Failed to allocate CMD parameter");
+ tester_test_failed();
+ return;
+ }
+ }
+
+ if (ioctl_data->expected_ioctl_err)
+ test_add_condition(data);
+
+ if (ioctl_data->expected_data)
+ test_add_condition(data);
+
+ if (!use_dev_id && ioctl_data->param) {
+ test_add_condition(data);
+ if (ioctl_data->cmd_param_func) {
+ ret = ioctl_data->cmd_param_func(req, &req_len);
+ if (ret) {
+ tester_warn("Failed to update cmd param");
+ tester_test_failed();
+ goto exit_free;
+ }
+ } else
+ memcpy(req, ioctl_data->param, req_len);
+
+ tester_print("Command Parameter is updated");
+ test_condition_complete(data);
+ }
+
+ if (use_dev_id)
+ ret = ioctl(data->sock_fd, ioctl_data->cmd, data->hci_dev_id);
+ else
+ ret = ioctl(data->sock_fd, ioctl_data->cmd, req);
+
+ if (ret < 0) {
+ if (ioctl_data->expected_ioctl_err) {
+ if (errno != ioctl_data->expected_ioctl_err) {
+ tester_warn("Unexpected error: %d expected: %d",
+ errno, ioctl_data->expected_ioctl_err);
+ tester_test_failed();
+ goto exit_free;
+ }
+
+ test_condition_complete(data);
+ tester_print("Received expected error: %d", errno);
+ goto exit_pass;
+ }
+
+ tester_warn("IOCTL failed with error: %d", errno);
+ tester_test_failed();
+ goto exit_free;
+ }
+
+ if (ioctl_data->expected_data && req) {
+ if (ioctl_data->expect_data_check_func)
+ ret = ioctl_data->expect_data_check_func(req, req_len);
+ else
+ ret = memcmp(req, ioctl_data->expected_data, req_len);
+
+ if (ret != 0) {
+ tester_warn("Mismatch expected data");
+ util_hexdump('>', req, req_len, print_debug, "");
+ util_hexdump('!', ioctl_data->expected_data, req_len,
+ print_debug, "");
+ tester_test_failed();
+ goto exit_free;
+ }
+
+ test_condition_complete(data);
+ }
+
+exit_pass:
+ tester_test_passed();
+exit_free:
+ if (req)
+ free(req);
+
+}
+
+static void test_ioctl_connected_event(uint16_t index, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ tester_print("Device Connected");
+
+ test_ioctl_common(data);
+}
+
+static void test_ioctl_connection(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+ unsigned int id;
+ const uint8_t *central_bdaddr;
+ struct bthost *bthost;
+ uint8_t addr_type;
+
+ tester_print("Registering %s notification",
+ mgmt_evstr(MGMT_EV_DEVICE_CONNECTED));
+ id = mgmt_register(data->mgmt_alt, MGMT_EV_DEVICE_CONNECTED,
+ data->mgmt_index,
+ test_ioctl_connected_event,
+ NULL, NULL);
+ data->mgmt_alt_ev_id = id;
+
+ central_bdaddr = hciemu_get_central_bdaddr(data->hciemu);
+ if (!central_bdaddr) {
+ tester_warn("No central bdaddr");
+ tester_setup_failed();
+ return;
+ }
+
+ addr_type = data->hciemu_type == HCIEMU_TYPE_BREDRLE ? BDADDR_BREDR :
+ BDADDR_LE_PUBLIC;
+ tester_print("ADDR TYPE: %d", addr_type);
+ bthost = hciemu_client_get_host(data->hciemu);
+ bthost_hci_connect(bthost, central_bdaddr, addr_type);
+}
+
+int main(int argc, char *argv[])
+{
+ tester_init(&argc, &argv);
+
+ test_ioctl("HCI Down", &dev_down, NULL, test_ioctl_common);
+
+ test_ioctl("Device List", &dev_list,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Device List - Invalid Param 1", &dev_list_invalid_1,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Device Info", &dev_info,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Reset Stat", &reset_stat,
+ setup_powered, test_ioctl_common);
+
+ test_ioctl("Set Link Mode - ACCEPT", &set_link_mode_accept,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Link Mode - MASTER", &set_link_mode_master,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - DM", &set_pkt_type_dm,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - DH", &set_pkt_type_dh,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - HV", &set_pkt_type_hv,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - 2-DH", &set_pkt_type_2dh,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - 2-DH", &set_pkt_type_3dh,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set Pkt Type - ALL", &set_pkt_type_all,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set ACL MTU - 1", &set_acl_mtu_1,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set ACL MTU - 2", &set_acl_mtu_2,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set SCO MTU - 1", &set_sco_mtu_1,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Set SCO MTU - 2", &set_sco_mtu_2,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Block BDADDR - Success", &block_bdaddr_success,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Block BDADDR - Fail", &block_bdaddr_fail,
+ setup_add_block_bdaddr, test_ioctl_common);
+
+ test_ioctl("Unblock BDADDR - Success", &unblock_bdaddr_success,
+ setup_add_block_bdaddr, test_ioctl_common);
+
+ test_ioctl("Unblock BDADDR - Fail", &unblock_bdaddr_fail,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Connection List - No Conn", &conn_list_no_conn,
+ NULL, test_ioctl_common);
+
+ test_ioctl("Connection List", &conn_list,
+ setup_powered, test_ioctl_connection);
+
+ test_ioctl("Connection Info", &conn_info,
+ setup_powered, test_ioctl_connection);
+
+ test_ioctl("Connection Info - No Connection", &conn_info_no_conn,
+ setup_powered, test_ioctl_common);
+
+ test_ioctl("Connection Info - Wrong Type", &conn_info_wrong_type,
+ setup_powered, test_ioctl_common);
+
+ test_ioctl("Authentication Info - No Connection", &auth_info_no_conn,
+ setup_powered, test_ioctl_common);
+
+ test_ioctl("Authentication Info", &auth_info,
+ setup_powered, test_ioctl_connection);
+
+ return tester_run();
+}
projects / platform / upstream / bluez.git / commitdiff