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__ "att_db.c" 39 40 #include <string.h> 41 42 #include "ble/att_db.h" 43 #include "ble/core.h" 44 #include "bluetooth.h" 45 #include "btstack_debug.h" 46 #include "btstack_util.h" 47 48 // check for ENABLE_ATT_DELAYED_READ_RESPONSE -> ENABLE_ATT_DELAYED_RESPONSE, 49 #ifdef ENABLE_ATT_DELAYED_READ_RESPONSE 50 #error "ENABLE_ATT_DELAYED_READ_RESPONSE was replaced by ENABLE_ATT_DELAYED_RESPONSE. Please update btstack_config.h" 51 #endif 52 53 typedef enum { 54 ATT_READ, 55 ATT_WRITE, 56 } att_operation_t; 57 58 59 static int is_Bluetooth_Base_UUID(uint8_t const *uuid){ 60 // Bluetooth Base UUID 00000000-0000-1000-8000-00805F9B34FB in little endian 61 static const uint8_t bluetooth_base_uuid[] = { 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 62 63 if (memcmp(&uuid[0], &bluetooth_base_uuid[0], 12) != 0) return false; 64 if (memcmp(&uuid[14], &bluetooth_base_uuid[14], 2) != 0) return false; 65 return true; 66 67 } 68 69 static uint16_t uuid16_from_uuid(uint16_t uuid_len, uint8_t * uuid){ 70 if (uuid_len == 2u) return little_endian_read_16(uuid, 0u); 71 if (!is_Bluetooth_Base_UUID(uuid)) return 0; 72 return little_endian_read_16(uuid, 12); 73 } 74 75 // ATT Database 76 77 // new java-style iterator 78 typedef struct att_iterator { 79 // private 80 uint8_t const * att_ptr; 81 // public 82 uint16_t size; 83 uint16_t flags; 84 uint16_t handle; 85 uint8_t const * uuid; 86 uint16_t value_len; 87 uint8_t const * value; 88 } att_iterator_t; 89 90 static void att_persistent_ccc_cache(att_iterator_t * it); 91 92 static uint8_t const * att_db = NULL; 93 static att_read_callback_t att_read_callback = NULL; 94 static att_write_callback_t att_write_callback = NULL; 95 static int att_prepare_write_error_code = 0; 96 static uint16_t att_prepare_write_error_handle = 0x0000; 97 98 // single cache for att_is_persistent_ccc - stores flags before write callback 99 static uint16_t att_persistent_ccc_handle; 100 static uint16_t att_persistent_ccc_uuid16; 101 102 static void att_iterator_init(att_iterator_t *it){ 103 it->att_ptr = att_db; 104 } 105 106 static bool att_iterator_has_next(att_iterator_t *it){ 107 return it->att_ptr != NULL; 108 } 109 110 static void att_iterator_fetch_next(att_iterator_t *it){ 111 it->size = little_endian_read_16(it->att_ptr, 0); 112 if (it->size == 0u){ 113 it->flags = 0; 114 it->handle = 0; 115 it->uuid = NULL; 116 it->value_len = 0; 117 it->value = NULL; 118 it->att_ptr = NULL; 119 return; 120 } 121 it->flags = little_endian_read_16(it->att_ptr, 2); 122 it->handle = little_endian_read_16(it->att_ptr, 4); 123 it->uuid = &it->att_ptr[6]; 124 // handle 128 bit UUIDs 125 if ((it->flags & ATT_PROPERTY_UUID128) != 0u){ 126 it->value_len = it->size - 22u; 127 it->value = &it->att_ptr[22]; 128 } else { 129 it->value_len = it->size - 8u; 130 it->value = &it->att_ptr[8]; 131 } 132 // advance AFTER setting values 133 it->att_ptr += it->size; 134 } 135 136 static int att_iterator_match_uuid16(att_iterator_t *it, uint16_t uuid){ 137 if (it->handle == 0u) return 0u; 138 if (it->flags & ATT_PROPERTY_UUID128){ 139 if (!is_Bluetooth_Base_UUID(it->uuid)) return 0; 140 return little_endian_read_16(it->uuid, 12) == uuid; 141 } 142 return little_endian_read_16(it->uuid, 0) == uuid; 143 } 144 145 static int att_iterator_match_uuid(att_iterator_t *it, uint8_t *uuid, uint16_t uuid_len){ 146 if (it->handle == 0u) return 0u; 147 // input: UUID16 148 if (uuid_len == 2u) { 149 return att_iterator_match_uuid16(it, little_endian_read_16(uuid, 0)); 150 } 151 // input and db: UUID128 152 if ((it->flags & ATT_PROPERTY_UUID128) != 0u){ 153 return memcmp(it->uuid, uuid, 16) == 0; 154 } 155 // input: UUID128, db: UUID16 156 if (!is_Bluetooth_Base_UUID(uuid)) return 0; 157 return little_endian_read_16(uuid, 12) == little_endian_read_16(it->uuid, 0); 158 } 159 160 161 static int att_find_handle(att_iterator_t *it, uint16_t handle){ 162 if (handle == 0u) return 0u; 163 att_iterator_init(it); 164 while (att_iterator_has_next(it)){ 165 att_iterator_fetch_next(it); 166 if (it->handle != handle) continue; 167 return 1; 168 } 169 return 0; 170 } 171 172 // experimental client API 173 uint16_t att_uuid_for_handle(uint16_t attribute_handle){ 174 att_iterator_t it; 175 int ok = att_find_handle(&it, attribute_handle); 176 if (!ok) return 0; 177 if ((it.flags & ATT_PROPERTY_UUID128) != 0u) return 0u; 178 return little_endian_read_16(it.uuid, 0); 179 } 180 // end of client API 181 182 static void att_update_value_len(att_iterator_t *it, hci_con_handle_t con_handle){ 183 if ((it->flags & ATT_PROPERTY_DYNAMIC) == 0u) return; 184 it->value_len = (*att_read_callback)(con_handle, it->handle, 0, NULL, 0); 185 return; 186 } 187 188 // copy attribute value from offset into buffer with given size 189 static int att_copy_value(att_iterator_t *it, uint16_t offset, uint8_t * buffer, uint16_t buffer_size, hci_con_handle_t con_handle){ 190 191 // DYNAMIC 192 if ((it->flags & ATT_PROPERTY_DYNAMIC) != 0u){ 193 return (*att_read_callback)(con_handle, it->handle, offset, buffer, buffer_size); 194 } 195 196 // STATIC 197 uint16_t bytes_to_copy = it->value_len - offset; 198 if (bytes_to_copy > buffer_size){ 199 bytes_to_copy = buffer_size; 200 } 201 (void)memcpy(buffer, it->value, bytes_to_copy); 202 return bytes_to_copy; 203 } 204 205 void att_set_db(uint8_t const * db){ 206 // validate db version 207 if (db == NULL) return; 208 if (*db++ != ATT_DB_VERSION){ 209 log_error("ATT DB version differs, please regenerate .h from .gatt file or update att_db_util.c"); 210 return; 211 } 212 att_db = db; 213 } 214 215 void att_set_read_callback(att_read_callback_t callback){ 216 att_read_callback = callback; 217 } 218 219 void att_set_write_callback(att_write_callback_t callback){ 220 att_write_callback = callback; 221 } 222 223 void att_dump_attributes(void){ 224 att_iterator_t it; 225 att_iterator_init(&it); 226 uint8_t uuid128[16]; 227 while (att_iterator_has_next(&it)){ 228 att_iterator_fetch_next(&it); 229 if (it.handle == 0u) { 230 log_info("Handle: END"); 231 return; 232 } 233 log_info("Handle: 0x%04x, flags: 0x%04x, uuid: ", it.handle, it.flags); 234 if ((it.flags & ATT_PROPERTY_UUID128) != 0u){ 235 reverse_128(it.uuid, uuid128); 236 log_info("%s", uuid128_to_str(uuid128)); 237 } else { 238 log_info("%04x", little_endian_read_16(it.uuid, 0)); 239 } 240 log_info(", value_len: %u, value: ", it.value_len); 241 log_info_hexdump(it.value, it.value_len); 242 } 243 } 244 245 static void att_prepare_write_reset(void){ 246 att_prepare_write_error_code = 0; 247 att_prepare_write_error_handle = 0x0000; 248 } 249 250 static void att_prepare_write_update_errors(uint8_t error_code, uint16_t handle){ 251 // first ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTH has highest priority 252 if ((error_code == ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTH) && (error_code != att_prepare_write_error_code)){ 253 att_prepare_write_error_code = error_code; 254 att_prepare_write_error_handle = handle; 255 return; 256 } 257 // first ATT_ERROR_INVALID_OFFSET is next 258 if ((error_code == ATT_ERROR_INVALID_OFFSET) && (att_prepare_write_error_code == 0)){ 259 att_prepare_write_error_code = error_code; 260 att_prepare_write_error_handle = handle; 261 return; 262 } 263 } 264 265 static uint16_t setup_error(uint8_t * response_buffer, uint16_t request, uint16_t handle, uint8_t error_code){ 266 response_buffer[0] = ATT_ERROR_RESPONSE; 267 response_buffer[1] = request; 268 little_endian_store_16(response_buffer, 2, handle); 269 response_buffer[4] = error_code; 270 return 5; 271 } 272 273 static inline uint16_t setup_error_read_not_permitted(uint8_t * response_buffer, uint16_t request, uint16_t start_handle){ 274 return setup_error(response_buffer, request, start_handle, ATT_ERROR_READ_NOT_PERMITTED); 275 } 276 277 static inline uint16_t setup_error_write_not_permitted(uint8_t * response_buffer, uint16_t request, uint16_t start_handle){ 278 return setup_error(response_buffer, request, start_handle, ATT_ERROR_WRITE_NOT_PERMITTED); 279 } 280 281 static inline uint16_t setup_error_atribute_not_found(uint8_t * response_buffer, uint16_t request, uint16_t start_handle){ 282 return setup_error(response_buffer, request, start_handle, ATT_ERROR_ATTRIBUTE_NOT_FOUND); 283 } 284 285 static inline uint16_t setup_error_invalid_handle(uint8_t * response_buffer, uint16_t request, uint16_t handle){ 286 return setup_error(response_buffer, request, handle, ATT_ERROR_INVALID_HANDLE); 287 } 288 289 static inline uint16_t setup_error_invalid_offset(uint8_t * response_buffer, uint16_t request, uint16_t handle){ 290 return setup_error(response_buffer, request, handle, ATT_ERROR_INVALID_OFFSET); 291 } 292 293 static inline uint16_t setup_error_invalid_pdu(uint8_t *response_buffer, uint16_t request) { 294 return setup_error(response_buffer, request, 0, ATT_ERROR_INVALID_PDU); 295 } 296 297 static uint8_t att_validate_security(att_connection_t * att_connection, att_operation_t operation, att_iterator_t * it){ 298 int required_security_level = 0; 299 bool requires_secure_connection = false; 300 switch (operation){ 301 case ATT_READ: 302 if ((it->flags & ATT_PROPERTY_READ_PERMISSION_BIT_0) != 0u){ 303 required_security_level |= 1; 304 } 305 if ((it->flags & ATT_PROPERTY_READ_PERMISSION_BIT_1) != 0u){ 306 required_security_level |= 2; 307 } 308 if ((it->flags & ATT_PROPERTY_READ_PERMISSION_SC) != 0u){ 309 requires_secure_connection = true; 310 } 311 break; 312 case ATT_WRITE: 313 if ((it->flags & ATT_PROPERTY_WRITE_PERMISSION_BIT_0) != 0u){ 314 required_security_level |= 1; 315 } 316 if ((it->flags & ATT_PROPERTY_WRITE_PERMISSION_BIT_1) != 0u){ 317 required_security_level |= 2; 318 } 319 if ((it->flags & ATT_PROPERTY_WRITE_PERMISSION_SC) != 0u){ 320 requires_secure_connection = true; 321 } 322 break; 323 } 324 325 uint8_t required_encryption_size = it->flags >> 12; 326 if (required_encryption_size != 0) required_encryption_size++; // store -1 to fit into 4 bit 327 328 log_debug("att_validate_security. flags 0x%04x (=> security level %u, key size %u) authorized %u, authenticated %u, encryption_key_size %u, secure connection %u", 329 it->flags, required_security_level, required_encryption_size, att_connection->authorized, att_connection->authenticated, att_connection->encryption_key_size, att_connection->secure_connection); 330 331 bool sc_missing = requires_secure_connection && (att_connection->secure_connection == 0u); 332 switch (required_security_level){ 333 case ATT_SECURITY_AUTHORIZED: 334 if ((att_connection->authorized == 0u) || sc_missing){ 335 return ATT_ERROR_INSUFFICIENT_AUTHORIZATION; 336 } 337 /* fall through */ 338 case ATT_SECURITY_AUTHENTICATED: 339 if ((att_connection->authenticated == 0u) || sc_missing){ 340 return ATT_ERROR_INSUFFICIENT_AUTHENTICATION; 341 } 342 /* fall through */ 343 case ATT_SECURITY_ENCRYPTED: 344 if ((required_encryption_size > 0u) && ((att_connection->encryption_key_size == 0u) || sc_missing)){ 345 return ATT_ERROR_INSUFFICIENT_ENCRYPTION; 346 } 347 if (required_encryption_size > att_connection->encryption_key_size){ 348 return ATT_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZE; 349 } 350 break; 351 default: 352 break; 353 } 354 return ATT_ERROR_SUCCESS; 355 } 356 357 // 358 // MARK: ATT_EXCHANGE_MTU_REQUEST 359 // 360 static uint16_t handle_exchange_mtu_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 361 uint8_t * response_buffer){ 362 363 if (request_len != 3u) return setup_error_invalid_pdu(response_buffer, ATT_EXCHANGE_MTU_REQUEST); 364 365 uint16_t client_rx_mtu = little_endian_read_16(request_buffer, 1); 366 367 // find min(local max mtu, remote mtu) >= ATT_DEFAULT_MTU and use as mtu for this connection 368 uint16_t min_mtu = btstack_min(client_rx_mtu, att_connection->max_mtu); 369 uint16_t new_mtu = btstack_max(ATT_DEFAULT_MTU, min_mtu); 370 att_connection->mtu = new_mtu; 371 372 response_buffer[0] = ATT_EXCHANGE_MTU_RESPONSE; 373 little_endian_store_16(response_buffer, 1, att_connection->mtu); 374 return 3; 375 } 376 377 378 // 379 // MARK: ATT_FIND_INFORMATION_REQUEST 380 // 381 // TODO: handle other types then GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID 382 // 383 static uint16_t handle_find_information_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, 384 uint16_t start_handle, uint16_t end_handle){ 385 386 UNUSED(att_connection); 387 388 log_info("ATT_FIND_INFORMATION_REQUEST: from %04X to %04X", start_handle, end_handle); 389 uint8_t request_type = ATT_FIND_INFORMATION_REQUEST; 390 391 if ((start_handle > end_handle) || (start_handle == 0u)){ 392 return setup_error_invalid_handle(response_buffer, request_type, start_handle); 393 } 394 395 uint16_t offset = 1; 396 uint16_t uuid_len = 0; 397 398 att_iterator_t it; 399 att_iterator_init(&it); 400 while (att_iterator_has_next(&it)){ 401 att_iterator_fetch_next(&it); 402 if (!it.handle) break; 403 if (it.handle > end_handle) break; 404 if (it.handle < start_handle) continue; 405 406 // log_info("Handle 0x%04x", it.handle); 407 408 uint16_t this_uuid_len = (it.flags & ATT_PROPERTY_UUID128) ? 16 : 2; 409 410 // check if value has same len as last one if not first result 411 if (offset > 1u){ 412 if (this_uuid_len != uuid_len) { 413 break; 414 } 415 } 416 417 // first 418 if (offset == 1u) { 419 uuid_len = this_uuid_len; 420 // set format field 421 response_buffer[offset] = (it.flags & ATT_PROPERTY_UUID128) ? 0x02 : 0x01; 422 offset++; 423 } 424 425 // space? 426 if ((offset + 2u + uuid_len) > response_buffer_size) break; 427 428 // store 429 little_endian_store_16(response_buffer, offset, it.handle); 430 offset += 2u; 431 432 (void)memcpy(response_buffer + offset, it.uuid, uuid_len); 433 offset += uuid_len; 434 } 435 436 if (offset == 1u){ 437 return setup_error_atribute_not_found(response_buffer, request_type, start_handle); 438 } 439 440 response_buffer[0] = ATT_FIND_INFORMATION_REPLY; 441 return offset; 442 } 443 444 static uint16_t handle_find_information_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 445 uint8_t * response_buffer, uint16_t response_buffer_size){ 446 447 if (request_len != 5u) return setup_error_invalid_pdu(response_buffer, ATT_FIND_INFORMATION_REQUEST); 448 449 uint16_t start_handle = little_endian_read_16(request_buffer, 1); 450 uint16_t end_handle = little_endian_read_16(request_buffer, 3); 451 return handle_find_information_request2(att_connection, response_buffer, response_buffer_size, start_handle, end_handle); 452 } 453 454 // 455 // MARK: ATT_FIND_BY_TYPE_VALUE 456 // 457 // "Only attributes with attribute handles between and including the Starting Handle parameter 458 // and the Ending Handle parameter that match the requested attri- bute type and the attribute 459 // value that have sufficient permissions to allow reading will be returned" -> (1) 460 // 461 // TODO: handle other types then GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID 462 // 463 // NOTE: doesn't handle DYNAMIC values 464 // NOTE: only supports 16 bit UUIDs 465 // 466 static uint16_t handle_find_by_type_value_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 467 uint8_t * response_buffer, uint16_t response_buffer_size){ 468 UNUSED(att_connection); 469 470 if (request_len < 7u) return setup_error_invalid_pdu(response_buffer, ATT_FIND_BY_TYPE_VALUE_REQUEST); 471 472 // parse request 473 uint16_t start_handle = little_endian_read_16(request_buffer, 1); 474 uint16_t end_handle = little_endian_read_16(request_buffer, 3); 475 uint16_t attribute_type = little_endian_read_16(request_buffer, 5); 476 const uint8_t *attribute_value = &request_buffer[7]; 477 uint16_t attribute_len = request_len - 7u; 478 479 log_info("ATT_FIND_BY_TYPE_VALUE_REQUEST: from %04X to %04X, type %04X, value: ", start_handle, end_handle, attribute_type); 480 log_info_hexdump(attribute_value, attribute_len); 481 uint8_t request_type = ATT_FIND_BY_TYPE_VALUE_REQUEST; 482 483 if ((start_handle > end_handle) || (start_handle == 0u)){ 484 return setup_error_invalid_handle(response_buffer, request_type, start_handle); 485 } 486 487 uint16_t offset = 1; 488 uint16_t in_group = 0; 489 uint16_t prev_handle = 0; 490 491 att_iterator_t it; 492 att_iterator_init(&it); 493 while (att_iterator_has_next(&it)){ 494 att_iterator_fetch_next(&it); 495 496 if (it.handle && (it.handle < start_handle)) continue; 497 if (it.handle > end_handle) break; // (1) 498 499 // close current tag, if within a group and a new service definition starts or we reach end of att db 500 if (in_group && 501 ((it.handle == 0u) || att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID))){ 502 503 log_info("End of group, handle 0x%04x", prev_handle); 504 little_endian_store_16(response_buffer, offset, prev_handle); 505 offset += 2u; 506 in_group = 0; 507 508 // check if space for another handle pair available 509 if ((offset + 4u) > response_buffer_size){ 510 break; 511 } 512 } 513 514 // keep track of previous handle 515 prev_handle = it.handle; 516 517 // does current attribute match 518 if (it.handle && att_iterator_match_uuid16(&it, attribute_type) && (attribute_len == it.value_len) && (memcmp(attribute_value, it.value, it.value_len) == 0)){ 519 log_info("Begin of group, handle 0x%04x", it.handle); 520 little_endian_store_16(response_buffer, offset, it.handle); 521 offset += 2u; 522 in_group = 1; 523 } 524 } 525 526 if (offset == 1u){ 527 return setup_error_atribute_not_found(response_buffer, request_type, start_handle); 528 } 529 530 response_buffer[0] = ATT_FIND_BY_TYPE_VALUE_RESPONSE; 531 return offset; 532 } 533 534 // 535 // MARK: ATT_READ_BY_TYPE_REQUEST 536 // 537 static uint16_t handle_read_by_type_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, 538 uint16_t start_handle, uint16_t end_handle, 539 uint16_t attribute_type_len, uint8_t * attribute_type){ 540 541 log_info("ATT_READ_BY_TYPE_REQUEST: from %04X to %04X, type: ", start_handle, end_handle); 542 log_info_hexdump(attribute_type, attribute_type_len); 543 uint8_t request_type = ATT_READ_BY_TYPE_REQUEST; 544 545 if ((start_handle > end_handle) || (start_handle == 0u)){ 546 return setup_error_invalid_handle(response_buffer, request_type, start_handle); 547 } 548 549 uint16_t offset = 1; 550 uint16_t pair_len = 0; 551 552 att_iterator_t it; 553 att_iterator_init(&it); 554 uint8_t error_code = 0; 555 uint16_t first_matching_but_unreadable_handle = 0; 556 557 while (att_iterator_has_next(&it)){ 558 att_iterator_fetch_next(&it); 559 560 if ((it.handle == 0u ) || (it.handle > end_handle)) break; 561 562 if (it.handle < start_handle) continue; 563 564 // does current attribute match 565 if (!att_iterator_match_uuid(&it, attribute_type, attribute_type_len)) continue; 566 567 // skip handles that cannot be read but remember that there has been at least one 568 if ((it.flags & ATT_PROPERTY_READ) == 0u) { 569 if (first_matching_but_unreadable_handle == 0u) { 570 first_matching_but_unreadable_handle = it.handle; 571 } 572 continue; 573 } 574 575 // check security requirements 576 error_code = att_validate_security(att_connection, ATT_READ, &it); 577 if (error_code != 0u) break; 578 579 att_update_value_len(&it, att_connection->con_handle); 580 581 #ifdef ENABLE_ATT_DELAYED_RESPONSE 582 if (it.value_len == ATT_READ_RESPONSE_PENDING){ 583 return ATT_READ_RESPONSE_PENDING; 584 } 585 #endif 586 587 // check if value has same len as last one 588 uint16_t this_pair_len = 2u + it.value_len; 589 if ((offset > 1u) && (pair_len != this_pair_len)) { 590 break; 591 } 592 593 // first 594 if (offset == 1u) { 595 pair_len = this_pair_len; 596 response_buffer[offset] = pair_len; 597 offset++; 598 } 599 600 // space? 601 if ((offset + pair_len) > response_buffer_size) { 602 if (offset > 2u) break; 603 it.value_len = response_buffer_size - 4u; 604 response_buffer[1u] = 2u + it.value_len; 605 } 606 607 // store 608 little_endian_store_16(response_buffer, offset, it.handle); 609 offset += 2u; 610 uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, it.value_len, att_connection->con_handle); 611 offset += bytes_copied; 612 } 613 614 // at least one attribute could be read 615 if (offset > 1u){ 616 response_buffer[0] = ATT_READ_BY_TYPE_RESPONSE; 617 return offset; 618 } 619 620 // first attribute had an error 621 if (error_code != 0u){ 622 return setup_error(response_buffer, request_type, start_handle, error_code); 623 } 624 625 // no other errors, but all found attributes had been non-readable 626 if (first_matching_but_unreadable_handle != 0u){ 627 return setup_error_read_not_permitted(response_buffer, request_type, first_matching_but_unreadable_handle); 628 } 629 630 // attribute not found 631 return setup_error_atribute_not_found(response_buffer, request_type, start_handle); 632 } 633 634 static uint16_t handle_read_by_type_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 635 uint8_t * response_buffer, uint16_t response_buffer_size){ 636 637 uint16_t attribute_type_len; 638 switch (request_len){ 639 case 7: 640 attribute_type_len = 2; 641 break; 642 case 21: 643 attribute_type_len = 16; 644 break; 645 default: 646 return setup_error_invalid_pdu(response_buffer, ATT_READ_BY_TYPE_REQUEST); 647 } 648 649 uint16_t start_handle = little_endian_read_16(request_buffer, 1); 650 uint16_t end_handle = little_endian_read_16(request_buffer, 3); 651 return handle_read_by_type_request2(att_connection, response_buffer, response_buffer_size, start_handle, end_handle, attribute_type_len, &request_buffer[5]); 652 } 653 654 // 655 // MARK: ATT_READ_BY_TYPE_REQUEST 656 // 657 static uint16_t handle_read_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, uint16_t handle){ 658 659 log_info("ATT_READ_REQUEST: handle %04x", handle); 660 uint8_t request_type = ATT_READ_REQUEST; 661 662 att_iterator_t it; 663 int ok = att_find_handle(&it, handle); 664 if (!ok){ 665 return setup_error_invalid_handle(response_buffer, request_type, handle); 666 } 667 668 // check if handle can be read 669 if ((it.flags & ATT_PROPERTY_READ) == 0u) { 670 return setup_error_read_not_permitted(response_buffer, request_type, handle); 671 } 672 673 // check security requirements 674 uint8_t error_code = att_validate_security(att_connection, ATT_READ, &it); 675 if (error_code) { 676 return setup_error(response_buffer, request_type, handle, error_code); 677 } 678 679 att_update_value_len(&it, att_connection->con_handle); 680 681 #ifdef ENABLE_ATT_DELAYED_RESPONSE 682 if (it.value_len == ATT_READ_RESPONSE_PENDING) return ATT_READ_RESPONSE_PENDING; 683 #endif 684 685 // store 686 uint16_t offset = 1; 687 uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, response_buffer_size - offset, att_connection->con_handle); 688 offset += bytes_copied; 689 690 response_buffer[0] = ATT_READ_RESPONSE; 691 return offset; 692 } 693 694 static uint16_t handle_read_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 695 uint8_t * response_buffer, uint16_t response_buffer_size){ 696 697 if (request_len != 3u) return setup_error_invalid_pdu(response_buffer, ATT_READ_REQUEST); 698 699 uint16_t handle = little_endian_read_16(request_buffer, 1); 700 return handle_read_request2(att_connection, response_buffer, response_buffer_size, handle); 701 } 702 703 //s 704 // MARK: ATT_READ_BLOB_REQUEST 0x0c 705 // 706 static uint16_t handle_read_blob_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, uint16_t handle, uint16_t value_offset){ 707 log_info("ATT_READ_BLOB_REQUEST: handle %04x, offset %u", handle, value_offset); 708 uint8_t request_type = ATT_READ_BLOB_REQUEST; 709 710 att_iterator_t it; 711 int ok = att_find_handle(&it, handle); 712 if (!ok){ 713 return setup_error_invalid_handle(response_buffer, request_type, handle); 714 } 715 716 // check if handle can be read 717 if ((it.flags & ATT_PROPERTY_READ) == 0u) { 718 return setup_error_read_not_permitted(response_buffer, request_type, handle); 719 } 720 721 // check security requirements 722 uint8_t error_code = att_validate_security(att_connection, ATT_READ, &it); 723 if (error_code) { 724 return setup_error(response_buffer, request_type, handle, error_code); 725 } 726 727 att_update_value_len(&it, att_connection->con_handle); 728 729 #ifdef ENABLE_ATT_DELAYED_RESPONSE 730 if (it.value_len == ATT_READ_RESPONSE_PENDING) return ATT_READ_RESPONSE_PENDING; 731 #endif 732 733 if (value_offset > it.value_len){ 734 return setup_error_invalid_offset(response_buffer, request_type, handle); 735 } 736 737 // prepare response 738 response_buffer[0] = ATT_READ_BLOB_RESPONSE; 739 uint16_t offset = 1; 740 741 // fetch more data if available 742 if (value_offset < it.value_len){ 743 uint16_t bytes_copied = att_copy_value(&it, value_offset, &response_buffer[offset], response_buffer_size - offset, att_connection->con_handle); 744 offset += bytes_copied; 745 } 746 return offset; 747 } 748 749 static uint16_t handle_read_blob_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 750 uint8_t * response_buffer, uint16_t response_buffer_size){ 751 752 if (request_len != 5u) return setup_error_invalid_pdu(response_buffer, ATT_READ_BLOB_REQUEST); 753 754 uint16_t handle = little_endian_read_16(request_buffer, 1); 755 uint16_t value_offset = little_endian_read_16(request_buffer, 3); 756 return handle_read_blob_request2(att_connection, response_buffer, response_buffer_size, handle, value_offset); 757 } 758 759 // 760 // MARK: ATT_READ_MULTIPLE_REQUEST 0x0e 761 // 762 static uint16_t handle_read_multiple_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, uint16_t num_handles, uint8_t * handles){ 763 log_info("ATT_READ_MULTIPLE_REQUEST: num handles %u", num_handles); 764 uint8_t request_type = ATT_READ_MULTIPLE_REQUEST; 765 766 // TODO: figure out which error to respond with 767 // if (num_handles < 2){ 768 // return setup_error(response_buffer, ATT_READ_MULTIPLE_REQUEST, handle, ???); 769 // } 770 771 uint16_t offset = 1; 772 773 int i; 774 uint8_t error_code = 0; 775 uint16_t handle = 0; 776 777 #ifdef ENABLE_ATT_DELAYED_RESPONSE 778 bool read_request_pending = false; 779 #endif 780 781 for (i=0;i<num_handles;i++){ 782 handle = little_endian_read_16(handles, i << 1); 783 784 if (handle == 0u){ 785 return setup_error_invalid_handle(response_buffer, request_type, handle); 786 } 787 788 att_iterator_t it; 789 790 int ok = att_find_handle(&it, handle); 791 if (!ok){ 792 return setup_error_invalid_handle(response_buffer, request_type, handle); 793 } 794 795 // check if handle can be read 796 if ((it.flags & ATT_PROPERTY_READ) == 0u) { 797 error_code = ATT_ERROR_READ_NOT_PERMITTED; 798 break; 799 } 800 801 // check security requirements 802 error_code = att_validate_security(att_connection, ATT_READ, &it); 803 if (error_code) break; 804 805 att_update_value_len(&it, att_connection->con_handle); 806 807 #ifdef ENABLE_ATT_DELAYED_RESPONSE 808 if (it.value_len == ATT_READ_RESPONSE_PENDING) { 809 read_request_pending = true; 810 } 811 if (read_request_pending) continue; 812 #endif 813 814 // store 815 uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, response_buffer_size - offset, att_connection->con_handle); 816 offset += bytes_copied; 817 } 818 819 if (error_code){ 820 return setup_error(response_buffer, request_type, handle, error_code); 821 } 822 823 response_buffer[0] = ATT_READ_MULTIPLE_RESPONSE; 824 return offset; 825 } 826 static uint16_t handle_read_multiple_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 827 uint8_t * response_buffer, uint16_t response_buffer_size){ 828 829 // 1 byte opcode + two or more attribute handles (2 bytes each) 830 if ( (request_len < 5u) || ((request_len & 1u) == 0u) ) return setup_error_invalid_pdu(response_buffer, 831 ATT_READ_MULTIPLE_REQUEST); 832 833 int num_handles = (request_len - 1u) >> 1u; 834 return handle_read_multiple_request2(att_connection, response_buffer, response_buffer_size, num_handles, &request_buffer[1]); 835 } 836 837 // 838 // MARK: ATT_READ_BY_GROUP_TYPE_REQUEST 0x10 839 // 840 // Only handles GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID 841 // Core v4.0, vol 3, part g, 2.5.3 842 // "The «Primary Service» and «Secondary Service» grouping types may be used in the Read By Group Type Request. 843 // The «Characteristic» grouping type shall not be used in the ATT Read By Group Type Request." 844 // 845 // NOTE: doesn't handle DYNAMIC values 846 // 847 // NOTE: we don't check for security as PRIMARY and SECONDAY SERVICE definition shouldn't be protected 848 // Core 4.0, vol 3, part g, 8.1 849 // "The list of services and characteristics that a device supports is not considered private or 850 // confidential information, and therefore the Service and Characteristic Discovery procedures 851 // shall always be permitted. " 852 // 853 static uint16_t handle_read_by_group_type_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size, 854 uint16_t start_handle, uint16_t end_handle, 855 uint16_t attribute_type_len, uint8_t * attribute_type){ 856 857 UNUSED(att_connection); 858 859 log_info("ATT_READ_BY_GROUP_TYPE_REQUEST: from %04X to %04X, buffer size %u, type: ", start_handle, end_handle, response_buffer_size); 860 log_info_hexdump(attribute_type, attribute_type_len); 861 uint8_t request_type = ATT_READ_BY_GROUP_TYPE_REQUEST; 862 863 if ((start_handle > end_handle) || (start_handle == 0u)){ 864 return setup_error_invalid_handle(response_buffer, request_type, start_handle); 865 } 866 867 // assert UUID is primary or secondary service uuid 868 uint16_t uuid16 = uuid16_from_uuid(attribute_type_len, attribute_type); 869 if ((uuid16 != GATT_PRIMARY_SERVICE_UUID) && (uuid16 != GATT_SECONDARY_SERVICE_UUID)){ 870 return setup_error(response_buffer, request_type, start_handle, ATT_ERROR_UNSUPPORTED_GROUP_TYPE); 871 } 872 873 uint16_t offset = 1; 874 uint16_t pair_len = 0; 875 uint16_t in_group = 0; 876 uint16_t group_start_handle = 0; 877 uint8_t const * group_start_value = NULL; 878 uint16_t prev_handle = 0; 879 880 att_iterator_t it; 881 att_iterator_init(&it); 882 while (att_iterator_has_next(&it)){ 883 att_iterator_fetch_next(&it); 884 885 if (it.handle && (it.handle < start_handle)) continue; 886 if (it.handle > end_handle) break; // (1) 887 888 // log_info("Handle 0x%04x", it.handle); 889 890 // close current tag, if within a group and a new service definition starts or we reach end of att db 891 if (in_group && 892 ((it.handle == 0u) || att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID))){ 893 // log_info("End of group, handle 0x%04x, val_len: %u", prev_handle, pair_len - 4); 894 895 little_endian_store_16(response_buffer, offset, group_start_handle); 896 offset += 2u; 897 little_endian_store_16(response_buffer, offset, prev_handle); 898 offset += 2u; 899 (void)memcpy(response_buffer + offset, group_start_value, 900 pair_len - 4u); 901 offset += pair_len - 4u; 902 in_group = 0; 903 904 // check if space for another handle pair available 905 if ((offset + pair_len) > response_buffer_size){ 906 break; 907 } 908 } 909 910 // keep track of previous handle 911 prev_handle = it.handle; 912 913 // does current attribute match 914 // log_info("compare: %04x == %04x", *(uint16_t*) context->attribute_type, *(uint16_t*) uuid); 915 if (it.handle && att_iterator_match_uuid(&it, attribute_type, attribute_type_len)) { 916 917 // check if value has same len as last one 918 uint16_t this_pair_len = 4u + it.value_len; 919 if (offset > 1u){ 920 if (this_pair_len != pair_len) { 921 break; 922 } 923 } 924 925 // log_info("Begin of group, handle 0x%04x", it.handle); 926 927 // first 928 if (offset == 1u) { 929 pair_len = this_pair_len; 930 response_buffer[offset] = this_pair_len; 931 offset++; 932 } 933 934 group_start_handle = it.handle; 935 group_start_value = it.value; 936 in_group = 1; 937 } 938 } 939 940 if (offset == 1u){ 941 return setup_error_atribute_not_found(response_buffer, request_type, start_handle); 942 } 943 944 response_buffer[0] = ATT_READ_BY_GROUP_TYPE_RESPONSE; 945 return offset; 946 } 947 static uint16_t handle_read_by_group_type_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 948 uint8_t * response_buffer, uint16_t response_buffer_size){ 949 uint16_t attribute_type_len; 950 switch (request_len){ 951 case 7: 952 attribute_type_len = 2; 953 break; 954 case 21: 955 attribute_type_len = 16; 956 break; 957 default: 958 return setup_error_invalid_pdu(response_buffer, ATT_READ_BY_GROUP_TYPE_REQUEST); 959 } 960 961 uint16_t start_handle = little_endian_read_16(request_buffer, 1); 962 uint16_t end_handle = little_endian_read_16(request_buffer, 3); 963 return handle_read_by_group_type_request2(att_connection, response_buffer, response_buffer_size, start_handle, end_handle, attribute_type_len, &request_buffer[5]); 964 } 965 966 // 967 // MARK: ATT_WRITE_REQUEST 0x12 968 static uint16_t handle_write_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 969 uint8_t * response_buffer, uint16_t response_buffer_size){ 970 971 UNUSED(response_buffer_size); 972 973 if (request_len < 3u) return setup_error_invalid_pdu(response_buffer, ATT_WRITE_REQUEST); 974 975 uint8_t request_type = ATT_WRITE_REQUEST; 976 977 uint16_t handle = little_endian_read_16(request_buffer, 1); 978 att_iterator_t it; 979 int ok = att_find_handle(&it, handle); 980 if (!ok) { 981 return setup_error_invalid_handle(response_buffer, request_type, handle); 982 } 983 if (att_write_callback == NULL) { 984 return setup_error_write_not_permitted(response_buffer, request_type, handle); 985 } 986 if ((it.flags & ATT_PROPERTY_WRITE) == 0u) { 987 return setup_error_write_not_permitted(response_buffer, request_type, handle); 988 } 989 if ((it.flags & ATT_PROPERTY_DYNAMIC) == 0u) { 990 return setup_error_write_not_permitted(response_buffer, request_type, handle); 991 } 992 // check security requirements 993 int error_code = att_validate_security(att_connection, ATT_WRITE, &it); 994 if (error_code) { 995 return setup_error(response_buffer, request_type, handle, error_code); 996 } 997 att_persistent_ccc_cache(&it); 998 error_code = (*att_write_callback)(att_connection->con_handle, handle, ATT_TRANSACTION_MODE_NONE, 0u, request_buffer + 3u, request_len - 3u); 999 1000 #ifdef ENABLE_ATT_DELAYED_RESPONSE 1001 if (error_code == ATT_ERROR_WRITE_RESPONSE_PENDING) return ATT_INTERNAL_WRITE_RESPONSE_PENDING; 1002 #endif 1003 1004 if (error_code) { 1005 return setup_error(response_buffer, request_type, handle, error_code); 1006 } 1007 response_buffer[0] = ATT_WRITE_RESPONSE; 1008 return 1; 1009 } 1010 1011 // 1012 // MARK: ATT_PREPARE_WRITE_REQUEST 0x16 1013 static uint16_t handle_prepare_write_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 1014 uint8_t * response_buffer, uint16_t response_buffer_size){ 1015 1016 uint8_t request_type = ATT_PREPARE_WRITE_REQUEST; 1017 1018 if (request_len < 5u) return setup_error_invalid_pdu(response_buffer, request_type); 1019 1020 uint16_t handle = little_endian_read_16(request_buffer, 1); 1021 uint16_t offset = little_endian_read_16(request_buffer, 3); 1022 if (att_write_callback == NULL) { 1023 return setup_error_write_not_permitted(response_buffer, request_type, handle); 1024 } 1025 att_iterator_t it; 1026 if (att_find_handle(&it, handle) == 0) { 1027 return setup_error_invalid_handle(response_buffer, request_type, handle); 1028 } 1029 if ((it.flags & ATT_PROPERTY_WRITE) == 0u) { 1030 return setup_error_write_not_permitted(response_buffer, request_type, handle); 1031 } 1032 if ((it.flags & ATT_PROPERTY_DYNAMIC) == 0u) { 1033 return setup_error_write_not_permitted(response_buffer, request_type, handle); 1034 } 1035 // check security requirements 1036 int error_code = att_validate_security(att_connection, ATT_WRITE, &it); 1037 if (error_code) { 1038 return setup_error(response_buffer, request_type, handle, error_code); 1039 } 1040 1041 error_code = (*att_write_callback)(att_connection->con_handle, handle, ATT_TRANSACTION_MODE_ACTIVE, offset, request_buffer + 5u, request_len - 5u); 1042 switch (error_code){ 1043 case 0: 1044 break; 1045 case ATT_ERROR_INVALID_OFFSET: 1046 case ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTH: 1047 // postpone to execute write request 1048 att_prepare_write_update_errors(error_code, handle); 1049 break; 1050 #ifdef ENABLE_ATT_DELAYED_RESPONSE 1051 case ATT_ERROR_WRITE_RESPONSE_PENDING: 1052 return ATT_INTERNAL_WRITE_RESPONSE_PENDING; 1053 #endif 1054 default: 1055 return setup_error(response_buffer, request_type, handle, error_code); 1056 } 1057 1058 // response: echo request 1059 uint16_t bytes_to_echo = btstack_min(request_len, response_buffer_size); 1060 (void)memcpy(response_buffer, request_buffer, bytes_to_echo); 1061 response_buffer[0] = ATT_PREPARE_WRITE_RESPONSE; 1062 return request_len; 1063 } 1064 1065 /* 1066 * @brief transcation queue of prepared writes, e.g., after disconnect 1067 */ 1068 void att_clear_transaction_queue(att_connection_t * att_connection){ 1069 (*att_write_callback)(att_connection->con_handle, 0, ATT_TRANSACTION_MODE_CANCEL, 0, NULL, 0); 1070 } 1071 1072 // MARK: ATT_EXECUTE_WRITE_REQUEST 0x18 1073 // NOTE: security has been verified by handle_prepare_write_request 1074 static uint16_t handle_execute_write_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, 1075 uint8_t * response_buffer, uint16_t response_buffer_size){ 1076 1077 UNUSED(response_buffer_size); 1078 1079 uint8_t request_type = ATT_EXECUTE_WRITE_REQUEST; 1080 1081 if (request_len < 2u) return setup_error_invalid_pdu(response_buffer, request_type); 1082 1083 if (att_write_callback == NULL) { 1084 return setup_error_write_not_permitted(response_buffer, request_type, 0); 1085 } 1086 1087 if (request_buffer[1]) { 1088 // validate queued write 1089 if (att_prepare_write_error_code == 0){ 1090 att_prepare_write_error_code = (*att_write_callback)(att_connection->con_handle, 0, ATT_TRANSACTION_MODE_VALIDATE, 0, NULL, 0); 1091 } 1092 #ifdef ENABLE_ATT_DELAYED_RESPONSE 1093 if (att_prepare_write_error_code == ATT_ERROR_WRITE_RESPONSE_PENDING) return ATT_INTERNAL_WRITE_RESPONSE_PENDING; 1094 #endif 1095 // deliver queued errors 1096 if (att_prepare_write_error_code){ 1097 att_clear_transaction_queue(att_connection); 1098 uint8_t error_code = att_prepare_write_error_code; 1099 uint16_t handle = att_prepare_write_error_handle; 1100 att_prepare_write_reset(); 1101 return setup_error(response_buffer, request_type, handle, error_code); 1102 } 1103 att_write_callback(att_connection->con_handle, 0, ATT_TRANSACTION_MODE_EXECUTE, 0, NULL, 0); 1104 } else { 1105 att_clear_transaction_queue(att_connection); 1106 } 1107 response_buffer[0] = ATT_EXECUTE_WRITE_RESPONSE; 1108 return 1; 1109 } 1110 1111 // MARK: ATT_WRITE_COMMAND 0x52 1112 // Core 4.0, vol 3, part F, 3.4.5.3 1113 // "No Error Response or Write Response shall be sent in response to this command" 1114 static void handle_write_command(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len, uint16_t required_flags){ 1115 1116 if (request_len < 3u) return; 1117 1118 uint16_t handle = little_endian_read_16(request_buffer, 1); 1119 if (att_write_callback == NULL) return; 1120 1121 att_iterator_t it; 1122 int ok = att_find_handle(&it, handle); 1123 if (!ok) return; 1124 if ((it.flags & ATT_PROPERTY_DYNAMIC) == 0u) return; 1125 if ((it.flags & required_flags) == 0u) return; 1126 if (att_validate_security(att_connection, ATT_WRITE, &it)) return; 1127 att_persistent_ccc_cache(&it); 1128 (*att_write_callback)(att_connection->con_handle, handle, ATT_TRANSACTION_MODE_NONE, 0u, request_buffer + 3u, request_len - 3u); 1129 } 1130 1131 // MARK: helper for ATT_HANDLE_VALUE_NOTIFICATION and ATT_HANDLE_VALUE_INDICATION 1132 static uint16_t prepare_handle_value(att_connection_t * att_connection, 1133 uint16_t handle, 1134 const uint8_t *value, 1135 uint16_t value_len, 1136 uint8_t * response_buffer){ 1137 little_endian_store_16(response_buffer, 1, handle); 1138 if (value_len > (att_connection->mtu - 3u)){ 1139 value_len = att_connection->mtu - 3u; 1140 } 1141 (void)memcpy(&response_buffer[3], value, value_len); 1142 return value_len + 3u; 1143 } 1144 1145 // MARK: ATT_HANDLE_VALUE_NOTIFICATION 0x1b 1146 uint16_t att_prepare_handle_value_notification(att_connection_t * att_connection, 1147 uint16_t handle, 1148 const uint8_t *value, 1149 uint16_t value_len, 1150 uint8_t * response_buffer){ 1151 1152 response_buffer[0] = ATT_HANDLE_VALUE_NOTIFICATION; 1153 return prepare_handle_value(att_connection, handle, value, value_len, response_buffer); 1154 } 1155 1156 // MARK: ATT_HANDLE_VALUE_INDICATION 0x1d 1157 uint16_t att_prepare_handle_value_indication(att_connection_t * att_connection, 1158 uint16_t handle, 1159 const uint8_t *value, 1160 uint16_t value_len, 1161 uint8_t * response_buffer){ 1162 1163 response_buffer[0] = ATT_HANDLE_VALUE_INDICATION; 1164 return prepare_handle_value(att_connection, handle, value, value_len, response_buffer); 1165 } 1166 1167 // MARK: Dispatcher 1168 uint16_t att_handle_request(att_connection_t * att_connection, 1169 uint8_t * request_buffer, 1170 uint16_t request_len, 1171 uint8_t * response_buffer){ 1172 uint16_t response_len = 0; 1173 uint16_t response_buffer_size = att_connection->mtu; 1174 1175 switch (request_buffer[0]){ 1176 case ATT_EXCHANGE_MTU_REQUEST: 1177 response_len = handle_exchange_mtu_request(att_connection, request_buffer, request_len, response_buffer); 1178 break; 1179 case ATT_FIND_INFORMATION_REQUEST: 1180 response_len = handle_find_information_request(att_connection, request_buffer, request_len,response_buffer, response_buffer_size); 1181 break; 1182 case ATT_FIND_BY_TYPE_VALUE_REQUEST: 1183 response_len = handle_find_by_type_value_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1184 break; 1185 case ATT_READ_BY_TYPE_REQUEST: 1186 response_len = handle_read_by_type_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1187 break; 1188 case ATT_READ_REQUEST: 1189 response_len = handle_read_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1190 break; 1191 case ATT_READ_BLOB_REQUEST: 1192 response_len = handle_read_blob_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1193 break; 1194 case ATT_READ_MULTIPLE_REQUEST: 1195 response_len = handle_read_multiple_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1196 break; 1197 case ATT_READ_BY_GROUP_TYPE_REQUEST: 1198 response_len = handle_read_by_group_type_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1199 break; 1200 case ATT_WRITE_REQUEST: 1201 response_len = handle_write_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1202 break; 1203 case ATT_PREPARE_WRITE_REQUEST: 1204 response_len = handle_prepare_write_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1205 break; 1206 case ATT_EXECUTE_WRITE_REQUEST: 1207 response_len = handle_execute_write_request(att_connection, request_buffer, request_len, response_buffer, response_buffer_size); 1208 break; 1209 case ATT_WRITE_COMMAND: 1210 handle_write_command(att_connection, request_buffer, request_len, ATT_PROPERTY_WRITE_WITHOUT_RESPONSE); 1211 break; 1212 #ifdef ENABLE_LE_SIGNED_WRITE 1213 case ATT_SIGNED_WRITE_COMMAND: 1214 handle_write_command(att_connection, request_buffer, request_len, ATT_PROPERTY_AUTHENTICATED_SIGNED_WRITE); 1215 break; 1216 #endif 1217 default: 1218 log_info("Unhandled ATT Command: %02X, DATA: ", request_buffer[0]); 1219 log_info_hexdump(&request_buffer[9u], request_len-9u); 1220 break; 1221 } 1222 return response_len; 1223 } 1224 1225 // returns 1 if service found. only primary service. 1226 bool gatt_server_get_get_handle_range_for_service_with_uuid16(uint16_t uuid16, uint16_t * start_handle, uint16_t * end_handle){ 1227 uint16_t in_group = 0; 1228 uint16_t prev_handle = 0; 1229 1230 uint8_t attribute_value[2]; 1231 int attribute_len = sizeof(attribute_value); 1232 little_endian_store_16(attribute_value, 0, uuid16); 1233 1234 att_iterator_t it; 1235 att_iterator_init(&it); 1236 while (att_iterator_has_next(&it)){ 1237 att_iterator_fetch_next(&it); 1238 int new_service_started = att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID); 1239 1240 // close current tag, if within a group and a new service definition starts or we reach end of att db 1241 if (in_group && 1242 ((it.handle == 0u) || new_service_started)){ 1243 *end_handle = prev_handle; 1244 return true; 1245 } 1246 1247 // keep track of previous handle 1248 prev_handle = it.handle; 1249 1250 // check if found 1251 if (it.handle && new_service_started && (attribute_len == it.value_len) && (memcmp(attribute_value, it.value, it.value_len) == 0)){ 1252 *start_handle = it.handle; 1253 in_group = true; 1254 } 1255 } 1256 return false; 1257 } 1258 1259 // returns false if not found 1260 uint16_t gatt_server_get_value_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t uuid16){ 1261 att_iterator_t it; 1262 att_iterator_init(&it); 1263 while (att_iterator_has_next(&it)){ 1264 att_iterator_fetch_next(&it); 1265 if (it.handle && (it.handle < start_handle)) continue; 1266 if (it.handle > end_handle) break; // (1) 1267 if (it.handle == 0u) break; 1268 if (att_iterator_match_uuid16(&it, uuid16)) return it.handle; 1269 } 1270 return 0; 1271 } 1272 1273 uint16_t gatt_server_get_descriptor_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16, uint16_t descriptor_uuid16){ 1274 att_iterator_t it; 1275 att_iterator_init(&it); 1276 int characteristic_found = 0; 1277 while (att_iterator_has_next(&it)){ 1278 att_iterator_fetch_next(&it); 1279 if (it.handle && (it.handle < start_handle)) continue; 1280 if (it.handle > end_handle) break; // (1) 1281 if (it.handle == 0u) break; 1282 if (att_iterator_match_uuid16(&it, characteristic_uuid16)){ 1283 characteristic_found = 1; 1284 continue; 1285 } 1286 if (att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) 1287 || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID) 1288 || att_iterator_match_uuid16(&it, GATT_CHARACTERISTICS_UUID)){ 1289 if (characteristic_found) break; 1290 continue; 1291 } 1292 if (characteristic_found && att_iterator_match_uuid16(&it, descriptor_uuid16)){ 1293 return it.handle; 1294 } 1295 } 1296 return 0; 1297 } 1298 1299 // returns 0 if not found 1300 uint16_t gatt_server_get_client_configuration_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16){ 1301 return gatt_server_get_descriptor_handle_for_characteristic_with_uuid16(start_handle, end_handle, characteristic_uuid16, GATT_CLIENT_CHARACTERISTICS_CONFIGURATION); 1302 } 1303 // returns 0 if not found 1304 1305 uint16_t gatt_server_get_server_configuration_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16){ 1306 return gatt_server_get_descriptor_handle_for_characteristic_with_uuid16(start_handle, end_handle, characteristic_uuid16, GATT_SERVER_CHARACTERISTICS_CONFIGURATION); 1307 } 1308 1309 // returns 1 if service found. only primary service. 1310 int gatt_server_get_get_handle_range_for_service_with_uuid128(const uint8_t * uuid128, uint16_t * start_handle, uint16_t * end_handle){ 1311 uint16_t in_group = 0; 1312 uint16_t prev_handle = 0; 1313 1314 uint8_t attribute_value[16]; 1315 int attribute_len = sizeof(attribute_value); 1316 reverse_128(uuid128, attribute_value); 1317 1318 att_iterator_t it; 1319 att_iterator_init(&it); 1320 while (att_iterator_has_next(&it)){ 1321 att_iterator_fetch_next(&it); 1322 int new_service_started = att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID); 1323 1324 // close current tag, if within a group and a new service definition starts or we reach end of att db 1325 if (in_group && 1326 ((it.handle == 0u) || new_service_started)){ 1327 *end_handle = prev_handle; 1328 return 1; 1329 } 1330 1331 // keep track of previous handle 1332 prev_handle = it.handle; 1333 1334 // check if found 1335 if (it.handle && new_service_started && (attribute_len == it.value_len) && (memcmp(attribute_value, it.value, it.value_len) == 0)){ 1336 *start_handle = it.handle; 1337 in_group = 1; 1338 } 1339 } 1340 return 0; 1341 } 1342 1343 // returns 0 if not found 1344 uint16_t gatt_server_get_value_handle_for_characteristic_with_uuid128(uint16_t start_handle, uint16_t end_handle, const uint8_t * uuid128){ 1345 uint8_t attribute_value[16]; 1346 reverse_128(uuid128, attribute_value); 1347 att_iterator_t it; 1348 att_iterator_init(&it); 1349 while (att_iterator_has_next(&it)){ 1350 att_iterator_fetch_next(&it); 1351 if (it.handle && (it.handle < start_handle)) continue; 1352 if (it.handle > end_handle) break; // (1) 1353 if (it.handle == 0u) break; 1354 if (att_iterator_match_uuid(&it, attribute_value, 16)) return it.handle; 1355 } 1356 return 0; 1357 } 1358 1359 // returns 0 if not found 1360 uint16_t gatt_server_get_client_configuration_handle_for_characteristic_with_uuid128(uint16_t start_handle, uint16_t end_handle, const uint8_t * uuid128){ 1361 uint8_t attribute_value[16]; 1362 reverse_128(uuid128, attribute_value); 1363 att_iterator_t it; 1364 att_iterator_init(&it); 1365 int characteristic_found = 0; 1366 while (att_iterator_has_next(&it)){ 1367 att_iterator_fetch_next(&it); 1368 if (it.handle && (it.handle < start_handle)) continue; 1369 if (it.handle > end_handle) break; // (1) 1370 if (it.handle == 0u) break; 1371 if (att_iterator_match_uuid(&it, attribute_value, 16)){ 1372 characteristic_found = 1; 1373 continue; 1374 } 1375 if (att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) 1376 || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID) 1377 || att_iterator_match_uuid16(&it, GATT_CHARACTERISTICS_UUID)){ 1378 if (characteristic_found) break; 1379 continue; 1380 } 1381 if (characteristic_found && att_iterator_match_uuid16(&it, GATT_CLIENT_CHARACTERISTICS_CONFIGURATION)){ 1382 return it.handle; 1383 } 1384 } 1385 return 0; 1386 } 1387 1388 1389 // 1-item cache to optimize query during write_callback 1390 static void att_persistent_ccc_cache(att_iterator_t * it){ 1391 att_persistent_ccc_handle = it->handle; 1392 if (it->flags & ATT_PROPERTY_UUID128){ 1393 att_persistent_ccc_uuid16 = 0; 1394 } else { 1395 att_persistent_ccc_uuid16 = little_endian_read_16(it->uuid, 0); 1396 } 1397 } 1398 1399 bool att_is_persistent_ccc(uint16_t handle){ 1400 if (handle != att_persistent_ccc_handle){ 1401 att_iterator_t it; 1402 int ok = att_find_handle(&it, handle); 1403 if (!ok) return false; 1404 att_persistent_ccc_cache(&it); 1405 } 1406 return att_persistent_ccc_uuid16 == GATT_CLIENT_CHARACTERISTICS_CONFIGURATION; 1407 } 1408 1409 // att_read_callback helpers 1410 uint16_t att_read_callback_handle_blob(const uint8_t * blob, uint16_t blob_size, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){ 1411 if (buffer){ 1412 uint16_t bytes_to_copy = btstack_min(blob_size - offset, buffer_size); 1413 (void)memcpy(buffer, &blob[offset], bytes_to_copy); 1414 return bytes_to_copy; 1415 } else { 1416 return blob_size; 1417 } 1418 } 1419 1420 uint16_t att_read_callback_handle_little_endian_32(uint32_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){ 1421 uint8_t value_buffer[4]; 1422 little_endian_store_32(value_buffer, 0, value); 1423 return att_read_callback_handle_blob(value_buffer, sizeof(value_buffer), offset, buffer, buffer_size); 1424 } 1425 1426 uint16_t att_read_callback_handle_little_endian_16(uint16_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){ 1427 uint8_t value_buffer[2]; 1428 little_endian_store_16(value_buffer, 0, value); 1429 return att_read_callback_handle_blob(value_buffer, sizeof(value_buffer), offset, buffer, buffer_size); 1430 } 1431 1432 uint16_t att_read_callback_handle_byte(uint8_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){ 1433 uint8_t value_buffer[1]; 1434 value_buffer[0] = value; 1435 return att_read_callback_handle_blob(value_buffer, sizeof(value_buffer), offset, buffer, buffer_size); 1436 } 1437