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