blob: 3a557923b9c8638359238e93d87422777a92e392 [file] [log] [blame]
/*
* Copyright (C) 2014 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <stdbool.h>
#include <unistd.h>
#include <libgen.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <sys/signalfd.h>
#include "lib/bluetooth.h"
#include "lib/mgmt.h"
#include "src/shared/util.h"
#include "src/shared/tester.h"
#include "src/shared/mgmt.h"
#include "src/shared/queue.h"
#include "emulator/bthost.h"
#include "monitor/bt.h"
#include "tester-main.h"
static char exec_dir[PATH_MAX + 1];
static gint scheduled_cbacks_num;
#define EMULATOR_SIGNAL_TIMEOUT 2 /* in seconds */
#define EMULATOR_SIGNAL "emulator_started"
#define BT_TRANSPORT_UNKNOWN 0x00
static struct {
uint16_t cb_num;
const char *str;
} cb_table[] = {
DBG_CB(CB_BT_NONE),
DBG_CB(CB_BT_ADAPTER_STATE_CHANGED),
DBG_CB(CB_BT_ADAPTER_PROPERTIES),
DBG_CB(CB_BT_REMOTE_DEVICE_PROPERTIES),
DBG_CB(CB_BT_DEVICE_FOUND),
DBG_CB(CB_BT_DISCOVERY_STATE_CHANGED),
DBG_CB(CB_BT_PIN_REQUEST),
DBG_CB(CB_BT_SSP_REQUEST),
DBG_CB(CB_BT_BOND_STATE_CHANGED),
DBG_CB(CB_BT_ACL_STATE_CHANGED),
DBG_CB(CB_BT_THREAD_EVT),
DBG_CB(CB_BT_DUT_MODE_RECV),
DBG_CB(CB_BT_LE_TEST_MODE),
/* Hidhost cb */
DBG_CB(CB_HH_CONNECTION_STATE),
DBG_CB(CB_HH_HID_INFO),
DBG_CB(CB_HH_PROTOCOL_MODE),
DBG_CB(CB_HH_IDLE_TIME),
DBG_CB(CB_HH_GET_REPORT),
DBG_CB(CB_HH_VIRTUAL_UNPLUG),
/* PAN cb */
DBG_CB(CB_PAN_CONTROL_STATE),
DBG_CB(CB_PAN_CONNECTION_STATE),
/* HDP cb */
DBG_CB(CB_HDP_APP_REG_STATE),
DBG_CB(CB_HDP_CHANNEL_STATE),
/* A2DP cb */
DBG_CB(CB_A2DP_CONN_STATE),
DBG_CB(CB_A2DP_AUDIO_STATE),
/* AVRCP */
DBG_CB(CB_AVRCP_PLAY_STATUS_REQ),
DBG_CB(CB_AVRCP_PLAY_STATUS_RSP),
DBG_CB(CB_AVRCP_REG_NOTIF_REQ),
DBG_CB(CB_AVRCP_REG_NOTIF_RSP),
DBG_CB(CB_AVRCP_GET_ATTR_REQ),
DBG_CB(CB_AVRCP_GET_ATTR_RSP),
/* Gatt client */
DBG_CB(CB_GATTC_REGISTER_CLIENT),
DBG_CB(CB_GATTC_SCAN_RESULT),
DBG_CB(CB_GATTC_OPEN),
DBG_CB(CB_GATTC_CLOSE),
DBG_CB(CB_GATTC_SEARCH_COMPLETE),
DBG_CB(CB_GATTC_SEARCH_RESULT),
DBG_CB(CB_GATTC_GET_CHARACTERISTIC),
DBG_CB(CB_GATTC_GET_DESCRIPTOR),
DBG_CB(CB_GATTC_GET_INCLUDED_SERVICE),
DBG_CB(CB_GATTC_REGISTER_FOR_NOTIFICATION),
DBG_CB(CB_GATTC_NOTIFY),
DBG_CB(CB_GATTC_READ_CHARACTERISTIC),
DBG_CB(CB_GATTC_WRITE_CHARACTERISTIC),
DBG_CB(CB_GATTC_READ_DESCRIPTOR),
DBG_CB(CB_GATTC_WRITE_DESCRIPTOR),
DBG_CB(CB_GATTC_EXECUTE_WRITE),
DBG_CB(CB_GATTC_READ_REMOTE_RSSI),
DBG_CB(CB_GATTC_LISTEN),
/* Gatt server */
DBG_CB(CB_GATTS_REGISTER_SERVER),
DBG_CB(CB_GATTS_CONNECTION),
DBG_CB(CB_GATTS_SERVICE_ADDED),
DBG_CB(CB_GATTS_INCLUDED_SERVICE_ADDED),
DBG_CB(CB_GATTS_CHARACTERISTIC_ADDED),
DBG_CB(CB_GATTS_DESCRIPTOR_ADDED),
DBG_CB(CB_GATTS_SERVICE_STARTED),
DBG_CB(CB_GATTS_SERVICE_STOPPED),
DBG_CB(CB_GATTS_SERVICE_DELETED),
DBG_CB(CB_GATTS_REQUEST_READ),
DBG_CB(CB_GATTS_REQUEST_WRITE),
DBG_CB(CB_GATTS_REQUEST_EXEC_WRITE),
DBG_CB(CB_GATTS_RESPONSE_CONFIRMATION),
DBG_CB(CB_GATTS_INDICATION_SEND),
/* Map client */
DBG_CB(CB_MAP_CLIENT_REMOTE_MAS_INSTANCES),
/* Emulator callbacks */
DBG_CB(CB_EMU_CONFIRM_SEND_DATA),
DBG_CB(CB_EMU_ENCRYPTION_ENABLED),
DBG_CB(CB_EMU_ENCRYPTION_DISABLED),
DBG_CB(CB_EMU_CONNECTION_REJECTED),
DBG_CB(CB_EMU_VALUE_INDICATION),
DBG_CB(CB_EMU_VALUE_NOTIFICATION),
DBG_CB(CB_EMU_READ_RESPONSE),
DBG_CB(CB_EMU_WRITE_RESPONSE),
DBG_CB(CB_EMU_ATT_ERROR),
};
static gboolean check_callbacks_called(gpointer user_data)
{
/*
* Wait for all callbacks scheduled in current test context to execute
* in main loop. This will avoid late callback calls after test case has
* already failed or timed out.
*/
if (g_atomic_int_get(&scheduled_cbacks_num) == 0) {
tester_teardown_complete();
return FALSE;
} else if (scheduled_cbacks_num < 0) {
tester_warn("Unscheduled callback called!");
return FALSE;
}
return TRUE;
}
static void check_daemon_term(void)
{
int status;
pid_t pid;
struct test_data *data = tester_get_data();
if (!data)
return;
pid = waitpid(data->bluetoothd_pid, &status, WNOHANG);
if (pid != data->bluetoothd_pid)
return;
data->bluetoothd_pid = 0;
if (WIFEXITED(status) && (WEXITSTATUS(status) == EXIT_SUCCESS)) {
g_idle_add(check_callbacks_called, NULL);
return;
}
tester_warn("Unexpected Daemon shutdown with status %d", status);
}
static gboolean signal_handler(GIOChannel *channel, GIOCondition cond,
gpointer user_data)
{
struct signalfd_siginfo si;
ssize_t result;
int fd;
if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
return FALSE;
fd = g_io_channel_unix_get_fd(channel);
result = read(fd, &si, sizeof(si));
if (result != sizeof(si))
return FALSE;
switch (si.ssi_signo) {
case SIGCHLD:
check_daemon_term();
break;
}
return TRUE;
}
static guint setup_signalfd(void)
{
GIOChannel *channel;
guint source;
sigset_t mask;
int fd;
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
return 0;
fd = signalfd(-1, &mask, 0);
if (fd < 0)
return 0;
channel = g_io_channel_unix_new(fd);
g_io_channel_set_close_on_unref(channel, TRUE);
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_channel_set_buffered(channel, FALSE);
source = g_io_add_watch(channel,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
signal_handler, NULL);
g_io_channel_unref(channel);
return source;
}
static void test_post_teardown(const void *test_data)
{
struct test_data *data = tester_get_data();
/* remove hook for encryption change */
hciemu_del_hook(data->hciemu, HCIEMU_HOOK_POST_EVT, 0x08);
hciemu_unref(data->hciemu);
data->hciemu = NULL;
g_source_remove(data->signalfd);
data->signalfd = 0;
}
static void bluetoothd_start(int hci_index)
{
char prg_name[PATH_MAX + 1];
char index[8];
char *prg_argv[5];
snprintf(prg_name, sizeof(prg_name), "%s/%s", exec_dir, "bluetoothd");
snprintf(index, sizeof(index), "%d", hci_index);
prg_argv[0] = prg_name;
prg_argv[1] = "-i";
prg_argv[2] = index;
prg_argv[3] = "-d";
prg_argv[4] = NULL;
if (!tester_use_debug())
fclose(stderr);
execve(prg_argv[0], prg_argv, NULL);
}
static void emulator(int pipe, int hci_index)
{
static const char SYSTEM_SOCKET_PATH[] = "\0android_system";
char buf[1024];
struct sockaddr_un addr;
struct timeval tv;
int fd;
ssize_t len;
fd = socket(PF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0);
if (fd < 0)
goto failed;
tv.tv_sec = EMULATOR_SIGNAL_TIMEOUT;
tv.tv_usec = 0;
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, SYSTEM_SOCKET_PATH, sizeof(SYSTEM_SOCKET_PATH));
if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Failed to bind system socket");
goto failed;
}
len = write(pipe, EMULATOR_SIGNAL, sizeof(EMULATOR_SIGNAL));
if (len != sizeof(EMULATOR_SIGNAL))
goto failed;
memset(buf, 0, sizeof(buf));
len = read(fd, buf, sizeof(buf));
if (len <= 0 || strcmp(buf, "bluetooth.start=daemon"))
goto failed;
close(pipe);
close(fd);
return bluetoothd_start(hci_index);
failed:
close(pipe);
if (fd >= 0)
close(fd);
}
static void mgmt_debug(const char *str, void *user_data)
{
const char *prefix = user_data;
tester_print("%s%s", prefix, str);
}
static bool hciemu_post_encr_hook(const void *data, uint16_t len,
void *user_data)
{
struct step *step;
/*
* Expected data: status (1 octet) + conn. handle (2 octets) +
* encryption flag (1 octet)
*/
if (len < 4)
return true;
step = g_new0(struct step, 1);
step->callback = ((uint8_t *)data)[3] ? CB_EMU_ENCRYPTION_ENABLED :
CB_EMU_ENCRYPTION_DISABLED;
schedule_callback_verification(step);
return true;
}
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;
}
/* set hook for encryption change */
hciemu_add_hook(data->hciemu, HCIEMU_HOOK_POST_EVT, 0x08,
hciemu_post_encr_hook, NULL);
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_unref(data->mgmt);
data->mgmt = 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();
return;
}
tester_print("New hciemu instance created");
}
static void test_pre_setup(const void *test_data)
{
struct test_data *data = tester_get_data();
data->signalfd = setup_signalfd();
if (!data->signalfd) {
tester_warn("Failed to setup signalfd");
tester_pre_setup_failed();
return;
}
data->mgmt = mgmt_new_default();
if (!data->mgmt) {
tester_warn("Failed to setup management interface");
tester_pre_setup_failed();
return;
}
if (!tester_use_debug())
fclose(stderr);
else
mgmt_set_debug(data->mgmt, mgmt_debug, "mgmt: ", NULL);
mgmt_send(data->mgmt, MGMT_OP_READ_INDEX_LIST, MGMT_INDEX_NONE, 0,
NULL, read_index_list_callback, NULL, NULL);
}
static bool match_property(bt_property_t *exp_prop, bt_property_t *rec_prop,
int prop_num)
{
if (exp_prop->type && (exp_prop->type != rec_prop->type))
return 0;
if (exp_prop->len && (exp_prop->len != rec_prop->len)) {
tester_debug("Property [%d] len don't match! received=%d, "
"expected=%d", prop_num, rec_prop->len,
exp_prop->len);
return 0;
}
if (exp_prop->val && memcmp(exp_prop->val, rec_prop->val,
exp_prop->len)) {
tester_debug("Property [%d] value don't match!", prop_num);
return 0;
}
return 1;
}
static bool match_mas_inst(btmce_mas_instance_t *exp_inst,
btmce_mas_instance_t *rec_inst, int inst_num)
{
if (exp_inst->id && (exp_inst->id != rec_inst->id)) {
tester_debug("MAS inst. [%d] id missmatch %d vs %d", inst_num,
rec_inst->id, exp_inst->id);
return 0;
}
if (exp_inst->scn && (exp_inst->scn != rec_inst->scn)) {
tester_debug("MAS inst. [%d] scn missmatch %d vs %d", inst_num,
rec_inst->scn, exp_inst->scn);
return 0;
}
if (exp_inst->msg_types &&
(exp_inst->msg_types != rec_inst->msg_types)) {
tester_debug("Mas inst. [%d] mesg type missmatch %d vs %d",
inst_num, rec_inst->scn, exp_inst->scn);
return 0;
}
if (exp_inst->p_name && memcmp(exp_inst->p_name, rec_inst->p_name,
strlen(exp_inst->p_name))) {
tester_debug("Mas inst. [%d] name don't match!", inst_num);
return 0;
}
return 1;
}
static int verify_property(bt_property_t *exp_props, int exp_num_props,
bt_property_t *rec_props, int rec_num_props)
{
int i, j;
int exp_prop_to_find = exp_num_props;
if (rec_num_props == 0)
return 1;
if (exp_num_props == 0) {
tester_debug("Wrong number of expected properties given");
tester_test_failed();
return 1;
}
/* Get first exp prop to match and search for it */
for (i = 0; i < exp_num_props; i++) {
for (j = 0; j < rec_num_props; j++) {
if (match_property(&exp_props[i], &rec_props[j], i)) {
exp_prop_to_find--;
break;
}
}
}
return exp_prop_to_find;
}
static int verify_mas_inst(btmce_mas_instance_t *exp_inst, int exp_num_inst,
btmce_mas_instance_t *rec_inst,
int rec_num_inst)
{
int i, j;
int exp_inst_to_find = exp_num_inst;
if (rec_num_inst == 0)
return 1;
if (exp_num_inst == 0) {
tester_debug("Wrong number of expected MAS instances given");
tester_test_failed();
return 1;
}
for (i = 0; i < exp_num_inst; i++) {
for (j = 0; j < rec_num_inst; j++) {
if (match_mas_inst(&exp_inst[i], &rec_inst[i], i)) {
exp_inst_to_find--;
break;
}
}
}
return exp_inst_to_find;
}
/*
* Check each test case step if test case expected
* data is set and match it with expected result.
*/
static bool verify_gatt_ids(btgatt_gatt_id_t *a, btgatt_gatt_id_t *b)
{
if (memcmp(&a->uuid, &b->uuid, sizeof(bt_uuid_t)))
return false;
if (a->inst_id != b->inst_id)
return false;
return true;
}
static bool verify_services(btgatt_srvc_id_t *a, btgatt_srvc_id_t *b)
{
if (a->is_primary != b->is_primary)
return false;
return verify_gatt_ids(&a->id, &b->id);
}
static bool match_data(struct step *step)
{
struct test_data *data = tester_get_data();
const struct step *exp;
exp = queue_peek_head(data->steps);
if (!exp) {
/* Can occure while test passed already */
tester_debug("Cannot get step to match");
return false;
}
if (exp->action_status != step->action_status) {
tester_debug("Action status don't match");
return false;
}
if (!exp->callback && !step->callback)
return true;
if (exp->callback != step->callback) {
tester_debug("Callback type mismatch: %s vs %s",
cb_table[step->callback].str,
cb_table[exp->callback].str);
return false;
}
if (exp->callback_result.state != step->callback_result.state) {
tester_debug("Callback state mismatch: %d vs %d",
step->callback_result.state,
exp->callback_result.state);
return false;
}
if (exp->callback_result.status != step->callback_result.status) {
tester_debug("Callback status mismatch: %d vs %d",
step->callback_result.status,
exp->callback_result.status);
return false;
}
if (exp->callback_result.mode != step->callback_result.mode) {
tester_debug("Callback mode mismatch: %02x vs %02x",
step->callback_result.mode,
exp->callback_result.mode);
return false;
}
if (exp->callback_result.report_size !=
step->callback_result.report_size) {
tester_debug("Callback report size mismatch: %d vs %d",
step->callback_result.report_size,
exp->callback_result.report_size);
return false;
}
if (exp->callback_result.ctrl_state !=
step->callback_result.ctrl_state) {
tester_debug("Callback ctrl state mismatch: %d vs %d",
step->callback_result.ctrl_state,
exp->callback_result.ctrl_state);
return false;
}
if (exp->callback_result.conn_state !=
step->callback_result.conn_state) {
tester_debug("Callback connection state mismatch: %d vs %d",
step->callback_result.conn_state,
exp->callback_result.conn_state);
return false;
}
if (exp->callback_result.local_role !=
step->callback_result.local_role) {
tester_debug("Callback local_role mismatch: %d vs %d",
step->callback_result.local_role,
exp->callback_result.local_role);
return false;
}
if (exp->callback_result.remote_role !=
step->callback_result.remote_role) {
tester_debug("Callback remote_role mismatch: %d vs %d",
step->callback_result.remote_role,
exp->callback_result.remote_role);
return false;
}
if (exp->callback_result.app_id != step->callback_result.app_id) {
tester_debug("Callback app_id mismatch: %d vs %d",
step->callback_result.app_id,
exp->callback_result.app_id);
return false;
}
if (exp->callback_result.channel_id !=
step->callback_result.channel_id) {
tester_debug("Callback channel_id mismatch: %d vs %d",
step->callback_result.channel_id,
exp->callback_result.channel_id);
return false;
}
if (exp->callback_result.mdep_cfg_index !=
step->callback_result.mdep_cfg_index) {
tester_debug("Callback mdep_cfg_index mismatch: %d vs %d",
step->callback_result.mdep_cfg_index,
exp->callback_result.mdep_cfg_index);
return false;
}
if (exp->callback_result.app_state != step->callback_result.app_state) {
tester_debug("Callback app_state mismatch: %d vs %d",
step->callback_result.app_state,
exp->callback_result.app_state);
return false;
}
if (exp->callback_result.channel_state !=
step->callback_result.channel_state) {
tester_debug("Callback channel_state mismatch: %d vs %d",
step->callback_result.channel_state,
exp->callback_result.channel_state);
return false;
}
if (exp->callback_result.av_conn_state !=
step->callback_result.av_conn_state) {
tester_debug("Callback av conn state mismatch: 0x%x vs 0x%x",
step->callback_result.av_conn_state,
exp->callback_result.av_conn_state);
return false;
}
if (exp->callback_result.av_audio_state !=
step->callback_result.av_audio_state) {
tester_debug("Callback av audio state mismatch: 0x%x vs 0x%x",
step->callback_result.av_audio_state,
exp->callback_result.av_audio_state);
return false;
}
if (exp->callback_result.song_length !=
step->callback_result.song_length) {
tester_debug("Callback song_length mismatch: 0x%x vs 0x%x",
step->callback_result.song_length,
exp->callback_result.song_length);
return false;
}
if (exp->callback_result.song_position !=
step->callback_result.song_position) {
tester_debug("Callback song_position mismatch: 0x%x vs 0x%x",
step->callback_result.song_position,
exp->callback_result.song_position);
return false;
}
if (exp->callback_result.play_status !=
step->callback_result.play_status) {
tester_debug("Callback play_status mismatch: 0x%x vs 0x%x",
step->callback_result.play_status,
exp->callback_result.play_status);
return false;
}
if (exp->callback_result.rc_index !=
step->callback_result.rc_index) {
tester_debug("Callback rc_index mismatch");
return false;
}
if (exp->callback_result.num_of_attrs !=
step->callback_result.num_of_attrs) {
tester_debug("Callback rc num of attrs mismatch");
return false;
}
if (exp->callback_result.attrs) {
if (memcmp(step->callback_result.attrs,
exp->callback_result.attrs,
exp->callback_result.num_of_attrs *
sizeof(btrc_element_attr_val_t))) {
tester_debug("Callback rc element attributes doesn't match");
return false;
}
}
if (exp->callback_result.pairing_variant !=
step->callback_result.pairing_variant) {
tester_debug("Callback pairing result mismatch: %d vs %d",
step->callback_result.pairing_variant,
exp->callback_result.pairing_variant);
return false;
}
if (exp->callback_result.adv_data != step->callback_result.adv_data) {
tester_debug("Callback adv. data status mismatch: %d vs %d",
step->callback_result.adv_data,
exp->callback_result.adv_data);
return false;
}
if (exp->callback_result.conn_id != step->callback_result.conn_id) {
tester_debug("Callback conn_id mismatch: %d vs %d",
step->callback_result.conn_id,
exp->callback_result.conn_id);
return false;
}
if (exp->callback_result.gatt_app_id !=
step->callback_result.gatt_app_id) {
tester_debug("Callback gatt_app_id mismatch: %d vs %d",
step->callback_result.gatt_app_id,
exp->callback_result.gatt_app_id);
return false;
}
if (exp->callback_result.properties &&
verify_property(exp->callback_result.properties,
exp->callback_result.num_properties,
step->callback_result.properties,
step->callback_result.num_properties)) {
tester_debug("Gatt properties don't match");
return false;
}
if (exp->callback_result.service &&
!verify_services(step->callback_result.service,
exp->callback_result.service)) {
tester_debug("Gatt service doesn't match");
return false;
}
if (exp->callback_result.characteristic) {
btgatt_gatt_id_t *a;
btgatt_gatt_id_t *b;
a = step->callback_result.characteristic;
b = exp->callback_result.characteristic;
if (!verify_gatt_ids(a, b)) {
tester_debug("Gatt char doesn't match");
return false;
}
}
if (exp->callback_result.char_prop != step->callback_result.char_prop) {
tester_debug("Gatt char prop mismatch: %d vs %d",
step->callback_result.char_prop,
exp->callback_result.char_prop);
return false;
}
if (exp->callback_result.descriptor) {
btgatt_gatt_id_t *a;
btgatt_gatt_id_t *b;
a = step->callback_result.descriptor;
b = exp->callback_result.descriptor;
if (!verify_gatt_ids(a, b)) {
tester_debug("Gatt desc doesn't match");
return false;
}
}
if (exp->callback_result.included) {
if (!verify_services(step->callback_result.included,
exp->callback_result.included)) {
tester_debug("Gatt include srvc doesn't match");
return false;
}
}
if (exp->callback_result.read_params) {
if (memcmp(step->callback_result.read_params,
exp->callback_result.read_params,
sizeof(btgatt_read_params_t))) {
tester_debug("Gatt read_param doesn't match");
return false;
}
}
if (exp->callback_result.write_params) {
if (memcmp(step->callback_result.write_params,
exp->callback_result.write_params,
sizeof(btgatt_write_params_t))) {
tester_debug("Gatt write_param doesn't match");
return false;
}
if (exp->callback_result.notification_registered !=
step->callback_result.notification_registered) {
tester_debug("Gatt registered flag mismatch");
return false;
}
if (exp->callback_result.notify_params) {
if (memcmp(step->callback_result.notify_params,
exp->callback_result.notify_params,
sizeof(btgatt_notify_params_t))) {
tester_debug("Gatt notify_param doesn't match");
return false;
}
}
}
if (exp->callback_result.connected !=
step->callback_result.connected) {
tester_debug("Gatt server conn status mismatch: %d vs %d",
step->callback_result.connected,
exp->callback_result.connected);
return false;
}
if (exp->callback_result.attr_handle &&
step->callback_result.attr_handle)
if (*exp->callback_result.attr_handle !=
*step->callback_result.attr_handle) {
tester_debug("Gatt attribute handle mismatch: %d vs %d",
*step->callback_result.attr_handle,
*exp->callback_result.attr_handle);
return false;
}
if (exp->callback_result.srvc_handle &&
step->callback_result.srvc_handle)
if (*exp->callback_result.srvc_handle !=
*step->callback_result.srvc_handle) {
tester_debug("Gatt service handle mismatch: %d vs %d",
*step->callback_result.srvc_handle,
*exp->callback_result.srvc_handle);
return false;
}
if (exp->callback_result.inc_srvc_handle &&
step->callback_result.inc_srvc_handle)
if (*exp->callback_result.inc_srvc_handle !=
*step->callback_result.inc_srvc_handle) {
tester_debug("Gatt inc. srvc handle mismatch: %d vs %d",
*step->callback_result.inc_srvc_handle,
*exp->callback_result.inc_srvc_handle);
return false;
}
if (exp->callback_result.uuid && step->callback_result.uuid)
if (memcmp(exp->callback_result.uuid,
step->callback_result.uuid,
sizeof(*exp->callback_result.uuid))) {
tester_debug("Uuid mismatch");
return false;
}
if (exp->callback_result.trans_id != step->callback_result.trans_id) {
tester_debug("Gatt trans id mismatch: %d vs %d",
exp->callback_result.trans_id,
step->callback_result.trans_id);
return false;
}
if (exp->callback_result.offset != step->callback_result.offset) {
tester_debug("Gatt offset mismatch: %d vs %d",
exp->callback_result.offset,
step->callback_result.offset);
return false;
}
if (exp->callback_result.is_long != step->callback_result.is_long) {
tester_debug("Gatt is long attr value flag mismatch: %d vs %d",
exp->callback_result.is_long,
step->callback_result.is_long);
return false;
}
if (exp->callback_result.length > 0) {
if (exp->callback_result.length !=
step->callback_result.length) {
tester_debug("Gatt attr length mismatch: %d vs %d",
exp->callback_result.length,
step->callback_result.length);
return false;
}
if (!exp->callback_result.value ||
!step->callback_result.value) {
tester_debug("Gatt attr values are wrong set");
return false;
}
if (!memcmp(exp->callback_result.value,
step->callback_result.value,
exp->callback_result.length)) {
tester_debug("Gatt attr value mismatch");
return false;
}
}
if (exp->callback_result.need_rsp != step->callback_result.need_rsp) {
tester_debug("Gatt need response value flag mismatch: %d vs %d",
exp->callback_result.need_rsp,
step->callback_result.need_rsp);
return false;
}
if (exp->callback_result.is_prep != step->callback_result.is_prep) {
tester_debug("Gatt is prepared value flag mismatch: %d vs %d",
exp->callback_result.is_prep,
step->callback_result.is_prep);
return false;
}
if (exp->callback_result.num_mas_instances !=
step->callback_result.num_mas_instances) {
tester_debug("Mas instance count mismatch: %d vs %d",
exp->callback_result.num_mas_instances,
step->callback_result.num_mas_instances);
return false;
}
if (exp->callback_result.mas_instances &&
verify_mas_inst(exp->callback_result.mas_instances,
exp->callback_result.num_mas_instances,
step->callback_result.mas_instances,
step->callback_result.num_mas_instances)) {
tester_debug("Mas instances don't match");
return false;
}
if (exp->callback_result.error != step->callback_result.error) {
tester_debug("Err mismatch: %d vs %d",
exp->callback_result.error,
step->callback_result.error);
return false;
}
if (exp->store_srvc_handle)
memcpy(exp->store_srvc_handle,
step->callback_result.srvc_handle,
sizeof(*exp->store_srvc_handle));
if (exp->store_char_handle)
memcpy(exp->store_char_handle,
step->callback_result.char_handle,
sizeof(*exp->store_char_handle));
return true;
}
static void init_test_steps(struct test_data *data)
{
const struct test_case *test_steps = data->test_data;
int i = 0;
for (i = 0; i < test_steps->step_num; i++)
queue_push_tail(data->steps, (void *) &(test_steps->step[i]));
tester_print("tester: Number of test steps=%d",
queue_length(data->steps));
}
/*
* Each test case step should be verified, if match with
* expected result tester should go to next test step.
*/
static void verify_step(struct step *step, queue_destroy_func_t cleanup_cb)
{
struct test_data *data = tester_get_data();
const struct test_case *test_steps = data->test_data;
struct step *next_step;
tester_debug("tester: STEP[%d] check",
test_steps->step_num-queue_length(data->steps) + 1);
if (step && !match_data(step)) {
if (cleanup_cb)
cleanup_cb(step);
return;
}
queue_pop_head(data->steps);
if (cleanup_cb)
cleanup_cb(step);
tester_debug("tester: STEP[%d] pass",
test_steps->step_num-queue_length(data->steps));
if (queue_isempty(data->steps)) {
tester_print("tester: All steps done, passing");
tester_test_passed();
return;
}
/* goto next step action if declared in step */
next_step = queue_peek_head(data->steps);
if (next_step->action)
next_step->action();
}
/*
* NOTICE:
* Its mandatory for callback to set proper step.callback value so that
* step verification could pass and move to next test step
*/
static void free_properties(struct step *step)
{
bt_property_t *properties = step->callback_result.properties;
int num_properties = step->callback_result.num_properties;
int i;
for (i = 0; i < num_properties; i++)
g_free(properties[i].val);
g_free(properties);
}
static void free_mas_instances(struct step *step)
{
btmce_mas_instance_t *mas_instances;
int num_instances;
int i;
mas_instances = step->callback_result.mas_instances;
num_instances = step->callback_result.num_mas_instances;
for (i = 0; i < num_instances; i++)
g_free(mas_instances[i].p_name);
g_free(mas_instances);
}
static void destroy_callback_step(void *data)
{
struct step *step = data;
if (step->callback_result.properties)
free_properties(step);
if (step->callback_result.service)
free(step->callback_result.service);
if (step->callback_result.characteristic)
free(step->callback_result.characteristic);
if (step->callback_result.descriptor)
free(step->callback_result.descriptor);
if (step->callback_result.included)
free(step->callback_result.included);
if (step->callback_result.read_params)
free(step->callback_result.read_params);
if (step->callback_result.write_params)
free(step->callback_result.write_params);
if (step->callback_result.notify_params)
free(step->callback_result.notify_params);
if (step->callback_result.srvc_handle)
free(step->callback_result.srvc_handle);
if (step->callback_result.inc_srvc_handle)
free(step->callback_result.inc_srvc_handle);
if (step->callback_result.uuid)
free(step->callback_result.uuid);
if (step->callback_result.char_handle)
free(step->callback_result.char_handle);
if (step->callback_result.desc_handle)
free(step->callback_result.desc_handle);
if (step->callback_result.attr_handle)
free(step->callback_result.attr_handle);
if (step->callback_result.value)
free(step->callback_result.value);
if (step->callback_result.mas_instances)
free_mas_instances(step);
g_free(step);
g_atomic_int_dec_and_test(&scheduled_cbacks_num);
}
static gboolean verify_action(gpointer user_data)
{
struct step *step = user_data;
verify_step(step, g_free);
return FALSE;
}
static gboolean verify_callback(gpointer user_data)
{
struct test_data *data = tester_get_data();
struct step *step = user_data;
/* Return if callback came when all steps are already verified */
if (queue_isempty(data->steps)) {
destroy_callback_step(step);
return FALSE;
}
/*
* TODO: This may call action from next step before callback data
* from previous step was freed.
*/
verify_step(step, destroy_callback_step);
return FALSE;
}
void schedule_callback_verification(struct step *step)
{
g_atomic_int_inc(&scheduled_cbacks_num);
g_idle_add(verify_callback, step);
}
void schedule_action_verification(struct step *step)
{
g_idle_add_full(G_PRIORITY_HIGH_IDLE, verify_action, step, NULL);
}
static void adapter_state_changed_cb(bt_state_t state)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.state = state;
step->callback = CB_BT_ADAPTER_STATE_CHANGED;
schedule_callback_verification(step);
}
static bt_property_t *copy_properties(int num_properties,
bt_property_t *properties)
{
int i;
bt_property_t *props = g_new0(bt_property_t, num_properties);
for (i = 0; i < num_properties; i++) {
props[i].type = properties[i].type;
props[i].len = properties[i].len;
props[i].val = g_memdup(properties[i].val, properties[i].len);
}
return props;
}
static bt_property_t *repack_properties(int num_properties,
bt_property_t **properties)
{
int i;
bt_property_t *props = g_new0(bt_property_t, num_properties);
for (i = 0; i < num_properties; i++) {
props[i].type = properties[i]->type;
props[i].len = properties[i]->len;
props[i].val = g_memdup(properties[i]->val, properties[i]->len);
}
return props;
}
static bt_property_t *create_property(bt_property_type_t type, void *val,
int len)
{
bt_property_t *prop = g_new0(bt_property_t, 1);
prop->type = type;
prop->len = len;
prop->val = g_memdup(val, len);
return prop;
}
static void adapter_properties_cb(bt_status_t status, int num_properties,
bt_property_t *properties)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.status = status;
step->callback_result.num_properties = num_properties;
step->callback_result.properties = copy_properties(num_properties,
properties);
step->callback = CB_BT_ADAPTER_PROPERTIES;
schedule_callback_verification(step);
}
static void discovery_state_changed_cb(bt_discovery_state_t state)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_BT_DISCOVERY_STATE_CHANGED;
step->callback_result.state = state;
schedule_callback_verification(step);
}
static void device_found_cb(int num_properties, bt_property_t *properties)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.num_properties = num_properties;
step->callback_result.properties = copy_properties(num_properties,
properties);
step->callback = CB_BT_DEVICE_FOUND;
schedule_callback_verification(step);
}
static void remote_device_properties_cb(bt_status_t status,
bt_bdaddr_t *bd_addr, int num_properties,
bt_property_t *properties)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.num_properties = num_properties;
step->callback_result.properties = copy_properties(num_properties,
properties);
step->callback = CB_BT_REMOTE_DEVICE_PROPERTIES;
schedule_callback_verification(step);
}
static void bond_state_changed_cb(bt_status_t status,
bt_bdaddr_t *remote_bd_addr,
bt_bond_state_t state)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.status = status;
step->callback_result.state = state;
/* Utilize property verification mechanism for bdaddr */
step->callback_result.num_properties = 1;
step->callback_result.properties =
create_property(BT_PROPERTY_BDADDR, remote_bd_addr,
sizeof(*remote_bd_addr));
step->callback = CB_BT_BOND_STATE_CHANGED;
schedule_callback_verification(step);
}
static void pin_request_cb(bt_bdaddr_t *remote_bd_addr,
bt_bdname_t *bd_name, uint32_t cod)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[3];
step->callback = CB_BT_PIN_REQUEST;
/* Utilize property verification mechanism for those */
props[0] = create_property(BT_PROPERTY_BDADDR, remote_bd_addr,
sizeof(*remote_bd_addr));
props[1] = create_property(BT_PROPERTY_BDNAME, bd_name->name,
strlen((char *) bd_name->name));
props[2] = create_property(BT_PROPERTY_CLASS_OF_DEVICE, &cod,
sizeof(cod));
step->callback_result.num_properties = 3;
step->callback_result.properties = repack_properties(3, props);
g_free(props[0]->val);
g_free(props[0]);
g_free(props[1]->val);
g_free(props[1]);
g_free(props[2]->val);
g_free(props[2]);
schedule_callback_verification(step);
}
static void ssp_request_cb(bt_bdaddr_t *remote_bd_addr,
bt_bdname_t *bd_name, uint32_t cod,
bt_ssp_variant_t pairing_variant,
uint32_t pass_key)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[3];
step->callback = CB_BT_SSP_REQUEST;
/* Utilize property verification mechanism for those */
props[0] = create_property(BT_PROPERTY_BDADDR, remote_bd_addr,
sizeof(*remote_bd_addr));
props[1] = create_property(BT_PROPERTY_BDNAME, bd_name->name,
strlen((char *) bd_name->name));
props[2] = create_property(BT_PROPERTY_CLASS_OF_DEVICE, &cod,
sizeof(cod));
step->callback_result.num_properties = 3;
step->callback_result.properties = repack_properties(3, props);
g_free(props[0]->val);
g_free(props[0]);
g_free(props[1]->val);
g_free(props[1]);
g_free(props[2]->val);
g_free(props[2]);
schedule_callback_verification(step);
}
static void acl_state_changed_cb(bt_status_t status,
bt_bdaddr_t *remote_bd_addr,
bt_acl_state_t state) {
struct step *step = g_new0(struct step, 1);
step->callback = CB_BT_ACL_STATE_CHANGED;
step->callback_result.status = status;
step->callback_result.state = state;
schedule_callback_verification(step);
}
static bt_callbacks_t bt_callbacks = {
.size = sizeof(bt_callbacks),
.adapter_state_changed_cb = adapter_state_changed_cb,
.adapter_properties_cb = adapter_properties_cb,
.remote_device_properties_cb = remote_device_properties_cb,
.device_found_cb = device_found_cb,
.discovery_state_changed_cb = discovery_state_changed_cb,
.pin_request_cb = pin_request_cb,
.ssp_request_cb = ssp_request_cb,
.bond_state_changed_cb = bond_state_changed_cb,
.acl_state_changed_cb = acl_state_changed_cb,
.thread_evt_cb = NULL,
.dut_mode_recv_cb = NULL,
.le_test_mode_cb = NULL,
.energy_info_cb = NULL,
};
static void hidhost_connection_state_cb(bt_bdaddr_t *bd_addr,
bthh_connection_state_t state)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HH_CONNECTION_STATE;
step->callback_result.state = state;
schedule_callback_verification(step);
}
static void hidhost_virtual_unplug_cb(bt_bdaddr_t *bd_addr, bthh_status_t status)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HH_VIRTUAL_UNPLUG;
step->callback_result.status = status;
schedule_callback_verification(step);
}
static void hidhost_protocol_mode_cb(bt_bdaddr_t *bd_addr,
bthh_status_t status,
bthh_protocol_mode_t mode)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HH_PROTOCOL_MODE;
step->callback_result.status = status;
step->callback_result.mode = mode;
/* TODO: add bdaddr to verify? */
schedule_callback_verification(step);
}
static void hidhost_hid_info_cb(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HH_HID_INFO;
schedule_callback_verification(step);
}
static void hidhost_get_report_cb(bt_bdaddr_t *bd_addr, bthh_status_t status,
uint8_t *report, int size)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HH_GET_REPORT;
step->callback_result.status = status;
step->callback_result.report_size = size;
schedule_callback_verification(step);
}
static bthh_callbacks_t bthh_callbacks = {
.size = sizeof(bthh_callbacks),
.connection_state_cb = hidhost_connection_state_cb,
.hid_info_cb = hidhost_hid_info_cb,
.protocol_mode_cb = hidhost_protocol_mode_cb,
.idle_time_cb = NULL,
.get_report_cb = hidhost_get_report_cb,
.virtual_unplug_cb = hidhost_virtual_unplug_cb,
.handshake_cb = NULL,
};
static void gattc_register_client_cb(int status, int client_if,
bt_uuid_t *app_uuid)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_REGISTER_CLIENT;
step->callback_result.status = status;
schedule_callback_verification(step);
}
static void gattc_scan_result_cb(bt_bdaddr_t *bda, int rssi, uint8_t *adv_data)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[2];
step->callback = CB_GATTC_SCAN_RESULT;
step->callback_result.adv_data = adv_data ? TRUE : FALSE;
/* Utilize property verification mechanism for those */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
props[1] = create_property(BT_PROPERTY_REMOTE_RSSI, &rssi,
sizeof(rssi));
step->callback_result.num_properties = 2;
step->callback_result.properties = repack_properties(2, props);
g_free(props[0]->val);
g_free(props[0]);
g_free(props[1]->val);
g_free(props[1]);
schedule_callback_verification(step);
}
static void gattc_connect_cb(int conn_id, int status, int client_if,
bt_bdaddr_t *bda)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[1];
step->callback = CB_GATTC_OPEN;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.gatt_app_id = client_if;
/* Utilize property verification mechanism for bdaddr */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
step->callback_result.num_properties = 1;
step->callback_result.properties = repack_properties(1, props);
g_free(props[0]->val);
g_free(props[0]);
schedule_callback_verification(step);
}
static void gattc_disconnect_cb(int conn_id, int status, int client_if,
bt_bdaddr_t *bda)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[1];
step->callback = CB_GATTC_CLOSE;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.gatt_app_id = client_if;
/* Utilize property verification mechanism for bdaddr */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
step->callback_result.num_properties = 1;
step->callback_result.properties = repack_properties(1, props);
g_free(props[0]->val);
g_free(props[0]);
schedule_callback_verification(step);
}
static void gattc_listen_cb(int status, int server_if)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_LISTEN;
step->callback_result.status = status;
schedule_callback_verification(step);
}
static void gattc_search_result_cb(int conn_id, btgatt_srvc_id_t *srvc_id)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_SEARCH_RESULT;
step->callback_result.conn_id = conn_id;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
schedule_callback_verification(step);
}
static void gattc_search_complete_cb(int conn_id, int status)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_SEARCH_COMPLETE;
step->callback_result.conn_id = conn_id;
schedule_callback_verification(step);
}
static void gattc_get_characteristic_cb(int conn_id, int status,
btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id,
int char_prop)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_GET_CHARACTERISTIC;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
step->callback_result.characteristic = g_memdup(char_id,
sizeof(*char_id));
step->callback_result.char_prop = char_prop;
schedule_callback_verification(step);
}
static void gattc_get_descriptor_cb(int conn_id, int status,
btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id,
btgatt_gatt_id_t *descr_id)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_GET_DESCRIPTOR;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
step->callback_result.characteristic = g_memdup(char_id,
sizeof(*char_id));
step->callback_result.descriptor = g_memdup(descr_id,
sizeof(*descr_id));
schedule_callback_verification(step);
}
static void gattc_get_included_service_cb(int conn_id, int status,
btgatt_srvc_id_t *srvc_id, btgatt_srvc_id_t *incl_srvc_id)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_GET_INCLUDED_SERVICE;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
step->callback_result.included = g_memdup(incl_srvc_id,
sizeof(*srvc_id));
schedule_callback_verification(step);
}
static void gattc_read_characteristic_cb(int conn_id, int status,
btgatt_read_params_t *p_data)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_READ_CHARACTERISTIC;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.read_params = g_memdup(p_data, sizeof(*p_data));
schedule_callback_verification(step);
}
static void gattc_read_descriptor_cb(int conn_id, int status,
btgatt_read_params_t *p_data)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_READ_DESCRIPTOR;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.read_params = g_memdup(p_data, sizeof(*p_data));
schedule_callback_verification(step);
}
static void gattc_write_characteristic_cb(int conn_id, int status,
btgatt_write_params_t *p_data)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_WRITE_CHARACTERISTIC;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.write_params = g_memdup(p_data, sizeof(*p_data));
schedule_callback_verification(step);
}
static void gattc_write_descriptor_cb(int conn_id, int status,
btgatt_write_params_t *p_data)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_WRITE_DESCRIPTOR;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.write_params = g_memdup(p_data, sizeof(*p_data));
schedule_callback_verification(step);
}
static void gattc_register_for_notification_cb(int conn_id, int registered,
int status,
btgatt_srvc_id_t *srvc_id,
btgatt_gatt_id_t *char_id)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_REGISTER_FOR_NOTIFICATION;
step->callback_result.status = status;
step->callback_result.conn_id = conn_id;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
step->callback_result.characteristic = g_memdup(char_id,
sizeof(*char_id));
step->callback_result.notification_registered = registered;
schedule_callback_verification(step);
}
static void gattc_notif_cb(int conn_id, btgatt_notify_params_t *p_data)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTC_NOTIFY;
step->callback_result.conn_id = conn_id;
step->callback_result.notify_params = g_memdup(p_data, sizeof(*p_data));
schedule_callback_verification(step);
}
static const btgatt_client_callbacks_t btgatt_client_callbacks = {
.register_client_cb = gattc_register_client_cb,
.scan_result_cb = gattc_scan_result_cb,
.open_cb = gattc_connect_cb,
.close_cb = gattc_disconnect_cb,
.search_complete_cb = gattc_search_complete_cb,
.search_result_cb = gattc_search_result_cb,
.get_characteristic_cb = gattc_get_characteristic_cb,
.get_descriptor_cb = gattc_get_descriptor_cb,
.get_included_service_cb = gattc_get_included_service_cb,
.register_for_notification_cb = gattc_register_for_notification_cb,
.notify_cb = gattc_notif_cb,
.read_characteristic_cb = gattc_read_characteristic_cb,
.write_characteristic_cb = gattc_write_characteristic_cb,
.read_descriptor_cb = gattc_read_descriptor_cb,
.write_descriptor_cb = gattc_write_descriptor_cb,
.execute_write_cb = NULL,
.read_remote_rssi_cb = NULL,
.listen_cb = gattc_listen_cb
};
static void gatts_register_server_cb(int status, int server_if,
bt_uuid_t *app_uuid)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_REGISTER_SERVER;
step->callback_result.status = status;
schedule_callback_verification(step);
}
static void gatts_connection_cb(int conn_id, int server_if, int connected,
bt_bdaddr_t *bda)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[1];
step->callback = CB_GATTS_CONNECTION;
step->callback_result.conn_id = conn_id;
step->callback_result.gatt_app_id = server_if;
step->callback_result.connected = connected;
/* Utilize property verification mechanism for bdaddr */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
step->callback_result.num_properties = 1;
step->callback_result.properties = repack_properties(1, props);
g_free(props[0]->val);
g_free(props[0]);
schedule_callback_verification(step);
}
static void gatts_service_added_cb(int status, int server_if,
btgatt_srvc_id_t *srvc_id,
int srvc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_SERVICE_ADDED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.service = g_memdup(srvc_id, sizeof(*srvc_id));
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
schedule_callback_verification(step);
}
static void gatts_included_service_added_cb(int status, int server_if,
int srvc_handle,
int inc_srvc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_INCLUDED_SERVICE_ADDED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
step->callback_result.inc_srvc_handle = g_memdup(&inc_srvc_handle,
sizeof(inc_srvc_handle));
schedule_callback_verification(step);
}
static void gatts_characteristic_added_cb(int status, int server_if,
bt_uuid_t *uuid,
int srvc_handle,
int char_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_CHARACTERISTIC_ADDED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
step->callback_result.uuid = g_memdup(uuid, sizeof(*uuid));
step->callback_result.char_handle = g_memdup(&char_handle,
sizeof(char_handle));
schedule_callback_verification(step);
}
static void gatts_descriptor_added_cb(int status, int server_if,
bt_uuid_t *uuid,
int srvc_handle,
int desc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_DESCRIPTOR_ADDED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
step->callback_result.uuid = g_memdup(uuid, sizeof(*uuid));
step->callback_result.desc_handle = g_memdup(&desc_handle,
sizeof(desc_handle));
schedule_callback_verification(step);
}
static void gatts_service_started_cb(int status, int server_if, int srvc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_SERVICE_STARTED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
schedule_callback_verification(step);
}
static void gatts_service_stopped_cb(int status, int server_if, int srvc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_SERVICE_STOPPED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
schedule_callback_verification(step);
}
static void gatts_service_deleted_cb(int status, int server_if, int srvc_handle)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_SERVICE_DELETED;
step->callback_result.status = status;
step->callback_result.gatt_app_id = server_if;
step->callback_result.srvc_handle = g_memdup(&srvc_handle,
sizeof(srvc_handle));
schedule_callback_verification(step);
}
static void gatts_request_read_cb(int conn_id, int trans_id, bt_bdaddr_t *bda,
int attr_handle, int offset,
bool is_long)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[1];
step->callback = CB_GATTS_REQUEST_READ;
step->callback_result.conn_id = conn_id;
step->callback_result.trans_id = trans_id;
step->callback_result.attr_handle = g_memdup(&attr_handle,
sizeof(attr_handle));
step->callback_result.offset = offset;
step->callback_result.is_long = is_long;
/* Utilize property verification mechanism for bdaddr */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
step->callback_result.num_properties = 1;
step->callback_result.properties = repack_properties(1, props);
g_free(props[0]->val);
g_free(props[0]);
schedule_callback_verification(step);
}
static void gatts_request_write_cb(int conn_id, int trans_id, bt_bdaddr_t *bda,
int attr_handle, int offset,
int length, bool need_rsp,
bool is_prep, uint8_t *value)
{
struct step *step = g_new0(struct step, 1);
bt_property_t *props[1];
step->callback = CB_GATTS_REQUEST_WRITE;
step->callback_result.conn_id = conn_id;
step->callback_result.trans_id = trans_id;
step->callback_result.attr_handle = g_memdup(&attr_handle,
sizeof(attr_handle));
step->callback_result.offset = offset;
step->callback_result.length = length;
step->callback_result.need_rsp = need_rsp;
step->callback_result.is_prep = is_prep;
step->callback_result.value = g_memdup(&value, length);
/* Utilize property verification mechanism for bdaddr */
props[0] = create_property(BT_PROPERTY_BDADDR, bda, sizeof(*bda));
step->callback_result.num_properties = 1;
step->callback_result.properties = repack_properties(1, props);
g_free(props[0]->val);
g_free(props[0]);
schedule_callback_verification(step);
}
static void gatts_indication_send_cb(int conn_id, int status)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_GATTS_INDICATION_SEND;
step->callback_result.conn_id = conn_id;
step->callback_result.status = status;
schedule_callback_verification(step);
}
static const btgatt_server_callbacks_t btgatt_server_callbacks = {
.register_server_cb = gatts_register_server_cb,
.connection_cb = gatts_connection_cb,
.service_added_cb = gatts_service_added_cb,
.included_service_added_cb = gatts_included_service_added_cb,
.characteristic_added_cb = gatts_characteristic_added_cb,
.descriptor_added_cb = gatts_descriptor_added_cb,
.service_started_cb = gatts_service_started_cb,
.service_stopped_cb = gatts_service_stopped_cb,
.service_deleted_cb = gatts_service_deleted_cb,
.request_read_cb = gatts_request_read_cb,
.request_write_cb = gatts_request_write_cb,
.request_exec_write_cb = NULL,
.response_confirmation_cb = NULL,
.indication_sent_cb = gatts_indication_send_cb,
.congestion_cb = NULL,
};
static const btgatt_callbacks_t btgatt_callbacks = {
.size = sizeof(btgatt_callbacks),
.client = &btgatt_client_callbacks,
.server = &btgatt_server_callbacks
};
static void pan_control_state_cb(btpan_control_state_t state, int local_role,
bt_status_t error, const char *ifname)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_PAN_CONTROL_STATE;
step->callback_result.state = error;
step->callback_result.ctrl_state = state;
step->callback_result.local_role = local_role;
schedule_callback_verification(step);
}
static void pan_connection_state_cb(btpan_connection_state_t state,
bt_status_t error,
const bt_bdaddr_t *bd_addr,
int local_role, int remote_role)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_PAN_CONNECTION_STATE;
step->callback_result.state = error;
step->callback_result.conn_state = state;
step->callback_result.local_role = local_role;
step->callback_result.remote_role = remote_role;
schedule_callback_verification(step);
}
static btpan_callbacks_t btpan_callbacks = {
.size = sizeof(btpan_callbacks),
.control_state_cb = pan_control_state_cb,
.connection_state_cb = pan_connection_state_cb,
};
static void hdp_app_reg_state_cb(int app_id, bthl_app_reg_state_t state)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HDP_APP_REG_STATE;
step->callback_result.app_id = app_id;
step->callback_result.app_state = state;
schedule_callback_verification(step);
}
static void hdp_channel_state_cb(int app_id, bt_bdaddr_t *bd_addr,
int mdep_cfg_index, int channel_id,
bthl_channel_state_t state, int fd)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_HDP_CHANNEL_STATE;
step->callback_result.app_id = app_id;
step->callback_result.channel_id = channel_id;
step->callback_result.mdep_cfg_index = mdep_cfg_index;
step->callback_result.channel_state = state;
schedule_callback_verification(step);
}
static bthl_callbacks_t bthl_callbacks = {
.size = sizeof(bthl_callbacks),
.app_reg_state_cb = hdp_app_reg_state_cb,
.channel_state_cb = hdp_channel_state_cb,
};
static void a2dp_connection_state_cb(btav_connection_state_t state,
bt_bdaddr_t *bd_addr)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_A2DP_CONN_STATE;
step->callback_result.av_conn_state = state;
schedule_callback_verification(step);
}
static void a2dp_audio_state_cb(btav_audio_state_t state, bt_bdaddr_t *bd_addr)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_A2DP_AUDIO_STATE;
step->callback_result.av_audio_state = state;
schedule_callback_verification(step);
}
static btav_callbacks_t bta2dp_callbacks = {
.size = sizeof(bta2dp_callbacks),
.connection_state_cb = a2dp_connection_state_cb,
.audio_state_cb = a2dp_audio_state_cb,
};
static void avrcp_get_play_status_cb(void)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_AVRCP_PLAY_STATUS_REQ;
schedule_callback_verification(step);
}
static void avrcp_register_notification_cb(btrc_event_id_t event_id,
uint32_t param)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_AVRCP_REG_NOTIF_REQ;
schedule_callback_verification(step);
}
static void avrcp_get_element_attr_cb(uint8_t num_attr,
btrc_media_attr_t *p_attrs)
{
struct step *step = g_new0(struct step, 1);
step->callback = CB_AVRCP_GET_ATTR_REQ;
schedule_callback_verification(step);
}
static btrc_callbacks_t btavrcp_callbacks = {
.size = sizeof(btavrcp_callbacks),
.get_play_status_cb = avrcp_get_play_status_cb,
.register_notification_cb = avrcp_register_notification_cb,
.get_element_attr_cb = avrcp_get_element_attr_cb,
};
static btmce_mas_instance_t *copy_mas_instances(int num_instances,
btmce_mas_instance_t *instances)
{
int i;
btmce_mas_instance_t *inst;
inst = g_new0(btmce_mas_instance_t, num_instances);
for (i = 0; i < num_instances; i++) {
inst[i].id = instances[i].id;
inst[i].scn = instances[i].scn;
inst[i].msg_types = instances[i].msg_types;
inst[i].p_name = g_memdup(instances[i].p_name,
strlen(instances[i].p_name));
}
return inst;
}
static void map_client_get_remote_mas_instances_cb(bt_status_t status,
bt_bdaddr_t *bd_addr,
int num_instances,
btmce_mas_instance_t
*instances)
{
struct step *step = g_new0(struct step, 1);
step->callback_result.status = status;
step->callback_result.num_mas_instances = num_instances;
step->callback_result.mas_instances = copy_mas_instances(num_instances,
instances);
step->callback = CB_MAP_CLIENT_REMOTE_MAS_INSTANCES;
schedule_callback_verification(step);
}
static btmce_callbacks_t btmap_client_callbacks = {
.size = sizeof(btmap_client_callbacks),
.remote_mas_instances_cb = map_client_get_remote_mas_instances_cb,
};
static bool setup_base(struct test_data *data)
{
const hw_module_t *module;
hw_device_t *device;
int signal_fd[2];
char buf[1024];
pid_t pid;
int len;
int err;
if (pipe(signal_fd))
return false;
pid = fork();
if (pid < 0) {
close(signal_fd[0]);
close(signal_fd[1]);
return false;
}
if (pid == 0) {
if (!tester_use_debug())
fclose(stderr);
close(signal_fd[0]);
emulator(signal_fd[1], data->mgmt_index);
exit(0);
}
close(signal_fd[1]);
data->bluetoothd_pid = pid;
len = read(signal_fd[0], buf, sizeof(buf));
if (len <= 0 || strcmp(buf, EMULATOR_SIGNAL)) {
close(signal_fd[0]);
return false;
}
close(signal_fd[0]);
err = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID,
AUDIO_HARDWARE_MODULE_ID_A2DP, &module);
if (err)
return false;
err = audio_hw_device_open(module, &data->audio);
if (err)
return false;
err = hw_get_module(BT_HARDWARE_MODULE_ID, &module);
if (err)
return false;
err = module->methods->open(module, BT_HARDWARE_MODULE_ID, &device);
if (err)
return false;
data->device = device;
data->if_bluetooth = ((bluetooth_device_t *)
device)->get_bluetooth_interface();
if (!data->if_bluetooth)
return false;
if (!(data->steps = queue_new()))
return false;
data->pdus = queue_new();
if (!data->pdus) {
queue_destroy(data->steps, NULL);
return false;
}
return true;
}
static void setup(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_socket(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *sock;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
sock = data->if_bluetooth->get_profile_interface(BT_PROFILE_SOCKETS_ID);
if (!sock) {
tester_setup_failed();
return;
}
data->if_sock = sock;
tester_setup_complete();
}
static void setup_hidhost(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *hid;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
hid = data->if_bluetooth->get_profile_interface(BT_PROFILE_HIDHOST_ID);
if (!hid) {
tester_setup_failed();
return;
}
data->if_hid = hid;
status = data->if_hid->init(&bthh_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_hid = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_pan(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *pan;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
pan = data->if_bluetooth->get_profile_interface(BT_PROFILE_PAN_ID);
if (!pan) {
tester_setup_failed();
return;
}
data->if_pan = pan;
status = data->if_pan->init(&btpan_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_pan = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_hdp(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *hdp;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
hdp = data->if_bluetooth->get_profile_interface(BT_PROFILE_HEALTH_ID);
if (!hdp) {
tester_setup_failed();
return;
}
data->if_hdp = hdp;
status = data->if_hdp->init(&bthl_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_hdp = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_a2dp(const void *test_data)
{
struct test_data *data = tester_get_data();
const bt_interface_t *if_bt;
bt_status_t status;
const void *a2dp;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
if_bt = data->if_bluetooth;
status = if_bt->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
a2dp = if_bt->get_profile_interface(BT_PROFILE_ADVANCED_AUDIO_ID);
if (!a2dp) {
tester_setup_failed();
return;
}
data->if_a2dp = a2dp;
status = data->if_a2dp->init(&bta2dp_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_a2dp = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_avrcp(const void *test_data)
{
struct test_data *data = tester_get_data();
const bt_interface_t *if_bt;
bt_status_t status;
const void *a2dp, *avrcp;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
if_bt = data->if_bluetooth;
status = if_bt->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
a2dp = if_bt->get_profile_interface(BT_PROFILE_ADVANCED_AUDIO_ID);
if (!a2dp) {
tester_setup_failed();
return;
}
data->if_a2dp = a2dp;
status = data->if_a2dp->init(&bta2dp_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_a2dp = NULL;
tester_setup_failed();
return;
}
avrcp = if_bt->get_profile_interface(BT_PROFILE_AV_RC_ID);
if (!avrcp) {
tester_setup_failed();
return;
}
data->if_avrcp = avrcp;
status = data->if_avrcp->init(&btavrcp_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_avrcp = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_gatt(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *gatt;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
gatt = data->if_bluetooth->get_profile_interface(BT_PROFILE_GATT_ID);
if (!gatt) {
tester_setup_failed();
return;
}
data->if_gatt = gatt;
status = data->if_gatt->init(&btgatt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_gatt = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void setup_map_client(const void *test_data)
{
struct test_data *data = tester_get_data();
bt_status_t status;
const void *map_client;
if (!setup_base(data)) {
tester_setup_failed();
return;
}
status = data->if_bluetooth->init(&bt_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_bluetooth = NULL;
tester_setup_failed();
return;
}
map_client = data->if_bluetooth->get_profile_interface(
BT_PROFILE_MAP_CLIENT_ID);
if (!map_client) {
tester_setup_failed();
return;
}
data->if_map_client = map_client;
status = data->if_map_client->init(&btmap_client_callbacks);
if (status != BT_STATUS_SUCCESS) {
data->if_map_client = NULL;
tester_setup_failed();
return;
}
tester_setup_complete();
}
static void teardown(const void *test_data)
{
struct test_data *data = tester_get_data();
queue_destroy(data->steps, NULL);
data->steps = NULL;
queue_destroy(data->pdus, NULL);
data->pdus = NULL;
/* no cleanup for map_client */
data->if_map_client = NULL;
if (data->if_gatt) {
data->if_gatt->cleanup();
data->if_gatt = NULL;
}
if (data->if_hid) {
data->if_hid->cleanup();
data->if_hid = NULL;
}
if (data->if_pan) {
data->if_pan->cleanup();
data->if_pan = NULL;
}
if (data->if_hdp) {
data->if_hdp->cleanup();
data->if_hdp = NULL;
}
if (data->if_stream) {
data->audio->close_output_stream(data->audio, data->if_stream);
data->if_stream = NULL;
}
if (data->if_a2dp) {
data->if_a2dp->cleanup();
data->if_a2dp = NULL;
}
if (data->if_avrcp) {
data->if_avrcp->cleanup();
data->if_avrcp = NULL;
}
if (data->if_bluetooth) {
data->if_bluetooth->cleanup();
data->if_bluetooth = NULL;
}
data->device->close(data->device);
audio_hw_device_close(data->audio);
/*
* Ssp_request_cb pointer can be set do default_ssp_req_cb.
* Set it back to ssp_request_cb
*/
bt_callbacks.ssp_request_cb = ssp_request_cb;
if (!data->bluetoothd_pid)
tester_teardown_complete();
}
static void emu_connectable_complete(uint16_t opcode, uint8_t status,
const void *param, uint8_t len,
void *user_data)
{
struct step *step;
struct test_data *data = user_data;
switch (opcode) {
case BT_HCI_CMD_WRITE_SCAN_ENABLE:
break;
case BT_HCI_CMD_LE_SET_ADV_ENABLE:
/*
* For BREDRLE emulator we want to verify step after scan
* enable and not after le_set_adv_enable
*/
if (data->hciemu_type == HCIEMU_TYPE_BREDRLE)
return;
break;
default:
return;
}
step = g_new0(struct step, 1);
if (status) {
tester_warn("Emulated remote setup failed.");
step->action_status = BT_STATUS_FAIL;
} else {
tester_debug("Emulated remote setup done.");
step->action_status = BT_STATUS_SUCCESS;
}
schedule_action_verification(step);
}
void emu_setup_powered_remote_action(void)
{
struct test_data *data = tester_get_data();
struct bthost *bthost;
bthost = hciemu_client_get_host(data->hciemu);
bthost_set_cmd_complete_cb(bthost, emu_connectable_complete, data);
if ((data->hciemu_type == HCIEMU_TYPE_LE) ||
(data->hciemu_type == HCIEMU_TYPE_BREDRLE)) {
uint8_t adv[4];
adv[0] = 0x02; /* Field length */
adv[1] = 0x01; /* Flags */
adv[2] = 0x02; /* Flags value */
adv[3] = 0x00; /* Field terminator */
bthost_set_adv_data(bthost, adv, sizeof(adv));
bthost_set_adv_enable(bthost, 0x01);
}
if (data->hciemu_type != HCIEMU_TYPE_LE)
bthost_write_scan_enable(bthost, 0x03);
}
void emu_set_pin_code_action(void)
{
struct test_data *data = tester_get_data();
struct step *current_data_step = queue_peek_head(data->steps);
struct bt_action_data *action_data = current_data_step->set_data;
struct bthost *bthost;
struct step *step = g_new0(struct step, 1);
bthost = hciemu_client_get_host(data->hciemu);
bthost_set_pin_code(bthost, action_data->pin->pin,
action_data->pin_len);
step->action_status = BT_STATUS_SUCCESS;
tester_print("Setting emu pin done.");
schedule_action_verification(step);
}
void emu_set_ssp_mode_action(void)
{
struct test_data *data = tester_get_data();
struct bthost *bthost;
struct step *step = g_new0(struct step, 1);
bthost = hciemu_client_get_host(data->hciemu);
bthost_write_ssp_mode(bthost, 0x01);
step->action_status = BT_STATUS_SUCCESS;
schedule_action_verification(step);
}
void emu_set_connect_cb_action(void)
{
struct test_data *data = tester_get_data();