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__ "pbap_client.c" 39 40 #include "btstack_config.h" 41 42 #include <stdint.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 47 #include "hci_cmd.h" 48 #include "btstack_run_loop.h" 49 #include "btstack_debug.h" 50 #include "hci.h" 51 #include "btstack_memory.h" 52 #include "hci_dump.h" 53 #include "l2cap.h" 54 #include "bluetooth_sdp.h" 55 #include "classic/sdp_client_rfcomm.h" 56 #include "btstack_event.h" 57 #include "md5.h" 58 #include "yxml.h" 59 60 #include "classic/obex.h" 61 #include "classic/obex_iterator.h" 62 #include "classic/goep_client.h" 63 #include "classic/pbap_client.h" 64 65 // 796135f0-f0c5-11d8-0966- 0800200c9a66 66 static const uint8_t pbap_uuid[] = { 0x79, 0x61, 0x35, 0xf0, 0xf0, 0xc5, 0x11, 0xd8, 0x09, 0x66, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66}; 67 68 const char * pbap_phonebook_type = "x-bt/phonebook"; 69 const char * pbap_phonebook_name = "pb.vcf"; 70 71 const char * pbap_vcard_listing_type = "x-bt/vcard-listing"; 72 const char * pbap_vcard_listing_name = "pb"; 73 74 // default 75 static uint32_t pbap_supported_features = 0x0000; 76 77 typedef enum { 78 PBAP_INIT = 0, 79 PBAP_W4_GOEP_CONNECTION, 80 PBAP_W2_SEND_CONNECT_REQUEST, 81 PBAP_W4_CONNECT_RESPONSE, 82 PBAP_W4_USER_AUTHENTICATION, 83 PBAP_W2_SEND_AUTHENTICATED_CONNECT, 84 PBAP_CONNECT_RESPONSE_RECEIVED, 85 PBAP_CONNECTED, 86 // 87 PBAP_W2_SEND_DISCONNECT_REQUEST, 88 PBAP_W4_DISCONNECT_RESPONSE, 89 // 90 PBAP_W2_PULL_PHONEBOOK, 91 PBAP_W4_PHONEBOOK, 92 PBAP_W2_SET_PATH_ROOT, 93 PBAP_W4_SET_PATH_ROOT_COMPLETE, 94 PBAP_W2_SET_PATH_ELEMENT, 95 PBAP_W4_SET_PATH_ELEMENT_COMPLETE, 96 PBAP_W2_GET_PHONEBOOK_SIZE, 97 PBAP_W4_GET_PHONEBOOK_SIZE_COMPLETE, 98 // 99 PBAP_W2_GET_CARD_LIST, 100 PBAP_W4_GET_CARD_LIST_COMPLETE, 101 102 } pbap_state_t; 103 104 typedef enum { 105 SRM_DISABLED, 106 SRM_W4_CONFIRM, 107 SRM_ENABLED_BUT_WAITING, 108 SRM_ENABLED 109 } srm_state_t; 110 111 typedef struct pbap_client { 112 pbap_state_t state; 113 uint16_t cid; 114 bd_addr_t bd_addr; 115 hci_con_handle_t con_handle; 116 uint8_t incoming; 117 uint16_t goep_cid; 118 btstack_packet_handler_t client_handler; 119 int request_number; 120 srm_state_t srm_state; 121 int single_response_mode_parameter; 122 const char * current_folder; 123 const char * phone_number; 124 uint16_t set_path_offset; 125 uint8_t authentication_options; 126 uint16_t authentication_nonce[16]; 127 const char * authentication_password; 128 yxml_t xml_parser; 129 uint8_t xml_buffer[50]; 130 } pbap_client_t; 131 132 static pbap_client_t _pbap_client; 133 static pbap_client_t * pbap_client = &_pbap_client; 134 135 static void pbap_client_emit_connected_event(pbap_client_t * context, uint8_t status){ 136 uint8_t event[15]; 137 int pos = 0; 138 event[pos++] = HCI_EVENT_PBAP_META; 139 pos++; // skip len 140 event[pos++] = PBAP_SUBEVENT_CONNECTION_OPENED; 141 little_endian_store_16(event,pos,context->cid); 142 pos+=2; 143 event[pos++] = status; 144 memcpy(&event[pos], context->bd_addr, 6); 145 pos += 6; 146 little_endian_store_16(event,pos,context->con_handle); 147 pos += 2; 148 event[pos++] = context->incoming; 149 event[1] = pos - 2; 150 if (pos != sizeof(event)) log_error("goep_client_emit_connected_event size %u", pos); 151 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 152 } 153 154 static void pbap_client_emit_connection_closed_event(pbap_client_t * context){ 155 uint8_t event[5]; 156 int pos = 0; 157 event[pos++] = HCI_EVENT_PBAP_META; 158 pos++; // skip len 159 event[pos++] = PBAP_SUBEVENT_CONNECTION_CLOSED; 160 little_endian_store_16(event,pos,context->cid); 161 pos+=2; 162 event[1] = pos - 2; 163 if (pos != sizeof(event)) log_error("pbap_client_emit_connection_closed_event size %u", pos); 164 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 165 } 166 167 static void pbap_client_emit_operation_complete_event(pbap_client_t * context, uint8_t status){ 168 uint8_t event[6]; 169 int pos = 0; 170 event[pos++] = HCI_EVENT_PBAP_META; 171 pos++; // skip len 172 event[pos++] = PBAP_SUBEVENT_OPERATION_COMPLETED; 173 little_endian_store_16(event,pos,context->cid); 174 pos+=2; 175 event[pos++]= status; 176 event[1] = pos - 2; 177 if (pos != sizeof(event)) log_error("pbap_client_emit_can_send_now_event size %u", pos); 178 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 179 } 180 181 static void pbap_client_emit_phonebook_size_event(pbap_client_t * context, uint8_t status, uint16_t phonebook_size){ 182 uint8_t event[8]; 183 int pos = 0; 184 event[pos++] = HCI_EVENT_PBAP_META; 185 pos++; // skip len 186 event[pos++] = PBAP_SUBEVENT_PHONEBOOK_SIZE; 187 little_endian_store_16(event,pos,context->cid); 188 pos+=2; 189 event[pos++] = status; 190 little_endian_store_16(event,pos, phonebook_size); 191 pos+=2; 192 event[1] = pos - 2; 193 if (pos != sizeof(event)) log_error("pbap_client_emit_phonebook_size_event size %u", pos); 194 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 195 } 196 197 static void pbap_client_emit_authentication_event(pbap_client_t * context, uint8_t options){ 198 // split options 199 uint8_t user_id_required = options & 1 ? 1 : 0; 200 uint8_t full_access = options & 2 ? 1 : 0; 201 202 uint8_t event[7]; 203 int pos = 0; 204 event[pos++] = HCI_EVENT_PBAP_META; 205 pos++; // skip len 206 event[pos++] = PBAP_SUBEVENT_AUTHENTICATION_REQUEST; 207 little_endian_store_16(event,pos,context->cid); 208 pos+=2; 209 event[pos++] = user_id_required; 210 event[pos++] = full_access; 211 if (pos != sizeof(event)) log_error("pbap_client_emit_authentication_event size %u", pos); 212 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 213 } 214 215 static void pbap_client_emit_card_result_event(pbap_client_t * context, const char * name, const char * handle){ 216 uint8_t event[5 + PBAP_MAX_NAME_LEN + PBAP_MAX_HANDLE_LEN]; 217 int pos = 0; 218 event[pos++] = HCI_EVENT_PBAP_META; 219 pos++; // skip len 220 event[pos++] = PBAP_SUBEVENT_CARD_RESULT; 221 little_endian_store_16(event,pos,context->cid); 222 pos+=2; 223 int name_len = btstack_min(PBAP_MAX_NAME_LEN, strlen(name)); 224 event[pos++] = name_len; 225 memcpy(&event[pos], name, name_len); 226 pos += name_len; 227 int handle_len = btstack_min(PBAP_MAX_HANDLE_LEN, strlen(handle)); 228 event[pos++] = handle_len; 229 memcpy(&event[pos], handle, handle_len); 230 pos += handle_len; 231 event[1] = pos - 2; 232 context->client_handler(HCI_EVENT_PACKET, context->cid, &event[0], pos); 233 } 234 235 static const uint8_t collon = (uint8_t) ':'; 236 237 static void pbap_handle_can_send_now(void){ 238 uint8_t path_element[20]; 239 uint16_t path_element_start; 240 uint16_t path_element_len; 241 uint8_t application_parameters[PBAP_MAX_PHONE_NUMBER_LEN + 10]; 242 uint8_t challenge_response[36]; 243 int i; 244 uint16_t phone_number_len; 245 246 MD5_CTX md5_ctx; 247 248 switch (pbap_client->state){ 249 case PBAP_W2_SEND_CONNECT_REQUEST: 250 goep_client_create_connect_request(pbap_client->goep_cid, OBEX_VERSION, 0, OBEX_MAX_PACKETLEN_DEFAULT); 251 goep_client_add_header_target(pbap_client->goep_cid, 16, pbap_uuid); 252 // Mandatory if the PSE advertises a PbapSupportedFeatures attribute in its SDP record, else excluded. 253 if (goep_client_get_pbap_supported_features(pbap_client->goep_cid) != PBAP_FEATURES_NOT_PRESENT){ 254 application_parameters[0] = PBAP_APPLICATION_PARAMETER_PBAP_SUPPORTED_FEATURES; 255 application_parameters[1] = 4; 256 big_endian_store_32(application_parameters, 2, pbap_supported_features); 257 goep_client_add_header_application_parameters(pbap_client->goep_cid, 6, &application_parameters[0]); 258 } 259 pbap_client->state = PBAP_W4_CONNECT_RESPONSE; 260 goep_client_execute(pbap_client->goep_cid); 261 break; 262 case PBAP_W2_SEND_AUTHENTICATED_CONNECT: 263 goep_client_create_connect_request(pbap_client->goep_cid, OBEX_VERSION, 0, OBEX_MAX_PACKETLEN_DEFAULT); 264 goep_client_add_header_target(pbap_client->goep_cid, 16, pbap_uuid); 265 // setup authentication challenge response 266 i = 0; 267 challenge_response[i++] = 0; // Tag Digest 268 challenge_response[i++] = 16; // Len 269 // calculate md5 270 MD5_Init(&md5_ctx); 271 MD5_Update(&md5_ctx, pbap_client->authentication_nonce, 16); 272 MD5_Update(&md5_ctx, &collon, 1); 273 MD5_Update(&md5_ctx, pbap_client->authentication_password, strlen(pbap_client->authentication_password)); 274 MD5_Final(&challenge_response[i], &md5_ctx); 275 i += 16; 276 challenge_response[i++] = 2; // Tag Nonce 277 challenge_response[i++] = 16; // Len 278 memcpy(&challenge_response[i], pbap_client->authentication_nonce, 16); 279 i += 16; 280 goep_client_add_header_challenge_response(pbap_client->goep_cid, i, challenge_response); 281 pbap_client->state = PBAP_W4_CONNECT_RESPONSE; 282 goep_client_execute(pbap_client->goep_cid); 283 break; 284 case PBAP_W2_SEND_DISCONNECT_REQUEST: 285 goep_client_create_disconnect_request(pbap_client->goep_cid); 286 pbap_client->state = PBAP_W4_DISCONNECT_RESPONSE; 287 goep_client_execute(pbap_client->goep_cid); 288 return; 289 case PBAP_W2_PULL_PHONEBOOK: 290 case PBAP_W2_GET_PHONEBOOK_SIZE: 291 goep_client_create_get_request(pbap_client->goep_cid); 292 if (pbap_client->request_number == 0){ 293 goep_client_add_header_srm_enable(pbap_client->goep_cid); 294 pbap_client->srm_state = SRM_W4_CONFIRM; 295 goep_client_add_header_type(pbap_client->goep_cid, pbap_phonebook_type); 296 goep_client_add_header_name(pbap_client->goep_cid, pbap_phonebook_name); 297 if (pbap_client->state == PBAP_W2_GET_PHONEBOOK_SIZE){ 298 // Regular TLV wih 1-byte len 299 application_parameters[0] = PBAP_APPLICATION_PARAMETER_MAX_LIST_COUNT; 300 application_parameters[1] = 2; 301 big_endian_store_16(application_parameters, 2, 0); 302 goep_client_add_header_application_parameters(pbap_client->goep_cid, 4, &application_parameters[0]); 303 } else { 304 // 305 } 306 } 307 if (pbap_client->state == PBAP_W2_GET_PHONEBOOK_SIZE){ 308 // state 309 pbap_client->state = PBAP_W4_GET_PHONEBOOK_SIZE_COMPLETE; 310 } else { 311 // state 312 pbap_client->state = PBAP_W4_PHONEBOOK; 313 } 314 // send packet 315 pbap_client->request_number++; 316 goep_client_execute(pbap_client->goep_cid); 317 break; 318 case PBAP_W2_GET_CARD_LIST: 319 goep_client_create_get_request(pbap_client->goep_cid); 320 goep_client_add_header_type(pbap_client->goep_cid, pbap_vcard_listing_type); 321 goep_client_add_header_name(pbap_client->goep_cid, pbap_vcard_listing_name); 322 // Regular TLV wih 1-byte len 323 i = 0; 324 phone_number_len = btstack_min(PBAP_MAX_PHONE_NUMBER_LEN, strlen(pbap_client->phone_number)); 325 application_parameters[i++] = PBAP_APPLICATION_PARAMETER_SEARCH_VALUE; 326 application_parameters[i++] = phone_number_len; 327 memcpy(&application_parameters[i], pbap_client->phone_number, phone_number_len); 328 i += phone_number_len; 329 application_parameters[i++] = PBAP_APPLICATION_PARAMETER_SEARCH_PROPERTY; 330 application_parameters[i++] = 1; 331 application_parameters[i++] = 0x01; // Number 332 goep_client_add_header_application_parameters(pbap_client->goep_cid, i, &application_parameters[0]); 333 pbap_client->state = PBAP_W4_GET_CARD_LIST_COMPLETE; 334 // send packet 335 goep_client_execute(pbap_client->goep_cid); 336 break; 337 case PBAP_W2_SET_PATH_ROOT: 338 goep_client_create_set_path_request(pbap_client->goep_cid, 1 << 1); // Don’t create directory 339 // On Android 4.2 Cyanogenmod, using "" as path fails 340 // goep_client_add_header_name(pbap_client->goep_cid, ""); // empty == / 341 // state 342 pbap_client->state = PBAP_W4_SET_PATH_ROOT_COMPLETE; 343 // send packet 344 goep_client_execute(pbap_client->goep_cid); 345 break; 346 case PBAP_W2_SET_PATH_ELEMENT: 347 // find '/' or '\0' 348 path_element_start = pbap_client->set_path_offset; 349 while (pbap_client->current_folder[pbap_client->set_path_offset] != '\0' && 350 pbap_client->current_folder[pbap_client->set_path_offset] != '/'){ 351 pbap_client->set_path_offset++; 352 } 353 // skip / 354 if (pbap_client->current_folder[pbap_client->set_path_offset] == '/'){ 355 pbap_client->set_path_offset++; 356 } 357 path_element_len = pbap_client->set_path_offset-path_element_start; 358 memcpy(path_element, &pbap_client->current_folder[path_element_start], path_element_len); 359 path_element[path_element_len] = 0; 360 361 // detect end of path (after setting path_element) 362 if (pbap_client->current_folder[pbap_client->set_path_offset] == '\0'){ 363 pbap_client->current_folder = NULL; 364 } 365 366 log_info("Path element '%s', done %u", path_element, pbap_client->current_folder == NULL); 367 368 goep_client_create_set_path_request(pbap_client->goep_cid, 1 << 1); // Don’t create directory 369 goep_client_add_header_name(pbap_client->goep_cid, (const char *) path_element); // next element 370 // state 371 pbap_client->state = PBAP_W4_SET_PATH_ELEMENT_COMPLETE; 372 // send packet 373 goep_client_execute(pbap_client->goep_cid); 374 break; 375 default: 376 break; 377 } 378 } 379 380 static void pbap_parse_authentication_challenge(pbap_client_t * context, const uint8_t * challenge_data, uint16_t challenge_len){ 381 // printf("Challenge: "); 382 // printf_hexdump(challenge_data, challenge_len); 383 int i; 384 // uint8_t charset_code = 0; 385 for (i=0 ; i<challenge_len ; ){ 386 int tag = challenge_data[i]; 387 int len = challenge_data[i + 1]; 388 i += 2; 389 switch (tag) { 390 case 0: 391 if (len != 0x10) { 392 log_error("Invalid OBEX digest len %u", len); 393 return; 394 } 395 memcpy(context->authentication_nonce, &challenge_data[i], 16); 396 // printf("Nonce: "); 397 // printf_hexdump(context->authentication_nonce, 16); 398 break; 399 case 1: 400 context->authentication_options = challenge_data[i]; 401 // printf("Options %u\n", context->authentication_options); 402 break; 403 case 2: 404 // TODO: handle charset 405 // charset_code = challenge_data[i]; 406 break; 407 } 408 i += len; 409 } 410 } 411 412 static void pbap_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 413 414 UNUSED(channel); // ok: there is no channel 415 UNUSED(size); // ok: handling own geop events 416 417 obex_iterator_t it; 418 uint8_t status; 419 int srm_value; 420 int srmp_value; 421 switch (packet_type){ 422 case HCI_EVENT_PACKET: 423 switch (hci_event_packet_get_type(packet)) { 424 case HCI_EVENT_GOEP_META: 425 switch (hci_event_goep_meta_get_subevent_code(packet)){ 426 case GOEP_SUBEVENT_CONNECTION_OPENED: 427 status = goep_subevent_connection_opened_get_status(packet); 428 pbap_client->con_handle = goep_subevent_connection_opened_get_con_handle(packet); 429 pbap_client->incoming = goep_subevent_connection_opened_get_incoming(packet); 430 goep_subevent_connection_opened_get_bd_addr(packet, pbap_client->bd_addr); 431 if (status){ 432 log_info("pbap: connection failed %u", status); 433 pbap_client->state = PBAP_INIT; 434 pbap_client_emit_connected_event(pbap_client, status); 435 } else { 436 log_info("pbap: connection established"); 437 pbap_client->goep_cid = goep_subevent_connection_opened_get_goep_cid(packet); 438 pbap_client->state = PBAP_W2_SEND_CONNECT_REQUEST; 439 goep_client_request_can_send_now(pbap_client->goep_cid); 440 } 441 break; 442 case GOEP_SUBEVENT_CONNECTION_CLOSED: 443 if (pbap_client->state != PBAP_CONNECTED){ 444 pbap_client_emit_operation_complete_event(pbap_client, OBEX_DISCONNECTED); 445 } 446 pbap_client->state = PBAP_INIT; 447 pbap_client_emit_connection_closed_event(pbap_client); 448 break; 449 case GOEP_SUBEVENT_CAN_SEND_NOW: 450 pbap_handle_can_send_now(); 451 break; 452 } 453 break; 454 default: 455 break; 456 } 457 break; 458 case GOEP_DATA_PACKET: 459 // TODO: handle chunked data 460 obex_dump_packet(goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); 461 switch (pbap_client->state){ 462 case PBAP_W4_CONNECT_RESPONSE: 463 switch (packet[0]){ 464 case OBEX_RESP_SUCCESS: 465 for (obex_iterator_init_with_response_packet(&it, goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); obex_iterator_has_more(&it) ; obex_iterator_next(&it)){ 466 uint8_t hi = obex_iterator_get_hi(&it); 467 if (hi == OBEX_HEADER_CONNECTION_ID){ 468 goep_client_set_connection_id(pbap_client->goep_cid, obex_iterator_get_data_32(&it)); 469 } 470 } 471 pbap_client->state = PBAP_CONNECTED; 472 pbap_client_emit_connected_event(pbap_client, 0); 473 break; 474 case OBEX_RESP_UNAUTHORIZED: 475 for (obex_iterator_init_with_response_packet(&it, goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); obex_iterator_has_more(&it) ; obex_iterator_next(&it)){ 476 uint8_t hi = obex_iterator_get_hi(&it); 477 if (hi == OBEX_HEADER_AUTHENTICATION_CHALLENGE){ 478 pbap_parse_authentication_challenge(pbap_client, obex_iterator_get_data(&it), obex_iterator_get_data_len(&it)); 479 } 480 } 481 pbap_client->state = PBAP_W4_USER_AUTHENTICATION; 482 pbap_client_emit_authentication_event(pbap_client, pbap_client->authentication_options); 483 break; 484 default: 485 log_info("pbap: obex connect failed, result 0x%02x", packet[0]); 486 pbap_client->state = PBAP_INIT; 487 pbap_client_emit_connected_event(pbap_client, OBEX_CONNECT_FAILED); 488 break; 489 } 490 break; 491 case PBAP_W4_DISCONNECT_RESPONSE: 492 goep_client_disconnect(pbap_client->goep_cid); 493 break; 494 case PBAP_W4_SET_PATH_ROOT_COMPLETE: 495 case PBAP_W4_SET_PATH_ELEMENT_COMPLETE: 496 log_info("set path root/path element complete, current folder %s, path offset %u", pbap_client->current_folder, pbap_client->set_path_offset); 497 if (packet[0] == OBEX_RESP_SUCCESS){ 498 if (pbap_client->current_folder){ 499 pbap_client->state = PBAP_W2_SET_PATH_ELEMENT; 500 goep_client_request_can_send_now(pbap_client->goep_cid); 501 } else { 502 pbap_client->state = PBAP_CONNECTED; 503 pbap_client_emit_operation_complete_event(pbap_client, 0); 504 } 505 } else if (packet[0] == OBEX_RESP_NOT_FOUND){ 506 pbap_client->state = PBAP_CONNECTED; 507 pbap_client_emit_operation_complete_event(pbap_client, OBEX_NOT_FOUND); 508 } else { 509 pbap_client->state = PBAP_CONNECTED; 510 pbap_client_emit_operation_complete_event(pbap_client, OBEX_UNKNOWN_ERROR); 511 } 512 break; 513 case PBAP_W4_PHONEBOOK: 514 srm_value = OBEX_SRM_DISABLE; 515 srmp_value = OBEX_SRMP_NEXT; 516 for (obex_iterator_init_with_response_packet(&it, goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); obex_iterator_has_more(&it) ; obex_iterator_next(&it)){ 517 uint8_t hi = obex_iterator_get_hi(&it); 518 uint16_t data_len = obex_iterator_get_data_len(&it); 519 const uint8_t * data = data = obex_iterator_get_data(&it); 520 switch (hi){ 521 case OBEX_HEADER_BODY: 522 case OBEX_HEADER_END_OF_BODY: 523 pbap_client->client_handler(PBAP_DATA_PACKET, pbap_client->cid, (uint8_t *) data, data_len); 524 break; 525 case OBEX_HEADER_SINGLE_RESPONSE_MODE: 526 if (data_len != 1) break; 527 srm_value = *data; 528 break; 529 case OBEX_HEADER_SINGLE_RESPONSE_MODE_PARAMETER: 530 if (data_len != 1) break; 531 srmp_value = *data; 532 break; 533 default: 534 break; 535 } 536 } 537 switch(packet[0]){ 538 case OBEX_RESP_CONTINUE: 539 switch (pbap_client->srm_state){ 540 case SRM_W4_CONFIRM: 541 switch (srm_value){ 542 case OBEX_SRM_ENABLE: 543 switch (srmp_value){ 544 case OBEX_SRMP_WAIT: 545 pbap_client->srm_state = SRM_ENABLED_BUT_WAITING; 546 break; 547 default: 548 pbap_client->srm_state = SRM_ENABLED; 549 break; 550 } 551 break; 552 default: 553 pbap_client->srm_state = SRM_DISABLED; 554 break; 555 } 556 break; 557 case SRM_ENABLED_BUT_WAITING: 558 switch (srmp_value){ 559 case OBEX_SRMP_WAIT: 560 pbap_client->srm_state = SRM_ENABLED_BUT_WAITING; 561 break; 562 default: 563 pbap_client->srm_state = SRM_ENABLED; 564 break; 565 } 566 break; 567 default: 568 break; 569 } 570 log_info("SRM state %u", pbap_client->srm_state); 571 if (pbap_client->srm_state == SRM_ENABLED) break; 572 pbap_client->state = PBAP_W2_PULL_PHONEBOOK; 573 goep_client_request_can_send_now(pbap_client->goep_cid); 574 break; 575 case OBEX_RESP_SUCCESS: 576 pbap_client->state = PBAP_CONNECTED; 577 pbap_client_emit_operation_complete_event(pbap_client, 0); 578 break; 579 default: 580 log_info("unexpected response 0x%02x", packet[0]); 581 pbap_client->state = PBAP_CONNECTED; 582 pbap_client_emit_operation_complete_event(pbap_client, OBEX_UNKNOWN_ERROR); 583 break; 584 } 585 break; 586 case PBAP_W4_GET_PHONEBOOK_SIZE_COMPLETE: 587 pbap_client->state = PBAP_CONNECTED; 588 if (packet[0] == OBEX_RESP_SUCCESS){ 589 int have_size = 0; 590 uint16_t phonebook_size; 591 for (obex_iterator_init_with_response_packet(&it, goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); obex_iterator_has_more(&it) ; obex_iterator_next(&it)){ 592 uint8_t hi = obex_iterator_get_hi(&it); 593 if (hi == OBEX_HEADER_APPLICATION_PARAMETERS){ 594 uint16_t data_len = obex_iterator_get_data_len(&it); 595 const uint8_t * data = obex_iterator_get_data(&it); 596 // iterate over application headers (TLV with 1 bytes len) 597 unsigned int i = 0; 598 while (i<data_len){ 599 uint8_t tag = data[i++]; 600 uint8_t len = data[i++]; 601 if (tag == PBAP_APPLICATION_PARAMETER_PHONEBOOK_SIZE && len == 2){ 602 have_size = 1; 603 phonebook_size = big_endian_read_16(data, i); 604 } 605 i+=len; 606 } 607 } 608 } 609 if (have_size){ 610 pbap_client_emit_phonebook_size_event(pbap_client, 0, phonebook_size); 611 break; 612 } 613 } 614 pbap_client_emit_phonebook_size_event(pbap_client, OBEX_UNKNOWN_ERROR, 0); 615 break; 616 case PBAP_W4_GET_CARD_LIST_COMPLETE: 617 switch (packet[0]){ 618 case OBEX_RESP_CONTINUE: 619 pbap_client->state = PBAP_W2_GET_CARD_LIST; 620 goep_client_request_can_send_now(pbap_client->goep_cid); 621 break; 622 case OBEX_RESP_SUCCESS: 623 for (obex_iterator_init_with_response_packet(&it, goep_client_get_request_opcode(pbap_client->goep_cid), packet, size); obex_iterator_has_more(&it) ; obex_iterator_next(&it)){ 624 uint8_t hi = obex_iterator_get_hi(&it); 625 if (hi == OBEX_HEADER_END_OF_BODY){ 626 uint16_t data_len = obex_iterator_get_data_len(&it); 627 const uint8_t * data = obex_iterator_get_data(&it); 628 // now try parsing it 629 yxml_init(&pbap_client->xml_parser, pbap_client->xml_buffer, sizeof(pbap_client->xml_buffer)); 630 int card_found = 0; 631 int name_found = 0; 632 int handle_found = 0; 633 char name[PBAP_MAX_NAME_LEN]; 634 char handle[PBAP_MAX_HANDLE_LEN]; 635 name[0] = 0; 636 handle[0] = 0; 637 while (data_len--){ 638 yxml_ret_t r = yxml_parse(&pbap_client->xml_parser, *data++); 639 switch (r){ 640 case YXML_ELEMSTART: 641 card_found = strcmp("card", pbap_client->xml_parser.elem) == 0; 642 break; 643 case YXML_ELEMEND: 644 if (card_found){ 645 pbap_client_emit_card_result_event(pbap_client, name, handle); 646 } 647 card_found = 0; 648 break; 649 case YXML_ATTRSTART: 650 if (!card_found) break; 651 if (strcmp("name", pbap_client->xml_parser.attr) == 0){ 652 name_found = 1; 653 break; 654 } 655 if (strcmp("handle", pbap_client->xml_parser.attr) == 0){ 656 handle_found = 1; 657 break; 658 } 659 break; 660 case YXML_ATTRVAL: 661 if (name_found) { 662 // "In UTF-8, characters from the U+0000..U+10FFFF range (the UTF-16 accessible range) are encoded using sequences of 1 to 4 octets." 663 if (strlen(name) + 4 + 1 >= sizeof(name)) break; 664 strcat(name, pbap_client->xml_parser.data); 665 break; 666 } 667 if (handle_found) { 668 // "In UTF-8, characters from the U+0000..U+10FFFF range (the UTF-16 accessible range) are encoded using sequences of 1 to 4 octets." 669 if (strlen(handle) + 4 + 1 >= sizeof(handle)) break; 670 strcat(handle, pbap_client->xml_parser.data); 671 break; 672 } 673 break; 674 case YXML_ATTREND: 675 name_found = 0; 676 handle_found = 0; 677 break; 678 default: 679 break; 680 } 681 } 682 // 683 pbap_client->state = PBAP_CONNECTED; 684 pbap_client_emit_operation_complete_event(pbap_client, 0); 685 } 686 } 687 break; 688 case OBEX_RESP_NOT_ACCEPTABLE: 689 pbap_client->state = PBAP_CONNECTED; 690 pbap_client_emit_operation_complete_event(pbap_client, OBEX_NOT_ACCEPTABLE); 691 break; 692 default: 693 log_info("unexpected response 0x%02x", packet[0]); 694 pbap_client->state = PBAP_CONNECTED; 695 pbap_client_emit_operation_complete_event(pbap_client, OBEX_UNKNOWN_ERROR); 696 break; 697 } 698 break; 699 default: 700 break; 701 } 702 break; 703 default: 704 break; 705 } 706 } 707 708 void pbap_client_init(void){ 709 memset(pbap_client, 0, sizeof(pbap_client_t)); 710 pbap_client->state = PBAP_INIT; 711 pbap_client->cid = 1; 712 } 713 714 uint8_t pbap_connect(btstack_packet_handler_t handler, bd_addr_t addr, uint16_t * out_cid){ 715 if (pbap_client->state != PBAP_INIT) return BTSTACK_MEMORY_ALLOC_FAILED; 716 pbap_client->state = PBAP_W4_GOEP_CONNECTION; 717 pbap_client->client_handler = handler; 718 uint8_t err = goep_client_create_connection(&pbap_packet_handler, addr, BLUETOOTH_SERVICE_CLASS_PHONEBOOK_ACCESS_PSE, &pbap_client->goep_cid); 719 *out_cid = pbap_client->cid; 720 if (err) return err; 721 return 0; 722 } 723 724 uint8_t pbap_disconnect(uint16_t pbap_cid){ 725 UNUSED(pbap_cid); 726 if (pbap_client->state != PBAP_CONNECTED) return BTSTACK_BUSY; 727 pbap_client->state = PBAP_W2_SEND_DISCONNECT_REQUEST; 728 goep_client_request_can_send_now(pbap_client->goep_cid); 729 return 0; 730 } 731 732 uint8_t pbap_get_phonebook_size(uint16_t pbap_cid){ 733 UNUSED(pbap_cid); 734 if (pbap_client->state != PBAP_CONNECTED) return BTSTACK_BUSY; 735 pbap_client->state = PBAP_W2_GET_PHONEBOOK_SIZE; 736 pbap_client->request_number = 0; 737 goep_client_request_can_send_now(pbap_client->goep_cid); 738 return 0; 739 } 740 741 uint8_t pbap_pull_phonebook(uint16_t pbap_cid){ 742 UNUSED(pbap_cid); 743 if (pbap_client->state != PBAP_CONNECTED) return BTSTACK_BUSY; 744 pbap_client->state = PBAP_W2_PULL_PHONEBOOK; 745 pbap_client->request_number = 0; 746 goep_client_request_can_send_now(pbap_client->goep_cid); 747 return 0; 748 } 749 750 uint8_t pbap_set_phonebook(uint16_t pbap_cid, const char * path){ 751 UNUSED(pbap_cid); 752 if (pbap_client->state != PBAP_CONNECTED) return BTSTACK_BUSY; 753 pbap_client->state = PBAP_W2_SET_PATH_ROOT; 754 pbap_client->current_folder = path; 755 pbap_client->set_path_offset = 0; 756 goep_client_request_can_send_now(pbap_client->goep_cid); 757 return 0; 758 } 759 760 uint8_t pbap_authentication_password(uint16_t pbap_cid, const char * password){ 761 UNUSED(pbap_cid); 762 if (pbap_client->state != PBAP_W4_USER_AUTHENTICATION) return BTSTACK_BUSY; 763 pbap_client->state = PBAP_W2_SEND_AUTHENTICATED_CONNECT; 764 pbap_client->authentication_password = password; 765 goep_client_request_can_send_now(pbap_client->goep_cid); 766 return 0; 767 } 768 769 uint8_t pbap_lookup_by_number(uint16_t pbap_cid, const char * phone_number){ 770 UNUSED(pbap_cid); 771 if (pbap_client->state != PBAP_CONNECTED) return BTSTACK_BUSY; 772 pbap_client->state = PBAP_W2_GET_CARD_LIST; 773 pbap_client->phone_number = phone_number; 774 goep_client_request_can_send_now(pbap_client->goep_cid); 775 return 0; 776 } 777