xref: /btstack/src/classic/sdp_client.c (revision 7a26a620f95123e94cd77336686fb29492996555)
1 /*
2  * Copyright (C) 2014 BlueKitchen GmbH
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the copyright holders nor the names of
14  *    contributors may be used to endorse or promote products derived
15  *    from this software without specific prior written permission.
16  * 4. Any redistribution, use, or modification is done solely for
17  *    personal benefit and not for any commercial purpose or for
18  *    monetary gain.
19  *
20  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
24  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * Please inquire about commercial licensing options at
34  * [email protected]
35  *
36  */
37 
38 #define __BTSTACK_FILE__ "sdp_client.c"
39 
40 /*
41  *  sdp_client.c
42  */
43 
44 #include "bluetooth_sdp.h"
45 #include "btstack_config.h"
46 #include "btstack_debug.h"
47 #include "btstack_event.h"
48 #include "classic/core.h"
49 #include "classic/sdp_client.h"
50 #include "classic/sdp_server.h"
51 #include "classic/sdp_util.h"
52 #include "hci_cmd.h"
53 #include "l2cap.h"
54 
55 // Types SDP Parser - Data Element stream helper
56 typedef enum {
57     GET_LIST_LENGTH = 1,
58     GET_RECORD_LENGTH,
59     GET_ATTRIBUTE_ID_HEADER_LENGTH,
60     GET_ATTRIBUTE_ID,
61     GET_ATTRIBUTE_VALUE_LENGTH,
62     GET_ATTRIBUTE_VALUE
63 } sdp_parser_state_t;
64 
65 // Types SDP Client
66 typedef enum {
67     INIT, W4_CONNECT, W2_SEND, W4_RESPONSE, QUERY_COMPLETE
68 } sdp_client_state_t;
69 
70 
71 // Prototypes SDP Parser
72 void sdp_parser_init(btstack_packet_handler_t callback);
73 void sdp_parser_handle_chunk(uint8_t * data, uint16_t size);
74 void sdp_parser_handle_done(uint8_t status);
75 void sdp_parser_init_service_attribute_search(void);
76 void sdp_parser_init_service_search(void);
77 void sdp_parser_handle_service_search(uint8_t * data, uint16_t total_count, uint16_t record_handle_count);
78 
79 // Prototypes SDP Client
80 void sdp_client_reset(void);
81 void sdp_client_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
82 static uint16_t sdp_client_setup_service_search_attribute_request(uint8_t * data);
83 #ifdef ENABLE_SDP_EXTRA_QUERIES
84 static uint16_t sdp_client_setup_service_search_request(uint8_t * data);
85 static uint16_t sdp_client_setup_service_attribute_request(uint8_t * data);
86 static void     sdp_client_parse_service_search_response(uint8_t* packet);
87 static void     sdp_client_parse_service_attribute_response(uint8_t* packet);
88 #endif
89 
90 static uint8_t des_attributeIDList[] = { 0x35, 0x05, 0x0A, 0x00, 0x01, 0xff, 0xff};  // Attribute: 0x0001 - 0x0100
91 
92 // State DES Parser
93 static de_state_t de_header_state;
94 
95 // State SDP Parser
96 static sdp_parser_state_t  state = GET_LIST_LENGTH;
97 static uint16_t attribute_id = 0;
98 static uint16_t attribute_bytes_received = 0;
99 static uint16_t attribute_bytes_delivered = 0;
100 static uint16_t list_offset = 0;
101 static uint16_t list_size;
102 static uint16_t record_offset = 0;
103 static uint16_t record_size;
104 static uint16_t attribute_value_size;
105 static int record_counter = 0;
106 static btstack_packet_handler_t sdp_parser_callback;
107 
108 // State SDP Client
109 static uint16_t  mtu;
110 static uint16_t  sdp_cid = 0x40;
111 static const uint8_t * service_search_pattern;
112 static const uint8_t * attribute_id_list;
113 static uint16_t  transactionID = 0;
114 static uint8_t   continuationState[16];
115 static uint8_t   continuationStateLen;
116 static sdp_client_state_t sdp_client_state = INIT;
117 static SDP_PDU_ID_t PDU_ID = SDP_Invalid;
118 #ifdef ENABLE_SDP_EXTRA_QUERIES
119 static uint32_t serviceRecordHandle;
120 static uint32_t record_handle;
121 #endif
122 
123 // DES Parser
124 void de_state_init(de_state_t * de_state){
125     de_state->in_state_GET_DE_HEADER_LENGTH = 1;
126     de_state->addon_header_bytes = 0;
127     de_state->de_size = 0;
128     de_state->de_offset = 0;
129 }
130 
131 int de_state_size(uint8_t eventByte, de_state_t *de_state){
132     if (de_state->in_state_GET_DE_HEADER_LENGTH){
133         de_state->addon_header_bytes = de_get_header_size(&eventByte) - 1;
134         de_state->de_size = 0;
135         de_state->de_offset = 0;
136 
137         if (de_state->addon_header_bytes == 0){
138             de_state->de_size = de_get_data_size(&eventByte);
139             if (de_state->de_size == 0) {
140                 log_error("  ERROR: ID size is zero");
141             }
142             // log_info("Data element payload is %d bytes.", de_state->de_size);
143             return 1;
144         }
145         de_state->in_state_GET_DE_HEADER_LENGTH = 0;
146         return 0;
147     }
148 
149     if (de_state->addon_header_bytes > 0){
150         de_state->de_size = (de_state->de_size << 8) | eventByte;
151         de_state->addon_header_bytes--;
152     }
153     if (de_state->addon_header_bytes > 0) return 0;
154     // log_info("Data element payload is %d bytes.", de_state->de_size);
155     de_state->in_state_GET_DE_HEADER_LENGTH = 1;
156     return 1;
157 }
158 
159 // SDP Parser
160 static void sdp_parser_emit_value_byte(uint8_t event_byte){
161     uint8_t event[11];
162     event[0] = SDP_EVENT_QUERY_ATTRIBUTE_VALUE;
163     event[1] = 9;
164     little_endian_store_16(event, 2, record_counter);
165     little_endian_store_16(event, 4, attribute_id);
166     little_endian_store_16(event, 6, attribute_value_size);
167     little_endian_store_16(event, 8, attribute_bytes_delivered);
168     event[10] = event_byte;
169     (*sdp_parser_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
170 }
171 
172 static void sdp_parser_process_byte(uint8_t eventByte){
173     // count all bytes
174     list_offset++;
175     record_offset++;
176 
177     // log_info(" parse BYTE_RECEIVED %02x", eventByte);
178     switch(state){
179         case GET_LIST_LENGTH:
180             if (!de_state_size(eventByte, &de_header_state)) break;
181             list_offset = de_header_state.de_offset;
182             list_size = de_header_state.de_size;
183             // log_info("parser: List offset %u, list size %u", list_offset, list_size);
184 
185             record_counter = 0;
186             state = GET_RECORD_LENGTH;
187             break;
188 
189         case GET_RECORD_LENGTH:
190             // check size
191             if (!de_state_size(eventByte, &de_header_state)) break;
192             // log_info("parser: Record payload is %d bytes.", de_header_state.de_size);
193             record_offset = de_header_state.de_offset;
194             record_size = de_header_state.de_size;
195             state = GET_ATTRIBUTE_ID_HEADER_LENGTH;
196             break;
197 
198         case GET_ATTRIBUTE_ID_HEADER_LENGTH:
199             if (!de_state_size(eventByte, &de_header_state)) break;
200             attribute_id = 0;
201             log_debug("ID data is stored in %d bytes.", (int) de_header_state.de_size);
202             state = GET_ATTRIBUTE_ID;
203             break;
204 
205         case GET_ATTRIBUTE_ID:
206             attribute_id = (attribute_id << 8) | eventByte;
207             de_header_state.de_size--;
208             if (de_header_state.de_size > 0) break;
209             log_debug("parser: Attribute ID: %04x.", attribute_id);
210 
211             state = GET_ATTRIBUTE_VALUE_LENGTH;
212             attribute_bytes_received  = 0;
213             attribute_bytes_delivered = 0;
214             attribute_value_size      = 0;
215             de_state_init(&de_header_state);
216             break;
217 
218         case GET_ATTRIBUTE_VALUE_LENGTH:
219             attribute_bytes_received++;
220             sdp_parser_emit_value_byte(eventByte);
221             attribute_bytes_delivered++;
222             if (!de_state_size(eventByte, &de_header_state)) break;
223 
224             attribute_value_size = de_header_state.de_size + attribute_bytes_received;
225 
226             state = GET_ATTRIBUTE_VALUE;
227             break;
228 
229         case GET_ATTRIBUTE_VALUE:
230             attribute_bytes_received++;
231             sdp_parser_emit_value_byte(eventByte);
232             attribute_bytes_delivered++;
233             // log_debug("paser: attribute_bytes_received %u, attribute_value_size %u", attribute_bytes_received, attribute_value_size);
234 
235             if (attribute_bytes_received < attribute_value_size) break;
236             // log_debug("parser: Record offset %u, record size %u", record_offset, record_size);
237             if (record_offset != record_size){
238                 state = GET_ATTRIBUTE_ID_HEADER_LENGTH;
239                 // log_debug("Get next attribute");
240                 break;
241             }
242             record_offset = 0;
243             // log_debug("parser: List offset %u, list size %u", list_offset, list_size);
244 
245             if (list_size > 0 && list_offset != list_size){
246                 record_counter++;
247                 state = GET_RECORD_LENGTH;
248                 log_debug("parser: END_OF_RECORD");
249                 break;
250             }
251             list_offset = 0;
252             de_state_init(&de_header_state);
253             state = GET_LIST_LENGTH;
254             record_counter = 0;
255             log_debug("parser: END_OF_RECORD & DONE");
256             break;
257         default:
258             break;
259     }
260 }
261 
262 void sdp_parser_init(btstack_packet_handler_t callback){
263     // init
264     sdp_parser_callback = callback;
265     de_state_init(&de_header_state);
266     state = GET_LIST_LENGTH;
267     list_offset = 0;
268     record_offset = 0;
269     record_counter = 0;
270 }
271 
272 void sdp_parser_handle_chunk(uint8_t * data, uint16_t size){
273     int i;
274     for (i=0;i<size;i++){
275         sdp_parser_process_byte(data[i]);
276     }
277 }
278 
279 #ifdef ENABLE_SDP_EXTRA_QUERIES
280 void sdp_parser_init_service_attribute_search(void){
281     // init
282     de_state_init(&de_header_state);
283     state = GET_RECORD_LENGTH;
284     list_offset = 0;
285     record_offset = 0;
286     record_counter = 0;
287 }
288 
289 void sdp_parser_init_service_search(void){
290     record_offset = 0;
291 }
292 
293 void sdp_parser_handle_service_search(uint8_t * data, uint16_t total_count, uint16_t record_handle_count){
294     int i;
295     for (i=0;i<record_handle_count;i++){
296         record_handle = big_endian_read_32(data, i*4);
297         record_counter++;
298         uint8_t event[10];
299         event[0] = SDP_EVENT_QUERY_SERVICE_RECORD_HANDLE;
300         event[1] = 8;
301         little_endian_store_16(event, 2, total_count);
302         little_endian_store_16(event, 4, record_counter);
303         little_endian_store_32(event, 6, record_handle);
304         (*sdp_parser_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
305     }
306 }
307 #endif
308 
309 void sdp_parser_handle_done(uint8_t status){
310     uint8_t event[3];
311     event[0] = SDP_EVENT_QUERY_COMPLETE;
312     event[1] = 1;
313     event[2] = status;
314     (*sdp_parser_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
315 }
316 
317 // SDP Client
318 
319 // TODO: inline if not needed (des(des))
320 
321 static void sdp_client_parse_attribute_lists(uint8_t* packet, uint16_t length){
322     sdp_parser_handle_chunk(packet, length);
323 }
324 
325 
326 static void sdp_client_send_request(uint16_t channel){
327 
328     if (sdp_client_state != W2_SEND) return;
329 
330     l2cap_reserve_packet_buffer();
331     uint8_t * data = l2cap_get_outgoing_buffer();
332     uint16_t request_len = 0;
333 
334     switch (PDU_ID){
335 #ifdef ENABLE_SDP_EXTRA_QUERIES
336         case SDP_ServiceSearchResponse:
337             request_len = sdp_client_setup_service_search_request(data);
338             break;
339         case SDP_ServiceAttributeResponse:
340             request_len = sdp_client_setup_service_attribute_request(data);
341             break;
342 #endif
343         case SDP_ServiceSearchAttributeResponse:
344             request_len = sdp_client_setup_service_search_attribute_request(data);
345             break;
346         default:
347             log_error("SDP Client sdp_client_send_request :: PDU ID invalid. %u", PDU_ID);
348             return;
349     }
350 
351     // prevent re-entrance
352     sdp_client_state = W4_RESPONSE;
353     PDU_ID = SDP_Invalid;
354     l2cap_send_prepared(channel, request_len);
355 }
356 
357 
358 static void sdp_client_parse_service_search_attribute_response(uint8_t* packet){
359     uint16_t offset = 3;
360     uint16_t parameterLength = big_endian_read_16(packet,offset);
361     offset+=2;
362     // AttributeListByteCount <= mtu
363     uint16_t attributeListByteCount = big_endian_read_16(packet,offset);
364     offset+=2;
365 
366     if (attributeListByteCount > mtu){
367         log_error("Error parsing ServiceSearchAttributeResponse: Number of bytes in found attribute list is larger then the MaximumAttributeByteCount.");
368         return;
369     }
370 
371     // AttributeLists
372     sdp_client_parse_attribute_lists(packet+offset, attributeListByteCount);
373     offset+=attributeListByteCount;
374 
375     continuationStateLen = packet[offset];
376     offset++;
377 
378     if (continuationStateLen > 16){
379         log_error("Error parsing ServiceSearchAttributeResponse: Number of bytes in continuation state exceedes 16.");
380         return;
381     }
382     memcpy(continuationState, packet+offset, continuationStateLen);
383     offset+=continuationStateLen;
384 
385     if (parameterLength != offset - 5){
386         log_error("Error parsing ServiceSearchAttributeResponse: wrong size of parameters, number of expected bytes%u, actual number %u.", parameterLength, offset);
387     }
388 }
389 
390 void sdp_client_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
391 
392     // uint16_t handle;
393     if (packet_type == L2CAP_DATA_PACKET){
394         if (size < 3) return;
395         uint16_t responseTransactionID = big_endian_read_16(packet,1);
396         if (responseTransactionID != transactionID){
397             log_error("Mismatching transaction ID, expected %u, found %u.", transactionID, responseTransactionID);
398             return;
399         }
400 
401         PDU_ID = (SDP_PDU_ID_t)packet[0];
402         switch (PDU_ID){
403             case SDP_ErrorResponse:
404                 log_error("Received error response with code %u, disconnecting", packet[2]);
405                 l2cap_disconnect(sdp_cid, 0);
406                 return;
407 #ifdef ENABLE_SDP_EXTRA_QUERIES
408             case SDP_ServiceSearchResponse:
409                 sdp_client_parse_service_search_response(packet);
410                 break;
411             case SDP_ServiceAttributeResponse:
412                 sdp_client_parse_service_attribute_response(packet);
413                 break;
414 #endif
415             case SDP_ServiceSearchAttributeResponse:
416                 sdp_client_parse_service_search_attribute_response(packet);
417                 break;
418             default:
419                 log_error("PDU ID %u unexpected/invalid", PDU_ID);
420                 return;
421         }
422 
423         // continuation set or DONE?
424         if (continuationStateLen == 0){
425             log_debug("SDP Client Query DONE! ");
426             sdp_client_state = QUERY_COMPLETE;
427             l2cap_disconnect(sdp_cid, 0);
428             return;
429         }
430         // prepare next request and send
431         sdp_client_state = W2_SEND;
432         l2cap_request_can_send_now_event(sdp_cid);
433         return;
434     }
435 
436     if (packet_type != HCI_EVENT_PACKET) return;
437 
438     switch(hci_event_packet_get_type(packet)){
439         case L2CAP_EVENT_CHANNEL_OPENED:
440             if (sdp_client_state != W4_CONNECT) break;
441             // data: event (8), len(8), status (8), address(48), handle (16), psm (16), local_cid(16), remote_cid (16), local_mtu(16), remote_mtu(16)
442             if (packet[2]) {
443                 log_info("SDP Client Connection failed, status 0x%02x.", packet[2]);
444                 sdp_client_state = INIT;
445                 sdp_parser_handle_done(packet[2]);
446                 break;
447             }
448             sdp_cid = channel;
449             mtu = little_endian_read_16(packet, 17);
450             // handle = little_endian_read_16(packet, 9);
451             log_debug("SDP Client Connected, cid %x, mtu %u.", sdp_cid, mtu);
452 
453             sdp_client_state = W2_SEND;
454             l2cap_request_can_send_now_event(sdp_cid);
455             break;
456 
457         case L2CAP_EVENT_CAN_SEND_NOW:
458             if(l2cap_event_can_send_now_get_local_cid(packet) == sdp_cid){
459                 sdp_client_send_request(sdp_cid);
460             }
461             break;
462         case L2CAP_EVENT_CHANNEL_CLOSED: {
463             if (sdp_cid != little_endian_read_16(packet, 2)) {
464                 // log_info("Received L2CAP_EVENT_CHANNEL_CLOSED for cid %x, current cid %x\n",  little_endian_read_16(packet, 2),sdp_cid);
465                 break;
466             }
467             log_info("SDP Client disconnected.");
468             uint8_t status = sdp_client_state == QUERY_COMPLETE ? 0 : SDP_QUERY_INCOMPLETE;
469             sdp_client_state = INIT;
470             sdp_parser_handle_done(status);
471             break;
472         }
473         default:
474             break;
475     }
476 }
477 
478 
479 static uint16_t sdp_client_setup_service_search_attribute_request(uint8_t * data){
480 
481     uint16_t offset = 0;
482     transactionID++;
483     // uint8_t SDP_PDU_ID_t.SDP_ServiceSearchRequest;
484     data[offset++] = SDP_ServiceSearchAttributeRequest;
485     // uint16_t transactionID
486     big_endian_store_16(data, offset, transactionID);
487     offset += 2;
488 
489     // param legnth
490     offset += 2;
491 
492     // parameters:
493     //     Service_search_pattern - DES (min 1 UUID, max 12)
494     uint16_t service_search_pattern_len = de_get_len(service_search_pattern);
495     memcpy(data + offset, service_search_pattern, service_search_pattern_len);
496     offset += service_search_pattern_len;
497 
498     //     MaximumAttributeByteCount - uint16_t  0x0007 - 0xffff -> mtu
499     big_endian_store_16(data, offset, mtu);
500     offset += 2;
501 
502     //     AttibuteIDList
503     uint16_t attribute_id_list_len = de_get_len(attribute_id_list);
504     memcpy(data + offset, attribute_id_list, attribute_id_list_len);
505     offset += attribute_id_list_len;
506 
507     //     ContinuationState - uint8_t number of cont. bytes N<=16
508     data[offset++] = continuationStateLen;
509     //                       - N-bytes previous response from server
510     memcpy(data + offset, continuationState, continuationStateLen);
511     offset += continuationStateLen;
512 
513     // uint16_t paramLength
514     big_endian_store_16(data, 3, offset - 5);
515 
516     return offset;
517 }
518 
519 #ifdef ENABLE_SDP_EXTRA_QUERIES
520 void sdp_client_parse_service_record_handle_list(uint8_t* packet, uint16_t total_count, uint16_t current_count){
521     sdp_parser_handle_service_search(packet, total_count, current_count);
522 }
523 
524 static uint16_t sdp_client_setup_service_search_request(uint8_t * data){
525     uint16_t offset = 0;
526     transactionID++;
527     // uint8_t SDP_PDU_ID_t.SDP_ServiceSearchRequest;
528     data[offset++] = SDP_ServiceSearchRequest;
529     // uint16_t transactionID
530     big_endian_store_16(data, offset, transactionID);
531     offset += 2;
532 
533     // param legnth
534     offset += 2;
535 
536     // parameters:
537     //     Service_search_pattern - DES (min 1 UUID, max 12)
538     uint16_t service_search_pattern_len = de_get_len(service_search_pattern);
539     memcpy(data + offset, service_search_pattern, service_search_pattern_len);
540     offset += service_search_pattern_len;
541 
542     //     MaximumAttributeByteCount - uint16_t  0x0007 - 0xffff -> mtu
543     big_endian_store_16(data, offset, mtu);
544     offset += 2;
545 
546     //     ContinuationState - uint8_t number of cont. bytes N<=16
547     data[offset++] = continuationStateLen;
548     //                       - N-bytes previous response from server
549     memcpy(data + offset, continuationState, continuationStateLen);
550     offset += continuationStateLen;
551 
552     // uint16_t paramLength
553     big_endian_store_16(data, 3, offset - 5);
554 
555     return offset;
556 }
557 
558 
559 static uint16_t sdp_client_setup_service_attribute_request(uint8_t * data){
560 
561     uint16_t offset = 0;
562     transactionID++;
563     // uint8_t SDP_PDU_ID_t.SDP_ServiceSearchRequest;
564     data[offset++] = SDP_ServiceAttributeRequest;
565     // uint16_t transactionID
566     big_endian_store_16(data, offset, transactionID);
567     offset += 2;
568 
569     // param legnth
570     offset += 2;
571 
572     // parameters:
573     //     ServiceRecordHandle
574     big_endian_store_32(data, offset, serviceRecordHandle);
575     offset += 4;
576 
577     //     MaximumAttributeByteCount - uint16_t  0x0007 - 0xffff -> mtu
578     big_endian_store_16(data, offset, mtu);
579     offset += 2;
580 
581     //     AttibuteIDList
582     uint16_t attribute_id_list_len = de_get_len(attribute_id_list);
583     memcpy(data + offset, attribute_id_list, attribute_id_list_len);
584     offset += attribute_id_list_len;
585 
586     //     ContinuationState - uint8_t number of cont. bytes N<=16
587     data[offset++] = continuationStateLen;
588     //                       - N-bytes previous response from server
589     memcpy(data + offset, continuationState, continuationStateLen);
590     offset += continuationStateLen;
591 
592     // uint16_t paramLength
593     big_endian_store_16(data, 3, offset - 5);
594 
595     return offset;
596 }
597 
598 static void sdp_client_parse_service_search_response(uint8_t* packet){
599     uint16_t offset = 3;
600     uint16_t parameterLength = big_endian_read_16(packet,offset);
601     offset+=2;
602 
603     uint16_t totalServiceRecordCount = big_endian_read_16(packet,offset);
604     offset+=2;
605 
606     uint16_t currentServiceRecordCount = big_endian_read_16(packet,offset);
607     offset+=2;
608     if (currentServiceRecordCount > totalServiceRecordCount){
609         log_error("CurrentServiceRecordCount is larger then TotalServiceRecordCount.");
610         return;
611     }
612 
613     sdp_client_parse_service_record_handle_list(packet+offset, totalServiceRecordCount, currentServiceRecordCount);
614     offset+=(currentServiceRecordCount * 4);
615 
616     continuationStateLen = packet[offset];
617     offset++;
618     if (continuationStateLen > 16){
619         log_error("Error parsing ServiceSearchResponse: Number of bytes in continuation state exceedes 16.");
620         return;
621     }
622     memcpy(continuationState, packet+offset, continuationStateLen);
623     offset+=continuationStateLen;
624 
625     if (parameterLength != offset - 5){
626         log_error("Error parsing ServiceSearchResponse: wrong size of parameters, number of expected bytes%u, actual number %u.", parameterLength, offset);
627     }
628 }
629 
630 static void sdp_client_parse_service_attribute_response(uint8_t* packet){
631     uint16_t offset = 3;
632     uint16_t parameterLength = big_endian_read_16(packet,offset);
633     offset+=2;
634 
635     // AttributeListByteCount <= mtu
636     uint16_t attributeListByteCount = big_endian_read_16(packet,offset);
637     offset+=2;
638 
639     if (attributeListByteCount > mtu){
640         log_error("Error parsing ServiceSearchAttributeResponse: Number of bytes in found attribute list is larger then the MaximumAttributeByteCount.");
641         return;
642     }
643 
644     // AttributeLists
645     sdp_client_parse_attribute_lists(packet+offset, attributeListByteCount);
646     offset+=attributeListByteCount;
647 
648     continuationStateLen = packet[offset];
649     offset++;
650 
651     if (continuationStateLen > 16){
652         log_error("Error parsing ServiceAttributeResponse: Number of bytes in continuation state exceedes 16.");
653         return;
654     }
655     memcpy(continuationState, packet+offset, continuationStateLen);
656     offset+=continuationStateLen;
657 
658     if (parameterLength != offset - 5){
659         log_error("Error parsing ServiceAttributeResponse: wrong size of parameters, number of expected bytes%u, actual number %u.", parameterLength, offset);
660     }
661 }
662 #endif
663 
664 // for testing only
665 void sdp_client_reset(void){
666     sdp_client_state = INIT;
667 }
668 
669 // Public API
670 
671 int sdp_client_ready(void){
672     return sdp_client_state == INIT;
673 }
674 
675 uint8_t sdp_client_query(btstack_packet_handler_t callback, bd_addr_t remote, const uint8_t * des_service_search_pattern, const uint8_t * des_attribute_id_list){
676     if (!sdp_client_ready()) return SDP_QUERY_BUSY;
677 
678     sdp_parser_init(callback);
679     service_search_pattern = des_service_search_pattern;
680     attribute_id_list = des_attribute_id_list;
681     continuationStateLen = 0;
682     PDU_ID = SDP_ServiceSearchAttributeResponse;
683 
684     sdp_client_state = W4_CONNECT;
685     return l2cap_create_channel(sdp_client_packet_handler, remote, BLUETOOTH_PROTOCOL_SDP, l2cap_max_mtu(), NULL);
686 }
687 
688 uint8_t sdp_client_query_uuid16(btstack_packet_handler_t callback, bd_addr_t remote, uint16_t uuid){
689     if (!sdp_client_ready()) return SDP_QUERY_BUSY;
690     return sdp_client_query(callback, remote, sdp_service_search_pattern_for_uuid16(uuid), des_attributeIDList);
691 }
692 
693 uint8_t sdp_client_query_uuid128(btstack_packet_handler_t callback, bd_addr_t remote, const uint8_t* uuid){
694     if (!sdp_client_ready()) return SDP_QUERY_BUSY;
695     return sdp_client_query(callback, remote, sdp_service_search_pattern_for_uuid128(uuid), des_attributeIDList);
696 }
697 
698 #ifdef ENABLE_SDP_EXTRA_QUERIES
699 uint8_t sdp_client_service_attribute_search(btstack_packet_handler_t callback, bd_addr_t remote, uint32_t search_service_record_handle, const uint8_t * des_attribute_id_list){
700     if (!sdp_client_ready()) return SDP_QUERY_BUSY;
701 
702     sdp_parser_init(callback);
703     serviceRecordHandle = search_service_record_handle;
704     attribute_id_list = des_attribute_id_list;
705     continuationStateLen = 0;
706     PDU_ID = SDP_ServiceAttributeResponse;
707 
708     sdp_client_state = W4_CONNECT;
709     l2cap_create_channel(sdp_client_packet_handler, remote, BLUETOOTH_PROTOCOL_SDP, l2cap_max_mtu(), NULL);
710     return 0;
711 }
712 
713 uint8_t sdp_client_service_search(btstack_packet_handler_t callback, bd_addr_t remote, const uint8_t * des_service_search_pattern){
714 
715     if (!sdp_client_ready()) return SDP_QUERY_BUSY;
716 
717     sdp_parser_init(callback);
718     service_search_pattern = des_service_search_pattern;
719     continuationStateLen = 0;
720     PDU_ID = SDP_ServiceSearchResponse;
721 
722     sdp_client_state = W4_CONNECT;
723     l2cap_create_channel(sdp_client_packet_handler, remote, BLUETOOTH_PROTOCOL_SDP, l2cap_max_mtu(), NULL);
724     return 0;
725 }
726 #endif
727 
728