xref: /freebsd/usr.sbin/bluetooth/bthidcontrol/sdp.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*
2  * sdp.c
3  *
4  * Copyright (c) 2004 Maksim Yevmenkin <m_evmenkin@yahoo.com>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $Id: sdp.c,v 1.3 2004/02/17 22:14:57 max Exp $
29  * $FreeBSD$
30  */
31 
32 #include <sys/queue.h>
33 #include <bluetooth.h>
34 #include <dev/usb/usb.h>
35 #include <dev/usb/usbhid.h>
36 #include <errno.h>
37 #include <sdp.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <usbhid.h>
41 #include "bthid_config.h"
42 #include "bthidcontrol.h"
43 
44 static int32_t hid_sdp_query				(bdaddr_t const *local, struct hid_device *hd, int32_t *error);
45 static int32_t hid_sdp_parse_protocol_descriptor_list	(sdp_attr_p a);
46 static int32_t hid_sdp_parse_hid_descriptor		(sdp_attr_p a);
47 static int32_t hid_sdp_parse_boolean			(sdp_attr_p a);
48 
49 static uint16_t		service = SDP_SERVICE_CLASS_HUMAN_INTERFACE_DEVICE;
50 
51 static uint32_t		attrs[] = {
52 SDP_ATTR_RANGE(	SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST,
53 		SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST),
54 SDP_ATTR_RANGE	(SDP_ATTR_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS,
55 		SDP_ATTR_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS),
56 SDP_ATTR_RANGE(	0x0205,		/* HIDReconnectInitiate */
57 		0x0206),	/* HIDDescriptorList */
58 SDP_ATTR_RANGE(	0x0209,		/* HIDBatteryPower */
59 		0x0209),
60 SDP_ATTR_RANGE(	0x020d,		/* HIDNormallyConnectable */
61 		0x020d)
62 	};
63 #define	nattrs	(sizeof(attrs)/sizeof(attrs[0]))
64 
65 static sdp_attr_t	values[8];
66 #define	nvalues	(sizeof(values)/sizeof(values[0]))
67 
68 static uint8_t		buffer[nvalues][512];
69 
70 /*
71  * Query remote device
72  */
73 
74 #undef	hid_sdp_query_exit
75 #define	hid_sdp_query_exit(e) {		\
76 	if (error != NULL)		\
77 		*error = (e);		\
78 	if (ss != NULL) {		\
79 		sdp_close(ss);		\
80 		ss = NULL;		\
81 	}				\
82 	return (((e) == 0)? 0 : -1);	\
83 }
84 
85 static int32_t
86 hid_sdp_query(bdaddr_t const *local, struct hid_device *hd, int32_t *error)
87 {
88 	void	*ss = NULL;
89 	uint8_t	*hid_descriptor = NULL;
90 	int32_t	 i, control_psm = -1, interrupt_psm = -1,
91 		 reconnect_initiate = -1,
92 		 normally_connectable = 0, battery_power = 0,
93 		 hid_descriptor_length = -1;
94 
95 	if (local == NULL)
96 		local = NG_HCI_BDADDR_ANY;
97 	if (hd == NULL)
98 		hid_sdp_query_exit(EINVAL);
99 
100 	for (i = 0; i < nvalues; i ++) {
101 		values[i].flags = SDP_ATTR_INVALID;
102 		values[i].attr = 0;
103 		values[i].vlen = sizeof(buffer[i]);
104 		values[i].value = buffer[i];
105 	}
106 
107 	if ((ss = sdp_open(local, &hd->bdaddr)) == NULL)
108 		hid_sdp_query_exit(ENOMEM);
109 	if (sdp_error(ss) != 0)
110 		hid_sdp_query_exit(sdp_error(ss));
111 	if (sdp_search(ss, 1, &service, nattrs, attrs, nvalues, values) != 0)
112                 hid_sdp_query_exit(sdp_error(ss));
113 
114         sdp_close(ss);
115         ss = NULL;
116 
117 	for (i = 0; i < nvalues; i ++) {
118 		if (values[i].flags != SDP_ATTR_OK)
119 			continue;
120 
121 		switch (values[i].attr) {
122 		case SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST:
123 			control_psm = hid_sdp_parse_protocol_descriptor_list(&values[i]);
124 			break;
125 
126 		case SDP_ATTR_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS:
127 			interrupt_psm = hid_sdp_parse_protocol_descriptor_list(&values[i]);
128 			break;
129 
130 		case 0x0205: /* HIDReconnectInitiate */
131 			reconnect_initiate = hid_sdp_parse_boolean(&values[i]);
132 			break;
133 
134 		case 0x0206: /* HIDDescriptorList */
135 			if (hid_sdp_parse_hid_descriptor(&values[i]) == 0) {
136 				hid_descriptor = values[i].value;
137 				hid_descriptor_length = values[i].vlen;
138 			}
139 			break;
140 
141 		case 0x0209: /* HIDBatteryPower */
142 			battery_power = hid_sdp_parse_boolean(&values[i]);
143 			break;
144 
145 		case 0x020d: /* HIDNormallyConnectable */
146 			normally_connectable = hid_sdp_parse_boolean(&values[i]);
147 			break;
148 		}
149 	}
150 
151 	if (control_psm == -1 || interrupt_psm == -1 ||
152 	    reconnect_initiate == -1 || normally_connectable == -1 ||
153 	    hid_descriptor == NULL || hid_descriptor_length == -1)
154 		hid_sdp_query_exit(ENOATTR);
155 
156 	hd->control_psm = control_psm;
157 	hd->interrupt_psm = interrupt_psm;
158 	hd->reconnect_initiate = reconnect_initiate? 1 : 0;
159 	hd->battery_power = battery_power? 1 : 0;
160 	hd->normally_connectable = normally_connectable? 1 : 0;
161 	hd->desc = hid_use_report_desc(hid_descriptor, hid_descriptor_length);
162 	if (hd->desc == NULL)
163 		hid_sdp_query_exit(ENOMEM);
164 
165 	return (0);
166 }
167 
168 /*
169  * seq len				2
170  *	seq len				2
171  *		uuid value		3
172  *		uint16 value		3
173  *		seq len			2
174  *			uuid value	3
175  */
176 
177 static int32_t
178 hid_sdp_parse_protocol_descriptor_list(sdp_attr_p a)
179 {
180 	uint8_t	*ptr = a->value;
181 	uint8_t	*end = a->value + a->vlen;
182 	int32_t	 type, len, uuid, psm;
183 
184 	if (end - ptr < 15)
185 		return (-1);
186 
187 	if (a->attr == SDP_ATTR_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS) {
188 		SDP_GET8(type, ptr);
189 		switch (type) {
190 		case SDP_DATA_SEQ8:
191 			SDP_GET8(len, ptr);
192 			break;
193 
194 		case SDP_DATA_SEQ16:
195 			SDP_GET16(len, ptr);
196 			break;
197 
198 		case SDP_DATA_SEQ32:
199 			SDP_GET32(len, ptr);
200 			break;
201 
202 		default:
203 			return (-1);
204 		}
205 		if (ptr + len > end)
206 			return (-1);
207 	}
208 
209 	SDP_GET8(type, ptr);
210 	switch (type) {
211 	case SDP_DATA_SEQ8:
212 		SDP_GET8(len, ptr);
213 		break;
214 
215 	case SDP_DATA_SEQ16:
216 		SDP_GET16(len, ptr);
217 		break;
218 
219 	case SDP_DATA_SEQ32:
220 		SDP_GET32(len, ptr);
221 		break;
222 
223 	default:
224 		return (-1);
225 	}
226 	if (ptr + len > end)
227 		return (-1);
228 
229 	/* Protocol */
230 	SDP_GET8(type, ptr);
231 	switch (type) {
232 	case SDP_DATA_SEQ8:
233 		SDP_GET8(len, ptr);
234 		break;
235 
236 	case SDP_DATA_SEQ16:
237 		SDP_GET16(len, ptr);
238 		break;
239 
240 	case SDP_DATA_SEQ32:
241 		SDP_GET32(len, ptr);
242 		break;
243 
244 	default:
245 		return (-1);
246 	}
247 	if (ptr + len > end)
248 		return (-1);
249 
250 	/* UUID */
251 	if (ptr + 3 > end)
252 		return (-1);
253 	SDP_GET8(type, ptr);
254 	switch (type) {
255 	case SDP_DATA_UUID16:
256 		SDP_GET16(uuid, ptr);
257 		if (uuid != SDP_UUID_PROTOCOL_L2CAP)
258 			return (-1);
259 		break;
260 
261 	case SDP_DATA_UUID32:  /* XXX FIXME can we have 32-bit UUID */
262 	case SDP_DATA_UUID128: /* XXX FIXME can we have 128-bit UUID */
263 	default:
264 		return (-1);
265 	}
266 
267 	/* PSM */
268 	if (ptr + 3 > end)
269 		return (-1);
270 	SDP_GET8(type, ptr);
271 	if (type != SDP_DATA_UINT16)
272 		return (-1);
273 	SDP_GET16(psm, ptr);
274 
275 	return (psm);
276 }
277 
278 /*
279  * seq len			2
280  *	seq len			2
281  *		uint8 value8	2
282  * 		str value	3
283  */
284 
285 static int32_t
286 hid_sdp_parse_hid_descriptor(sdp_attr_p a)
287 {
288 	uint8_t	*ptr = a->value;
289 	uint8_t	*end = a->value + a->vlen;
290 	int32_t	 type, len, descriptor_type;
291 
292 	if (end - ptr < 9)
293 		return (-1);
294 
295 	SDP_GET8(type, ptr);
296 	switch (type) {
297 	case SDP_DATA_SEQ8:
298 		SDP_GET8(len, ptr);
299 		break;
300 
301 	case SDP_DATA_SEQ16:
302 		SDP_GET16(len, ptr);
303 		break;
304 
305 	case SDP_DATA_SEQ32:
306 		SDP_GET32(len, ptr);
307 		break;
308 
309 	default:
310 		return (-1);
311 	}
312 	if (ptr + len > end)
313 		return (-1);
314 
315 	while (ptr < end) {
316 		/* Descriptor */
317 		SDP_GET8(type, ptr);
318 		switch (type) {
319 		case SDP_DATA_SEQ8:
320 			if (ptr + 1 > end)
321 				return (-1);
322 			SDP_GET8(len, ptr);
323 			break;
324 
325 		case SDP_DATA_SEQ16:
326 			if (ptr + 2 > end)
327 				return (-1);
328 			SDP_GET16(len, ptr);
329 			break;
330 
331 		case SDP_DATA_SEQ32:
332 			if (ptr + 4 > end)
333 				return (-1);
334 			SDP_GET32(len, ptr);
335 			break;
336 
337 		default:
338 			return (-1);
339 		}
340 
341 		/* Descripor type */
342 		if (ptr + 1 > end)
343 			return (-1);
344 		SDP_GET8(type, ptr);
345 		if (type != SDP_DATA_UINT8 || ptr + 1 > end)
346 			return (-1);
347 		SDP_GET8(descriptor_type, ptr);
348 
349 		/* Descriptor value */
350 		if (ptr + 1 > end)
351 			return (-1);
352 		SDP_GET8(type, ptr);
353 		switch (type) {
354 		case SDP_DATA_STR8:
355 			if (ptr + 1 > end)
356 				return (-1);
357 			SDP_GET8(len, ptr);
358 			break;
359 
360 		case SDP_DATA_STR16:
361 			if (ptr + 2 > end)
362 				return (-1);
363 			SDP_GET16(len, ptr);
364 			break;
365 
366 		case SDP_DATA_STR32:
367 			if (ptr + 4 > end)
368 				return (-1);
369 			SDP_GET32(len, ptr);
370 			break;
371 
372 		default:
373 			return (-1);
374 		}
375 		if (ptr + len > end)
376 			return (-1);
377 
378 		if (descriptor_type == UDESC_REPORT && len > 0) {
379 			a->value = ptr;
380 			a->vlen = len;
381 
382 			return (0);
383 		}
384 
385 		ptr += len;
386 	}
387 
388 	return (-1);
389 }
390 
391 /* bool8 int8 */
392 static int32_t
393 hid_sdp_parse_boolean(sdp_attr_p a)
394 {
395 	if (a->vlen != 2 || a->value[0] != SDP_DATA_BOOL)
396 		return (-1);
397 
398 	return (a->value[1]);
399 }
400 
401 /* Perform SDP query */
402 static int32_t
403 hid_query(bdaddr_t *bdaddr, int argc, char **argv)
404 {
405 	struct hid_device	hd;
406 	int			e;
407 
408 	memcpy(&hd.bdaddr, bdaddr, sizeof(hd.bdaddr));
409 	if (hid_sdp_query(NULL, &hd, &e) < 0) {
410 		fprintf(stderr, "Could not perform SDP query on the " \
411 			"device %s. %s (%d)\n", bt_ntoa(bdaddr, NULL),
412 			strerror(e), e);
413 		return (FAILED);
414 	}
415 
416 	print_hid_device(&hd, stdout);
417 
418 	return (OK);
419 }
420 
421 struct bthid_command	sdp_commands[] =
422 {
423 {
424 "Query",
425 "Perform SDP query to the specified device and print HID configuration entry\n"\
426 "for the device. The configuration entry should be appended to the Bluetooth\n"\
427 "HID daemon configuration file and the daemon should be restarted.\n",
428 hid_query
429 },
430 { NULL, NULL, NULL }
431 };
432 
433