Home | History | Annotate | Line # | Download | only in sdpquery
print.c revision 1.2
      1 /*	$NetBSD: print.c,v 1.2 2009/07/04 16:01:15 plunky Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2009 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Iain Hibbert.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __RCSID("$NetBSD: print.c,v 1.2 2009/07/04 16:01:15 plunky Exp $");
     34 
     35 #include <ctype.h>
     36 #include <iconv.h>
     37 #include <langinfo.h>
     38 #include <sdp.h>
     39 #include <stdbool.h>
     40 #include <stdio.h>
     41 #include <stdlib.h>
     42 #include <string.h>
     43 #include <uuid.h>
     44 #include <vis.h>
     45 
     46 #include "sdpquery.h"
     47 
     48 typedef struct {
     49 	uint16_t	id;
     50 	const char *	desc;
     51 	void		(*print)(sdp_data_t *);
     52 } attr_t;
     53 
     54 typedef struct {
     55 	uint16_t	class;
     56 	const char *	desc;
     57 	attr_t *	attrs;
     58 	size_t		nattr;
     59 } service_t;
     60 
     61 typedef struct {
     62 	uint16_t	base;
     63 	const char *	codeset;
     64 } language_t;
     65 
     66 static const char *string_uuid(uuid_t *);
     67 static const char *string_vis(int, const char *, size_t);
     68 
     69 static void print_hexdump(const char *, const uint8_t *, size_t);
     70 static bool print_attribute(uint16_t, sdp_data_t *, attr_t *, int);
     71 static bool print_universal_attribute(uint16_t, sdp_data_t *);
     72 static bool print_language_attribute(uint16_t, sdp_data_t *);
     73 static bool print_service_attribute(uint16_t, sdp_data_t *);
     74 
     75 static void print_bool(sdp_data_t *);
     76 static void print_uint8x(sdp_data_t *);
     77 static void print_uint16d(sdp_data_t *);
     78 static void print_uint16x(sdp_data_t *);
     79 static void print_uint32x(sdp_data_t *);
     80 static void print_uint32d(sdp_data_t *);
     81 static void print_uuid(sdp_data_t *);
     82 static void print_uuid_list(sdp_data_t *);
     83 static void print_string(sdp_data_t *);
     84 static void print_url(sdp_data_t *);
     85 static void print_profile_version(sdp_data_t *);
     86 static void print_language_string(sdp_data_t *);
     87 
     88 static void print_service_class_id_list(sdp_data_t *);
     89 static void print_protocol_descriptor(sdp_data_t *);
     90 static void print_protocol_descriptor_list(sdp_data_t *);
     91 static void print_language_base_attribute_id_list(sdp_data_t *);
     92 static void print_service_availability(sdp_data_t *);
     93 static void print_bluetooth_profile_descriptor_list(sdp_data_t *);
     94 static void print_additional_protocol_descriptor_lists(sdp_data_t *);
     95 static void print_sds_version_number_list(sdp_data_t *);
     96 static void print_ct_network(sdp_data_t *);
     97 static void print_asrc_features(sdp_data_t *);
     98 static void print_asink_features(sdp_data_t *);
     99 static void print_avrcp_features(sdp_data_t *);
    100 static void print_supported_data_stores(sdp_data_t *);
    101 static void print_supported_formats(sdp_data_t *);
    102 static void print_hid_version(sdp_data_t *);
    103 static void print_hid_device_subclass(sdp_data_t *);
    104 static void print_hid_descriptor_list(sdp_data_t *);
    105 static void print_security_description(sdp_data_t *);
    106 static void print_hf_features(sdp_data_t *);
    107 static void print_hfag_network(sdp_data_t *);
    108 static void print_hfag_features(sdp_data_t *);
    109 static void print_net_access_type(sdp_data_t *);
    110 static void print_pnp_source(sdp_data_t *);
    111 
    112 static void print_rfcomm(sdp_data_t *);
    113 static void print_bnep(sdp_data_t *);
    114 static void print_avctp(sdp_data_t *);
    115 static void print_avdtp(sdp_data_t *);
    116 static void print_l2cap(sdp_data_t *);
    117 
    118 attr_t protocol_list[] = {
    119 	{ 0x0001, "SDP",				NULL },
    120 	{ 0x0002, "UDP",				NULL },
    121 	{ 0x0003, "RFCOMM",				print_rfcomm },
    122 	{ 0x0004, "TCP",				NULL },
    123 	{ 0x0005, "TCS_BIN",				NULL },
    124 	{ 0x0006, "TCS_AT",				NULL },
    125 	{ 0x0008, "OBEX",				NULL },
    126 	{ 0x0009, "IP",					NULL },
    127 	{ 0x000a, "FTP",				NULL },
    128 	{ 0x000c, "HTTP",				NULL },
    129 	{ 0x000e, "WSP",				NULL },
    130 	{ 0x000f, "BNEP",				print_bnep },
    131 	{ 0x0010, "UPNP",				NULL },
    132 	{ 0x0011, "HIDP",				NULL },
    133 	{ 0x0012, "HARDCOPY_CONTROL_CHANNEL",		NULL },
    134 	{ 0x0014, "HARDCOPY_DATA_CHANNEL",		NULL },
    135 	{ 0x0016, "HARDCOPY_NOTIFICATION",		NULL },
    136 	{ 0x0017, "AVCTP",				print_avctp },
    137 	{ 0x0019, "AVDTP",				print_avdtp },
    138 	{ 0x001b, "CMTP",				NULL },
    139 	{ 0x001d, "UDI_C_PLANE",			NULL },
    140 	{ 0x0100, "L2CAP",				print_l2cap },
    141 };
    142 
    143 attr_t universal_attrs[] = {
    144 	{ 0x0000, "ServiceRecordHandle",		print_uint32x },
    145 	{ 0x0001, "ServiceClassIDList",			print_service_class_id_list },
    146 	{ 0x0002, "ServiceRecordState",			print_uint32x },
    147 	{ 0x0003, "ServiceID",				print_uuid },
    148 	{ 0x0004, "ProtocolDescriptorList",		print_protocol_descriptor_list },
    149 	{ 0x0005, "BrowseGroupList",			print_uuid_list },
    150 	{ 0x0006, "LanguageBaseAttributeIDList",	print_language_base_attribute_id_list },
    151 	{ 0x0007, "ServiceInfoTimeToLive",		print_uint32d },
    152 	{ 0x0008, "ServiceAvailability",		print_service_availability },
    153 	{ 0x0009, "BluetoothProfileDescriptorList",	print_bluetooth_profile_descriptor_list },
    154 	{ 0x000a, "DocumentationURL",			print_url },
    155 	{ 0x000b, "ClientExecutableURL",		print_url },
    156 	{ 0x000c, "IconURL",				print_url },
    157 	{ 0x000d, "AdditionalProtocolDescriptorLists",	print_additional_protocol_descriptor_lists },
    158 };
    159 
    160 attr_t language_attrs[] = { /* Language Attribute Offsets */
    161 	{ 0x0000, "ServiceName",			print_language_string },
    162 	{ 0x0001, "ServiceDescription",			print_language_string },
    163 	{ 0x0002, "ProviderName",			print_language_string },
    164 };
    165 
    166 attr_t sds_attrs[] = {	/* Service Discovery Server */
    167 	{ 0x0200, "VersionNumberList",			print_sds_version_number_list },
    168 	{ 0x0201, "ServiceDatabaseState",		print_uint32x },
    169 };
    170 
    171 attr_t bgd_attrs[] = {	/* Browse Group Descriptor */
    172 	{ 0x0200, "GroupID",				print_uuid },
    173 };
    174 
    175 attr_t ct_attrs[] = { /* Cordless Telephony */
    176 	{ 0x0301, "ExternalNetwork",			print_ct_network },
    177 };
    178 
    179 attr_t asrc_attrs[] = { /* Audio Source */
    180 	{ 0x0311, "SupportedFeatures",			print_asrc_features },
    181 };
    182 
    183 attr_t asink_attrs[] = { /* Audio Sink */
    184 	{ 0x0311, "SupportedFeatures",			print_asink_features },
    185 };
    186 
    187 attr_t avrcp_attrs[] = { /* Audio Video Remote Control Profile */
    188 	{ 0x0311, "SupportedFeatures",			print_avrcp_features },
    189 };
    190 
    191 attr_t lan_attrs[] = {	/* LAN Access Using PPP */
    192 	{ 0x0200, "IPSubnet",				print_string },
    193 };
    194 
    195 attr_t dun_attrs[] = {	/* Dialup Networking */
    196 	{ 0x0305, "AudioFeedbackSupport",		print_bool },
    197 };
    198 
    199 attr_t irmc_sync_attrs[] = { /* IrMC Sync */
    200 	{ 0x0301, "SupportedDataStoresList",		print_supported_data_stores },
    201 };
    202 
    203 attr_t opush_attrs[] = { /* Object Push */
    204 	{ 0x0303, "SupportedFormatsList",		print_supported_formats },
    205 };
    206 
    207 attr_t hset_attrs[] = {	/* Headset */
    208 	{ 0x0302, "RemoteAudioVolumeControl",		print_bool },
    209 };
    210 
    211 attr_t fax_attrs[] = {	/* Fax */
    212 	{ 0x0302, "FAXClass1",				print_bool },
    213 	{ 0x0303, "FAXClass2.0",			print_bool },
    214 	{ 0x0304, "FAXClass2",				print_bool },
    215 	{ 0x0305, "AudioFeedbackSupport",		print_bool },
    216 };
    217 
    218 attr_t panu_attrs[] = {	/* Personal Area Networking User */
    219 	{ 0x030a, "SecurityDescription",		print_security_description },
    220 };
    221 
    222 attr_t nap_attrs[] = {	/* Network Access Point */
    223 	{ 0x030a, "SecurityDescription",		print_security_description },
    224 	{ 0x030b, "NetAccessType",			print_net_access_type },
    225 	{ 0x030c, "MaxNetAccessRate",			print_uint32d },
    226 	{ 0x030d, "IPv4Subnet",				print_string },
    227 	{ 0x030e, "IPv6Subnet",				print_string },
    228 };
    229 
    230 attr_t gn_attrs[] = {	/* Group Network */
    231 	{ 0x030a, "SecurityDescription",		print_security_description },
    232 	{ 0x030d, "IPv4Subnet",				print_string },
    233 	{ 0x030e, "IPv6Subnet",				print_string },
    234 };
    235 
    236 attr_t hf_attrs[] = {	/* Handsfree */
    237 	{ 0x0311, "SupportedFeatures",			print_hf_features },
    238 };
    239 
    240 attr_t hfag_attrs[] = {	/* Handsfree Audio Gateway */
    241 	{ 0x0301, "Network",				print_hfag_network },
    242 	{ 0x0311, "SupportedFeatures",			print_hfag_features },
    243 };
    244 
    245 attr_t hid_attrs[] = {	/* Human Interface Device */
    246 	{ 0x0200, "HIDDeviceReleaseNumber",		print_hid_version },
    247 	{ 0x0201, "HIDParserVersion",			print_hid_version },
    248 	{ 0x0202, "HIDDeviceSubClass",			print_hid_device_subclass },
    249 	{ 0x0203, "HIDCountryCode",			print_uint8x },
    250 	{ 0x0204, "HIDVirtualCable",			print_bool },
    251 	{ 0x0205, "HIDReconnectInitiate",		print_bool },
    252 	{ 0x0206, "HIDDescriptorList",			print_hid_descriptor_list },
    253 	{ 0x0207, "HIDLANGIDBaseList",			NULL },
    254 	{ 0x0208, "HIDSDPDisable",			print_bool },
    255 	{ 0x0209, "HIDBatteryPower",			print_bool },
    256 	{ 0x020a, "HIDRemoteWake",			print_bool },
    257 	{ 0x020b, "HIDProfileVersion",			print_profile_version },
    258 	{ 0x020c, "HIDSupervisionTimeout",		print_uint16d },
    259 	{ 0x020d, "HIDNormallyConnectable",		print_bool },
    260 	{ 0x020e, "HIDBootDevice",			print_bool },
    261 };
    262 
    263 attr_t pnp_attrs[] = {	/* Device ID */
    264 	{ 0x0200, "SpecificationID",			print_profile_version },
    265 	{ 0x0201, "VendorID",				print_uint16x },
    266 	{ 0x0202, "ProductID",				print_uint16x },
    267 	{ 0x0203, "Version",				print_hid_version },
    268 	{ 0x0204, "PrimaryRecord",			print_bool },
    269 	{ 0x0205, "VendorIDSource",			print_pnp_source },
    270 };
    271 
    272 #define A(a)	a, __arraycount(a)
    273 service_t service_list[] = {
    274 	{ 0x1000, "Service Discovery Server",		A(sds_attrs) },
    275 	{ 0x1001, "Browse Group Descriptor",		A(bgd_attrs) },
    276 	{ 0x1002, "Public Browse Root",			NULL, 0 },
    277 	{ 0x1101, "Serial Port",			NULL, 0 },
    278 	{ 0x1102, "LAN Access Using PPP",		A(lan_attrs) },
    279 	{ 0x1103, "Dialup Networking",			A(dun_attrs) },
    280 	{ 0x1104, "IrMC Sync",				A(irmc_sync_attrs) },
    281 	{ 0x1105, "Object Push",			A(opush_attrs) },
    282 	{ 0x1106, "File Transfer",			NULL, 0 },
    283 	{ 0x1107, "IrMC Sync Command",			NULL, 0 },
    284 	{ 0x1108, "Headset",				A(hset_attrs) },
    285 	{ 0x1109, "Cordless Telephony",			A(ct_attrs) },
    286 	{ 0x110a, "Audio Source",			A(asrc_attrs) },
    287 	{ 0x110b, "Audio Sink",				A(asink_attrs) },
    288 	{ 0x110c, "A/V Remote Control Target",		A(avrcp_attrs) },
    289 	{ 0x110d, "Advanced Audio Distribution",	NULL, 0 },
    290 	{ 0x110e, "A/V Remote Control",			A(avrcp_attrs) },
    291 	{ 0x110f, "Video Conferencing",			NULL, 0 },
    292 	{ 0x1110, "Intercom",				NULL, 0 },
    293 	{ 0x1111, "Fax",				A(fax_attrs) },
    294 	{ 0x1112, "Headset Audio Gateway",		NULL, 0 },
    295 	{ 0x1113, "WAP",				NULL, 0 },
    296 	{ 0x1114, "WAP Client",				NULL, 0 },
    297 	{ 0x1115, "Personal Area Networking User",	A(panu_attrs) },
    298 	{ 0x1116, "Network Access Point",		A(nap_attrs) },
    299 	{ 0x1117, "Group Network",			A(gn_attrs) },
    300 	{ 0x1118, "Direct Printing",			NULL, 0 },
    301 	{ 0x1119, "Reference Printing",			NULL, 0 },
    302 	{ 0x111a, "Imaging",				NULL, 0 },
    303 	{ 0x111b, "Imaging Responder",			NULL, 0 },
    304 	{ 0x111c, "Imaging Automatic Archive",		NULL, 0 },
    305 	{ 0x111d, "Imaging Referenced Objects",		NULL, 0 },
    306 	{ 0x111e, "Handsfree",				A(hf_attrs) },
    307 	{ 0x111f, "Handsfree Audio Gateway",		A(hfag_attrs) },
    308 	{ 0x1120, "Direct Printing Reference Objects",	NULL, 0 },
    309 	{ 0x1121, "Reflected User Interface",		NULL, 0 },
    310 	{ 0x1122, "Basic Printing",			NULL, 0 },
    311 	{ 0x1123, "Printing Status",			NULL, 0 },
    312 	{ 0x1124, "Human Interface Device",		A(hid_attrs) },
    313 	{ 0x1125, "Hardcopy Cable Replacement",		NULL, 0 },
    314 	{ 0x1126, "Hardcopy Cable Replacement Print",	NULL, 0 },
    315 	{ 0x1127, "Hardcopy Cable Replacement Scan",	NULL, 0 },
    316 	{ 0x1128, "Common ISDN Access",			NULL, 0 },
    317 	{ 0x1129, "Video Conferencing GW",		NULL, 0 },
    318 	{ 0x112a, "UDI MT",				NULL, 0 },
    319 	{ 0x112b, "UDI TA",				NULL, 0 },
    320 	{ 0x112c, "Audio/Video",			NULL, 0 },
    321 	{ 0x112d, "SIM Access",				NULL, 0 },
    322 	{ 0x1200, "PNP Information",			A(pnp_attrs) },
    323 	{ 0x1201, "Generic Networking",			NULL, 0 },
    324 	{ 0x1202, "Generic File Transfer",		NULL, 0 },
    325 	{ 0x1203, "Generic Audio",			NULL, 0 },
    326 	{ 0x1204, "Generic Telephony",			NULL, 0 },
    327 	{ 0x1205, "UPNP",				NULL, 0 },
    328 	{ 0x1206, "UPNP IP",				NULL, 0 },
    329 	{ 0x1300, "UPNP IP PAN",			NULL, 0 },
    330 	{ 0x1301, "UPNP IP LAP",			NULL, 0 },
    331 	{ 0x1302, "UPNP IP L2CAP",			NULL, 0 },
    332 };
    333 #undef A
    334 
    335 /* extracted Service Class ID List */
    336 #define MAX_SERVICES		16
    337 static size_t nservices;
    338 static uint16_t service_class[MAX_SERVICES];
    339 
    340 /* extracted Language Base Attribute ID List */
    341 #define MAX_LANGUAGES		16
    342 static int nlanguages;
    343 static language_t language[MAX_LANGUAGES];
    344 static int current;
    345 
    346 static bool
    347 sdp_get_uint8(sdp_data_t *d, uint8_t *vp)
    348 {
    349 	uintmax_t v;
    350 
    351 	if (sdp_data_type(d) != SDP_DATA_UINT8
    352 	    || !sdp_get_uint(d, &v))
    353 		return false;
    354 
    355 	*vp = (uint8_t)v;
    356 	return true;
    357 }
    358 
    359 static bool
    360 sdp_get_uint16(sdp_data_t *d, uint16_t *vp)
    361 {
    362 	uintmax_t v;
    363 
    364 	if (sdp_data_type(d) != SDP_DATA_UINT16
    365 	    || !sdp_get_uint(d, &v))
    366 		return false;
    367 
    368 	*vp = (uint16_t)v;
    369 	return true;
    370 }
    371 
    372 static bool
    373 sdp_get_uint32(sdp_data_t *d, uint32_t *vp)
    374 {
    375 	uintmax_t v;
    376 
    377 	if (sdp_data_type(d) != SDP_DATA_UINT32
    378 	    || !sdp_get_uint(d, &v))
    379 		return false;
    380 
    381 	*vp = (uint32_t)v;
    382 	return true;
    383 }
    384 
    385 void
    386 print_record(sdp_data_t *rec)
    387 {
    388 	sdp_data_t value;
    389 	uint16_t id;
    390 
    391 	nservices = 0;
    392 	nlanguages = 0;
    393 	current = -1;
    394 
    395 	while (sdp_get_attr(rec, &id, &value)) {
    396 		if (Xflag) {
    397 			printf("AttributeID 0x%04x:\n", id);
    398 			print_hexdump("     ", value.next, value.end - value.next);
    399 		} else if (Rflag) {
    400 			printf("AttributeID 0x%04x:\n", id);
    401 			sdp_data_print(&value, 4);
    402 		} else if (print_universal_attribute(id, &value)
    403 		    || print_language_attribute(id, &value)
    404 		    || print_service_attribute(id, &value)) {
    405 			if (value.next != value.end)
    406 			    printf("    [additional data ignored]\n");
    407 		} else {
    408 			printf("AttributeID 0x%04x:\n", id);
    409 			sdp_data_print(&value, 4);
    410 		}
    411 	}
    412 }
    413 
    414 static const char *
    415 string_uuid(uuid_t *uuid)
    416 {
    417 	static char buf[64];
    418 	const char *desc;
    419 	uuid_t u;
    420 	size_t i;
    421 
    422 	u = *uuid;
    423 	u.time_low = 0;
    424 	if (!uuid_equal(&u, &BLUETOOTH_BASE_UUID, NULL)) {
    425 		snprintf(buf, sizeof(buf),
    426 		    "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
    427 		    uuid->time_low, uuid->time_mid, uuid->time_hi_and_version,
    428 		    uuid->clock_seq_hi_and_reserved, uuid->clock_seq_low,
    429 		    uuid->node[0], uuid->node[1], uuid->node[2],
    430 		    uuid->node[3], uuid->node[4], uuid->node[5]);
    431 
    432 		return buf;
    433 	}
    434 
    435 	desc = NULL;
    436 	for (i = 0; i < __arraycount(service_list); i++) {
    437 		if (uuid->time_low == service_list[i].class) {
    438 			desc = service_list[i].desc;
    439 			break;
    440 		}
    441 	}
    442 
    443 	for (i = 0; i < __arraycount(protocol_list); i++) {
    444 		if (uuid->time_low == protocol_list[i].id) {
    445 			desc = protocol_list[i].desc;
    446 			break;
    447 		}
    448 	}
    449 
    450 	if (!Nflag && desc) {
    451 		snprintf(buf, sizeof(buf), "%s", desc);
    452 		return buf;
    453 	}
    454 
    455 	snprintf(buf, sizeof(buf), "%s%s(0x%*.*x)",
    456 	    (desc == NULL ? "" : desc),
    457 	    (desc == NULL ? "" : " "),
    458 	    (uuid->time_low > UINT16_MAX ? 8 : 4),
    459 	    (uuid->time_low > UINT16_MAX ? 8 : 4),
    460 	    uuid->time_low);
    461 
    462 	return buf;
    463 }
    464 
    465 static const char *
    466 string_vis(int style, const char *src, size_t len)
    467 {
    468 	static char buf[50];
    469 	char *dst = buf;
    470 
    471 	style |= VIS_NL;
    472 	while (len > 0 && (dst + 5) < (buf + sizeof(buf))) {
    473 		dst = vis(dst, src[0], style, (len > 1 ? src[1] : 0));
    474 		src++;
    475 		len--;
    476 	}
    477 
    478 	return buf;
    479 }
    480 
    481 static void
    482 print_hexdump(const char *title, const uint8_t *data, size_t len)
    483 {
    484 	int n, i;
    485 
    486 	i = 0;
    487 	n = printf("%s", title);
    488 
    489 	while (len-- > 0) {
    490 		if (++i > 8) {
    491 			printf("\n%*s", n, "");
    492 			i = 1;
    493 		}
    494 
    495 		printf(" 0x%02x", *data++);
    496 	}
    497 
    498 	printf("\n");
    499 }
    500 
    501 static bool
    502 print_attribute(uint16_t id, sdp_data_t *value, attr_t *attr, int count)
    503 {
    504 	int i;
    505 
    506 	for (i = 0; i < count; i++) {
    507 		if (id == attr[i].id) {
    508 			printf("%s", attr[i].desc);
    509 
    510 			if (Nflag) {
    511 				printf(" (");
    512 
    513 				if (current != -1)
    514 					printf("0x%04x + ", language[current].base);
    515 
    516 				printf("0x%04x)", id);
    517 			}
    518 
    519 			printf(": ");
    520 
    521 			if (attr[i].print == NULL) {
    522 				printf("\n");
    523 				sdp_data_print(value, 4);
    524 				value->next = value->end;
    525 			} else {
    526 				(attr[i].print)(value);
    527 			}
    528 
    529 			return true;
    530 		}
    531 	}
    532 
    533 	return false;
    534 }
    535 
    536 static bool
    537 print_universal_attribute(uint16_t id, sdp_data_t *value)
    538 {
    539 
    540 	return print_attribute(id, value,
    541 	    universal_attrs, __arraycount(universal_attrs));
    542 }
    543 
    544 static bool
    545 print_language_attribute(uint16_t id, sdp_data_t *value)
    546 {
    547 	bool done = false;
    548 
    549 	for (current = 0; current < nlanguages && !done; current++)
    550 		done = print_attribute(id - language[current].base, value,
    551 		    language_attrs, __arraycount(language_attrs));
    552 
    553 	current = -1;
    554 	return done;
    555 }
    556 
    557 static bool
    558 print_service_attribute(uint16_t id, sdp_data_t *value)
    559 {
    560 	size_t i, j;
    561 
    562 	for (i = 0; i < nservices; i++) {
    563 		for (j = 0; j < __arraycount(service_list); j++) {
    564 			if (service_class[i] == service_list[j].class)
    565 				return print_attribute(id, value,
    566 				    service_list[j].attrs,
    567 				    service_list[j].nattr);
    568 		}
    569 	}
    570 
    571 	return false;
    572 }
    573 
    574 static void
    575 print_bool(sdp_data_t *data)
    576 {
    577 	bool v;
    578 
    579 	if (!sdp_get_bool(data, &v))
    580 		return;
    581 
    582 	printf("%s\n", (v ? "true" : "false"));
    583 }
    584 
    585 static void
    586 print_uint8x(sdp_data_t *data)
    587 {
    588 	uint8_t v;
    589 
    590 	if (!sdp_get_uint8(data, &v))
    591 		return;
    592 
    593 	printf("0x%02x\n", v);
    594 }
    595 
    596 static void
    597 print_uint16d(sdp_data_t *data)
    598 {
    599 	uint16_t v;
    600 
    601 	if (!sdp_get_uint16(data, &v))
    602 		return;
    603 
    604 	printf("%d\n", v);
    605 }
    606 
    607 static void
    608 print_uint16x(sdp_data_t *data)
    609 {
    610 	uint16_t v;
    611 
    612 	if (!sdp_get_uint16(data, &v))
    613 		return;
    614 
    615 	printf("0x%04x\n", v);
    616 }
    617 
    618 static void
    619 print_uint32x(sdp_data_t *data)
    620 {
    621 	uint32_t v;
    622 
    623 	if (!sdp_get_uint32(data, &v))
    624 		return;
    625 
    626 	printf("0x%08x\n", v);
    627 }
    628 
    629 static void
    630 print_uint32d(sdp_data_t *data)
    631 {
    632 	uint32_t v;
    633 
    634 	if (!sdp_get_uint32(data, &v))
    635 		return;
    636 
    637 	printf("%d\n", v);
    638 }
    639 
    640 static void
    641 print_uuid(sdp_data_t *data)
    642 {
    643 	uuid_t uuid;
    644 
    645 	if (!sdp_get_uuid(data, &uuid))
    646 		return;
    647 
    648 	printf("%s\n", string_uuid(&uuid));
    649 }
    650 
    651 static void
    652 print_uuid_list(sdp_data_t *data)
    653 {
    654 	sdp_data_t seq;
    655 	uuid_t uuid;
    656 
    657 	if (!sdp_get_seq(data, &seq))
    658 		return;
    659 
    660 	printf("\n");
    661 	while (sdp_get_uuid(&seq, &uuid))
    662 		printf("    %s\n", string_uuid(&uuid));
    663 
    664 	if (seq.next != seq.end)
    665 		printf("    [additional data]\n");
    666 }
    667 
    668 static void
    669 print_string(sdp_data_t *data)
    670 {
    671 	char *str;
    672 	size_t len;
    673 
    674 	if (!sdp_get_str(data, &str, &len))
    675 		return;
    676 
    677 	printf("\"%s\"\n", string_vis(VIS_CSTYLE, str, len));
    678 }
    679 
    680 static void
    681 print_url(sdp_data_t *data)
    682 {
    683 	char *url;
    684 	size_t len;
    685 
    686 	if (!sdp_get_url(data, &url, &len))
    687 		return;
    688 
    689 	printf("\"%s\"\n", string_vis(VIS_HTTPSTYLE, url, len));
    690 }
    691 
    692 static void
    693 print_profile_version(sdp_data_t *data)
    694 {
    695 	uint16_t v;
    696 
    697 	if (!sdp_get_uint16(data, &v))
    698 		return;
    699 
    700 	printf("v%d.%d\n", (v >> 8), (v & 0xff));
    701 }
    702 
    703 /*
    704  * This should only be called through print_language_attribute() which
    705  * sets codeset of the string to be printed.
    706  */
    707 static void
    708 print_language_string(sdp_data_t *data)
    709 {
    710 	char buf[50], *dst, *src;
    711 	iconv_t ih;
    712 	size_t n, srcleft, dstleft;
    713 
    714 	if (!sdp_get_str(data, &src, &srcleft))
    715 		return;
    716 
    717 	dst = buf;
    718 	dstleft = sizeof(buf);
    719 
    720 	ih = iconv_open(nl_langinfo(CODESET), language[current].codeset);
    721 	if (ih == (iconv_t)-1) {
    722 		printf("Can't convert %s string\n", language[current].codeset);
    723 		return;
    724 	}
    725 
    726 	n = iconv(ih, (const char **)&src, &srcleft, &dst, &dstleft);
    727 
    728 	iconv_close(ih);
    729 
    730 	if (Nflag || n > 0)
    731 		printf("(%s) ", language[current].codeset);
    732 
    733 	printf("\"%.*s%s\n", (int)(sizeof(buf) - dstleft), buf,
    734 	    (srcleft > 0 ? " ..." : "\""));
    735 }
    736 
    737 static void
    738 print_service_class_id_list(sdp_data_t *data)
    739 {
    740 	sdp_data_t seq;
    741 	uuid_t uuid;
    742 
    743 	if (!sdp_get_seq(data, &seq))
    744 		return;
    745 
    746 	printf("\n");
    747 	while (sdp_get_uuid(&seq, &uuid)) {
    748 		printf("    %s\n", string_uuid(&uuid));
    749 
    750 		if (nservices < MAX_SERVICES) {
    751 			service_class[nservices] = uuid.time_low;
    752 			uuid.time_low = 0;
    753 			if (uuid_equal(&uuid, &BLUETOOTH_BASE_UUID, NULL))
    754 				nservices++;
    755 		}
    756 	}
    757 
    758 	if (seq.next != seq.end)
    759 		printf("    [additional data]\n");
    760 }
    761 
    762 static void
    763 print_protocol_descriptor(sdp_data_t *data)
    764 {
    765 	uuid_t u0, uuid;
    766 	size_t i;
    767 
    768 	if (!sdp_get_uuid(data, &uuid))
    769 		return;
    770 
    771 	u0 = uuid;
    772 	u0.time_low = 0;
    773 	if (uuid_equal(&u0, &BLUETOOTH_BASE_UUID, NULL)) {
    774 		for (i = 0; i < __arraycount(protocol_list); i++) {
    775 			if (uuid.time_low == protocol_list[i].id) {
    776 				printf("    %s", protocol_list[i].desc);
    777 
    778 				if (Nflag)
    779 					printf(" (0x%04x)", protocol_list[i].id);
    780 
    781 				if (protocol_list[i].print)
    782 					(protocol_list[i].print)(data);
    783 
    784 				if (data->next != data->end)
    785 					printf(" [additional data ignored]");
    786 
    787 				printf("\n");
    788 				return;
    789 			}
    790 		}
    791 	}
    792 
    793 	printf("    %s\n", string_uuid(&uuid));
    794 	sdp_data_print(data, 4);
    795 	data->next = data->end;
    796 }
    797 
    798 static void
    799 print_protocol_descriptor_list(sdp_data_t *data)
    800 {
    801 	sdp_data_t seq, proto;
    802 
    803 	printf("\n");
    804 	sdp_get_alt(data, data);	/* strip [optional] alt header */
    805 
    806 	while (sdp_get_seq(data, &seq))
    807 		while (sdp_get_seq(&seq, &proto))
    808 			print_protocol_descriptor(&proto);
    809 }
    810 
    811 static void
    812 print_language_base_attribute_id_list(sdp_data_t *data)
    813 {
    814 	sdp_data_t list;
    815 	uint16_t v;
    816 	const char *codeset;
    817 	char lang[2];
    818 
    819 	if (!sdp_get_seq(data, &list))
    820 		return;
    821 
    822 	printf("\n");
    823 	while (list.next < list.end) {
    824 		/*
    825 		 * ISO-639-1 natural language values are published at
    826 		 *	http://www.loc.gov/standards/iso639-2/php/code-list.php
    827 		 */
    828 		if (!sdp_get_uint16(&list, &v))
    829 			break;
    830 
    831 		be16enc(lang, v);
    832 		if (!islower((int)lang[0]) || !islower((int)lang[1]))
    833 			break;
    834 
    835 		/*
    836 		 * MIBenum values are published at
    837 		 *	http://www.iana.org/assignments/character-sets
    838 		 */
    839 		if (!sdp_get_uint16(&list, &v))
    840 			break;
    841 
    842 		switch(v) {
    843 		case 3:		codeset = "US-ASCII";		break;
    844 		case 4:		codeset = "ISO-8859-1";		break;
    845 		case 5:		codeset = "ISO-8859-2";		break;
    846 		case 106:	codeset = "UTF-8";		break;
    847 		case 1013:	codeset = "UTF-16BE";		break;
    848 		case 1014:	codeset = "UTF-16LE";		break;
    849 		default:	codeset = "Unknown";		break;
    850 		}
    851 
    852 		if (!sdp_get_uint16(&list, &v))
    853 			break;
    854 
    855 		printf("    %.2s.%s base 0x%04x\n", lang, codeset, v);
    856 
    857 		if (nlanguages < MAX_LANGUAGES) {
    858 			language[nlanguages].base = v;
    859 			language[nlanguages].codeset = codeset;
    860 			nlanguages++;
    861 		}
    862 	}
    863 
    864 	if (list.next != list.end)
    865 		printf("    [additional data]\n");
    866 }
    867 
    868 static void
    869 print_service_availability(sdp_data_t *data)
    870 {
    871 	uint8_t v;
    872 
    873 	if (!sdp_get_uint8(data, &v))
    874 		return;
    875 
    876 	printf("%d/%d\n", v, UINT8_MAX);
    877 }
    878 
    879 static void
    880 print_bluetooth_profile_descriptor_list(sdp_data_t *data)
    881 {
    882 	sdp_data_t seq, profile;
    883 	uuid_t uuid;
    884 	uint16_t v;
    885 
    886 	if (!sdp_get_seq(data, &seq))
    887 		return;
    888 
    889 	printf("\n");
    890 	while (seq.next < seq.end) {
    891 		if (!sdp_get_seq(&seq, &profile)
    892 		    || !sdp_get_uuid(&profile, &uuid)
    893 		    || !sdp_get_uint16(&profile, &v))
    894 			break;
    895 
    896 		printf("    %s, v%d.%d", string_uuid(&uuid),
    897 		    (v >> 8), (v & 0xff));
    898 
    899 		if (profile.next != profile.end)
    900 			printf(" [additional profile data]");
    901 
    902 		printf("\n");
    903 	}
    904 
    905 	if (seq.next != seq.end)
    906 		printf("    [additional data]\n");
    907 }
    908 
    909 static void
    910 print_additional_protocol_descriptor_lists(sdp_data_t *data)
    911 {
    912 	sdp_data_t seq, stack, proto;
    913 
    914 	printf("\n");
    915 	sdp_get_seq(data, &seq);
    916 
    917 	while (sdp_get_seq(&seq, &stack))
    918 		while (sdp_get_seq(&stack, &proto))
    919 			print_protocol_descriptor(&proto);
    920 
    921 	if (seq.next != seq.end)
    922 		printf("    [additional data]\n");
    923 }
    924 
    925 static void
    926 print_sds_version_number_list(sdp_data_t *data)
    927 {
    928 	sdp_data_t list;
    929 	const char *sep;
    930 	uint16_t v;
    931 
    932 	if (!sdp_get_seq(data, &list))
    933 		return;
    934 
    935 	sep = "";
    936 	while (sdp_get_uint16(&list, &v)) {
    937 		printf("%sv%d.%d", sep, (v >> 8), (v & 0xff));
    938 		sep = ", ";
    939 	}
    940 
    941 	if (list.next != list.end)
    942 		printf(" [additional data]");
    943 
    944 	printf("\n");
    945 }
    946 
    947 static void
    948 print_ct_network(sdp_data_t *data)
    949 {
    950 	uint8_t v;
    951 
    952 	if (!sdp_get_uint8(data, &v))
    953 		return;
    954 
    955 	switch (v) {
    956 	case 0x01:	printf("PSTN");			break;
    957 	case 0x02:	printf("ISDN");			break;
    958 	case 0x03:	printf("GSM");			break;
    959 	case 0x04:	printf("CDMA");			break;
    960 	case 0x05:	printf("Analogue Cellular");	break;
    961 	case 0x06:	printf("Packet Switched");	break;
    962 	case 0x07:	printf("Other");		break;
    963 	default:	printf("0x%02x", v);		break;
    964 	}
    965 
    966 	printf("\n");
    967 }
    968 
    969 static void
    970 print_asrc_features(sdp_data_t *data)
    971 {
    972 	uint16_t v;
    973 
    974 	if (!sdp_get_uint16(data, &v))
    975 		return;
    976 
    977 	if (Nflag)
    978 		printf("(0x%04x)", v);
    979 
    980 	printf("\n");
    981 	if (v & (1<<0))	printf("    Player\n");
    982 	if (v & (1<<1))	printf("    Microphone\n");
    983 	if (v & (1<<2))	printf("    Tuner\n");
    984 	if (v & (1<<3))	printf("    Mixer\n");
    985 }
    986 
    987 static void
    988 print_asink_features(sdp_data_t *data)
    989 {
    990 	uint16_t v;
    991 
    992 	if (!sdp_get_uint16(data, &v))
    993 		return;
    994 
    995 	if (Nflag)
    996 		printf("(0x%04x)", v);
    997 
    998 	printf("\n");
    999 	if (v & (1<<0))	printf("    Headphone\n");
   1000 	if (v & (1<<1))	printf("    Speaker\n");
   1001 	if (v & (1<<2))	printf("    Recorder\n");
   1002 	if (v & (1<<3))	printf("    Amplifier\n");
   1003 }
   1004 
   1005 static void
   1006 print_avrcp_features(sdp_data_t *data)
   1007 {
   1008 	uint16_t v;
   1009 
   1010 	if (!sdp_get_uint16(data, &v))
   1011 		return;
   1012 
   1013 	if (Nflag)
   1014 		printf("(0x%04x)", v);
   1015 
   1016 	printf("\n");
   1017 	if (v & (1<<0))	printf("    Category 1\n");
   1018 	if (v & (1<<1))	printf("    Category 2\n");
   1019 	if (v & (1<<2))	printf("    Category 3\n");
   1020 	if (v & (1<<3))	printf("    Category 4\n");
   1021 }
   1022 
   1023 static void
   1024 print_supported_data_stores(sdp_data_t *data)
   1025 {
   1026 	sdp_data_t list;
   1027 	const char *sep;
   1028 	uint8_t v;
   1029 
   1030 	if (!sdp_get_seq(data, &list))
   1031 		return;
   1032 
   1033 	sep = "\n    ";
   1034 	while (sdp_get_uint8(&list, &v)) {
   1035 		printf(sep);
   1036 		sep = ", ";
   1037 
   1038 		switch(v) {
   1039 		case 0x01:	printf("Phonebook");	break;
   1040 		case 0x03:	printf("Calendar");	break;
   1041 		case 0x05:	printf("Notes");	break;
   1042 		case 0x06:	printf("Messages");	break;
   1043 		default:	printf("0x%02x", v);	break;
   1044 		}
   1045 	}
   1046 
   1047 	if (list.next != list.end)
   1048 		printf("   [additional data]");
   1049 
   1050 	printf("\n");
   1051 }
   1052 
   1053 static void
   1054 print_supported_formats(sdp_data_t *data)
   1055 {
   1056 	sdp_data_t list;
   1057 	const char *sep;
   1058 	uint8_t v;
   1059 
   1060 	if (!sdp_get_seq(data, &list))
   1061 		return;
   1062 
   1063 	sep = "\n    ";
   1064 	while (sdp_get_uint8(&list, &v)) {
   1065 		printf(sep);
   1066 		sep = ", ";
   1067 
   1068 		switch(v) {
   1069 		case 0x01:	printf("vCard 2.1");	break;
   1070 		case 0x02:	printf("vCard 3.0");	break;
   1071 		case 0x03:	printf("vCal 1.0");	break;
   1072 		case 0x04:	printf("iCal 2.0");	break;
   1073 		case 0x05:	printf("vNote");	break;
   1074 		case 0x06:	printf("vMessage");	break;
   1075 		case 0xff:	printf("Any");		break;
   1076 		default:	printf("0x%02x", v);	break;
   1077 		}
   1078 	}
   1079 
   1080 	if (list.next != list.end)
   1081 		printf("   [additional data]");
   1082 
   1083 	printf("\n");
   1084 }
   1085 
   1086 static void
   1087 print_hid_version(sdp_data_t *data)
   1088 {
   1089 	uint16_t v;
   1090 
   1091 	if (!sdp_get_uint16(data, &v))
   1092 		return;
   1093 
   1094 	printf("v%d.%d.%d\n",
   1095 	    ((v & 0xff00) >> 8), ((v & 0x00f0) >> 4), (v & 0x000f));
   1096 }
   1097 
   1098 static void
   1099 print_hid_device_subclass(sdp_data_t *data)
   1100 {
   1101 	uint8_t v;
   1102 
   1103 	if (!sdp_get_uint8(data, &v))
   1104 		return;
   1105 
   1106 	switch ((v & 0x3c) >> 2) {
   1107 	case 1:		printf("Joystick");		break;
   1108 	case 2:		printf("Gamepad");		break;
   1109 	case 3:		printf("Remote Control");	break;
   1110 	case 4:		printf("Sensing Device");	break;
   1111 	case 5:		printf("Digitiser Tablet");	break;
   1112 	case 6:		printf("Card Reader");		break;
   1113 	default:	printf("Peripheral");		break;
   1114 	}
   1115 
   1116 	if (v & 0x40)	printf(" <Keyboard>");
   1117 	if (v & 0x80)	printf(" <Mouse>");
   1118 
   1119 	printf("\n");
   1120 }
   1121 
   1122 static void
   1123 print_hid_descriptor_list(sdp_data_t *data)
   1124 {
   1125 	sdp_data_t list, seq;
   1126 	uint8_t type;
   1127 	const char *name;
   1128 	char *str;
   1129 	size_t len;
   1130 
   1131 
   1132 	if (!sdp_get_seq(data, &list))
   1133 		return;
   1134 
   1135 	printf("\n");
   1136 	while (list.next < list.end) {
   1137 		if (!sdp_get_seq(&list, &seq)
   1138 		    || !sdp_get_uint8(&seq, &type)
   1139 		    || !sdp_get_str(&seq, &str, &len))
   1140 			return;
   1141 
   1142 		switch (type) {
   1143 		case 0x22:	name = "Report";		break;
   1144 		case 0x23:	name = "Physical Descriptor";	break;
   1145 		default:	name = "";			break;
   1146 		}
   1147 
   1148 		printf("    Type 0x%02x: %s\n", type, name);
   1149 		print_hexdump("    Data", (uint8_t *)str, len);
   1150 
   1151 		if (seq.next != seq.end)
   1152 			printf("    [additional data]\n");
   1153 	}
   1154 }
   1155 
   1156 static void
   1157 print_security_description(sdp_data_t *data)
   1158 {
   1159 	uint16_t v;
   1160 
   1161 	if (!sdp_get_uint16(data, &v))
   1162 		return;
   1163 
   1164 	switch (v) {
   1165 	case 0x0000:	printf("None");				break;
   1166 	case 0x0001:	printf("Service-level Security");	break;
   1167 	case 0x0002:	printf("802.1x Security");		break;
   1168 	default:	printf("0x%04x", v);			break;
   1169 	}
   1170 
   1171 	printf("\n");
   1172 }
   1173 
   1174 static void
   1175 print_hf_features(sdp_data_t *data)
   1176 {
   1177 	uint16_t v;
   1178 
   1179 	if (!sdp_get_uint16(data, &v))
   1180 		return;
   1181 
   1182 	if (Nflag)
   1183 		printf("(0x%04x)", v);
   1184 
   1185 	printf("\n");
   1186 	if (v & (1<<0))	printf("    Echo Cancellation/Noise Reduction\n");
   1187 	if (v & (1<<1))	printf("    Call Waiting\n");
   1188 	if (v & (1<<2))	printf("    Caller Line Identification\n");
   1189 	if (v & (1<<3))	printf("    Voice Recognition\n");
   1190 	if (v & (1<<4))	printf("    Volume Control\n");
   1191 }
   1192 
   1193 static void
   1194 print_hfag_network(sdp_data_t *data)
   1195 {
   1196 	uint8_t v;
   1197 
   1198 	if (!sdp_get_uint8(data, &v))
   1199 		return;
   1200 
   1201 	switch (v) {
   1202 	case 0x01:	printf("Ability to reject a call");	break;
   1203 	case 0x02:	printf("No ability to reject a call");	break;
   1204 	default:	printf("0x%02x", v);			break;
   1205 	}
   1206 
   1207 	printf("\n");
   1208 }
   1209 
   1210 static void
   1211 print_hfag_features(sdp_data_t *data)
   1212 {
   1213 	uint16_t v;
   1214 
   1215 	if (!sdp_get_uint16(data, &v))
   1216 		return;
   1217 
   1218 	if (Nflag)
   1219 		printf("(0x%04x)", v);
   1220 
   1221 	printf("\n");
   1222 	if (v & (1<<0))	printf("    3 Way Calling\n");
   1223 	if (v & (1<<1))	printf("    Echo Cancellation/Noise Reduction\n");
   1224 	if (v & (1<<2))	printf("    Voice Recognition\n");
   1225 	if (v & (1<<3))	printf("    In-band Ring Tone\n");
   1226 	if (v & (1<<4))	printf("    Voice Tags\n");
   1227 }
   1228 
   1229 static void
   1230 print_net_access_type(sdp_data_t *data)
   1231 {
   1232 	uint16_t v;
   1233 
   1234 	if (!sdp_get_uint16(data, &v))
   1235 		return;
   1236 
   1237 	switch(v) {
   1238 	case 0x0000:	printf("PSTN");			break;
   1239 	case 0x0001:	printf("ISDN");			break;
   1240 	case 0x0002:	printf("DSL");			break;
   1241 	case 0x0003:	printf("Cable Modem");		break;
   1242 	case 0x0004:	printf("10Mb Ethernet");	break;
   1243 	case 0x0005:	printf("100Mb Ethernet");	break;
   1244 	case 0x0006:	printf("4Mb Token Ring");	break;
   1245 	case 0x0007:	printf("16Mb Token Ring");	break;
   1246 	case 0x0008:	printf("100Mb Token Ring");	break;
   1247 	case 0x0009:	printf("FDDI");			break;
   1248 	case 0x000a:	printf("GSM");			break;
   1249 	case 0x000b:	printf("CDMA");			break;
   1250 	case 0x000c:	printf("GPRS");			break;
   1251 	case 0x000d:	printf("3G Cellular");		break;
   1252 	case 0xfffe:	printf("other");		break;
   1253 	default:	printf("0x%04x", v);		break;
   1254 	}
   1255 
   1256 	printf("\n");
   1257 }
   1258 
   1259 static void
   1260 print_pnp_source(sdp_data_t *data)
   1261 {
   1262 	uint16_t v;
   1263 
   1264 	if (!sdp_get_uint16(data, &v))
   1265 		return;
   1266 
   1267 	switch (v) {
   1268 	case 0x0001:	printf("Bluetooth SIG");		break;
   1269 	case 0x0002:	printf("USB Implementers Forum");	break;
   1270 	default:	printf("0x%04x", v);			break;
   1271 	}
   1272 
   1273 	printf("\n");
   1274 }
   1275 
   1276 static void
   1277 print_rfcomm(sdp_data_t *data)
   1278 {
   1279 	uint8_t v;
   1280 
   1281 	if (sdp_get_uint8(data, &v))
   1282 		printf(" (channel %d)", v);
   1283 }
   1284 
   1285 static void
   1286 print_bnep(sdp_data_t *data)
   1287 {
   1288 	sdp_data_t seq;
   1289 	uint16_t v;
   1290 	const char *sep;
   1291 
   1292 	if (!sdp_get_uint16(data, &v)
   1293 	    || !sdp_get_seq(data, &seq))
   1294 		return;
   1295 
   1296 	printf(" (v%d.%d", (v >> 8), (v & 0xff));
   1297 	sep = "; ";
   1298 	while (sdp_get_uint16(&seq, &v)) {
   1299 		printf(sep);
   1300 		sep = ", ";
   1301 
   1302 		switch (v) {
   1303 		case 0x0800:	printf("IPv4");		break;
   1304 		case 0x0806:	printf("ARP");		break;
   1305 		case 0x86dd:	printf("IPv6");		break;
   1306 		default:	printf("0x%04x", v);	break;
   1307 		}
   1308 	}
   1309 	printf(")");
   1310 
   1311 	if (seq.next != seq.end)
   1312 		printf(" [additional data]");
   1313 }
   1314 
   1315 static void
   1316 print_avctp(sdp_data_t *data)
   1317 {
   1318 	uint16_t v;
   1319 
   1320 	if (sdp_get_uint16(data, &v))
   1321 		printf(" (v%d.%d)", (v >> 8), (v & 0xff));
   1322 }
   1323 
   1324 static void
   1325 print_avdtp(sdp_data_t *data)
   1326 {
   1327 	uint16_t v;
   1328 
   1329 	if (sdp_get_uint16(data, &v))
   1330 		printf(" (v%d.%d)", (v >> 8), (v & 0xff));
   1331 }
   1332 
   1333 static void
   1334 print_l2cap(sdp_data_t *data)
   1335 {
   1336 	uint16_t v;
   1337 
   1338 	if (sdp_get_uint16(data, &v))
   1339 		printf(" (PSM 0x%04x)", v);
   1340 }
   1341