Linux bluetooth development
 help / color / mirror / Atom feed
* [PATCH BlueZ v2 1/2] device: Fix SDP records without a record handle
@ 2026-11-21  5:51 Muxian Li
  2026-11-21  5:51 ` [PATCH BlueZ v2 2/2] test: functional: Cover SDP records without handle Muxian Li
  2026-11-21 11:25 ` [BlueZ,v2,1/2] device: Fix SDP records without a record handle bluez.test.bot
  0 siblings, 2 replies; 3+ messages in thread
From: Muxian Li @ 2026-11-21  5:51 UTC (permalink / raw)
  To: linux-bluetooth; +Cc: Muxian Li

Devices that leave the ServiceRecordHandle attribute out of their
Service Search Attribute responses, such as the Nintendo Switch 2,
produce records that all carry the 0xffffffff placeholder handle.
update_record() then drops every record but the first as a duplicate,
so e.g. the AVRCP Controller record of the Switch 2 is lost and
absolute volume is rejected.

Tell such records apart by the missing attribute rather than by the
placeholder, which is also a valid handle, and compare them by content,
so copies returned by the different searches are still merged while
distinct records are kept.

Cache each of them under a key that nothing else is stored under,
chosen from 0xffffffff downwards. A record keeps its key as long as it
does not change, also when the device returns its records in another
order or leaves some out, and is moved to another key when a record
with that handle is found.

As for records with a handle, cached records are not removed when a
later discovery no longer returns them. Without a handle a changed
record can not be told from a new one, so it is cached next to the
version it replaces.

Fixes: 8b2e688eaf5b ("Check for duplicate record handles and not UUIDs")
Assisted-by: Claude:claude-mythos-5-2
---
v2:
- Records without handle keep their cache key from one discovery to
  the next, instead of being numbered in the order they were found
  (reported by Copilot review).
- Their key no longer takes the place of a record with that handle
  (reported by Copilot review).
- A record with the handle 0xffffffff is handled as any record with a
  handle.
- Records are no longer encoded again for every comparison.
- Link to v1: https://lore.kernel.org/linux-bluetooth/20261115070055.45999-1-muxianli5401@gmail.com/

 doc/settings-storage.txt |   5 +-
 src/device.c             | 202 +++++++++++++++++++++++++++++++++------
 2 files changed, 178 insertions(+), 29 deletions(-)

diff --git a/doc/settings-storage.txt b/doc/settings-storage.txt
index 8bd677e24..0caf3305e 100644
--- a/doc/settings-storage.txt
+++ b/doc/settings-storage.txt
@@ -187,7 +187,10 @@ Each file, named by remote device address, may includes multiple groups
 (General, ServiceRecords, Attributes, Endpoints, NameResolving).
 
 In ServiceRecords, SDP records are stored using their handle as key
-(hexadecimal format).
+(hexadecimal format). Records without a ServiceRecordHandle attribute are
+stored under a key that nothing else is stored under, chosen from 0xFFFFFFFF
+downwards. Such a record keeps its key as long as it does not change, and is
+moved to another key when a record with that handle is found.
 
 In "Attributes" group GATT database is stored using attribute handle as key
 (hexadecimal format). Value associated with this handle is serialized form of
diff --git a/src/device.c b/src/device.c
index 36a980d1e..d4d5f9d16 100644
--- a/src/device.c
+++ b/src/device.c
@@ -126,6 +126,9 @@ struct browse_req {
 	GSList *match_uuids;
 	GSList *profiles_added;
 	sdp_list_t *records;
+	GTree *handles;
+	GTree *pdus;
+	uint32_t keys_tried;
 	int search_uuid;
 	int reconnect_attempt;
 	guint listener_id;
@@ -797,6 +800,10 @@ static void browse_request_free(struct browse_req *req)
 	g_slist_free_full(req->profiles_added, g_free);
 	if (req->records)
 		sdp_list_free(req->records, (sdp_free_func_t) sdp_record_free);
+	if (req->handles)
+		g_tree_destroy(req->handles);
+	if (req->pdus)
+		g_tree_destroy(req->pdus);
 
 	g_free(req);
 }
@@ -5948,29 +5955,144 @@ add_uuids:
 	device_add_uuids(device, uuids);
 }
 
-static void store_sdp_record(GKeyFile *key_file, sdp_record_t *rec)
+/*
+ * Some devices (e.g. the Nintendo Switch 2) omit the ServiceRecordHandle
+ * attribute from their Service Search Attribute responses. rec->handle of
+ * such a record is the placeholder set by sdp_record_alloc(), which is also
+ * a valid handle, so check for the attribute itself.
+ */
+static bool record_has_handle(const sdp_record_t *rec)
+{
+	return sdp_data_get(rec, SDP_ATTR_RECORD_HANDLE) != NULL;
+}
+
+static char *record_to_string(const sdp_record_t *rec)
 {
-	char handle_str[11];
 	sdp_buf_t buf;
-	int size, i;
+	uint32_t i;
 	char *str;
 
-	sprintf(handle_str, "0x%8.8X", rec->handle);
-
 	if (sdp_gen_record_pdu(rec, &buf) < 0)
-		return;
-
-	size = buf.data_size;
+		return NULL;
 
-	str = g_malloc0(size*2+1);
+	str = g_malloc0(buf.data_size * 2 + 1);
 
-	for (i = 0; i < size; i++)
+	for (i = 0; i < buf.data_size; i++)
 		sprintf(str + (i * 2), "%02X", buf.data[i]);
 
-	g_key_file_set_string(key_file, "ServiceRecords", handle_str, str);
-
 	free(buf.data);
-	g_free(str);
+
+	return str;
+}
+
+static bool string_is_record_without_handle(const char *str)
+{
+	sdp_record_t *rec;
+	bool ret;
+
+	rec = record_from_string(str);
+	if (!rec)
+		return false;
+
+	ret = rec->attrlist && !record_has_handle(rec);
+
+	sdp_record_free(rec);
+
+	return ret;
+}
+
+static int record_string_cmp(gconstpointer a, gconstpointer b, gpointer data)
+{
+	return strcmp(a, b);
+}
+
+static int record_handle_cmp(gconstpointer a, gconstpointer b)
+{
+	uint32_t h1 = GPOINTER_TO_UINT(a);
+	uint32_t h2 = GPOINTER_TO_UINT(b);
+
+	if (h1 == h2)
+		return 0;
+
+	return h1 < h2 ? -1 : 1;
+}
+
+/* Value to key of the cached records, to find the key of a known record */
+static GTree *load_sdp_record_keys(GKeyFile *key_file)
+{
+	GTree *keys;
+	char **names, **name;
+
+	keys = g_tree_new_full(record_string_cmp, NULL, g_free, g_free);
+
+	names = g_key_file_get_keys(key_file, "ServiceRecords", NULL, NULL);
+
+	for (name = names; name && *name; name++) {
+		char *str;
+
+		str = g_key_file_get_string(key_file, "ServiceRecords", *name,
+									NULL);
+		if (!str)
+			continue;
+
+		if (g_tree_lookup(keys, str))
+			g_free(str);
+		else
+			g_tree_insert(keys, str, g_strdup(*name));
+	}
+
+	g_strfreev(names);
+
+	return keys;
+}
+
+/* Next key, from 0xffffffff downwards, that nothing is stored under */
+static void unused_sdp_record_key(struct browse_req *req, GKeyFile *key_file,
+								char *key)
+{
+	do {
+		sprintf(key, "0x%8.8X", 0xffffffff - req->keys_tried++);
+	} while (g_key_file_has_key(key_file, "ServiceRecords", key, NULL));
+}
+
+/*
+ * A record is stored using its handle as key. A record without handle is
+ * stored under a key that nothing else uses, and keeps it as long as it
+ * does not change: there is nothing else to tell that it is the same
+ * record. It makes way for a record that has its key as handle.
+ */
+static void store_sdp_record(struct browse_req *req, GKeyFile *key_file,
+					GTree *keys, sdp_record_t *rec,
+					const char *str)
+{
+	char key[11];
+
+	if (record_has_handle(rec)) {
+		char *old;
+
+		sprintf(key, "0x%8.8X", rec->handle);
+
+		old = g_key_file_get_string(key_file, "ServiceRecords", key,
+									NULL);
+		if (old && string_is_record_without_handle(old)) {
+			char new_key[11];
+
+			unused_sdp_record_key(req, key_file, new_key);
+			g_key_file_set_string(key_file, "ServiceRecords",
+							new_key, old);
+			g_tree_replace(keys, old, g_strdup(new_key));
+		} else {
+			g_free(old);
+		}
+	} else {
+		if (g_tree_lookup(keys, str))
+			return;
+
+		unused_sdp_record_key(req, key_file, key);
+		g_tree_insert(keys, g_strdup(str), g_strdup(key));
+	}
+
+	g_key_file_set_string(key_file, "ServiceRecords", key, str);
 }
 
 static void store_primaries_from_sdp_record(GKeyFile *key_file,
@@ -6020,22 +6142,36 @@ done:
 	free(att_uuid);
 }
 
-static int rec_cmp(const void *a, const void *b)
-{
-	const sdp_record_t *r1 = a;
-	const sdp_record_t *r2 = b;
-
-	return r1->handle - r2->handle;
-}
-
 static int update_record(struct browse_req *req, const char *uuid,
-							sdp_record_t *rec)
+					sdp_record_t *rec, const char *str)
 {
 	GSList *l;
 
-	/* Check for duplicates */
-	if (sdp_list_find(req->records, rec, rec_cmp))
-		return -EALREADY;
+	/*
+	 * Check for duplicates. Records without handle are compared by
+	 * content: copies of one record returned by different searches are
+	 * identical, different records are not.
+	 */
+	if (record_has_handle(rec)) {
+		gpointer handle = GUINT_TO_POINTER(rec->handle);
+
+		if (!req->handles)
+			req->handles = g_tree_new(record_handle_cmp);
+
+		if (g_tree_lookup_extended(req->handles, handle, NULL, NULL))
+			return -EALREADY;
+
+		g_tree_insert(req->handles, handle, NULL);
+	} else {
+		if (!req->pdus)
+			req->pdus = g_tree_new_full(record_string_cmp, NULL,
+								g_free, NULL);
+
+		if (g_tree_lookup_extended(req->pdus, str, NULL, NULL))
+			return -EALREADY;
+
+		g_tree_insert(req->pdus, g_strdup(str), NULL);
+	}
 
 	/* Copy record */
 	req->records = sdp_list_append(req->records, sdp_copy_record(rec));
@@ -6063,6 +6199,7 @@ static void update_bredr_services(struct browse_req *req, sdp_list_t *recs)
 	char att_file[PATH_MAX];
 	GKeyFile *sdp_key_file;
 	GKeyFile *att_key_file;
+	GTree *sdp_keys = NULL;
 	GError *gerr = NULL;
 
 	char *data;
@@ -6081,7 +6218,8 @@ static void update_bredr_services(struct browse_req *req, sdp_list_t *recs)
 		g_clear_error(&gerr);
 		g_key_file_free(sdp_key_file);
 		sdp_key_file = NULL;
-	}
+	} else
+		sdp_keys = load_sdp_record_keys(sdp_key_file);
 
 	create_filename(att_file, PATH_MAX, "/%s/%s/attributes", srcaddr,
 							dstaddr);
@@ -6099,6 +6237,7 @@ static void update_bredr_services(struct browse_req *req, sdp_list_t *recs)
 	for (seq = recs; seq; seq = seq->next) {
 		sdp_record_t *rec = (sdp_record_t *) seq->data;
 		char *profile_uuid;
+		char *str;
 
 		if (!rec)
 			break;
@@ -6132,16 +6271,22 @@ static void update_bredr_services(struct browse_req *req, sdp_list_t *recs)
 							product, version);
 		}
 
-		if (update_record(req, profile_uuid, rec) < 0)
+		str = record_to_string(rec);
+		if (!str)
+			goto next;
+
+		if (update_record(req, profile_uuid, rec, str) < 0)
 			goto next;
 
 		if (sdp_key_file)
-			store_sdp_record(sdp_key_file, rec);
+			store_sdp_record(req, sdp_key_file, sdp_keys, rec,
+									str);
 
 		if (att_key_file)
 			store_primaries_from_sdp_record(att_key_file, rec);
 
 next:
+		g_free(str);
 		free(profile_uuid);
 	}
 
@@ -6158,6 +6303,7 @@ next:
 
 		g_free(data);
 		g_key_file_free(sdp_key_file);
+		g_tree_destroy(sdp_keys);
 	}
 
 	if (att_key_file) {

base-commit: 20ffd285b58facfd1f2478d159a5f941b09d5be1
-- 
2.53.0


^ permalink raw reply related	[flat|nested] 3+ messages in thread

* [PATCH BlueZ v2 2/2] test: functional: Cover SDP records without handle
  2026-11-21  5:51 [PATCH BlueZ v2 1/2] device: Fix SDP records without a record handle Muxian Li
@ 2026-11-21  5:51 ` Muxian Li
  2026-11-21 11:25 ` [BlueZ,v2,1/2] device: Fix SDP records without a record handle bluez.test.bot
  1 sibling, 0 replies; 3+ messages in thread
From: Muxian Li @ 2026-11-21  5:51 UTC (permalink / raw)
  To: linux-bluetooth; +Cc: Muxian Li

Make host1 answer SDP itself, without bluetoothd, with records that
lack the ServiceRecordHandle attribute, like those of a Nintendo
Switch 2. Check that bluetoothd on host0 keeps and caches each record
once, that a record keeps its cache key from one discovery to the
next, and that records with and without a handle do not overwrite each
other, also when host1 goes out of range during a discovery.

Document the tests in functional-sdp(7).

Assisted-by: Claude:claude-mythos-5-2
---
v2:
- Check the responses host1 sent, the cache keys and the cached
  records themselves.
- Add test_sdp_out_of_range.py and test_sdp_cache.py.
- Move the documentation to functional-sdp(7).

 Makefile.am                              |   1 +
 doc/functional-sdp.rst                   | 619 +++++++++++++++++++
 doc/functional-testing.rst               |   3 +
 test/functional/test_sdp.py              | 333 ++++++++++
 test/functional/test_sdp_cache.py        | 739 +++++++++++++++++++++++
 test/functional/test_sdp_out_of_range.py | 723 ++++++++++++++++++++++
 6 files changed, 2418 insertions(+)
 create mode 100644 doc/functional-sdp.rst
 create mode 100644 test/functional/test_sdp.py
 create mode 100644 test/functional/test_sdp_cache.py
 create mode 100644 test/functional/test_sdp_out_of_range.py

diff --git a/Makefile.am b/Makefile.am
index 37302ed47..b51a6ff30 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -506,6 +506,7 @@ EXTRA_DIST += doc/assigned-numbers.rst doc/supported-features.txt \
 				doc/functional-hog.rst \
 				doc/functional-mpris-proxy.rst \
 				doc/functional-obex.rst \
+				doc/functional-sdp.rst \
 				doc/settings-storage.txt
 
 EXTRA_DIST += doc/hci-protocol.rst doc/mgmt-protocol.rst \
diff --git a/doc/functional-sdp.rst b/doc/functional-sdp.rst
new file mode 100644
index 000000000..5e40b9717
--- /dev/null
+++ b/doc/functional-sdp.rst
@@ -0,0 +1,619 @@
+==============
+functional-sdp
+==============
+
+DESCRIPTION
+===========
+
+SDP client functional tests, `test/functional/test_sdp.py`,
+`test/functional/test_sdp_out_of_range.py` and
+`test/functional/test_sdp_cache.py`, covering the service discovery of
+**bluetoothd(8)** over BR/EDR and the SDP records it caches. See
+**functional-testing(7)** for the conventions used here, and
+**test-functional(1)** for how to run the suite.
+
+SETUP
+=====
+
+Two hosts, connected over BR/EDR. host0 runs **bluetoothd(8)** with an
+agent. host1 runs no bluetoothd: `btmgmt` makes it connectable and
+discoverable, and it answers SDP on PSM 1 itself:
+
+.. code-block::
+
+	+------------------------+                 +------------------------+
+	| host0                  |      BR/EDR     | host1                  |
+	| bluetoothd, agent      | --------------> | SDP server, PSM 1      |
+	| discovers, browses     |                 | no bluetoothd          |
+	+------------------------+                 +------------------------+
+
+	--> connection is initiated by
+
+host0 discovers the services of host1 as follows:
+
+1. host0 calls ``org.bluez.Adapter1.StartDiscovery`` until it has a
+   device object for host1, then ``StopDiscovery``.
+2. host0 sets ``Trusted`` on it, as bluetoothd only keeps a device that
+   is paired or trusted once its link is lost.
+3. host0 calls ``org.bluez.Device1.Connect``, which browses the SDP
+   records of host1 with a Service Search Attribute request for the
+   L2CAP UUID, and then one for the PnP Information UUID. ``Connect``
+   returns an error, as host1 offers no service to connect.
+
+bluetoothd caches the records in the ``ServiceRecords`` group of the
+cache file of host1, using their handle as key (see
+`doc/settings-storage.txt`). A record without the ServiceRecordHandle
+attribute has no handle, so bluetoothd chooses a key for it.
+
+The tests in `test_sdp_cache.py` have host1 return these records:
+
+A, B, C, E
+	Records of the service classes 0x7001, 0x7002, 0x7003 and 0x7005,
+	which no profile of bluetoothd handles, as ``Connect`` only
+	discovers the services of a known device again if it finds no
+	service to connect. Returned for the L2CAP search, without handle
+	unless a test says otherwise.
+
+D
+	A PnP Information record without handle, returned for the PnP
+	Information search unless a test says otherwise.
+
+A changed record is the same record with attribute 0x0200 set to
+another value.
+
+Unless a test says otherwise, it checks that the cache holds exactly
+the records named, each of them once, that every key is ``0x``
+followed by 8 uppercase hexadecimal digits, and that a record with a
+handle is cached under it.
+
+Some tests run **bluetoothd(8)** with ``Experimental = true``, for
+``org.bluez.Device1.GetServiceRecords``, which returns the records
+bluetoothd has in memory. host1 connects to host0 first, as the method
+requires a connected device, which does not make host0 discover its
+services again.
+
+TEST CASES
+==========
+
+test_sdp_records_without_handle[switch2]
+----------------------------------------
+
+:Setup: As above, host1 answers with the records of a Nintendo Switch
+	2, none of which has the ServiceRecordHandle attribute: Audio
+	Source, A/V Remote Control and A/V Remote Control Target for the
+	L2CAP search, and PnP Information for the PnP Information search.
+
+:Steps:
+	1. host0 calls ``org.bluez.Adapter1.StartDiscovery`` until it has a
+	   device object for host1, then ``StopDiscovery``.
+	2. host0 calls ``org.bluez.Device1.Connect``.
+	3. Wait until ``org.bluez.Device1.UUIDs`` of host1 contains the
+	   Audio Source UUID of its first record.
+
+:Expected:
+	1. ``UUIDs`` also contains the A/V Remote Control Target, A/V
+	   Remote Control and PnP Information UUIDs of the other records.
+	2. host1 sent the PnP Information record in its second response
+	   only.
+	3. The cache holds each of the 4 records once.
+
+:Notes: Skipped if `btmgmt` is not built.
+
+test_sdp_records_without_handle[duplicate]
+------------------------------------------
+
+:Setup: As above, but host1 also returns the PnP Information record
+	for the L2CAP search.
+
+:Steps: As above.
+
+:Expected: As above, except host1 sent the PnP Information record in
+	both responses. It is cached once.
+
+test_sdp_new_without_handle_down_before_second_response
+-------------------------------------------------------
+
+:Setup: As for test_sdp_records_without_handle[switch2], except host1
+	goes out of range when it receives the second request: it stops
+	page scan, disconnects with the reason Connection Timeout and
+	powers off.
+
+:Steps: host0 discovers the services of host1.
+
+:Expected:
+	1. ``Connect`` returns ``br-connection-create-socket``.
+	2. ``UUIDs`` of host1 is empty, as the discovery did not complete.
+	3. The cache holds the 3 records of the first search.
+
+:Notes: btvirt has no link supervision timeout, so host1 disconnects
+	with that reason itself, which btvirt passes on to host0 as it is.
+
+test_sdp_cache_same_record_twice
+--------------------------------
+
+:Setup: As above, host1 returns A, A and C for the L2CAP search.
+
+:Steps: host0 discovers the services of host1.
+
+:Expected: The cache holds A, C and D.
+
+test_sdp_cache_in_memory_after_discovery
+----------------------------------------
+
+:Setup: As above, with ``Experimental = true``. host1 returns A, B and
+	C.
+
+:Steps:
+	1. host0 discovers the services of host1.
+	2. host1 connects to host0, and host0 calls
+	   ``org.bluez.Device1.GetServiceRecords``.
+
+:Expected: ``GetServiceRecords`` returns A, B, C and D, each once.
+
+test_sdp_cache_in_memory_after_rediscovery
+------------------------------------------
+
+:Setup: As above, with ``Experimental = true``.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A, B and
+	   C.
+	2. host0 discovers them again, host1 returning A and C.
+	3. host1 connects to host0, and host0 calls
+	   ``org.bluez.Device1.GetServiceRecords``.
+
+:Expected:
+	1. ``GetServiceRecords`` returns A, C and D, each once.
+	2. The cache holds A, B, C and D.
+
+test_sdp_cache_same_records
+---------------------------
+
+:Setup: As above.
+
+:Steps: host0 discovers the services of host1 twice, host1 returning
+	A, B and C both times.
+
+:Expected: The cache holds A, B, C and D, each under the key it had
+	after the first discovery.
+
+test_sdp_cache_records_in_other_order
+-------------------------------------
+
+:Setup: As above.
+
+:Steps: As for test_sdp_cache_same_records, except host1 returns C, A
+	and B the second time.
+
+:Expected: As for test_sdp_cache_same_records.
+
+test_sdp_cache_record_in_both_searches_again
+--------------------------------------------
+
+:Setup: As above.
+
+:Steps: As for test_sdp_cache_same_records, except host1 returns A, B,
+	C and D for the L2CAP search the second time.
+
+:Expected: As for test_sdp_cache_same_records, and host1 sent D in
+	both responses of the second discovery.
+
+test_sdp_cache_fewer_records
+----------------------------
+
+:Setup: As above.
+
+:Steps: As for test_sdp_cache_same_records, except host1 returns A and
+	C the second time.
+
+:Expected: As for test_sdp_cache_same_records: B stays cached, as
+	bluetoothd keeps the records with a handle it no longer finds.
+
+test_sdp_cache_changed_record_read_back
+---------------------------------------
+
+:Setup: As above, with ``Experimental = true``.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A, B and
+	   C.
+	2. host0 discovers them again, host1 returning A, B and a changed
+	   C.
+	3. **bluetoothd(8)** is restarted on host0, with the same state
+	   directory.
+	4. host1 connects to host0, and host0 calls
+	   ``org.bluez.Device1.GetServiceRecords``.
+
+:Expected: ``GetServiceRecords`` returns A, B, both versions of C and
+	D, each once, the first version of C before the changed one.
+
+:Notes: bluetoothd can not tell a changed record without handle from a
+	new one. A lookup by UUID finds the first record of that UUID.
+
+test_sdp_cache_changed_record_every_discovery
+---------------------------------------------
+
+:Setup: As above.
+
+:Steps: host0 discovers the services of host1 four times. host1
+	returns A, B and C, with C changed at each discovery.
+
+:Expected: After each discovery the cache holds one more record, the
+	new version of C, and every record cached before under the key it
+	had.
+
+test_sdp_cache_added_record[added-last]
+---------------------------------------
+
+:Setup: As above.
+
+:Steps: As for test_sdp_cache_same_records, except host1 returns A, B,
+	C and E the second time.
+
+:Expected: The cache holds A, B, C, D and E. A, B, C and D have the key
+	they had after the first discovery.
+
+test_sdp_cache_added_record[added-first]
+----------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 returns E, A, B and C the second time.
+
+:Expected: As above.
+
+test_sdp_cache_added_record_down_before_second_response[added-last]
+-------------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As for test_sdp_cache_added_record[added-last], except host1
+	goes out of range when it receives the second request of the
+	second discovery.
+
+:Expected: As for test_sdp_cache_added_record[added-last]: D, which
+	host0 did not get again, stays cached.
+
+test_sdp_cache_added_record_down_before_second_response[added-first]
+--------------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 returns E, A, B and C the second time.
+
+:Expected: As above.
+
+test_sdp_cache_written_without_fix
+----------------------------------
+
+:Setup: As above. Before the discovery, B is written to the cache file
+	of host1 under ``0xFFFFFFFF``, as a bluetoothd that only keeps one
+	record without handle caches it.
+
+:Steps: host0 discovers the services of host1, which returns A, B and
+	C.
+
+:Expected: The cache holds A, B, C and D, B still under
+	``0xFFFFFFFF``.
+
+test_sdp_cache_value_no_record[first-key]
+-----------------------------------------
+
+:Setup: As above. Before the discovery, the value ``DEADBEEF``, which
+	is no SDP record, is written to the cache file of host1 under
+	``0xFFFFFFFF``.
+
+:Steps: host0 discovers the services of host1, which returns A, B and
+	C.
+
+:Expected: The cache holds A, B, C and D, and the entry written before
+	as it was.
+
+test_sdp_cache_value_no_record[second-key]
+------------------------------------------
+
+:Setup: As above, but the value is written under ``0xFFFFFFFE``.
+
+:Steps: As above.
+
+:Expected: As above.
+
+test_sdp_cache_value_no_record[empty]
+-------------------------------------
+
+:Setup: As for test_sdp_cache_value_no_record[first-key], but the
+	value is empty.
+
+:Steps: As above.
+
+:Expected: As above.
+
+test_sdp_cache_value_no_record[not-hex]
+---------------------------------------
+
+:Setup: As for test_sdp_cache_value_no_record[first-key], but the
+	value is ``not hex``.
+
+:Steps: As above.
+
+:Expected: As above.
+
+test_sdp_cache_read_back_after_restart
+--------------------------------------
+
+:Setup: As above, with ``Experimental = true``.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A, B and
+	   C.
+	2. host0 discovers them again, host1 returning A and C.
+	3. **bluetoothd(8)** is restarted on host0, with the same state
+	   directory.
+	4. host1 connects to host0, and host0 calls
+	   ``org.bluez.Device1.GetServiceRecords``.
+
+:Expected: ``GetServiceRecords`` returns A, B, C and D, each once.
+
+test_sdp_cache_handle_equal_to_key_same_search[first]
+-----------------------------------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A and C,
+	   and reads the key of C from the cache.
+	2. host0 calls ``org.bluez.Adapter1.RemoveDevice`` on host1, and
+	   finds it again.
+	3. host0 discovers the services of host1, which returns R, A and
+	   C. R is a record of service class 0x7004 with the key of C as
+	   handle.
+
+:Expected: The cache holds A, R, C and D, R under its handle.
+
+:Notes: The key is read from an earlier discovery, so the test does
+	not depend on how bluetoothd chooses the keys of records without
+	handle.
+
+test_sdp_cache_handle_equal_to_key_same_search[middle]
+------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 returns A, R and C.
+
+:Expected: As above.
+
+test_sdp_cache_handle_equal_to_key_same_search[last]
+----------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 returns A, C and R, so R is found after
+	C got that key.
+
+:Expected: As above.
+
+test_sdp_cache_handle_equal_to_key_later_search[key-of-first]
+-------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A and C
+	   and no PnP Information record, and reads the key of A from the
+	   cache.
+	2. host0 removes host1 and finds it again.
+	3. host0 discovers the services of host1, which returns A and C,
+	   and for the PnP Information search a PnP Information record R
+	   with the key of A as handle.
+
+:Expected: The cache holds A, C and R, R under its handle.
+
+test_sdp_cache_handle_equal_to_key_later_search[key-of-second]
+--------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, with the key of C.
+
+:Expected: As above.
+
+test_sdp_cache_handle_equal_to_key_later_discovery[key-of-c-complete]
+---------------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A, B and
+	   C, and reads the key of C from the cache.
+	2. host0 discovers them again, host1 returning A, B, C and R. R is
+	   a record of service class 0x7004 with the key of C as handle.
+
+:Expected: The cache holds A, B, C, D and R, R under its handle. C is
+	cached under another key, and A, B and D have the key they had
+	after the first discovery.
+
+test_sdp_cache_handle_equal_to_key_later_discovery[key-of-c-down]
+-----------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 goes out of range when it receives the
+	second request of the second discovery.
+
+:Expected: As above.
+
+test_sdp_cache_handle_equal_to_key_later_discovery[key-of-d-down]
+-----------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, with the key of D, which host0 does not get again.
+
+:Expected: As above, D being the record cached under another key.
+
+test_sdp_cache_handle_equal_to_key_later_discovery[key-of-d-first-down]
+-----------------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except host1 returns R, A, B and C.
+
+:Expected: As above.
+
+test_sdp_cache_handle_equal_to_key_later_discovery[key-of-dropped-b]
+--------------------------------------------------------------------
+
+:Setup: As above.
+
+:Steps: As for
+	test_sdp_cache_handle_equal_to_key_later_discovery[key-of-c-complete],
+	with the key of B, host1 returning A, C and R the second time.
+
+:Expected: As above, B being the record cached under another key.
+
+test_sdp_cache_key_equal_to_cached_handle[dropped]
+--------------------------------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A and E
+	   and no PnP Information record, and reads the key of E from the
+	   cache.
+	2. host0 removes host1 and finds it again.
+	3. host0 discovers the services of host1, which returns A, and
+	   for the PnP Information search a PnP Information record P with
+	   the key of E as handle.
+	4. host0 discovers them again, host1 returning A and E and no PnP
+	   Information record.
+
+:Expected: The cache holds A, E and P. A and P have the key they had
+	after step 3.
+
+test_sdp_cache_key_equal_to_cached_handle[down]
+-----------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, except in step 4 host1 still returns P, and goes out
+	of range when it receives the second request.
+
+:Expected: As above.
+
+test_sdp_cache_handle_0xffffffff
+--------------------------------
+
+:Setup: As above. R is a record of service class 0x7004 with the
+	handle 0xFFFFFFFF.
+
+:Steps: host0 discovers the services of host1, which returns B, R and
+	C.
+
+:Expected: The cache holds B, R, C and D, R under ``0xFFFFFFFF``.
+
+:Notes: 0xFFFFFFFF is also the value the handle of a record without
+	the ServiceRecordHandle attribute has in bluetoothd.
+
+test_sdp_cache_same_handle_twice
+--------------------------------
+
+:Setup: As above. R1 and R2 are records of the service classes 0x7004
+	and 0x7006, both with the handle 0xFFFFFFFF.
+
+:Steps: host0 discovers the services of host1, which returns R1 and
+	R2.
+
+:Expected:
+	1. The cache holds R1 and D.
+	2. ``UUIDs`` of host1 contains the UUID of R1, and not the one of
+	   R2.
+
+:Notes: The second record is dropped as a duplicate of the first, as
+	for any handle.
+
+test_sdp_cache_same_handle_changed
+----------------------------------
+
+:Setup: As above. R is a record of service class 0x7004 with the
+	handle 0xFFFFFFFF.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A and R.
+	2. host0 discovers them again, host1 returning A and a changed R.
+
+:Expected: The cache holds A, the changed R and D.
+
+test_sdp_cache_handles_gained_or_lost[gains]
+--------------------------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns A and C.
+	2. host0 discovers them again, host1 returning A, C and D with the
+	   handles 0x00010001, 0x00010003 and 0x00010004.
+
+:Expected: The cache holds the records of both discoveries, those of
+	the first under the key they had.
+
+test_sdp_cache_handles_gained_or_lost[loses]
+--------------------------------------------
+
+:Setup: As above.
+
+:Steps: As above, with the two discoveries in the other order.
+
+:Expected: As above.
+
+test_sdp_cache_many_records
+---------------------------
+
+:Setup: As above.
+
+:Steps:
+	1. host0 discovers the services of host1, which returns 10000
+	   records of service class 0x7001 for the L2CAP search, each with
+	   a handle of its own and another value of attribute 0x0200.
+	2. host0 removes host1 and finds it again.
+	3. host0 discovers the services of host1, which returns the same
+	   records without handle.
+
+:Expected:
+	1. The cache holds 10001 records after each discovery.
+	2. host0 takes at most twice as long from the response to the
+	   L2CAP search to its PnP Information search in step 3 as in
+	   step 1.
+
+:Notes: host1 sends a response that does not fit in the L2CAP MTU in
+	parts of 600 bytes, with a continuation state. The time is taken
+	on host1, so it does not include the transfer of the response.
+	The keys and the records themselves are not checked.
+
+test_sdp_cache_public_browse_group[alone]
+-----------------------------------------
+
+:Setup: As above. X and Y are records of service class 0x1002 without
+	handle. host1 returns no record for the L2CAP and the PnP
+	Information search, and X and Y for the Public Browse Group
+	search.
+
+:Steps: host0 discovers the services of host1.
+
+:Expected:
+	1. host1 received three searches.
+	2. The cache holds X and Y.
+
+:Notes: bluetoothd only searches for the Public Browse Group if the
+	L2CAP search returns no record, and only keeps records of that
+	service class from it. It handles the records of its last search
+	twice.
+
+test_sdp_cache_public_browse_group[after-pnp]
+---------------------------------------------
+
+:Setup: As above, but host1 returns D for the PnP Information search.
+
+:Steps: As above.
+
+:Expected: As above, the cache holding X, Y and D.
diff --git a/doc/functional-testing.rst b/doc/functional-testing.rst
index 371258261..6c9689dfa 100644
--- a/doc/functional-testing.rst
+++ b/doc/functional-testing.rst
@@ -19,6 +19,9 @@ are documented separately:
 - **functional-hog(7)**: `test/functional/test_hog.py`
 - **functional-mpris-proxy(7)**: `test/functional/test_mpris_proxy.py`
 - **functional-obex(7)**: `test/functional/test_obex.py`
+- **functional-sdp(7)**: `test/functional/test_sdp.py`,
+  `test/functional/test_sdp_out_of_range.py` and
+  `test/functional/test_sdp_cache.py`
 
 Each test case is described as:
 
diff --git a/test/functional/test_sdp.py b/test/functional/test_sdp.py
new file mode 100644
index 000000000..2a27ea4df
--- /dev/null
+++ b/test/functional/test_sdp.py
@@ -0,0 +1,333 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for the bluetoothd SDP client using VM instances
+"""
+
+import configparser
+import glob
+import os
+import re
+import socket
+import struct
+import subprocess
+import threading
+
+import dbus
+import pytest
+
+from pytest_bluezenv import (
+    host_config,
+    Agent,
+    HostPlugin,
+    find_exe,
+    run,
+    wait_until,
+    mainloop_wrap,
+    get_dbus,
+)
+
+pytestmark = [pytest.mark.vm]
+
+SDP_PSM = 0x0001
+SDP_SVC_SEARCH_ATTR_REQ = 0x06
+SDP_SVC_SEARCH_ATTR_RSP = 0x07
+L2CAP_UUID = 0x0100
+PNP_INFO_UUID = 0x1200
+
+SDP_DE_UINT = 1
+SDP_DE_UUID = 3
+SDP_DE_SEQ = 6
+SDP_DE_ALT = 7
+
+# Key format of doc/settings-storage.txt: the handle in hexadecimal
+KEY = re.compile(r"0x[0-9A-F]{8}")
+
+# Attribute lists sent by a Nintendo Switch 2 for the L2CAP and PnP searches
+# of bluetoothd, over the full attribute range. None of its records has the
+# ServiceRecordHandle attribute (0x0000).
+SWITCH2_RECORDS = {
+    L2CAP_UUID: bytes.fromhex(
+        "36009c"
+        # Audio Source
+        "360030090001350319110a090004351035061901000900193506190019090103"
+        "0900093508350619110d090104090311090000"
+        # A/V Remote Control, A/V Remote Control Controller
+        "360033090001350619110e19110f090004351035061901000900173506190017"
+        "0901040900093508350619110e090106090311090002"
+        # A/V Remote Control Target
+        "360030090001350319110c090004351035061901000900173506190017090104"
+        "0900093508350619110e090106090311090001"
+    ),
+    PNP_INFO_UUID: bytes.fromhex(
+        "36002e"
+        "36002b0900013503191200090200090103090201090553090202092060090203"
+        "0901000902042801090205090001"
+    ),
+}
+
+
+def de_span(buf, pos):
+    """Type, and start and end of the data, of the data element at pos"""
+    dtype, index = buf[pos] >> 3, buf[pos] & 7
+    pos += 1
+
+    if dtype == 0:
+        return dtype, pos, pos
+
+    if index < 5:
+        return dtype, pos, pos + (1 << index)
+
+    size = 1 << (index - 5)
+    start = pos + size
+    return dtype, start, start + int.from_bytes(buf[pos:start], "big")
+
+
+def de_parse(buf, pos=0):
+    """
+    Value of the data element at pos and the position after it. How its
+    size was encoded is left out, so that equal values compare equal.
+    """
+    dtype, start, end = de_span(buf, pos)
+
+    if dtype not in (SDP_DE_SEQ, SDP_DE_ALT):
+        return (dtype, bytes(buf[start:end])), end
+
+    items = []
+    while start < end:
+        item, start = de_parse(buf, start)
+        items.append(item)
+
+    return (dtype, tuple(items)), end
+
+
+def record_attrs(attr_list):
+    """Attributes of a record as a sorted tuple of (id, value)"""
+    dtype, start, end = de_span(attr_list, 0)
+    if dtype == SDP_DE_SEQ and end == len(attr_list):
+        attr_list = attr_list[start:end]
+
+    attrs = {}
+    pos = 0
+    while pos < len(attr_list):
+        (dtype, attr), pos = de_parse(attr_list, pos)
+        assert dtype == SDP_DE_UINT and len(attr) == 2
+        attrs[int.from_bytes(attr, "big")], pos = de_parse(attr_list, pos)
+
+    return tuple(sorted(attrs.items()))
+
+
+def split_records(attr_lists):
+    """Attribute lists of the records of a Service Search Attribute response"""
+    _, pos, end = de_span(attr_lists, 0)
+
+    records = []
+    while pos < end:
+        _, start, pos = de_span(attr_lists, pos)
+        records.append(attr_lists[start:pos])
+
+    return records
+
+
+def search_uuids(params):
+    """UUID16 values of the ServiceSearchPattern of a request"""
+    if params[0] == 0x35:
+        size, pos = params[1], 2
+    elif params[0] == 0x36:
+        size, pos = struct.unpack(">H", params[1:3])[0], 3
+    else:
+        return set()
+
+    pattern = params[pos : pos + size]
+    return {
+        struct.unpack(">H", pattern[i + 1 : i + 3])[0]
+        for i in range(0, len(pattern) - 2, 3)
+        if pattern[i] == 0x19
+    }
+
+
+def search_attr_rsp(tid, attr_lists):
+    params = struct.pack(">H", len(attr_lists)) + attr_lists + b"\x00"
+    return struct.pack(">BHH", SDP_SVC_SEARCH_ATTR_RSP, tid, len(params)) + params
+
+
+class Switch2SdpServer(HostPlugin):
+    """
+    SDP server without bluetoothd that answers Service Search Attribute
+    requests with the records of a Nintendo Switch 2.
+    """
+
+    name = "switch2_sdp"
+
+    def presetup(self, config):
+        try:
+            self.btmgmt = find_exe("tools", "btmgmt")
+        except FileNotFoundError as exc:
+            pytest.skip(reason=f"btmgmt: {exc!r}")
+
+    def setup(self, impl):
+        self.records = dict(SWITCH2_RECORDS)
+        self.answered = []
+
+        for cmd in (("connectable", "on"), ("power", "on"), ("discov", "yes")):
+            run(
+                [self.btmgmt, "--index", "0", *cmd],
+                check=True,
+                stdin=subprocess.DEVNULL,
+            )
+
+        self.sock = socket.socket(
+            socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP
+        )
+        self.sock.bind((socket.BDADDR_ANY, SDP_PSM))
+        self.sock.listen(1)
+        threading.Thread(target=self.serve, daemon=True).start()
+
+    def serve(self):
+        while True:
+            try:
+                conn, _ = self.sock.accept()
+            except OSError:
+                return
+
+            with conn:
+                self.answer(conn)
+
+    def answer(self, conn):
+        while True:
+            try:
+                pdu = conn.recv(1024)
+            except OSError:
+                return
+
+            if not pdu:
+                return
+
+            if len(pdu) < 6 or pdu[0] != SDP_SVC_SEARCH_ATTR_REQ:
+                continue
+
+            tid = struct.unpack(">H", pdu[1:3])[0]
+            attr_lists = b"\x35\x00"
+            for uuid in search_uuids(pdu[5:]):
+                attr_lists = self.records.get(uuid, attr_lists)
+
+            conn.send(search_attr_rsp(tid, attr_lists))
+            self.answered.append(split_records(attr_lists))
+
+    def get_answered(self):
+        """Records of each response sent, as attribute lists"""
+        return list(self.answered)
+
+    def answer_pnp_in_l2cap_search(self):
+        """
+        Also return the PnP Information record for the L2CAP search, so
+        that bluetoothd gets it from both of its searches.
+        """
+        l2cap = self.records[L2CAP_UUID][3:]
+        pnp = self.records[PNP_INFO_UUID][3:]
+        self.records[L2CAP_UUID] = (
+            struct.pack(">BH", 0x36, len(l2cap) + len(pnp)) + l2cap + pnp
+        )
+
+    def teardown(self):
+        self.sock.close()
+
+
+@mainloop_wrap
+def device_uuids(address):
+    bus = get_dbus()
+    manager = dbus.Interface(
+        bus.get_object("org.bluez", "/"), "org.freedesktop.DBus.ObjectManager"
+    )
+
+    for ifaces in manager.GetManagedObjects().values():
+        device = ifaces.get("org.bluez.Device1")
+        if device is not None and device["Address"].lower() == address.lower():
+            return [str(uuid) for uuid in device.get("UUIDs", [])]
+
+    return []
+
+
+@mainloop_wrap
+def bluetoothd_state_directory():
+    """State directory of the bluetoothd that owns org.bluez"""
+    bus = get_dbus()
+    bus_daemon = dbus.Interface(
+        bus.get_object("org.freedesktop.DBus", "/org/freedesktop/DBus"),
+        "org.freedesktop.DBus",
+    )
+    pid = bus_daemon.GetConnectionUnixProcessID("org.bluez")
+
+    with open(f"/proc/{pid}/environ", "rb") as f:
+        env = dict(var.split(b"=", 1) for var in f.read().split(b"\0") if b"=" in var)
+
+    # Set by the Bluetoothd plugin; src/textfile.c uses its first path
+    return env[b"STATE_DIRECTORY"].split(b":")[0].decode()
+
+
+def cached_records(address):
+    """
+    Service records in the cache file bluetoothd keeps for a device, as
+    (key, value)
+    """
+    state_dir = bluetoothd_state_directory()
+    paths = glob.glob(os.path.join(state_dir, "*", "cache", address.upper()))
+    assert len(paths) == 1, paths
+
+    cache = configparser.ConfigParser(interpolation=None)
+    cache.optionxform = str
+    cache.read(paths[0])
+
+    if not cache.has_section("ServiceRecords"):
+        return []
+
+    return list(cache["ServiceRecords"].items())
+
+
+@host_config([Agent()], [Switch2SdpServer()])
+@pytest.mark.parametrize("duplicate", [False, True], ids=["switch2", "duplicate"])
+def test_sdp_records_without_handle(hosts, duplicate):
+    host0, host1 = hosts
+
+    if duplicate:
+        host1.switch2_sdp.answer_pnp_in_l2cap_search()
+
+    host0.agent.adapter_method("StartDiscovery")
+    host0.agent.expect("org.bluez.Adapter1.StartDiscovery:reply")
+
+    wait_until(host0.agent.has_device, host1.bdaddr)
+
+    host0.agent.adapter_method("StopDiscovery")
+    host0.agent.expect("org.bluez.Adapter1.StopDiscovery:reply")
+
+    # Connecting browses the SDP records of host1; host1 offers no profile
+    # to connect, so the result of Connect itself does not matter.
+    host0.agent.device_method(host1.bdaddr, "Connect")
+
+    # All UUIDs of a browse are added at once
+    audio_source = "0000110a-0000-1000-8000-00805f9b34fb"
+    wait_until(lambda: audio_source in host0.call(device_uuids, host1.bdaddr))
+
+    uuids = host0.call(device_uuids, host1.bdaddr)
+    assert "0000110c-0000-1000-8000-00805f9b34fb" in uuids
+    assert "0000110e-0000-1000-8000-00805f9b34fb" in uuids
+    assert "00001200-0000-1000-8000-00805f9b34fb" in uuids
+
+    # bluetoothd got the PnP Information record from both searches, if
+    # duplicate, else from the second only
+    answered = host1.switch2_sdp.get_answered()
+    pnp = split_records(SWITCH2_RECORDS[PNP_INFO_UUID])
+    assert len(answered) == 2
+    assert answered[1] == pnp
+    assert (answered[0][-1:] == pnp) == duplicate
+
+    # Each record is cached once, also the PnP record received twice, under
+    # a key of the documented format
+    cached = host0.call(cached_records, host1.bdaddr)
+    for key, _ in cached:
+        assert KEY.fullmatch(key), key
+
+    expected = split_records(SWITCH2_RECORDS[L2CAP_UUID]) + pnp
+    assert sorted(record_attrs(bytes.fromhex(v)) for _, v in cached) == sorted(
+        map(record_attrs, expected)
+    )
diff --git a/test/functional/test_sdp_cache.py b/test/functional/test_sdp_cache.py
new file mode 100644
index 000000000..16e94d97f
--- /dev/null
+++ b/test/functional/test_sdp_cache.py
@@ -0,0 +1,739 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for the keys under which bluetoothd caches the SDP records of a
+BR/EDR device, using VM instances
+
+bluetoothd caches each record of a device under its ServiceRecordHandle.
+A record without that attribute (0x0000) has no handle, so bluetoothd
+chooses a key for it. These tests check that such a record keeps its key
+from one discovery to the next, that no record is cached twice or
+overwritten by another, and that no cached record is removed while the
+device is known.
+
+The records are of service classes no profile of bluetoothd handles, so
+that Device1.Connect discovers the services of a known device again: it
+only does so when it finds no service to connect.
+"""
+
+import configparser
+import glob
+import os
+import struct
+
+import dbus
+import pytest
+
+from pytest_bluezenv import (
+    host_config,
+    Agent,
+    wait_until,
+    mainloop_wrap,
+    get_dbus,
+)
+
+from .test_sdp import (
+    L2CAP_UUID,
+    PNP_INFO_UUID,
+    bluetoothd_state_directory,
+    record_attrs,
+)
+from .test_sdp_out_of_range import (
+    BASE_UUID,
+    CONNECTING,
+    SEARCH1,
+    SEARCH2,
+    ExperimentalBluetoothdRestart,
+    OutOfRangeSdpServer,
+    add_handle,
+    browse,
+    cached_records,
+    check_records,
+    device_properties,
+    find_and_trust,
+    find_device,
+    read_back,
+    record_uuid,
+    service_records,
+)
+
+pytestmark = [pytest.mark.vm]
+
+PUBLIC_BROWSE_GROUP = 0x1002
+
+# A cached value that is no SDP record
+NOT_A_RECORD = "DEADBEEF"
+
+# Records of a response that takes bluetoothd long to handle if it compares
+# every record with every other by content
+MANY_RECORDS = 10000
+
+
+def record(n, handle=None, version=None, svclass=None):
+    """
+    Attribute list of a record of service class svclass, by default
+    0x7000 + n, with the given ServiceRecordHandle, and with attribute
+    0x0200 set to version to tell versions of a record apart.
+    """
+    attrs = (
+        # ServiceClassIDList
+        bytes.fromhex("0900013503")
+        + struct.pack(">BH", 0x19, svclass or 0x7000 + n)
+        # ProtocolDescriptorList: L2CAP
+        + bytes.fromhex("09000435053503190100")
+    )
+
+    if version is not None:
+        attrs += struct.pack(">BHBH", 0x09, 0x0200, 0x09, version)
+
+    return attrs if handle is None else add_handle(attrs, handle)
+
+
+def pnp(handle=None):
+    """Attribute list of a PnP Information record"""
+    attrs = bytes.fromhex(
+        "090001350319120009020009010309020109ffff090202090001090203090001"
+        "0902042801090205090001"
+    )
+
+    return attrs if handle is None else add_handle(attrs, handle)
+
+
+# Records without ServiceRecordHandle
+A, B, C, E = (record(n) for n in (1, 2, 3, 5))
+D = pnp()
+
+
+def answers(l2cap, pnp_records=(D,)):
+    """Records host1 returns for the L2CAP and the PnP Information search"""
+    return {L2CAP_UUID: list(l2cap), PNP_INFO_UUID: list(pnp_records)}
+
+
+def all_records(records):
+    return [r for rs in records.values() for r in rs]
+
+
+def uuid_of(attr_list):
+    return record_uuid(record_attrs(attr_list))
+
+
+def cache_value(attr_list):
+    """
+    A record as bluetoothd writes it to the cache file: in a sequence with
+    an 8 bit size if the whole fits in 255 bytes, else a 16 bit one.
+    """
+    if len(attr_list) + 2 <= 0xFF:
+        header = struct.pack(">BB", 0x35, len(attr_list))
+    else:
+        header = struct.pack(">BH", 0x36, len(attr_list))
+
+    return (header + attr_list).hex().upper()
+
+
+def seed_cache(address, entries):
+    """
+    Add entries to [ServiceRecords] of the cache file of a device, as an
+    earlier bluetoothd may have left them. Returns the cached records.
+    """
+    state_dir = bluetoothd_state_directory()
+    (adapter_dir,) = glob.glob(os.path.join(state_dir, "??:??:??:??:??:??"))
+    path = os.path.join(adapter_dir, "cache", address.upper())
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    cache = configparser.ConfigParser(interpolation=None)
+    cache.optionxform = str
+    cache.read(path)
+
+    if not cache.has_section("ServiceRecords"):
+        cache.add_section("ServiceRecords")
+
+    for key, value in entries.items():
+        cache["ServiceRecords"][key] = value
+
+    with open(path, "w") as f:
+        cache.write(f, space_around_delimiters=False)
+
+    return cached_records(address)
+
+
+def check_cache(hosts, expected, others=None):
+    """
+    Check that host0 caches exactly the expected records of host1, each
+    once, under a key of the documented format, those with a
+    ServiceRecordHandle under it, and besides them exactly the entries of
+    others, by key. Returns the key of each record, by record_attrs().
+    """
+    host0, host1 = hosts
+    others = others or {}
+    cached = host0.call(cached_records, host1.bdaddr)
+
+    assert {key: value for key, value in cached if key in others} == others
+
+    return check_records([e for e in cached if e[0] not in others], expected)
+
+
+def check_kept(before, after, records):
+    """Check that the given records kept their key"""
+    for attrs in map(record_attrs, records):
+        assert after[attrs] == before[attrs]
+
+
+def discover(hosts, records, down_at=None):
+    """
+    Let bluetoothd on host0 discover the services of host1, which returns
+    the given records and goes down at the given point, if any.
+    """
+    host0, host1 = hosts
+    host1.sdp_peer.configure(records, down_at)
+
+    # Its UUID is only added when a discovery of a new device is complete,
+    # and for a known device Connect only fails once the discovery is done
+    done_uuid = uuid_of(all_records(records)[0])
+
+    return browse(hosts, down_at, done_uuid)
+
+
+def rediscover(hosts, first, second, down_at=None):
+    """
+    Let bluetoothd on host0 discover the services of host1 twice: host1
+    returns the records first, and then the records second, and goes down
+    at the given point of the second discovery, if any. Returns the key
+    of each record cached after the first discovery.
+    """
+    find_and_trust(hosts)
+
+    discover(hosts, first)
+    before = check_cache(hosts, all_records(first))
+
+    discover(hosts, second, down_at)
+    return before
+
+
+@mainloop_wrap
+def remove_device(address):
+    path, _ = find_device(address)
+    adapter = dbus.Interface(
+        get_dbus().get_object("org.bluez", path.rsplit("/", 1)[0]),
+        "org.bluez.Adapter1",
+    )
+    adapter.RemoveDevice(path)
+
+
+def remove_and_find_again(hosts):
+    """Remove host1 from bluetoothd on host0, and let it find host1 again"""
+    host0, host1 = hosts
+
+    host0.call(remove_device, host1.bdaddr)
+    wait_until(lambda: host0.call(device_properties, host1.bdaddr) is None)
+
+    find_and_trust(hosts)
+
+
+def learn_keys(hosts, records):
+    """
+    Let bluetoothd on host0 discover the given records of host1, and then
+    remove host1 so that it is a new device again. Returns the key each
+    record got, so that tests do not depend on how bluetoothd chooses the
+    keys of records without handle.
+    """
+    find_and_trust(hosts)
+    discover(hosts, records)
+    keys = check_cache(hosts, all_records(records))
+
+    remove_and_find_again(hosts)
+    return keys
+
+
+def cached_count(address):
+    return len(cached_records(address))
+
+
+def key_handle(keys, attr_list):
+    """The cache key of a record, as a handle value"""
+    return int(keys[record_attrs(attr_list)], 16)
+
+
+def in_memory(hosts):
+    """
+    Records bluetoothd on host0 has in memory for host1, as sorted
+    record_attrs(). host1 connects to host0 for that, which does not make
+    host0 discover its services again.
+    """
+    host0, host1 = hosts
+    steps = host1.sdp_peer.get_steps()
+
+    host1.sdp_peer.connect(host0.bdaddr)
+    wait_until(lambda: host0.call(device_properties, host1.bdaddr)["Connected"])
+
+    records = host0.call(service_records, host1.bdaddr)
+    assert host1.sdp_peer.get_steps() == steps
+
+    return sorted(map(record_attrs, records))
+
+
+config = host_config([Agent()], [OutOfRangeSdpServer()])
+
+# With Device1.GetServiceRecords
+experimental_config = host_config(
+    [ExperimentalBluetoothdRestart(), Agent()], [OutOfRangeSdpServer()]
+)
+
+
+#
+# Records without ServiceRecordHandle
+#
+
+
+@config
+def test_sdp_cache_same_record_twice(hosts):
+    """The same record twice in one response is cached once"""
+    find_and_trust(hosts)
+
+    discover(hosts, answers([A, A, C]))
+
+    check_cache(hosts, [A, C, D])
+
+
+@experimental_config
+def test_sdp_cache_in_memory_after_discovery(hosts):
+    """
+    Right after a discovery, bluetoothd has each record of it in memory
+    once.
+    """
+    find_and_trust(hosts)
+
+    discover(hosts, answers([A, B, C]))
+
+    assert in_memory(hosts) == sorted(map(record_attrs, [A, B, C, D]))
+
+
+@experimental_config
+def test_sdp_cache_in_memory_after_rediscovery(hosts):
+    """
+    Right after a discovery of a known device, bluetoothd has in memory
+    each record of that discovery once, while the cache also keeps the
+    record host1 stopped returning.
+    """
+    rediscover(hosts, answers([A, B, C]), answers([A, C]))
+
+    assert in_memory(hosts) == sorted(map(record_attrs, [A, C, D]))
+    check_cache(hosts, [A, B, C, D])
+
+
+@config
+def test_sdp_cache_same_records(hosts):
+    """The same records discovered again keep their key"""
+    before = rediscover(hosts, answers([A, B, C]), answers([A, B, C]))
+
+    after = check_cache(hosts, [A, B, C, D])
+    assert after == before
+
+
+@config
+def test_sdp_cache_records_in_other_order(hosts):
+    """Records returned in another order keep their key"""
+    before = rediscover(hosts, answers([A, B, C]), answers([C, A, B]))
+
+    after = check_cache(hosts, [A, B, C, D])
+    assert after == before
+
+
+@config
+def test_sdp_cache_record_in_both_searches_again(hosts):
+    """
+    A record returned by both searches of a discovery of a known device is
+    cached once, and keeps its key.
+    """
+    _, host1 = hosts
+    before = rediscover(hosts, answers([A, B, C]), answers([A, B, C, D]))
+
+    # host1 sent D in its response to both searches
+    assert host1.sdp_peer.get_answered() == [[A, B, C, D], [D]]
+
+    after = check_cache(hosts, [A, B, C, D])
+    assert after == before
+
+
+@config
+def test_sdp_cache_fewer_records(hosts):
+    """
+    A record host1 stops returning stays cached, as bluetoothd keeps the
+    records with a handle it no longer finds. The others keep their key.
+    """
+    before = rediscover(hosts, answers([A, B, C]), answers([A, C]))
+
+    after = check_cache(hosts, [A, B, C, D])
+    assert after == before
+
+
+@experimental_config
+def test_sdp_cache_changed_record_read_back(hosts):
+    """
+    After a restart, bluetoothd reads both versions of a changed record
+    back, the old one first: it was cached first, and a lookup by UUID
+    finds the first record of that UUID.
+    """
+    C2 = record(3, version=2)
+    rediscover(hosts, answers([A, B, C]), answers([A, B, C2]))
+
+    records = read_back(hosts, ordered=True)
+    assert sorted(records) == sorted(map(record_attrs, [A, B, C, C2, D]))
+    assert records.index(record_attrs(C)) < records.index(record_attrs(C2))
+
+
+@config
+def test_sdp_cache_changed_record_every_discovery(hosts):
+    """
+    A record that host1 returns changed at every discovery adds a cached
+    record each time, as none is removed, and every record cached before
+    keeps its key.
+    """
+    versions = [C] + [record(3, version=v) for v in (2, 3, 4)]
+
+    find_and_trust(hosts)
+    discover(hosts, answers([A, B, C]))
+    cached = [A, B, C, D]
+    before = check_cache(hosts, cached)
+
+    for version in versions[1:]:
+        discover(hosts, answers([A, B, version]))
+        after = check_cache(hosts, cached + [version])
+        check_kept(before, after, cached)
+
+        cached.append(version)
+        before = after
+
+
+@config
+@pytest.mark.parametrize("first", [False, True], ids=["added-last", "added-first"])
+def test_sdp_cache_added_record(hosts, first):
+    """A record host1 returns in addition does not take the key of another"""
+    l2cap = [E, A, B, C] if first else [A, B, C, E]
+    before = rediscover(hosts, answers([A, B, C]), answers(l2cap))
+
+    after = check_cache(hosts, [A, B, C, D, E])
+    check_kept(before, after, [A, B, C, D])
+
+
+@config
+@pytest.mark.parametrize("first", [False, True], ids=["added-last", "added-first"])
+def test_sdp_cache_added_record_down_before_second_response(hosts, first):
+    """
+    host1 returns one more record in its first search, and goes out of
+    range before the response to the second: the record of the second
+    search that bluetoothd did not get again stays cached.
+    """
+    l2cap = [E, A, B, C] if first else [A, B, C, E]
+    before = rediscover(hosts, answers([A, B, C]), answers(l2cap), SEARCH2)
+
+    after = check_cache(hosts, [A, B, C, D, E])
+    check_kept(before, after, [A, B, C, D])
+
+
+@config
+def test_sdp_cache_written_without_fix(hosts):
+    """
+    bluetoothd without support for records without handle cached one of
+    them only, under 0xFFFFFFFF. That record keeps its key and is not
+    cached twice.
+    """
+    host0, host1 = hosts
+    find_and_trust(hosts)
+
+    seeded = host0.call(seed_cache, host1.bdaddr, {"0xFFFFFFFF": cache_value(B)})
+    assert seeded == [("0xFFFFFFFF", cache_value(B))]
+
+    discover(hosts, answers([A, B, C]))
+
+    keys = check_cache(hosts, [A, B, C, D])
+    assert keys[record_attrs(B)] == "0xFFFFFFFF"
+
+
+@config
+@pytest.mark.parametrize(
+    "key, value",
+    [
+        ("0xFFFFFFFF", NOT_A_RECORD),
+        ("0xFFFFFFFE", NOT_A_RECORD),
+        ("0xFFFFFFFF", ""),
+        ("0xFFFFFFFF", "not hex"),
+    ],
+    ids=["first-key", "second-key", "empty", "not-hex"],
+)
+def test_sdp_cache_value_no_record(hosts, key, value):
+    """
+    A cache entry that is no record is left alone by the records without
+    handle.
+    """
+    host0, host1 = hosts
+    find_and_trust(hosts)
+
+    seeded = host0.call(seed_cache, host1.bdaddr, {key: value})
+    assert seeded == [(key, value)]
+
+    discover(hosts, answers([A, B, C]))
+
+    check_cache(hosts, [A, B, C, D], others={key: value})
+
+
+@experimental_config
+def test_sdp_cache_read_back_after_restart(hosts):
+    """
+    After a restart, bluetoothd reads each cached record back once, also
+    after host1 stopped returning one of them.
+    """
+    rediscover(hosts, answers([A, B, C]), answers([A, C]))
+
+    assert read_back(hosts) == sorted(map(record_attrs, [A, B, C, D]))
+
+
+#
+# Records with and without ServiceRecordHandle from one device
+#
+
+
+@config
+@pytest.mark.parametrize("position", [0, 1, 2], ids=["first", "middle", "last"])
+def test_sdp_cache_handle_equal_to_key_same_search(hosts, position):
+    """
+    A record with a handle equal to the key that bluetoothd gives a record
+    without handle of the same search, C: all are cached, the one with a
+    handle under it. Coming last, it is found after C got that key.
+    """
+    keys = learn_keys(hosts, answers([A, C]))
+
+    R = record(4, handle=key_handle(keys, C))
+    l2cap = [A, C]
+    l2cap.insert(position, R)
+    discover(hosts, answers(l2cap))
+
+    check_cache(hosts, [A, R, C, D])
+
+
+@config
+@pytest.mark.parametrize("target", [0, 1], ids=["key-of-first", "key-of-second"])
+def test_sdp_cache_handle_equal_to_key_later_search(hosts, target):
+    """
+    A record with a handle equal to the key a record without handle got in
+    the first search comes in the second search.
+    """
+    keys = learn_keys(hosts, answers([A, C], ()))
+
+    R = pnp(handle=key_handle(keys, [A, C][target]))
+    discover(hosts, answers([A, C], [R]))
+
+    check_cache(hosts, [A, C, R])
+
+
+@config
+@pytest.mark.parametrize(
+    "target, l2cap, down_at",
+    [
+        ("C", "ABCR", None),
+        ("C", "ABCR", SEARCH2),
+        ("D", "ABCR", SEARCH2),
+        ("D", "RABC", SEARCH2),
+        ("B", "ACR", None),
+    ],
+    ids=[
+        "key-of-c-complete",
+        "key-of-c-down",
+        "key-of-d-down",
+        "key-of-d-first-down",
+        "key-of-dropped-b",
+    ],
+)
+def test_sdp_cache_handle_equal_to_key_later_discovery(hosts, target, l2cap, down_at):
+    """
+    host1 returns a new record R with a handle equal to the key of a cached
+    record without handle, which must be moved, not overwritten: C, which
+    bluetoothd got again before R; D, which bluetoothd does not get again
+    as host1 goes out of range before the response to the second search;
+    or B, which host1 no longer returns.
+    """
+    find_and_trust(hosts)
+
+    discover(hosts, answers([A, B, C]))
+    before = check_cache(hosts, [A, B, C, D])
+
+    moved = {"B": B, "C": C, "D": D}[target]
+    R = record(4, handle=key_handle(before, moved))
+    records = {"A": A, "B": B, "C": C, "R": R}
+    discover(hosts, answers([records[r] for r in l2cap]), down_at)
+
+    after = check_cache(hosts, [A, B, C, D, R])
+    check_kept(before, after, [r for r in (A, B, C, D) if r != moved])
+
+
+@config
+@pytest.mark.parametrize("down_at", [None, SEARCH2], ids=["dropped", "down"])
+def test_sdp_cache_key_equal_to_cached_handle(hosts, down_at):
+    """
+    A new record without handle does not take the key of a cached record
+    with that handle, P: also when host1 no longer returns P, or goes out
+    of range before the response to the search that returns it.
+    """
+    keys = learn_keys(hosts, answers([A, E], ()))
+
+    P = pnp(handle=key_handle(keys, E))
+    discover(hosts, answers([A], [P]))
+    before = check_cache(hosts, [A, P])
+
+    discover(hosts, answers([A, E], () if down_at is None else [P]), down_at)
+
+    after = check_cache(hosts, [A, E, P])
+    check_kept(before, after, [A, P])
+
+
+@config
+def test_sdp_cache_handle_0xffffffff(hosts):
+    """
+    A record with handle 0xFFFFFFFF, the value bluetoothd gives a record
+    without handle, is cached under it like any record with a handle.
+    """
+    R = record(4, handle=0xFFFFFFFF)
+    find_and_trust(hosts)
+
+    discover(hosts, answers([B, R, C]))
+
+    keys = check_cache(hosts, [B, R, C, D])
+    assert keys[record_attrs(R)] == "0xFFFFFFFF"
+
+
+@config
+def test_sdp_cache_same_handle_twice(hosts):
+    """
+    Of two different records with the handle 0xFFFFFFFF, the second is
+    dropped as a duplicate of the first, as for any handle.
+    """
+    handle = 0xFFFFFFFF
+    host0, host1 = hosts
+    R1 = record(4, handle=handle)
+    R2 = record(6, handle=handle)
+    find_and_trust(hosts)
+
+    discover(hosts, answers([R1, R2]))
+
+    check_cache(hosts, [R1, D])
+    uuids = host0.call(device_properties, host1.bdaddr)["UUIDs"]
+    assert uuid_of(R1) in uuids
+    assert uuid_of(R2) not in uuids
+
+
+@config
+def test_sdp_cache_same_handle_changed(hosts):
+    """
+    A record with the handle 0xFFFFFFFF that host1 changes is overwritten
+    under it, as for any handle.
+    """
+    handle = 0xFFFFFFFF
+    R1 = record(4, handle=handle)
+    R2 = record(4, handle=handle, version=2)
+
+    rediscover(hosts, answers([A, R1]), answers([A, R2]))
+
+    check_cache(hosts, [A, R2, D])
+
+
+@config
+@pytest.mark.parametrize("to_handles", [True, False], ids=["gains", "loses"])
+def test_sdp_cache_handles_gained_or_lost(hosts, to_handles):
+    """
+    host1 returns the same records with a handle each after it returned
+    them without, or the other way round. The records of the first
+    discovery stay cached under their keys, as records host1 stops
+    returning, next to those of the second.
+    """
+    without = answers([A, C])
+    with_handles = answers(
+        [record(1, handle=0x00010001), record(3, handle=0x00010003)],
+        [pnp(handle=0x00010004)],
+    )
+    first, second = (without, with_handles) if to_handles else (with_handles, without)
+
+    before = rediscover(hosts, first, second)
+
+    after = check_cache(hosts, all_records(first) + all_records(second))
+    check_kept(before, after, all_records(first))
+
+
+#
+# Many records
+#
+
+
+@config
+def test_sdp_cache_many_records(hosts):
+    """
+    bluetoothd does not take longer to handle a response of many records
+    without handle than one of as many records with a handle each: it is
+    busy for that time, and the device chooses the number of its records.
+    """
+    host0, host1 = hosts
+    times = {}
+
+    find_and_trust(hosts)
+
+    for with_handle in (True, False):
+        l2cap = [
+            record(1, handle=0x00010000 + v if with_handle else None, version=v)
+            for v in range(MANY_RECORDS)
+        ]
+        discover(hosts, answers(l2cap))
+
+        # All of them are different records
+        assert host0.call(cached_count, host1.bdaddr) == MANY_RECORDS + 1
+
+        # From the response to the L2CAP search to the PnP Information search
+        times[with_handle] = host1.sdp_peer.get_handling_times()[0]
+
+        if with_handle:
+            remove_and_find_again(hosts)
+
+    assert times[False] <= 2 * times[True], times
+
+
+#
+# The Public Browse Group search
+#
+
+
+def discover_public_browse_group(hosts, records):
+    """
+    Let bluetoothd on host0 discover the services of host1, which returns
+    the given records. bluetoothd only searches for the Public Browse Group
+    when the L2CAP search returns no record, and only keeps records of the
+    service class 0x1002 from it, as for the PnP Information search.
+    """
+    host0, host1 = hosts
+    host1.sdp_peer.configure(records)
+
+    host0.agent.device_method(host1.bdaddr, "Connect")
+
+    done_uuid = BASE_UUID % PUBLIC_BROWSE_GROUP
+    wait_until(
+        lambda: done_uuid in host0.call(device_properties, host1.bdaddr)["UUIDs"]
+    )
+    host0.agent.expect("org.bluez.Device1.Connect:error")
+
+    assert host1.sdp_peer.get_steps() == [CONNECTING, SEARCH1, SEARCH2, "search3"]
+
+
+@config
+@pytest.mark.parametrize("with_pnp", [False, True], ids=["alone", "after-pnp"])
+def test_sdp_cache_public_browse_group(hosts, with_pnp):
+    """
+    The records without handle of the Public Browse Group search are cached
+    once each, also when the PnP Information search returned a record:
+    bluetoothd handles the records of its last search twice.
+    """
+    X = record(6, svclass=PUBLIC_BROWSE_GROUP)
+    Y = record(7, svclass=PUBLIC_BROWSE_GROUP, version=2)
+    records = {PUBLIC_BROWSE_GROUP: [X, Y]}
+    if with_pnp:
+        records[PNP_INFO_UUID] = [D]
+
+    find_and_trust(hosts)
+    discover_public_browse_group(hosts, records)
+
+    check_cache(hosts, [X, Y] + ([D] if with_pnp else []))
diff --git a/test/functional/test_sdp_out_of_range.py b/test/functional/test_sdp_out_of_range.py
new file mode 100644
index 000000000..9c6508d91
--- /dev/null
+++ b/test/functional/test_sdp_out_of_range.py
@@ -0,0 +1,723 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for what bluetoothd keeps of a BR/EDR device that goes out of range
+while its services are being discovered over SDP, using VM instances
+
+bluetoothd on host0 browses host1 with a Service Search Attribute request
+for the L2CAP UUID and then one for the PnP Information UUID, both on the
+same L2CAP channel. It gets the records of a search when the response is
+complete, caches them right away, and adds the UUIDs of all of them to
+the device once the last search is done. host1 can go down at one of:
+
+  ``connecting``          while the SDP channel is being set up, before any
+                          request. This is the only point at which
+                          bluetoothd gets the error of the link itself,
+                          and so the only one where it matters whether
+                          host1 got out of range or was powered off: it
+                          tries again in the latter case.
+  ``search1``             after the first request, before any response.
+  ``search1-continued``   after the first part of the first response, when
+                          the rest of it is requested.
+  ``search2``             after the first response, when the second
+                          request is received.
+  ``search2-continued``   after the first part of the second response.
+  ``done``                after the last response, for reference.
+
+"""
+
+import configparser
+import glob
+import os
+import socket
+import struct
+import subprocess
+import threading
+import time
+
+import dbus
+import pytest
+
+from pytest_bluezenv import (
+    host_config,
+    Agent,
+    Bluetoothd,
+    HostPlugin,
+    find_exe,
+    run,
+    wait_until,
+    mainloop_wrap,
+    get_dbus,
+)
+
+from .test_sdp import (
+    SDP_PSM,
+    SDP_SVC_SEARCH_ATTR_REQ,
+    SDP_SVC_SEARCH_ATTR_RSP,
+    SDP_DE_SEQ,
+    SDP_DE_UUID,
+    L2CAP_UUID,
+    PNP_INFO_UUID,
+    SWITCH2_RECORDS,
+    KEY,
+    bluetoothd_state_directory,
+    de_span,
+    record_attrs,
+    split_records,
+)
+
+pytestmark = [pytest.mark.vm]
+
+SOL_L2CAP = 6
+L2CAP_CONNINFO = 0x02
+SOL_BLUETOOTH = 274
+BT_DEFER_SETUP = 7
+
+HCI_COMMAND_PKT = 0x01
+HCI_OP_DISCONNECT = 0x0406
+HCI_ERROR_CONNECTION_TIMEOUT = 0x08
+
+SDP_ATTR_RECORD_HANDLE = 0x0000
+
+# Attribute list bytes host1 sends per response, so that a response fits
+# in the default L2CAP MTU of 672
+MAX_RSP_SIZE = 600
+SDP_ATTR_SVCLASS_ID_LIST = 0x0001
+
+BASE_UUID = "0000%04x-0000-1000-8000-00805f9b34fb"
+
+CONNECTING = "connecting"
+SEARCH1 = "search1"
+SEARCH1_CONTINUED = "search1-continued"
+SEARCH2 = "search2"
+SEARCH2_CONTINUED = "search2-continued"
+DONE = "done"
+
+ERR_CREATE_SOCKET = "br-connection-create-socket"
+
+
+def record_uuid(attrs):
+    """
+    First service class UUID of the record_attrs() of a record, which is
+    the one bluetoothd adds to the UUIDs of a device.
+    """
+    dtype, items = dict(attrs)[SDP_ATTR_SVCLASS_ID_LIST]
+    assert dtype == SDP_DE_SEQ and items[0][0] == SDP_DE_UUID
+    return BASE_UUID % int.from_bytes(items[0][1], "big")
+
+
+def join_records(records):
+    attr_lists = b"".join(struct.pack(">BH", 0x36, len(r)) + r for r in records)
+
+    if len(attr_lists) > 0xFFFF:
+        return struct.pack(">BI", 0x37, len(attr_lists)) + attr_lists
+
+    return struct.pack(">BH", 0x36, len(attr_lists)) + attr_lists
+
+
+def add_handle(record, handle):
+    return struct.pack(">BHBI", 0x09, SDP_ATTR_RECORD_HANDLE, 0x0A, handle) + record
+
+
+def switch2_records():
+    """
+    Records host1 returns for each search of bluetoothd, as attribute
+    lists: those of a Nintendo Switch 2, which have no ServiceRecordHandle.
+    """
+    return {
+        uuid: split_records(SWITCH2_RECORDS[uuid])
+        for uuid in (L2CAP_UUID, PNP_INFO_UUID)
+    }
+
+
+def search_request(params):
+    """UUID16 values searched for by a request, and its continuation state"""
+    _, start, end = de_span(params, 0)
+    uuids = {
+        struct.unpack(">H", params[i + 1 : i + 3])[0]
+        for i in range(start, end - 2, 3)
+        if params[i] == 0x19
+    }
+
+    # MaximumAttributeByteCount, AttributeIDList
+    _, _, end = de_span(params, end + 2)
+
+    return uuids, params[end + 1 : end + 1 + params[end]]
+
+
+def search_attr_rsp(tid, attr_lists, cstate=b""):
+    params = (
+        struct.pack(">H", len(attr_lists)) + attr_lists + bytes([len(cstate)]) + cstate
+    )
+    return struct.pack(">BHH", SDP_SVC_SEARCH_ATTR_RSP, tid, len(params)) + params
+
+
+class OutOfRangeSdpServer(HostPlugin):
+    """
+    SDP server without bluetoothd, whose host can go out of range at a
+    given point of the service discovery of its peer.
+
+    Out of range means that the peer stops hearing from this host, so
+    that its controller reports the link as lost with Connection Timeout
+    once the link supervision timeout expires, and that it can not be
+    paged any more. btvirt has no link supervision timeout, so the
+    Disconnection Complete event of the peer is produced right away
+    instead, by disconnecting with that reason from here: btvirt passes
+    the reason of a HCI Disconnect command on to the peer as it is.
+
+    With power_off=True the host is powered off instead. The peer then
+    sees Remote Device Terminated Connection due to Power Off, for which
+    L2CAP reports ECONNRESET rather than ETIMEDOUT.
+    """
+
+    name = "sdp_peer"
+
+    def presetup(self, config):
+        try:
+            self.btmgmt = find_exe("tools", "btmgmt")
+        except FileNotFoundError as exc:
+            pytest.skip(reason=f"btmgmt: {exc!r}")
+
+    def setup(self, impl):
+        self.records = {}
+        self.down_at = None
+        self.power_off = False
+        self.is_down = threading.Event()
+        self.conn = None
+        self.out = None
+        self.steps = []
+        self.answered = []
+        self.answered_at = None
+        self.handling_times = []
+        self.lock = threading.Lock()
+
+        # Without the UUIDs an earlier bluetoothd may have left in the
+        # extended inquiry response of this host, which the peer shows
+        # for a device until its services are discovered
+        for cmd in (
+            ("clr-uuids",),
+            ("connectable", "on"),
+            ("power", "on"),
+            ("discov", "yes"),
+        ):
+            self.mgmt(*cmd)
+
+        self.sock = socket.socket(
+            socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP
+        )
+        self.sock.bind((socket.BDADDR_ANY, SDP_PSM))
+        self.sock.listen(1)
+        threading.Thread(target=self.serve, daemon=True).start()
+
+    def mgmt(self, *cmd):
+        run(
+            [self.btmgmt, "--index", "0", *cmd],
+            check=True,
+            stdin=subprocess.DEVNULL,
+        )
+
+    def configure(self, records, down_at=None, power_off=False):
+        """
+        Set the records to return for each search, and the point of the
+        next service discovery to go down at. With DONE this is left to
+        go_down(). Starts get_steps(), get_answered() and
+        get_handling_times() over.
+        """
+        self.records = records
+        self.down_at = down_at
+        self.power_off = power_off
+
+        with self.lock:
+            self.steps = []
+            self.answered = []
+            self.answered_at = None
+            self.handling_times = []
+
+        # Leave the L2CAP Connection Request of the peer pending
+        self.sock.setsockopt(SOL_BLUETOOTH, BT_DEFER_SETUP, down_at == CONNECTING)
+
+    def step(self, name):
+        with self.lock:
+            self.steps.append(name)
+
+    def get_steps(self):
+        """Points reached so far, and "down" once gone down"""
+        with self.lock:
+            return list(self.steps)
+
+    def sent(self, records):
+        with self.lock:
+            self.answered.append(list(records))
+            self.answered_at = time.monotonic()
+
+    def searched(self):
+        """Note how long the peer took from the last response to a request"""
+        with self.lock:
+            if self.answered_at is not None:
+                self.handling_times.append(time.monotonic() - self.answered_at)
+                self.answered_at = None
+
+    def get_handling_times(self):
+        """
+        Seconds the peer took from each response sent in full to its next
+        search, which is the time it took to handle the records of it
+        """
+        with self.lock:
+            return list(self.handling_times)
+
+    def get_answered(self):
+        """Records of each response sent in full, as attribute lists"""
+        with self.lock:
+            return list(self.answered)
+
+    def get_down(self):
+        return self.is_down.is_set()
+
+    def go_down(self):
+        """Go out of range, or power off"""
+        with self.lock:
+            conn = self.conn
+
+        if self.power_off:
+            self.mgmt("power", "off")
+        else:
+            # Stop page scan first, so that there is no moment in which
+            # the link is lost but the peer could connect again
+            self.mgmt("connectable", "off")
+
+            try:
+                handle = struct.unpack(
+                    "<H3s", conn.getsockopt(SOL_L2CAP, L2CAP_CONNINFO, 5)
+                )[0]
+            except (AttributeError, OSError):
+                # No link left to lose
+                handle = None
+
+            if handle is not None:
+                with socket.socket(
+                    socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI
+                ) as hci:
+                    hci.bind((0,))
+                    hci.send(
+                        struct.pack(
+                            "<BHBHB",
+                            HCI_COMMAND_PKT,
+                            HCI_OP_DISCONNECT,
+                            3,
+                            handle,
+                            HCI_ERROR_CONNECTION_TIMEOUT,
+                        )
+                    )
+
+            self.mgmt("power", "off")
+
+        self.step("down")
+        self.is_down.set()
+
+    def at(self, point):
+        """Note that a point was reached, go down if it is the one set"""
+        self.step(point)
+
+        if self.down_at != point:
+            return False
+
+        self.go_down()
+        return True
+
+    def serve(self):
+        while True:
+            try:
+                conn, _ = self.sock.accept()
+            except OSError:
+                return
+
+            with self.lock:
+                self.conn = conn
+
+            try:
+                self.answer(conn)
+            except Exception as exc:
+                self.step(f"error: {exc!r}")
+
+            # The connection is left open; closing it would tell the peer
+
+    def answer(self, conn):
+        search = 0
+        rest = b""
+        pending = []
+
+        if self.at(CONNECTING):
+            return
+
+        while True:
+            try:
+                pdu = conn.recv(1024)
+            except OSError:
+                return
+
+            if not pdu:
+                return
+
+            if len(pdu) < 6 or pdu[0] != SDP_SVC_SEARCH_ATTR_REQ:
+                continue
+
+            tid = struct.unpack(">H", pdu[1:3])[0]
+            uuids, cstate = search_request(pdu[5:])
+
+            if cstate:
+                point = f"search{search}-continued"
+                if self.down_at == point and self.at(point):
+                    return
+
+                part, rest = rest[:MAX_RSP_SIZE], rest[MAX_RSP_SIZE:]
+                conn.send(search_attr_rsp(tid, part, b"\x01" if rest else b""))
+                if not rest:
+                    self.sent(pending)
+                continue
+
+            self.searched()
+
+            search += 1
+            if self.at(f"search{search}"):
+                return
+
+            records = []
+            attr_lists = b"\x35\x00"
+            for uuid in uuids:
+                if uuid in self.records:
+                    records = self.records[uuid]
+                    attr_lists = join_records(records)
+
+            if self.down_at == f"search{search}-continued":
+                # Return the first half only, and ask to be asked for more
+                half = len(attr_lists) // 2
+                rest = attr_lists[half:]
+                pending = records
+                conn.send(search_attr_rsp(tid, attr_lists[:half], b"\x01"))
+            else:
+                # In parts, if it does not fit in one response
+                part, rest = attr_lists[:MAX_RSP_SIZE], attr_lists[MAX_RSP_SIZE:]
+                pending = records
+                conn.send(search_attr_rsp(tid, part, b"\x01" if rest else b""))
+                if not rest:
+                    self.sent(records)
+
+    def come_back(self):
+        """
+        Come back in range, or power on again, without going down at any
+        point of a service discovery. Starts get_steps() over.
+        """
+        self.configure(self.records)
+        self.mgmt("power", "on")
+        self.mgmt("connectable", "on")
+
+    def connect(self, address):
+        """Bring up an ACL link by connecting to the SDP server of a peer"""
+        self.out = socket.socket(
+            socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP
+        )
+        self.out.connect((address, SDP_PSM))
+
+    def teardown(self):
+        self.sock.close()
+
+        if self.out is not None:
+            self.out.close()
+
+        with self.lock:
+            if self.conn is not None:
+                self.conn.close()
+
+
+class BluetoothdRestart(HostPlugin):
+    """
+    Restarts the bluetoothd of the Bluetoothd host plugin, which keeps
+    its state directory.
+    """
+
+    name = "bluetoothd_restart"
+    depends = [Bluetoothd()]
+
+    def setup(self, impl):
+        self.impl = impl
+
+    @mainloop_wrap
+    def restart(self):
+        bluetoothd = self.impl.plugins["bluetoothd"]
+        agent = self.impl.plugins.get("agent")
+        bus = get_dbus()
+
+        old = bluetoothd.job
+        old.terminate()
+        old.wait()
+
+        bus_daemon = dbus.Interface(
+            bus.get_object("org.freedesktop.DBus", "/org/freedesktop/DBus"),
+            "org.freedesktop.DBus",
+        )
+        wait_until(lambda: not bus_daemon.NameHasOwner("org.bluez"))
+
+        state_dir = os.path.join(bluetoothd.tmpdir.name, "state")
+        bluetoothd.job = subprocess.Popen(
+            old.args,
+            env=dict(os.environ, STATE_DIRECTORY=state_dir),
+            stdin=subprocess.DEVNULL,
+            stdout=bluetoothd.log_stream.stream,
+            stderr=subprocess.STDOUT,
+        )
+
+        def powered():
+            try:
+                adapter = dbus.Interface(
+                    bus.get_object("org.bluez", "/org/bluez/hci0"),
+                    "org.freedesktop.DBus.Properties",
+                )
+                return bool(adapter.Get("org.bluez.Adapter1", "Powered"))
+            except dbus.DBusException:
+                return False
+
+        wait_until(powered)
+
+        if agent is not None:
+            # Expected to be registered when the Agent plugin is unloaded
+            agent.manager = dbus.Interface(
+                agent.bus.get_object("org.bluez", "/org/bluez"),
+                "org.bluez.AgentManager1",
+            )
+            agent.manager.RegisterAgent(agent.path, agent.capability)
+
+
+class ExperimentalBluetoothdRestart(BluetoothdRestart):
+    """
+    BluetoothdRestart for a bluetoothd with experimental interfaces, for
+    Device1.GetServiceRecords. Has to come before Agent, so that Agent
+    does not add a Bluetoothd of its own.
+    """
+
+    depends = [Bluetoothd(conf="[General]\nExperimental = true\n")]
+
+
+def find_device(address):
+    """Path and properties of the device object of bluetoothd, if any"""
+    bus = get_dbus()
+    manager = dbus.Interface(
+        bus.get_object("org.bluez", "/"), "org.freedesktop.DBus.ObjectManager"
+    )
+
+    for path, ifaces in manager.GetManagedObjects().items():
+        device = ifaces.get("org.bluez.Device1")
+        if device is not None and device["Address"].lower() == address.lower():
+            return path, device
+
+    return None, None
+
+
+@mainloop_wrap
+def device_properties(address):
+    """Properties of the device object of bluetoothd, None without one"""
+    _, device = find_device(address)
+    if device is None:
+        return None
+
+    return {
+        "UUIDs": sorted(str(uuid) for uuid in device.get("UUIDs", [])),
+        "Connected": bool(device["Connected"]),
+    }
+
+
+@mainloop_wrap
+def service_records(address):
+    """Records bluetoothd returns from Device1.GetServiceRecords"""
+    path, _ = find_device(address)
+    device = dbus.Interface(
+        get_dbus().get_object("org.bluez", path), "org.bluez.Device1"
+    )
+
+    return [bytes(r) for r in device.GetServiceRecords()]
+
+
+def read_back(hosts, ordered=False):
+    """
+    Restart bluetoothd on host0 and return the records it then reads back
+    from its cache for host1, as sorted record_attrs(), or with ordered in
+    the order bluetoothd has them, which is the order of the cache file.
+    host1 comes back and connects to host0 for that, which does not make
+    host0 discover its services again.
+    """
+    host0, host1 = hosts
+
+    host0.bluetoothd_restart.restart()
+    wait_until(lambda: host0.call(device_properties, host1.bdaddr) is not None)
+
+    host1.sdp_peer.come_back()
+    host1.sdp_peer.connect(host0.bdaddr)
+    wait_until(lambda: host0.call(device_properties, host1.bdaddr)["Connected"])
+
+    records = host0.call(service_records, host1.bdaddr)
+    assert host1.sdp_peer.get_steps() == []
+
+    records = list(map(record_attrs, records))
+    return records if ordered else sorted(records)
+
+
+@mainloop_wrap
+def trust_device(address):
+    path, _ = find_device(address)
+    props = dbus.Interface(
+        get_dbus().get_object("org.bluez", path), "org.freedesktop.DBus.Properties"
+    )
+    props.Set("org.bluez.Device1", "Trusted", dbus.Boolean(True))
+
+
+def cached_records(address):
+    """
+    Service records in the cache file bluetoothd keeps for a device, as
+    list of (key, record). Empty if there is no cache file.
+    """
+    state_dir = bluetoothd_state_directory()
+    paths = glob.glob(os.path.join(state_dir, "*", "cache", address.upper()))
+    assert len(paths) <= 1, paths
+
+    cache = configparser.ConfigParser(interpolation=None)
+    cache.optionxform = str
+    cache.read(paths)
+
+    if not cache.has_section("ServiceRecords"):
+        return []
+
+    return list(cache["ServiceRecords"].items())
+
+
+def find_and_trust(hosts):
+    """Let bluetoothd on host0 find host1, and keep it"""
+    host0, host1 = hosts
+
+    host0.agent.adapter_method("StartDiscovery")
+    host0.agent.expect("org.bluez.Adapter1.StartDiscovery:reply")
+
+    wait_until(host0.agent.has_device, host1.bdaddr)
+
+    host0.agent.adapter_method("StopDiscovery")
+    host0.agent.expect("org.bluez.Adapter1.StopDiscovery:reply")
+
+    # bluetoothd only keeps a device that is paired or trusted once its
+    # link is lost: any other is made temporary again, and is removed
+    # together with its cached records when its timer expires or when it
+    # can not be paged.
+    host0.call(trust_device, host1.bdaddr)
+
+    before = host0.call(device_properties, host1.bdaddr)
+    assert before["UUIDs"] == []
+    assert host0.call(cached_records, host1.bdaddr) == []
+
+
+def browse(hosts, down_at=None, done_uuid=None):
+    """
+    Let bluetoothd on host0 discover the services of host1. host1 goes
+    down at the given point, with DONE once host0 has the done_uuid that
+    only a complete discovery adds. Returns the error of Connect.
+    """
+    host0, host1 = hosts
+
+    # Connecting browses the SDP records of host1
+    host0.agent.device_method(host1.bdaddr, "Connect")
+
+    if down_at in (None, DONE):
+        # All UUIDs of a browse are added at once, when it is complete
+        wait_until(
+            lambda: done_uuid in host0.call(device_properties, host1.bdaddr)["UUIDs"]
+        )
+
+    if down_at == DONE:
+        host1.sdp_peer.go_down()
+
+    # host1 offers no service to connect, so Connect fails in any case
+    error = host0.agent.expect("org.bluez.Device1.Connect:error").error
+
+    if down_at is None:
+        assert host1.sdp_peer.get_steps() == [CONNECTING, SEARCH1, SEARCH2]
+
+        host0.agent.device_method(host1.bdaddr, "Disconnect")
+        host0.agent.expect(
+            (
+                "org.bluez.Device1.Disconnect:reply",
+                "org.bluez.Device1.Disconnect:error",
+            )
+        )
+    else:
+        wait_until(host1.sdp_peer.get_down)
+
+    wait_until(lambda: not host0.call(device_properties, host1.bdaddr)["Connected"])
+
+    if down_at is None:
+        pass
+    elif down_at == DONE:
+        assert host1.sdp_peer.get_steps() == [CONNECTING, SEARCH1, SEARCH2, "down"]
+    else:
+        # host1 went down where it was supposed to, and was not reached again
+        points = [CONNECTING, SEARCH1, SEARCH1_CONTINUED, SEARCH2, SEARCH2_CONTINUED]
+        expected = [
+            p
+            for p in points[: points.index(down_at) + 1]
+            if not p.endswith("-continued") or p == down_at
+        ]
+        assert host1.sdp_peer.get_steps() == expected + ["down"]
+
+    return error.get_dbus_message()
+
+
+def first_uuid(records):
+    return record_uuid(record_attrs(records[L2CAP_UUID][0]))
+
+
+def check_records(cached, records):
+    """
+    Check that the cache holds exactly the given records, each of them
+    once, under a key of the documented format, and a record with a
+    ServiceRecordHandle under it. Returns the key of each record, by
+    record_attrs().
+    """
+    keys = {}
+    for key, value in cached:
+        assert KEY.fullmatch(key), key
+
+        attrs = record_attrs(bytes.fromhex(value))
+        assert attrs not in keys, f"{keys[attrs]} and {key} hold the same record"
+        keys[attrs] = key
+
+    assert sorted(keys) == sorted(record_attrs(r) for r in records)
+
+    for attrs, key in keys.items():
+        handle = dict(attrs).get(SDP_ATTR_RECORD_HANDLE)
+        if handle is not None:
+            assert key == "0x%08X" % int.from_bytes(handle[1], "big")
+
+    return keys
+
+
+#
+# A device bluetoothd sees for the first time
+#
+
+
+@host_config([Agent()], [OutOfRangeSdpServer()])
+def test_sdp_new_without_handle_down_before_second_response(hosts):
+    """
+    host1 goes down after bluetoothd has the response to its first search
+    but not the one to its second: it caches the records of the first
+    search, but adds no UUID as the discovery did not complete.
+    """
+    host0, host1 = hosts
+    records = switch2_records()
+
+    host1.sdp_peer.configure(records, SEARCH2)
+
+    find_and_trust(hosts)
+    message = browse(hosts, SEARCH2, first_uuid(records))
+
+    props = host0.call(device_properties, host1.bdaddr)
+    assert props is not None
+
+    assert message == ERR_CREATE_SOCKET
+    assert props["UUIDs"] == []
+    check_records(host0.call(cached_records, host1.bdaddr), records[L2CAP_UUID])
-- 
2.53.0


^ permalink raw reply related	[flat|nested] 3+ messages in thread

* RE: [BlueZ,v2,1/2] device: Fix SDP records without a record handle
  2026-11-21  5:51 [PATCH BlueZ v2 1/2] device: Fix SDP records without a record handle Muxian Li
  2026-11-21  5:51 ` [PATCH BlueZ v2 2/2] test: functional: Cover SDP records without handle Muxian Li
@ 2026-11-21 11:25 ` bluez.test.bot
  1 sibling, 0 replies; 3+ messages in thread
From: bluez.test.bot @ 2026-11-21 11:25 UTC (permalink / raw)
  To: linux-bluetooth, muxianli5401

[-- Attachment #1: Type: text/plain, Size: 1021 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/series/1217926/

---Test result---

Test Summary:
CheckPatch                    PASS      0.88 seconds
GitLint                       PASS      0.41 seconds
BuildEll                      PASS      16.97 seconds
BluezMake                     PASS      238.83 seconds
MakeCheck                     PASS      13.66 seconds
MakeDistcheck                 PASS      124.53 seconds
CheckValgrind                 PASS      304.48 seconds
CheckSmatch                   PASS      241.26 seconds
bluezmakeextell               PASS      79.30 seconds
TestFunctional                PASS      1644.53 seconds
IncrementalBuild              PASS      251.98 seconds
ScanBuild                     PASS      896.41 seconds



https://github.com/bluez/bluez/pull/2863

---
Regards,
Linux Bluetooth


^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-21 11:25 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-21  5:51 [PATCH BlueZ v2 1/2] device: Fix SDP records without a record handle Muxian Li
2026-11-21  5:51 ` [PATCH BlueZ v2 2/2] test: functional: Cover SDP records without handle Muxian Li
2026-11-21 11:25 ` [BlueZ,v2,1/2] device: Fix SDP records without a record handle 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