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