resource/csdk/connectivity/src/bt_le_adapter/tizen/cableclientutil.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 "cableclientutil.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
  34 #define TZ_BLE_CLIENT_UTIL_TAG "TZ_BLE_GATT_CLIENT_UTIL"
  35
  36 #define OIC_BLE_SERVICE_ID "000018f3-0000-1000-8000-00805f9b34fb"
  37 ///TODO: OIC_BLE_SERVICE_ID  will be generated by invoking API in future.
  38
  39
  40 static int32_t gNumberOfServiceConnected = 0;
  41
  42 void CAIncrementRegisteredServiceCount()
  43 {
  44     gNumberOfServiceConnected++;
  45 }
  46
  47 void CADecrementRegisteredServiceCount()
  48 {
  49     gNumberOfServiceConnected--;
  50 }
  51
  52 void CAResetRegisteredServiceCount()
  53 {
  54     gNumberOfServiceConnected = 0;
  55 }
  56
  57 int32_t  CAGetRegisteredServiceCount()
  58 {
  59     return gNumberOfServiceConnected ;
  60 }
  61
  62 CAResult_t CACreateBLEServiceInfo(const char *bdAddress, bt_gatt_attribute_h service,
  63                                   BLEServiceInfo **bleServiceInfo)
  64 {
  65     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
  66
  67     VERIFY_NON_NULL(bdAddress, NULL, " Param bdAddress is NULL");
  68     VERIFY_NON_NULL(service, NULL, " Param service is NULL");
  69
  70     *bleServiceInfo = (BLEServiceInfo *) OICMalloc(sizeof(BLEServiceInfo));
  71     if (NULL == *bleServiceInfo)
  72     {
  73         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, " Malloc failed!");
  74         return CA_STATUS_FAILED;
  75     }
  76     memset(*bleServiceInfo, 0x0, sizeof(BLEServiceInfo));
  77
  78     int32_t len = strlen(bdAddress);
  79     (*bleServiceInfo)->bdAddress = (char *) OICMalloc(sizeof(char) * len + 1);
  80
  81     if (NULL == (*bleServiceInfo)->bdAddress)
  82     {
  83         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, " Malloc failed!");
  84
  85         OICFree(*bleServiceInfo);
  86         return CA_STATUS_FAILED;
  87     }
  88     memset((*bleServiceInfo)->bdAddress, 0x0, len + 1);
  89
  90     strncpy((*bleServiceInfo)->bdAddress, bdAddress, len);
  91
  92     if (service)
  93     {
  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, NULL, " Param characteristic is NULL");
 118     VERIFY_NON_NULL(bleServiceInfo, NULL, " Param bleServiceInfo is NULL");
 119
 120     if (READ_CHAR == type )
 121     {
 122         int32_t ret = bt_gatt_clone_attribute_handle(&((bleServiceInfo)->read_char), characteristic);
 123         if (BT_ERROR_NONE != ret)
 124         {
 125             OIC_LOG_V(ERROR, TZ_BLE_CLIENT_UTIL_TAG, " read_char clone failed with ret [%d]",
 126                       ret);
 127             return CA_STATUS_FAILED;
 128         }
 129     }
 130     else  if (WRITE_CHAR == type)
 131     {
 132         int32_t ret = bt_gatt_clone_attribute_handle(&((bleServiceInfo)->write_char), characteristic);
 133         if (BT_ERROR_NONE != ret)
 134         {
 135             OIC_LOG_V(ERROR, TZ_BLE_CLIENT_UTIL_TAG, " write_char clone failed with ret [%d]",
 136                       ret);
 137             return CA_STATUS_FAILED;
 138         }
 139     }
 140
 141     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 142
 143     return CA_STATUS_OK;
 144 }
 145
 146 CAResult_t CAAddBLEServiceInfoToList(BLEServiceList **serviceList, BLEServiceInfo *bleServiceInfo)
 147 {
 148
 149     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 150
 151     VERIFY_NON_NULL(serviceList, NULL, " Param serviceList is NULL");
 152     VERIFY_NON_NULL(bleServiceInfo, NULL, " Param bleServiceInfo is NULL");
 153
 154     BLEServiceList *node = (BLEServiceList *) OICMalloc(sizeof(BLEServiceList));
 155     if (NULL == node)
 156     {
 157         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "[ERROR]Malloc failed!");
 158         OICFree(bleServiceInfo->bdAddress);
 159         OICFree(bleServiceInfo);
 160         return CA_STATUS_FAILED;
 161     }
 162     memset(node, 0x0, sizeof(BLEServiceList));
 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", bleServiceInfo->bdAddress);
 180
 181     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 182
 183     return CA_STATUS_OK;
 184 }
 185
 186 CAResult_t CARemoveBLEServiceInfoToList(BLEServiceList **serviceList,
 187                                         BLEServiceInfo *bleServiceInfo,
 188                                         const char *bdAddress)
 189 {
 190
 191     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 192
 193     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 194     VERIFY_NON_NULL(*serviceList, NULL, "Param *serviceList is NULL");
 195     VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
 196
 197     BLEServiceList *cur = NULL;
 198     BLEServiceList *prev = NULL;
 199
 200     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
 237 CAResult_t CAGetBLEServiceInfo(BLEServiceList *serviceList, const char *bdAddress,
 238                                BLEServiceInfo **bleServiceInfo)
 239 {
 240
 241     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 242
 243     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 244     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 245     VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
 246
 247
 248     BLEServiceList *cur = serviceList;
 249     *bleServiceInfo = NULL;
 250     while (cur != NULL)
 251     {
 252         if (!strcasecmp(cur->serviceInfo->bdAddress, bdAddress))
 253         {
 254             *bleServiceInfo = cur->serviceInfo;
 255             OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 256             return CA_STATUS_OK;
 257         }
 258
 259         cur = cur->next;
 260     }
 261
 262     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, " OUT");
 263     return CA_STATUS_FAILED;
 264 }
 265
 266 CAResult_t CAGetBLEServiceInfoByPosition(BLEServiceList *serviceList, int32_t position,
 267         BLEServiceInfo **bleServiceInfo)
 268 {
 269     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 270
 271     VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
 272     VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
 273
 274     if (0 > position)
 275     {
 276         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "Position Invalid input !");
 277         return CA_STATUS_INVALID_PARAM;
 278     }
 279     BLEServiceList *cur = serviceList;
 280     *bleServiceInfo = NULL;
 281     int32_t count = 0;
 282
 283     while (cur != NULL)
 284     {
 285         if (position == count)
 286         {
 287             *bleServiceInfo = cur->serviceInfo;
 288             OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 289             return CA_STATUS_OK;
 290         }
 291         count++;
 292         cur = cur->next;
 293     }
 294     return CA_STATUS_FAILED;
 295 }
 296
 297 void CAFreeBLEServiceList(BLEServiceList *serviceList)
 298 {
 299     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 300     while (serviceList)
 301     {
 302         BLEServiceList *temp = serviceList;
 303         serviceList = serviceList->next;
 304         CAFreeBLEServiceInfo(temp->serviceInfo);
 305         OICFree(temp);
 306     }
 307     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 308     return ;
 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_device_destroy_bond(bleServiceInfo->bdAddress);
 319             bt_gatt_disconnect(bleServiceInfo->bdAddress);
 320             OICFree(bleServiceInfo->bdAddress);
 321             bt_gatt_destroy_attribute_handle(bleServiceInfo->service_clone);
 322             bt_gatt_destroy_attribute_handle(bleServiceInfo->read_char);
 323             bt_gatt_destroy_attribute_handle(bleServiceInfo->write_char);
 324         }
 325         OICFree(bleServiceInfo);
 326     }
 327     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 328     return ;
 329 }
 330
 331
 332 CAResult_t CAVerifyOICService(bt_gatt_attribute_h serviceHandle)
 333 {
 334     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
 335
 336     VERIFY_NON_NULL(serviceHandle, NULL, "Param serviceHandle is NULL");
 337
 338     int32_t ret = 0;
 339     char *uuid = NULL;
 340
 341     ret = bt_gatt_get_service_uuid(serviceHandle, &uuid);
 342
 343     if (0 != ret)
 344     {
 345         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "bt_gatt_get_service_uuid failed !");
 346         return CA_STATUS_FAILED;
 347     }
 348
 349     if (strcasecmp(uuid, OIC_BLE_SERVICE_ID) != 0)
 350     {
 351         OIC_LOG(ERROR, TZ_BLE_CLIENT_UTIL_TAG, "It is not OIC service!");
 352         return CA_STATUS_FAILED;
 353     }
 354     OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "OUT");
 355     return CA_STATUS_OK;
 356 }
 357
 358 const char *CABTGetErrorMsg(bt_error_e err)
 359 {
 360     const char *errStr = NULL;
 361
 362     switch (err)
 363     {
 364         case BT_ERROR_NONE:
 365             errStr = "BT_ERROR_NONE";
 366             break;
 367         case BT_ERROR_CANCELLED:
 368             errStr = "BT_ERROR_CANCELLED";
 369             break;
 370         case BT_ERROR_INVALID_PARAMETER:
 371             errStr = "BT_ERROR_INVALID_PARAMETER";
 372             break;
 373         case BT_ERROR_OUT_OF_MEMORY:
 374             errStr = "BT_ERROR_OUT_OF_MEMORY";
 375             break;
 376         case BT_ERROR_RESOURCE_BUSY:
 377             errStr = "BT_ERROR_RESOURCE_BUSY";
 378             break;
 379         case BT_ERROR_TIMED_OUT:
 380             errStr = "BT_ERROR_TIMED_OUT";
 381             break;
 382         case BT_ERROR_NOW_IN_PROGRESS:
 383             errStr = "BT_ERROR_NOW_IN_PROGRESS";
 384             break;
 385         case BT_ERROR_NOT_INITIALIZED:
 386             errStr = "BT_ERROR_NOT_INITIALIZED";
 387             break;
 388         case BT_ERROR_NOT_ENABLED:
 389             errStr = "BT_ERROR_NOT_ENABLED";
 390             break;
 391         case BT_ERROR_ALREADY_DONE:
 392             errStr = "BT_ERROR_ALREADY_DONE";
 393             break;
 394         case BT_ERROR_OPERATION_FAILED:
 395             errStr = "BT_ERROR_OPERATION_FAILED";
 396             break;
 397         case BT_ERROR_NOT_IN_PROGRESS:
 398             errStr = "BT_ERROR_NOT_IN_PROGRESS";
 399             break;
 400         case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
 401             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_BONDED";
 402             break;
 403         case BT_ERROR_AUTH_REJECTED:
 404             errStr = "BT_ERROR_AUTH_REJECTED";
 405             break;
 406         case BT_ERROR_AUTH_FAILED:
 407             errStr = "BT_ERROR_AUTH_FAILED";
 408             break;
 409         case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
 410             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_FOUND";
 411             break;
 412         case BT_ERROR_SERVICE_SEARCH_FAILED:
 413             errStr = "BT_ERROR_SERVICE_SEARCH_FAILED";
 414             break;
 415         case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
 416             errStr = "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED";
 417             break;
 418         case BT_ERROR_PERMISSION_DENIED:
 419             errStr = "BT_ERROR_PERMISSION_DENIED";
 420             break;
 421         case BT_ERROR_SERVICE_NOT_FOUND:
 422             errStr = "BT_ERROR_SERVICE_NOT_FOUND";
 423             break;
 424         case BT_ERROR_NOT_SUPPORTED:
 425             errStr = "BT_ERROR_NOT_SUPPORTED";
 426             break;
 427         default:
 428             errStr = "NOT Defined";
 429             break;
 430     }
 431
 432     return errStr;
 433 }
 434