From: Luiz Augusto von Dentz <luiz.dentz@gmail.com>
To: linux-bluetooth@vger.kernel.org
Subject: [PATCH BlueZ v2 4/5] rfcomm-tester: Add tests for deferred setup
Date: Fri, 20 Nov 2026 10:47:49 -0500 [thread overview]
Message-ID: <20261120154750.1745643-5-luiz.dentz@gmail.com> (raw)
In-Reply-To: <20261120154750.1745643-1-luiz.dentz@gmail.com>
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
Add the following tests:
Basic RFCOMM Socket Server - Defer Success
Basic RFCOMM Socket Server - Defer Early Accept
Defer Early Accept has the listener accepting and authorizing the
connection while authentication, which then fails, is still pending and
expects the connection to be refused.
Assisted-by: OpenCode:claude-fable-5.2
---
tools/rfcomm-tester.c | 146 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 146 insertions(+)
diff --git a/tools/rfcomm-tester.c b/tools/rfcomm-tester.c
index 998d698c1bb2..ae4f3c7ee7ac 100644
--- a/tools/rfcomm-tester.c
+++ b/tools/rfcomm-tester.c
@@ -43,6 +43,7 @@ struct test_data {
struct tester_io *io;
unsigned int io_id;
uint16_t conn_handle;
+ int listen_sk;
uint16_t send_len;
uint16_t recv_len;
};
@@ -61,6 +62,12 @@ struct rfcomm_server_data {
uint8_t server_channel;
uint8_t client_channel;
bool expected_status;
+ bool defer;
+ int sec_level;
+ const uint8_t *pin;
+ uint8_t pin_len;
+ const uint8_t *client_pin;
+ uint8_t client_pin_len;
const uint8_t *send_data;
const uint8_t *read_data;
uint16_t data_len;
@@ -286,13 +293,81 @@ static void setup_powered_server_callback(uint8_t status, uint16_t length,
tester_setup_complete();
}
+/* Authorize a deferred connection, the socket is kept open in data->io */
+static void defer_authorize(struct test_data *data, int sk)
+{
+ ssize_t ret;
+ char c;
+
+ ret = recv(sk, &c, 1, MSG_DONTWAIT);
+
+ tester_print("Authorize deferred setup sk = %d: %zd (%s)", sk, ret,
+ ret < 0 ? strerror(errno) : "ok");
+
+ if (data->io)
+ tester_io_unref(data->io);
+
+ data->io = tester_io_new(sk);
+ tester_io_set_close_on_unref(data->io, true);
+}
+
+static void pin_code_request_callback(uint16_t index, uint16_t length,
+ const void *param, void *user_data)
+{
+ const struct mgmt_ev_pin_code_request *ev = param;
+ struct test_data *data = user_data;
+ const struct rfcomm_server_data *srv = data->test_data;
+ struct mgmt_cp_pin_code_reply cp;
+
+ /* Behave like a listener that does not wait to be notified: accept
+ * and authorize whatever is queued while authentication is pending.
+ */
+ if (srv->defer) {
+ int new_sk;
+
+ new_sk = accept(data->listen_sk, NULL, NULL);
+ if (new_sk < 0) {
+ tester_print("Nothing to accept while authentication "
+ "is pending: %s (%d)", strerror(errno),
+ errno);
+ } else {
+ tester_print("Accepted sk = %d while authentication "
+ "is pending", new_sk);
+ defer_authorize(data, new_sk);
+ }
+ }
+
+ memset(&cp, 0, sizeof(cp));
+ memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
+ cp.pin_len = srv->pin_len;
+ memcpy(cp.pin_code, srv->pin, srv->pin_len);
+
+ mgmt_reply(data->mgmt, MGMT_OP_PIN_CODE_REPLY, data->mgmt_index,
+ sizeof(cp), &cp, NULL, NULL, NULL);
+}
+
static void setup_powered_server(const void *test_data)
{
struct test_data *data = tester_get_data();
+ const struct rfcomm_server_data *srv = test_data;
unsigned char param[] = { 0x01 };
tester_print("Powering on controller");
+ if (srv && srv->pin) {
+ struct bthost *bthost = hciemu_client_get_host(data->hciemu);
+
+ mgmt_register(data->mgmt, MGMT_EV_PIN_CODE_REQUEST,
+ data->mgmt_index, pin_code_request_callback,
+ data, NULL);
+
+ bthost_set_pin_code(bthost, srv->client_pin,
+ srv->client_pin_len);
+
+ mgmt_send(data->mgmt, MGMT_OP_SET_BONDABLE, data->mgmt_index,
+ sizeof(param), param, NULL, NULL, NULL);
+ }
+
mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
sizeof(param), param,
NULL, NULL, NULL);
@@ -374,6 +449,33 @@ const struct rfcomm_server_data listen_read_success = {
.read_data = data
};
+const struct rfcomm_server_data listen_defer_success = {
+ .server_channel = 0x0c,
+ .client_channel = 0x0c,
+ .expected_status = true,
+ .defer = true,
+};
+
+static const uint8_t pair_pin[] = { 0x30, 0x30, 0x30, 0x30 }; /* "0000" */
+/* "1111" */
+static const uint8_t pair_wrong_pin[] = { 0x31, 0x31, 0x31, 0x31 };
+
+/* The listener accepts and authorizes the connection while authentication is
+ * still pending and then authentication fails, the connection shall be
+ * refused.
+ */
+const struct rfcomm_server_data listen_defer_early_accept = {
+ .server_channel = 0x0c,
+ .client_channel = 0x0c,
+ .expected_status = false,
+ .defer = true,
+ .sec_level = BT_SECURITY_MEDIUM,
+ .pin = pair_pin,
+ .pin_len = sizeof(pair_pin),
+ .client_pin = pair_wrong_pin,
+ .client_pin_len = sizeof(pair_wrong_pin),
+};
+
const struct rfcomm_server_data listen_nval = {
.server_channel = 0x0c,
.client_channel = 0x0e,
@@ -721,6 +823,13 @@ static bool rfcomm_listen_cb(struct tester_io *io, uint32_t cond,
return false;
}
+ /* The result is checked once the client connection completes */
+ if (srv->defer) {
+ tester_print("Accept deferred setup sk = %d", new_sk);
+ defer_authorize(data, new_sk);
+ return false;
+ }
+
if (srv->send_data) {
ssize_t ret;
@@ -803,6 +912,37 @@ static void test_server(const void *test_data)
return;
}
+ if (srv->sec_level) {
+ struct bt_security sec;
+
+ memset(&sec, 0, sizeof(sec));
+ sec.level = srv->sec_level;
+
+ if (setsockopt(sk, SOL_BLUETOOTH, BT_SECURITY, &sec,
+ sizeof(sec)) < 0) {
+ tester_warn("Can't set security level: %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ close(sk);
+ return;
+ }
+ }
+
+ if (srv->defer) {
+ int opt = 1;
+
+ if (setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP, &opt,
+ sizeof(opt)) < 0) {
+ tester_warn("Can't enable deferred setup: %s (%d)",
+ strerror(errno), errno);
+ tester_test_failed();
+ close(sk);
+ return;
+ }
+ }
+
+ data->listen_sk = sk;
+
if (listen(sk, 5) < 0) {
tester_warn("listening on socket failed: %s (%u)",
strerror(errno), errno);
@@ -868,6 +1008,12 @@ int main(int argc, char *argv[])
test_rfcomm("Basic RFCOMM Socket Server - Read Success",
&listen_read_success, setup_powered_server,
test_server);
+ test_rfcomm("Basic RFCOMM Socket Server - Defer Success",
+ &listen_defer_success, setup_powered_server,
+ test_server);
+ test_rfcomm("Basic RFCOMM Socket Server - Defer Early Accept",
+ &listen_defer_early_accept,
+ setup_powered_server, test_server);
test_rfcomm("Basic RFCOMM Socket Server - Conn Refused", &listen_nval,
setup_powered_server, test_server);
--
2.56.0
next prev parent reply other threads:[~2026-11-20 15:47 UTC|newest]
Thread overview: 6+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 15:47 [PATCH BlueZ v2 0/5] Add tests for security of deferred setup Luiz Augusto von Dentz
2026-11-20 15:47 ` [PATCH BlueZ v2 1/5] emulator/bthost: Add helpers to test " Luiz Augusto von Dentz
2026-11-20 15:47 ` [PATCH BlueZ v2 2/5] emulator/btdev: Add btdev_set_link_key_type Luiz Augusto von Dentz
2026-11-20 15:47 ` [PATCH BlueZ v2 3/5] l2cap-tester: Add tests for security of deferred setup Luiz Augusto von Dentz
2026-11-20 15:47 ` Luiz Augusto von Dentz [this message]
2026-11-20 15:47 ` [PATCH BlueZ v2 5/5] l2cap-tester: Set IO capability in Client SSP - Success 2 Luiz Augusto von Dentz
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120154750.1745643-5-luiz.dentz@gmail.com \
--to=luiz.dentz@gmail.com \
--cc=linux-bluetooth@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox