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