resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.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 contains the APIs for EDR adapter.
  25  */
  26
  27 #include "caedradapter.h"
  28
  29 #include "caedrinterface.h"
  30 #include "caadapterutils.h"
  31 #include "logger.h"
  32 #include "camsgparser.h"
  33 #include "caqueueingthread.h"
  34 #include "oic_malloc.h"
  35
  36 /**
  37  * @var EDR_ADAPTER_TAG
  38  * @brief Logging tag for module name.
  39  */
  40 #define EDR_ADAPTER_TAG "CA_EDR_ADAPTER"
  41
  42 /**
  43  * @var g_edrThreadPool
  44  * @brief Reference to threadpool.
  45  */
  46 static u_thread_pool_t g_edrThreadPool = NULL;
  47
  48 /**
  49  * @var g_sendQueueHandle
  50  * @brief Queue handle for Send Data
  51  */
  52 static CAQueueingThread_t *g_sendQueueHandle = NULL;
  53
  54 /**
  55  * @var g_recvQueueHandle
  56  * @brief Queue handle for Receive Data
  57  */
  58 static CAQueueingThread_t *g_recvQueueHandle = NULL;
  59
  60 /**
  61  * @var g_isHeaderAvailable
  62  * @brief to differentiate btw header and data packet.
  63  */
  64 static bool g_isHeaderAvailable = false;
  65
  66 /**
  67  * @var g_adapterState
  68  * @brief Storing Adapter state information
  69  */
  70 static bool g_adapterState = true;
  71
  72 /**
  73  * @var g_networkPacketReceivedCallback
  74  * @brief Maintains the callback to be notified on receival of network packets from other
  75  *          Bluetooth devices.
  76  */
  77 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
  78
  79 /**
  80  * @var g_networkChangeCallback
  81  * @brief Maintains the callback to be notified on local bluetooth adapter status change.
  82  */
  83 static CANetworkChangeCallback g_networkChangeCallback = NULL;
  84
  85 /**
  86  * @var g_localConnectivity
  87  * @brief Information of local Bluetooth adapter.
  88  */
  89 static CALocalConnectivity_t *g_localConnectivity = NULL;
  90
  91 /**
  92  * @var g_serverId
  93  * @brief Storing RfcommserverUUID
  94  */
  95 static int g_serverId = -1;
  96
  97 /**
  98  * @var g_serverState
  99  * @brief Storing Rfcommserver state information
 100  */
 101 static bool g_serverState = false;
 102
 103 static CAResult_t CAStartServer(void);
 104 static CAResult_t CAEDRInitializeQueueHandlers(void);
 105 CAResult_t CAEDRInitializeSendHandler(void);
 106 CAResult_t CAEDRInitializeReceiveHandler(void);
 107 void CAAdapterTerminateQueues(void);
 108 void CAAdapterDataSendHandler(void *context);
 109 void CAAdapterDataReceiverHandler(void *context);
 110 CAResult_t CAAdapterStopQueue();
 111 void CAAdapterRecvData(const char *remoteAddress, const void *data,
 112                                     uint32_t dataLength, uint32_t *sentLength);
 113 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
 114 void CAEDROnNetworkStatusChanged(void *context);
 115 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
 116                                const void *data, uint32_t dataLength, uint32_t *sentLength);
 117 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CALocalConnectivity_t *connectivity,
 118                                            CANetworkStatus_t status);
 119 CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID,
 120                                       const void *data, uint32_t dataLength, uint32_t *sentLength);
 121 /**
 122  * @fn CACreateEDRData
 123  * @brief Helper function to create CAEDRData
 124  */
 125 static CAEDRData *CACreateEDRData(const CARemoteEndpoint_t *remoteEndpoint, const void *data,
 126                                 uint32_t dataLength);
 127
 128 /**
 129  * @fn CAFreeEDRData
 130  * @brief Free the Created EDR data
 131  */
 132 static void CAFreeEDRData(CAEDRData *edrData);
 133
 134 /**
 135  * @fn CAEDRFreeNetworkEvent
 136  * @brief Free the memory associated with @event.
 137  */
 138 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
 139
 140 static void CAEDRDataDestroyer(void *data, uint32_t size);
 141
 142 CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
 143                            CANetworkPacketReceivedCallback packetReceivedCallback,
 144                            CANetworkChangeCallback networkStateChangeCallback,
 145                            u_thread_pool_t handle)
 146 {
 147     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 148
 149     // Input validation
 150     VERIFY_NON_NULL(registerCallback, EDR_ADAPTER_TAG, "register callback is NULL");
 151     VERIFY_NON_NULL(packetReceivedCallback, EDR_ADAPTER_TAG, "data receive callback is NULL");
 152     VERIFY_NON_NULL(networkStateChangeCallback, EDR_ADAPTER_TAG,
 153                     "network state change callback is NULL");
 154     VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool handle is NULL");
 155
 156     // Register the callbacks
 157
 158     g_edrThreadPool = handle;
 159     g_networkPacketReceivedCallback = packetReceivedCallback;
 160     g_networkChangeCallback = networkStateChangeCallback;
 161
 162     // Initialize EDR Network Monitor
 163     CAResult_t err = CAEDRInitializeNetworkMonitor();
 164     if (CA_STATUS_OK != err)
 165     {
 166         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR N/w Monitor Initialize failed!, error number [%d]",
 167                   err);
 168         return err;
 169     }
 170
 171     CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
 172     CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
 173     CAEDRInitializeClient(handle);
 174
 175     CAConnectivityHandler_t handler;
 176     handler.startAdapter = CAStartEDR;
 177     handler.startListenServer = CAStartEDRListeningServer;
 178     handler.startDiscoveryServer = CAStartEDRDiscoveryServer;
 179     handler.sendData = CASendEDRUnicastData;
 180     handler.sendDataToAll = CASendEDRMulticastData;
 181     handler.GetnetInfo = CAGetEDRInterfaceInformation;
 182     handler.readData = CAReadEDRData;
 183     handler.stopAdapter = CAStopEDR;
 184     handler.terminate = CATerminateEDR;
 185     registerCallback(handler, CA_EDR);
 186
 187     // Initialize Send/Receive data message queues
 188     if (CA_STATUS_OK != CAEDRInitializeQueueHandlers())
 189     {
 190         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAAdapterInitializeQueues API failed");
 191         CATerminateEDR();
 192         return CA_STATUS_FAILED;
 193     }
 194
 195     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 196     return CA_STATUS_OK;
 197 }
 198
 199 CAResult_t CAStartEDR(void)
 200 {
 201     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 202
 203     //Start Monitoring EDR Network
 204     CAResult_t ret = CAEDRStartNetworkMonitor();
 205     if(CA_STATUS_OK != ret)
 206     {
 207        OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor");
 208     }
 209
 210     // Get Bluetooth adapter state
 211     bool adapterState = false;
 212     if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 213     {
 214         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 215         return CA_STATUS_FAILED;
 216     }
 217
 218     if (false == adapterState)
 219     {
 220         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 221         g_adapterState = false;
 222         return CA_STATUS_OK;
 223     }
 224
 225     if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
 226     {
 227         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Start Network Monitor failed!, error number [%d] ",
 228                   ret);
 229     }
 230
 231     if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
 232     {
 233         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ",
 234                   ret);
 235     }
 236
 237     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 238     return ret;
 239 }
 240
 241 CAResult_t CAStartEDRListeningServer(void)
 242 {
 243     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 244
 245     return CAStartServer();
 246 }
 247
 248 CAResult_t CAStartEDRDiscoveryServer(void)
 249 {
 250     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 251
 252     return CAStartServer();
 253 }
 254
 255 int32_t CASendEDRUnicastData(const CARemoteEndpoint_t *remoteEndpoint, const void *data,
 256                               uint32_t dataLength)
 257 {
 258     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 259
 260     CAResult_t err = CA_STATUS_OK;
 261
 262     // Input validation
 263     VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
 264     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 265
 266     if (0 == strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
 267     {
 268         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
 269         return -1;
 270     }
 271
 272     if (0 == dataLength)
 273     {
 274         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 275         return -1;
 276     }
 277
 278     uint32_t sentLength = 0;
 279     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 280     const char *address = remoteEndpoint->addressInfo.BT.btMacAddress;
 281     if (CA_STATUS_OK != (err = CAAdapterSendData(address, serviceUUID, data,
 282                                dataLength, &sentLength)))
 283     {
 284         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
 285         return -1;
 286     }
 287
 288     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 289     return sentLength;
 290 }
 291
 292 int32_t CASendEDRMulticastData(const void *data, uint32_t dataLength)
 293 {
 294     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
 295
 296     CAResult_t err = CA_STATUS_OK;
 297
 298     // Input validation
 299     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 300
 301     if (0 == dataLength)
 302     {
 303         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 304         return -1;
 305     }
 306
 307     uint32_t sentLen = 0;
 308     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 309     if (CA_STATUS_OK != (err = CAAdapterSendData(NULL, serviceUUID, data, dataLength,
 310                                &sentLen)))
 311     {
 312         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]",
 313                   err);
 314         return -1;
 315     }
 316
 317     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
 318     return sentLen;
 319 }
 320
 321
 322 CAResult_t CAGetEDRInterfaceInformation(CALocalConnectivity_t **info, uint32_t *size)
 323 {
 324     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 325
 326     VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
 327
 328     CAResult_t err = CA_STATUS_OK;
 329     *size = 0;
 330     if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
 331     {
 332         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 333                   "Failed to get local interface information!, error num [%d]", err);
 334         return err;
 335     }
 336
 337     *size = 1;
 338     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 339     return err;
 340 }
 341
 342 CAResult_t CAReadEDRData(void)
 343 {
 344     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 345
 346     return CAEDRManagerReadData();
 347 }
 348
 349 CAResult_t CAStopEDR(void)
 350 {
 351     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 352
 353     // Stop RFComm server if it is running
 354     if (-1 != g_serverId)
 355     {
 356         CAEDRServerStop(g_serverId);
 357         g_serverId = -1;
 358     }
 359
 360     // Stop network monitor
 361     CAEDRStopNetworkMonitor();
 362
 363     // Stop the adapter
 364     CAEDRClientUnsetCallbacks();
 365
 366     // Disconnect all the client connections
 367     CAEDRClientDisconnectAll();
 368
 369     // Stop Send and receive Queue
 370     CAAdapterStopQueue();
 371
 372     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 373     return CA_STATUS_OK;
 374 }
 375
 376 void CATerminateEDR(void)
 377 {
 378     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 379
 380     // Terminate EDR Network Monitor
 381     CAEDRTerminateNetworkMonitor();
 382
 383     // Terminate Send/Receive data messages queues
 384     CAAdapterTerminateQueues();
 385
 386     g_networkPacketReceivedCallback = NULL;
 387     g_networkChangeCallback = NULL;
 388
 389     // Terminate thread pool
 390     g_edrThreadPool = NULL;
 391
 392     // Terminate BT Client
 393     CAEDRClientTerminate();
 394
 395     // Terminate BT Server
 396     CAEDRServerTerminate();
 397
 398     // Free LocalConnectivity information
 399     CAAdapterFreeLocalEndpoint(g_localConnectivity);
 400     g_localConnectivity = NULL;
 401
 402     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 403 }
 404
 405 CAResult_t CAStartServer(void)
 406 {
 407     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 408
 409     CAResult_t err = CA_STATUS_OK;
 410
 411     if (false == g_adapterState)
 412     {
 413         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 414         // Setting g_serverState for starting Rfcommserver when adapter starts
 415         g_serverState = TRUE;
 416         return CA_STATUS_OK;
 417     }
 418
 419     if (-1 < g_serverId)
 420     {
 421         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Server is already in running state.");
 422         return CA_STATUS_OK;
 423     }
 424
 425     if (CA_STATUS_OK != (err = CAEDRServerStart(OIC_EDR_SERVICE_ID, &g_serverId, g_edrThreadPool)))
 426     {
 427         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 428                   err);
 429         return err;
 430     }
 431
 432     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 433     return err;
 434 }
 435
 436 CAResult_t CAEDRInitializeQueueHandlers(void)
 437 {
 438     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 439
 440     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 441         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 442     {
 443         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 444         return CA_STATUS_OK;
 445     }
 446
 447     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 448     return CA_STATUS_FAILED;
 449 }
 450
 451 CAResult_t CAEDRInitializeSendHandler(void)
 452 {
 453     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 454     // Check if the message queue is already initialized
 455     if (g_sendQueueHandle)
 456     {
 457         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 458         return CA_STATUS_OK;
 459     }
 460
 461     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 462     if (!g_sendQueueHandle)
 463     {
 464         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 465         return CA_MEMORY_ALLOC_FAILED;
 466     }
 467
 468     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 469             CAAdapterDataSendHandler, CAEDRDataDestroyer))
 470     {
 471         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 472         return CA_STATUS_FAILED;
 473     }
 474     return CA_STATUS_OK;
 475 }
 476
 477 CAResult_t CAEDRInitializeReceiveHandler(void)
 478 {
 479     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 480     // Check if the message queue is already initialized
 481     if (g_recvQueueHandle)
 482     {
 483         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 484         return CA_STATUS_OK;
 485     }
 486
 487     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 488     if (!g_recvQueueHandle)
 489     {
 490         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 491         return CA_MEMORY_ALLOC_FAILED;
 492     }
 493
 494     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 495             CAAdapterDataReceiverHandler, CAEDRDataDestroyer))
 496     {
 497         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 498         return CA_STATUS_FAILED;
 499     }
 500
 501     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 502     return CA_STATUS_OK;
 503 }
 504
 505 void CAAdapterTerminateQueues(void)
 506 {
 507     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 508
 509     if (g_sendQueueHandle)
 510     {
 511         CAQueueingThreadDestroy(g_sendQueueHandle);
 512         g_sendQueueHandle = NULL;
 513     }
 514     if (g_recvQueueHandle)
 515     {
 516         CAQueueingThreadDestroy(g_recvQueueHandle);
 517         g_recvQueueHandle = NULL;
 518     }
 519
 520     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 521 }
 522
 523 void CAAdapterDataSendHandler(void *context)
 524 {
 525     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 526
 527     CAEDRData *message = (CAEDRData *) context;
 528     if (message == NULL)
 529     {
 530         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 531         return;
 532     }
 533
 534     const char *remoteAddress = NULL;
 535     const char *serviceUUID = NULL;
 536     uint32_t sentLength = 0;
 537
 538     if(NULL == message->remoteEndpoint)
 539     {
 540         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 541     }
 542
 543     remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
 544     serviceUUID = message->remoteEndpoint->resourceUri;
 545
 546     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "checking for fragmentation and the dataLen is %d",
 547               message->dataLen);
 548
 549     char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char));
 550     VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Malloc failed");
 551
 552     char* dataSegment = (char *) OICCalloc(message->dataLen + CA_HEADER_LENGTH, sizeof(char));
 553     if (NULL == dataSegment)
 554     {
 555         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Malloc failed");
 556         OICFree(header);
 557         return;
 558     }
 559
 560     CAResult_t result = CAGenerateHeader(header, message->dataLen);
 561     if (CA_STATUS_OK != result )
 562     {
 563         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed");
 564         OICFree(header);
 565         OICFree(dataSegment);
 566         return ;
 567     }
 568
 569     memcpy(dataSegment, header, CA_HEADER_LENGTH);
 570     OICFree(header);
 571     int32_t length = 0;
 572     if (CA_SUPPORTED_BLE_MTU_SIZE >= message->dataLen)
 573     {
 574         length = message->dataLen + CA_HEADER_LENGTH;
 575         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "length [%d]", length);
 576         memcpy(dataSegment + CA_HEADER_LENGTH, message->data, message->dataLen);
 577     }
 578     else
 579     {
 580         length =  CA_SUPPORTED_BLE_MTU_SIZE;
 581         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "length [%d]", length);
 582         memcpy(dataSegment + CA_HEADER_LENGTH, message->data,
 583                CA_SUPPORTED_BLE_MTU_SIZE - CA_HEADER_LENGTH);
 584     }
 585
 586     int32_t iter = message->dataLen / CA_SUPPORTED_BLE_MTU_SIZE;
 587     int32_t index = 0;
 588     if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 589                                                 dataSegment, length, &sentLength))
 590     {
 591         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 592         OICFree(dataSegment);
 593         return;
 594     }
 595     OICFree(dataSegment);
 596
 597     for (index = 1; index < iter; index++)
 598     {
 599         // Send the remaining header.
 600         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending the chunk number [%d]", index);
 601
 602         if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 603                     message->data + ((index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH),
 604                     CA_SUPPORTED_BLE_MTU_SIZE, &sentLength))
 605         {
 606             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 607             return;
 608         }
 609     }
 610
 611     if (message->dataLen / CA_SUPPORTED_BLE_MTU_SIZE)
 612     {
 613         // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200)
 614         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending the last chunk");
 615         if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 616                     message->data + (index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH,
 617                     message->dataLen % CA_SUPPORTED_BLE_MTU_SIZE + CA_HEADER_LENGTH, &sentLength))
 618         {
 619             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 620             return;
 621         }
 622     }
 623
 624     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 625 }
 626
 627 CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID,
 628                                       const void *data, uint32_t dataLength, uint32_t *sentLength)
 629 {
 630
 631     // Send the first segment with the header.
 632     if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
 633     {
 634         if (CA_STATUS_OK != CAEDRClientSendUnicastData(remoteAddress, serviceUUID,
 635                 data, dataLength, sentLength))
 636         {
 637             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
 638             return CA_STATUS_FAILED;
 639         }
 640     }
 641     else
 642     {
 643         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
 644         if (CA_STATUS_OK != CAEDRClientSendMulticastData(serviceUUID, data,
 645                 dataLength, sentLength))
 646         {
 647             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
 648             return CA_STATUS_FAILED;
 649         }
 650     }
 651     return CA_STATUS_OK;
 652 }
 653
 654 void CAAdapterDataReceiverHandler(void *context)
 655 {
 656     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 657
 658     CAEDRData *message = (CAEDRData *) context;
 659     if (message == NULL)
 660     {
 661         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 662         return;
 663     }
 664
 665     static uint32_t recvDataLen = 0;
 666     static uint32_t totalDataLen = 0;
 667     static char *defragData = NULL;
 668     static CARemoteEndpoint_t *remoteEndpoint = NULL;
 669
 670     if (!g_isHeaderAvailable)
 671     {
 672         totalDataLen = CAParseHeader((char*)message->data);
 673         if (totalDataLen == 0)
 674         {
 675             OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "totalDataLen is zero");
 676             return;
 677         }
 678
 679         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Total data to be accumulated [%d] bytes",
 680                   totalDataLen);
 681
 682         defragData = (char *) OICMalloc(sizeof(char) * totalDataLen);
 683         if (!defragData)
 684         {
 685             OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "defragData is null");
 686             return;
 687         }
 688
 689         const char *remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
 690         const char *serviceUUID = message->remoteEndpoint->resourceUri;
 691
 692         remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
 693                          serviceUUID);
 694
 695         memcpy(defragData + recvDataLen, message->data + CA_HEADER_LENGTH,
 696                message->dataLen - CA_HEADER_LENGTH);
 697         recvDataLen += message->dataLen - CA_HEADER_LENGTH;
 698         g_isHeaderAvailable = true;
 699     }
 700     else
 701     {
 702         memcpy(defragData + recvDataLen, message->data, message->dataLen);
 703         recvDataLen += message->dataLen ;
 704     }
 705
 706     if (totalDataLen == recvDataLen)
 707     {
 708         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 709         g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen);
 710         recvDataLen = 0;
 711         totalDataLen = 0;
 712         remoteEndpoint = NULL;
 713         g_isHeaderAvailable = false;
 714     }
 715
 716     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 717 }
 718
 719 CAResult_t CAAdapterStartQueue()
 720 {
 721     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 722     // Start send queue thread
 723     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 724     {
 725         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 726         CAEDRClientUnsetCallbacks();
 727         //Disconnect all the client connections
 728         CAEDRClientDisconnectAll();
 729         return CA_STATUS_FAILED;
 730     }
 731
 732     // Start receive queue thread
 733     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 734     {
 735         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 736         CAEDRClientUnsetCallbacks();
 737         //Disconnect all the client connections
 738         CAEDRClientDisconnectAll();
 739         return CA_STATUS_FAILED;
 740     }
 741     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 742     return CA_STATUS_OK;
 743 }
 744
 745 CAResult_t CAAdapterStopQueue()
 746 {
 747     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 748     //Stop send queue thread
 749     CAQueueingThreadStop(g_sendQueueHandle);
 750
 751     //Stop receive queue thread
 752     CAQueueingThreadStop(g_recvQueueHandle);
 753     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 754     return CA_STATUS_OK;
 755 }
 756
 757 void CAAdapterRecvData(const char *remoteAddress, const void *data,
 758                                     uint32_t dataLength, uint32_t *sentLength)
 759 {
 760     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 761
 762     if (false == g_adapterState)
 763     {
 764         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 765         *sentLength = 0;
 766         return;
 767     }
 768
 769     char *serviceUUID = OIC_EDR_SERVICE_ID;
 770
 771     // Input validation
 772     VERIFY_NON_NULL_VOID(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 773     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 774     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 775
 776     // Create remote endpoint
 777     CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
 778                                          serviceUUID);
 779     if (NULL == remoteEndpoint)
 780     {
 781         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 782         return;
 783     }
 784
 785     // Add message to data queue
 786     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 787     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CARemoteEndpoint_t));
 788     *sentLength = dataLength;
 789
 790     // Free remote endpoint
 791     CAAdapterFreeRemoteEndpoint(remoteEndpoint);
 792
 793     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 794     return;
 795 }
 796
 797 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
 798                                const void *data, uint32_t dataLength, uint32_t *sentLength)
 799 {
 800     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 801
 802     if (false == g_adapterState)
 803     {
 804         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 805         *sentLength = 0;
 806         return CA_STATUS_OK;
 807     }
 808     // Input validation
 809     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 810     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 811     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 812
 813     // Create remote endpoint
 814     CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
 815                                          serviceUUID);
 816     if (NULL == remoteEndpoint)
 817     {
 818         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 819         return CA_STATUS_FAILED;
 820     }
 821
 822     // Add message to data queue
 823     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 824     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof(CAEDRData));
 825     *sentLength = dataLength;
 826
 827     // Free remote endpoint
 828     CAAdapterFreeRemoteEndpoint(remoteEndpoint);
 829
 830     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 831     return CA_STATUS_OK;
 832 }
 833
 834 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 835 {
 836     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 837
 838     // Create localconnectivity
 839     if (NULL == g_localConnectivity)
 840     {
 841         CAEDRGetInterfaceInformation(&g_localConnectivity);
 842     }
 843
 844     if(CA_INTERFACE_UP == status)
 845     {
 846         if(false == g_adapterState)
 847         {
 848             // Get Bluetooth adapter state
 849             bool adapterState = false;
 850             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 851             {
 852                 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 853                 return;
 854             }
 855
 856             if (false== adapterState)
 857             {
 858                 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 859                 g_adapterState = false;
 860                 return;
 861             }
 862             CAEDRClientSetCallbacks();
 863             g_adapterState = true;
 864             CAAdapterStartQueue();
 865             // starting RFCommServer
 866             if(true == g_serverState)
 867             {
 868                 CAStartServer();
 869                 g_serverState = false;
 870             }
 871         }
 872     }
 873     else
 874     {
 875         g_adapterState = false;
 876     }
 877
 878     // Notity to upper layer
 879     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 880     {
 881         // Add notification task to thread pool
 882         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 883         if (NULL != event)
 884         {
 885             if (CA_STATUS_OK != u_thread_pool_add_task(g_edrThreadPool, CAEDROnNetworkStatusChanged,
 886                     event))
 887             {
 888                 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 889                 return;
 890             }
 891         }
 892     }
 893
 894     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 895 }
 896
 897 void CAEDROnNetworkStatusChanged(void *context)
 898 {
 899     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
 900
 901     if (NULL == context)
 902     {
 903         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 904         return;
 905     }
 906
 907     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 908
 909     // Notity to upper layer
 910     if (g_networkChangeCallback)
 911     {
 912         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 913     }
 914
 915     // Free the created Network event
 916     CAEDRFreeNetworkEvent(networkEvent);
 917
 918     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 919 }
 920
 921 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CALocalConnectivity_t *connectivity,
 922                                            CANetworkStatus_t status)
 923 {
 924     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 925
 926     // Create CAEDRNetworkEvent
 927     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 928     if (NULL == event)
 929     {
 930         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 931         return NULL;
 932     }
 933
 934     // Create duplicate of Local connectivity
 935     event->info = CAAdapterCopyLocalEndpoint(connectivity);
 936     event->status = status;
 937     return event;
 938 }
 939
 940 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 941 {
 942     if (event)
 943     {
 944         CAAdapterFreeLocalEndpoint(event->info);
 945         OICFree(event);
 946     }
 947 }
 948
 949 CAEDRData *CACreateEDRData(const CARemoteEndpoint_t *remoteEndpoint, const void *data,
 950                            uint32_t dataLength)
 951 {
 952     CAEDRData *edrData = (CAEDRData *) OICMalloc(sizeof(CAEDRData));
 953     if (!edrData)
 954     {
 955         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 956         return NULL;
 957     }
 958
 959     edrData->remoteEndpoint = CAAdapterCopyRemoteEndpoint(remoteEndpoint);
 960     edrData->data = OICMalloc(dataLength);
 961     if (NULL == edrData->data)
 962     {
 963         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 964         CAFreeEDRData(edrData);
 965         return NULL;
 966     }
 967     memcpy(edrData->data, data, dataLength);
 968     edrData->dataLen = dataLength;
 969
 970     return edrData;
 971 }
 972
 973 void CAFreeEDRData(CAEDRData *edrData)
 974 {
 975     if (!edrData)
 976         return;
 977
 978     CAAdapterFreeRemoteEndpoint(edrData->remoteEndpoint);
 979     OICFree(edrData->data);
 980     OICFree(edrData);
 981 }
 982
 983 void CAEDRDataDestroyer(void *data, uint32_t size)
 984 {
 985     CAEDRData *edrdata = (CAEDRData *) data;
 986
 987     CAFreeEDRData(edrdata);
 988 }
 989