3
* BlueZ - Bluetooth protocol stack for Linux
5
* Copyright (C) 2005-2010 Marcel Holtmann <marcel@holtmann.org>
8
* This program is free software; you can redistribute it and/or modify
9
* it under the terms of the GNU General Public License as published by
10
* the Free Software Foundation; either version 2 of the License, or
11
* (at your option) any later version.
13
* This program is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
* GNU General Public License for more details.
18
* You should have received a copy of the GNU General Public License
19
* along with this program; if not, write to the Free Software
20
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
36
#include <bluetooth/sdp.h>
37
#include <bluetooth/sdp_lib.h>
41
#define STRBUFSIZE 1024
44
static void convert_raw_data_to_xml(sdp_data_t *value, int indent_level,
45
void *data, void (*appender)(void *, const char *))
49
char indent[MAXINDENT];
50
char next_indent[MAXINDENT];
55
if (indent_level >= MAXINDENT)
56
indent_level = MAXINDENT - 2;
58
for (i = 0; i < indent_level; i++) {
60
next_indent[i] = '\t';
64
next_indent[i] = '\t';
65
next_indent[i + 1] = '\0';
67
buf[STRBUFSIZE - 1] = '\0';
71
appender(data, indent);
72
appender(data, "<nil/>\n");
76
appender(data, indent);
77
appender(data, "<boolean value=\"");
78
appender(data, value->val.uint8 ? "true" : "false");
79
appender(data, "\" />\n");
83
appender(data, indent);
84
appender(data, "<uint8 value=\"");
85
snprintf(buf, STRBUFSIZE - 1, "0x%02x", value->val.uint8);
87
appender(data, "\" />\n");
91
appender(data, indent);
92
appender(data, "<uint16 value=\"");
93
snprintf(buf, STRBUFSIZE - 1, "0x%04x", value->val.uint16);
95
appender(data, "\" />\n");
99
appender(data, indent);
100
appender(data, "<uint32 value=\"");
101
snprintf(buf, STRBUFSIZE - 1, "0x%08x", value->val.uint32);
103
appender(data, "\" />\n");
107
appender(data, indent);
108
appender(data, "<uint64 value=\"");
109
snprintf(buf, STRBUFSIZE - 1, "0x%016jx", value->val.uint64);
111
appender(data, "\" />\n");
115
appender(data, indent);
116
appender(data, "<uint128 value=\"");
118
for (i = 0; i < 16; i++) {
119
sprintf(&buf[i * 2], "%02x",
120
(unsigned char) value->val.uint128.data[i]);
124
appender(data, "\" />\n");
128
appender(data, indent);
129
appender(data, "<int8 value=\"");
130
snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int8);
132
appender(data, "\" />\n");
136
appender(data, indent);
137
appender(data, "<int16 value=\"");
138
snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int16);
140
appender(data, "\" />\n");
144
appender(data, indent);
145
appender(data, "<int32 value=\"");
146
snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int32);
148
appender(data, "\" />\n");
152
appender(data, indent);
153
appender(data, "<int64 value=\"");
154
snprintf(buf, STRBUFSIZE - 1, "%jd", value->val.int64);
156
appender(data, "\" />\n");
160
appender(data, indent);
161
appender(data, "<int128 value=\"");
163
for (i = 0; i < 16; i++) {
164
sprintf(&buf[i * 2], "%02x",
165
(unsigned char) value->val.int128.data[i]);
169
appender(data, "\" />\n");
173
appender(data, indent);
174
appender(data, "<uuid value=\"");
175
snprintf(buf, STRBUFSIZE - 1, "0x%04x", value->val.uuid.value.uuid16);
177
appender(data, "\" />\n");
181
appender(data, indent);
182
appender(data, "<uuid value=\"");
183
snprintf(buf, STRBUFSIZE - 1, "0x%08x", value->val.uuid.value.uuid32);
185
appender(data, "\" />\n");
189
appender(data, indent);
190
appender(data, "<uuid value=\"");
192
snprintf(buf, STRBUFSIZE - 1,
193
"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
194
(unsigned char) value->val.uuid.value.
196
(unsigned char) value->val.uuid.value.
198
(unsigned char) value->val.uuid.value.
200
(unsigned char) value->val.uuid.value.
202
(unsigned char) value->val.uuid.value.
204
(unsigned char) value->val.uuid.value.
206
(unsigned char) value->val.uuid.value.
208
(unsigned char) value->val.uuid.value.
210
(unsigned char) value->val.uuid.value.
212
(unsigned char) value->val.uuid.value.
214
(unsigned char) value->val.uuid.value.
216
(unsigned char) value->val.uuid.value.
218
(unsigned char) value->val.uuid.value.
220
(unsigned char) value->val.uuid.value.
222
(unsigned char) value->val.uuid.value.
224
(unsigned char) value->val.uuid.value.
228
appender(data, "\" />\n");
235
int num_chars_to_escape = 0;
236
int length = value->unitSize - 1;
241
for (i = 0; i < length; i++) {
242
if (!isprint(value->val.str[i]) &&
243
value->val.str[i] != '\0') {
248
/* XML is evil, must do this... */
249
if ((value->val.str[i] == '<') ||
250
(value->val.str[i] == '>') ||
251
(value->val.str[i] == '"') ||
252
(value->val.str[i] == '&'))
253
num_chars_to_escape++;
256
appender(data, indent);
258
appender(data, "<text ");
261
appender(data, "encoding=\"hex\" ");
262
strBuf = malloc(sizeof(char)
263
* ((value->unitSize-1) * 2 + 1));
265
/* Unit Size seems to include the size for dtd
267
This is safe for Normal strings, but not
269
for (i = 0; i < (value->unitSize-1); i++)
270
sprintf(&strBuf[i*sizeof(char)*2],
272
(unsigned char) value->val.str[i]);
274
strBuf[(value->unitSize-1) * 2] = '\0';
278
/* escape the XML disallowed chars */
279
strBuf = malloc(sizeof(char) *
280
(value->unitSize + 1 + num_chars_to_escape * 4));
281
for (i = 0, j = 0; i < length; i++) {
282
if (value->val.str[i] == '&') {
288
else if (value->val.str[i] == '<') {
293
else if (value->val.str[i] == '>') {
298
else if (value->val.str[i] == '"') {
305
else if (value->val.str[i] == '\0') {
308
strBuf[j++] = value->val.str[i];
315
appender(data, "value=\"");
316
appender(data, strBuf);
317
appender(data, "\" />\n");
328
appender(data, indent);
329
appender(data, "<url value=\"");
330
strBuf = strndup(value->val.str, value->unitSize - 1);
331
appender(data, strBuf);
333
appender(data, "\" />\n");
340
appender(data, indent);
341
appender(data, "<sequence>\n");
343
convert_raw_data_to_xml(value->val.dataseq,
344
indent_level + 1, data, appender);
346
appender(data, indent);
347
appender(data, "</sequence>\n");
354
appender(data, indent);
356
appender(data, "<alternate>\n");
358
convert_raw_data_to_xml(value->val.dataseq,
359
indent_level + 1, data, appender);
360
appender(data, indent);
362
appender(data, "</alternate>\n");
367
convert_raw_data_to_xml(value->next, indent_level, data, appender);
370
struct conversion_data {
372
void (*appender)(void *data, const char *);
375
static void convert_raw_attr_to_xml_func(void *val, void *data)
377
struct conversion_data *cd = data;
378
sdp_data_t *value = val;
379
char buf[STRBUFSIZE];
381
buf[STRBUFSIZE - 1] = '\0';
382
snprintf(buf, STRBUFSIZE - 1, "\t<attribute id=\"0x%04x\">\n",
384
cd->appender(cd->data, buf);
387
convert_raw_data_to_xml(value, 2, cd->data, cd->appender);
389
cd->appender(cd->data, "\t\tNULL\n");
391
cd->appender(cd->data, "\t</attribute>\n");
395
* Will convert the sdp record to XML. The appender and data can be used
396
* to control where to output the record (e.g. file or a data buffer). The
397
* appender will be called repeatedly with data and the character buffer
398
* (containing parts of the generated XML) to append.
400
void convert_sdp_record_to_xml(sdp_record_t *rec,
401
void *data, void (*appender)(void *, const char *))
403
struct conversion_data cd;
406
cd.appender = appender;
408
if (rec && rec->attrlist) {
409
appender(data, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n\n");
410
appender(data, "<record>\n");
411
sdp_list_foreach(rec->attrlist,
412
convert_raw_attr_to_xml_func, &cd);
413
appender(data, "</record>\n");
417
static sdp_data_t *sdp_xml_parse_uuid128(const char *data)
424
memset(&val, 0, sizeof(val));
428
for (j = 0, i = 0; i < strlen(data);) {
429
if (data[i] == '-') {
435
buf[1] = data[i + 1];
437
val.data[j++] = strtoul(buf, 0, 16);
441
return sdp_data_alloc(SDP_UUID128, &val);
444
sdp_data_t *sdp_xml_parse_uuid(const char *data, sdp_record_t *record)
455
ret = sdp_xml_parse_uuid128(data);
459
val = strtoll(data, &endptr, 16);
465
if (val > USHRT_MAX) {
466
ret = sdp_data_alloc(SDP_UUID32, &val);
472
ret = sdp_data_alloc(SDP_UUID16, &val2);
476
sdp_pattern_add_uuid(record, &ret->val.uuid);
481
sdp_data_t *sdp_xml_parse_int(const char * data, uint8_t dtd)
484
sdp_data_t *ret = NULL;
491
if (!strcmp("true", data)) {
495
else if (!strcmp("false", data)) {
502
ret = sdp_data_alloc(dtd, &val);
508
int8_t val = strtoul(data, &endptr, 0);
510
/* Failed to parse */
511
if ((endptr != data) && (*endptr != '\0'))
514
ret = sdp_data_alloc(dtd, &val);
520
uint8_t val = strtoul(data, &endptr, 0);
522
/* Failed to parse */
523
if ((endptr != data) && (*endptr != '\0'))
526
ret = sdp_data_alloc(dtd, &val);
532
int16_t val = strtoul(data, &endptr, 0);
534
/* Failed to parse */
535
if ((endptr != data) && (*endptr != '\0'))
538
ret = sdp_data_alloc(dtd, &val);
544
uint16_t val = strtoul(data, &endptr, 0);
546
/* Failed to parse */
547
if ((endptr != data) && (*endptr != '\0'))
550
ret = sdp_data_alloc(dtd, &val);
556
int32_t val = strtoul(data, &endptr, 0);
558
/* Failed to parse */
559
if ((endptr != data) && (*endptr != '\0'))
562
ret = sdp_data_alloc(dtd, &val);
568
uint32_t val = strtoul(data, &endptr, 0);
570
/* Failed to parse */
571
if ((endptr != data) && (*endptr != '\0'))
574
ret = sdp_data_alloc(dtd, &val);
580
int64_t val = strtoull(data, &endptr, 0);
582
/* Failed to parse */
583
if ((endptr != data) && (*endptr != '\0'))
586
ret = sdp_data_alloc(dtd, &val);
592
uint64_t val = strtoull(data, &endptr, 0);
594
/* Failed to parse */
595
if ((endptr != data) && (*endptr != '\0'))
598
ret = sdp_data_alloc(dtd, &val);
611
for (; i < 32; i += 2) {
613
buf[1] = data[i + 1];
615
val.data[i >> 1] = strtoul(buf, 0, 16);
618
ret = sdp_data_alloc(dtd, &val);
627
static char *sdp_xml_parse_string_decode(const char *data, char encoding, uint32_t *length)
629
int len = strlen(data);
632
if (encoding == SDP_XML_ENCODING_NORMAL) {
636
char buf[3], *decoded;
639
decoded = malloc((len >> 1) + 1);
641
/* Ensure the string is a power of 2 */
642
len = (len >> 1) << 1;
646
for (i = 0; i < len; i += 2) {
648
buf[1] = data[i + 1];
650
decoded[i >> 1] = strtoul(buf, 0, 16);
653
decoded[len >> 1] = '\0';
661
sdp_data_t *sdp_xml_parse_url(const char *data)
663
uint8_t dtd = SDP_URL_STR8;
668
url = sdp_xml_parse_string_decode(data,
669
SDP_XML_ENCODING_NORMAL, &length);
671
if (length > UCHAR_MAX)
674
ret = sdp_data_alloc_with_length(dtd, url, length);
681
sdp_data_t *sdp_xml_parse_text(const char *data, char encoding)
683
uint8_t dtd = SDP_TEXT_STR8;
688
text = sdp_xml_parse_string_decode(data, encoding, &length);
690
if (length > UCHAR_MAX)
691
dtd = SDP_TEXT_STR16;
693
ret = sdp_data_alloc_with_length(dtd, text, length);
700
sdp_data_t *sdp_xml_parse_nil(const char *data)
702
return sdp_data_alloc(SDP_DATA_NIL, 0);
705
#define DEFAULT_XML_DATA_SIZE 1024
707
struct sdp_xml_data *sdp_xml_data_alloc()
709
struct sdp_xml_data *elem;
711
elem = malloc(sizeof(struct sdp_xml_data));
715
memset(elem, 0, sizeof(struct sdp_xml_data));
717
/* Null terminate the text */
718
elem->size = DEFAULT_XML_DATA_SIZE;
719
elem->text = malloc(DEFAULT_XML_DATA_SIZE);
720
elem->text[0] = '\0';
725
void sdp_xml_data_free(struct sdp_xml_data *elem)
728
sdp_data_free(elem->data);
735
struct sdp_xml_data *sdp_xml_data_expand(struct sdp_xml_data *elem)
739
newbuf = malloc(elem->size * 2);
743
memcpy(newbuf, elem->text, elem->size);
752
sdp_data_t *sdp_xml_parse_datatype(const char *el, struct sdp_xml_data *elem,
753
sdp_record_t *record)
755
const char *data = elem->text;
757
if (!strcmp(el, "boolean"))
758
return sdp_xml_parse_int(data, SDP_BOOL);
759
else if (!strcmp(el, "uint8"))
760
return sdp_xml_parse_int(data, SDP_UINT8);
761
else if (!strcmp(el, "uint16"))
762
return sdp_xml_parse_int(data, SDP_UINT16);
763
else if (!strcmp(el, "uint32"))
764
return sdp_xml_parse_int(data, SDP_UINT32);
765
else if (!strcmp(el, "uint64"))
766
return sdp_xml_parse_int(data, SDP_UINT64);
767
else if (!strcmp(el, "uint128"))
768
return sdp_xml_parse_int(data, SDP_UINT128);
769
else if (!strcmp(el, "int8"))
770
return sdp_xml_parse_int(data, SDP_INT8);
771
else if (!strcmp(el, "int16"))
772
return sdp_xml_parse_int(data, SDP_INT16);
773
else if (!strcmp(el, "int32"))
774
return sdp_xml_parse_int(data, SDP_INT32);
775
else if (!strcmp(el, "int64"))
776
return sdp_xml_parse_int(data, SDP_INT64);
777
else if (!strcmp(el, "int128"))
778
return sdp_xml_parse_int(data, SDP_INT128);
779
else if (!strcmp(el, "uuid"))
780
return sdp_xml_parse_uuid(data, record);
781
else if (!strcmp(el, "url"))
782
return sdp_xml_parse_url(data);
783
else if (!strcmp(el, "text"))
784
return sdp_xml_parse_text(data, elem->type);
785
else if (!strcmp(el, "nil"))
786
return sdp_xml_parse_nil(data);