GenericGattClient.cpp

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2017-2017 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #include <stdio.h>
00018 #include <stdlib.h>
00019 
00020 #include <ble/DiscoveredService.h>
00021 #include <ble/DiscoveredCharacteristic.h>
00022 #include "ble/generic/GenericGattClient.h"
00023 #include "ble/blecommon.h"
00024 #include <algorithm>
00025 
00026 using ble::pal::AttServerMessage;
00027 using ble::pal::AttReadResponse;
00028 using ble::pal::AttReadBlobResponse;
00029 using ble::pal::AttReadByTypeResponse;
00030 using ble::pal::AttReadByGroupTypeResponse;
00031 using ble::pal::AttFindByTypeValueResponse;
00032 using ble::pal::AttErrorResponse;
00033 using ble::pal::AttributeOpcode;
00034 using ble::pal::AttWriteResponse;
00035 using ble::pal::AttPrepareWriteResponse;
00036 using ble::pal::AttExecuteWriteResponse;
00037 using ble::pal::AttHandleValueIndication;
00038 using ble::pal::AttHandleValueNotification;
00039 using ble::pal::AttFindInformationResponse;
00040 
00041 namespace ble {
00042 namespace generic {
00043 
00044 /*
00045  * Type of procedures which can be launched by the client.
00046  */
00047 enum procedure_type_t {
00048     COMPLETE_DISCOVERY_PROCEDURE,
00049     READ_PROCEDURE,
00050     WRITE_PROCEDURE,
00051     DESCRIPTOR_DISCOVERY_PROCEDURE
00052 };
00053 
00054 
00055 /*
00056  * Base class for a procedure control block
00057  */
00058 struct GenericGattClient::ProcedureControlBlock {
00059     /*
00060      * Base constructor for procedure control block.
00061      */
00062     ProcedureControlBlock(procedure_type_t type, Gap::Handle_t handle) :
00063         type(type), connection_handle(handle), next(NULL) { }
00064 
00065     virtual ~ProcedureControlBlock() { }
00066 
00067     /*
00068      * Entry point of the control block stack machine.
00069      */
00070     virtual void handle(GenericGattClient* client, const AttServerMessage& message) = 0;
00071 
00072     /*
00073      * Function call in case of timeout
00074      */
00075     virtual void handle_timeout_error(GenericGattClient* client) = 0;
00076 
00077     /**
00078      * Function called when the procedure is aborted
00079      */
00080     virtual void abort(GenericGattClient *client) = 0;
00081 
00082     procedure_type_t type;
00083     Gap::Handle_t connection_handle;
00084     ProcedureControlBlock* next;
00085 };
00086 
00087 
00088 /*
00089  * Procedure control block for the discovery process.
00090  */
00091 struct GenericGattClient::DiscoveryControlBlock : public ProcedureControlBlock {
00092     DiscoveryControlBlock(
00093         Gap::Handle_t handle,
00094         ServiceDiscovery::ServiceCallback_t  service_callback,
00095         ServiceDiscovery::CharacteristicCallback_t  characteristic_callback,
00096         UUID matching_service_uuid,
00097         UUID matching_characteristic_uuid
00098     ) : ProcedureControlBlock(COMPLETE_DISCOVERY_PROCEDURE, handle),
00099         service_callback(service_callback),
00100         characteristic_callback(characteristic_callback),
00101         matching_service_uuid(matching_service_uuid),
00102         matching_characteristic_uuid(matching_characteristic_uuid),
00103         services_discovered(NULL),
00104         done(false) {
00105     }
00106 
00107     virtual ~DiscoveryControlBlock() {
00108         while(services_discovered) {
00109             service_t* tmp = services_discovered->next;
00110             delete services_discovered;
00111             services_discovered = tmp;
00112         }
00113     }
00114 
00115     virtual void handle_timeout_error(GenericGattClient* client) {
00116         terminate(client);
00117     }
00118 
00119     virtual void abort(GenericGattClient *client) {
00120         terminate(client);
00121     }
00122 
00123     virtual void handle(GenericGattClient* client, const AttServerMessage& message) {
00124         // if end of discovery has been requested, ends it immediately
00125         if (done) {
00126             terminate(client);
00127             return;
00128         }
00129 
00130         switch(message.opcode) {
00131             case AttributeOpcode::READ_BY_GROUP_TYPE_RESPONSE:
00132                 handle_service_discovered(
00133                     client, static_cast<const AttReadByGroupTypeResponse&>(message)
00134                 );
00135                break;
00136             case AttributeOpcode::FIND_BY_VALUE_TYPE_RESPONSE:
00137                 handle_service_discovered(
00138                     client, static_cast<const AttFindByTypeValueResponse&>(message)
00139                 );
00140                 break;
00141             case AttributeOpcode::READ_BY_TYPE_RESPONSE:
00142                 handle_characteristic_discovered(
00143                     client, static_cast<const AttReadByTypeResponse&>(message)
00144                 );
00145                 break;
00146             case AttributeOpcode::ERROR_RESPONSE: {
00147                 const AttErrorResponse& error = static_cast<const AttErrorResponse&>(message);
00148                 if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) {
00149                     terminate(client);
00150                 }
00151 
00152                 switch (error.request_opcode) {
00153                     case AttributeOpcode::READ_BY_GROUP_TYPE_REQUEST:
00154                     case AttributeOpcode::FIND_BY_TYPE_VALUE_REQUEST:
00155                         start_characteristic_discovery(client);
00156                         break;
00157                     case AttributeOpcode::READ_BY_TYPE_REQUEST:
00158                         handle_all_characteristics_discovered(client);
00159                         break;
00160                     default:
00161                         // error
00162                         break;
00163                 }
00164             }   break;
00165             default:
00166                 // error
00167                 break;
00168         }
00169     }
00170 
00171     template<typename Response>
00172     void handle_service_discovered(GenericGattClient* client, const Response& response) {
00173         if (!response.size()) {
00174             terminate(client);
00175             return;
00176         }
00177 
00178         uint16_t end_handle = 0x0000;
00179         for (size_t i = 0; i < response.size(); ++i) {
00180             uint16_t start_handle = get_start_handle(response[i]);
00181             end_handle = get_end_handle(response[i]);
00182             UUID uuid = get_uuid(response[i]);
00183 
00184             if (!characteristic_callback) {
00185                 DiscoveredService discovered_service;
00186                 discovered_service.setup(uuid, start_handle, end_handle);
00187                 service_callback(&discovered_service);
00188             } else {
00189                 service_t* discovered_service = new (std::nothrow) service_t(
00190                     start_handle, end_handle, uuid
00191                 );
00192 
00193                 if (discovered_service == NULL) {
00194                     terminate(client);
00195                     return;
00196                 }
00197 
00198                 insert_service(discovered_service);
00199             }
00200         }
00201 
00202         if (end_handle == 0xFFFF) {
00203             start_characteristic_discovery(client);
00204         } else {
00205             ble_error_t err = client->_pal_client->discover_primary_service(
00206                 connection_handle, end_handle + 1
00207             );
00208 
00209             if (err) {
00210                 terminate(client);
00211             }
00212         }
00213     }
00214 
00215     void start_characteristic_discovery(GenericGattClient* client) {
00216         if (!services_discovered) {
00217             terminate(client);
00218             return;
00219         }
00220 
00221         if (!characteristic_callback) {
00222             terminate(client);
00223             return;
00224         }
00225 
00226         if (service_callback) {
00227             DiscoveredService discovered_service;
00228             discovered_service.setup(
00229                 services_discovered->uuid,
00230                 services_discovered->begin,
00231                 services_discovered->end
00232             );
00233             service_callback(&discovered_service);
00234         }
00235 
00236         last_characteristic = characteristic_t();
00237         client->_pal_client->discover_characteristics_of_a_service(
00238             connection_handle,
00239             attribute_handle_range(
00240                 services_discovered->begin,
00241                 services_discovered->end
00242             )
00243         );
00244     }
00245 
00246     void handle_characteristic_discovered(GenericGattClient* client, const AttReadByTypeResponse& response) {
00247         for (size_t i = 0; i < response.size(); ++i) {
00248             if (last_characteristic.is_valid() == false) {
00249                 last_characteristic.set_last_handle(response[i].handle - 1);
00250                 if (matching_characteristic_uuid == UUID()
00251                 || last_characteristic.getUUID() == matching_characteristic_uuid) {
00252                     characteristic_callback(&last_characteristic);
00253                 }
00254             }
00255 
00256             last_characteristic = characteristic_t(
00257                 client, connection_handle, response[i].handle, response[i].value
00258             );
00259         }
00260 
00261         // check if all the characteristics of the service has been discovered
00262         if (last_characteristic.getValueHandle() == services_discovered->end) {
00263             handle_all_characteristics_discovered(client);
00264         } else {
00265             ble_error_t err = client->_pal_client->discover_characteristics_of_a_service(
00266                 connection_handle,
00267                 attribute_handle_range(
00268                     last_characteristic.getValueHandle() + 1,
00269                     services_discovered->end
00270                 )
00271             );
00272 
00273             if (err) {
00274                 terminate(client);
00275             }
00276         }
00277     }
00278 
00279     void handle_all_characteristics_discovered(GenericGattClient* client) {
00280         if (last_characteristic.is_valid() == false) {
00281             if (matching_characteristic_uuid == UUID()
00282                 || matching_characteristic_uuid == last_characteristic.getUUID()) {
00283                 last_characteristic.set_last_handle(services_discovered->end);
00284                 characteristic_callback(&last_characteristic);
00285             }
00286         }
00287 
00288         service_t* old = services_discovered;
00289         services_discovered = services_discovered->next;
00290         delete old;
00291 
00292         if (!services_discovered) {
00293             terminate(client);
00294         } else {
00295             start_characteristic_discovery(client);
00296         }
00297     }
00298 
00299     void terminate(GenericGattClient* client) {
00300         // unknown error, terminate the procedure immediately
00301         client->remove_control_block(this);
00302         Gap::Handle_t handle = connection_handle;
00303         delete this;
00304         client->on_termination(handle);
00305     }
00306 
00307     uint16_t get_start_handle(const AttReadByGroupTypeResponse::attribute_data_t& data) {
00308         return data.group_range.begin;
00309     }
00310 
00311     uint16_t get_start_handle(const attribute_handle_range_t& range) {
00312         return range.begin;
00313     }
00314 
00315     uint16_t get_end_handle(const AttReadByGroupTypeResponse::attribute_data_t& data) {
00316         return data.group_range.end;
00317     }
00318 
00319     uint16_t get_end_handle(const attribute_handle_range_t& range) {
00320         return range.end;
00321     }
00322 
00323     UUID get_uuid(const AttReadByGroupTypeResponse::attribute_data_t& data) {
00324         if (data.value.size() == 2) {
00325             return UUID(data.value[0] | data.value[1] << 8);
00326         } else {
00327             return UUID(data.value.data(), UUID::LSB);
00328         }
00329     }
00330 
00331     UUID get_uuid(const attribute_handle_range_t& range) {
00332         return matching_service_uuid;
00333     }
00334 
00335     struct service_t {
00336         service_t(uint16_t begin, uint16_t end, const UUID& uuid) :
00337             begin(begin), end(end), uuid(uuid), next(NULL) { }
00338         uint16_t begin;
00339         uint16_t end;
00340         UUID uuid;
00341         service_t* next;
00342     };
00343 
00344     struct characteristic_t : DiscoveredCharacteristic {
00345         characteristic_t() : DiscoveredCharacteristic() {
00346             lastHandle = 0x0001;
00347         }
00348 
00349         characteristic_t(
00350             GattClient* client,
00351             Gap::Handle_t connection_handle,
00352             uint16_t decl_handle,
00353             const ArrayView<const uint8_t> value
00354         ) : DiscoveredCharacteristic() {
00355             gattc = client;
00356             uuid = get_uuid(value);
00357             props = get_properties(value);
00358             declHandle = decl_handle;
00359             valueHandle = get_value_handle(value);
00360             lastHandle = 0x0000;
00361             connHandle = connection_handle;
00362         }
00363 
00364         static UUID get_uuid(const ArrayView<const uint8_t>& value) {
00365             if (value.size() == 5) {
00366                 return UUID(value[3] | (value[4] << 8));
00367             } else {
00368                 return UUID(value.data() + 3, UUID::LSB);
00369             }
00370         }
00371 
00372         static DiscoveredCharacteristic::Properties_t get_properties(const ArrayView<const uint8_t>& value) {
00373             uint8_t raw_properties = value[0];
00374             DiscoveredCharacteristic::Properties_t result;
00375             result._broadcast = (raw_properties & (1 << 0)) ? true : false;
00376             result._read = (raw_properties & (1 << 1)) ? true : false;
00377             result._writeWoResp = (raw_properties & (1 << 2))  ? true : false;
00378             result._write = (raw_properties & (1 << 3))  ? true : false;
00379             result._notify = (raw_properties & (1 << 4))  ? true : false;
00380             result._indicate = (raw_properties & (1 << 5))  ? true : false;
00381             result._authSignedWrite = (raw_properties & (1 << 6))  ? true : false;
00382             return result;
00383         }
00384 
00385         static uint16_t get_value_handle(const ArrayView<const uint8_t>& value) {
00386             return value[1] | (value[2] << 8);
00387         }
00388 
00389         void set_last_handle(uint16_t last_handle) {
00390             lastHandle = last_handle;
00391         }
00392 
00393         bool is_valid() const {
00394             return lastHandle != 0x0000;
00395         }
00396     };
00397 
00398     void insert_service(service_t* service) {
00399         if (services_discovered == NULL) {
00400             services_discovered = service;
00401             return;
00402         }
00403 
00404         service_t* current = services_discovered;
00405         while (current->next) {
00406             current = current->next;
00407         }
00408         current->next = service;
00409     }
00410 
00411     ServiceDiscovery::ServiceCallback_t  service_callback;
00412     ServiceDiscovery::CharacteristicCallback_t  characteristic_callback;
00413     UUID matching_service_uuid;
00414     UUID matching_characteristic_uuid;
00415     service_t* services_discovered;
00416     characteristic_t last_characteristic;
00417     bool done;
00418 };
00419 
00420 
00421 struct GenericGattClient::ReadControlBlock : public ProcedureControlBlock {
00422     ReadControlBlock(
00423         Gap::Handle_t connection_handle, uint16_t attribute_handle, uint16_t offset
00424     ) : ProcedureControlBlock(READ_PROCEDURE, connection_handle),
00425         attribute_handle(attribute_handle),
00426         offset(offset), current_offset(offset), data(NULL) {
00427     }
00428 
00429     virtual ~ReadControlBlock() {
00430         if (data != NULL) {
00431             free(data);
00432         }
00433     }
00434 
00435     virtual void handle_timeout_error(GenericGattClient* client) {
00436         GattReadCallbackParams response = {
00437             connection_handle,
00438             attribute_handle,
00439             offset,
00440             0, // size of 0
00441             NULL, // no data
00442             BLE_ERROR_UNSPECIFIED,
00443 
00444         };
00445         terminate(client, response);
00446     }
00447 
00448     virtual void abort(GenericGattClient *client) {
00449         GattReadCallbackParams response = {
00450             connection_handle,
00451             attribute_handle,
00452             offset,
00453             0, // size of 0
00454             NULL, // no data
00455             BLE_ERROR_INVALID_STATE,
00456 
00457         };
00458         terminate(client, response);
00459     }
00460 
00461     void terminate(GenericGattClient* client, const GattReadCallbackParams& response) {
00462         client->remove_control_block(this);
00463         client->processReadResponse(&response);
00464         delete this;
00465     }
00466 
00467     virtual void handle(GenericGattClient* client, const AttServerMessage& message) {
00468         switch(message.opcode) {
00469             case AttributeOpcode::ERROR_RESPONSE:
00470                 handle_error(client, static_cast<const AttErrorResponse&>(message));
00471                 break;
00472 
00473             case AttributeOpcode::READ_RESPONSE:
00474                 handle_read_response(client, static_cast<const AttReadResponse&>(message));
00475                 break;
00476 
00477             case AttributeOpcode::READ_BLOB_RESPONSE:
00478                 handle_read_response(client, static_cast<const AttReadBlobResponse&>(message));
00479                 break;
00480 
00481             default: {
00482                 // should not happen, terminate the procedure and notify client with an error
00483                 // in such case
00484                 GattReadCallbackParams response = {
00485                     connection_handle,
00486                     attribute_handle,
00487                     AttErrorResponse::UNLIKELY_ERROR,
00488                     0, // size of 0
00489                     NULL, // no data
00490                     BLE_ERROR_UNSPECIFIED,
00491 
00492                 };
00493                 terminate(client, response);
00494             }   break;
00495         }
00496     }
00497 
00498     template<typename ResponseType>
00499     void handle_read_response(GenericGattClient* client, const ResponseType& read_response) {
00500         uint16_t mtu_size = client->get_mtu(connection_handle);
00501 
00502         // end of responses ?
00503         if ((uint16_t) read_response.size() < (mtu_size - 1)) {
00504             GattReadCallbackParams response = {
00505                 connection_handle,
00506                 attribute_handle,
00507                 offset,
00508                 0, // size of 0
00509                 NULL, // no data
00510                 BLE_ERROR_NONE,
00511             };
00512 
00513             // is it the first response, or is there any other response already
00514             // in the object ?
00515             if (data == NULL) {
00516                 response.len = (uint16_t) read_response.size();
00517                 response.data = read_response.data();
00518             } else {
00519                 // copy the data in the existing buffer
00520                 memcpy(data + (current_offset - offset), read_response.data(), read_response.size());
00521                 response.len = (current_offset + read_response.size()) - offset;
00522                 response.data = data;
00523             }
00524             terminate(client, response);
00525         } else {
00526             // allocation which will contain the response data plus the next one.
00527             data = (uint8_t*) realloc(data, (current_offset - offset) + ((mtu_size - 1) * 2));
00528             if (data == NULL) {
00529                 GattReadCallbackParams response = {
00530                     connection_handle,
00531                     attribute_handle,
00532                     offset,
00533                     AttErrorResponse::INSUFFICIENT_RESOURCES,
00534                     NULL,
00535                     BLE_ERROR_NO_MEM,
00536                 };
00537                 terminate(client, response);
00538                 return;
00539             }
00540 
00541             memcpy(data + (current_offset - offset), read_response.data(), read_response.size());
00542             current_offset = current_offset + read_response.size();
00543             ble_error_t err = client->_pal_client->read_attribute_blob(
00544                 connection_handle,
00545                 attribute_handle,
00546                 current_offset
00547             );
00548 
00549             if (err) {
00550                 GattReadCallbackParams response = {
00551                     connection_handle,
00552                     attribute_handle,
00553                     AttErrorResponse::UNLIKELY_ERROR,
00554                     0, // size of 0
00555                     NULL, // no data
00556                     BLE_ERROR_UNSPECIFIED,
00557 
00558                 };
00559                 terminate(client, response);
00560             }
00561         }
00562     }
00563 
00564     void handle_error(GenericGattClient* client, const AttErrorResponse& error) {
00565         ble_error_t status = BLE_ERROR_UNSPECIFIED;
00566 
00567         switch (error.error_code) {
00568             case AttErrorResponse::INVALID_HANDLE:
00569                 status = BLE_ERROR_INVALID_PARAM;
00570                 break;
00571             case AttErrorResponse::INSUFFICIENT_AUTHORIZATION:
00572                 status = BLE_ERROR_INVALID_STATE;
00573                 break;
00574             case AttErrorResponse::INSUFFICIENT_AUTHENTICATION:
00575                 status = BLE_ERROR_INVALID_STATE;
00576                 break;
00577             case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE:
00578                 status = BLE_ERROR_INVALID_STATE;
00579                 break;
00580             case AttErrorResponse::INSUFFICIENT_ENCRYPTION:
00581                 status = BLE_ERROR_INVALID_STATE;
00582                 break;
00583             case AttErrorResponse::READ_NOT_PERMITTED:
00584                 status = BLE_ERROR_OPERATION_NOT_PERMITTED;
00585                 break;
00586             case AttErrorResponse::INVALID_OFFSET:
00587                 status = BLE_ERROR_PARAM_OUT_OF_RANGE;
00588                 break;
00589             case AttErrorResponse::ATTRIBUTE_NOT_LONG:
00590                 status = BLE_ERROR_PARAM_OUT_OF_RANGE;
00591                 break;
00592             default:
00593                 status = BLE_ERROR_UNSPECIFIED;
00594                 break;
00595         }
00596 
00597         GattReadCallbackParams response = {
00598             connection_handle,
00599             attribute_handle,
00600             offset,
00601             error.error_code,
00602             /* data */ NULL,
00603             status
00604         };
00605 
00606         terminate(client, response);
00607     }
00608 
00609     uint16_t attribute_handle;
00610     uint16_t offset;
00611     uint16_t current_offset;
00612     uint8_t* data;
00613 };
00614 
00615 /*
00616  * Control block for the write process
00617  */
00618 struct GenericGattClient::WriteControlBlock : public ProcedureControlBlock {
00619     WriteControlBlock(
00620         Gap::Handle_t connection_handle, uint16_t attribute_handle,
00621         uint8_t* data, uint16_t len
00622     ) : ProcedureControlBlock(WRITE_PROCEDURE, connection_handle),
00623         attribute_handle(attribute_handle), len(len), offset(0), data(data),
00624         prepare_success(false), status(BLE_ERROR_UNSPECIFIED), error_code(0xFF) {
00625     }
00626 
00627     virtual ~WriteControlBlock() {
00628         free(data);
00629     }
00630 
00631     virtual void handle_timeout_error(GenericGattClient* client) {
00632         GattWriteCallbackParams response = {
00633             connection_handle,
00634             attribute_handle,
00635             GattWriteCallbackParams::OP_WRITE_REQ,
00636             BLE_ERROR_UNSPECIFIED,
00637             0x00
00638         };
00639         terminate(client, response);
00640     }
00641 
00642     virtual void abort(GenericGattClient *client) {
00643         GattWriteCallbackParams response = {
00644             connection_handle,
00645             attribute_handle,
00646             GattWriteCallbackParams::OP_WRITE_REQ,
00647             BLE_ERROR_INVALID_STATE,
00648             0x00
00649         };
00650         terminate(client, response);
00651     }
00652 
00653     void terminate(GenericGattClient* client, const GattWriteCallbackParams& response) {
00654         client->remove_control_block(this);
00655         client->processWriteResponse(&response);
00656         delete this;
00657     }
00658 
00659     virtual void handle(GenericGattClient* client, const AttServerMessage& message) {
00660         switch(message.opcode) {
00661             case AttributeOpcode::ERROR_RESPONSE:
00662                 handle_error(client, static_cast<const AttErrorResponse&>(message));
00663                 break;
00664 
00665             case AttributeOpcode::WRITE_RESPONSE:
00666                 handle_write_response(client, static_cast<const AttWriteResponse&>(message));
00667                 break;
00668 
00669             case AttributeOpcode::PREPARE_WRITE_RESPONSE:
00670                 handle_prepare_write_response(client, static_cast<const AttPrepareWriteResponse&>(message));
00671                 break;
00672 
00673             case AttributeOpcode::EXECUTE_WRITE_RESPONSE:
00674                 handle_execute_write_response(client, static_cast<const AttExecuteWriteResponse&>(message));
00675                 break;
00676 
00677             default: {
00678                 GattWriteCallbackParams response = {
00679                     connection_handle,
00680                     attribute_handle,
00681                     GattWriteCallbackParams::OP_WRITE_REQ,
00682                     BLE_ERROR_UNSPECIFIED,
00683                     AttErrorResponse::UNLIKELY_ERROR
00684                 };
00685 
00686                 terminate(client, response);
00687             }   break;
00688         }
00689     }
00690 
00691     void handle_write_response(GenericGattClient* client, const AttWriteResponse& write_response) {
00692         GattWriteCallbackParams response = {
00693             connection_handle, attribute_handle,
00694             GattWriteCallbackParams::OP_WRITE_REQ,
00695             BLE_ERROR_NONE, 0x00
00696         };
00697 
00698         terminate(client, response);
00699     }
00700 
00701     void handle_prepare_write_response(GenericGattClient* client, const AttPrepareWriteResponse& write_response) {
00702         ble_error_t err = BLE_ERROR_UNSPECIFIED;
00703 
00704         uint16_t mtu_size = client->get_mtu(connection_handle);
00705         offset = write_response.offset + write_response.partial_value.size();
00706         if (offset < len) {
00707             err = client->_pal_client->queue_prepare_write(
00708                 connection_handle, attribute_handle,
00709                 make_const_ArrayView(
00710                     data + offset,
00711                     std::min((len - offset), (mtu_size - 5))
00712                 ),
00713                 offset
00714             );
00715         } else {
00716             err = client->_pal_client->execute_write_queue(
00717                 connection_handle, true
00718             );
00719         }
00720 
00721         if (err) {
00722             clear_prepare_queue(client, err, AttErrorResponse::UNLIKELY_ERROR);
00723         }
00724     }
00725 
00726     void handle_execute_write_response(GenericGattClient* client, const AttExecuteWriteResponse& execute_response) {
00727         if (prepare_success) {
00728             status = BLE_ERROR_NONE;
00729             error_code = 0x00;
00730         }
00731 
00732         GattWriteCallbackParams response = {
00733             connection_handle,
00734             attribute_handle,
00735             GattWriteCallbackParams::OP_WRITE_REQ,
00736             status,
00737             error_code
00738         };
00739 
00740         terminate(client, response);
00741     }
00742 
00743     void clear_prepare_queue(GenericGattClient* client, ble_error_t s, uint8_t e) {
00744         prepare_success = false;
00745         status = s;
00746         error_code = e;
00747         ble_error_t err = client->_pal_client->execute_write_queue(
00748             connection_handle, false
00749         );
00750 
00751         if (err) {
00752             GattWriteCallbackParams response = {
00753                 connection_handle,
00754                 attribute_handle,
00755                 GattWriteCallbackParams::OP_WRITE_REQ,
00756                 err,
00757                 AttErrorResponse::UNLIKELY_ERROR
00758             };
00759 
00760             terminate(client, response);
00761         }
00762     }
00763 
00764     void handle_error(GenericGattClient* client, const AttErrorResponse& error) {
00765         ble_error_t status = BLE_ERROR_UNSPECIFIED;
00766 
00767         switch (error.error_code) {
00768             case AttErrorResponse::INVALID_HANDLE:
00769                 status = BLE_ERROR_INVALID_PARAM;
00770                 break;
00771             case AttErrorResponse::INVALID_ATTRIBUTE_VALUE_LENGTH:
00772                 status = BLE_ERROR_INVALID_PARAM;
00773                 break;
00774             case AttErrorResponse::INSUFFICIENT_AUTHORIZATION:
00775                 status = BLE_ERROR_INVALID_STATE;
00776                 break;
00777             case AttErrorResponse::INSUFFICIENT_AUTHENTICATION:
00778                 status = BLE_ERROR_INVALID_STATE;
00779                 break;
00780             case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE:
00781                 status = BLE_ERROR_INVALID_STATE;
00782                 break;
00783             case AttErrorResponse::INSUFFICIENT_ENCRYPTION:
00784                 status = BLE_ERROR_INVALID_STATE;
00785                 break;
00786             case AttErrorResponse::WRITE_NOT_PERMITTED:
00787                 status = BLE_ERROR_OPERATION_NOT_PERMITTED;
00788                 break;
00789             default:
00790                 status = BLE_ERROR_UNSPECIFIED;
00791                 break;
00792         }
00793 
00794         if (error.request_opcode == AttributeOpcode(AttributeOpcode::PREPARE_WRITE_REQUEST)) {
00795             clear_prepare_queue(client, status, error.error_code);
00796         } else {
00797             GattWriteCallbackParams response = {
00798                 connection_handle,
00799                 attribute_handle,
00800                 GattWriteCallbackParams::OP_WRITE_REQ,
00801                 status,
00802                 error.error_code
00803             };
00804 
00805             terminate(client, response);
00806         }
00807     }
00808 
00809     uint16_t attribute_handle;
00810     uint16_t len;
00811     uint16_t offset;
00812     uint8_t* data;
00813     bool prepare_success;
00814     ble_error_t status;
00815     uint8_t error_code;
00816 };
00817 
00818 /*
00819  * Control block for the descriptor discovery process
00820  */
00821 struct GenericGattClient::DescriptorDiscoveryControlBlock : public ProcedureControlBlock {
00822     DescriptorDiscoveryControlBlock(
00823         const DiscoveredCharacteristic& characteristic,
00824         const CharacteristicDescriptorDiscovery::DiscoveryCallback_t & discoveryCallback,
00825         const CharacteristicDescriptorDiscovery::TerminationCallback_t & terminationCallback
00826     ) : ProcedureControlBlock(DESCRIPTOR_DISCOVERY_PROCEDURE, characteristic.getConnectionHandle()),
00827         characteristic(characteristic),
00828         discovery_cb(discoveryCallback),
00829         termination_cb(terminationCallback),
00830         next_handle(characteristic.getValueHandle() + 1),
00831         done(false) {
00832     }
00833 
00834     virtual ~DescriptorDiscoveryControlBlock() { }
00835 
00836     ble_error_t start(GenericGattClient* client) {
00837         return client->_pal_client->discover_characteristics_descriptors(
00838             connection_handle,
00839             attribute_handle_range(
00840                 next_handle,
00841                 characteristic.getLastHandle()
00842             )
00843         );
00844     }
00845 
00846     virtual void handle_timeout_error(GenericGattClient* client) {
00847         terminate(client, BLE_ERROR_UNSPECIFIED);
00848     }
00849 
00850     virtual void abort(GenericGattClient *client) {
00851         terminate(client, BLE_ERROR_INVALID_STATE);
00852     }
00853 
00854     virtual void handle(GenericGattClient* client, const AttServerMessage& message) {
00855         if (done) {
00856             terminate(client, BLE_ERROR_NONE);
00857             return;
00858         }
00859 
00860         switch(message.opcode) {
00861             case AttributeOpcode::ERROR_RESPONSE:
00862                 handle_error(client, static_cast<const AttErrorResponse&>(message));
00863                 return;
00864 
00865             case AttributeOpcode::FIND_INFORMATION_RESPONSE:
00866                 handle_response(client, static_cast<const AttFindInformationResponse&>(message));
00867                 return;
00868 
00869             default:
00870                 break;
00871         }
00872     }
00873 
00874     void handle_error(GenericGattClient* client, const AttErrorResponse& error) {
00875         if (error.error_code == AttErrorResponse::ATTRIBUTE_NOT_FOUND) {
00876             terminate(client, BLE_ERROR_NONE);
00877         } else {
00878             terminate(client, BLE_ERROR_UNSPECIFIED, error.error_code);
00879         }
00880     }
00881 
00882     void handle_response(GenericGattClient* client, const AttFindInformationResponse& response) {
00883         for (size_t i = 0; i < response.size(); ++i) {
00884             DiscoveredCharacteristicDescriptor descriptor(
00885                 client, connection_handle, response[i].handle, response[i].uuid
00886             );
00887             CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t params = {
00888                 characteristic,
00889                 descriptor
00890             };
00891             discovery_cb(&params);
00892             if (done) {
00893                 terminate(client, BLE_ERROR_NONE);
00894                 return;
00895             }
00896 
00897             if (response[i].handle == characteristic.getLastHandle()) {
00898                 terminate(client, BLE_ERROR_NONE);
00899                 return;
00900             }
00901             next_handle = response[i].handle + 1;
00902         }
00903 
00904         ble_error_t err = start(client);
00905         if (err) {
00906             terminate(client, err, AttErrorResponse::UNLIKELY_ERROR);
00907         }
00908     }
00909 
00910     void terminate(GenericGattClient* client, ble_error_t status, uint8_t error_code = 0x00) {
00911         client->remove_control_block(this);
00912         CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = {
00913             characteristic,
00914             status,
00915             error_code
00916         };
00917         termination_cb(&params);
00918         delete this;
00919     }
00920 
00921     DiscoveredCharacteristic characteristic;
00922     CharacteristicDescriptorDiscovery::DiscoveryCallback_t  discovery_cb;
00923     CharacteristicDescriptorDiscovery::TerminationCallback_t  termination_cb;
00924     uint16_t next_handle;
00925     bool done;
00926 };
00927 
00928 
00929 GenericGattClient::GenericGattClient(pal::GattClient* pal_client) :
00930     _pal_client(pal_client),
00931     _termination_callback(),
00932      control_blocks(NULL),
00933     _is_reseting(false) {
00934     _pal_client->when_server_message_received(
00935         mbed::callback(this, &GenericGattClient::on_server_message_received)
00936     );
00937     _pal_client->when_transaction_timeout(
00938         mbed::callback(this, &GenericGattClient::on_transaction_timeout)
00939     );
00940 }
00941 
00942 ble_error_t GenericGattClient::launchServiceDiscovery (
00943     Gap::Handle_t connection_handle,
00944     ServiceDiscovery::ServiceCallback_t  service_callback,
00945     ServiceDiscovery::CharacteristicCallback_t  characteristic_callback,
00946     const UUID& matching_service_uuid,
00947     const UUID& matching_characteristic_uuid
00948 ) {
00949     // verify that there is no other procedures going on this connection
00950     if (_is_reseting || get_control_block(connection_handle)) {
00951         return BLE_ERROR_INVALID_STATE;
00952     }
00953 
00954     // terminate and return if there is no callback to call
00955     if (!service_callback && !characteristic_callback) {
00956         on_termination(connection_handle);
00957         return BLE_ERROR_NONE;
00958     }
00959 
00960     DiscoveryControlBlock* discovery_pcb = new(std::nothrow) DiscoveryControlBlock(
00961         connection_handle,
00962         service_callback,
00963         characteristic_callback,
00964         matching_service_uuid,
00965         matching_characteristic_uuid
00966     );
00967 
00968     if (discovery_pcb == NULL) {
00969         return BLE_ERROR_NO_MEM;
00970     }
00971 
00972     // note: control block inserted prior the request because they are part of
00973     // of the transaction and the callback can be call synchronously
00974     insert_control_block(discovery_pcb);
00975 
00976     // launch the request
00977     ble_error_t err = BLE_ERROR_UNSPECIFIED;
00978     if (matching_service_uuid == UUID()) {
00979         err = _pal_client->discover_primary_service(
00980             connection_handle,
00981             0x0001
00982         );
00983     } else {
00984         err = _pal_client->discover_primary_service_by_service_uuid(
00985             connection_handle,
00986             0x0001,
00987             matching_service_uuid
00988         );
00989     }
00990 
00991     if (err) {
00992         remove_control_block(discovery_pcb);
00993         delete discovery_pcb;
00994     }
00995 
00996     return err;
00997 }
00998 
00999 bool GenericGattClient::isServiceDiscoveryActive () const {
01000     ProcedureControlBlock* pcb = control_blocks;
01001 
01002     while (pcb) {
01003         if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) {
01004             return true;
01005         }
01006         pcb = pcb->next;
01007     }
01008 
01009     return false;
01010 }
01011 
01012 void GenericGattClient::terminateServiceDiscovery ()
01013 {
01014     ProcedureControlBlock* pcb = control_blocks;
01015     while (pcb) {
01016         if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) {
01017             static_cast<DiscoveryControlBlock*>(pcb)->done = true;
01018         }
01019         pcb = pcb->next;
01020     }
01021 }
01022 
01023 ble_error_t GenericGattClient::read (
01024     Gap::Handle_t connection_handle,
01025     GattAttribute::Handle_t attribute_handle,
01026     uint16_t offset) const
01027 {
01028     // verify that there is no other procedures going on this connection
01029     if (_is_reseting || get_control_block(connection_handle)) {
01030         return BLE_ERROR_INVALID_STATE;
01031     }
01032 
01033     ReadControlBlock* read_pcb = new(std::nothrow) ReadControlBlock(
01034         connection_handle,
01035         attribute_handle,
01036         offset
01037     );
01038 
01039     if (read_pcb == NULL) {
01040         return BLE_ERROR_NO_MEM;
01041     }
01042 
01043     insert_control_block(read_pcb);
01044 
01045     ble_error_t err = BLE_ERROR_NONE;
01046 
01047     if (offset == 0) {
01048         err = _pal_client->read_attribute_value(
01049             connection_handle, attribute_handle
01050         );
01051     } else {
01052         err = _pal_client->read_attribute_blob(
01053             connection_handle, attribute_handle, offset
01054         );
01055     }
01056 
01057     if (err) {
01058         remove_control_block(read_pcb);
01059         delete read_pcb;
01060     }
01061 
01062     return err;
01063 }
01064 
01065 ble_error_t GenericGattClient::write (
01066     GattClient::WriteOp_t cmd,
01067     Gap::Handle_t connection_handle,
01068     GattAttribute::Handle_t attribute_handle,
01069     size_t length,
01070     const uint8_t* value
01071 ) const {
01072     // verify that there is no other procedures going on this connection
01073     if (_is_reseting || get_control_block(connection_handle)) {
01074         return BLE_ERROR_INVALID_STATE;
01075     }
01076 
01077     uint16_t mtu = get_mtu(connection_handle);
01078 
01079     if (cmd == GattClient::GATT_OP_WRITE_CMD) {
01080         if (length > (uint16_t)(mtu - 3)) {
01081             return BLE_ERROR_PARAM_OUT_OF_RANGE;
01082         }
01083         return _pal_client->write_without_response(
01084             connection_handle,
01085             attribute_handle,
01086             make_const_ArrayView(value, length)
01087         );
01088     } else {
01089         uint8_t* data = NULL;
01090 
01091         if (length > (uint16_t)(mtu - 3)) {
01092             data = (uint8_t*) malloc(length);
01093             if (data == NULL) {
01094                 return BLE_ERROR_NO_MEM;
01095             }
01096             memcpy(data, value, length);
01097         }
01098 
01099         WriteControlBlock* write_pcb = new(std::nothrow) WriteControlBlock(
01100             connection_handle,
01101             attribute_handle,
01102             data,
01103             length
01104         );
01105 
01106         if (write_pcb == NULL) {
01107             free(data);
01108             return BLE_ERROR_NO_MEM;
01109         }
01110 
01111         insert_control_block(write_pcb);
01112 
01113         ble_error_t err = BLE_ERROR_UNSPECIFIED;
01114         if (data) {
01115             err = _pal_client->queue_prepare_write(
01116                 connection_handle,
01117                 attribute_handle,
01118                 make_const_ArrayView(value, mtu - 5),
01119                 /* offset */ 0
01120             );
01121         } else {
01122             err = _pal_client->write_attribute(
01123                 connection_handle,
01124                 attribute_handle,
01125                 make_const_ArrayView(value, length)
01126             );
01127         }
01128 
01129         if (err) {
01130             remove_control_block(write_pcb);
01131             delete write_pcb;
01132         }
01133 
01134         return err;
01135     }
01136 
01137     return BLE_ERROR_NOT_IMPLEMENTED;
01138 }
01139 
01140 void GenericGattClient::onServiceDiscoveryTermination (
01141     ServiceDiscovery::TerminationCallback_t  callback
01142 ) {
01143     _termination_callback = callback;
01144 }
01145 
01146 ble_error_t GenericGattClient::discoverCharacteristicDescriptors (
01147     const DiscoveredCharacteristic& characteristic,
01148     const CharacteristicDescriptorDiscovery::DiscoveryCallback_t & discoveryCallback,
01149     const CharacteristicDescriptorDiscovery::TerminationCallback_t & terminationCallback
01150 ) {
01151     // verify that there is no other procedures going on this connection
01152     if (_is_reseting || get_control_block(characteristic.getConnectionHandle())) {
01153         return BLE_ERROR_INVALID_STATE;
01154     }
01155 
01156     if (characteristic.getValueHandle() == characteristic.getLastHandle()) {
01157         CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = {
01158             characteristic,
01159             BLE_ERROR_NONE,
01160             /* error code */ 0x00
01161         };
01162 
01163         terminationCallback(&params);
01164         return BLE_ERROR_NONE;
01165     }
01166 
01167     DescriptorDiscoveryControlBlock* discovery_pcb =
01168         new(std::nothrow) DescriptorDiscoveryControlBlock(
01169             characteristic,
01170             discoveryCallback,
01171             terminationCallback
01172         );
01173 
01174     if (discovery_pcb == NULL) {
01175         return BLE_ERROR_NO_MEM;
01176     }
01177 
01178     insert_control_block(discovery_pcb);
01179 
01180     ble_error_t err = discovery_pcb->start(this);
01181 
01182     if (err) {
01183         remove_control_block(discovery_pcb);
01184         delete discovery_pcb;
01185     }
01186 
01187     return err;
01188 }
01189 
01190 bool GenericGattClient::isCharacteristicDescriptorDiscoveryActive (
01191     const DiscoveredCharacteristic& characteristic
01192 ) const {
01193     ProcedureControlBlock* pcb = control_blocks;
01194 
01195     while (pcb) {
01196         if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE &&
01197             static_cast<DescriptorDiscoveryControlBlock*>(pcb)->characteristic == characteristic) {
01198             return true;
01199         }
01200         pcb = pcb->next;
01201     }
01202 
01203     return false;
01204 }
01205 
01206 void GenericGattClient::terminateCharacteristicDescriptorDiscovery (
01207     const DiscoveredCharacteristic& characteristic
01208 ) {
01209     ProcedureControlBlock* pcb = control_blocks;
01210 
01211     while (pcb) {
01212         if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE) {
01213             DescriptorDiscoveryControlBlock* dpcb =
01214                 static_cast<DescriptorDiscoveryControlBlock*>(pcb);
01215             if (dpcb->characteristic == characteristic) {
01216                 dpcb->done = true;
01217                 return;
01218             }
01219         }
01220 
01221         pcb = pcb->next;
01222     }
01223 
01224 }
01225 
01226 ble_error_t GenericGattClient::reset (void) {
01227 
01228     // _is_reseting prevent executions of new procedure while the instance resets.
01229     // otherwise new procedures can be launched from callbacks generated by the
01230     // reset.
01231     _is_reseting = true;
01232     while (control_blocks) {
01233         control_blocks->abort(this);
01234     }
01235     _is_reseting = false;
01236 
01237     return BLE_ERROR_NONE;
01238 }
01239 
01240 void GenericGattClient::on_termination(Gap::Handle_t connection_handle) {
01241     if (_termination_callback) {
01242         _termination_callback(connection_handle);
01243     }
01244 }
01245 
01246 void GenericGattClient::on_server_message_received(
01247     connection_handle_t connection_handle,
01248     const AttServerMessage& message
01249 ) {
01250     switch(message.opcode) {
01251         case AttributeOpcode::ERROR_RESPONSE:
01252         case AttributeOpcode::EXCHANGE_MTU_RESPONSE:
01253         case AttributeOpcode::FIND_INFORMATION_RESPONSE:
01254         case AttributeOpcode::FIND_BY_VALUE_TYPE_RESPONSE:
01255         case AttributeOpcode::READ_BY_TYPE_RESPONSE:
01256         case AttributeOpcode::READ_RESPONSE:
01257         case AttributeOpcode::READ_BLOB_RESPONSE:
01258         case AttributeOpcode::READ_MULTIPLE_RESPONSE:
01259         case AttributeOpcode::READ_BY_GROUP_TYPE_RESPONSE:
01260         case AttributeOpcode::WRITE_RESPONSE:
01261         case AttributeOpcode::PREPARE_WRITE_RESPONSE:
01262         case AttributeOpcode::EXECUTE_WRITE_RESPONSE: {
01263             on_server_response(connection_handle, message);
01264         } break;
01265 
01266         case AttributeOpcode::HANDLE_VALUE_INDICATION:
01267         case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: {
01268             on_server_event(connection_handle, message);
01269         } break;
01270 
01271         default:
01272             // invalid message receive
01273             return;
01274     }
01275 }
01276 
01277 void GenericGattClient::on_server_response(
01278     connection_handle_t connection,
01279     const AttServerMessage& message
01280 ) {
01281     ProcedureControlBlock* pcb = get_control_block(connection);
01282     if (pcb == NULL) {
01283         return;
01284     }
01285 
01286     pcb->handle(this, message);
01287 }
01288 
01289 void GenericGattClient::on_server_event(connection_handle_t connection, const AttServerMessage& message) {
01290     GattHVXCallbackParams callbacks_params = {
01291         (Gap::Handle_t) connection, 0
01292     };
01293 
01294     switch (message.opcode) {
01295         case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: {
01296             const AttHandleValueNotification& notification =
01297                 static_cast<const AttHandleValueNotification&>(message);
01298             callbacks_params.handle = notification.attribute_handle;
01299             callbacks_params.type = BLE_HVX_NOTIFICATION;
01300             callbacks_params.len = notification.attribute_value.size();
01301             callbacks_params.data = notification.attribute_value.data();
01302         } break;
01303 
01304         case AttributeOpcode::HANDLE_VALUE_INDICATION: {
01305             const AttHandleValueIndication& indication =
01306                 static_cast<const AttHandleValueIndication&>(message);
01307             callbacks_params.handle = indication.attribute_handle;
01308             callbacks_params.type = BLE_HVX_INDICATION;
01309             callbacks_params.len = indication.attribute_value.size();
01310             callbacks_params.data = indication.attribute_value.data();
01311         } break;
01312 
01313         default:
01314             return;
01315     }
01316 
01317     processHVXEvent(&callbacks_params);
01318 }
01319 
01320 void GenericGattClient::on_transaction_timeout(connection_handle_t connection) {
01321     ProcedureControlBlock* pcb = get_control_block(connection);
01322     if (pcb == NULL) {
01323         return;
01324     }
01325 
01326     pcb->handle_timeout_error(this);
01327 }
01328 
01329 GenericGattClient::ProcedureControlBlock* GenericGattClient::get_control_block(Gap::Handle_t connection) {
01330     ProcedureControlBlock* it = control_blocks;
01331     while (it && it->connection_handle != connection) {
01332         it = it->next;
01333     }
01334     return it;
01335 }
01336 
01337 const GenericGattClient::ProcedureControlBlock* GenericGattClient::get_control_block(Gap::Handle_t connection) const {
01338     ProcedureControlBlock* it = control_blocks;
01339     while (it && it->connection_handle != connection) {
01340         it = it->next;
01341     }
01342     return it;
01343 }
01344 
01345 void GenericGattClient::insert_control_block(ProcedureControlBlock* cb) const {
01346     if (control_blocks == NULL) {
01347         control_blocks = cb;
01348         return;
01349     }
01350 
01351     ProcedureControlBlock* current = control_blocks;
01352     while (current->next) {
01353         current = current->next;
01354     }
01355     current->next = cb;
01356 }
01357 
01358 void GenericGattClient::remove_control_block(ProcedureControlBlock* cb) const {
01359     if (control_blocks == NULL) {
01360         return;
01361     }
01362 
01363     if (cb == control_blocks) {
01364         control_blocks = control_blocks->next;
01365         return;
01366     }
01367 
01368     ProcedureControlBlock* current = control_blocks;
01369     while (current->next && current->next != cb) {
01370         current = current->next;
01371     }
01372 
01373     if (current->next == NULL) {
01374         return;
01375     }
01376 
01377     current->next = cb->next;
01378     cb->next = NULL;
01379 }
01380 
01381 uint16_t GenericGattClient::get_mtu(Gap::Handle_t connection) const {
01382     uint16_t result = 23;
01383     if(_pal_client->get_mtu_size((connection_handle_t) connection, result) != BLE_ERROR_NONE) {
01384         result = 23;
01385     }
01386     return result;
01387 }
01388 
01389 } // namespace pal
01390 } // namespace ble