resource/csdk/connectivity/src/bt_edr_adapter/tizen/caedrdevicelist.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 /**
  22  * @file
  23  *
  24  * This file provides APIs to access the discovered bluetooth device list.
  25  */
  26
  27 #include "caedrdevicelist.h"
  28 #include "caadapterutils.h"
  29 #include "caedrutils.h"
  30 #include "logger.h"
  31
  32
  33 /**
  34  * @fn  CACreateEDRDevice
  35  * @brief  Creates #EDRDevice for specified remote address and uuid.
  36  *
  37  */
  38 static CAResult_t CACreateEDRDevice(const char *deviceAddress,
  39                                 const char *uuid,EDRDevice **device);
  40
  41
  42 /**
  43  * @fn  CADestroyEDRDevice
  44  * @brief  Free all the memory associated with specified device.
  45  *
  46  */
  47 static void CADestroyEDRDevice(EDRDevice *device);
  48
  49
  50 /**
  51  * @fn  CADestroyEDRData
  52  * @brief  Free all the memory associated with specified data.
  53  *
  54  */
  55 static void CADestroyEDRData(EDRData *data);
  56
  57
  58 CAResult_t CACreateAndAddToDeviceList(EDRDeviceList **deviceList, const char *deviceAddress,
  59                                       const char *uuid, EDRDevice **device)
  60 {
  61     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
  62
  63     VERIFY_NON_NULL(deviceList, EDR_ADAPTER_TAG, "Device list is null");
  64     VERIFY_NON_NULL(deviceAddress, EDR_ADAPTER_TAG, "Remote address is null");
  65     VERIFY_NON_NULL(device, EDR_ADAPTER_TAG, "Device is null");
  66     CAResult_t result = CACreateEDRDevice(deviceAddress, uuid, device);
  67     if (CA_STATUS_OK != result || NULL == *device)
  68     {
  69         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid or Not bonded device ret[%d]", result);
  70         return CA_STATUS_FAILED;
  71     }
  72     result = CAAddEDRDeviceToList(deviceList, *device);
  73     if (CA_STATUS_OK != result)
  74     {
  75         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to add in list ret[%d]", result);
  76
  77         //Remove created EDRDevice
  78         CADestroyEDRDevice(*device);
  79         *device = NULL;
  80
  81         return CA_STATUS_FAILED;
  82     }
  83
  84     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
  85     return CA_STATUS_OK;
  86 }
  87
  88 CAResult_t CACreateEDRDevice(const char *deviceAddress, const char *uuid, EDRDevice **device)
  89 {
  90     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
  91
  92     VERIFY_NON_NULL(deviceAddress, EDR_ADAPTER_TAG, "Remote address is null");
  93     VERIFY_NON_NULL(uuid, EDR_ADAPTER_TAG, "uuid is null");
  94     VERIFY_NON_NULL(device, EDR_ADAPTER_TAG, "Device is null");
  95
  96     *device = (EDRDevice *) OICMalloc(sizeof(EDRDevice));
  97     if (NULL == *device)
  98     {
  99         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Out of memory (device)!");
 100         return CA_MEMORY_ALLOC_FAILED;
 101     }
 102
 103     //Copy bluetooth address
 104     if (deviceAddress[0])
 105     {
 106         (*device)->remoteAddress = strndup(deviceAddress, strlen(deviceAddress));
 107         if (NULL == (*device)->remoteAddress)
 108         {
 109             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Out of memory (remote address)!");
 110
 111             OICFree(*device);
 112             *device = NULL;
 113             return CA_MEMORY_ALLOC_FAILED;
 114         }
 115     }
 116
 117     //Copy OIC service uuid
 118     if (strlen(uuid))
 119     {
 120         (*device)->serviceUUID = strndup(uuid, strlen(uuid));
 121         if (NULL == (*device)->serviceUUID)
 122         {
 123             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 124                       "[createEDRDevice] Out of memory (service uuid)!");
 125
 126             OICFree((*device)->remoteAddress);
 127             OICFree(*device);
 128             *device = NULL;
 129             return CA_MEMORY_ALLOC_FAILED;
 130         }
 131     }
 132
 133     (*device)->socketFD = -1;
 134     (*device)->pendingDataList = NULL;
 135     (*device)->serviceSearched = false;
 136
 137     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 138     return CA_STATUS_OK;
 139 }
 140
 141 CAResult_t CAAddEDRDeviceToList(EDRDeviceList **deviceList, EDRDevice *device)
 142 {
 143     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 144
 145     VERIFY_NON_NULL(deviceList, EDR_ADAPTER_TAG, "Device list is null");
 146     VERIFY_NON_NULL(device, EDR_ADAPTER_TAG, "Device is null");
 147
 148     EDRDeviceList *node = (EDRDeviceList *) OICMalloc(sizeof(EDRDeviceList));
 149     if (NULL == node)
 150     {
 151         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Out of memory (device list)!");
 152         return CA_MEMORY_ALLOC_FAILED;
 153     }
 154
 155     node->device = device;
 156     node->next = NULL;
 157
 158     if (NULL == *deviceList) //Empty list
 159     {
 160         *deviceList = node;
 161     }
 162     else //Add at front end
 163     {
 164         node->next = *deviceList;
 165         *deviceList = node;
 166     }
 167
 168     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 169     return CA_STATUS_OK;
 170 }
 171
 172 CAResult_t CAGetEDRDevice(EDRDeviceList *deviceList,
 173                             const char *deviceAddress, EDRDevice **device)
 174 {
 175     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 176
 177     VERIFY_NON_NULL(deviceList, EDR_ADAPTER_TAG, "Device list is null");
 178     VERIFY_NON_NULL(deviceAddress, EDR_ADAPTER_TAG, "Remote address is null");
 179     VERIFY_NON_NULL(device, EDR_ADAPTER_TAG, "Device is null");
 180
 181     EDRDeviceList *curNode = deviceList;
 182     *device = NULL;
 183     while (curNode != NULL)
 184     {
 185         if (!strcasecmp(curNode->device->remoteAddress, deviceAddress))
 186         {
 187             *device = curNode->device;
 188             return CA_STATUS_OK;
 189         }
 190
 191         curNode = curNode->next;
 192     }
 193
 194     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT [Device not found!]");
 195     return CA_STATUS_FAILED;
 196 }
 197
 198 CAResult_t CAGetEDRDeviceBySocketId(EDRDeviceList *deviceList,
 199                                     int32_t socketID, EDRDevice **device)
 200 {
 201     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 202
 203     VERIFY_NON_NULL(deviceList, EDR_ADAPTER_TAG, "Device list is null");
 204     VERIFY_NON_NULL(device, EDR_ADAPTER_TAG, "Device is null");
 205     EDRDeviceList *curNode = deviceList;
 206     *device = NULL;
 207     while (curNode != NULL)
 208     {
 209         if (curNode->device->socketFD == socketID)
 210         {
 211             *device = curNode->device;
 212             return CA_STATUS_OK;
 213         }
 214
 215         curNode = curNode->next;
 216     }
 217
 218     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 219     return CA_STATUS_FAILED;
 220 }
 221
 222 CAResult_t CARemoveEDRDeviceFromList(EDRDeviceList **deviceList,
 223     const char *deviceAddress)
 224 {
 225     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 226
 227     VERIFY_NON_NULL(deviceList, EDR_ADAPTER_TAG, "Device list is null");
 228     VERIFY_NON_NULL(deviceAddress, EDR_ADAPTER_TAG, "Remote address is null");
 229
 230     EDRDeviceList *curNode = NULL;
 231     EDRDeviceList *prevNode = NULL;
 232
 233     curNode = *deviceList;
 234     while (curNode != NULL)
 235     {
 236         if (!strcasecmp(curNode->device->remoteAddress, deviceAddress))
 237         {
 238             if (curNode == *deviceList)
 239             {
 240                 *deviceList = curNode->next;
 241
 242                 curNode->next = NULL;
 243                 CADestroyEDRDeviceList(&curNode);
 244                 return CA_STATUS_OK;
 245             }
 246             else
 247             {
 248                 prevNode->next = curNode->next;
 249
 250                 curNode->next = NULL;
 251                 CADestroyEDRDeviceList(&curNode);
 252                 return CA_STATUS_OK;
 253             }
 254         }
 255         else
 256         {
 257             prevNode = curNode;
 258             curNode = curNode->next;
 259         }
 260     }
 261
 262     OIC_LOG(ERROR, EDR_ADAPTER_TAG, "OUT Device not in the list !");
 263     return CA_STATUS_FAILED;
 264 }
 265
 266 void CADestroyEDRDeviceList(EDRDeviceList **deviceList)
 267 {
 268     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 269
 270     VERIFY_NON_NULL_VOID(deviceList, EDR_ADAPTER_TAG, "deviceList is null");
 271
 272     while (*deviceList)
 273     {
 274         EDRDeviceList *curNode = *deviceList;
 275         *deviceList = (*deviceList)->next;
 276
 277         CADestroyEDRDevice(curNode->device);
 278         OICFree(curNode);
 279     }
 280
 281     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 282 }
 283
 284 void CADestroyEDRDevice(EDRDevice *device)
 285 {
 286     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 287     if (device)
 288     {
 289         OICFree(device->remoteAddress);
 290         OICFree(device->serviceUUID);
 291         CADestroyEDRDataList(&device->pendingDataList);
 292         OICFree(device);
 293     }
 294     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 295 }
 296
 297 CAResult_t CAAddEDRDataToList(EDRDataList **dataList, const void *data, uint32_t dataLength)
 298 {
 299     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 300
 301     VERIFY_NON_NULL(dataList, EDR_ADAPTER_TAG, "Data list is null");
 302     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 303
 304     if (0 == dataLength)
 305     {
 306         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 307         return CA_STATUS_INVALID_PARAM;
 308     }
 309
 310     EDRDataList *pending_data = (EDRDataList *) OICMalloc(sizeof(EDRDataList));
 311     if (NULL == pending_data)
 312     {
 313         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "OICMalloc failed (data list)!");
 314         return CA_MEMORY_ALLOC_FAILED;
 315     }
 316
 317     pending_data->data = (EDRData *) OICMalloc(sizeof(EDRData));
 318     if (NULL == pending_data->data)
 319     {
 320         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "OICMalloc failed (data node)!");
 321
 322         OICFree(pending_data);
 323         return CA_MEMORY_ALLOC_FAILED;
 324     }
 325     pending_data->next = NULL;
 326
 327     pending_data->data->data = (void *) OICMalloc(dataLength); //data
 328     if (NULL == pending_data->data->data)
 329     {
 330         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "OICMalloc failed (data)!");
 331
 332         OICFree(pending_data->data);
 333         OICFree(pending_data);
 334         return CA_MEMORY_ALLOC_FAILED;
 335     }
 336
 337     memcpy(pending_data->data->data, data, dataLength);
 338     pending_data->data->dataLength = dataLength;
 339
 340     if (NULL == *dataList) //Empty list
 341     {
 342         *dataList = pending_data;
 343     }
 344     else //Add at rear end
 345     {
 346         EDRDataList *curNode = *dataList;
 347         while (curNode->next != NULL)
 348         {
 349             curNode = curNode->next;
 350         }
 351
 352         curNode->next = pending_data;
 353     }
 354
 355     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 356     return CA_STATUS_OK;
 357 }
 358
 359 CAResult_t CARemoveEDRDataFromList(EDRDataList **dataList)
 360 {
 361     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 362
 363     VERIFY_NON_NULL(dataList, EDR_ADAPTER_TAG, "Data list is null");
 364
 365     if (*dataList)
 366     {
 367         EDRDataList *curNode = *dataList;
 368         *dataList = (*dataList)->next;
 369
 370         //Delete the first node
 371         CADestroyEDRData(curNode->data);
 372         OICFree(curNode);
 373     }
 374
 375     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 376     return CA_STATUS_OK;
 377 }
 378
 379 void CADestroyEDRDataList(EDRDataList **dataList)
 380 {
 381     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 382
 383     VERIFY_NON_NULL_VOID(dataList, EDR_ADAPTER_TAG, "Data list is null");
 384
 385     while (*dataList)
 386     {
 387         EDRDataList *curNode = *dataList;
 388         *dataList = (*dataList)->next;
 389
 390         CADestroyEDRData(curNode->data);
 391         OICFree(curNode);
 392     }
 393
 394     *dataList = NULL;
 395
 396     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 397 }
 398
 399 void CADestroyEDRData(EDRData *data)
 400 {
 401     if (data)
 402     {
 403         OICFree(data->data);
 404         OICFree(data);
 405     }
 406 }
 407