M7350/external/bluetooth/bluez/android/ipc-tester.c
2024-09-09 08:57:42 +00:00

1262 lines
37 KiB
C

/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2013-2014 Intel Corporation. All rights reserved.
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <libgen.h>
#include <glib.h>
#include "lib/bluetooth.h"
#include "lib/mgmt.h"
#include "src/shared/tester.h"
#include "src/shared/mgmt.h"
#include "src/shared/hciemu.h"
#include "hal-msg.h"
#include "ipc-common.h"
#include <cutils/properties.h>
#define WAIT_FOR_SIGNAL_TIME 2 /* in seconds */
#define EMULATOR_SIGNAL "emulator_started"
struct test_data {
struct mgmt *mgmt;
uint16_t mgmt_index;
struct hciemu *hciemu;
enum hciemu_type hciemu_type;
pid_t bluetoothd_pid;
bool setup_done;
};
struct ipc_data {
void *buffer;
size_t len;
};
struct generic_data {
struct ipc_data ipc_data;
unsigned int num_services;
int init_services[];
};
struct regmod_msg {
struct ipc_hdr header;
struct hal_cmd_register_module cmd;
} __attribute__((packed));
#define CONNECT_TIMEOUT (5 * 1000)
#define SERVICE_NAME "bluetoothd"
static char exec_dir[PATH_MAX + 1];
static int cmd_sk = -1;
static int notif_sk = -1;
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_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 *data)
{
struct test_data *test_data = tester_get_data();
if (!tester_use_debug())
fclose(stderr);
test_data->mgmt = mgmt_new_default();
if (!test_data->mgmt) {
tester_warn("Failed to setup management interface");
tester_pre_setup_failed();
return;
}
mgmt_send(test_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 *data)
{
struct test_data *test_data = tester_get_data();
if (test_data->hciemu) {
hciemu_unref(test_data->hciemu);
test_data->hciemu = NULL;
}
}
static void bluetoothd_start(int hci_index)
{
char prg_name[PATH_MAX + 1];
char index[8];
char *prg_argv[4];
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] = 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 = WAIT_FOR_SIGNAL_TIME;
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, "ctl.start=bluetoothd"))
goto failed;
close(pipe);
close(fd);
bluetoothd_start(hci_index);
failed:
close(pipe);
close(fd);
}
static int accept_connection(int sk)
{
int err;
struct pollfd pfd;
int new_sk;
memset(&pfd, 0 , sizeof(pfd));
pfd.fd = sk;
pfd.events = POLLIN;
err = poll(&pfd, 1, CONNECT_TIMEOUT);
if (err < 0) {
err = errno;
tester_warn("Failed to poll: %d (%s)", err, strerror(err));
return -errno;
}
if (err == 0) {
tester_warn("bluetoothd connect timeout");
return -errno;
}
new_sk = accept(sk, NULL, NULL);
if (new_sk < 0) {
err = errno;
tester_warn("Failed to accept socket: %d (%s)",
err, strerror(err));
return -errno;
}
return new_sk;
}
static bool init_ipc(void)
{
struct sockaddr_un addr;
int sk;
int err;
sk = socket(AF_LOCAL, SOCK_SEQPACKET, 0);
if (sk < 0) {
err = errno;
tester_warn("Failed to create socket: %d (%s)", err,
strerror(err));
return false;
}
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, BLUEZ_HAL_SK_PATH, sizeof(BLUEZ_HAL_SK_PATH));
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
err = errno;
tester_warn("Failed to bind socket: %d (%s)", err,
strerror(err));
close(sk);
return false;
}
if (listen(sk, 2) < 0) {
err = errno;
tester_warn("Failed to listen on socket: %d (%s)", err,
strerror(err));
close(sk);
return false;
}
/* Start Android Bluetooth daemon service */
if (property_set("ctl.start", SERVICE_NAME) < 0) {
tester_warn("Failed to start service %s", SERVICE_NAME);
close(sk);
return false;
}
cmd_sk = accept_connection(sk);
if (cmd_sk < 0) {
close(sk);
return false;
}
notif_sk = accept_connection(sk);
if (notif_sk < 0) {
close(sk);
close(cmd_sk);
cmd_sk = -1;
return false;
}
tester_print("bluetoothd connected");
close(sk);
return true;
}
static void cleanup_ipc(void)
{
if (cmd_sk < 0)
return;
close(cmd_sk);
cmd_sk = -1;
}
static gboolean check_for_daemon(gpointer user_data)
{
int status;
struct test_data *data = user_data;
if ((waitpid(data->bluetoothd_pid, &status, WNOHANG))
!= data->bluetoothd_pid)
return true;
if (data->setup_done) {
if (WIFEXITED(status) &&
(WEXITSTATUS(status) == EXIT_SUCCESS)) {
tester_test_passed();
return false;
}
tester_test_failed();
} else {
tester_setup_failed();
test_post_teardown(data);
}
tester_warn("Unexpected Daemon shutdown with status %d", status);
return false;
}
static bool setup_module(int service_id)
{
struct ipc_hdr response;
struct ipc_hdr expected_response;
struct regmod_msg btmodule_msg = {
.header = {
.service_id = HAL_SERVICE_ID_CORE,
.opcode = HAL_OP_REGISTER_MODULE,
.len = sizeof(struct hal_cmd_register_module),
},
.cmd = {
.service_id = service_id,
},
};
if (write(cmd_sk, &btmodule_msg, sizeof(btmodule_msg)) < 0)
goto fail;
if (read(cmd_sk, &response, sizeof(response)) < 0)
goto fail;
expected_response = btmodule_msg.header;
expected_response.len = 0;
if (memcmp(&response, &expected_response, sizeof(response)) == 0)
return true;
fail:
tester_warn("Module registration failed.");
return false;
}
static void setup(const void *data)
{
const struct generic_data *generic_data = data;
struct test_data *test_data = tester_get_data();
int signal_fd[2];
char buf[1024];
pid_t pid;
int len;
unsigned int i;
if (pipe(signal_fd))
goto failed;
pid = fork();
if (pid < 0) {
close(signal_fd[0]);
close(signal_fd[1]);
goto failed;
}
if (pid == 0) {
if (!tester_use_debug())
fclose(stderr);
close(signal_fd[0]);
emulator(signal_fd[1], test_data->mgmt_index);
exit(0);
}
close(signal_fd[1]);
test_data->bluetoothd_pid = pid;
len = read(signal_fd[0], buf, sizeof(buf));
if (len <= 0 || (strcmp(buf, EMULATOR_SIGNAL))) {
close(signal_fd[0]);
goto failed;
}
g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, check_for_daemon, test_data,
NULL);
if (!init_ipc()) {
tester_warn("Cannot initialize IPC mechanism!");
goto failed;
}
tester_print("Will init %d services.", generic_data->num_services);
for (i = 0; i < generic_data->num_services; i++)
if (!setup_module(generic_data->init_services[i])) {
cleanup_ipc();
goto failed;
}
test_data->setup_done = true;
tester_setup_complete();
return;
failed:
g_idle_remove_by_data(test_data);
tester_setup_failed();
test_post_teardown(data);
}
static void teardown(const void *data)
{
struct test_data *test_data = tester_get_data();
g_idle_remove_by_data(test_data);
cleanup_ipc();
if (test_data->bluetoothd_pid)
waitpid(test_data->bluetoothd_pid, NULL, 0);
tester_teardown_complete();
}
static void ipc_send_tc(const void *data)
{
const struct generic_data *generic_data = data;
const struct ipc_data *ipc_data = &generic_data->ipc_data;
if (ipc_data->len) {
if (write(cmd_sk, ipc_data->buffer, ipc_data->len) < 0)
tester_test_failed();
}
}
#define service_data(args...) { args }
#define gen_data(writelen, writebuf, servicelist...) \
{ \
.ipc_data = { \
.buffer = writebuf, \
.len = writelen, \
}, \
.init_services = service_data(servicelist), \
.num_services = sizeof((const int[]) \
service_data(servicelist)) / \
sizeof(int), \
}
#define test_generic(name, test, setup, teardown, buffer, writelen, \
services...) \
do { \
struct test_data *user; \
static const struct generic_data data = \
gen_data(writelen, buffer, services); \
user = g_malloc0(sizeof(struct test_data)); \
if (!user) \
break; \
user->hciemu_type = HCIEMU_TYPE_BREDRLE; \
tester_add_full(name, &data, test_pre_setup, setup, \
test, teardown, test_post_teardown, \
3, user, g_free); \
} while (0)
#define test_opcode_valid(_name, _service, _opcode, _len, _servicelist...) \
do { \
static struct ipc_hdr hdr = { \
.service_id = _service, \
.opcode = _opcode, \
.len = _len, \
}; \
\
test_generic("Opcode out of range: "_name, \
ipc_send_tc, setup, teardown, \
&hdr, \
sizeof(hdr), \
_servicelist); \
} while (0)
struct vardata {
struct ipc_hdr hdr;
uint8_t buf[IPC_MTU];
} __attribute__((packed));
#define test_datasize_valid(_name, _service, _opcode, _hlen, _addatasize, \
_servicelist...) \
do { \
static struct vardata vdata = { \
.hdr.service_id = _service, \
.hdr.opcode = _opcode, \
.hdr.len = (_hlen) + (_addatasize), \
.buf = {}, \
}; \
test_generic("Data size "_name, \
ipc_send_tc, setup, teardown, \
&vdata, \
sizeof(vdata.hdr) + (_hlen) + (_addatasize),\
_servicelist); \
} while (0)
struct regmod_msg register_bt_msg = {
.header = {
.service_id = HAL_SERVICE_ID_CORE,
.opcode = HAL_OP_REGISTER_MODULE,
.len = sizeof(struct hal_cmd_register_module),
},
.cmd = {
.service_id = HAL_SERVICE_ID_BLUETOOTH,
},
};
struct regmod_msg register_bt_malformed_size_msg = {
.header = {
.service_id = HAL_SERVICE_ID_CORE,
.opcode = HAL_OP_REGISTER_MODULE,
/* wrong payload size declared */
.len = sizeof(struct hal_cmd_register_module) - 1,
},
.cmd = {
.service_id = HAL_SERVICE_ID_CORE,
},
};
struct malformed_data3_struct {
struct regmod_msg valid_msg;
int redundant_data;
} __attribute__((packed));
static struct malformed_data3_struct malformed_data3_msg = {
/* valid register service message */
.valid_msg = {
.header = {
.service_id = HAL_SERVICE_ID_CORE,
.opcode = HAL_OP_REGISTER_MODULE,
.len = sizeof(struct hal_cmd_register_module),
},
.cmd = {
.service_id = HAL_SERVICE_ID_CORE,
},
},
/* plus redundant data */
. redundant_data = 666,
};
struct ipc_hdr enable_unknown_service_hdr = {
.service_id = HAL_SERVICE_ID_MAX + 1,
.opcode = HAL_OP_REGISTER_MODULE,
.len = 0,
};
struct ipc_hdr enable_bt_service_hdr = {
.service_id = HAL_SERVICE_ID_BLUETOOTH,
.opcode = HAL_OP_ENABLE,
.len = 0,
};
struct bt_set_adapter_prop_data {
struct ipc_hdr hdr;
struct hal_cmd_set_adapter_prop prop;
/* data placeholder for hal_cmd_set_adapter_prop.val[0] */
uint8_t buf[IPC_MTU - sizeof(struct ipc_hdr) -
sizeof(struct hal_cmd_set_adapter_prop)];
} __attribute__((packed));
#define set_name "new name"
static struct bt_set_adapter_prop_data bt_set_adapter_prop_data_overs = {
.hdr.service_id = HAL_SERVICE_ID_BLUETOOTH,
.hdr.opcode = HAL_OP_SET_ADAPTER_PROP,
.hdr.len = sizeof(struct hal_cmd_set_adapter_prop) +
sizeof(set_name),
.prop.type = HAL_PROP_ADAPTER_NAME,
/* declare wrong descriptor length */
.prop.len = sizeof(set_name) + 1,
/* init prop.val[0] */
.buf = set_name,
};
static struct bt_set_adapter_prop_data bt_set_adapter_prop_data_unders = {
.hdr.service_id = HAL_SERVICE_ID_BLUETOOTH,
.hdr.opcode = HAL_OP_SET_ADAPTER_PROP,
.hdr.len = sizeof(struct hal_cmd_set_adapter_prop) +
sizeof(set_name),
.prop.type = HAL_PROP_ADAPTER_NAME,
/* declare wrong descriptor length */
.prop.len = sizeof(set_name) - 1,
/* init prop.val[0] */
.buf = set_name,
};
struct bt_set_remote_prop_data {
struct ipc_hdr hdr;
struct hal_cmd_set_remote_device_prop prop;
/* data placeholder for hal_cmd_set_remote_device_prop.val[0] */
uint8_t buf[IPC_MTU - sizeof(struct ipc_hdr) -
sizeof(struct hal_cmd_set_remote_device_prop)];
} __attribute__((packed));
static struct bt_set_remote_prop_data bt_set_remote_prop_data_overs = {
.hdr.service_id = HAL_SERVICE_ID_BLUETOOTH,
.hdr.opcode = HAL_OP_SET_REMOTE_DEVICE_PROP,
.hdr.len = sizeof(struct hal_cmd_set_remote_device_prop) +
sizeof(set_name),
.prop.bdaddr = {},
.prop.type = HAL_PROP_DEVICE_NAME,
/* declare wrong descriptor length */
.prop.len = sizeof(set_name) + 1,
.buf = set_name,
};
static struct bt_set_remote_prop_data bt_set_remote_prop_data_unders = {
.hdr.service_id = HAL_SERVICE_ID_BLUETOOTH,
.hdr.opcode = HAL_OP_SET_REMOTE_DEVICE_PROP,
.hdr.len = sizeof(struct hal_cmd_set_remote_device_prop) +
sizeof(set_name),
.prop.bdaddr = {},
.prop.type = HAL_PROP_DEVICE_NAME,
/* declare wrong descriptor length */
.prop.len = sizeof(set_name) - 1,
.buf = set_name,
};
struct hidhost_set_info_data {
struct ipc_hdr hdr;
struct hal_cmd_hidhost_set_info info;
/* data placeholder for hal_cmd_hidhost_set_info.descr[0] field */
uint8_t buf[IPC_MTU - sizeof(struct ipc_hdr) -
sizeof(struct hal_cmd_hidhost_set_info)];
} __attribute__((packed));
#define set_info_data "some descriptor"
static struct hidhost_set_info_data hidhost_set_info_data_overs = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SET_INFO,
.hdr.len = sizeof(struct hal_cmd_hidhost_set_info) +
sizeof(set_info_data),
/* declare wrong descriptor length */
.info.descr_len = sizeof(set_info_data) + 1,
/* init .info.descr[0] */
.buf = set_info_data,
};
static struct hidhost_set_info_data hidhost_set_info_data_unders = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SET_INFO,
.hdr.len = sizeof(struct hal_cmd_hidhost_set_info) +
sizeof(set_info_data),
/* declare wrong descriptor length */
.info.descr_len = sizeof(set_info_data) - 1,
/* init .info.descr[0] */
.buf = set_info_data,
};
struct hidhost_set_report_data {
struct ipc_hdr hdr;
struct hal_cmd_hidhost_set_report report;
/* data placeholder for hal_cmd_hidhost_set_report.data[0] field */
uint8_t buf[IPC_MTU - sizeof(struct ipc_hdr) -
sizeof(struct hal_cmd_hidhost_set_report)];
} __attribute__((packed));
#define set_rep_data "1234567890"
static struct hidhost_set_report_data hidhost_set_report_data_overs = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SET_REPORT,
.hdr.len = sizeof(struct hal_cmd_hidhost_set_report) +
sizeof(set_rep_data),
/* declare wrong descriptor length */
.report.len = sizeof(set_rep_data) + 1,
/* init report.data[0] */
.buf = set_rep_data,
};
static struct hidhost_set_report_data hidhost_set_report_data_unders = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SET_REPORT,
.hdr.len = sizeof(struct hal_cmd_hidhost_set_report) +
sizeof(set_rep_data),
/* declare wrong descriptor length */
.report.len = sizeof(set_rep_data) - 1,
/* init report.data[0] */
.buf = set_rep_data,
};
struct hidhost_send_data_data {
struct ipc_hdr hdr;
struct hal_cmd_hidhost_send_data hiddata;
/* data placeholder for hal_cmd_hidhost_send_data.data[0] field */
uint8_t buf[IPC_MTU - sizeof(struct ipc_hdr) -
sizeof(struct hal_cmd_hidhost_send_data)];
} __attribute__((packed));
#define send_data_data "1234567890"
static struct hidhost_send_data_data hidhost_send_data_overs = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SEND_DATA,
.hdr.len = sizeof(struct hal_cmd_hidhost_send_data) +
sizeof(send_data_data),
/* declare wrong descriptor length */
.hiddata.len = sizeof(send_data_data) + 1,
/* init .hiddata.data[0] */
.buf = send_data_data,
};
static struct hidhost_send_data_data hidhost_send_data_unders = {
.hdr.service_id = HAL_SERVICE_ID_HIDHOST,
.hdr.opcode = HAL_OP_HIDHOST_SEND_DATA,
.hdr.len = sizeof(struct hal_cmd_hidhost_send_data) +
sizeof(send_data_data),
/* declare wrong descriptor length */
.hiddata.len = sizeof(send_data_data) - 1,
/* init .hiddata.data[0] */
.buf = send_data_data,
};
int main(int argc, char *argv[])
{
snprintf(exec_dir, sizeof(exec_dir), "%s", dirname(argv[0]));
tester_init(&argc, &argv);
/* check general IPC errors */
test_generic("Too small data",
ipc_send_tc, setup, teardown,
&register_bt_msg, 1);
test_generic("Malformed data (wrong payload declared)",
ipc_send_tc, setup, teardown,
&register_bt_malformed_size_msg,
sizeof(register_bt_malformed_size_msg),
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Malformed data2 (undersized msg)",
ipc_send_tc, setup, teardown,
&register_bt_msg,
sizeof(register_bt_msg) - 1,
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Malformed data3 (oversized msg)",
ipc_send_tc, setup, teardown,
&malformed_data3_msg,
sizeof(malformed_data3_msg),
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Invalid service",
ipc_send_tc, setup, teardown,
&enable_unknown_service_hdr,
sizeof(enable_unknown_service_hdr),
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Enable unregistered service",
ipc_send_tc, setup, teardown,
&enable_bt_service_hdr,
sizeof(enable_bt_service_hdr));
/* check service handler's max opcode value */
test_opcode_valid("CORE", HAL_SERVICE_ID_CORE, 0x03, 0);
test_opcode_valid("BLUETOOTH", HAL_SERVICE_ID_BLUETOOTH, 0x15, 0,
HAL_SERVICE_ID_BLUETOOTH);
test_opcode_valid("SOCK", HAL_SERVICE_ID_SOCKET, 0x03, 0,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_SOCKET);
test_opcode_valid("HIDHOST", HAL_SERVICE_ID_HIDHOST, 0x10, 0,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_opcode_valid("PAN", HAL_SERVICE_ID_PAN, 0x05, 0,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_opcode_valid("A2DP", HAL_SERVICE_ID_A2DP, 0x03, 0,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_A2DP);
/* check for valid data size */
test_datasize_valid("CORE Register+", HAL_SERVICE_ID_CORE,
HAL_OP_REGISTER_MODULE,
sizeof(struct hal_cmd_register_module), 1);
test_datasize_valid("CORE Register-", HAL_SERVICE_ID_CORE,
HAL_OP_REGISTER_MODULE,
sizeof(struct hal_cmd_register_module), -1);
test_datasize_valid("CORE Unregister+", HAL_SERVICE_ID_CORE,
HAL_OP_UNREGISTER_MODULE,
sizeof(struct hal_cmd_unregister_module), 1);
test_datasize_valid("CORE Unregister-", HAL_SERVICE_ID_CORE,
HAL_OP_UNREGISTER_MODULE,
sizeof(struct hal_cmd_unregister_module), -1);
/* check for valid data size for BLUETOOTH */
test_datasize_valid("BT Enable+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_ENABLE,
0, 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Disable+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_DISABLE,
0, 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Adapter Props+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_ADAPTER_PROPS,
0, 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Adapter Prop+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_ADAPTER_PROP,
sizeof(struct hal_cmd_get_adapter_prop), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Adapter Prop-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_ADAPTER_PROP,
sizeof(struct hal_cmd_get_adapter_prop), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Set Adapter Prop+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SET_ADAPTER_PROP,
sizeof(struct hal_cmd_set_adapter_prop), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Set Adapter Prop-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SET_ADAPTER_PROP,
sizeof(struct hal_cmd_set_adapter_prop), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Data size BT Set Adapter Prop Vardata+",
ipc_send_tc, setup, teardown,
&bt_set_adapter_prop_data_overs,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_set_adapter_prop) +
sizeof(set_name)),
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Data size BT Set Adapter Prop Vardata+",
ipc_send_tc, setup, teardown,
&bt_set_adapter_prop_data_unders,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_set_adapter_prop) +
sizeof(set_name)),
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Props+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_DEVICE_PROPS,
sizeof(struct hal_cmd_get_remote_device_props), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Props-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_DEVICE_PROPS,
sizeof(struct hal_cmd_get_remote_device_props), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Prop+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_DEVICE_PROP,
sizeof(struct hal_cmd_get_remote_device_prop), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Prop-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_DEVICE_PROP,
sizeof(struct hal_cmd_get_remote_device_prop), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Set Remote Prop+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SET_REMOTE_DEVICE_PROP,
sizeof(struct hal_cmd_set_remote_device_prop), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Set Remote Prop-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SET_REMOTE_DEVICE_PROP,
sizeof(struct hal_cmd_set_remote_device_prop), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Data size BT Set Remote Prop Vardata+",
ipc_send_tc, setup, teardown,
&bt_set_remote_prop_data_overs,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_set_remote_device_prop) +
sizeof(set_name)),
HAL_SERVICE_ID_BLUETOOTH);
test_generic("Data size BT Set Remote Prop Vardata-",
ipc_send_tc, setup, teardown,
&bt_set_remote_prop_data_unders,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_set_remote_device_prop) +
sizeof(set_name)),
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote SV Rec+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_SERVICE_REC,
sizeof(struct hal_cmd_get_remote_service_rec), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote SV Rec-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_SERVICE_REC,
sizeof(struct hal_cmd_get_remote_service_rec), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Services+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_SERVICES,
sizeof(struct hal_cmd_get_remote_services), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Get Remote Services-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_SERVICES,
sizeof(struct hal_cmd_get_remote_services), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Start Discovery+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_START_DISCOVERY,
0, 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Cancel Discovery+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_CANCEL_DISCOVERY,
0, 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Create Bond+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_CREATE_BOND,
sizeof(struct hal_cmd_create_bond), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Create Bond-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_CREATE_BOND,
sizeof(struct hal_cmd_create_bond), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Remove Bond+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_REMOVE_BOND,
sizeof(struct hal_cmd_remove_bond), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Remove Bond-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_REMOVE_BOND,
sizeof(struct hal_cmd_remove_bond), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Cancel Bond+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_CANCEL_BOND,
sizeof(struct hal_cmd_cancel_bond), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Cancel Bond-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_CANCEL_BOND,
sizeof(struct hal_cmd_cancel_bond), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Pin Reply+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_PIN_REPLY,
sizeof(struct hal_cmd_pin_reply), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT Pin Reply-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_PIN_REPLY,
sizeof(struct hal_cmd_pin_reply), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT SSP Reply+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SSP_REPLY,
sizeof(struct hal_cmd_ssp_reply), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT SSP Reply-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_SSP_REPLY,
sizeof(struct hal_cmd_ssp_reply), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT DUT Mode Conf+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_DUT_MODE_CONF,
sizeof(struct hal_cmd_dut_mode_conf), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT DUT Mode Conf-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_DUT_MODE_CONF,
sizeof(struct hal_cmd_dut_mode_conf), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT DUT Mode Send+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_DUT_MODE_SEND,
sizeof(struct hal_cmd_dut_mode_send), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT DUT Mode Send-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_DUT_MODE_SEND,
sizeof(struct hal_cmd_dut_mode_send), -1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT LE Test+", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_LE_TEST_MODE,
sizeof(struct hal_cmd_le_test_mode), 1,
HAL_SERVICE_ID_BLUETOOTH);
test_datasize_valid("BT LE Test-", HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_LE_TEST_MODE,
sizeof(struct hal_cmd_le_test_mode), -1,
HAL_SERVICE_ID_BLUETOOTH);
/* check for valid data size for SOCK */
test_datasize_valid("SOCKET Listen+", HAL_SERVICE_ID_SOCKET,
HAL_OP_SOCKET_LISTEN,
sizeof(struct hal_cmd_socket_listen), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_SOCKET);
test_datasize_valid("SOCKET Listen-", HAL_SERVICE_ID_SOCKET,
HAL_OP_SOCKET_LISTEN,
sizeof(struct hal_cmd_socket_listen), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_SOCKET);
test_datasize_valid("SOCKET Connect+", HAL_SERVICE_ID_SOCKET,
HAL_OP_SOCKET_CONNECT,
sizeof(struct hal_cmd_socket_connect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_SOCKET);
test_datasize_valid("SOCKET Connect-", HAL_SERVICE_ID_SOCKET,
HAL_OP_SOCKET_CONNECT,
sizeof(struct hal_cmd_socket_connect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_SOCKET);
/* check for valid data size for HID Host */
test_datasize_valid("HIDHOST Connect+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_CONNECT,
sizeof(struct hal_cmd_hidhost_connect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Connect-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_CONNECT,
sizeof(struct hal_cmd_hidhost_connect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Disconnect+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_DISCONNECT,
sizeof(struct hal_cmd_hidhost_disconnect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Disconnect-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_DISCONNECT,
sizeof(struct hal_cmd_hidhost_disconnect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Virt. Unplug+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_VIRTUAL_UNPLUG,
sizeof(struct hal_cmd_hidhost_virtual_unplug), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Virt. Unplug-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_VIRTUAL_UNPLUG,
sizeof(struct hal_cmd_hidhost_virtual_unplug), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Info+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_INFO,
sizeof(struct hal_cmd_hidhost_set_info), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Info-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_INFO,
sizeof(struct hal_cmd_hidhost_set_info), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Set Info Vardata+",
ipc_send_tc, setup, teardown,
&hidhost_set_info_data_overs,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_set_info) +
sizeof(set_info_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Set Info Vardata-",
ipc_send_tc, setup, teardown,
&hidhost_set_info_data_unders,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_set_info) +
sizeof(set_info_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Get Protocol+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_GET_PROTOCOL,
sizeof(struct hal_cmd_hidhost_get_protocol), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Get Protocol-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_GET_PROTOCOL,
sizeof(struct hal_cmd_hidhost_get_protocol), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Protocol+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_PROTOCOL,
sizeof(struct hal_cmd_hidhost_set_protocol), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Protocol-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_PROTOCOL,
sizeof(struct hal_cmd_hidhost_set_protocol), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Get Report+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_GET_REPORT,
sizeof(struct hal_cmd_hidhost_get_report), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Get Report-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_GET_REPORT,
sizeof(struct hal_cmd_hidhost_get_report), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Report+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_REPORT,
sizeof(struct hal_cmd_hidhost_set_report), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Set Report-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SET_REPORT,
sizeof(struct hal_cmd_hidhost_set_report), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Set Report Vardata+",
ipc_send_tc, setup, teardown,
&hidhost_set_report_data_overs,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_set_report) +
sizeof(set_rep_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Set Report Vardata-",
ipc_send_tc, setup, teardown,
&hidhost_set_report_data_unders,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_set_report) +
sizeof(set_rep_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Send Data+", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SEND_DATA,
sizeof(struct hal_cmd_hidhost_send_data), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_datasize_valid("HIDHOST Send Data-", HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_SEND_DATA,
sizeof(struct hal_cmd_hidhost_send_data), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Send Vardata+",
ipc_send_tc, setup, teardown,
&hidhost_send_data_overs,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_send_data) +
sizeof(send_data_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
test_generic("Data size HIDHOST Send Vardata-",
ipc_send_tc, setup, teardown,
&hidhost_send_data_unders,
(sizeof(struct ipc_hdr) +
sizeof(struct hal_cmd_hidhost_send_data) +
sizeof(send_data_data)),
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_HIDHOST);
/* check for valid data size for PAN */
test_datasize_valid("PAN Enable+", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_ENABLE,
sizeof(struct hal_cmd_pan_enable), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Enable-", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_ENABLE,
sizeof(struct hal_cmd_pan_enable), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Get Role+", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_GET_ROLE,
0, 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Connect+", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_CONNECT,
sizeof(struct hal_cmd_pan_connect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Connect-", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_CONNECT,
sizeof(struct hal_cmd_pan_connect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Disconnect+", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_DISCONNECT,
sizeof(struct hal_cmd_pan_disconnect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
test_datasize_valid("PAN Disconnect-", HAL_SERVICE_ID_PAN,
HAL_OP_PAN_DISCONNECT,
sizeof(struct hal_cmd_pan_disconnect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_PAN);
/* check for valid data size for A2DP */
test_datasize_valid("A2DP Connect+", HAL_SERVICE_ID_A2DP,
HAL_OP_A2DP_CONNECT,
sizeof(struct hal_cmd_a2dp_connect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_A2DP);
test_datasize_valid("A2DP Connect-", HAL_SERVICE_ID_A2DP,
HAL_OP_A2DP_CONNECT,
sizeof(struct hal_cmd_a2dp_connect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_A2DP);
test_datasize_valid("A2DP Disconnect+", HAL_SERVICE_ID_A2DP,
HAL_OP_A2DP_DISCONNECT,
sizeof(struct hal_cmd_a2dp_disconnect), 1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_A2DP);
test_datasize_valid("A2DP Disconnect-", HAL_SERVICE_ID_A2DP,
HAL_OP_A2DP_DISCONNECT,
sizeof(struct hal_cmd_a2dp_disconnect), -1,
HAL_SERVICE_ID_BLUETOOTH, HAL_SERVICE_ID_A2DP);
return tester_run();
}