resource/csdk/connectivity/src/bt_le_adapter/tizen/cableutil.c

   1 /******************************************************************
   2 *
   3 * Copyright 2014 Samsung Electronics All Rights Reserved.
   4 *
   5 *
   6 *
   7 * Licensed under the Apache License, Version 2.0 (the "License");
   8 * you may not use this file except in compliance with the License.
   9 * You may obtain a copy of the License at
  10 *
  11 *      http://www.apache.org/licenses/LICENSE-2.0
  12 *
  13 * Unless required by applicable law or agreed to in writing, software
  14 * distributed under the License is distributed on an "AS IS" BASIS,
  15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 * See the License for the specific language governing permissions and
  17 * limitations under the License.
  18 *
  19 ******************************************************************/
  20
  21 #include "cableutil.h"
  22
  23 #include<stdio.h>
  24 #include<stdlib.h>
  25 #include<string.h>
  26 #include<arpa/inet.h>
  27 #include<sys/types.h>
  28 #include<sys/socket.h>
  29 #include<netinet/in.h>
  30
  31
  32 #include "caadapterutils.h"
  33 #include "oic_string.h"
  34 #include "oic_malloc.h"
  35
  36 /**
  37  * @def TZ_BLE_CLIENT_UTIL_TAG
  38  * @brief Logging tag for module name
  39  */
  40 #define TZ_BLE_CLIENT_UTIL_TAG "TZ_BLE_GATT_CLIENT_UTIL"
  41
  42 /**
  43  * @var g_numberOfServiceConnected
  44  * @brief Number of services connected.
  45  */
  46 static int32_t g_numberOfServiceConnected = 0;
  47
  48 void CAIncrementRegisteredServiceCount()
  49 {
  50     g_numberOfServiceConnected++;
  51 }
  52
  53 void CADecrementRegisteredServiceCount()
  54 {
  55     g_numberOfServiceConnected--;
  56 }
  57
  58 void CAResetRegisteredServiceCount()
  59 {
  60     g_numberOfServiceConnected = 0;
  61 }
  62
  63 int32_t  CAGetRegisteredServiceCount()
  64 {
  65     return g_numberOfServiceConnected ;
  66 }
  67
  68 CAResult_t CACreateBLEServiceInfo(const char *bdAddress, bt_gatt_attribute_h service,
  69                                   BLEServiceInfo **bleServiceInfo)
  70 {
  71     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
  72
  73     VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
  74     VERIFY_NON_NULL(service, NULL, "Param service is NULL");
  75     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
  76
  77     *bleServiceInfo = (BLEServiceInfo *) OICCalloc(1, sizeof(BLEServiceInfo));
  78     if (NULL == *bleServiceInfo)
  79     {
  80         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "Malloc failed!");
  81         return CA_STATUS_FAILED;
  82     }
  83
  84     size_t len = strlen(bdAddress);
  85     (*bleServiceInfo)->bdAddress = (char *) OICMalloc(sizeof(char) * (len + 1));
  86
  87     if (NULL == (*bleServiceInfo)->bdAddress)
  88     {
  89         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "Malloc failed!");
  90         OICFree(*bleServiceInfo);
  91         return CA_STATUS_FAILED;
  92     }
  93
  94     strncpy((*bleServiceInfo)->bdAddress, bdAddress, len + 1);
  95
  96     if (service)
  97     {
  98         int32_t ret = bt_gatt_clone_attribute_handle(&((*bleServiceInfo)->service_clone), service);
  99
 100         if (BT_ERROR_NONE != ret)
 101         {
 102             OIC_LOG_V(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "service handle clone failed with ret [%d]",
 103                       ret);
 104             OICFree((*bleServiceInfo)->bdAddress);
 105             OICFree(*bleServiceInfo);
 106             return CA_STATUS_FAILED;
 107         }
 108     }
 109
 110     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 111
 112     return CA_STATUS_OK;
 113 }
 114
 115 CAResult_t CAAppendBLECharInfo( bt_gatt_attribute_h characteristic, CHAR_TYPE type,
 116                                 BLEServiceInfo *bleServiceInfo)
 117 {
 118     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 119
 120     VERIFY_NON_NULL(characteristic, NULL, "Param characteristic is NULL");
 121     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 122
 123     if (BLE_GATT_READ_CHAR == type )
 124     {
 125         int ret = bt_gatt_clone_attribute_handle(&((bleServiceInfo)->read_char),
 126             characteristic);
 127         if (BT_ERROR_NONE != ret)
 128         {
 129             OIC_LOG_V(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "read_char clone failed with ret [%d]",
 130                       ret);
 131             return CA_STATUS_FAILED;
 132         }
 133     }
 134     else  if (BLE_GATT_WRITE_CHAR == type)
 135     {
 136         int ret = bt_gatt_clone_attribute_handle(&((bleServiceInfo)->write_char),
 137             characteristic);
 138         if (BT_ERROR_NONE != ret)
 139         {
 140             OIC_LOG_V(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "write_char clone failed with ret [%d]",
 141                       ret);
 142             return CA_STATUS_FAILED;
 143         }
 144     }
 145
 146     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 147
 148     return CA_STATUS_OK;
 149 }
 150
 151 CAResult_t CAAddBLEServiceInfoToList(BLEServiceList **serviceList,
 152     BLEServiceInfo *bleServiceInfo)
 153 {
 154
 155     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 156
 157     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 158     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 159
 160     BLEServiceList *node = (BLEServiceList *) OICCalloc(1, sizeof(BLEServiceList));
 161     if (NULL == node)
 162     {
 163         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "Malloc failed!");
 164         return CA_STATUS_FAILED;
 165     }
 166
 167     node->serviceInfo = bleServiceInfo;
 168     node->next = NULL;
 169
 170     if (*serviceList == NULL)   // Empty list
 171     {
 172         *serviceList = node;
 173     }
 174     else     // Add at front end
 175     {
 176         node->next = *serviceList;
 177         *serviceList = node;
 178     }
 179
 180     CAIncrementRegisteredServiceCount();
 181
 182     OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "Device [%s] added to list",
 183         bleServiceInfo->bdAddress);
 184
 185     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 186
 187     return CA_STATUS_OK;
 188 }
 189
 190 CAResult_t CARemoveBLEServiceInfoToList(BLEServiceList **serviceList,
 191                                         BLEServiceInfo *bleServiceInfo,
 192                                         const char *bdAddress)
 193 {
 194
 195     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 196
 197     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 198     VERIFY_NON_NULL(*serviceList, NULL, "Param *serviceList is NULL");
 199     VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
 200
 201     BLEServiceList *prev = NULL;
 202     BLEServiceList *cur = *serviceList;
 203     while (cur != NULL)
 204     {
 205         if (!strcasecmp(cur->serviceInfo->bdAddress, bdAddress))
 206         {
 207             if (cur == *serviceList)
 208             {
 209                 *serviceList = cur->next;
 210
 211                 cur->next = NULL;
 212                 CAFreeBLEServiceList(cur);
 213                 CADecrementRegisteredServiceCount();
 214                 OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 215                 return CA_STATUS_OK;
 216             }
 217             else
 218             {
 219                 prev->next = cur->next;
 220
 221                 cur->next = NULL;
 222                 CAFreeBLEServiceList(cur);
 223                 CADecrementRegisteredServiceCount();
 224                 OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 225                 return CA_STATUS_OK;
 226             }
 227         }
 228         else
 229         {
 230             prev = cur;
 231             cur = cur->next;
 232         }
 233     }
 234     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, " OUT");
 235     return CA_STATUS_FAILED;
 236 }
 237
 238 CAResult_t CAGetBLEServiceInfo(BLEServiceList *serviceList, const char *bdAddress,
 239                                BLEServiceInfo **bleServiceInfo)
 240 {
 241
 242     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 243
 244     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 245     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 246     VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
 247
 248
 249     BLEServiceList *cur = serviceList;
 250     *bleServiceInfo = NULL;
 251     while (cur != NULL)
 252     {
 253         if (!strcasecmp(cur->serviceInfo->bdAddress, bdAddress))
 254         {
 255             *bleServiceInfo = cur->serviceInfo;
 256             OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 257             return CA_STATUS_OK;
 258         }
 259
 260         cur = cur->next;
 261     }
 262
 263     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, " OUT");
 264     return CA_STATUS_FAILED;
 265 }
 266
 267 CAResult_t CAGetBLEServiceInfoByPosition(BLEServiceList *serviceList, int32_t position,
 268         BLEServiceInfo **bleServiceInfo)
 269 {
 270     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 271
 272     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 273     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 274
 275     if (0 > position)
 276     {
 277         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "Position Invalid input !");
 278         return CA_STATUS_INVALID_PARAM;
 279     }
 280
 281     *bleServiceInfo = NULL;
 282     int32_t count = 0;
 283     BLEServiceList *cur = serviceList;
 284     while (cur != NULL)
 285     {
 286         if (position == count)
 287         {
 288             *bleServiceInfo = cur->serviceInfo;
 289             OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 290             return CA_STATUS_OK;
 291         }
 292         count++;
 293         cur = cur->next;
 294     }
 295     return CA_STATUS_FAILED;
 296 }
 297
 298 void CAFreeBLEServiceList(BLEServiceList *serviceList)
 299 {
 300     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 301     while (serviceList)
 302     {
 303         BLEServiceList *temp = serviceList;
 304         serviceList = serviceList->next;
 305         CAFreeBLEServiceInfo(temp->serviceInfo);
 306         OICFree(temp);
 307     }
 308     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 309 }
 310
 311 void CAFreeBLEServiceInfo(BLEServiceInfo *bleServiceInfo)
 312 {
 313     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 314     if (bleServiceInfo)
 315     {
 316         if (bleServiceInfo->bdAddress)
 317         {
 318             bt_gatt_disconnect(bleServiceInfo->bdAddress);
 319             OICFree(bleServiceInfo->bdAddress);
 320             bt_gatt_destroy_attribute_handle(bleServiceInfo->service_clone);
 321             bt_gatt_destroy_attribute_handle(bleServiceInfo->read_char);
 322             bt_gatt_destroy_attribute_handle(bleServiceInfo->write_char);
 323         }
 324         OICFree(bleServiceInfo);
 325     }
 326     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 327 }
 328
 329 CAResult_t CAVerifyOICServiceByUUID(const char* serviceUUID)
 330 {
 331     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 332
 333     VERIFY_NON_NULL(serviceUUID, NULL, "Param serviceHandle is NULL");
 334
 335     if (strcasecmp(serviceUUID, OIC_BLE_SERVICE_ID) != 0)
 336     {
 337         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "It is not OIC service!");
 338         return CA_STATUS_FAILED;
 339     }
 340     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 341     return CA_STATUS_OK;
 342 }
 343
 344 CAResult_t CAVerifyOICServiceByServiceHandle(bt_gatt_attribute_h serviceHandle)
 345 {
 346     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 347
 348     VERIFY_NON_NULL(serviceHandle, NULL, "Param serviceHandle is NULL");
 349
 350     char *uuid = NULL;
 351     int ret = bt_gatt_get_service_uuid(serviceHandle, &uuid);
 352
 353     if (0 != ret || NULL == uuid)
 354     {
 355         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "bt_gatt_get_service_uuid failed !");
 356         return CA_STATUS_FAILED;
 357     }
 358
 359     if (strcasecmp(uuid, OIC_BLE_SERVICE_ID) != 0)
 360     {
 361         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "It is not OIC service!");
 362         OICFree(uuid);
 363         return CA_STATUS_FAILED;
 364     }
 365
 366     OICFree(uuid);
 367     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 368     return CA_STATUS_OK;
 369 }
 370
 371 const char *CABTGetErrorMsg(bt_error_e err)
 372 {
 373     const char *errStr = NULL;
 374
 375     switch (err)
 376     {
 377         case BT_ERROR_NONE:
 378             errStr = "BT_ERROR_NONE";
 379             break;
 380         case BT_ERROR_CANCELLED:
 381             errStr = "BT_ERROR_CANCELLED";
 382             break;
 383         case BT_ERROR_INVALID_PARAMETER:
 384             errStr = "BT_ERROR_INVALID_PARAMETER";
 385             break;
 386         case BT_ERROR_OUT_OF_MEMORY:
 387             errStr = "BT_ERROR_OUT_OF_MEMORY";
 388             break;
 389         case BT_ERROR_RESOURCE_BUSY:
 390             errStr = "BT_ERROR_RESOURCE_BUSY";
 391             break;
 392         case BT_ERROR_TIMED_OUT:
 393             errStr = "BT_ERROR_TIMED_OUT";
 394             break;
 395         case BT_ERROR_NOW_IN_PROGRESS:
 396             errStr = "BT_ERROR_NOW_IN_PROGRESS";
 397             break;
 398         case BT_ERROR_NOT_INITIALIZED:
 399             errStr = "BT_ERROR_NOT_INITIALIZED";
 400             break;
 401         case BT_ERROR_NOT_ENABLED:
 402             errStr = "BT_ERROR_NOT_ENABLED";
 403             break;
 404         case BT_ERROR_ALREADY_DONE:
 405             errStr = "BT_ERROR_ALREADY_DONE";
 406             break;
 407         case BT_ERROR_OPERATION_FAILED:
 408             errStr = "BT_ERROR_OPERATION_FAILED";
 409             break;
 410         case BT_ERROR_NOT_IN_PROGRESS:
 411             errStr = "BT_ERROR_NOT_IN_PROGRESS";
 412             break;
 413         case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
 414             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_BONDED";
 415             break;
 416         case BT_ERROR_AUTH_REJECTED:
 417             errStr = "BT_ERROR_AUTH_REJECTED";
 418             break;
 419         case BT_ERROR_AUTH_FAILED:
 420             errStr = "BT_ERROR_AUTH_FAILED";
 421             break;
 422         case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
 423             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_FOUND";
 424             break;
 425         case BT_ERROR_SERVICE_SEARCH_FAILED:
 426             errStr = "BT_ERROR_SERVICE_SEARCH_FAILED";
 427             break;
 428         case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
 429             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED";
 430             break;
 431         case BT_ERROR_PERMISSION_DENIED:
 432             errStr = "BT_ERROR_PERMISSION_DENIED";
 433             break;
 434         case BT_ERROR_SERVICE_NOT_FOUND:
 435             errStr = "BT_ERROR_SERVICE_NOT_FOUND";
 436             break;
 437         case BT_ERROR_NOT_SUPPORTED:
 438             errStr = "BT_ERROR_NOT_SUPPORTED";
 439             break;
 440         default:
 441             errStr = "NOT Defined";
 442             break;
 443     }
 444
 445     return errStr;
 446 }
 447
 448