//
// MARK: ATT_READ_MULTIPLE_REQUEST 0x0e
//
static uint16_t handle_read_multiple_request2(uint8_t * response_buffer, uint16_t response_buffer_size, uint16_t num_handles, uint16_t * handles){
printf("ATT_READ_MULTIPLE_REQUEST: num handles %u\n", num_handles);
uint16_t offset = 1;
int i;
for (i=0;i<num_handles;i++){
uint16_t handle = handles[i];
if (handle == 0){
return setup_error_invalid_handle(response_buffer, ATT_READ_MULTIPLE_REQUEST, handle);
}
att_iterator_t it;
int ok = att_find_handle(&it, handle);
if (!ok){
return setup_error_invalid_handle(response_buffer, ATT_READ_MULTIPLE_REQUEST, handle);
}
att_update_value_len(&it);
// limit data
if (offset + it.value_len > response_buffer_size) {
it.value_len = response_buffer_size - 1;
}
// store
uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, it.value_len);
offset += bytes_copied;
}
response_buffer[0] = ATT_READ_MULTIPLE_RESPONSE;
return offset;
}
//
// MARK: ATT_READ_MULTIPLE_REQUEST 0x0e
//
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){
log_info("ATT_READ_MULTIPLE_REQUEST: num handles %u", num_handles);
uint8_t request_type = ATT_READ_MULTIPLE_REQUEST;
// TODO: figure out which error to respond with
// if (num_handles < 2){
// return setup_error(response_buffer, ATT_READ_MULTIPLE_REQUEST, handle, ???);
// }
uint16_t offset = 1;
int i;
uint8_t error_code = 0;
uint16_t handle = 0;
for (i=0;i<num_handles;i++){
handle = READ_BT_16(handles, i << 1);
if (handle == 0){
return setup_error_invalid_handle(response_buffer, request_type, handle);
}
att_iterator_t it;
int ok = att_find_handle(&it, handle);
if (!ok){
return setup_error_invalid_handle(response_buffer, request_type, handle);
}
// check if handle can be read
if ((it.flags & ATT_PROPERTY_READ) == 0) {
error_code = ATT_ERROR_READ_NOT_PERMITTED;
break;
}
// check security requirements
error_code = att_validate_security(att_connection, &it);
if (error_code) break;
att_update_value_len(&it, att_connection->con_handle);
// limit data
if (offset + it.value_len > response_buffer_size) {
it.value_len = response_buffer_size - 1;
}
// store
uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, it.value_len, att_connection->con_handle);
offset += bytes_copied;
}
if (error_code){
return setup_error(response_buffer, request_type, handle, error_code);
}
response_buffer[0] = ATT_READ_MULTIPLE_RESPONSE;
return offset;
}
//
// MARK: ATT_WRITE_REQUEST 0x12
static uint16_t handle_write_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len,
uint8_t * response_buffer, uint16_t response_buffer_size){
uint8_t request_type = ATT_WRITE_REQUEST;
uint16_t handle = READ_BT_16(request_buffer, 1);
att_iterator_t it;
int ok = att_find_handle(&it, handle);
if (!ok) {
return setup_error_invalid_handle(response_buffer, request_type, handle);
}
if (!att_write_callback) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
if ((it.flags & ATT_PROPERTY_WRITE) == 0) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
if ((it.flags & ATT_PROPERTY_DYNAMIC) == 0) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
// check security requirements
uint8_t error_code = att_validate_security(att_connection, &it);
if (error_code) {
return setup_error(response_buffer, request_type, handle, error_code);
}
error_code = (*att_write_callback)(att_connection->con_handle, handle, ATT_TRANSACTION_MODE_NONE, 0, request_buffer + 3, request_len - 3);
if (error_code) {
return setup_error(response_buffer, request_type, handle, error_code);
}
response_buffer[0] = ATT_WRITE_RESPONSE;
return 1;
}
//
// MARK: ATT_FIND_BY_TYPE_VALUE
//
// "Only attributes with attribute handles between and including the Starting Handle parameter
// and the Ending Handle parameter that match the requested attri- bute type and the attribute
// value that have sufficient permissions to allow reading will be returned" -> (1)
//
// TODO: handle other types then GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID
//
// NOTE: doesn't handle DYNAMIC values
// NOTE: only supports 16 bit UUIDs
//
static uint16_t handle_find_by_type_value_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size,
uint16_t start_handle, uint16_t end_handle,
uint16_t attribute_type, uint16_t attribute_len, uint8_t* attribute_value){
log_info("ATT_FIND_BY_TYPE_VALUE_REQUEST: from %04X to %04X, type %04X, value: ", start_handle, end_handle, attribute_type);
hexdump(attribute_value, attribute_len);
uint8_t request_type = ATT_FIND_BY_TYPE_VALUE_REQUEST;
if (start_handle > end_handle || start_handle == 0){
return setup_error_invalid_handle(response_buffer, request_type, start_handle);
}
uint16_t offset = 1;
uint16_t in_group = 0;
uint16_t prev_handle = 0;
att_iterator_t it;
att_iterator_init(&it);
while (att_iterator_has_next(&it)){
att_iterator_fetch_next(&it);
if (it.handle && it.handle < start_handle) continue;
if (it.handle > end_handle) break; // (1)
// close current tag, if within a group and a new service definition starts or we reach end of att db
if (in_group &&
(it.handle == 0 || att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID))){
log_info("End of group, handle 0x%04x", prev_handle);
bt_store_16(response_buffer, offset, prev_handle);
offset += 2;
in_group = 0;
// check if space for another handle pair available
if (offset + 4 > response_buffer_size){
break;
}
}
// keep track of previous handle
prev_handle = it.handle;
// does current attribute match
if (it.handle && att_iterator_match_uuid16(&it, attribute_type) && attribute_len == it.value_len && memcmp(attribute_value, it.value, it.value_len) == 0){
log_info("Begin of group, handle 0x%04x", it.handle);
bt_store_16(response_buffer, offset, it.handle);
offset += 2;
in_group = 1;
}
}
if (offset == 1){
return setup_error_atribute_not_found(response_buffer, request_type, start_handle);
}
response_buffer[0] = ATT_FIND_BY_TYPE_VALUE_RESPONSE;
return offset;
}
//
// MARK: ATT_FIND_INFORMATION_REQUEST
//
// TODO: handle other types then GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID
//
static uint16_t handle_find_information_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size,
uint16_t start_handle, uint16_t end_handle){
log_info("ATT_FIND_INFORMATION_REQUEST: from %04X to %04X", start_handle, end_handle);
uint8_t request_type = ATT_FIND_INFORMATION_REQUEST;
if (start_handle > end_handle || start_handle == 0){
return setup_error_invalid_handle(response_buffer, request_type, start_handle);
}
uint16_t offset = 1;
uint16_t uuid_len = 0;
att_iterator_t it;
att_iterator_init(&it);
while (att_iterator_has_next(&it)){
att_iterator_fetch_next(&it);
if (!it.handle) break;
if (it.handle > end_handle) break;
if (it.handle < start_handle) continue;
// log_info("Handle 0x%04x", it.handle);
uint16_t this_uuid_len = (it.flags & ATT_PROPERTY_UUID128) ? 16 : 2;
// check if value has same len as last one if not first result
if (offset > 1){
if (this_uuid_len != uuid_len) {
break;
}
}
// first
if (offset == 1) {
uuid_len = this_uuid_len;
// set format field
response_buffer[offset] = (it.flags & ATT_PROPERTY_UUID128) ? 0x02 : 0x01;
offset++;
}
// space?
if (offset + 2 + uuid_len > response_buffer_size) break;
// store
bt_store_16(response_buffer, offset, it.handle);
offset += 2;
memcpy(response_buffer + offset, it.uuid, uuid_len);
offset += uuid_len;
}
if (offset == 1){
return setup_error_atribute_not_found(response_buffer, request_type, start_handle);
}
response_buffer[0] = ATT_FIND_INFORMATION_REPLY;
return offset;
}
//
// MARK: ATT_PREPARE_WRITE_REQUEST 0x16
static uint16_t handle_prepare_write_request(att_connection_t * att_connection, uint8_t * request_buffer, uint16_t request_len,
uint8_t * response_buffer, uint16_t response_buffer_size){
uint8_t request_type = ATT_PREPARE_WRITE_REQUEST;
uint16_t handle = READ_BT_16(request_buffer, 1);
uint16_t offset = READ_BT_16(request_buffer, 3);
if (!att_write_callback) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
att_iterator_t it;
int ok = att_find_handle(&it, handle);
if (!ok) {
return setup_error_invalid_handle(response_buffer, request_type, handle);
}
if ((it.flags & ATT_PROPERTY_WRITE) == 0) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
if ((it.flags & ATT_PROPERTY_DYNAMIC) == 0) {
return setup_error_write_not_permitted(response_buffer, request_type, handle);
}
// check security requirements
uint8_t error_code = att_validate_security(att_connection, &it);
if (error_code) {
return setup_error(response_buffer, request_type, handle, error_code);
}
error_code = (*att_write_callback)(att_connection->con_handle, handle, ATT_TRANSACTION_MODE_ACTIVE, offset, request_buffer + 5, request_len - 5);
switch (error_code){
case 0:
break;
case ATT_ERROR_INVALID_OFFSET:
case ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTH:
// postpone to execute write request
att_prepare_write_update_errors(error_code, handle);
break;
default:
return setup_error(response_buffer, request_type, handle, error_code);
}
// response: echo request
memcpy(response_buffer, request_buffer, request_len);
response_buffer[0] = ATT_PREPARE_WRITE_RESPONSE;
return request_len;
}
//
// MARK: ATT_READ_BLOB_REQUEST 0x0c
//
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){
log_info("ATT_READ_BLOB_REQUEST: handle %04x, offset %u", handle, value_offset);
uint8_t request_type = ATT_READ_BLOB_REQUEST;
att_iterator_t it;
int ok = att_find_handle(&it, handle);
if (!ok){
return setup_error_invalid_handle(response_buffer, request_type, handle);
}
// check if handle can be read
if ((it.flags & ATT_PROPERTY_READ) == 0) {
return setup_error_read_not_permitted(response_buffer, request_type, handle);
}
// check security requirements
uint8_t error_code = att_validate_security(att_connection, &it);
if (error_code) {
return setup_error(response_buffer, request_type, handle, error_code);
}
att_update_value_len(&it, att_connection->con_handle);
if (value_offset > it.value_len){
return setup_error_invalid_offset(response_buffer, request_type, handle);
}
// limit data
uint16_t offset = 1;
if (offset + it.value_len - value_offset > response_buffer_size) {
it.value_len = response_buffer_size - 1 + value_offset;
}
// store
uint16_t bytes_copied = att_copy_value(&it, value_offset, response_buffer + offset, it.value_len - value_offset, att_connection->con_handle);
offset += bytes_copied;
response_buffer[0] = ATT_READ_BLOB_RESPONSE;
return offset;
}
//
// MARK: ATT_READ_BY_GROUP_TYPE_REQUEST 0x10
//
// Only handles GATT_PRIMARY_SERVICE_UUID and GATT_SECONDARY_SERVICE_UUID
// Core v4.0, vol 3, part g, 2.5.3
// "The «Primary Service» and «Secondary Service» grouping types may be used in the Read By Group Type Request.
// The «Characteristic» grouping type shall not be used in the ATT Read By Group Type Request."
//
// NOTE: doesn't handle DYNAMIC values
//
// NOTE: we don't check for security as PRIMARY and SECONDAY SERVICE definition shouldn't be protected
// Core 4.0, vol 3, part g, 8.1
// "The list of services and characteristics that a device supports is not considered private or
// confidential information, and therefore the Service and Characteristic Discovery procedures
// shall always be permitted. "
//
static uint16_t handle_read_by_group_type_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size,
uint16_t start_handle, uint16_t end_handle,
uint16_t attribute_type_len, uint8_t * attribute_type){
log_info("ATT_READ_BY_GROUP_TYPE_REQUEST: from %04X to %04X, buffer size %u, type: ", start_handle, end_handle, response_buffer_size);
hexdump(attribute_type, attribute_type_len);
uint8_t request_type = ATT_READ_BY_GROUP_TYPE_REQUEST;
if (start_handle > end_handle || start_handle == 0){
return setup_error_invalid_handle(response_buffer, request_type, start_handle);
}
// assert UUID is primary or secondary service uuid
uint16_t uuid16 = uuid16_from_uuid(attribute_type_len, attribute_type);
if (uuid16 != GATT_PRIMARY_SERVICE_UUID && uuid16 != GATT_SECONDARY_SERVICE_UUID){
return setup_error(response_buffer, request_type, start_handle, ATT_ERROR_UNSUPPORTED_GROUP_TYPE);
}
uint16_t offset = 1;
uint16_t pair_len = 0;
uint16_t in_group = 0;
uint16_t group_start_handle = 0;
uint8_t const * group_start_value = NULL;
uint16_t prev_handle = 0;
att_iterator_t it;
att_iterator_init(&it);
while (att_iterator_has_next(&it)){
att_iterator_fetch_next(&it);
if (it.handle && it.handle < start_handle) continue;
if (it.handle > end_handle) break; // (1)
// log_info("Handle 0x%04x", it.handle);
// close current tag, if within a group and a new service definition starts or we reach end of att db
if (in_group &&
(it.handle == 0 || att_iterator_match_uuid16(&it, GATT_PRIMARY_SERVICE_UUID) || att_iterator_match_uuid16(&it, GATT_SECONDARY_SERVICE_UUID))){
// log_info("End of group, handle 0x%04x, val_len: %u", prev_handle, pair_len - 4);
bt_store_16(response_buffer, offset, group_start_handle);
offset += 2;
bt_store_16(response_buffer, offset, prev_handle);
offset += 2;
memcpy(response_buffer + offset, group_start_value, pair_len - 4);
offset += pair_len - 4;
in_group = 0;
// check if space for another handle pair available
if (offset + pair_len > response_buffer_size){
break;
}
}
// keep track of previous handle
prev_handle = it.handle;
// does current attribute match
// log_info("compare: %04x == %04x", *(uint16_t*) context->attribute_type, *(uint16_t*) uuid);
if (it.handle && att_iterator_match_uuid(&it, attribute_type, attribute_type_len)) {
// check if value has same len as last one
uint16_t this_pair_len = 4 + it.value_len;
if (offset > 1){
if (this_pair_len != pair_len) {
break;
}
}
// log_info("Begin of group, handle 0x%04x", it.handle);
// first
if (offset == 1) {
pair_len = this_pair_len;
response_buffer[offset] = this_pair_len;
offset++;
}
group_start_handle = it.handle;
group_start_value = it.value;
in_group = 1;
}
}
if (offset == 1){
return setup_error_atribute_not_found(response_buffer, request_type, start_handle);
}
response_buffer[0] = ATT_READ_BY_GROUP_TYPE_RESPONSE;
return offset;
}
//
// MARK: ATT_READ_BY_TYPE_REQUEST
//
static uint16_t handle_read_by_type_request2(att_connection_t * att_connection, uint8_t * response_buffer, uint16_t response_buffer_size,
uint16_t start_handle, uint16_t end_handle,
uint16_t attribute_type_len, uint8_t * attribute_type){
log_info("ATT_READ_BY_TYPE_REQUEST: from %04X to %04X, type: ", start_handle, end_handle);
hexdump(attribute_type, attribute_type_len);
uint8_t request_type = ATT_READ_BY_TYPE_REQUEST;
if (start_handle > end_handle || start_handle == 0){
return setup_error_invalid_handle(response_buffer, request_type, start_handle);
}
uint16_t offset = 1;
uint16_t pair_len = 0;
att_iterator_t it;
att_iterator_init(&it);
uint8_t error_code = 0;
uint16_t first_matching_but_unreadable_handle = 0;
while (att_iterator_has_next(&it)){
att_iterator_fetch_next(&it);
if (!it.handle) break;
if (it.handle < start_handle) continue;
if (it.handle > end_handle) break; // (1)
// does current attribute match
if (!att_iterator_match_uuid(&it, attribute_type, attribute_type_len)) continue;
// skip handles that cannot be read but rembember that there has been at least one
if ((it.flags & ATT_PROPERTY_READ) == 0) {
if (first_matching_but_unreadable_handle == 0) {
first_matching_but_unreadable_handle = it.handle;
}
continue;
}
// check security requirements
error_code = att_validate_security(att_connection, &it);
if (error_code) break;
att_update_value_len(&it, att_connection->con_handle);
// check if value has same len as last one
uint16_t this_pair_len = 2 + it.value_len;
if (offset > 1){
if (pair_len != this_pair_len) {
break;
}
}
// first
if (offset == 1) {
pair_len = this_pair_len;
response_buffer[offset] = pair_len;
offset++;
}
// space?
if (offset + pair_len > response_buffer_size) {
if (offset > 2) break;
it.value_len = response_buffer_size - 4;
response_buffer[1] = 2 + it.value_len;
}
// store
bt_store_16(response_buffer, offset, it.handle);
offset += 2;
uint16_t bytes_copied = att_copy_value(&it, 0, response_buffer + offset, it.value_len, att_connection->con_handle);
offset += bytes_copied;
}
// at least one attribute could be read
if (offset > 1){
response_buffer[0] = ATT_READ_BY_TYPE_RESPONSE;
return offset;
}
// first attribute had an error
if (error_code){
return setup_error(response_buffer, request_type, start_handle, error_code);
}
// no other errors, but all found attributes had been non-readable
if (first_matching_but_unreadable_handle){
return setup_error_read_not_permitted(response_buffer, request_type, first_matching_but_unreadable_handle);
}
// attribute not found
return setup_error_atribute_not_found(response_buffer, request_type, start_handle);
}