| /* |
| * |
| * BlueZ - Bluetooth protocol stack for Linux |
| * |
| * Copyright (C) 2005-2010 Marcel Holtmann <marcel@holtmann.org> |
| * |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| #include <errno.h> |
| #include <ctype.h> |
| #include <string.h> |
| #include <limits.h> |
| #include <stdlib.h> |
| |
| #include <glib.h> |
| |
| #include <bluetooth/sdp.h> |
| #include <bluetooth/sdp_lib.h> |
| |
| #include "sdp-xml.h" |
| |
| #define DBG(...) (void)(0) |
| #define error(...) (void)(0) |
| |
| #define SDP_XML_ENCODING_NORMAL 0 |
| #define SDP_XML_ENCODING_HEX 1 |
| |
| #define STRBUFSIZE 1024 |
| #define MAXINDENT 64 |
| |
| struct sdp_xml_data { |
| char *text; /* Pointer to the current buffer */ |
| int size; /* Size of the current buffer */ |
| sdp_data_t *data; /* The current item being built */ |
| struct sdp_xml_data *next; /* Next item on the stack */ |
| char type; /* 0 = Text or Hexadecimal */ |
| char *name; /* Name, optional in the dtd */ |
| /* TODO: What is it used for? */ |
| }; |
| |
| struct context_data { |
| sdp_record_t *record; |
| sdp_data_t attr_data; |
| struct sdp_xml_data *stack_head; |
| uint16_t attr_id; |
| }; |
| |
| static int compute_seq_size(sdp_data_t *data) |
| { |
| int unit_size = data->unitSize; |
| sdp_data_t *seq = data->val.dataseq; |
| |
| for (; seq; seq = seq->next) |
| unit_size += seq->unitSize; |
| |
| return unit_size; |
| } |
| |
| #define DEFAULT_XML_DATA_SIZE 1024 |
| |
| static struct sdp_xml_data *sdp_xml_data_alloc(void) |
| { |
| struct sdp_xml_data *elem; |
| |
| elem = malloc(sizeof(struct sdp_xml_data)); |
| if (!elem) |
| return NULL; |
| |
| memset(elem, 0, sizeof(struct sdp_xml_data)); |
| |
| /* Null terminate the text */ |
| elem->size = DEFAULT_XML_DATA_SIZE; |
| elem->text = malloc(DEFAULT_XML_DATA_SIZE); |
| elem->text[0] = '\0'; |
| |
| return elem; |
| } |
| |
| static struct sdp_xml_data *sdp_xml_data_expand(struct sdp_xml_data *elem) |
| { |
| char *newbuf; |
| |
| newbuf = malloc(elem->size * 2); |
| if (!newbuf) |
| return NULL; |
| |
| memcpy(newbuf, elem->text, elem->size); |
| elem->size *= 2; |
| free(elem->text); |
| |
| elem->text = newbuf; |
| |
| return elem; |
| } |
| |
| static sdp_data_t *sdp_xml_parse_uuid128(const char *data) |
| { |
| uint128_t val; |
| unsigned int i, j; |
| |
| char buf[3]; |
| |
| memset(&val, 0, sizeof(val)); |
| |
| buf[2] = '\0'; |
| |
| for (j = 0, i = 0; i < strlen(data);) { |
| if (data[i] == '-') { |
| i++; |
| continue; |
| } |
| |
| buf[0] = data[i]; |
| buf[1] = data[i + 1]; |
| |
| val.data[j++] = strtoul(buf, 0, 16); |
| i += 2; |
| } |
| |
| return sdp_data_alloc(SDP_UUID128, &val); |
| } |
| |
| static sdp_data_t *sdp_xml_parse_uuid(const char *data, sdp_record_t *record) |
| { |
| sdp_data_t *ret; |
| char *endptr; |
| uint32_t val; |
| uint16_t val2; |
| int len; |
| |
| len = strlen(data); |
| |
| if (len == 36) { |
| ret = sdp_xml_parse_uuid128(data); |
| goto result; |
| } |
| |
| val = strtoll(data, &endptr, 16); |
| |
| /* Couldn't parse */ |
| if (*endptr != '\0') |
| return NULL; |
| |
| if (val > USHRT_MAX) { |
| ret = sdp_data_alloc(SDP_UUID32, &val); |
| goto result; |
| } |
| |
| val2 = val; |
| |
| ret = sdp_data_alloc(SDP_UUID16, &val2); |
| |
| result: |
| if (record && ret) |
| sdp_pattern_add_uuid(record, &ret->val.uuid); |
| |
| return ret; |
| } |
| |
| static sdp_data_t *sdp_xml_parse_int(const char *data, uint8_t dtd) |
| { |
| char *endptr; |
| sdp_data_t *ret = NULL; |
| |
| switch (dtd) { |
| case SDP_BOOL: |
| { |
| uint8_t val = 0; |
| |
| if (!strcmp("true", data)) |
| val = 1; |
| else if (!strcmp("false", data)) |
| val = 0; |
| else |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_INT8: |
| { |
| int8_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_UINT8: |
| { |
| uint8_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_INT16: |
| { |
| int16_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_UINT16: |
| { |
| uint16_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_INT32: |
| { |
| int32_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_UINT32: |
| { |
| uint32_t val = strtoul(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_INT64: |
| { |
| int64_t val = strtoull(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_UINT64: |
| { |
| uint64_t val = strtoull(data, &endptr, 0); |
| |
| /* Failed to parse */ |
| if ((endptr != data) && (*endptr != '\0')) |
| return NULL; |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| case SDP_INT128: |
| case SDP_UINT128: |
| { |
| uint128_t val; |
| int i = 0; |
| char buf[3]; |
| |
| buf[2] = '\0'; |
| |
| for (; i < 32; i += 2) { |
| buf[0] = data[i]; |
| buf[1] = data[i + 1]; |
| |
| val.data[i >> 1] = strtoul(buf, 0, 16); |
| } |
| |
| ret = sdp_data_alloc(dtd, &val); |
| break; |
| } |
| |
| }; |
| |
| return ret; |
| } |
| |
| static char *sdp_xml_parse_string_decode(const char *data, char encoding, |
| uint32_t *length) |
| { |
| int len = strlen(data); |
| char *text; |
| |
| if (encoding == SDP_XML_ENCODING_NORMAL) { |
| text = strdup(data); |
| *length = len; |
| } else { |
| char buf[3], *decoded; |
| int i; |
| |
| decoded = malloc((len >> 1) + 1); |
| |
| /* Ensure the string is a power of 2 */ |
| len = (len >> 1) << 1; |
| |
| buf[2] = '\0'; |
| |
| for (i = 0; i < len; i += 2) { |
| buf[0] = data[i]; |
| buf[1] = data[i + 1]; |
| |
| decoded[i >> 1] = strtoul(buf, 0, 16); |
| } |
| |
| decoded[len >> 1] = '\0'; |
| text = decoded; |
| *length = len >> 1; |
| } |
| |
| return text; |
| } |
| |
| static sdp_data_t *sdp_xml_parse_url(const char *data) |
| { |
| uint8_t dtd = SDP_URL_STR8; |
| char *url; |
| uint32_t length; |
| sdp_data_t *ret; |
| |
| url = sdp_xml_parse_string_decode(data, |
| SDP_XML_ENCODING_NORMAL, &length); |
| |
| if (length > UCHAR_MAX) |
| dtd = SDP_URL_STR16; |
| |
| ret = sdp_data_alloc_with_length(dtd, url, length); |
| |
| free(url); |
| |
| return ret; |
| } |
| |
| static sdp_data_t *sdp_xml_parse_text(const char *data, char encoding) |
| { |
| uint8_t dtd = SDP_TEXT_STR8; |
| char *text; |
| uint32_t length; |
| sdp_data_t *ret; |
| |
| text = sdp_xml_parse_string_decode(data, encoding, &length); |
| |
| if (length > UCHAR_MAX) |
| dtd = SDP_TEXT_STR16; |
| |
| ret = sdp_data_alloc_with_length(dtd, text, length); |
| |
| free(text); |
| |
| return ret; |
| } |
| |
| static sdp_data_t *sdp_xml_parse_nil(const char *data) |
| { |
| return sdp_data_alloc(SDP_DATA_NIL, 0); |
| } |
| |
| static sdp_data_t *sdp_xml_parse_datatype(const char *el, |
| struct sdp_xml_data *elem, |
| sdp_record_t *record) |
| { |
| const char *data = elem->text; |
| |
| if (!strcmp(el, "boolean")) |
| return sdp_xml_parse_int(data, SDP_BOOL); |
| else if (!strcmp(el, "uint8")) |
| return sdp_xml_parse_int(data, SDP_UINT8); |
| else if (!strcmp(el, "uint16")) |
| return sdp_xml_parse_int(data, SDP_UINT16); |
| else if (!strcmp(el, "uint32")) |
| return sdp_xml_parse_int(data, SDP_UINT32); |
| else if (!strcmp(el, "uint64")) |
| return sdp_xml_parse_int(data, SDP_UINT64); |
| else if (!strcmp(el, "uint128")) |
| return sdp_xml_parse_int(data, SDP_UINT128); |
| else if (!strcmp(el, "int8")) |
| return sdp_xml_parse_int(data, SDP_INT8); |
| else if (!strcmp(el, "int16")) |
| return sdp_xml_parse_int(data, SDP_INT16); |
| else if (!strcmp(el, "int32")) |
| return sdp_xml_parse_int(data, SDP_INT32); |
| else if (!strcmp(el, "int64")) |
| return sdp_xml_parse_int(data, SDP_INT64); |
| else if (!strcmp(el, "int128")) |
| return sdp_xml_parse_int(data, SDP_INT128); |
| else if (!strcmp(el, "uuid")) |
| return sdp_xml_parse_uuid(data, record); |
| else if (!strcmp(el, "url")) |
| return sdp_xml_parse_url(data); |
| else if (!strcmp(el, "text")) |
| return sdp_xml_parse_text(data, elem->type); |
| else if (!strcmp(el, "nil")) |
| return sdp_xml_parse_nil(data); |
| |
| return NULL; |
| } |
| static void element_start(GMarkupParseContext *context, |
| const char *element_name, const char **attribute_names, |
| const char **attribute_values, gpointer user_data, GError **err) |
| { |
| struct context_data *ctx_data = user_data; |
| |
| if (!strcmp(element_name, "record")) |
| return; |
| |
| if (!strcmp(element_name, "attribute")) { |
| int i; |
| for (i = 0; attribute_names[i]; i++) { |
| if (!strcmp(attribute_names[i], "id")) { |
| ctx_data->attr_id = strtol(attribute_values[i], 0, 0); |
| break; |
| } |
| } |
| DBG("New attribute 0x%04x", ctx_data->attr_id); |
| return; |
| } |
| |
| if (ctx_data->stack_head) { |
| struct sdp_xml_data *newelem = sdp_xml_data_alloc(); |
| newelem->next = ctx_data->stack_head; |
| ctx_data->stack_head = newelem; |
| } else { |
| ctx_data->stack_head = sdp_xml_data_alloc(); |
| ctx_data->stack_head->next = NULL; |
| } |
| |
| if (!strcmp(element_name, "sequence")) |
| ctx_data->stack_head->data = sdp_data_alloc(SDP_SEQ8, NULL); |
| else if (!strcmp(element_name, "alternate")) |
| ctx_data->stack_head->data = sdp_data_alloc(SDP_ALT8, NULL); |
| else { |
| int i; |
| /* Parse value, name, encoding */ |
| for (i = 0; attribute_names[i]; i++) { |
| if (!strcmp(attribute_names[i], "value")) { |
| int curlen = strlen(ctx_data->stack_head->text); |
| int attrlen = strlen(attribute_values[i]); |
| |
| /* Ensure we're big enough */ |
| while ((curlen + 1 + attrlen) > ctx_data->stack_head->size) |
| sdp_xml_data_expand(ctx_data->stack_head); |
| |
| memcpy(ctx_data->stack_head->text + curlen, |
| attribute_values[i], attrlen); |
| ctx_data->stack_head->text[curlen + attrlen] = '\0'; |
| } |
| |
| if (!strcmp(attribute_names[i], "encoding")) { |
| if (!strcmp(attribute_values[i], "hex")) |
| ctx_data->stack_head->type = 1; |
| } |
| |
| if (!strcmp(attribute_names[i], "name")) |
| ctx_data->stack_head->name = strdup(attribute_values[i]); |
| } |
| |
| ctx_data->stack_head->data = sdp_xml_parse_datatype(element_name, |
| ctx_data->stack_head, ctx_data->record); |
| |
| if (ctx_data->stack_head->data == NULL) |
| error("Can't parse element %s", element_name); |
| } |
| } |
| |
| static void sdp_xml_data_free(struct sdp_xml_data *elem) |
| { |
| if (elem->data) |
| sdp_data_free(elem->data); |
| |
| free(elem->name); |
| free(elem->text); |
| free(elem); |
| } |
| |
| static void element_end(GMarkupParseContext *context, |
| const char *element_name, gpointer user_data, GError **err) |
| { |
| struct context_data *ctx_data = user_data; |
| struct sdp_xml_data *elem; |
| |
| if (!strcmp(element_name, "record")) |
| return; |
| |
| if (!strcmp(element_name, "attribute")) { |
| if (ctx_data->stack_head && ctx_data->stack_head->data) { |
| int ret = sdp_attr_add(ctx_data->record, ctx_data->attr_id, |
| ctx_data->stack_head->data); |
| if (ret == -1) |
| DBG("Could not add attribute 0x%04x", |
| ctx_data->attr_id); |
| |
| ctx_data->stack_head->data = NULL; |
| sdp_xml_data_free(ctx_data->stack_head); |
| ctx_data->stack_head = NULL; |
| } else { |
| DBG("No data for attribute 0x%04x", ctx_data->attr_id); |
| } |
| return; |
| } |
| |
| if (!ctx_data->stack_head || !ctx_data->stack_head->data) { |
| DBG("No data for %s", element_name); |
| return; |
| } |
| |
| if (!strcmp(element_name, "sequence")) { |
| ctx_data->stack_head->data->unitSize = compute_seq_size(ctx_data->stack_head->data); |
| |
| if (ctx_data->stack_head->data->unitSize > USHRT_MAX) { |
| ctx_data->stack_head->data->unitSize += sizeof(uint32_t); |
| ctx_data->stack_head->data->dtd = SDP_SEQ32; |
| } else if (ctx_data->stack_head->data->unitSize > UCHAR_MAX) { |
| ctx_data->stack_head->data->unitSize += sizeof(uint16_t); |
| ctx_data->stack_head->data->dtd = SDP_SEQ16; |
| } else { |
| ctx_data->stack_head->data->unitSize += sizeof(uint8_t); |
| } |
| } else if (!strcmp(element_name, "alternate")) { |
| ctx_data->stack_head->data->unitSize = compute_seq_size(ctx_data->stack_head->data); |
| |
| if (ctx_data->stack_head->data->unitSize > USHRT_MAX) { |
| ctx_data->stack_head->data->unitSize += sizeof(uint32_t); |
| ctx_data->stack_head->data->dtd = SDP_ALT32; |
| } else if (ctx_data->stack_head->data->unitSize > UCHAR_MAX) { |
| ctx_data->stack_head->data->unitSize += sizeof(uint16_t); |
| ctx_data->stack_head->data->dtd = SDP_ALT16; |
| } else { |
| ctx_data->stack_head->data->unitSize += sizeof(uint8_t); |
| } |
| } |
| |
| if (ctx_data->stack_head->next && ctx_data->stack_head->data && |
| ctx_data->stack_head->next->data) { |
| switch (ctx_data->stack_head->next->data->dtd) { |
| case SDP_SEQ8: |
| case SDP_SEQ16: |
| case SDP_SEQ32: |
| case SDP_ALT8: |
| case SDP_ALT16: |
| case SDP_ALT32: |
| ctx_data->stack_head->next->data->val.dataseq = |
| sdp_seq_append(ctx_data->stack_head->next->data->val.dataseq, |
| ctx_data->stack_head->data); |
| ctx_data->stack_head->data = NULL; |
| break; |
| } |
| |
| elem = ctx_data->stack_head; |
| ctx_data->stack_head = ctx_data->stack_head->next; |
| |
| sdp_xml_data_free(elem); |
| } |
| } |
| |
| static GMarkupParser parser = { |
| element_start, element_end, NULL, NULL, NULL |
| }; |
| |
| sdp_record_t *sdp_xml_parse_record(const char *data, int size) |
| { |
| GMarkupParseContext *ctx; |
| struct context_data *ctx_data; |
| sdp_record_t *record; |
| |
| ctx_data = malloc(sizeof(*ctx_data)); |
| if (!ctx_data) |
| return NULL; |
| |
| record = sdp_record_alloc(); |
| if (!record) { |
| free(ctx_data); |
| return NULL; |
| } |
| |
| memset(ctx_data, 0, sizeof(*ctx_data)); |
| ctx_data->record = record; |
| |
| ctx = g_markup_parse_context_new(&parser, 0, ctx_data, NULL); |
| |
| if (g_markup_parse_context_parse(ctx, data, size, NULL) == FALSE) { |
| error("XML parsing error"); |
| g_markup_parse_context_free(ctx); |
| sdp_record_free(record); |
| free(ctx_data); |
| return NULL; |
| } |
| |
| g_markup_parse_context_free(ctx); |
| |
| free(ctx_data); |
| |
| return record; |
| } |
| |
| |
| static void convert_raw_data_to_xml(sdp_data_t *value, int indent_level, |
| void *data, void (*appender)(void *, const char *)) |
| { |
| int i, hex; |
| char buf[STRBUFSIZE]; |
| char indent[MAXINDENT]; |
| |
| if (!value) |
| return; |
| |
| if (indent_level >= MAXINDENT) |
| indent_level = MAXINDENT - 2; |
| |
| for (i = 0; i < indent_level; i++) |
| indent[i] = '\t'; |
| |
| indent[i] = '\0'; |
| buf[STRBUFSIZE - 1] = '\0'; |
| |
| switch (value->dtd) { |
| case SDP_DATA_NIL: |
| appender(data, indent); |
| appender(data, "<nil/>\n"); |
| break; |
| |
| case SDP_BOOL: |
| appender(data, indent); |
| appender(data, "<boolean value=\""); |
| appender(data, value->val.uint8 ? "true" : "false"); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UINT8: |
| appender(data, indent); |
| appender(data, "<uint8 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%02x", value->val.uint8); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UINT16: |
| appender(data, indent); |
| appender(data, "<uint16 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%04x", value->val.uint16); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UINT32: |
| appender(data, indent); |
| appender(data, "<uint32 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%08x", value->val.uint32); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UINT64: |
| appender(data, indent); |
| appender(data, "<uint64 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%016jx", value->val.uint64); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UINT128: |
| appender(data, indent); |
| appender(data, "<uint128 value=\""); |
| |
| for (i = 0; i < 16; i++) { |
| sprintf(&buf[i * 2], "%02x", |
| (unsigned char) value->val.uint128.data[i]); |
| } |
| |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_INT8: |
| appender(data, indent); |
| appender(data, "<int8 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int8); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_INT16: |
| appender(data, indent); |
| appender(data, "<int16 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int16); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_INT32: |
| appender(data, indent); |
| appender(data, "<int32 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "%d", value->val.int32); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_INT64: |
| appender(data, indent); |
| appender(data, "<int64 value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "%jd", value->val.int64); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_INT128: |
| appender(data, indent); |
| appender(data, "<int128 value=\""); |
| |
| for (i = 0; i < 16; i++) { |
| sprintf(&buf[i * 2], "%02x", |
| (unsigned char) value->val.int128.data[i]); |
| } |
| appender(data, buf); |
| |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UUID16: |
| appender(data, indent); |
| appender(data, "<uuid value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%04x", value->val.uuid.value.uuid16); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UUID32: |
| appender(data, indent); |
| appender(data, "<uuid value=\""); |
| snprintf(buf, STRBUFSIZE - 1, "0x%08x", value->val.uuid.value.uuid32); |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_UUID128: |
| appender(data, indent); |
| appender(data, "<uuid value=\""); |
| |
| snprintf(buf, STRBUFSIZE - 1, |
| "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[0], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[1], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[2], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[3], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[4], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[5], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[6], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[7], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[8], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[9], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[10], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[11], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[12], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[13], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[14], |
| (unsigned char) value->val.uuid.value. |
| uuid128.data[15]); |
| |
| appender(data, buf); |
| appender(data, "\" />\n"); |
| break; |
| |
| case SDP_TEXT_STR8: |
| case SDP_TEXT_STR16: |
| case SDP_TEXT_STR32: |
| { |
| int num_chars_to_escape = 0; |
| int length = value->unitSize - 1; |
| char *strBuf = 0; |
| |
| hex = 0; |
| |
| for (i = 0; i < length; i++) { |
| if (!isprint(value->val.str[i]) && |
| value->val.str[i] != '\0') { |
| hex = 1; |
| break; |
| } |
| |
| /* XML is evil, must do this... */ |
| if ((value->val.str[i] == '<') || |
| (value->val.str[i] == '>') || |
| (value->val.str[i] == '"') || |
| (value->val.str[i] == '&')) |
| num_chars_to_escape++; |
| } |
| |
| appender(data, indent); |
| |
| appender(data, "<text "); |
| |
| if (hex) { |
| appender(data, "encoding=\"hex\" "); |
| strBuf = malloc(sizeof(char) |
| * ((value->unitSize-1) * 2 + 1)); |
| |
| /* Unit Size seems to include the size for dtd |
| It is thus off by 1 |
| This is safe for Normal strings, but not |
| hex encoded data */ |
| for (i = 0; i < (value->unitSize-1); i++) |
| sprintf(&strBuf[i*sizeof(char)*2], |
| "%02x", |
| (unsigned char) value->val.str[i]); |
| |
| strBuf[(value->unitSize-1) * 2] = '\0'; |
| } else { |
| int j; |
| /* escape the XML disallowed chars */ |
| strBuf = malloc(sizeof(char) * |
| (value->unitSize + 1 + num_chars_to_escape * 4)); |
| for (i = 0, j = 0; i < length; i++) { |
| if (value->val.str[i] == '&') { |
| strBuf[j++] = '&'; |
| strBuf[j++] = 'a'; |
| strBuf[j++] = 'm'; |
| strBuf[j++] = 'p'; |
| } else if (value->val.str[i] == '<') { |
| strBuf[j++] = '&'; |
| strBuf[j++] = 'l'; |
| strBuf[j++] = 't'; |
| } else if (value->val.str[i] == '>') { |
| strBuf[j++] = '&'; |
| strBuf[j++] = 'g'; |
| strBuf[j++] = 't'; |
| } else if (value->val.str[i] == '"') { |
| strBuf[j++] = '&'; |
| strBuf[j++] = 'q'; |
| strBuf[j++] = 'u'; |
| strBuf[j++] = 'o'; |
| strBuf[j++] = 't'; |
| } else if (value->val.str[i] == '\0') { |
| strBuf[j++] = ' '; |
| } else { |
| strBuf[j++] = value->val.str[i]; |
| } |
| } |
| |
| strBuf[j] = '\0'; |
| } |
| |
| appender(data, "value=\""); |
| appender(data, strBuf); |
| appender(data, "\" />\n"); |
| free(strBuf); |
| break; |
| } |
| |
| case SDP_URL_STR8: |
| case SDP_URL_STR16: |
| case SDP_URL_STR32: |
| { |
| char *strBuf; |
| |
| appender(data, indent); |
| appender(data, "<url value=\""); |
| strBuf = strndup(value->val.str, value->unitSize - 1); |
| appender(data, strBuf); |
| free(strBuf); |
| appender(data, "\" />\n"); |
| break; |
| } |
| |
| case SDP_SEQ8: |
| case SDP_SEQ16: |
| case SDP_SEQ32: |
| appender(data, indent); |
| appender(data, "<sequence>\n"); |
| |
| convert_raw_data_to_xml(value->val.dataseq, |
| indent_level + 1, data, appender); |
| |
| appender(data, indent); |
| appender(data, "</sequence>\n"); |
| |
| break; |
| |
| case SDP_ALT8: |
| case SDP_ALT16: |
| case SDP_ALT32: |
| appender(data, indent); |
| |
| appender(data, "<alternate>\n"); |
| |
| convert_raw_data_to_xml(value->val.dataseq, |
| indent_level + 1, data, appender); |
| appender(data, indent); |
| |
| appender(data, "</alternate>\n"); |
| |
| break; |
| } |
| |
| convert_raw_data_to_xml(value->next, indent_level, data, appender); |
| } |
| |
| struct conversion_data { |
| void *data; |
| void (*appender)(void *data, const char *); |
| }; |
| |
| static void convert_raw_attr_to_xml_func(void *val, void *data) |
| { |
| struct conversion_data *cd = data; |
| sdp_data_t *value = val; |
| char buf[STRBUFSIZE]; |
| |
| buf[STRBUFSIZE - 1] = '\0'; |
| snprintf(buf, STRBUFSIZE - 1, "\t<attribute id=\"0x%04x\">\n", |
| value->attrId); |
| cd->appender(cd->data, buf); |
| |
| convert_raw_data_to_xml(value, 2, cd->data, cd->appender); |
| |
| cd->appender(cd->data, "\t</attribute>\n"); |
| } |
| |
| /* |
| * Will convert the sdp record to XML. The appender and data can be used |
| * to control where to output the record (e.g. file or a data buffer). The |
| * appender will be called repeatedly with data and the character buffer |
| * (containing parts of the generated XML) to append. |
| */ |
| void convert_sdp_record_to_xml(sdp_record_t *rec, |
| void *data, void (*appender)(void *, const char *)) |
| { |
| struct conversion_data cd; |
| |
| cd.data = data; |
| cd.appender = appender; |
| |
| if (rec && rec->attrlist) { |
| appender(data, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n\n"); |
| appender(data, "<record>\n"); |
| sdp_list_foreach(rec->attrlist, |
| convert_raw_attr_to_xml_func, &cd); |
| appender(data, "</record>\n"); |
| } |
| } |