xref: /btstack/src/classic/sdp_util.c (revision 59c6af158dbc40c703cd6422bc90ce91f2efa168)
13deb3ec6SMatthias Ringwald /*
23deb3ec6SMatthias Ringwald  * Copyright (C) 2014 BlueKitchen GmbH
33deb3ec6SMatthias Ringwald  *
43deb3ec6SMatthias Ringwald  * Redistribution and use in source and binary forms, with or without
53deb3ec6SMatthias Ringwald  * modification, are permitted provided that the following conditions
63deb3ec6SMatthias Ringwald  * are met:
73deb3ec6SMatthias Ringwald  *
83deb3ec6SMatthias Ringwald  * 1. Redistributions of source code must retain the above copyright
93deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer.
103deb3ec6SMatthias Ringwald  * 2. Redistributions in binary form must reproduce the above copyright
113deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer in the
123deb3ec6SMatthias Ringwald  *    documentation and/or other materials provided with the distribution.
133deb3ec6SMatthias Ringwald  * 3. Neither the name of the copyright holders nor the names of
143deb3ec6SMatthias Ringwald  *    contributors may be used to endorse or promote products derived
153deb3ec6SMatthias Ringwald  *    from this software without specific prior written permission.
163deb3ec6SMatthias Ringwald  * 4. Any redistribution, use, or modification is done solely for
173deb3ec6SMatthias Ringwald  *    personal benefit and not for any commercial purpose or for
183deb3ec6SMatthias Ringwald  *    monetary gain.
193deb3ec6SMatthias Ringwald  *
203deb3ec6SMatthias Ringwald  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
213deb3ec6SMatthias Ringwald  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
223deb3ec6SMatthias Ringwald  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
233deb3ec6SMatthias Ringwald  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
243deb3ec6SMatthias Ringwald  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
253deb3ec6SMatthias Ringwald  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
263deb3ec6SMatthias Ringwald  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
273deb3ec6SMatthias Ringwald  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
283deb3ec6SMatthias Ringwald  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
293deb3ec6SMatthias Ringwald  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
303deb3ec6SMatthias Ringwald  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
313deb3ec6SMatthias Ringwald  * SUCH DAMAGE.
323deb3ec6SMatthias Ringwald  *
333deb3ec6SMatthias Ringwald  * Please inquire about commercial licensing options at
343deb3ec6SMatthias Ringwald  * [email protected]
353deb3ec6SMatthias Ringwald  *
363deb3ec6SMatthias Ringwald  */
373deb3ec6SMatthias Ringwald 
383deb3ec6SMatthias Ringwald /*
393deb3ec6SMatthias Ringwald  *  sdp_util.c
403deb3ec6SMatthias Ringwald  */
413deb3ec6SMatthias Ringwald 
42e2a91e48SMatthias Ringwald #include "bluetooth.h"
43*59c6af15SMatthias Ringwald #include "btstack_config.h"
44*59c6af15SMatthias Ringwald #include "btstack_util.h"
45*59c6af15SMatthias Ringwald #include "classic/core.h"
46*59c6af15SMatthias Ringwald #include "classic/sdp_util.h"
473deb3ec6SMatthias Ringwald 
483deb3ec6SMatthias Ringwald #include <stdio.h>
493deb3ec6SMatthias Ringwald #include <stdlib.h>
503deb3ec6SMatthias Ringwald #include <string.h>
513deb3ec6SMatthias Ringwald #include <stdint.h>
523deb3ec6SMatthias Ringwald #include <inttypes.h>   // PRIx32
533deb3ec6SMatthias Ringwald 
54a9a4c409SMatthias Ringwald #ifdef ENABLE_SDP_DES_DUMP
553deb3ec6SMatthias Ringwald // workaround for missing PRIx32 on mspgcc (16-bit MCU)
563deb3ec6SMatthias Ringwald #ifndef PRIx32
573deb3ec6SMatthias Ringwald #warning Using own: #define PRIx32 "lx"
583deb3ec6SMatthias Ringwald #define PRIx32 "lx"
593deb3ec6SMatthias Ringwald #endif
603deb3ec6SMatthias Ringwald // date element type names
613deb3ec6SMatthias Ringwald const char * const type_names[] = { "NIL", "UINT", "INT", "UUID", "STRING", "BOOL", "DES", "DEA", "URL"};
623deb3ec6SMatthias Ringwald #endif
633deb3ec6SMatthias Ringwald 
64023f2764SMatthias Ringwald static uint8_t des_serviceSearchPattern[] = {0x35, 0x03, 0x19, 0x00, 0x00};
65023f2764SMatthias Ringwald static uint8_t des_serviceSearchPatternUUID128[] = {
66023f2764SMatthias Ringwald     0x35, 0x10, 0x19,
67023f2764SMatthias Ringwald     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
68023f2764SMatthias Ringwald     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
69023f2764SMatthias Ringwald 
703deb3ec6SMatthias Ringwald // MARK: DataElement getter
716c927b22SMatthias Ringwald de_size_t de_get_size_type(const uint8_t *header){
723deb3ec6SMatthias Ringwald     return (de_size_t) (header[0] & 7);
733deb3ec6SMatthias Ringwald }
743deb3ec6SMatthias Ringwald 
756c927b22SMatthias Ringwald de_type_t de_get_element_type(const uint8_t *header){
763deb3ec6SMatthias Ringwald     return (de_type_t) (header[0] >> 3);
773deb3ec6SMatthias Ringwald }
783deb3ec6SMatthias Ringwald 
796c927b22SMatthias Ringwald int de_get_header_size(const uint8_t * header){
803deb3ec6SMatthias Ringwald     de_size_t de_size = de_get_size_type(header);
813deb3ec6SMatthias Ringwald     if (de_size <= DE_SIZE_128) {
823deb3ec6SMatthias Ringwald         return 1;
833deb3ec6SMatthias Ringwald     }
843deb3ec6SMatthias Ringwald     return 1 + (1 << (de_size-DE_SIZE_VAR_8));
853deb3ec6SMatthias Ringwald }
863deb3ec6SMatthias Ringwald 
876c927b22SMatthias Ringwald int de_get_data_size(const uint8_t * header){
883deb3ec6SMatthias Ringwald     uint32_t result = 0;
893deb3ec6SMatthias Ringwald     de_type_t de_type = de_get_element_type(header);
903deb3ec6SMatthias Ringwald     de_size_t de_size = de_get_size_type(header);
913deb3ec6SMatthias Ringwald     switch (de_size){
923deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_8:
933deb3ec6SMatthias Ringwald             result = header[1];
943deb3ec6SMatthias Ringwald             break;
953deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_16:
96f8fbdce0SMatthias Ringwald             result = big_endian_read_16(header,1);
973deb3ec6SMatthias Ringwald             break;
983deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_32:
99c9b8fdd9SMatthias Ringwald             result = big_endian_read_32(header,1);
1003deb3ec6SMatthias Ringwald             break;
1013deb3ec6SMatthias Ringwald         default:
1023deb3ec6SMatthias Ringwald         // case DE_SIZE_8:
1033deb3ec6SMatthias Ringwald         // case DE_SIZE_16:
1043deb3ec6SMatthias Ringwald         // case DE_SIZE_32:
1053deb3ec6SMatthias Ringwald         // case DE_SIZE_64:
1063deb3ec6SMatthias Ringwald         // case DE_SIZE_128:
1073deb3ec6SMatthias Ringwald             if (de_type == DE_NIL) return 0;
1083deb3ec6SMatthias Ringwald             return 1 << de_size;
1093deb3ec6SMatthias Ringwald     }
1103deb3ec6SMatthias Ringwald     return result;
1113deb3ec6SMatthias Ringwald }
1123deb3ec6SMatthias Ringwald 
1136c927b22SMatthias Ringwald int de_get_len(const uint8_t *header){
1143deb3ec6SMatthias Ringwald     return de_get_header_size(header) + de_get_data_size(header);
1153deb3ec6SMatthias Ringwald }
1163deb3ec6SMatthias Ringwald 
1173deb3ec6SMatthias Ringwald // @returns OK, if UINT16 value was read
1186c927b22SMatthias Ringwald int de_element_get_uint16(const uint8_t * element, uint16_t * value){
1193deb3ec6SMatthias Ringwald     if (de_get_size_type(element) != DE_SIZE_16) return 0;
120f8fbdce0SMatthias Ringwald     *value = big_endian_read_16(element, de_get_header_size(element));
1213deb3ec6SMatthias Ringwald     return 1;
1223deb3ec6SMatthias Ringwald }
1233deb3ec6SMatthias Ringwald 
1243deb3ec6SMatthias Ringwald // @returns: element is valid UUID
1256c927b22SMatthias Ringwald int de_get_normalized_uuid(uint8_t *uuid128, const uint8_t *element){
1263deb3ec6SMatthias Ringwald     de_type_t uuidType = de_get_element_type(element);
1273deb3ec6SMatthias Ringwald     de_size_t uuidSize = de_get_size_type(element);
1283deb3ec6SMatthias Ringwald     if (uuidType != DE_UUID) return 0;
1293deb3ec6SMatthias Ringwald     uint32_t shortUUID;
1303deb3ec6SMatthias Ringwald     switch (uuidSize){
1313deb3ec6SMatthias Ringwald         case DE_SIZE_16:
132f8fbdce0SMatthias Ringwald             shortUUID = big_endian_read_16(element, 1);
1333deb3ec6SMatthias Ringwald             break;
1343deb3ec6SMatthias Ringwald         case DE_SIZE_32:
135c9b8fdd9SMatthias Ringwald             shortUUID = big_endian_read_32(element, 1);
1363deb3ec6SMatthias Ringwald             break;
1373deb3ec6SMatthias Ringwald         case DE_SIZE_128:
1383deb3ec6SMatthias Ringwald             memcpy(uuid128, element+1, 16);
1393deb3ec6SMatthias Ringwald             return 1;
1403deb3ec6SMatthias Ringwald         default:
1413deb3ec6SMatthias Ringwald             return 0;
1423deb3ec6SMatthias Ringwald     }
143e1a125dfSMatthias Ringwald     uuid_add_bluetooth_prefix(uuid128, shortUUID);
1443deb3ec6SMatthias Ringwald     return 1;
1453deb3ec6SMatthias Ringwald }
1463deb3ec6SMatthias Ringwald 
1473deb3ec6SMatthias Ringwald // @returns 0 if no UUID16 or UUID32 is present, and UUID32 otherwise
1486c927b22SMatthias Ringwald uint32_t de_get_uuid32(const uint8_t * element){
1493deb3ec6SMatthias Ringwald     uint8_t uuid128[16];
1503deb3ec6SMatthias Ringwald     int validUuid128 = de_get_normalized_uuid(uuid128, element);
1513deb3ec6SMatthias Ringwald     if (!validUuid128) return 0;
152e1a125dfSMatthias Ringwald     int hasBlueoothBaseUuid = uuid_has_bluetooth_prefix(uuid128);
1533deb3ec6SMatthias Ringwald     if (!hasBlueoothBaseUuid) return 0;
154c9b8fdd9SMatthias Ringwald     return big_endian_read_32(uuid128, 0);
1553deb3ec6SMatthias Ringwald }
1563deb3ec6SMatthias Ringwald 
1573deb3ec6SMatthias Ringwald // functions to create record
1583deb3ec6SMatthias Ringwald static void de_store_descriptor(uint8_t * header, de_type_t type, de_size_t size){
1593deb3ec6SMatthias Ringwald     header[0] = (type << 3) | size;
1603deb3ec6SMatthias Ringwald }
1613deb3ec6SMatthias Ringwald 
1623deb3ec6SMatthias Ringwald void de_store_descriptor_with_len(uint8_t * header, de_type_t type, de_size_t size, uint32_t len){
1633deb3ec6SMatthias Ringwald     header[0] = (type << 3) | size;
1643deb3ec6SMatthias Ringwald     switch (size){
1653deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_8:
1663deb3ec6SMatthias Ringwald             header[1] = len;
1673deb3ec6SMatthias Ringwald             break;
1683deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_16:
169f8fbdce0SMatthias Ringwald             big_endian_store_16(header, 1, len);
1703deb3ec6SMatthias Ringwald             break;
1713deb3ec6SMatthias Ringwald         case DE_SIZE_VAR_32:
172f8fbdce0SMatthias Ringwald             big_endian_store_32(header, 1, len);
1733deb3ec6SMatthias Ringwald             break;
1743deb3ec6SMatthias Ringwald         default:
1753deb3ec6SMatthias Ringwald             break;
1763deb3ec6SMatthias Ringwald     }
1773deb3ec6SMatthias Ringwald }
1783deb3ec6SMatthias Ringwald 
1793deb3ec6SMatthias Ringwald // MARK: DataElement creation
1803deb3ec6SMatthias Ringwald 
1813deb3ec6SMatthias Ringwald /* starts a new sequence in empty buffer - first call */
1823deb3ec6SMatthias Ringwald void de_create_sequence(uint8_t *header){
1833deb3ec6SMatthias Ringwald     de_store_descriptor_with_len( header, DE_DES, DE_SIZE_VAR_16, 0); // DES, 2 Byte Length
1843deb3ec6SMatthias Ringwald };
1853deb3ec6SMatthias Ringwald 
1863deb3ec6SMatthias Ringwald /* starts a sub-sequence, @returns handle for sub-sequence */
1873deb3ec6SMatthias Ringwald uint8_t * de_push_sequence(uint8_t *header){
1883deb3ec6SMatthias Ringwald     int element_len = de_get_len(header);
1893deb3ec6SMatthias Ringwald     de_store_descriptor_with_len(header+element_len, DE_DES, DE_SIZE_VAR_16, 0); // DES, 2 Byte Length
1903deb3ec6SMatthias Ringwald     return header + element_len;
1913deb3ec6SMatthias Ringwald }
1923deb3ec6SMatthias Ringwald 
1933deb3ec6SMatthias Ringwald /* closes the current sequence and updates the parent sequence */
1943deb3ec6SMatthias Ringwald void de_pop_sequence(uint8_t * parent, uint8_t * child){
1953deb3ec6SMatthias Ringwald     int child_len = de_get_len(child);
196f8fbdce0SMatthias Ringwald     int data_size_parent = big_endian_read_16(parent,1);
197f8fbdce0SMatthias Ringwald     big_endian_store_16(parent, 1, data_size_parent + child_len);
1983deb3ec6SMatthias Ringwald }
1993deb3ec6SMatthias Ringwald 
2003deb3ec6SMatthias Ringwald /* adds a single number value and 16+32 bit UUID to the sequence */
2013deb3ec6SMatthias Ringwald void de_add_number(uint8_t *seq, de_type_t type, de_size_t size, uint32_t value){
202f8fbdce0SMatthias Ringwald     int data_size   = big_endian_read_16(seq,1);
2033deb3ec6SMatthias Ringwald     int element_size = 1;   // e.g. for DE_TYPE_NIL
2043deb3ec6SMatthias Ringwald     de_store_descriptor(seq+3+data_size, type, size);
2053deb3ec6SMatthias Ringwald     switch (size){
2063deb3ec6SMatthias Ringwald         case DE_SIZE_8:
2073deb3ec6SMatthias Ringwald             if (type != DE_NIL){
2083deb3ec6SMatthias Ringwald                 seq[4+data_size] = value;
2093deb3ec6SMatthias Ringwald                 element_size = 2;
2103deb3ec6SMatthias Ringwald             }
2113deb3ec6SMatthias Ringwald             break;
2123deb3ec6SMatthias Ringwald         case DE_SIZE_16:
213f8fbdce0SMatthias Ringwald             big_endian_store_16(seq, 4+data_size, value);
2143deb3ec6SMatthias Ringwald             element_size = 3;
2153deb3ec6SMatthias Ringwald             break;
2163deb3ec6SMatthias Ringwald         case DE_SIZE_32:
217f8fbdce0SMatthias Ringwald             big_endian_store_32(seq, 4+data_size, value);
2183deb3ec6SMatthias Ringwald             element_size = 5;
2193deb3ec6SMatthias Ringwald             break;
2203deb3ec6SMatthias Ringwald         default:
2213deb3ec6SMatthias Ringwald             break;
2223deb3ec6SMatthias Ringwald     }
223f8fbdce0SMatthias Ringwald     big_endian_store_16(seq, 1, data_size+element_size);
2243deb3ec6SMatthias Ringwald }
2253deb3ec6SMatthias Ringwald 
2263deb3ec6SMatthias Ringwald /* add a single block of data, e.g. as DE_STRING, DE_URL */
2273deb3ec6SMatthias Ringwald void de_add_data( uint8_t *seq, de_type_t type, uint16_t size, uint8_t *data){
228f8fbdce0SMatthias Ringwald     int data_size   = big_endian_read_16(seq,1);
2293deb3ec6SMatthias Ringwald     if (size > 0xff) {
2303deb3ec6SMatthias Ringwald         // use 16-bit lengh information (3 byte header)
2313deb3ec6SMatthias Ringwald         de_store_descriptor_with_len(seq+3+data_size, type, DE_SIZE_VAR_16, size);
2323deb3ec6SMatthias Ringwald         data_size += 3;
2333deb3ec6SMatthias Ringwald     } else {
2343deb3ec6SMatthias Ringwald         // use 8-bit lengh information (2 byte header)
2353deb3ec6SMatthias Ringwald         de_store_descriptor_with_len(seq+3+data_size, type, DE_SIZE_VAR_8, size);
2363deb3ec6SMatthias Ringwald         data_size += 2;
2373deb3ec6SMatthias Ringwald     }
2383deb3ec6SMatthias Ringwald     memcpy( seq + 3 + data_size, data, size);
2393deb3ec6SMatthias Ringwald     data_size += size;
240f8fbdce0SMatthias Ringwald     big_endian_store_16(seq, 1, data_size);
2413deb3ec6SMatthias Ringwald }
2423deb3ec6SMatthias Ringwald 
2433deb3ec6SMatthias Ringwald void de_add_uuid128(uint8_t * seq, uint8_t * uuid){
244f8fbdce0SMatthias Ringwald     int data_size   = big_endian_read_16(seq,1);
2453deb3ec6SMatthias Ringwald     de_store_descriptor(seq+3+data_size, DE_UUID, DE_SIZE_128);
2463deb3ec6SMatthias Ringwald     memcpy( seq + 4 + data_size, uuid, 16);
247f8fbdce0SMatthias Ringwald     big_endian_store_16(seq, 1, data_size+1+16);
2483deb3ec6SMatthias Ringwald }
2493deb3ec6SMatthias Ringwald 
2503deb3ec6SMatthias Ringwald // MARK: DES iterator
2513deb3ec6SMatthias Ringwald int des_iterator_init(des_iterator_t * it, uint8_t * element){
2523deb3ec6SMatthias Ringwald     de_type_t type = de_get_element_type(element);
2533deb3ec6SMatthias Ringwald     if (type != DE_DES) return 0;
2543deb3ec6SMatthias Ringwald 
2553deb3ec6SMatthias Ringwald     it->element = element;
2563deb3ec6SMatthias Ringwald     it->pos = de_get_header_size(element);
2573deb3ec6SMatthias Ringwald     it->length = de_get_len(element);
2583deb3ec6SMatthias Ringwald     // printf("des_iterator_init current pos %d, total len %d\n", it->pos, it->length);
2593deb3ec6SMatthias Ringwald     return 1;
2603deb3ec6SMatthias Ringwald }
2613deb3ec6SMatthias Ringwald 
2623deb3ec6SMatthias Ringwald de_type_t des_iterator_get_type (des_iterator_t * it){
2633deb3ec6SMatthias Ringwald     return de_get_element_type(&it->element[it->pos]);
2643deb3ec6SMatthias Ringwald }
2653deb3ec6SMatthias Ringwald 
2663deb3ec6SMatthias Ringwald uint16_t des_iterator_get_size (des_iterator_t * it){
2673deb3ec6SMatthias Ringwald     int length = de_get_len(&it->element[it->pos]);
2683deb3ec6SMatthias Ringwald     int header_size = de_get_header_size(&it->element[it->pos]);
2693deb3ec6SMatthias Ringwald     return length - header_size;
2703deb3ec6SMatthias Ringwald }
2713deb3ec6SMatthias Ringwald 
2723deb3ec6SMatthias Ringwald int des_iterator_has_more(des_iterator_t * it){
2733deb3ec6SMatthias Ringwald     return it->pos < it->length;
2743deb3ec6SMatthias Ringwald }
2753deb3ec6SMatthias Ringwald 
2763deb3ec6SMatthias Ringwald uint8_t * des_iterator_get_element(des_iterator_t * it){
2773deb3ec6SMatthias Ringwald     if (!des_iterator_has_more(it)) return NULL;
2783deb3ec6SMatthias Ringwald     return &it->element[it->pos];
2793deb3ec6SMatthias Ringwald }
2803deb3ec6SMatthias Ringwald 
2813deb3ec6SMatthias Ringwald void des_iterator_next(des_iterator_t * it){
2823deb3ec6SMatthias Ringwald     int element_len = de_get_len(&it->element[it->pos]);
2833deb3ec6SMatthias Ringwald     // printf("des_iterator_next element size %d, current pos %d, total len %d\n", element_len, it->pos, it->length);
2843deb3ec6SMatthias Ringwald     it->pos += element_len;
2853deb3ec6SMatthias Ringwald }
2863deb3ec6SMatthias Ringwald 
2873deb3ec6SMatthias Ringwald // MARK: DataElementSequence traversal
2883deb3ec6SMatthias Ringwald typedef int (*de_traversal_callback_t)(uint8_t * element, de_type_t type, de_size_t size, void *context);
2893deb3ec6SMatthias Ringwald static void de_traverse_sequence(uint8_t * element, de_traversal_callback_t handler, void *context){
2903deb3ec6SMatthias Ringwald     de_type_t type = de_get_element_type(element);
2913deb3ec6SMatthias Ringwald     if (type != DE_DES) return;
2923deb3ec6SMatthias Ringwald     int pos = de_get_header_size(element);
2933deb3ec6SMatthias Ringwald     int end_pos = de_get_len(element);
2943deb3ec6SMatthias Ringwald     while (pos < end_pos){
2953deb3ec6SMatthias Ringwald         de_type_t elemType = de_get_element_type(element + pos);
2963deb3ec6SMatthias Ringwald         de_size_t elemSize = de_get_size_type(element + pos);
2973deb3ec6SMatthias Ringwald         uint8_t done = (*handler)(element + pos, elemType, elemSize, context);
2983deb3ec6SMatthias Ringwald         if (done) break;
2993deb3ec6SMatthias Ringwald         pos += de_get_len(element + pos);
3003deb3ec6SMatthias Ringwald     }
3013deb3ec6SMatthias Ringwald }
3023deb3ec6SMatthias Ringwald 
3033deb3ec6SMatthias Ringwald // MARK: AttributeList traversal
3043deb3ec6SMatthias Ringwald typedef int (*sdp_attribute_list_traversal_callback_t)(uint16_t attributeID, uint8_t * attributeValue, de_type_t type, de_size_t size, void *context);
3053deb3ec6SMatthias Ringwald static void sdp_attribute_list_traverse_sequence(uint8_t * element, sdp_attribute_list_traversal_callback_t handler, void *context){
3063deb3ec6SMatthias Ringwald     de_type_t type = de_get_element_type(element);
3073deb3ec6SMatthias Ringwald     if (type != DE_DES) return;
3083deb3ec6SMatthias Ringwald     int pos = de_get_header_size(element);
3093deb3ec6SMatthias Ringwald     int end_pos = de_get_len(element);
3103deb3ec6SMatthias Ringwald     while (pos < end_pos){
3113deb3ec6SMatthias Ringwald         de_type_t idType = de_get_element_type(element + pos);
3123deb3ec6SMatthias Ringwald         de_size_t idSize = de_get_size_type(element + pos);
3133deb3ec6SMatthias Ringwald         if (idType != DE_UINT || idSize != DE_SIZE_16) break; // wrong type
314f8fbdce0SMatthias Ringwald         uint16_t attribute_id = big_endian_read_16(element, pos + 1);
3153deb3ec6SMatthias Ringwald         pos += 3;
3163deb3ec6SMatthias Ringwald         if (pos >= end_pos) break; // array out of bounds
3173deb3ec6SMatthias Ringwald         de_type_t valueType = de_get_element_type(element + pos);
3183deb3ec6SMatthias Ringwald         de_size_t valueSize = de_get_size_type(element + pos);
3193deb3ec6SMatthias Ringwald         uint8_t done = (*handler)(attribute_id, element + pos, valueType, valueSize, context);
3203deb3ec6SMatthias Ringwald         if (done) break;
3213deb3ec6SMatthias Ringwald         pos += de_get_len(element + pos);
3223deb3ec6SMatthias Ringwald     }
3233deb3ec6SMatthias Ringwald }
3243deb3ec6SMatthias Ringwald 
3253deb3ec6SMatthias Ringwald // MARK: AttributeID in AttributeIDList
3263deb3ec6SMatthias Ringwald // attribute ID in AttributeIDList
3273deb3ec6SMatthias Ringwald // context { result, attributeID }
3283deb3ec6SMatthias Ringwald struct sdp_context_attributeID_search {
3293deb3ec6SMatthias Ringwald     int result;
3303deb3ec6SMatthias Ringwald     uint16_t attributeID;
3313deb3ec6SMatthias Ringwald };
3323deb3ec6SMatthias Ringwald static int sdp_traversal_attributeID_search(uint8_t * element, de_type_t type, de_size_t size, void *my_context){
3333deb3ec6SMatthias Ringwald     struct sdp_context_attributeID_search * context = (struct sdp_context_attributeID_search *) my_context;
3343deb3ec6SMatthias Ringwald     if (type != DE_UINT) return 0;
3353deb3ec6SMatthias Ringwald     switch (size) {
3363deb3ec6SMatthias Ringwald         case DE_SIZE_16:
337f8fbdce0SMatthias Ringwald             if (big_endian_read_16(element, 1) == context->attributeID) {
3383deb3ec6SMatthias Ringwald                 context->result = 1;
3393deb3ec6SMatthias Ringwald                 return 1;
3403deb3ec6SMatthias Ringwald             }
3413deb3ec6SMatthias Ringwald             break;
3423deb3ec6SMatthias Ringwald         case DE_SIZE_32:
343f8fbdce0SMatthias Ringwald             if (big_endian_read_16(element, 1) <= context->attributeID
344f8fbdce0SMatthias Ringwald             &&  context->attributeID <= big_endian_read_16(element, 3)) {
3453deb3ec6SMatthias Ringwald                 context->result = 1;
3463deb3ec6SMatthias Ringwald                 return 1;
3473deb3ec6SMatthias Ringwald             }
3483deb3ec6SMatthias Ringwald             break;
3493deb3ec6SMatthias Ringwald         default:
3503deb3ec6SMatthias Ringwald             break;
3513deb3ec6SMatthias Ringwald     }
3523deb3ec6SMatthias Ringwald     return 0;
3533deb3ec6SMatthias Ringwald }
3543deb3ec6SMatthias Ringwald 
3553deb3ec6SMatthias Ringwald int sdp_attribute_list_constains_id(uint8_t *attributeIDList, uint16_t attributeID){
3563deb3ec6SMatthias Ringwald     struct sdp_context_attributeID_search attributeID_search;
3573deb3ec6SMatthias Ringwald     attributeID_search.result = 0;
3583deb3ec6SMatthias Ringwald     attributeID_search.attributeID = attributeID;
3593deb3ec6SMatthias Ringwald     de_traverse_sequence(attributeIDList, sdp_traversal_attributeID_search, &attributeID_search);
3603deb3ec6SMatthias Ringwald     return attributeID_search.result;
3613deb3ec6SMatthias Ringwald }
3623deb3ec6SMatthias Ringwald 
3633deb3ec6SMatthias Ringwald // MARK: Append Attributes for AttributeIDList
3643deb3ec6SMatthias Ringwald // pre: buffer contains DES with 2 byte length field
3653deb3ec6SMatthias Ringwald struct sdp_context_append_attributes {
3663deb3ec6SMatthias Ringwald     uint8_t * buffer;
3673deb3ec6SMatthias Ringwald     uint16_t startOffset;     // offset of when to start copying
3683deb3ec6SMatthias Ringwald     uint16_t maxBytes;
3693deb3ec6SMatthias Ringwald     uint16_t usedBytes;
3703deb3ec6SMatthias Ringwald     uint8_t *attributeIDList;
3713deb3ec6SMatthias Ringwald };
3723deb3ec6SMatthias Ringwald 
3733deb3ec6SMatthias Ringwald static int sdp_traversal_append_attributes(uint16_t attributeID, uint8_t * attributeValue, de_type_t type, de_size_t size, void *my_context){
3743deb3ec6SMatthias Ringwald     struct sdp_context_append_attributes * context = (struct sdp_context_append_attributes *) my_context;
3753deb3ec6SMatthias Ringwald     if (sdp_attribute_list_constains_id(context->attributeIDList, attributeID)) {
3763deb3ec6SMatthias Ringwald         // DES_HEADER(3) + DES_DATA + (UINT16(3) + attribute)
377f8fbdce0SMatthias Ringwald         uint16_t data_size = big_endian_read_16(context->buffer, 1);
3783deb3ec6SMatthias Ringwald         int attribute_len = de_get_len(attributeValue);
3793deb3ec6SMatthias Ringwald         if (3 + data_size + (3 + attribute_len) <= context->maxBytes) {
3803deb3ec6SMatthias Ringwald             // copy Attribute
3813deb3ec6SMatthias Ringwald             de_add_number(context->buffer, DE_UINT, DE_SIZE_16, attributeID);
3823deb3ec6SMatthias Ringwald             data_size += 3; // 3 bytes
3833deb3ec6SMatthias Ringwald             memcpy(context->buffer + 3 + data_size, attributeValue, attribute_len);
384f8fbdce0SMatthias Ringwald             big_endian_store_16(context->buffer,1,data_size+attribute_len);
3853deb3ec6SMatthias Ringwald         } else {
3863deb3ec6SMatthias Ringwald             // not enought space left -> continue with previous element
3873deb3ec6SMatthias Ringwald             return 1;
3883deb3ec6SMatthias Ringwald         }
3893deb3ec6SMatthias Ringwald     }
3903deb3ec6SMatthias Ringwald     return 0;
3913deb3ec6SMatthias Ringwald }
3923deb3ec6SMatthias Ringwald 
3933deb3ec6SMatthias Ringwald // maxBytes: maximal size of data element sequence
3943deb3ec6SMatthias Ringwald uint16_t sdp_append_attributes_in_attributeIDList(uint8_t *record, uint8_t *attributeIDList, uint16_t startOffset, uint16_t maxBytes, uint8_t *buffer){
3953deb3ec6SMatthias Ringwald     struct sdp_context_append_attributes context;
3963deb3ec6SMatthias Ringwald     context.buffer = buffer;
3973deb3ec6SMatthias Ringwald     context.maxBytes = maxBytes;
3983deb3ec6SMatthias Ringwald     context.usedBytes = 0;
3993deb3ec6SMatthias Ringwald     context.startOffset = startOffset;
4003deb3ec6SMatthias Ringwald     context.attributeIDList = attributeIDList;
4013deb3ec6SMatthias Ringwald     sdp_attribute_list_traverse_sequence(record, sdp_traversal_append_attributes, &context);
4023deb3ec6SMatthias Ringwald     return context.usedBytes;
4033deb3ec6SMatthias Ringwald }
4043deb3ec6SMatthias Ringwald 
4053deb3ec6SMatthias Ringwald // MARK: Filter attributes that match attribute list from startOffset and a max nr bytes
4063deb3ec6SMatthias Ringwald struct sdp_context_filter_attributes {
4073deb3ec6SMatthias Ringwald     uint8_t * buffer;
4083deb3ec6SMatthias Ringwald     uint16_t startOffset;     // offset of when to start copying
4093deb3ec6SMatthias Ringwald     uint16_t maxBytes;
4103deb3ec6SMatthias Ringwald     uint16_t usedBytes;
4113deb3ec6SMatthias Ringwald     uint8_t *attributeIDList;
4123deb3ec6SMatthias Ringwald     int      complete;
4133deb3ec6SMatthias Ringwald };
4143deb3ec6SMatthias Ringwald 
4153deb3ec6SMatthias Ringwald // copy data with given start offset and max bytes, returns OK if all data has been copied
4163deb3ec6SMatthias Ringwald static int spd_append_range(struct sdp_context_filter_attributes* context, uint16_t len, uint8_t *data){
4173deb3ec6SMatthias Ringwald     int ok = 1;
4183deb3ec6SMatthias Ringwald     uint16_t remainder_len = len - context->startOffset;
4193deb3ec6SMatthias Ringwald     if (context->maxBytes < remainder_len){
4203deb3ec6SMatthias Ringwald         remainder_len = context->maxBytes;
4213deb3ec6SMatthias Ringwald         ok = 0;
4223deb3ec6SMatthias Ringwald     }
4233deb3ec6SMatthias Ringwald     memcpy(context->buffer, &data[context->startOffset], remainder_len);
4243deb3ec6SMatthias Ringwald     context->usedBytes += remainder_len;
4253deb3ec6SMatthias Ringwald     context->buffer    += remainder_len;
4263deb3ec6SMatthias Ringwald     context->maxBytes  -= remainder_len;
4273deb3ec6SMatthias Ringwald     context->startOffset = 0;
4283deb3ec6SMatthias Ringwald     return ok;
4293deb3ec6SMatthias Ringwald }
4303deb3ec6SMatthias Ringwald 
4313deb3ec6SMatthias Ringwald static int sdp_traversal_filter_attributes(uint16_t attributeID, uint8_t * attributeValue, de_type_t type, de_size_t size, void *my_context){
4323deb3ec6SMatthias Ringwald     struct sdp_context_filter_attributes * context = (struct sdp_context_filter_attributes *) my_context;
4333deb3ec6SMatthias Ringwald 
4343deb3ec6SMatthias Ringwald     if (!sdp_attribute_list_constains_id(context->attributeIDList, attributeID)) return 0;
4353deb3ec6SMatthias Ringwald 
4363deb3ec6SMatthias Ringwald     // { Attribute ID (Descriptor, big endian 16-bit ID), AttributeValue (data)}
4373deb3ec6SMatthias Ringwald 
4383deb3ec6SMatthias Ringwald     // handle Attribute ID
4393deb3ec6SMatthias Ringwald     if (context->startOffset >= 3){
4403deb3ec6SMatthias Ringwald         context->startOffset -= 3;
4413deb3ec6SMatthias Ringwald     } else {
4423deb3ec6SMatthias Ringwald         uint8_t idBuffer[3];
4433deb3ec6SMatthias Ringwald         de_store_descriptor(idBuffer, DE_UINT,  DE_SIZE_16);
444f8fbdce0SMatthias Ringwald         big_endian_store_16(idBuffer,1,attributeID);
4453deb3ec6SMatthias Ringwald 
4463deb3ec6SMatthias Ringwald         int ok = spd_append_range(context, 3, idBuffer);
4473deb3ec6SMatthias Ringwald         if (!ok) {
4483deb3ec6SMatthias Ringwald             context->complete = 0;
4493deb3ec6SMatthias Ringwald             return 1;
4503deb3ec6SMatthias Ringwald         }
4513deb3ec6SMatthias Ringwald     }
4523deb3ec6SMatthias Ringwald 
4533deb3ec6SMatthias Ringwald     // handle Attribute Value
4543deb3ec6SMatthias Ringwald     int attribute_len = de_get_len(attributeValue);
4553deb3ec6SMatthias Ringwald     if (context->startOffset >= attribute_len) {
4563deb3ec6SMatthias Ringwald         context->startOffset -= attribute_len;
4573deb3ec6SMatthias Ringwald         return 0;
4583deb3ec6SMatthias Ringwald     }
4593deb3ec6SMatthias Ringwald 
4603deb3ec6SMatthias Ringwald     int ok = spd_append_range(context, attribute_len, attributeValue);
4613deb3ec6SMatthias Ringwald     if (!ok) {
4623deb3ec6SMatthias Ringwald         context->complete = 0;
4633deb3ec6SMatthias Ringwald         return 1;
4643deb3ec6SMatthias Ringwald     }
4653deb3ec6SMatthias Ringwald     return 0;
4663deb3ec6SMatthias Ringwald }
4673deb3ec6SMatthias Ringwald 
4683deb3ec6SMatthias Ringwald int sdp_filter_attributes_in_attributeIDList(uint8_t *record, uint8_t *attributeIDList, uint16_t startOffset, uint16_t maxBytes, uint16_t *usedBytes, uint8_t *buffer){
4693deb3ec6SMatthias Ringwald 
4703deb3ec6SMatthias Ringwald     struct sdp_context_filter_attributes context;
4713deb3ec6SMatthias Ringwald     context.buffer = buffer;
4723deb3ec6SMatthias Ringwald     context.maxBytes = maxBytes;
4733deb3ec6SMatthias Ringwald     context.usedBytes = 0;
4743deb3ec6SMatthias Ringwald     context.startOffset = startOffset;
4753deb3ec6SMatthias Ringwald     context.attributeIDList = attributeIDList;
4763deb3ec6SMatthias Ringwald     context.complete = 1;
4773deb3ec6SMatthias Ringwald 
4783deb3ec6SMatthias Ringwald     sdp_attribute_list_traverse_sequence(record, sdp_traversal_filter_attributes, &context);
4793deb3ec6SMatthias Ringwald 
4803deb3ec6SMatthias Ringwald     *usedBytes = context.usedBytes;
4813deb3ec6SMatthias Ringwald     return context.complete;
4823deb3ec6SMatthias Ringwald }
4833deb3ec6SMatthias Ringwald 
4843deb3ec6SMatthias Ringwald // MARK: Get sum of attributes matching attribute list
4853deb3ec6SMatthias Ringwald struct sdp_context_get_filtered_size {
4863deb3ec6SMatthias Ringwald     uint8_t *attributeIDList;
4873deb3ec6SMatthias Ringwald     uint16_t size;
4883deb3ec6SMatthias Ringwald };
4893deb3ec6SMatthias Ringwald 
4903deb3ec6SMatthias Ringwald static int sdp_traversal_get_filtered_size(uint16_t attributeID, uint8_t * attributeValue, de_type_t type, de_size_t size, void *my_context){
4913deb3ec6SMatthias Ringwald     struct sdp_context_get_filtered_size * context = (struct sdp_context_get_filtered_size *) my_context;
4923deb3ec6SMatthias Ringwald     if (sdp_attribute_list_constains_id(context->attributeIDList, attributeID)) {
4933deb3ec6SMatthias Ringwald         context->size += 3 + de_get_len(attributeValue);
4943deb3ec6SMatthias Ringwald     }
4953deb3ec6SMatthias Ringwald     return 0;
4963deb3ec6SMatthias Ringwald }
4973deb3ec6SMatthias Ringwald 
4983deb3ec6SMatthias Ringwald int spd_get_filtered_size(uint8_t *record, uint8_t *attributeIDList){
4993deb3ec6SMatthias Ringwald     struct sdp_context_get_filtered_size context;
5003deb3ec6SMatthias Ringwald     context.size = 0;
5013deb3ec6SMatthias Ringwald     context.attributeIDList = attributeIDList;
5023deb3ec6SMatthias Ringwald     sdp_attribute_list_traverse_sequence(record, sdp_traversal_get_filtered_size, &context);
5033deb3ec6SMatthias Ringwald     return context.size;
5043deb3ec6SMatthias Ringwald }
5053deb3ec6SMatthias Ringwald 
5063deb3ec6SMatthias Ringwald // MARK: Get AttributeValue for AttributeID
5073deb3ec6SMatthias Ringwald // find attribute (ELEMENT) by ID
5083deb3ec6SMatthias Ringwald struct sdp_context_attribute_by_id {
5093deb3ec6SMatthias Ringwald     uint16_t  attributeID;
5103deb3ec6SMatthias Ringwald     uint8_t * attributeValue;
5113deb3ec6SMatthias Ringwald };
5123deb3ec6SMatthias Ringwald static int sdp_traversal_attribute_by_id(uint16_t attributeID, uint8_t * attributeValue, de_type_t attributeType, de_size_t size, void *my_context){
5133deb3ec6SMatthias Ringwald     struct sdp_context_attribute_by_id * context = (struct sdp_context_attribute_by_id *) my_context;
5143deb3ec6SMatthias Ringwald     if (attributeID == context->attributeID) {
5153deb3ec6SMatthias Ringwald         context->attributeValue = attributeValue;
5163deb3ec6SMatthias Ringwald         return 1;
5173deb3ec6SMatthias Ringwald     }
5183deb3ec6SMatthias Ringwald     return 0;
5193deb3ec6SMatthias Ringwald }
5203deb3ec6SMatthias Ringwald 
5213deb3ec6SMatthias Ringwald uint8_t * sdp_get_attribute_value_for_attribute_id(uint8_t * record, uint16_t attributeID){
5223deb3ec6SMatthias Ringwald     struct sdp_context_attribute_by_id context;
5233deb3ec6SMatthias Ringwald     context.attributeValue = NULL;
5243deb3ec6SMatthias Ringwald     context.attributeID = attributeID;
5253deb3ec6SMatthias Ringwald     sdp_attribute_list_traverse_sequence(record, sdp_traversal_attribute_by_id, &context);
5263deb3ec6SMatthias Ringwald     return context.attributeValue;
5273deb3ec6SMatthias Ringwald }
5283deb3ec6SMatthias Ringwald 
5293deb3ec6SMatthias Ringwald // MARK: Set AttributeValue for AttributeID
5303deb3ec6SMatthias Ringwald struct sdp_context_set_attribute_for_id {
5313deb3ec6SMatthias Ringwald     uint16_t  attributeID;
5323deb3ec6SMatthias Ringwald     uint32_t  attributeValue;
5333deb3ec6SMatthias Ringwald     uint8_t   attributeFound;
5343deb3ec6SMatthias Ringwald };
5353deb3ec6SMatthias Ringwald static int sdp_traversal_set_attribute_for_id(uint16_t attributeID, uint8_t * attributeValue, de_type_t attributeType, de_size_t size, void *my_context){
5363deb3ec6SMatthias Ringwald     struct sdp_context_set_attribute_for_id * context = (struct sdp_context_set_attribute_for_id *) my_context;
5373deb3ec6SMatthias Ringwald     if (attributeID == context->attributeID) {
5383deb3ec6SMatthias Ringwald         context->attributeFound = 1;
5393deb3ec6SMatthias Ringwald         switch (size){
5403deb3ec6SMatthias Ringwald             case DE_SIZE_8:
5413deb3ec6SMatthias Ringwald                 if (attributeType != DE_NIL){
5423deb3ec6SMatthias Ringwald                     attributeValue[1] = context->attributeValue;
5433deb3ec6SMatthias Ringwald                 }
5443deb3ec6SMatthias Ringwald                 break;
5453deb3ec6SMatthias Ringwald             case DE_SIZE_16:
546f8fbdce0SMatthias Ringwald                 big_endian_store_16(attributeValue, 1, context->attributeValue);
5473deb3ec6SMatthias Ringwald                 break;
5483deb3ec6SMatthias Ringwald             case DE_SIZE_32:
549f8fbdce0SMatthias Ringwald                 big_endian_store_32(attributeValue, 1, context->attributeValue);
5503deb3ec6SMatthias Ringwald                 break;
5513deb3ec6SMatthias Ringwald                 // Might want to support STRINGS to, copy upto original length
5523deb3ec6SMatthias Ringwald             default:
5533deb3ec6SMatthias Ringwald                 break;
5543deb3ec6SMatthias Ringwald         }
5553deb3ec6SMatthias Ringwald         return 1;
5563deb3ec6SMatthias Ringwald     }
5573deb3ec6SMatthias Ringwald     return 0;
5583deb3ec6SMatthias Ringwald }
5593deb3ec6SMatthias Ringwald uint8_t sdp_set_attribute_value_for_attribute_id(uint8_t * record, uint16_t attributeID, uint32_t value){
5603deb3ec6SMatthias Ringwald     struct sdp_context_set_attribute_for_id context;
5613deb3ec6SMatthias Ringwald     context.attributeID = attributeID;
5623deb3ec6SMatthias Ringwald     context.attributeValue = value;
5633deb3ec6SMatthias Ringwald     context.attributeFound = 0;
5643deb3ec6SMatthias Ringwald     sdp_attribute_list_traverse_sequence(record, sdp_traversal_set_attribute_for_id, &context);
5653deb3ec6SMatthias Ringwald     return context.attributeFound;
5663deb3ec6SMatthias Ringwald }
5673deb3ec6SMatthias Ringwald 
5683deb3ec6SMatthias Ringwald // MARK: ServiceRecord contains UUID
5693deb3ec6SMatthias Ringwald // service record contains UUID
5703deb3ec6SMatthias Ringwald // context { normalizedUUID }
5713deb3ec6SMatthias Ringwald struct sdp_context_contains_uuid128 {
5723deb3ec6SMatthias Ringwald     uint8_t * uuid128;
5733deb3ec6SMatthias Ringwald     int result;
5743deb3ec6SMatthias Ringwald };
5753deb3ec6SMatthias Ringwald int sdp_record_contains_UUID128(uint8_t *record, uint8_t *uuid128);
5763deb3ec6SMatthias Ringwald static int sdp_traversal_contains_UUID128(uint8_t * element, de_type_t type, de_size_t size, void *my_context){
5773deb3ec6SMatthias Ringwald     struct sdp_context_contains_uuid128 * context = (struct sdp_context_contains_uuid128 *) my_context;
5783deb3ec6SMatthias Ringwald     uint8_t normalizedUUID[16];
5793deb3ec6SMatthias Ringwald     if (type == DE_UUID){
5803deb3ec6SMatthias Ringwald         uint8_t uuidOK = de_get_normalized_uuid(normalizedUUID, element);
5813deb3ec6SMatthias Ringwald         context->result = uuidOK && memcmp(context->uuid128, normalizedUUID, 16) == 0;
5823deb3ec6SMatthias Ringwald     }
5833deb3ec6SMatthias Ringwald     if (type == DE_DES){
5843deb3ec6SMatthias Ringwald         context->result = sdp_record_contains_UUID128(element, context->uuid128);
5853deb3ec6SMatthias Ringwald     }
5863deb3ec6SMatthias Ringwald     return context->result;
5873deb3ec6SMatthias Ringwald }
5883deb3ec6SMatthias Ringwald int sdp_record_contains_UUID128(uint8_t *record, uint8_t *uuid128){
5893deb3ec6SMatthias Ringwald     struct sdp_context_contains_uuid128 context;
5903deb3ec6SMatthias Ringwald     context.uuid128 = uuid128;
5913deb3ec6SMatthias Ringwald     context.result = 0;
5923deb3ec6SMatthias Ringwald     de_traverse_sequence(record, sdp_traversal_contains_UUID128, &context);
5933deb3ec6SMatthias Ringwald     return context.result;
5943deb3ec6SMatthias Ringwald }
5953deb3ec6SMatthias Ringwald 
5963deb3ec6SMatthias Ringwald // MARK: ServiceRecord matches SearchServicePattern
5973deb3ec6SMatthias Ringwald // if UUID in searchServicePattern is not found in record => false
5983deb3ec6SMatthias Ringwald // context { result, record }
5993deb3ec6SMatthias Ringwald struct sdp_context_match_pattern {
6003deb3ec6SMatthias Ringwald     uint8_t * record;
6013deb3ec6SMatthias Ringwald     int result;
6023deb3ec6SMatthias Ringwald };
6033deb3ec6SMatthias Ringwald 
6043deb3ec6SMatthias Ringwald int sdp_traversal_match_pattern(uint8_t * element, de_type_t attributeType, de_size_t size, void *my_context){
6053deb3ec6SMatthias Ringwald     struct sdp_context_match_pattern * context = (struct sdp_context_match_pattern *) my_context;
6063deb3ec6SMatthias Ringwald     uint8_t normalizedUUID[16];
6073deb3ec6SMatthias Ringwald     uint8_t uuidOK = de_get_normalized_uuid(normalizedUUID, element);
6083deb3ec6SMatthias Ringwald     if (!uuidOK || !sdp_record_contains_UUID128(context->record, normalizedUUID)){
6093deb3ec6SMatthias Ringwald         context->result = 0;
6103deb3ec6SMatthias Ringwald         return 1;
6113deb3ec6SMatthias Ringwald     }
6123deb3ec6SMatthias Ringwald     return 0;
6133deb3ec6SMatthias Ringwald }
6143deb3ec6SMatthias Ringwald int sdp_record_matches_service_search_pattern(uint8_t *record, uint8_t *serviceSearchPattern){
6153deb3ec6SMatthias Ringwald     struct sdp_context_match_pattern context;
6163deb3ec6SMatthias Ringwald     context.record = record;
6173deb3ec6SMatthias Ringwald     context.result = 1;
6183deb3ec6SMatthias Ringwald     de_traverse_sequence(serviceSearchPattern, sdp_traversal_match_pattern, &context);
6193deb3ec6SMatthias Ringwald     return context.result;
6203deb3ec6SMatthias Ringwald }
6213deb3ec6SMatthias Ringwald 
6223deb3ec6SMatthias Ringwald // MARK: Dump DataElement
6233deb3ec6SMatthias Ringwald // context { indent }
624a9a4c409SMatthias Ringwald #ifdef ENABLE_SDP_DES_DUMP
6253deb3ec6SMatthias Ringwald static int de_traversal_dump_data(uint8_t * element, de_type_t de_type, de_size_t de_size, void *my_context){
6263deb3ec6SMatthias Ringwald     int indent = *(int*) my_context;
6273deb3ec6SMatthias Ringwald     int i;
6283deb3ec6SMatthias Ringwald     for (i=0; i<indent;i++) printf("    ");
6293deb3ec6SMatthias Ringwald     int pos     = de_get_header_size(element);
6303deb3ec6SMatthias Ringwald     int end_pos = de_get_len(element);
6313deb3ec6SMatthias Ringwald     printf("type %5s (%u), element len %2u ", type_names[de_type], de_type, end_pos);
6323deb3ec6SMatthias Ringwald     if (de_type == DE_DES) {
6333deb3ec6SMatthias Ringwald 		printf("\n");
6343deb3ec6SMatthias Ringwald         indent++;
6353deb3ec6SMatthias Ringwald         de_traverse_sequence(element, de_traversal_dump_data, (void *)&indent);
6363deb3ec6SMatthias Ringwald     } else if (de_type == DE_UUID && de_size == DE_SIZE_128) {
6371b0524c4SMatthias Ringwald         printf(", value: %s\n", uuid128_to_str(element+1));
6383deb3ec6SMatthias Ringwald     } else if (de_type == DE_STRING) {
6393deb3ec6SMatthias Ringwald         int len = 0;
6403deb3ec6SMatthias Ringwald         switch (de_size){
6413deb3ec6SMatthias Ringwald             case DE_SIZE_VAR_8:
6423deb3ec6SMatthias Ringwald                 len = element[1];
6433deb3ec6SMatthias Ringwald                 break;
6443deb3ec6SMatthias Ringwald             case DE_SIZE_VAR_16:
645f8fbdce0SMatthias Ringwald                 len = big_endian_read_16(element, 1);
6463deb3ec6SMatthias Ringwald                 break;
6473deb3ec6SMatthias Ringwald             default:
6483deb3ec6SMatthias Ringwald                 break;
6493deb3ec6SMatthias Ringwald         }
6503deb3ec6SMatthias Ringwald         printf("len %u (0x%02x)\n", len, len);
6513deb3ec6SMatthias Ringwald         printf_hexdump(&element[pos], len);
6523deb3ec6SMatthias Ringwald     } else {
6533deb3ec6SMatthias Ringwald         uint32_t value = 0;
6543deb3ec6SMatthias Ringwald         switch (de_size) {
6553deb3ec6SMatthias Ringwald             case DE_SIZE_8:
6563deb3ec6SMatthias Ringwald                 if (de_type != DE_NIL){
6573deb3ec6SMatthias Ringwald                     value = element[pos];
6583deb3ec6SMatthias Ringwald                 }
6593deb3ec6SMatthias Ringwald                 break;
6603deb3ec6SMatthias Ringwald             case DE_SIZE_16:
661f8fbdce0SMatthias Ringwald 				value = big_endian_read_16(element,pos);
6623deb3ec6SMatthias Ringwald                 break;
6633deb3ec6SMatthias Ringwald             case DE_SIZE_32:
664c9b8fdd9SMatthias Ringwald 				value = big_endian_read_32(element,pos);
6653deb3ec6SMatthias Ringwald                 break;
6663deb3ec6SMatthias Ringwald             default:
6673deb3ec6SMatthias Ringwald                 break;
6683deb3ec6SMatthias Ringwald         }
6693deb3ec6SMatthias Ringwald         printf(", value: 0x%08" PRIx32 "\n", value);
6703deb3ec6SMatthias Ringwald     }
6713deb3ec6SMatthias Ringwald     return 0;
6723deb3ec6SMatthias Ringwald }
6733deb3ec6SMatthias Ringwald #endif
6743deb3ec6SMatthias Ringwald 
6756c927b22SMatthias Ringwald void de_dump_data_element(const uint8_t * record){
676a9a4c409SMatthias Ringwald #ifdef ENABLE_SDP_DES_DUMP
6773deb3ec6SMatthias Ringwald     int indent = 0;
6783deb3ec6SMatthias Ringwald     // hack to get root DES, too.
6793deb3ec6SMatthias Ringwald     de_type_t type = de_get_element_type(record);
6803deb3ec6SMatthias Ringwald     de_size_t size = de_get_size_type(record);
6816c927b22SMatthias Ringwald     de_traversal_dump_data((uint8_t *) record, type, size, (void*) &indent);
6823deb3ec6SMatthias Ringwald #endif
6833deb3ec6SMatthias Ringwald }
6843deb3ec6SMatthias Ringwald 
685023f2764SMatthias Ringwald uint8_t* sdp_service_search_pattern_for_uuid16(uint16_t uuid16){
686023f2764SMatthias Ringwald     big_endian_store_16(des_serviceSearchPattern, 3, uuid16);
687023f2764SMatthias Ringwald     return (uint8_t*)des_serviceSearchPattern;
688023f2764SMatthias Ringwald }
689023f2764SMatthias Ringwald 
690023f2764SMatthias Ringwald uint8_t* sdp_service_search_pattern_for_uuid128(const uint8_t * uuid128){
691023f2764SMatthias Ringwald     memcpy(&des_serviceSearchPatternUUID128[3], uuid128, 16);
692023f2764SMatthias Ringwald     return (uint8_t*)des_serviceSearchPatternUUID128;
693023f2764SMatthias Ringwald }
694023f2764SMatthias Ringwald 
695