* [PATCH v4 1/8] lib: Add definitions for ISO socket
@ 2022-05-16 22:12 Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 2/8] shared/util: Decode BlueZ Experimental ISO Socket UUID Luiz Augusto von Dentz
` (7 more replies)
0 siblings, 8 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:12 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
---
v2: Fix CI findings.
v3: Add patch fixing mgmt-tester Read EXP Features tests.
v4: Rebase and add flag EXP_FEAT_ISO_SOCKET
Makefile.am | 2 +-
lib/bluetooth.h | 38 +++++++++++++++++++++++++++++++++++++-
lib/iso.h | 42 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 80 insertions(+), 2 deletions(-)
create mode 100644 lib/iso.h
diff --git a/Makefile.am b/Makefile.am
index 82125c482..c7b369606 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -69,7 +69,7 @@ lib_headers = lib/bluetooth.h lib/hci.h lib/hci_lib.h \
lib/sco.h lib/l2cap.h lib/sdp.h lib/sdp_lib.h \
lib/rfcomm.h lib/bnep.h lib/cmtp.h lib/hidp.h
-extra_headers = lib/mgmt.h lib/uuid.h lib/a2mp.h lib/amp.h
+extra_headers = lib/mgmt.h lib/uuid.h lib/a2mp.h lib/amp.h lib/iso.h
extra_sources = lib/uuid.c
local_headers = $(foreach file,$(lib_headers), lib/bluetooth/$(notdir $(file)))
diff --git a/lib/bluetooth.h b/lib/bluetooth.h
index 0fcf412c6..73297c147 100644
--- a/lib/bluetooth.h
+++ b/lib/bluetooth.h
@@ -37,6 +37,7 @@ extern "C" {
#define BTPROTO_CMTP 5
#define BTPROTO_HIDP 6
#define BTPROTO_AVDTP 7
+#define BTPROTO_ISO 8
#define SOL_HCI 0
#define SOL_L2CAP 6
@@ -140,7 +141,39 @@ struct bt_voice {
#define BT_SCM_PKT_STATUS 0x03
-#define BT_CODEC 19
+#define BT_ISO_QOS 17
+
+#define BT_ISO_QOS_CIG_UNSET 0xff
+#define BT_ISO_QOS_CIS_UNSET 0xff
+
+struct bt_iso_io_qos {
+ uint32_t interval;
+ uint16_t latency;
+ uint16_t sdu;
+ uint8_t phy;
+ uint8_t rtn;
+};
+
+struct bt_iso_qos {
+ union {
+ uint8_t cig;
+ uint8_t big;
+ };
+ union {
+ uint8_t cis;
+ uint8_t bis;
+ };
+ union {
+ uint8_t sca;
+ uint8_t sync_interval;
+ };
+ uint8_t packing;
+ uint8_t framing;
+ struct bt_iso_io_qos in;
+ struct bt_iso_io_qos out;
+};
+
+#define BT_CODEC 19
struct bt_codec {
uint8_t id;
uint16_t cid;
@@ -158,6 +191,7 @@ struct bt_codecs {
struct bt_codec codecs[];
} __attribute__((packed));
+
/* Connection and socket states */
enum {
BT_CONNECTED = 1, /* Equal to TCP_ESTABLISHED to make net code happy */
@@ -171,6 +205,8 @@ enum {
BT_CLOSED
};
+#define BT_ISO_BASE 20
+
/* Byte order conversions */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define htobs(d) (d)
diff --git a/lib/iso.h b/lib/iso.h
new file mode 100644
index 000000000..1e9f79ce5
--- /dev/null
+++ b/lib/iso.h
@@ -0,0 +1,42 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2022 Intel Corporation.
+ *
+ */
+
+#ifndef __ISO_H
+#define __ISO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ISO defaults */
+#define ISO_DEFAULT_MTU 251
+#define ISO_MAX_NUM_BIS 0x1f
+
+/* ISO socket broadcast address */
+struct sockaddr_iso_bc {
+ bdaddr_t bc_bdaddr;
+ uint8_t bc_bdaddr_type;
+ uint8_t bc_sid;
+ uint8_t bc_num_bis;
+ uint8_t bc_bis[ISO_MAX_NUM_BIS];
+};
+
+/* ISO socket address */
+struct sockaddr_iso {
+ sa_family_t iso_family;
+ bdaddr_t iso_bdaddr;
+ uint8_t iso_bdaddr_type;
+ struct sockaddr_iso_bc iso_bc[];
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ISO_H */
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 2/8] shared/util: Decode BlueZ Experimental ISO Socket UUID
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
@ 2022-05-16 22:12 ` Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 3/8] mgmt-tester: Fix Read Exp Feature tests Luiz Augusto von Dentz
` (6 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:12 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds BlueZ experimental ISO Socket UUID to uuid128_table so it is
decoded by the likes of btmon.
---
src/shared/util.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/shared/util.c b/src/shared/util.c
index 33196bf8b..b74a005ce 100644
--- a/src/shared/util.c
+++ b/src/shared/util.c
@@ -1149,6 +1149,8 @@ static const struct {
{ "330859bc-7506-492d-9370-9a6f0614037f",
"BlueZ Experimental Bluetooth Quality Report" },
{ "a6695ace-ee7f-4fb9-881a-5fac66c629af", "BlueZ Offload Codecs"},
+ { "6fbaf188-05e0-496a-9885-d6ddfdb4e03e",
+ "BlueZ Experimental ISO Socket"},
{ }
};
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 3/8] mgmt-tester: Fix Read Exp Feature tests
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 2/8] shared/util: Decode BlueZ Experimental ISO Socket UUID Luiz Augusto von Dentz
@ 2022-05-16 22:12 ` Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 4/8] adapter: Add support for setting ISO Socket experimental feature Luiz Augusto von Dentz
` (5 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:12 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds ISO Socket UUID as response to Read Exp Feature.
---
tools/mgmt-tester.c | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/tools/mgmt-tester.c b/tools/mgmt-tester.c
index e5319d123..bfa5905e0 100644
--- a/tools/mgmt-tester.c
+++ b/tools/mgmt-tester.c
@@ -9798,7 +9798,7 @@ static const struct generic_data set_dev_flags_fail_3 = {
};
static const uint8_t read_exp_feat_param_success[] = {
- 0x03, 0x00, /* Feature Count */
+ 0x04, 0x00, /* Feature Count */
0xd6, 0x49, 0xb0, 0xd1, 0x28, 0xeb, /* UUID - Simultaneous */
0x27, 0x92, 0x96, 0x46, 0xc0, 0x42, /* Central Peripheral */
0xb5, 0x10, 0x1b, 0x67,
@@ -9810,7 +9810,11 @@ static const uint8_t read_exp_feat_param_success[] = {
0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f, /* UUID - Codec Offload */
0x1a, 0x88, 0xb9, 0x4f, 0x7f, 0xee,
0xce, 0x5a, 0x69, 0xa6,
- 0x00, 0x00, 0x00, 0x00 /* Flags */
+ 0x00, 0x00, 0x00, 0x00, /* Flags */
+ 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, /* UUID - ISO Socket */
+ 0x85, 0x98, 0x6a, 0x49, 0xe0, 0x05,
+ 0x88, 0xf1, 0xba, 0x6f,
+ 0x00, 0x00, 0x00, 0x00, /* Flags */
};
static const struct generic_data read_exp_feat_success = {
@@ -9822,11 +9826,15 @@ static const struct generic_data read_exp_feat_success = {
static const uint8_t read_exp_feat_param_success_index_none[] = {
- 0x01, 0x00, /* Feature Count */
+ 0x02, 0x00, /* Feature Count */
0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c, /* UUID - Debug */
0x01, 0xab, 0x9f, 0x46, 0xec, 0xb9,
0x30, 0x25, 0x99, 0xd4,
0x00, 0x00, 0x00, 0x00, /* Flags */
+ 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, /* UUID - ISO Socket */
+ 0x85, 0x98, 0x6a, 0x49, 0xe0, 0x05,
+ 0x88, 0xf1, 0xba, 0x6f,
+ 0x00, 0x00, 0x00, 0x00, /* Flags */
};
static const struct generic_data read_exp_feat_success_index_none = {
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 4/8] adapter: Add support for setting ISO Socket experimental feature
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 2/8] shared/util: Decode BlueZ Experimental ISO Socket UUID Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 3/8] mgmt-tester: Fix Read Exp Feature tests Luiz Augusto von Dentz
@ 2022-05-16 22:13 ` Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 5/8] btio: Add support for ISO sockets Luiz Augusto von Dentz
` (4 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:13 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds support for setting ISO Socket experimental UUID which
enables the use of BTPROTO_ISO on the system.
---
src/adapter.c | 42 ++++++++++++++++++++++++++++++++++++++++++
src/adapter.h | 1 +
src/main.c | 1 +
src/main.conf | 1 +
4 files changed, 45 insertions(+)
diff --git a/src/adapter.c b/src/adapter.c
index f7faaa263..6cfc7facc 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -141,6 +141,13 @@ static const struct mgmt_exp_uuid codec_offload_uuid = {
.str = "a6695ace-ee7f-4fb9-881a-5fac66c629af"
};
+/* 6fbaf188-05e0-496a-9885-d6ddfdb4e03e */
+static const struct mgmt_exp_uuid iso_socket_uuid = {
+ .val = { 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, 0x85, 0x98,
+ 0x6a, 0x49, 0xe0, 0x05, 0x88, 0xf1, 0xba, 0x6f },
+ .str = "6fbaf188-05e0-496a-9885-d6ddfdb4e03e"
+};
+
static DBusConnection *dbus_conn = NULL;
static uint32_t kernel_features = 0;
@@ -9695,6 +9702,40 @@ static void codec_offload_func(struct btd_adapter *adapter, uint8_t action)
btd_error(adapter->dev_id, "Failed to set Codec Offload");
}
+static void iso_socket_complete(uint8_t status, uint16_t len,
+ const void *param, void *user_data)
+{
+ struct btd_adapter *adapter = user_data;
+ uint8_t action = btd_opts.experimental ? 0x01 : 0x00;
+
+ if (status != 0) {
+ error("Set ISO Socket failed with status 0x%02x (%s)",
+ status, mgmt_errstr(status));
+ return;
+ }
+
+ DBG("ISO Socket successfully set");
+
+ if (action)
+ queue_push_tail(adapter->exps, (void *)iso_socket_uuid.val);
+}
+
+static void iso_socket_func(struct btd_adapter *adapter, uint8_t action)
+{
+ struct mgmt_cp_set_exp_feature cp;
+
+ memset(&cp, 0, sizeof(cp));
+ memcpy(cp.uuid, iso_socket_uuid.val, 16);
+ cp.action = action;
+
+ if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
+ MGMT_INDEX_NONE, sizeof(cp), &cp,
+ iso_socket_complete, adapter, NULL) > 0)
+ return;
+
+ btd_error(adapter->dev_id, "Failed to set ISO Socket");
+}
+
static const struct exp_feat {
uint32_t flag;
const struct mgmt_exp_uuid *uuid;
@@ -9708,6 +9749,7 @@ static const struct exp_feat {
rpa_resolution_func),
EXP_FEAT(EXP_FEAT_CODEC_OFFLOAD, &codec_offload_uuid,
codec_offload_func),
+ EXP_FEAT(EXP_FEAT_ISO_SOCKET, &iso_socket_uuid, iso_socket_func),
};
static void read_exp_features_complete(uint8_t status, uint16_t length,
diff --git a/src/adapter.h b/src/adapter.h
index 688ed51c6..b09044edd 100644
--- a/src/adapter.h
+++ b/src/adapter.h
@@ -260,6 +260,7 @@ enum experimental_features {
EXP_FEAT_BQR = 1 << 2,
EXP_FEAT_RPA_RESOLUTION = 1 << 3,
EXP_FEAT_CODEC_OFFLOAD = 1 << 4,
+ EXP_FEAT_ISO_SOCKET = 1 << 5,
};
bool btd_adapter_has_exp_feature(struct btd_adapter *adapter, uint32_t feature);
diff --git a/src/main.c b/src/main.c
index 12cc21372..011d66d5a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -606,6 +606,7 @@ static const char *valid_uuids[] = {
"15c0a148-c273-11ea-b3de-0242ac130004",
"330859bc-7506-492d-9370-9a6f0614037f",
"a6695ace-ee7f-4fb9-881a-5fac66c629af",
+ "6fbaf188-05e0-496a-9885-d6ddfdb4e03e",
"*"
};
diff --git a/src/main.conf b/src/main.conf
index 91b98b8c4..9d0319318 100644
--- a/src/main.conf
+++ b/src/main.conf
@@ -120,6 +120,7 @@
# 15c0a148-c273-11ea-b3de-0242ac130004 (BlueZ Experimental LL privacy)
# 330859bc-7506-492d-9370-9a6f0614037f (BlueZ Experimental Bluetooth Quality Report)
# a6695ace-ee7f-4fb9-881a-5fac66c629af (BlueZ Experimental Offload Codecs)
+# 6fbaf188-05e0-496a-9885-d6ddfdb4e03e (BlueZ Experimental ISO socket)
# Defaults to false.
#Experimental = false
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 5/8] btio: Add support for ISO sockets
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
` (2 preceding siblings ...)
2022-05-16 22:13 ` [PATCH v4 4/8] adapter: Add support for setting ISO Socket experimental feature Luiz Augusto von Dentz
@ 2022-05-16 22:13 ` Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 6/8] tools: Add iso-tester Luiz Augusto von Dentz
` (3 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:13 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds support to create objects that map to ISO sockets.
---
btio/btio.c | 170 +++++++++++++++++++++++++++++++++++++++++++++++
btio/btio.h | 4 +-
tools/btiotest.c | 110 ++++++++++++++++++++++++++++++
3 files changed, 283 insertions(+), 1 deletion(-)
diff --git a/btio/btio.c b/btio/btio.c
index f4f53574c..75d17e7aa 100644
--- a/btio/btio.c
+++ b/btio/btio.c
@@ -27,6 +27,7 @@
#include "lib/l2cap.h"
#include "lib/rfcomm.h"
#include "lib/sco.h"
+#include "lib/iso.h"
#include "btio.h"
@@ -44,6 +45,7 @@ typedef enum {
BT_IO_L2CAP,
BT_IO_RFCOMM,
BT_IO_SCO,
+ BT_IO_ISO,
BT_IO_INVALID,
} BtIOType;
@@ -66,6 +68,7 @@ struct set_opts {
int flushable;
uint32_t priority;
uint16_t voice;
+ struct bt_iso_qos qos;
};
struct connect {
@@ -123,6 +126,8 @@ static BtIOType bt_io_get_type(GIOChannel *io, GError **gerr)
return BT_IO_SCO;
case BTPROTO_L2CAP:
return BT_IO_L2CAP;
+ case BTPROTO_ISO:
+ return BT_IO_ISO;
default:
g_set_error(gerr, BT_IO_ERROR, EINVAL,
"Unknown BtIO socket type");
@@ -763,6 +768,24 @@ static int sco_bind(int sock, const bdaddr_t *src, GError **err)
return 0;
}
+static int iso_bind(int sock, const bdaddr_t *src, uint8_t src_type,
+ GError **err)
+{
+ struct sockaddr_iso addr;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ bacpy(&addr.iso_bdaddr, src);
+ addr.iso_bdaddr_type = src_type;
+
+ if (!bind(sock, (struct sockaddr *) &addr, sizeof(addr)))
+ return 0;
+
+ ERROR_FAILED(err, "iso_bind", errno);
+
+ return -errno;
+}
+
static int sco_connect(int sock, const bdaddr_t *dst)
{
struct sockaddr_sco addr;
@@ -779,6 +802,23 @@ static int sco_connect(int sock, const bdaddr_t *dst)
return 0;
}
+static int iso_connect(int sock, const bdaddr_t *dst, uint8_t dst_type)
+{
+ struct sockaddr_iso addr;
+ int err;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ bacpy(&addr.iso_bdaddr, dst);
+ addr.iso_bdaddr_type = dst_type;
+
+ err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
+ if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
+ return -errno;
+
+ return 0;
+}
+
static gboolean sco_set(int sock, uint16_t mtu, uint16_t voice, GError **err)
{
struct sco_options sco_opt;
@@ -817,6 +857,17 @@ voice:
return TRUE;
}
+static gboolean iso_set(int sock, struct bt_iso_qos *qos, GError **err)
+{
+ if (setsockopt(sock, SOL_BLUETOOTH, BT_ISO_QOS, qos,
+ sizeof(*qos)) < 0) {
+ ERROR_FAILED(err, "setsockopt(BT_ISO_QOS)", errno);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
static gboolean parse_set_opts(struct set_opts *opts, GError **err,
BtIOOption opt1, va_list args)
{
@@ -894,6 +945,13 @@ static gboolean parse_set_opts(struct set_opts *opts, GError **err,
break;
case BT_IO_OPT_MODE:
opts->mode = va_arg(args, int);
+ if (opts->mode == BT_IO_MODE_ISO) {
+ opts->type = BT_IO_ISO;
+ if (opts->src_type == BDADDR_BREDR)
+ opts->src_type = BDADDR_LE_PUBLIC;
+ if (opts->dst_type == BDADDR_BREDR)
+ opts->dst_type = BDADDR_LE_PUBLIC;
+ }
break;
case BT_IO_OPT_FLUSHABLE:
opts->flushable = va_arg(args, gboolean);
@@ -904,6 +962,9 @@ static gboolean parse_set_opts(struct set_opts *opts, GError **err,
case BT_IO_OPT_VOICE:
opts->voice = va_arg(args, int);
break;
+ case BT_IO_OPT_QOS:
+ opts->qos = *va_arg(args, struct bt_iso_qos *);
+ break;
case BT_IO_OPT_INVALID:
case BT_IO_OPT_KEY_SIZE:
case BT_IO_OPT_SOURCE_CHANNEL:
@@ -1227,6 +1288,7 @@ parse_opts:
case BT_IO_OPT_DEST_CHANNEL:
case BT_IO_OPT_MTU:
case BT_IO_OPT_VOICE:
+ case BT_IO_OPT_QOS:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
"Unknown option %d", opt);
@@ -1380,6 +1442,7 @@ static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1,
case BT_IO_OPT_FLUSHABLE:
case BT_IO_OPT_PRIORITY:
case BT_IO_OPT_VOICE:
+ case BT_IO_OPT_QOS:
case BT_IO_OPT_INVALID:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
@@ -1489,6 +1552,95 @@ static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args)
case BT_IO_OPT_FLUSHABLE:
case BT_IO_OPT_PRIORITY:
case BT_IO_OPT_VOICE:
+ case BT_IO_OPT_QOS:
+ case BT_IO_OPT_INVALID:
+ default:
+ g_set_error(err, BT_IO_ERROR, EINVAL,
+ "Unknown option %d", opt);
+ return FALSE;
+ }
+
+ opt = va_arg(args, int);
+ }
+
+ return TRUE;
+}
+
+static gboolean iso_get(int sock, GError **err, BtIOOption opt1, va_list args)
+{
+ BtIOOption opt = opt1;
+ struct sockaddr_iso src, dst;
+ struct bt_iso_qos qos;
+ socklen_t len;
+ uint32_t phy;
+
+ len = sizeof(qos);
+ memset(&qos, 0, len);
+ if (getsockopt(sock, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len) < 0) {
+ ERROR_FAILED(err, "getsockopt(BT_ISO_QOS)", errno);
+ return FALSE;
+ }
+
+ if (!get_src(sock, &src, sizeof(src), err))
+ return FALSE;
+
+ if (!get_dst(sock, &dst, sizeof(dst), err))
+ return FALSE;
+
+ while (opt != BT_IO_OPT_INVALID) {
+ switch (opt) {
+ case BT_IO_OPT_SOURCE:
+ ba2str(&src.iso_bdaddr, va_arg(args, char *));
+ break;
+ case BT_IO_OPT_SOURCE_BDADDR:
+ bacpy(va_arg(args, bdaddr_t *), &src.iso_bdaddr);
+ break;
+ case BT_IO_OPT_SOURCE_TYPE:
+ *(va_arg(args, uint8_t *)) = src.iso_bdaddr_type;
+ break;
+ case BT_IO_OPT_DEST:
+ ba2str(&dst.iso_bdaddr, va_arg(args, char *));
+ break;
+ case BT_IO_OPT_DEST_BDADDR:
+ bacpy(va_arg(args, bdaddr_t *), &dst.iso_bdaddr);
+ break;
+ case BT_IO_OPT_DEST_TYPE:
+ *(va_arg(args, uint8_t *)) = dst.iso_bdaddr_type;
+ break;
+ case BT_IO_OPT_MTU:
+ *(va_arg(args, uint16_t *)) = qos.out.sdu;
+ break;
+ case BT_IO_OPT_IMTU:
+ *(va_arg(args, uint16_t *)) = qos.in.sdu;
+ break;
+ case BT_IO_OPT_OMTU:
+ *(va_arg(args, uint16_t *)) = qos.out.sdu;
+ break;
+ case BT_IO_OPT_PHY:
+ if (get_phy(sock, &phy) < 0) {
+ ERROR_FAILED(err, "get_phy", errno);
+ return FALSE;
+ }
+ *(va_arg(args, uint32_t *)) = phy;
+ break;
+ case BT_IO_OPT_QOS:
+ *(va_arg(args, struct bt_iso_qos *)) = qos;
+ break;
+ case BT_IO_OPT_HANDLE:
+ case BT_IO_OPT_CLASS:
+ case BT_IO_OPT_DEFER_TIMEOUT:
+ case BT_IO_OPT_SEC_LEVEL:
+ case BT_IO_OPT_KEY_SIZE:
+ case BT_IO_OPT_CHANNEL:
+ case BT_IO_OPT_SOURCE_CHANNEL:
+ case BT_IO_OPT_DEST_CHANNEL:
+ case BT_IO_OPT_PSM:
+ case BT_IO_OPT_CID:
+ case BT_IO_OPT_CENTRAL:
+ case BT_IO_OPT_MODE:
+ case BT_IO_OPT_FLUSHABLE:
+ case BT_IO_OPT_PRIORITY:
+ case BT_IO_OPT_VOICE:
case BT_IO_OPT_INVALID:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
@@ -1516,6 +1668,8 @@ static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err,
return rfcomm_get(sock, err, opt1, args);
case BT_IO_SCO:
return sco_get(sock, err, opt1, args);
+ case BT_IO_ISO:
+ return iso_get(sock, err, opt1, args);
case BT_IO_INVALID:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
@@ -1584,6 +1738,8 @@ gboolean bt_io_set(GIOChannel *io, GError **err, BtIOOption opt1, ...)
return rfcomm_set(sock, opts.sec_level, opts.central, err);
case BT_IO_SCO:
return sco_set(sock, opts.mtu, opts.voice, err);
+ case BT_IO_ISO:
+ return iso_set(sock, &opts.qos, err);
case BT_IO_INVALID:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
@@ -1655,6 +1811,17 @@ static GIOChannel *create_io(gboolean server, struct set_opts *opts,
if (!sco_set(sock, opts->mtu, opts->voice, err))
goto failed;
break;
+ case BT_IO_ISO:
+ sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sock < 0) {
+ ERROR_FAILED(err, "socket(SEQPACKET, ISO)", errno);
+ return NULL;
+ }
+ if (iso_bind(sock, &opts->src, opts->src_type, err) < 0)
+ goto failed;
+ if (!iso_set(sock, &opts->qos, err))
+ goto failed;
+ break;
case BT_IO_INVALID:
default:
g_set_error(err, BT_IO_ERROR, EINVAL,
@@ -1719,6 +1886,9 @@ GIOChannel *bt_io_connect(BtIOConnect connect, gpointer user_data,
case BT_IO_SCO:
err = sco_connect(sock, &opts.dst);
break;
+ case BT_IO_ISO:
+ err = iso_connect(sock, &opts.dst, opts.dst_type);
+ break;
case BT_IO_INVALID:
default:
g_set_error(gerr, BT_IO_ERROR, EINVAL,
diff --git a/btio/btio.h b/btio/btio.h
index 50a2a4dc0..9636fd467 100644
--- a/btio/btio.h
+++ b/btio/btio.h
@@ -44,6 +44,7 @@ typedef enum {
BT_IO_OPT_PRIORITY,
BT_IO_OPT_VOICE,
BT_IO_OPT_PHY,
+ BT_IO_OPT_QOS,
} BtIOOption;
typedef enum {
@@ -58,7 +59,8 @@ typedef enum {
BT_IO_MODE_ERTM,
BT_IO_MODE_STREAMING,
BT_IO_MODE_LE_FLOWCTL,
- BT_IO_MODE_EXT_FLOWCTL
+ BT_IO_MODE_EXT_FLOWCTL,
+ BT_IO_MODE_ISO
} BtIOMode;
typedef void (*BtIOConfirm)(GIOChannel *io, gpointer user_data);
diff --git a/tools/btiotest.c b/tools/btiotest.c
index 70d74ffbe..193e1395b 100644
--- a/tools/btiotest.c
+++ b/tools/btiotest.c
@@ -29,6 +29,25 @@
#define DEFAULT_ACCEPT_TIMEOUT 2
static int opt_update_sec = 0;
+#define DEFAULT_IO_QOS \
+{ \
+ .interval = 10000, \
+ .latency = 10, \
+ .sdu = 40, \
+ .phy = 0x02, \
+ .rtn = 2, \
+}
+
+struct bt_iso_qos qos = {
+ .cig = BT_ISO_QOS_CIG_UNSET,
+ .cis = BT_ISO_QOS_CIG_UNSET,
+ .sca = 0x07,
+ .packing = 0x00,
+ .framing = 0x00,
+ .in = DEFAULT_IO_QOS,
+ .out = DEFAULT_IO_QOS,
+};
+
struct io_data {
guint ref;
GIOChannel *io;
@@ -36,6 +55,7 @@ struct io_data {
int disconn;
int accept;
int voice;
+ struct bt_iso_qos *qos;
};
static void io_data_unref(struct io_data *data)
@@ -67,6 +87,7 @@ static struct io_data *io_data_new(GIOChannel *io, int reject, int disconn,
data->reject = reject;
data->disconn = disconn;
data->accept = accept;
+ data->qos = &qos;
return io_data_ref(data);
}
@@ -530,9 +551,88 @@ static void sco_listen(const char *src, gboolean defer, int reject,
g_io_channel_unref(sco_srv);
}
+static void iso_connect(const char *src, const char *dst, int disconn)
+{
+ struct io_data *data;
+ GError *err = NULL;
+
+ printf("Connecting ISO to %s\n", dst);
+
+ data = io_data_new(NULL, -1, disconn, -1);
+
+ if (src)
+ data->io = bt_io_connect(connect_cb, data,
+ (GDestroyNotify) io_data_unref,
+ &err,
+ BT_IO_OPT_SOURCE, src,
+ BT_IO_OPT_DEST, dst,
+ BT_IO_OPT_MODE, BT_IO_MODE_ISO,
+ BT_IO_OPT_QOS, data->qos,
+ BT_IO_OPT_INVALID);
+ else
+ data->io = bt_io_connect(connect_cb, data,
+ (GDestroyNotify) io_data_unref,
+ &err,
+ BT_IO_OPT_DEST, dst,
+ BT_IO_OPT_MODE, BT_IO_MODE_ISO,
+ BT_IO_OPT_QOS, data->qos,
+ BT_IO_OPT_INVALID);
+
+ if (!data->io) {
+ printf("Connecting to %s failed: %s\n", dst, err->message);
+ g_error_free(err);
+ exit(EXIT_FAILURE);
+ }
+}
+
+static void iso_listen(const char *src, gboolean defer, int reject,
+ int disconn, int accept)
+{
+ struct io_data *data;
+ BtIOConnect conn;
+ BtIOConfirm cfm;
+ GIOChannel *iso_srv;
+ GError *err = NULL;
+
+ printf("Listening for ISO connections\n");
+
+ if (defer) {
+ conn = NULL;
+ cfm = confirm_cb;
+ } else {
+ conn = connect_cb;
+ cfm = NULL;
+ }
+
+ data = io_data_new(NULL, reject, disconn, accept);
+
+ if (src)
+ iso_srv = bt_io_listen(conn, cfm, data,
+ (GDestroyNotify) io_data_unref,
+ &err,
+ BT_IO_OPT_SOURCE, src,
+ BT_IO_OPT_MODE, BT_IO_MODE_ISO,
+ BT_IO_OPT_INVALID);
+ else
+ iso_srv = bt_io_listen(conn, cfm, data,
+ (GDestroyNotify) io_data_unref,
+ &err,
+ BT_IO_OPT_MODE, BT_IO_MODE_ISO,
+ BT_IO_OPT_INVALID);
+
+ if (!iso_srv) {
+ printf("Listening failed: %s\n", err->message);
+ g_error_free(err);
+ exit(EXIT_FAILURE);
+ }
+
+ g_io_channel_unref(iso_srv);
+}
+
static int opt_channel = -1;
static int opt_psm = 0;
static gboolean opt_sco = FALSE;
+static gboolean opt_iso = FALSE;
static gboolean opt_defer = FALSE;
static gint opt_voice = 0;
static char *opt_dev = NULL;
@@ -559,6 +659,8 @@ static GOptionEntry options[] = {
"(0 BR/EDR 1 LE Public 2 LE Random" },
{ "sco", 's', 0, G_OPTION_ARG_NONE, &opt_sco,
"Use SCO" },
+ { "iso", 'o', 0, G_OPTION_ARG_NONE, &opt_iso,
+ "Use ISO" },
{ "defer", 'd', 0, G_OPTION_ARG_NONE, &opt_defer,
"Use DEFER_SETUP for incoming connections" },
{ "voice", 'V', 0, G_OPTION_ARG_INT, &opt_voice,
@@ -637,6 +739,14 @@ int main(int argc, char *argv[])
opt_disconn, opt_accept, opt_voice);
}
+ if (opt_iso) {
+ if (argc > 1)
+ iso_connect(opt_dev, argv[1], opt_disconn);
+ else
+ iso_listen(opt_dev, opt_defer, opt_reject,
+ opt_disconn, opt_accept);
+ }
+
signal(SIGTERM, sig_term);
signal(SIGINT, sig_term);
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 6/8] tools: Add iso-tester
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
` (3 preceding siblings ...)
2022-05-16 22:13 ` [PATCH v4 5/8] btio: Add support for ISO sockets Luiz Augusto von Dentz
@ 2022-05-16 22:13 ` Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 7/8] tools: Add isotest tool Luiz Augusto von Dentz
` (2 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:13 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds iso-tester which tests BTPROTO_ISO socket:
Basic Framework - Success
Basic ISO Socket - Success
Basic ISO Get Socket Option - Success
Basic ISO Set Socket Option - Success
ISO QoS 8_1_1 - Success
ISO QoS 8_2_1 - Success
ISO QoS 16_1_1 - Success
ISO QoS 16_2_1 - Success
ISO QoS 16_2_1 CIG 0x01 - Success
ISO QoS 16_2_1 CIG 0x01 CIS 0x01 - Success
ISO QoS 24_1_1 - Success
ISO QoS 24_2_1 - Success
ISO QoS 32_1_1 - Success
ISO QoS 32_2_1 - Success
ISO QoS 44_1_1 - Success
ISO QoS 44_2_1 - Success
ISO QoS 48_1_1 - Success
ISO QoS 48_2_1 - Success
ISO QoS 48_3_1 - Success
ISO QoS 48_4_1 - Success
ISO QoS 48_5_1 - Success
ISO QoS 48_6_1 - Success
ISO QoS 8_1_2 - Success
ISO QoS 8_2_2 - Success
ISO QoS 16_1_2 - Success
ISO QoS 16_2_2 - Success
ISO QoS 24_1_2 - Success
ISO QoS 24_2_2 - Success
ISO QoS 32_1_2 - Success
ISO QoS 32_2_2 - Success
ISO QoS 44_1_2 - Success
ISO QoS 44_2_2 - Success
ISO QoS 48_1_2 - Success
ISO QoS 48_2_2 - Success
ISO QoS 48_3_2 - Success
ISO QoS 48_4_2 - Success
ISO QoS 48_5_2 - Success
ISO QoS 48_6_2 - Success
ISO QoS - Invalid
ISO Connect2 CIG 0x01 - Success
ISO Send - Success
ISO Receive - Success
ISO Send and Receive - Success
ISO Broadcaster - Success
ISO Broadcaster BIG 0x01 - Success
ISO Broadcaster BIG 0x01 BIS 0x01 - Success
ISO Broadcaster Receiver - Success
---
Makefile.tools | 11 +-
tools/iso-tester.c | 1487 +++++++++++++++++++++++++++++++++++++++++++
tools/test-runner.c | 5 +-
3 files changed, 1500 insertions(+), 3 deletions(-)
create mode 100644 tools/iso-tester.c
diff --git a/Makefile.tools b/Makefile.tools
index b7d893248..89533ece2 100644
--- a/Makefile.tools
+++ b/Makefile.tools
@@ -81,7 +81,7 @@ noinst_PROGRAMS += emulator/btvirt emulator/b1ee emulator/hfp \
tools/l2cap-tester tools/sco-tester \
tools/smp-tester tools/hci-tester \
tools/rfcomm-tester tools/bnep-tester \
- tools/userchan-tester
+ tools/userchan-tester tools/iso-tester
emulator_btvirt_SOURCES = emulator/main.c monitor/bt.h \
emulator/serial.h emulator/serial.c \
@@ -189,6 +189,15 @@ tools_userchan_tester_SOURCES = tools/userchan-tester.c monitor/bt.h \
emulator/smp.c
tools_userchan_tester_LDADD = lib/libbluetooth-internal.la \
src/libshared-glib.la $(GLIB_LIBS)
+
+tools_iso_tester_SOURCES = tools/iso-tester.c monitor/bt.h \
+ emulator/hciemu.h emulator/hciemu.c \
+ emulator/vhci.h emulator/vhci.c \
+ emulator/btdev.h emulator/btdev.c \
+ emulator/bthost.h emulator/bthost.c \
+ emulator/smp.c
+tools_iso_tester_LDADD = lib/libbluetooth-internal.la \
+ src/libshared-glib.la $(GLIB_LIBS)
endif
if TOOLS
diff --git a/tools/iso-tester.c b/tools/iso-tester.c
new file mode 100644
index 000000000..c68d22fc2
--- /dev/null
+++ b/tools/iso-tester.c
@@ -0,0 +1,1487 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2022 Intel Corporation.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdbool.h>
+
+#include <glib.h>
+
+#include "lib/bluetooth.h"
+#include "lib/iso.h"
+#include "lib/mgmt.h"
+
+#include "monitor/bt.h"
+#include "emulator/bthost.h"
+#include "emulator/hciemu.h"
+
+#include "src/shared/tester.h"
+#include "src/shared/mgmt.h"
+#include "src/shared/util.h"
+
+#define QOS_IO(_interval, _latency, _sdu, _phy, _rtn) \
+{ \
+ .interval = _interval, \
+ .latency = _latency, \
+ .sdu = _sdu, \
+ .phy = _phy, \
+ .rtn = _rtn, \
+}
+
+#define QOS_FULL(_cig, _cis, _in, _out) \
+{ \
+ .cig = _cig, \
+ .cis = _cis, \
+ .sca = 0x07, \
+ .packing = 0x00, \
+ .framing = 0x00, \
+ .in = _in, \
+ .out = _out, \
+}
+
+#define QOS(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(BT_ISO_QOS_CIG_UNSET, BT_ISO_QOS_CIS_UNSET, \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn), \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_1(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(0x01, BT_ISO_QOS_CIS_UNSET, \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn), \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_1_1(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(0x01, 0x01, \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn), \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_OUT(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(BT_ISO_QOS_CIG_UNSET, BT_ISO_QOS_CIS_UNSET, \
+ {}, QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_OUT_1(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(0x01, BT_ISO_QOS_CIS_UNSET, \
+ {}, QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_OUT_1_1(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(0x01, 0x01, \
+ {}, QOS_IO(_interval, _latency, _sdu, _phy, _rtn))
+
+#define QOS_IN(_interval, _latency, _sdu, _phy, _rtn) \
+ QOS_FULL(BT_ISO_QOS_CIG_UNSET, BT_ISO_QOS_CIS_UNSET, \
+ QOS_IO(_interval, _latency, _sdu, _phy, _rtn), {})
+
+/* QoS Configuration settings for low latency audio data */
+#define QOS_8_1_1 QOS(7500, 8, 26, 0x02, 2)
+#define QOS_8_2_1 QOS(10000, 10, 30, 0x02, 2)
+#define QOS_16_1_1 QOS(7500, 8, 30, 0x02, 2)
+#define QOS_16_2_1 QOS(10000, 10, 40, 0x02, 2)
+#define QOS_1_16_2_1 QOS_1(10000, 10, 40, 0x02, 2)
+#define QOS_1_1_16_2_1 QOS_1_1(10000, 10, 40, 0x02, 2)
+#define QOS_24_1_1 QOS(7500, 8, 45, 0x02, 2)
+#define QOS_24_2_1 QOS(10000, 10, 60, 0x02, 2)
+#define QOS_32_1_1 QOS(7500, 8, 60, 0x02, 2)
+#define QOS_32_2_1 QOS(10000, 10, 80, 0x02, 2)
+#define QOS_44_1_1 QOS_OUT(8163, 24, 98, 0x02, 5)
+#define QOS_44_2_1 QOS_OUT(10884, 31, 130, 0x02, 5)
+#define QOS_48_1_1 QOS_OUT(7500, 15, 75, 0x02, 5)
+#define QOS_48_2_1 QOS_OUT(10000, 20, 100, 0x02, 5)
+#define QOS_48_3_1 QOS_OUT(7500, 15, 90, 0x02, 5)
+#define QOS_48_4_1 QOS_OUT(10000, 20, 120, 0x02, 5)
+#define QOS_48_5_1 QOS_OUT(7500, 15, 117, 0x02, 5)
+#define QOS_48_6_1 QOS_OUT(10000, 20, 155, 0x02, 5)
+/* QoS Configuration settings for high reliability audio data */
+#define QOS_8_1_2 QOS(7500, 45, 26, 0x02, 41)
+#define QOS_8_2_2 QOS(10000, 60, 30, 0x02, 53)
+#define QOS_16_1_2 QOS(7500, 45, 30, 0x02, 41)
+#define QOS_16_2_2 QOS(10000, 60, 40, 0x02, 47)
+#define QOS_24_1_2 QOS(7500, 45, 45, 0x02, 35)
+#define QOS_24_2_2 QOS(10000, 60, 60, 0x02, 41)
+#define QOS_32_1_2 QOS(7500, 45, 60, 0x02, 29)
+#define QOS_32_2_2 QOS(10000, 60, 80, 0x02, 35)
+#define QOS_44_1_2 QOS_OUT(8163, 54, 98, 0x02, 23)
+#define QOS_44_2_2 QOS_OUT(10884, 71, 130, 0x02, 23)
+#define QOS_48_1_2 QOS_OUT(7500, 45, 75, 0x02, 23)
+#define QOS_48_2_2 QOS_OUT(10000, 60, 100, 0x02, 23)
+#define QOS_48_3_2 QOS_OUT(7500, 45, 90, 0x02, 23)
+#define QOS_48_4_2 QOS_OUT(10000, 60, 120, 0x02, 23)
+#define QOS_48_5_2 QOS_OUT(7500, 45, 117, 0x02, 23)
+#define QOS_48_6_2 QOS_OUT(10000, 60, 155, 0x02, 23)
+
+#define QOS_OUT_16_2_1 QOS_OUT(10000, 10, 40, 0x02, 2)
+#define QOS_OUT_1_16_2_1 QOS_OUT_1(10000, 10, 40, 0x02, 2)
+#define QOS_OUT_1_1_16_2_1 QOS_OUT_1_1(10000, 10, 40, 0x02, 2)
+#define QOS_IN_16_2_1 QOS_IN(10000, 10, 40, 0x02, 2)
+
+struct test_data {
+ const void *test_data;
+ struct mgmt *mgmt;
+ uint16_t mgmt_index;
+ struct hciemu *hciemu;
+ enum hciemu_type hciemu_type;
+ uint16_t handle;
+ uint16_t acl_handle;
+ unsigned int io_id[2];
+ uint8_t client_num;
+ int step;
+};
+
+struct iso_client_data {
+ struct bt_iso_qos qos;
+ int expect_err;
+ struct iovec send;
+ struct iovec recv;
+ bool server;
+ bool bcast;
+};
+
+static void mgmt_debug(const char *str, void *user_data)
+{
+ const char *prefix = user_data;
+
+ tester_print("%s%s", prefix, str);
+}
+
+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 hciemu_debug(const char *str, void *user_data)
+{
+ const char *prefix = user_data;
+
+ tester_print("%s%s", prefix, str);
+}
+
+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_num(HCIEMU_TYPE_BREDRLE52, data->client_num);
+ if (!data->hciemu) {
+ tester_warn("Failed to setup HCI emulation");
+ tester_pre_setup_failed();
+ return;
+ }
+
+ if (tester_use_debug())
+ hciemu_set_debug(data->hciemu, hciemu_debug, "hciemu: ", NULL);
+
+ tester_print("New hciemu instance created");
+}
+
+static const uint8_t set_iso_socket_param[] = {
+ 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, 0x85, 0x98, /* UUID - ISO Socket */
+ 0x6a, 0x49, 0xe0, 0x05, 0x88, 0xf1, 0xba, 0x6f,
+ 0x01, /* Action - enable */
+};
+
+static void set_iso_socket_callback(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ if (status != MGMT_STATUS_SUCCESS) {
+ tester_print("ISO socket feature could not be enabled");
+ return;
+ }
+
+ tester_print("ISO socket feature is enabled");
+}
+
+static void test_pre_setup(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ data->mgmt = mgmt_new_default();
+ if (!data->mgmt) {
+ tester_warn("Failed to setup management interface");
+ tester_pre_setup_failed();
+ return;
+ }
+
+ if (tester_use_debug())
+ mgmt_set_debug(data->mgmt, mgmt_debug, "mgmt: ", NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_EXP_FEATURE, MGMT_INDEX_NONE,
+ sizeof(set_iso_socket_param), set_iso_socket_param,
+ set_iso_socket_callback, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_READ_INDEX_LIST, MGMT_INDEX_NONE, 0, NULL,
+ read_index_list_callback, NULL, NULL);
+}
+
+static void test_post_teardown(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ hciemu_unref(data->hciemu);
+ data->hciemu = NULL;
+}
+
+static void test_data_free(void *test_data)
+{
+ struct test_data *data = test_data;
+
+ if (data->io_id[0] > 0)
+ g_source_remove(data->io_id[0]);
+
+ if (data->io_id[1] > 0)
+ g_source_remove(data->io_id[1]);
+
+ free(data);
+}
+
+#define test_iso_full(name, data, setup, func, num) \
+ do { \
+ struct test_data *user; \
+ user = new0(struct test_data, 1); \
+ if (!user) \
+ break; \
+ user->hciemu_type = HCIEMU_TYPE_BREDRLE; \
+ user->test_data = data; \
+ user->client_num = num; \
+ tester_add_full(name, data, \
+ test_pre_setup, setup, func, NULL, \
+ test_post_teardown, 2, user, test_data_free); \
+ } while (0)
+
+#define test_iso(name, data, setup, func) \
+ test_iso_full(name, data, setup, func, 1)
+
+#define test_iso2(name, data, setup, func) \
+ test_iso_full(name, data, setup, func, 2)
+
+static const struct iso_client_data connect_8_1_1 = {
+ .qos = QOS_8_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_8_2_1 = {
+ .qos = QOS_8_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_16_1_1 = {
+ .qos = QOS_16_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_16_2_1 = {
+ .qos = QOS_16_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_1_16_2_1 = {
+ .qos = QOS_1_16_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_1_1_16_2_1 = {
+ .qos = QOS_1_1_16_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_24_1_1 = {
+ .qos = QOS_24_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_24_2_1 = {
+ .qos = QOS_24_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_32_1_1 = {
+ .qos = QOS_32_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_32_2_1 = {
+ .qos = QOS_32_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_44_1_1 = {
+ .qos = QOS_44_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_44_2_1 = {
+ .qos = QOS_44_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_1_1 = {
+ .qos = QOS_48_1_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_2_1 = {
+ .qos = QOS_48_2_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_3_1 = {
+ .qos = QOS_48_3_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_4_1 = {
+ .qos = QOS_48_4_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_5_1 = {
+ .qos = QOS_48_5_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_6_1 = {
+ .qos = QOS_48_6_1,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_8_1_2 = {
+ .qos = QOS_8_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_8_2_2 = {
+ .qos = QOS_8_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_16_1_2 = {
+ .qos = QOS_16_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_16_2_2 = {
+ .qos = QOS_16_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_24_1_2 = {
+ .qos = QOS_24_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_24_2_2 = {
+ .qos = QOS_24_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_32_1_2 = {
+ .qos = QOS_32_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_32_2_2 = {
+ .qos = QOS_32_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_44_1_2 = {
+ .qos = QOS_44_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_44_2_2 = {
+ .qos = QOS_44_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_1_2 = {
+ .qos = QOS_48_1_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_2_2 = {
+ .qos = QOS_48_2_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_3_2 = {
+ .qos = QOS_48_3_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_4_2 = {
+ .qos = QOS_48_4_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_5_2 = {
+ .qos = QOS_48_5_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_48_6_2 = {
+ .qos = QOS_48_6_2,
+ .expect_err = 0
+};
+
+static const struct iso_client_data connect_invalid = {
+ .qos = QOS(0, 0, 0, 0, 0),
+ .expect_err = -EINVAL
+};
+
+static const uint8_t data_16_2_1[40] = { [0 ... 39] = 0xff };
+static const struct iovec send_16_2_1 = {
+ .iov_base = (void *)data_16_2_1,
+ .iov_len = sizeof(data_16_2_1),
+};
+
+static const struct iso_client_data connect_16_2_1_send = {
+ .qos = QOS_16_2_1,
+ .expect_err = 0,
+ .send = send_16_2_1,
+};
+
+static const struct iso_client_data listen_16_2_1_recv = {
+ .qos = QOS_16_2_1,
+ .expect_err = 0,
+ .recv = send_16_2_1,
+ .server = true,
+};
+
+static const struct iso_client_data connect_16_2_1_send_recv = {
+ .qos = QOS_16_2_1,
+ .expect_err = 0,
+ .send = send_16_2_1,
+ .recv = send_16_2_1,
+};
+
+static const struct iso_client_data bcast_16_2_1_send = {
+ .qos = QOS_OUT_16_2_1,
+ .expect_err = 0,
+ .send = send_16_2_1,
+ .bcast = true,
+};
+
+static const struct iso_client_data bcast_1_16_2_1_send = {
+ .qos = QOS_OUT_1_16_2_1,
+ .expect_err = 0,
+ .send = send_16_2_1,
+ .bcast = true,
+};
+
+static const struct iso_client_data bcast_1_1_16_2_1_send = {
+ .qos = QOS_OUT_1_1_16_2_1,
+ .expect_err = 0,
+ .send = send_16_2_1,
+ .bcast = true,
+};
+
+static const struct iso_client_data bcast_16_2_1_recv = {
+ .qos = QOS_IN_16_2_1,
+ .expect_err = 0,
+ .recv = send_16_2_1,
+ .bcast = true,
+};
+
+static void client_connectable_complete(uint16_t opcode, uint8_t status,
+ const void *param, uint8_t len,
+ void *user_data)
+{
+ struct test_data *data = user_data;
+ static uint8_t client_num;
+
+ if (opcode != BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE)
+ return;
+
+ tester_print("Client %u set connectable status 0x%02x", client_num,
+ status);
+
+ client_num++;
+
+ if (status)
+ tester_setup_failed();
+ else if (data->client_num == client_num) {
+ tester_setup_complete();
+ client_num = 0;
+ }
+}
+
+static void iso_new_conn(uint16_t handle, void *user_data)
+{
+ struct test_data *data = user_data;
+
+ tester_print("New client connection with handle 0x%04x", handle);
+
+ data->handle = handle;
+}
+
+static void acl_new_conn(uint16_t handle, void *user_data)
+{
+ struct test_data *data = user_data;
+
+ tester_print("New ACL connection with handle 0x%04x", handle);
+
+ data->acl_handle = handle;
+}
+
+static void setup_powered_callback(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct iso_client_data *isodata = data->test_data;
+ uint8_t i;
+
+ if (status != MGMT_STATUS_SUCCESS) {
+ tester_setup_failed();
+ return;
+ }
+
+ tester_print("Controller powered on");
+
+ for (i = 0; i < data->client_num; i++) {
+ struct hciemu_client *client;
+ struct bthost *host;
+
+ client = hciemu_get_client(data->hciemu, i);
+ host = hciemu_client_host(client);
+ bthost_set_cmd_complete_cb(host, client_connectable_complete,
+ data);
+ bthost_set_ext_adv_params(host);
+ bthost_set_ext_adv_enable(host, 0x01);
+
+ if (!isodata)
+ continue;
+
+ if (isodata->send.iov_base || isodata->recv.iov_base)
+ bthost_set_iso_cb(host, iso_new_conn, data);
+
+ if (isodata->bcast) {
+ bthost_set_pa_params(host);
+ bthost_set_pa_enable(host, 0x01);
+ bthost_create_big(host, 1);
+ } else if (!isodata->send.iov_base && isodata->recv.iov_base) {
+ const uint8_t *bdaddr;
+
+ bdaddr = hciemu_get_central_bdaddr(data->hciemu);
+ bthost_set_connect_cb(host, acl_new_conn, data);
+ bthost_hci_connect(host, bdaddr, BDADDR_LE_PUBLIC);
+ }
+ }
+}
+
+static void setup_powered(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct iso_client_data *isodata = data->test_data;
+ unsigned char param[] = { 0x01 };
+
+ tester_print("Powering on controller");
+
+ if (!isodata || !isodata->bcast)
+ mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
+ sizeof(param), param,
+ NULL, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+
+ if (isodata && isodata->server && !isodata->bcast)
+ mgmt_send(data->mgmt, MGMT_OP_SET_ADVERTISING,
+ data->mgmt_index, sizeof(param), param, NULL,
+ NULL, NULL);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
+ sizeof(param), param,
+ setup_powered_callback, NULL, NULL);
+}
+
+static void test_framework(const void *test_data)
+{
+ tester_test_passed();
+}
+
+static void test_socket(const void *test_data)
+{
+ int sk;
+
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sk < 0) {
+ tester_warn("Can't create socket: %s (%d)", strerror(errno),
+ errno);
+ tester_test_abort();
+ return;
+ }
+
+ close(sk);
+
+ tester_test_passed();
+}
+
+static void test_getsockopt(const void *test_data)
+{
+ int sk, err;
+ socklen_t len;
+ struct bt_iso_qos qos;
+
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sk < 0) {
+ tester_warn("Can't create socket: %s (%d)", strerror(errno),
+ errno);
+ tester_test_abort();
+ return;
+ }
+
+ len = sizeof(qos);
+ memset(&qos, 0, len);
+
+ err = getsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len);
+ if (err < 0) {
+ tester_warn("Can't get socket option : %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ goto end;
+ }
+
+ tester_test_passed();
+
+end:
+ close(sk);
+}
+
+static void test_setsockopt(const void *test_data)
+{
+ int sk, err;
+ socklen_t len;
+ struct bt_iso_qos qos = QOS_16_1_2;
+
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sk < 0) {
+ tester_warn("Can't create socket: %s (%d)", strerror(errno),
+ errno);
+ tester_test_abort();
+ goto end;
+ }
+
+ err = setsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, sizeof(qos));
+ if (err < 0) {
+ tester_warn("Can't set socket option : %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ goto end;
+ }
+
+ len = sizeof(qos);
+ memset(&qos, 0, len);
+
+ err = getsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len);
+ if (err < 0) {
+ tester_warn("Can't get socket option : %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ goto end;
+ }
+
+ tester_test_passed();
+
+end:
+ close(sk);
+}
+
+static int create_iso_sock(struct test_data *data)
+{
+ const uint8_t *master_bdaddr;
+ struct sockaddr_iso addr;
+ int sk, err;
+
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET | SOCK_NONBLOCK, BTPROTO_ISO);
+ if (sk < 0) {
+ err = -errno;
+ tester_warn("Can't create socket: %s (%d)", strerror(errno),
+ errno);
+ return -EPROTONOSUPPORT;
+ }
+
+ master_bdaddr = hciemu_get_central_bdaddr(data->hciemu);
+ if (!master_bdaddr) {
+ tester_warn("No master bdaddr");
+ return -ENODEV;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ bacpy(&addr.iso_bdaddr, (void *) master_bdaddr);
+ addr.iso_bdaddr_type = BDADDR_LE_PUBLIC;
+
+ if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ err = -errno;
+ tester_warn("Can't bind socket: %s (%d)", strerror(errno),
+ errno);
+ close(sk);
+ return err;
+ }
+
+ return sk;
+}
+
+static const uint8_t base_lc3_16_2_1[] = {
+ 0x28, 0x00, 0x00, /* Presentation Delay */
+ 0x01, /* Number of Subgroups */
+ 0x01, /* Number of BIS */
+ 0x06, 0x00, 0x00, 0x00, 0x00, /* Code ID = LC3 (0x06) */
+ 0x11, /* Codec Specific Configuration */
+ 0x02, 0x01, 0x03, /* 16 KHZ */
+ 0x02, 0x02, 0x01, /* 10 ms */
+ 0x05, 0x03, 0x01, 0x00, 0x00, 0x00, /* Front Left */
+ 0x03, 0x04, 0x28, 0x00, /* Frame Length 40 bytes */
+ 0x04, /* Metadata */
+ 0x03, 0x02, 0x02, 0x00, /* Audio Context: Convertional */
+ 0x01, /* BIS */
+ 0x00, /* Codec Specific Configuration */
+};
+
+static int connect_iso_sock(struct test_data *data, uint8_t num, int sk)
+{
+ const struct iso_client_data *isodata = data->test_data;
+ struct hciemu_client *client;
+ const uint8_t *client_bdaddr = NULL;
+ struct sockaddr_iso addr;
+ char str[18];
+ int err;
+
+ client = hciemu_get_client(data->hciemu, num);
+ if (!client) {
+ tester_warn("No client");
+ return -ENODEV;
+ }
+
+ if (!isodata->bcast) {
+ client_bdaddr = hciemu_client_bdaddr(client);
+ if (!client_bdaddr) {
+ tester_warn("No client bdaddr");
+ return -ENODEV;
+ }
+ } else {
+ err = setsockopt(sk, SOL_BLUETOOTH, BT_ISO_BASE,
+ base_lc3_16_2_1, sizeof(base_lc3_16_2_1));
+ if (err < 0) {
+ tester_warn("Can't set socket BT_ISO_BASE option: "
+ "%s (%d)", strerror(errno), errno);
+ tester_test_failed();
+ return -EINVAL;
+ }
+ }
+
+ err = setsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &isodata->qos,
+ sizeof(isodata->qos));
+ if (err < 0) {
+ tester_warn("Can't set socket BT_ISO_QOS option : %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ return -EINVAL;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ bacpy(&addr.iso_bdaddr, client_bdaddr ? (void *) client_bdaddr :
+ BDADDR_ANY);
+ addr.iso_bdaddr_type = BDADDR_LE_PUBLIC;
+
+ ba2str(&addr.iso_bdaddr, str);
+
+ tester_print("Connecting to %s...", str);
+
+ err = connect(sk, (struct sockaddr *) &addr, sizeof(addr));
+ if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS)) {
+ err = -errno;
+ tester_warn("Can't connect socket: %s (%d)", strerror(errno),
+ errno);
+ return err;
+ }
+
+ return 0;
+}
+
+static bool check_io_qos(const struct bt_iso_io_qos *io1,
+ const struct bt_iso_io_qos *io2)
+{
+ if (io1->interval && io2->interval && io1->interval != io2->interval) {
+ tester_warn("Unexpected IO interval: %u != %u",
+ io1->interval, io2->interval);
+ return false;
+ }
+
+ if (io1->latency && io2->latency && io1->latency != io2->latency) {
+ tester_warn("Unexpected IO latency: %u != %u",
+ io1->latency, io2->latency);
+ return false;
+ }
+
+ if (io1->sdu != io2->sdu) {
+ tester_warn("Unexpected IO SDU: %u != %u", io1->sdu, io2->sdu);
+ return false;
+ }
+
+ if (io1->phy && io2->phy && io1->phy != io2->phy) {
+ tester_warn("Unexpected IO PHY: 0x%02x != 0x%02x",
+ io1->phy, io2->phy);
+ return false;
+ }
+
+ if (io1->rtn && io2->rtn && io1->rtn != io2->rtn) {
+ tester_warn("Unexpected IO RTN: %u != %u", io1->rtn, io2->rtn);
+ return false;
+ }
+
+ return true;
+}
+
+static bool check_qos(const struct bt_iso_qos *qos1,
+ const struct bt_iso_qos *qos2)
+{
+ if (qos1->packing != qos2->packing) {
+ tester_warn("Unexpected QoS packing: 0x%02x != 0x%02x",
+ qos1->packing, qos2->packing);
+ return false;
+ }
+
+ if (qos1->framing != qos2->framing) {
+ tester_warn("Unexpected QoS framing: 0x%02x != 0x%02x",
+ qos1->framing, qos2->framing);
+ return false;
+ }
+
+ if (!check_io_qos(&qos1->in, &qos2->in)) {
+ tester_warn("Unexpected Input QoS");
+ return false;
+ }
+
+ if (!check_io_qos(&qos1->out, &qos2->out)) {
+ tester_warn("Unexpected Output QoS");
+ return false;
+ }
+
+ return true;
+}
+
+static gboolean iso_recv_data(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct test_data *data = user_data;
+ const struct iso_client_data *isodata = data->test_data;
+ int sk = g_io_channel_unix_get_fd(io);
+ ssize_t ret;
+ char buf[1024];
+
+ ret = read(sk, buf, isodata->recv.iov_len);
+ if (ret < 0 || isodata->recv.iov_len != (size_t) ret) {
+ tester_warn("Failed to read %zu bytes: %s (%d)",
+ isodata->recv.iov_len, strerror(errno), errno);
+ tester_test_failed();
+ return FALSE;
+ }
+
+ if (memcmp(buf, isodata->recv.iov_base, ret))
+ tester_test_failed();
+ else
+ tester_test_passed();
+
+ return FALSE;
+}
+
+static void iso_recv(struct test_data *data, GIOChannel *io)
+{
+ const struct iso_client_data *isodata = data->test_data;
+ struct bthost *host;
+
+ tester_print("Receive %zu bytes of data", isodata->recv.iov_len);
+
+ if (!data->handle) {
+ tester_warn("ISO handle not set");
+ tester_test_failed();
+ return;
+ }
+
+ host = hciemu_client_get_host(data->hciemu);
+ bthost_send_iso(host, data->handle, &isodata->recv, 1);
+ g_io_add_watch(io, G_IO_IN, iso_recv_data, data);
+ g_io_channel_unref(io);
+}
+
+static void bthost_recv_data(const void *buf, uint16_t len, void *user_data)
+{
+ struct test_data *data = user_data;
+ const struct iso_client_data *isodata = data->test_data;
+
+ tester_print("Client received %u bytes of data", len);
+
+ if (isodata->send.iov_len != len ||
+ memcmp(isodata->send.iov_base, buf, len)) {
+ if (!isodata->recv.iov_base)
+ tester_test_failed();
+ } else
+ tester_test_passed();
+}
+
+static void iso_send(struct test_data *data, GIOChannel *io)
+{
+ const struct iso_client_data *isodata = data->test_data;
+ struct bthost *host;
+ ssize_t ret;
+ int sk;
+
+ sk = g_io_channel_unix_get_fd(io);
+
+ tester_print("Writing %zu bytes of data", isodata->send.iov_len);
+
+ host = hciemu_client_get_host(data->hciemu);
+ bthost_add_iso_hook(host, data->handle, bthost_recv_data, data);
+
+ ret = write(sk, isodata->send.iov_base, isodata->send.iov_len);
+ if (ret < 0 || isodata->send.iov_len != (size_t) ret) {
+ tester_warn("Failed to write %zu bytes: %s (%d)",
+ isodata->send.iov_len, strerror(errno), errno);
+ tester_test_failed();
+ return;
+ }
+
+ if (isodata->bcast) {
+ tester_test_passed();
+ return;
+ }
+
+ if (isodata->recv.iov_base)
+ iso_recv(data, io);
+}
+
+static gboolean iso_connect(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct test_data *data = tester_get_data();
+ const struct iso_client_data *isodata = data->test_data;
+ int err, sk_err, sk;
+ socklen_t len;
+ struct bt_iso_qos qos;
+
+ sk = g_io_channel_unix_get_fd(io);
+
+ len = sizeof(qos);
+ memset(&qos, 0, len);
+
+ err = getsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len);
+ if (err < 0) {
+ tester_warn("Can't get socket option : %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ return FALSE;
+ }
+
+ if (!check_qos(&qos, &isodata->qos)) {
+ tester_warn("Unexpected QoS parameter");
+ tester_test_failed();
+ return FALSE;
+ }
+
+ len = sizeof(sk_err);
+
+ if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)
+ err = -errno;
+ else
+ err = -sk_err;
+
+ if (err < 0)
+ tester_warn("Connect failed: %s (%d)", strerror(-err), -err);
+ else
+ tester_print("Successfully connected");
+
+ if (-err != isodata->expect_err)
+ tester_test_failed();
+ else {
+ data->step--;
+ if (data->step)
+ tester_print("Step %u", data->step);
+ else if (isodata->send.iov_base)
+ iso_send(data, io);
+ else if (isodata->recv.iov_base)
+ iso_recv(data, io);
+ else
+ tester_test_passed();
+ }
+
+ return FALSE;
+}
+
+static gboolean iso_connect_cb(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ data->io_id[0] = 0;
+
+ return iso_connect(io, cond, user_data);
+}
+
+static gboolean iso_connect2_cb(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct test_data *data = tester_get_data();
+
+ data->io_id[1] = 0;
+
+ return iso_connect(io, cond, user_data);
+}
+
+static void setup_connect(struct test_data *data, uint8_t num, GIOFunc func)
+{
+ GIOChannel *io;
+ int sk, err;
+
+ sk = create_iso_sock(data);
+ if (sk < 0) {
+ if (sk == -EPROTONOSUPPORT)
+ tester_test_abort();
+ else
+ tester_test_failed();
+ return;
+ }
+
+ err = connect_iso_sock(data, num, sk);
+ if (err < 0) {
+ const struct iso_client_data *isodata = data->test_data;
+
+ close(sk);
+
+ if (isodata->expect_err == err)
+ tester_test_passed();
+ else
+ tester_test_failed();
+
+ return;
+ }
+
+ io = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ data->io_id[num] = g_io_add_watch(io, G_IO_OUT, func, NULL);
+
+ g_io_channel_unref(io);
+
+ tester_print("Connect in progress");
+
+ data->step++;
+}
+
+static void test_connect(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ setup_connect(data, 0, iso_connect_cb);
+}
+
+static int listen_iso_sock(struct test_data *data)
+{
+ const struct iso_client_data *isodata = data->test_data;
+ const uint8_t *src, *dst;
+ struct sockaddr_iso *addr;
+ int sk, err;
+
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET | SOCK_NONBLOCK, BTPROTO_ISO);
+ if (sk < 0) {
+ err = -errno;
+ tester_warn("Can't create socket: %s (%d)", strerror(errno),
+ errno);
+ return -EPROTONOSUPPORT;
+ }
+
+ src = hciemu_get_central_bdaddr(data->hciemu);
+ if (!src) {
+ tester_warn("No source bdaddr");
+ return -ENODEV;
+ }
+
+ /* Bind to local address */
+ addr = malloc(sizeof(*addr) + sizeof(*addr->iso_bc));
+ memset(addr, 0, sizeof(*addr) + sizeof(*addr->iso_bc));
+ addr->iso_family = AF_BLUETOOTH;
+ bacpy(&addr->iso_bdaddr, (void *) src);
+ addr->iso_bdaddr_type = BDADDR_LE_PUBLIC;
+
+ if (isodata->bcast) {
+ /* Bind to destination address in case of broadcast */
+ dst = hciemu_get_client_bdaddr(data->hciemu);
+ if (!dst) {
+ tester_warn("No source bdaddr");
+ return -ENODEV;
+ }
+ bacpy(&addr->iso_bc->bc_bdaddr, (void *) dst);
+ addr->iso_bc->bc_bdaddr_type = BDADDR_LE_PUBLIC;
+ addr->iso_bc->bc_num_bis = 1;
+ addr->iso_bc->bc_bis[0] = 1;
+
+ err = bind(sk, (struct sockaddr *) addr, sizeof(*addr) +
+ sizeof(*addr->iso_bc));
+ } else
+ err = bind(sk, (struct sockaddr *) addr, sizeof(*addr));
+
+ if (err < 0) {
+ err = -errno;
+ tester_warn("Can't bind socket: %s (%d)", strerror(errno),
+ errno);
+ goto fail;
+ }
+
+ if (listen(sk, 10)) {
+ err = -errno;
+ tester_warn("Can't listen socket: %s (%d)", strerror(errno),
+ errno);
+ goto fail;
+ }
+
+ return sk;
+
+fail:
+ close(sk);
+ return err;
+}
+
+static void setup_listen(struct test_data *data, uint8_t num, GIOFunc func)
+{
+ const struct iso_client_data *isodata = data->test_data;
+ GIOChannel *io;
+ int sk;
+
+ sk = listen_iso_sock(data);
+ if (sk < 0) {
+ if (sk == -EPROTONOSUPPORT)
+ tester_test_abort();
+ else
+ tester_test_failed();
+ return;
+ }
+
+ io = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ data->io_id[num] = g_io_add_watch(io, G_IO_IN, func, NULL);
+
+ g_io_channel_unref(io);
+
+ tester_print("Listen in progress");
+
+ data->step++;
+
+ if (!isodata->bcast) {
+ struct hciemu_client *client;
+ struct bthost *host;
+
+ if (!data->acl_handle) {
+ tester_print("ACL handle not set");
+ tester_test_failed();
+ return;
+ }
+
+ client = hciemu_get_client(data->hciemu, 0);
+ host = hciemu_client_host(client);
+
+ bthost_set_cig_params(host, 0x01, 0x01);
+ bthost_create_cis(host, 257, data->acl_handle);
+ }
+}
+
+static gboolean iso_accept_cb(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct test_data *data = tester_get_data();
+ int sk, new_sk;
+
+ data->io_id[0] = 0;
+
+ sk = g_io_channel_unix_get_fd(io);
+
+ new_sk = accept(sk, NULL, NULL);
+ if (new_sk < 0) {
+ tester_test_failed();
+ return false;
+ }
+
+ io = g_io_channel_unix_new(new_sk);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ return iso_connect(io, cond, user_data);
+}
+
+static void test_listen(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ setup_listen(data, 0, iso_accept_cb);
+}
+
+static void test_connect2(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ setup_connect(data, 0, iso_connect_cb);
+ setup_connect(data, 1, iso_connect2_cb);
+}
+
+static void test_bcast(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ setup_connect(data, 0, iso_connect_cb);
+}
+
+static void test_bcast_recv(const void *test_data)
+{
+ struct test_data *data = tester_get_data();
+
+ setup_listen(data, 0, iso_accept_cb);
+}
+
+int main(int argc, char *argv[])
+{
+ tester_init(&argc, &argv);
+
+ test_iso("Basic Framework - Success", NULL, setup_powered,
+ test_framework);
+
+ test_iso("Basic ISO Socket - Success", NULL, setup_powered,
+ test_socket);
+
+ test_iso("Basic ISO Get Socket Option - Success", NULL, setup_powered,
+ test_getsockopt);
+
+ test_iso("Basic ISO Set Socket Option - Success", NULL, setup_powered,
+ test_setsockopt);
+
+ test_iso("ISO QoS 8_1_1 - Success", &connect_8_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 8_2_1 - Success", &connect_8_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_1_1 - Success", &connect_16_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_2_1 - Success", &connect_16_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_2_1 CIG 0x01 - Success", &connect_1_16_2_1,
+ setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_2_1 CIG 0x01 CIS 0x01 - Success",
+ &connect_1_1_16_2_1,
+ setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 24_1_1 - Success", &connect_24_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 24_2_1 - Success", &connect_24_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 32_1_1 - Success", &connect_32_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 32_2_1 - Success", &connect_32_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 44_1_1 - Success", &connect_44_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 44_2_1 - Success", &connect_44_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_1_1 - Success", &connect_48_1_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_2_1 - Success", &connect_48_2_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_3_1 - Success", &connect_48_3_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_4_1 - Success", &connect_48_4_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_5_1 - Success", &connect_48_5_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_6_1 - Success", &connect_48_6_1, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 8_1_2 - Success", &connect_8_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 8_2_2 - Success", &connect_8_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_1_2 - Success", &connect_16_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 16_2_2 - Success", &connect_16_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 24_1_2 - Success", &connect_24_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 24_2_2 - Success", &connect_24_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 32_1_2 - Success", &connect_32_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 32_2_2 - Success", &connect_32_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 44_1_2 - Success", &connect_44_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 44_2_2 - Success", &connect_44_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_1_2 - Success", &connect_48_1_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_2_2 - Success", &connect_48_2_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_3_2 - Success", &connect_48_3_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_4_2 - Success", &connect_48_4_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_5_2 - Success", &connect_48_5_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS 48_6_2 - Success", &connect_48_6_2, setup_powered,
+ test_connect);
+
+ test_iso("ISO QoS - Invalid", &connect_invalid, setup_powered,
+ test_connect);
+
+ test_iso2("ISO Connect2 CIG 0x01 - Success", &connect_1_16_2_1,
+ setup_powered,
+ test_connect2);
+
+ test_iso("ISO Send - Success", &connect_16_2_1_send, setup_powered,
+ test_connect);
+
+ test_iso("ISO Receive - Success", &listen_16_2_1_recv, setup_powered,
+ test_listen);
+
+ test_iso("ISO Send and Receive - Success", &connect_16_2_1_send_recv,
+ setup_powered,
+ test_connect);
+
+ test_iso("ISO Broadcaster - Success", &bcast_16_2_1_send, setup_powered,
+ test_bcast);
+ test_iso("ISO Broadcaster BIG 0x01 - Success", &bcast_1_16_2_1_send,
+ setup_powered,
+ test_bcast);
+ test_iso("ISO Broadcaster BIG 0x01 BIS 0x01 - Success",
+ &bcast_1_1_16_2_1_send,
+ setup_powered,
+ test_bcast);
+
+ test_iso("ISO Broadcaster Receiver - Success", &bcast_16_2_1_recv,
+ setup_powered,
+ test_bcast_recv);
+
+ return tester_run();
+}
diff --git a/tools/test-runner.c b/tools/test-runner.c
index 1f1a8c36f..f0b5fc396 100644
--- a/tools/test-runner.c
+++ b/tools/test-runner.c
@@ -190,7 +190,6 @@ static char *const qemu_argv[] = {
"-machine", "type=q35,accel=kvm:tcg",
"-m", "192M",
"-nographic",
- "-vga", "none",
"-net", "none",
"-no-acpi",
"-no-hpet",
@@ -247,7 +246,7 @@ static void start_qemu(void)
snprintf(cmdline, sizeof(cmdline),
"console=ttyS0,115200n8 earlyprintk=serial "
"rootfstype=9p "
- "rootflags=trans=virtio,version=9p2000.L "
+ "rootflags=trans=virtio,version=9p2000.u "
"acpi=off pci=noacpi noapic quiet ro init=%s "
"bluetooth.enable_ecred=1"
"TESTHOME=%s TESTDBUS=%u TESTDAEMON=%u "
@@ -535,6 +534,7 @@ static const char *test_table[] = {
"l2cap-tester",
"rfcomm-tester",
"sco-tester",
+ "iso-tester",
"bnep-tester",
"check-selftest",
"tools/mgmt-tester",
@@ -542,6 +542,7 @@ static const char *test_table[] = {
"tools/l2cap-tester",
"tools/rfcomm-tester",
"tools/sco-tester",
+ "tools/iso-tester",
"tools/bnep-tester",
"tools/check-selftest",
NULL
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 7/8] tools: Add isotest tool
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
` (4 preceding siblings ...)
2022-05-16 22:13 ` [PATCH v4 6/8] tools: Add iso-tester Luiz Augusto von Dentz
@ 2022-05-16 22:13 ` Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 8/8] isotest: Add documentation Luiz Augusto von Dentz
2022-05-17 2:33 ` [v4,1/8] lib: Add definitions for ISO socket bluez.test.bot
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:13 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds isotest tool which can be used to test ISO sockets.
---
Makefile.tools | 4 +-
tools/isotest.c | 1203 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 1206 insertions(+), 1 deletion(-)
create mode 100644 tools/isotest.c
diff --git a/Makefile.tools b/Makefile.tools
index 89533ece2..3e949c00c 100644
--- a/Makefile.tools
+++ b/Makefile.tools
@@ -202,7 +202,7 @@ endif
if TOOLS
bin_PROGRAMS += tools/rctest tools/l2test tools/l2ping tools/bluemoon \
- tools/hex2hcd tools/mpris-proxy tools/btattach
+ tools/hex2hcd tools/mpris-proxy tools/btattach tools/isotest
noinst_PROGRAMS += tools/bdaddr tools/avinfo tools/avtest \
tools/scotest tools/amptest tools/hwdb \
@@ -314,6 +314,8 @@ tools_gatt_service_SOURCES = tools/gatt-service.c
tools_gatt_service_LDADD = gdbus/libgdbus-internal.la \
src/libshared-mainloop.la $(GLIB_LIBS) $(DBUS_LIBS)
+tools_isotest_LDADD = lib/libbluetooth-internal.la
+
profiles_iap_iapd_SOURCES = profiles/iap/main.c
profiles_iap_iapd_LDADD = gdbus/libgdbus-internal.la $(GLIB_LIBS) $(DBUS_LIBS)
diff --git a/tools/isotest.c b/tools/isotest.c
new file mode 100644
index 000000000..a5f3bad7c
--- /dev/null
+++ b/tools/isotest.c
@@ -0,0 +1,1203 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2022 Intel Corporation.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <syslog.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+#include <linux/sockios.h>
+#include <time.h>
+
+#include "lib/bluetooth.h"
+#include "lib/hci.h"
+#include "lib/hci_lib.h"
+#include "lib/mgmt.h"
+#include "lib/iso.h"
+
+#include "src/shared/util.h"
+
+#define NSEC_USEC(_t) (_t / 1000L)
+#define SEC_USEC(_t) (_t * 1000000L)
+#define TS_USEC(_ts) (SEC_USEC((_ts)->tv_sec) + NSEC_USEC((_ts)->tv_nsec))
+
+/* Test modes */
+enum {
+ SEND,
+ RECV,
+ RECONNECT,
+ MULTY,
+ DUMP,
+ CONNECT
+};
+
+static unsigned char *buf;
+
+/* Default data size */
+static long data_size = 251;
+
+static int mgmt_index = MGMT_INDEX_NONE;
+static bdaddr_t bdaddr;
+static int bdaddr_type = BDADDR_LE_PUBLIC;
+
+static int defer_setup;
+static int sndbuf;
+static struct timeval sndto;
+static bool quiet;
+
+struct bt_iso_qos *iso_qos;
+static bool inout;
+
+struct lookup_table {
+ const char *name;
+ int flag;
+};
+
+static struct lookup_table bdaddr_types[] = {
+ { "le_public", BDADDR_LE_PUBLIC },
+ { "le_random", BDADDR_LE_RANDOM },
+ { NULL, 0 },
+};
+
+static int get_lookup_flag(struct lookup_table *table, char *name)
+{
+ int i;
+
+ for (i = 0; table[i].name; i++)
+ if (!strcasecmp(table[i].name, name))
+ return table[i].flag;
+
+ return -1;
+}
+
+static void print_lookup_values(struct lookup_table *table, char *header)
+{
+ int i;
+
+ printf("%s\n", header);
+
+ for (i = 0; table[i].name; i++)
+ printf("\t%s\n", table[i].name);
+}
+
+static float tv2fl(struct timeval tv)
+{
+ return (float)tv.tv_sec + (float)(tv.tv_usec/1000000.0);
+}
+
+static const uint8_t set_iso_socket_param[] = {
+ 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, 0x85, 0x98, /* UUID - ISO Socket */
+ 0x6a, 0x49, 0xe0, 0x05, 0x88, 0xf1, 0xba, 0x6f,
+ 0x01, /* Action - enable */
+};
+
+static int mgmt_recv(int fd)
+{
+ uint8_t buf[1024];
+
+ return read(fd, buf, sizeof(buf));
+}
+
+static int mgmt_send_cmd(int fd, uint16_t op, uint16_t id, const void *data,
+ size_t len)
+{
+ struct mgmt_hdr hdr;
+ struct iovec iov[2];
+ int ret;
+
+ memset(&hdr, 0, sizeof(hdr));
+ hdr.opcode = htobs(op);
+ hdr.index = htobs(id);
+ hdr.len = htobs(len);
+
+ iov[0].iov_base = &hdr;
+ iov[0].iov_len = sizeof(hdr);
+
+ iov[1].iov_base = (void *)data;
+ iov[1].iov_len = len;
+
+ ret = writev(fd, iov, 2);
+ if (ret < 0)
+ return ret;
+
+ /* Wait for MGMT to respond */
+ ret = mgmt_recv(fd);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
+static int mgmt_open(void)
+{
+ union {
+ struct sockaddr common;
+ struct sockaddr_hci hci;
+ } addr;
+ int fd, err;
+
+ fd = socket(PF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK,
+ BTPROTO_HCI);
+ if (fd < 0) {
+ syslog(LOG_ERR, "Can't create mgmt socket: %s (%d)",
+ strerror(errno), errno);
+ return -errno;
+ }
+
+ syslog(LOG_ERR, "mgmt socket: fd %d", fd);
+
+ memset(&addr, 0, sizeof(addr));
+ addr.hci.hci_family = AF_BLUETOOTH;
+ addr.hci.hci_dev = HCI_DEV_NONE;
+ addr.hci.hci_channel = HCI_CHANNEL_CONTROL;
+
+ if (bind(fd, &addr.common, sizeof(addr.hci)) < 0) {
+ syslog(LOG_ERR, "Can't bind mgmt socket: %s (%d)",
+ strerror(errno), errno);
+ err = -errno;
+ close(fd);
+ return err;
+ }
+
+ return fd;
+}
+
+
+static const uint8_t set_le_param[] = {
+ 0x01, /* Action - enable */
+};
+
+static int mgmt_set_le(int fd)
+{
+ int err, index;
+
+ index = mgmt_index;
+ if (index == MGMT_INDEX_NONE)
+ index = 0;
+
+ err = mgmt_send_cmd(fd, MGMT_OP_SET_LE, index,
+ set_le_param, sizeof(set_le_param));
+ if (err < 0) {
+ syslog(LOG_ERR, "Fail to write mgmt socket: %s (%d)",
+ strerror(errno), errno);
+ err = -errno;
+ }
+
+ syslog(LOG_ERR, "%s: err %d", __func__, err);
+
+ return err < 0 ? err : 0;
+}
+
+static int mgmt_set_experimental(void)
+{
+ int fd, err;
+
+ fd = mgmt_open();
+ if (fd < 0)
+ return fd;
+
+ err = mgmt_set_le(fd);
+ if (err < 0)
+ goto fail;
+
+ err = mgmt_send_cmd(fd, MGMT_OP_SET_EXP_FEATURE, MGMT_INDEX_NONE,
+ set_iso_socket_param, sizeof(set_iso_socket_param));
+ if (err < 0) {
+ syslog(LOG_ERR, "Fail to write mgmt socket: %s (%d)",
+ strerror(errno), errno);
+ err = -errno;
+ }
+
+ syslog(LOG_ERR, "%s: err %d", __func__, err);
+
+fail:
+ close(fd);
+
+ return err < 0 ? err : 0;
+}
+
+static void print_qos(int sk, struct sockaddr_iso *addr)
+{
+ struct bt_iso_qos qos;
+ socklen_t len;
+
+ /* Read Out QOS */
+ memset(&qos, 0, sizeof(qos));
+ len = sizeof(qos);
+
+ if (getsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len) < 0) {
+ syslog(LOG_ERR, "Can't get QoS socket option: %s (%d)",
+ strerror(errno), errno);
+ return;
+ }
+
+ if (!bacmp(&addr->iso_bdaddr, BDADDR_ANY)) {
+ syslog(LOG_INFO, "QoS BIG 0x%02x BIS 0x%02x Packing 0x%02x "
+ "Framing 0x%02x]", qos.big, qos.bis, qos.packing,
+ qos.framing);
+ } else {
+ syslog(LOG_INFO, "QoS CIG 0x%02x CIS 0x%02x Packing 0x%02x "
+ "Framing 0x%02x]", qos.cig, qos.cis, qos.packing,
+ qos.framing);
+ syslog(LOG_INFO, "Input QoS [Interval %u us Latency %u "
+ "ms SDU %u PHY 0x%02x RTN %u]", qos.in.interval,
+ qos.in.latency, qos.in.sdu, qos.in.phy, qos.in.rtn);
+ }
+ syslog(LOG_INFO, "Output QoS [Interval %u us Latency %u "
+ "ms SDU %u PHY 0x%02x RTN %u]", qos.out.interval,
+ qos.out.latency, qos.out.sdu, qos.out.phy, qos.out.rtn);
+}
+
+static int do_connect(char *peer)
+{
+ struct sockaddr_iso addr;
+ int sk;
+
+ mgmt_set_experimental();
+
+ /* Create socket */
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sk < 0) {
+ syslog(LOG_ERR, "Can't create socket: %s (%d)",
+ strerror(errno), errno);
+ return -1;
+ }
+
+ /* Bind to local address */
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ bacpy(&addr.iso_bdaddr, mgmt_index != MGMT_INDEX_NONE ?
+ &bdaddr : BDADDR_ANY);
+ addr.iso_bdaddr_type = BDADDR_LE_PUBLIC;
+
+ if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ syslog(LOG_ERR, "Can't bind socket: %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ /* Set QoS if available */
+ if (iso_qos) {
+ if (!inout || !strcmp(peer, "00:00:00:00:00:00")) {
+ iso_qos->in.phy = 0x00;
+ iso_qos->in.sdu = 0;
+ }
+
+ if (setsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, iso_qos,
+ sizeof(*iso_qos)) < 0) {
+ syslog(LOG_ERR, "Can't set QoS socket option: "
+ "%s (%d)", strerror(errno), errno);
+ goto error;
+ }
+ }
+
+ /* Enable deferred setup */
+ if (defer_setup && setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP,
+ &defer_setup, sizeof(defer_setup)) < 0) {
+ syslog(LOG_ERR, "Can't enable deferred setup : %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ /* Connect to remote device */
+ memset(&addr, 0, sizeof(addr));
+ addr.iso_family = AF_BLUETOOTH;
+ str2ba(peer, &addr.iso_bdaddr);
+ addr.iso_bdaddr_type = bdaddr_type;
+
+ syslog(LOG_INFO, "Connecting %s ...", peer);
+
+ if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ syslog(LOG_ERR, "Can't connect: %s (%d)", strerror(errno),
+ errno);
+ goto error;
+ }
+
+ syslog(LOG_INFO, "Connected [%s]", peer);
+
+ print_qos(sk, &addr);
+
+ return sk;
+
+error:
+ close(sk);
+ return -1;
+}
+
+static void do_listen(char *filename, void (*handler)(int fd, int sk),
+ char *peer)
+{
+ struct sockaddr_iso *addr = NULL;
+ socklen_t optlen;
+ int sk, nsk, fd = -1;
+ char ba[18];
+
+ if (filename) {
+ fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644);
+ if (fd < 0) {
+ syslog(LOG_ERR, "Can't open file %s: %s\n",
+ filename, strerror(errno));
+ exit(1);
+ }
+ }
+
+ mgmt_set_experimental();
+
+ /* Create socket */
+ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_ISO);
+ if (sk < 0) {
+ syslog(LOG_ERR, "Can't create socket: %s (%d)",
+ strerror(errno), errno);
+ if (fd >= 0)
+ close(fd);
+ exit(1);
+ }
+
+ /* Bind to local address */
+ addr = malloc(sizeof(*addr) + sizeof(*addr->iso_bc));
+ memset(addr, 0, sizeof(*addr) + sizeof(*addr->iso_bc));
+ addr->iso_family = AF_BLUETOOTH;
+ bacpy(&addr->iso_bdaddr, mgmt_index != MGMT_INDEX_NONE ?
+ &bdaddr : BDADDR_ANY);
+ addr->iso_bdaddr_type = BDADDR_LE_PUBLIC;
+ optlen = sizeof(*addr);
+
+ if (peer) {
+ str2ba(peer, &addr->iso_bc->bc_bdaddr);
+ addr->iso_bc->bc_bdaddr_type = bdaddr_type;
+ addr->iso_bc->bc_num_bis = 1;
+ addr->iso_bc->bc_bis[0] = 1;
+ optlen += sizeof(*addr->iso_bc);
+ }
+
+ if (bind(sk, (struct sockaddr *) addr, optlen) < 0) {
+ syslog(LOG_ERR, "Can't bind socket: %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ /* Enable deferred setup */
+ if (defer_setup && setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP,
+ &defer_setup, sizeof(defer_setup)) < 0) {
+ syslog(LOG_ERR, "Can't enable deferred setup : %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ /* Listen for connections */
+ if (listen(sk, 10)) {
+ syslog(LOG_ERR, "Can not listen on the socket: %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ syslog(LOG_INFO, "Waiting for connection %s...", peer ? peer : "");
+
+ while (1) {
+ memset(addr, 0, sizeof(*addr) + sizeof(*addr->iso_bc));
+ optlen = sizeof(*addr);
+
+ if (peer)
+ optlen += sizeof(*addr->iso_bc);
+
+ nsk = accept(sk, (struct sockaddr *) addr, &optlen);
+ if (nsk < 0) {
+ syslog(LOG_ERR, "Accept failed: %s (%d)",
+ strerror(errno), errno);
+ goto error;
+ }
+
+ if (fork()) {
+ /* Parent */
+ close(nsk);
+ continue;
+ }
+ /* Child */
+ close(sk);
+
+ ba2str(&addr->iso_bdaddr, ba);
+ syslog(LOG_INFO, "Connected [%s]", ba);
+
+ print_qos(nsk, addr);
+
+ /* Handle deferred setup */
+ if (defer_setup) {
+ syslog(LOG_INFO, "Waiting for %d seconds",
+ abs(defer_setup) - 1);
+ sleep(abs(defer_setup) - 1);
+
+ if (defer_setup < 0) {
+ close(nsk);
+ exit(1);
+ }
+ }
+
+ handler(fd, nsk);
+
+ syslog(LOG_INFO, "Disconnect");
+ exit(0);
+ }
+
+error:
+ free(addr);
+
+ if (fd >= 0)
+ close(fd);
+ close(sk);
+ exit(1);
+}
+
+static void dump_mode(int fd, int sk)
+{
+ int len;
+
+ if (defer_setup) {
+ len = read(sk, buf, data_size);
+ if (len < 0)
+ syslog(LOG_ERR, "Initial read error: %s (%d)",
+ strerror(errno), errno);
+ else
+ syslog(LOG_INFO, "Initial bytes %d", len);
+ }
+
+ syslog(LOG_INFO, "Receiving ...");
+ while ((len = read(sk, buf, data_size)) > 0) {
+ if (fd >= 0) {
+ len = write(fd, buf, len);
+ if (len < 0) {
+ syslog(LOG_ERR, "Write failed: %s (%d)",
+ strerror(errno), errno);
+ return;
+ }
+ } else if (!quiet)
+ syslog(LOG_INFO, "Received %d bytes", len);
+ }
+}
+
+static void recv_mode(int fd, int sk)
+{
+ struct timeval tv_beg, tv_end, tv_diff;
+ long total;
+ int len;
+ uint32_t seq;
+
+ if (defer_setup) {
+ len = read(sk, buf, data_size);
+ if (len < 0)
+ syslog(LOG_ERR, "Initial read error: %s (%d)",
+ strerror(errno), errno);
+ else
+ syslog(LOG_INFO, "Initial bytes %d", len);
+ }
+
+ syslog(LOG_INFO, "Receiving ...");
+
+ for (seq = 0; ; seq++) {
+ gettimeofday(&tv_beg, NULL);
+ total = 0;
+ while (total < data_size) {
+ int r;
+
+ r = recv(sk, buf, data_size, 0);
+ if (r <= 0) {
+ if (r < 0)
+ syslog(LOG_ERR, "Read failed: %s (%d)",
+ strerror(errno), errno);
+ if (errno != ENOTCONN)
+ return;
+ r = 0;
+ }
+
+ if (fd >= 0) {
+ r = write(fd, buf, r);
+ if (r < 0) {
+ syslog(LOG_ERR, "Write failed: %s (%d)",
+ strerror(errno), errno);
+ return;
+ }
+ }
+
+ total += r;
+ }
+ gettimeofday(&tv_end, NULL);
+
+ timersub(&tv_end, &tv_beg, &tv_diff);
+
+ if (!quiet)
+ syslog(LOG_INFO,
+ "[seq %d] %ld bytes in %.2f sec speed %.2f "
+ "kb/s", seq, total, tv2fl(tv_diff),
+ (float)(total * 8 / tv2fl(tv_diff)) / 1024.0);
+ }
+}
+
+static int open_file(const char *filename)
+{
+ int fd = -1;
+
+ syslog(LOG_INFO, "Opening %s ...", filename);
+
+ fd = open(filename, O_RDONLY);
+ if (fd <= 0) {
+ syslog(LOG_ERR, "Can't open file %s: %s\n",
+ filename, strerror(errno));
+ }
+
+ return fd;
+}
+
+static void send_wait(struct timespec *t_start, uint32_t us)
+{
+ struct timespec t_now;
+ struct timespec t_diff;
+ int64_t delta_us;
+
+ /* Skip sleep at start */
+ if (!us)
+ return;
+
+ if (clock_gettime(CLOCK_MONOTONIC, &t_now) < 0) {
+ perror("clock_gettime");
+ exit(EXIT_FAILURE);
+ }
+
+ t_diff.tv_sec = t_now.tv_sec - t_start->tv_sec;
+ t_diff.tv_nsec = t_now.tv_nsec - t_start->tv_nsec;
+
+ delta_us = us - TS_USEC(&t_diff);
+
+ if (delta_us < 0) {
+ syslog(LOG_INFO, "Send is behind: %zd us", delta_us);
+ delta_us = 1000;
+ }
+
+ if (!quiet)
+ syslog(LOG_INFO, "Waiting (%zd us)...", delta_us);
+
+ usleep(delta_us);
+
+ if (clock_gettime(CLOCK_MONOTONIC, t_start) < 0) {
+ perror("clock_gettime");
+ exit(EXIT_FAILURE);
+ }
+}
+
+static int read_stream(int fd, ssize_t count)
+{
+ ssize_t len, ret = 0;
+
+ while (ret < count) {
+ len = read(fd, buf + ret, count - ret);
+ if (len < 0)
+ return -errno;
+
+ ret += len;
+ usleep(1000);
+ }
+
+ return ret;
+}
+
+static int read_file(int fd, ssize_t count, bool rewind)
+{
+ ssize_t len;
+
+ if (fd == STDIN_FILENO)
+ return read_stream(fd, count);
+
+ len = read(fd, buf, count);
+ if (len <= 0) {
+ if (!len) {
+ if (rewind) {
+ lseek(fd, 0, SEEK_SET);
+ return read_file(fd, count, rewind);
+ }
+ return len;
+ }
+
+ return -errno;
+ }
+
+ return len;
+}
+
+static void do_send(int sk, int fd, struct bt_iso_qos *qos, uint32_t num,
+ bool repeat)
+{
+ uint32_t seq;
+ struct timespec t_start;
+ int len, used;
+
+ if (clock_gettime(CLOCK_MONOTONIC, &t_start) < 0) {
+ perror("clock_gettime");
+ exit(EXIT_FAILURE);
+ }
+
+ for (seq = 0; ; seq++) {
+ if (fd >= 0) {
+ len = read_file(fd, qos->out.sdu, repeat);
+ if (len < 0) {
+ syslog(LOG_ERR, "read failed: %s (%d)",
+ strerror(-len), -len);
+ exit(1);
+ }
+ } else
+ len = qos->out.sdu;
+
+ len = send(sk, buf, len, 0);
+ if (len <= 0) {
+ syslog(LOG_ERR, "send failed: %s (%d)",
+ strerror(errno), errno);
+ exit(1);
+ }
+
+ ioctl(sk, TIOCOUTQ, &used);
+
+ if (!quiet)
+ syslog(LOG_INFO,
+ "[seq %d] %d bytes buffered %d (%d bytes)",
+ seq, len, used / len, used);
+
+ if (seq && !((seq + 1) % num))
+ send_wait(&t_start, num * qos->out.interval);
+ }
+}
+
+static void send_mode(char *filename, char *peer, int i, bool repeat)
+{
+ struct bt_iso_qos qos;
+ socklen_t len;
+ int sk, fd = -1;
+ uint32_t num;
+
+ if (filename) {
+ char altername[PATH_MAX];
+ struct stat st;
+ int err;
+
+ snprintf(altername, PATH_MAX, "%s.%u", filename, i);
+
+ err = stat(altername, &st);
+ if (!err)
+ fd = open_file(altername);
+
+ if (fd <= 0)
+ fd = open_file(filename);
+ }
+
+ sk = do_connect(peer);
+ if (sk < 0) {
+ syslog(LOG_ERR, "Can't connect to the server: %s (%d)",
+ strerror(errno), errno);
+ exit(1);
+ }
+
+ if (defer_setup) {
+ syslog(LOG_INFO, "Waiting for %d seconds",
+ abs(defer_setup) - 1);
+ sleep(abs(defer_setup) - 1);
+ }
+
+ syslog(LOG_INFO, "Sending ...");
+
+ /* Read QoS */
+ memset(&qos, 0, sizeof(qos));
+ len = sizeof(qos);
+ if (getsockopt(sk, SOL_BLUETOOTH, BT_ISO_QOS, &qos, &len) < 0) {
+ syslog(LOG_ERR, "Can't get Output QoS socket option: %s (%d)",
+ strerror(errno), errno);
+ qos.out.sdu = ISO_DEFAULT_MTU;
+ }
+
+ /* num of packets = latency (ms) / interval (us) */
+ num = (qos.out.latency * 1000 / qos.out.interval);
+
+ syslog(LOG_INFO, "Number of packets: %d", num);
+
+ if (!sndbuf)
+ /* Use socket buffer as a jitter buffer for the entire buffer
+ * latency:
+ * jitter buffer = 2 * (SDU * subevents)
+ */
+ sndbuf = 2 * ((qos.out.latency * 1000 / qos.out.interval) *
+ qos.out.sdu);
+
+ len = sizeof(sndbuf);
+ if (setsockopt(sk, SOL_SOCKET, SO_SNDBUF, &sndbuf, len) < 0) {
+ syslog(LOG_ERR, "Can't set socket SO_SNDBUF option: %s (%d)",
+ strerror(errno), errno);
+ }
+
+ syslog(LOG_INFO, "Socket jitter buffer: %d buffer", sndbuf);
+
+ if (sndto.tv_usec) {
+ len = sizeof(sndto);
+ if (setsockopt(sk, SOL_SOCKET, SO_SNDTIMEO, &sndto, len) < 0) {
+ syslog(LOG_ERR, "Can't set socket SO_SNDTIMEO option: "
+ "%s (%d)", strerror(errno), errno);
+ } else {
+ syslog(LOG_INFO, "Socket send timeout: %ld usec",
+ sndto.tv_usec);
+ }
+ }
+
+ for (i = 6; i < qos.out.sdu; i++)
+ buf[i] = 0x7f;
+
+ do_send(sk, fd, &qos, num, repeat);
+}
+
+static void reconnect_mode(char *peer)
+{
+ while (1) {
+ int sk;
+
+ sk = do_connect(peer);
+ if (sk < 0) {
+ syslog(LOG_ERR, "Can't connect to the server: %s (%d)",
+ strerror(errno), errno);
+ exit(1);
+ }
+
+ close(sk);
+
+ sleep(5);
+ }
+}
+
+static void multy_connect_mode(char *peer)
+{
+ while (1) {
+ int i, sk;
+
+ for (i = 0; i < 10; i++) {
+ if (fork())
+ continue;
+
+ /* Child */
+ sk = do_connect(peer);
+ if (sk < 0) {
+ syslog(LOG_ERR, "Can't connect to the server: "
+ "%s (%d)", strerror(errno), errno);
+ }
+ close(sk);
+ exit(0);
+ }
+
+ sleep(19);
+ }
+}
+
+#define QOS_IO(_interval, _latency, _sdu, _phy, _rtn) \
+{ \
+ .interval = _interval, \
+ .latency = _latency, \
+ .sdu = _sdu, \
+ .phy = _phy, \
+ .rtn = _rtn, \
+}
+
+#define QOS(_interval, _latency, _sdu, _phy, _rtn) \
+{ \
+ .cig = BT_ISO_QOS_CIG_UNSET, \
+ .cis = BT_ISO_QOS_CIS_UNSET, \
+ .sca = 0x07, \
+ .packing = 0x00, \
+ .framing = 0x00, \
+ .out = QOS_IO(_interval, _latency, _sdu, _phy, _rtn), \
+}
+
+#define QOS_PRESET(_name, _inout, _interval, _latency, _sdu, _phy, _rtn) \
+{ \
+ .name = _name, \
+ .inout = _inout, \
+ .qos = QOS(_interval, _latency, _sdu, _phy, _rtn), \
+}
+
+static struct qos_preset {
+ const char *name;
+ bool inout;
+ struct bt_iso_qos qos;
+} presets[] = {
+ /* QoS Configuration settings for low latency audio data */
+ QOS_PRESET("8_1_1", true, 7500, 8, 26, 0x02, 2),
+ QOS_PRESET("8_2_1", true, 10000, 10, 30, 0x02, 2),
+ QOS_PRESET("16_1_1", true, 7500, 8, 30, 0x02, 2),
+ QOS_PRESET("16_2_1", true, 10000, 10, 40, 0x02, 2),
+ QOS_PRESET("24_1_1", true, 7500, 8, 45, 0x02, 2),
+ QOS_PRESET("24_2_1", true, 10000, 10, 60, 0x02, 2),
+ QOS_PRESET("32_1_1", true, 7500, 8, 60, 0x02, 2),
+ QOS_PRESET("32_2_1", true, 10000, 10, 80, 0x02, 2),
+ QOS_PRESET("44_1_1", false, 8163, 24, 98, 0x02, 5),
+ QOS_PRESET("44_2_1", false, 10884, 31, 130, 0x02, 5),
+ QOS_PRESET("48_1_1", false, 7500, 15, 75, 0x02, 5),
+ QOS_PRESET("48_2_1", false, 10000, 20, 100, 0x02, 5),
+ QOS_PRESET("48_3_1", false, 7500, 15, 90, 0x02, 5),
+ QOS_PRESET("48_4_1", false, 10000, 20, 120, 0x02, 5),
+ QOS_PRESET("48_5_1", false, 7500, 15, 117, 0x02, 5),
+ QOS_PRESET("44_6_1", false, 10000, 20, 155, 0x02, 5),
+ /* QoS Configuration settings for high reliability audio data */
+ QOS_PRESET("8_1_2", true, 7500, 45, 26, 0x02, 41),
+ QOS_PRESET("8_2_2", true, 10000, 60, 30, 0x02, 53),
+ QOS_PRESET("16_1_2", true, 7500, 45, 30, 0x02, 41),
+ QOS_PRESET("16_2_2", true, 10000, 60, 40, 0x02, 47),
+ QOS_PRESET("24_1_2", true, 7500, 45, 45, 0x02, 35),
+ QOS_PRESET("24_2_2", true, 10000, 60, 60, 0x02, 41),
+ QOS_PRESET("32_1_2", true, 7500, 45, 60, 0x02, 29),
+ QOS_PRESET("32_2_1", true, 10000, 60, 80, 0x02, 35),
+ QOS_PRESET("44_1_2", false, 8163, 54, 98, 0x02, 23),
+ QOS_PRESET("44_2_2", false, 10884, 71, 130, 0x02, 23),
+ QOS_PRESET("48_1_2", false, 7500, 45, 75, 0x02, 23),
+ QOS_PRESET("48_2_2", false, 10000, 60, 100, 0x02, 23),
+ QOS_PRESET("48_3_2", false, 7500, 45, 90, 0x02, 23),
+ QOS_PRESET("48_4_2", false, 10000, 60, 120, 0x02, 23),
+ QOS_PRESET("48_5_2", false, 7500, 45, 117, 0x02, 23),
+ QOS_PRESET("44_6_2", false, 10000, 60, 155, 0x02, 23),
+};
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+static void usage(void)
+{
+ printf("isotest - ISO testing\n"
+ "Usage:\n");
+ printf("\tisotest <mode> [options] [bdaddr] [bdaddr1]...\n");
+ printf("Modes:\n"
+ "\t-d, --dump [filename] dump (server)\n"
+ "\t-c, --reconnect reconnect (client)\n"
+ "\t-m, --multiple multiple connects (client)\n"
+ "\t-r, --receive [filename] receive (server)\n"
+ "\t-s, --send [filename,...] connect and send "
+ "(client/broadcaster)\n"
+ "\t-n, --silent connect and be silent (client)\n"
+ "Options:\n"
+ "\t[-b, --bytes <value>]\n"
+ "\t[-i, --device <num>]\n"
+ "\t[-j, --jitter <bytes> socket/jitter buffer]\n"
+ "\t[-h, --help]\n"
+ "\t[-q, --quiet disable packet logging]\n"
+ "\t[-t, --timeout <usec> send timeout]\n"
+ "\t[-C, --continue]\n"
+ "\t[-W, --defer <seconds>] enable deferred setup\n"
+ "\t[-M, --mtu <value>]\n"
+ "\t[-S, --sca/adv-interval <value>]\n"
+ "\t[-P, --packing <value>]\n"
+ "\t[-F, --framing <value>]\n"
+ "\t[-I, --interval <useconds>]\n"
+ "\t[-L, --latency <mseconds>]\n"
+ "\t[-Y, --phy <value>]\n"
+ "\t[-R, --rtn <value>]\n"
+ "\t[-B, --preset <value>]\n"
+ "\t[-G, --CIG/BIG <value>]\n"
+ "\t[-T, --CIS/BIS <value>]\n"
+ "\t[-V, --type <value>] address type (help for list)\n");
+}
+
+static const struct option main_options[] = {
+ { "dump", optional_argument, NULL, 'd'},
+ { "reconnect", no_argument, NULL, 'c'},
+ { "multiple", no_argument, NULL, 'm'},
+ { "receive", optional_argument, NULL, 'r'},
+ { "send", optional_argument, NULL, 's'},
+ { "silent", no_argument, NULL, 'n'},
+ { "bytes", required_argument, NULL, 'b'},
+ { "index", required_argument, NULL, 'i'},
+ { "jitter", required_argument, NULL, 'j'},
+ { "help", no_argument, NULL, 'h'},
+ { "quiet", no_argument, NULL, 'q'},
+ { "timeout", required_argument, NULL, 't'},
+ { "continue", no_argument, NULL, 'C'},
+ { "defer", required_argument, NULL, 'W'},
+ { "mtu", required_argument, NULL, 'M'},
+ { "sca", required_argument, NULL, 'S'},
+ { "packing", required_argument, NULL, 'P'},
+ { "framing", required_argument, NULL, 'F'},
+ { "interval", required_argument, NULL, 'I'},
+ { "latency", required_argument, NULL, 'L'},
+ { "phy", required_argument, NULL, 'Y'},
+ { "rtn", required_argument, NULL, 'R'},
+ { "preset", required_argument, NULL, 'B'},
+ { "CIG/BIG", required_argument, NULL, 'G'},
+ { "CIS/BIS", required_argument, NULL, 'T'},
+ { "type", required_argument, NULL, 'V'},
+ {}
+};
+
+int main(int argc, char *argv[])
+{
+ struct sigaction sa;
+ int sk, mode = RECV;
+ char *filename = NULL;
+ bool repeat = false;
+ unsigned int i;
+
+ iso_qos = malloc(sizeof(*iso_qos));
+ /* Default to 16_2_1 */
+ *iso_qos = presets[3].qos;
+ inout = true;
+
+ while (1) {
+ int opt;
+
+ opt = getopt_long(argc, argv,
+ "d::cmr::s::nb:i:j:hqt:CV:W:M:S:P:F:I:L:Y:R:B:G:T:",
+ main_options, NULL);
+ if (opt < 0)
+ break;
+
+ switch (opt) {
+ case 'r':
+ mode = RECV;
+ if (optarg)
+ filename = strdup(optarg);
+ break;
+
+ case 's':
+ mode = SEND;
+ if (optarg)
+ filename = strdup(optarg);
+ break;
+
+ case 'd':
+ mode = DUMP;
+ if (optarg)
+ filename = strdup(optarg);
+ break;
+
+ case 'c':
+ mode = RECONNECT;
+ break;
+
+ case 'm':
+ mode = MULTY;
+ break;
+
+ case 'n':
+ mode = CONNECT;
+ break;
+
+ case 'b':
+ data_size = atoi(optarg);
+ break;
+
+ case 'i':
+ if (!strncasecmp(optarg, "hci", 3)) {
+ mgmt_index = atoi(optarg + 3);
+ hci_devba(mgmt_index, &bdaddr);
+ } else
+ str2ba(optarg, &bdaddr);
+ break;
+
+ case 'j':
+ sndbuf = atoi(optarg);
+ break;
+
+ case 'q':
+ quiet = true;
+ break;
+
+ case 't':
+ sndto.tv_usec = atoi(optarg);
+ break;
+
+ case 'C':
+ repeat = true;
+ break;
+
+ case 'V':
+ bdaddr_type = get_lookup_flag(bdaddr_types, optarg);
+
+ if (bdaddr_type == -1) {
+ print_lookup_values(bdaddr_types,
+ "List Address types:");
+ exit(1);
+ }
+
+ break;
+
+ case 'W':
+ defer_setup = atoi(optarg);
+ break;
+
+ case 'M':
+ iso_qos->out.sdu = atoi(optarg);
+
+ break;
+
+ case 'S':
+ iso_qos->sca = atoi(optarg);
+
+ break;
+
+
+ case 'P':
+ iso_qos->packing = atoi(optarg);
+
+ break;
+
+ case 'F':
+ iso_qos->framing = atoi(optarg);
+
+ break;
+
+ case 'I':
+ iso_qos->out.interval = atoi(optarg);
+
+ break;
+
+ case 'L':
+ iso_qos->out.latency = atoi(optarg);
+
+ break;
+
+ case 'Y':
+ iso_qos->out.phy = atoi(optarg);
+
+ break;
+
+ case 'R':
+ iso_qos->out.rtn = atoi(optarg);
+
+ break;
+
+ case 'B':
+ for (i = 0; i < ARRAY_SIZE(presets); i++) {
+ if (!strcmp(presets[i].name, optarg)) {
+ *iso_qos = presets[i].qos;
+ inout = presets[i].inout;
+ break;
+ }
+ }
+
+ break;
+
+ case 'G':
+ iso_qos->cig = atoi(optarg);
+
+ break;
+
+ case 'T':
+ iso_qos->cis = atoi(optarg);
+
+ break;
+
+ /* fall through */
+ default:
+ usage();
+ exit(1);
+ }
+ }
+
+ if (inout) {
+ iso_qos->in = iso_qos->out;
+ } else {
+ /* Align interval and latency even if is unidirectional */
+ iso_qos->in.interval = iso_qos->out.interval;
+ iso_qos->in.latency = iso_qos->out.latency;
+ }
+
+ buf = malloc(data_size);
+ if (!buf) {
+ perror("Can't allocate data buffer");
+ exit(1);
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = SIG_IGN;
+ sa.sa_flags = SA_NOCLDSTOP;
+ sigaction(SIGCHLD, &sa, NULL);
+
+ openlog("isotest", LOG_PERROR | LOG_PID, LOG_LOCAL0);
+
+ if (!(argc - optind)) {
+ switch (mode) {
+ case RECV:
+ do_listen(filename, recv_mode, NULL);
+ goto done;
+
+ case DUMP:
+ do_listen(filename, dump_mode, NULL);
+ goto done;
+ default:
+ usage();
+ exit(1);
+ }
+ }
+
+ argc -= optind;
+
+ for (i = 0; i < (unsigned int) argc; i++) {
+ pid_t pid;
+
+ pid = fork();
+ if (pid < 0) {
+ perror("Failed to fork new process");
+ return -1;
+ }
+
+ if (!pid)
+ continue;
+
+ switch (mode) {
+ case SEND:
+ send_mode(filename, argv[optind + i], i, repeat);
+ if (strchr(filename, ','))
+ filename = strchr(filename, ',') + 1;
+ break;
+
+ case RECONNECT:
+ reconnect_mode(argv[optind + i]);
+ break;
+
+ case MULTY:
+ multy_connect_mode(argv[optind + i]);
+ break;
+
+ case CONNECT:
+ sk = do_connect(argv[optind + i]);
+ if (sk < 0)
+ exit(1);
+ dump_mode(-1, sk);
+ break;
+
+ case RECV:
+ do_listen(filename, recv_mode, argv[optind + i]);
+ break;
+
+ case DUMP:
+ do_listen(filename, dump_mode, argv[optind + i]);
+ break;
+ }
+
+ break;
+ }
+
+done:
+ syslog(LOG_INFO, "Exit");
+
+ closelog();
+
+ return 0;
+}
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH v4 8/8] isotest: Add documentation
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
` (5 preceding siblings ...)
2022-05-16 22:13 ` [PATCH v4 7/8] tools: Add isotest tool Luiz Augusto von Dentz
@ 2022-05-16 22:13 ` Luiz Augusto von Dentz
2022-05-17 2:33 ` [v4,1/8] lib: Add definitions for ISO socket bluez.test.bot
7 siblings, 0 replies; 9+ messages in thread
From: Luiz Augusto von Dentz @ 2022-05-16 22:13 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This adds isotest.rst which documents the modes and options of
isotest(1) and is then converted isotest.1 manpage.
---
Makefile.tools | 4 +-
tools/isotest.rst | 202 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 204 insertions(+), 2 deletions(-)
create mode 100644 tools/isotest.rst
diff --git a/Makefile.tools b/Makefile.tools
index 3e949c00c..3c5766728 100644
--- a/Makefile.tools
+++ b/Makefile.tools
@@ -320,7 +320,7 @@ profiles_iap_iapd_SOURCES = profiles/iap/main.c
profiles_iap_iapd_LDADD = gdbus/libgdbus-internal.la $(GLIB_LIBS) $(DBUS_LIBS)
if MANPAGES
-man_MANS += tools/rctest.1 tools/l2ping.1 tools/btattach.1
+man_MANS += tools/rctest.1 tools/l2ping.1 tools/btattach.1 tools/isotest.1
endif
if MESH
@@ -438,7 +438,7 @@ manual_pages += tools/hciattach.1 tools/hciconfig.1 \
tools/hcitool.1 tools/hcidump.1 \
tools/rfcomm.1 tools/sdptool.1 tools/ciptool.1 \
tools/rctest.1 tools/l2ping.1 tools/btattach.1 \
- tools/bdaddr.1
+ tools/bdaddr.1 tools/isotest.1
if HID2HCI
udevdir = $(UDEV_DIR)
diff --git a/tools/isotest.rst b/tools/isotest.rst
new file mode 100644
index 000000000..b2f4e4b38
--- /dev/null
+++ b/tools/isotest.rst
@@ -0,0 +1,202 @@
+=======
+isotest
+=======
+
+-----------
+ISO testing
+-----------
+
+:Authors: - Luiz Augusto Von Dentz <luiz.von.dentz@intel.com>
+:Version: BlueZ
+:Copyright: Free use of this software is granted under ther terms of the GNU
+ Lesser General Public Licenses (LGPL).
+:Date: May 4, 2022
+:Manual section: 1
+:Manual group: Linux System Administration
+
+SYNOPSIS
+========
+
+**isotest** <*MODE*> [*OPTIONS*] [*bdaddr*] [*bdaddr1*]...
+
+DESCRIPTION
+===========
+
+**isotest(1)** is used to test Isochronous (CIS/BIS) communications on the
+BlueZ stack
+
+MODES
+=====
+
+-d, --dump=[FILE] Listen and dump incoming data
+ (CIS server/BIS broadcaster) and optionally save the
+ contents to *FILE*.
+
+-c, --reconnect Reconnect (CIS client).
+
+-m, --multiple Multiple connects (CIS client).
+
+-r, --receive=[FILE] Receive (CIS server/BIS broadcast receiver) and
+ optionally save the contents to *FILE*.
+
+-s, --send=[FILE] Connect and send (CIS client/BIS broadcaster), can
+ optionally use contents from *FILE*.
+
+-n, --silent Connect and be silent (CIS client/BIS broadcaster).
+
+OPTIONS
+=======
+
+-b, --bytes=<SIZE> Send or Receive packet size
+
+-i, --index=<NUM> Select the specified HCI device index. *hciNUM* is
+ also acceptable.
+
+-j, --jitter=<JITTER> Socket jitter buffer.
+
+-h, --help
+
+-q, --quiet Disables packet logging.
+
+-t, --timeout=<USEC> Socket send timeout.
+
+-C, --continue Continuously send packets starting over in case of a
+ file.
+
+-W, --defer=<SEC> Enable deferred setup.
+
+-M, --mtu=<SDU> Socket QoS SDU.
+
+-S, --sca/adv-interval=<SCA/INTERVAL>
+ Socket QoS CIS SCA/BIS advertising interval.
+
+-P, --packing=<PACKING> Socket QoS Packing.
+
+.. list-table::
+ :header-rows: 1
+ :widths: auto
+ :stub-columns: 1
+ :align: left
+
+ * - *PACKING*
+ - Description
+
+ * - **0x00**
+ - Sequential
+
+ * - **0x01**
+ - Interleaved
+
+-F, --framing=<FRAMING> Socket QoS Framing.
+
+.. list-table::
+ :header-rows: 1
+ :widths: auto
+ :stub-columns: 1
+ :align: left
+
+ * - *FRAMING*
+ - Description
+
+ * - **0x00**
+ - Unframed
+
+ * - **0x01**
+ - Framed
+
+-I, --interval=<USEC> Socket QoS Interval.
+
+-L, --latency=<MSEC> Socket QoS Latency.
+
+-Y, --phy=<PHY> Socket QoS PHY.
+
+.. list-table::
+ :header-rows: 1
+ :widths: auto
+ :stub-columns: 1
+ :align: left
+
+ * - *PHY*
+ - Description
+
+ * - **0x01**
+ - LE 1M
+
+ * - **0x02**
+ - LE 2M
+
+ * - **0x03**
+ - LE Coded
+
+-R, --rtn=<NUM> Socket QoS retransmissions.
+
+-B, --preset=<PRESET> Socket QoS preset.
+
+-G, --CIG/BIG=<ID> Socket QoS CIG/BIG ID.
+
+-T, --CIS/BIS=<ID> Socket QoS CIS/BIS ID.
+
+-V, --type=<TYPE> Socket destination address type:
+
+.. list-table::
+ :header-rows: 1
+ :widths: auto
+ :stub-columns: 1
+ :align: left
+
+ * - *TYPE*
+ - Description
+
+ * - **le_public**
+ - LE Public Address
+
+ * - **le_random**
+ - LE Random Address
+
+EXAMPLES
+========
+
+Unicast Central
+---------------
+
+.. code-block::
+
+ $ tools/isotest -s XX:XX:XX:XX:XX:XX
+
+Unicast Central connecting to 2 peers using CIG 0x01
+----------------------------------------------------
+
+.. code-block::
+
+ $ tools/isotest -G 0x01 -s XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY
+
+Unicast Peripheral
+------------------
+
+.. code-block::
+
+ $ tools/isotest -d
+
+Broadcaster
+-----------
+
+.. code-block::
+
+ $ tools/isotest -s 00:00:00:00:00:00
+
+Broadcast Receiver using hci1
+-----------------------------
+
+.. code-block::
+
+ $ tools/isotest -i hci1 -d XX:XX:XX:XX:XX:XX
+
+RESOURCES
+=========
+
+http://www.bluez.org
+
+REPORTING BUGS
+==============
+
+linux-bluetooth@vger.kernel.org
--
2.35.1
^ permalink raw reply related [flat|nested] 9+ messages in thread
* RE: [v4,1/8] lib: Add definitions for ISO socket
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
` (6 preceding siblings ...)
2022-05-16 22:13 ` [PATCH v4 8/8] isotest: Add documentation Luiz Augusto von Dentz
@ 2022-05-17 2:33 ` bluez.test.bot
7 siblings, 0 replies; 9+ messages in thread
From: bluez.test.bot @ 2022-05-17 2:33 UTC (permalink / raw)
To: linux-bluetooth, luiz.dentz
[-- Attachment #1: Type: text/plain, Size: 1895 bytes --]
This is automated email and please do not reply to this email!
Dear submitter,
Thank you for submitting the patches to the linux bluetooth mailing list.
This is a CI test results with your patch series:
PW Link:https://patchwork.kernel.org/project/bluetooth/list/?series=642117
---Test result---
Test Summary:
CheckPatch FAIL 14.39 seconds
GitLint PASS 8.14 seconds
Prep - Setup ELL PASS 45.93 seconds
Build - Prep PASS 0.71 seconds
Build - Configure PASS 9.26 seconds
Build - Make PASS 1359.77 seconds
Make Check PASS 12.62 seconds
Make Check w/Valgrind PASS 460.20 seconds
Make Distcheck PASS 248.84 seconds
Build w/ext ELL - Configure PASS 9.29 seconds
Build w/ext ELL - Make PASS 1361.08 seconds
Incremental Build with patchesPASS 11151.92 seconds
Details
##############################
Test: CheckPatch - FAIL
Desc: Run checkpatch.pl script with rule in .checkpatch.conf
Output:
[v4,7/8] tools: Add isotest tool
WARNING:PREFER_FALLTHROUGH: Prefer 'fallthrough;' over fallthrough comment
#1222: FILE: tools/isotest.c:1106:
+ /* fall through */
/github/workspace/src/12851538.patch total: 0 errors, 1 warnings, 1219 lines checked
NOTE: For some of the reported defects, checkpatch may be able to
mechanically convert to the typical style using --fix or --fix-inplace.
/github/workspace/src/12851538.patch has style problems, please review.
NOTE: Ignored message types: COMMIT_MESSAGE COMPLEX_MACRO CONST_STRUCT FILE_PATH_CHANGES MISSING_SIGN_OFF PREFER_PACKED SPDX_LICENSE_TAG SPLIT_STRING SSCANF_TO_KSTRTO
NOTE: If any of the errors are false positives, please report
them to the maintainer, see CHECKPATCH in MAINTAINERS.
---
Regards,
Linux Bluetooth
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2022-05-17 2:33 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-05-16 22:12 [PATCH v4 1/8] lib: Add definitions for ISO socket Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 2/8] shared/util: Decode BlueZ Experimental ISO Socket UUID Luiz Augusto von Dentz
2022-05-16 22:12 ` [PATCH v4 3/8] mgmt-tester: Fix Read Exp Feature tests Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 4/8] adapter: Add support for setting ISO Socket experimental feature Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 5/8] btio: Add support for ISO sockets Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 6/8] tools: Add iso-tester Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 7/8] tools: Add isotest tool Luiz Augusto von Dentz
2022-05-16 22:13 ` [PATCH v4 8/8] isotest: Add documentation Luiz Augusto von Dentz
2022-05-17 2:33 ` [v4,1/8] lib: Add definitions for ISO socket bluez.test.bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).