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 ca_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();
 104 static CAResult_t CAEDRInitializeQueueHandlers();
 105 CAResult_t CAEDRInitializeSendHandler();
 106 CAResult_t CAEDRInitializeReceiveHandler();
 107 void CAAdapterTerminateQueues();
 108 void CAAdapterDataSendHandler(void *context);
 109 void CAAdapterDataReceiverHandler(void *context);
 110 CAResult_t CAAdapterStopQueue();
 111 void CAAdapterRecvData(const char *remoteAddress, const void *data, uint32_t dataLength,
 112                        uint32_t *sentLength);
 113 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
 114 void CAEDROnNetworkStatusChanged(void *context);
 115 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const void *data,
 116                              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                            ca_thread_pool_t handle)
 146 {
 147     OIC_LOG(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(handle);
 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(DEBUG, EDR_ADAPTER_TAG, "OUT");
 196     return CA_STATUS_OK;
 197 }
 198
 199 CAResult_t CAStartEDR()
 200 {
 201     OIC_LOG(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(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(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 221         g_adapterState = false;
 222         return CA_ADAPTER_NOT_ENABLED;
 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] ", ret);
 234     }
 235
 236     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 237     return ret;
 238 }
 239
 240 CAResult_t CAStartEDRListeningServer()
 241 {
 242     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 243
 244     return CAStartServer();
 245 }
 246
 247 CAResult_t CAStartEDRDiscoveryServer()
 248 {
 249     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 250
 251     return CAStartServer();
 252 }
 253
 254 int32_t CASendEDRUnicastData(const CARemoteEndpoint_t *remoteEndpoint, const void *data,
 255                              uint32_t dataLength)
 256 {
 257     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 258
 259     // Input validation
 260     VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
 261     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 262
 263     if (0 == dataLength)
 264     {
 265         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 266         return -1;
 267     }
 268
 269     if (0 == strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
 270     {
 271         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
 272         return -1;
 273     }
 274
 275     uint32_t sentLength = 0;
 276     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 277     const char *address = remoteEndpoint->addressInfo.BT.btMacAddress;
 278     CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
 279     if (CA_STATUS_OK != err)
 280     {
 281         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
 282         return -1;
 283     }
 284
 285     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 286     return sentLength;
 287 }
 288
 289 int32_t CASendEDRMulticastData(const void *data, uint32_t dataLength)
 290 {
 291     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
 292
 293     // Input validation
 294     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 295
 296     if (0 == dataLength)
 297     {
 298         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 299         return -1;
 300     }
 301
 302     uint32_t sentLen = 0;
 303     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 304     CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
 305     if (CA_STATUS_OK != err)
 306     {
 307         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
 308         return -1;
 309     }
 310
 311     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
 312     return sentLen;
 313 }
 314
 315
 316 CAResult_t CAGetEDRInterfaceInformation(CALocalConnectivity_t **info, uint32_t *size)
 317 {
 318     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 319
 320     VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
 321
 322     CAResult_t err = CA_STATUS_OK;
 323     *size = 0;
 324     if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
 325     {
 326         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 327                   "Failed to get local interface information!, error num [%d]", err);
 328         return err;
 329     }
 330
 331     *size = 1;
 332     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 333     return err;
 334 }
 335
 336 CAResult_t CAReadEDRData()
 337 {
 338     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 339
 340     return CAEDRManagerReadData();
 341 }
 342
 343 CAResult_t CAStopEDR()
 344 {
 345     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 346
 347     // Stop RFComm server if it is running
 348     if (-1 != g_serverId)
 349     {
 350         CAEDRServerStop(g_serverId);
 351         g_serverId = -1;
 352     }
 353
 354     // Stop network monitor
 355     CAEDRStopNetworkMonitor();
 356
 357     // Stop the adapter
 358     CAEDRClientUnsetCallbacks();
 359
 360     // Disconnect all the client connections
 361     CAEDRClientDisconnectAll();
 362
 363     // Stop Send and receive Queue
 364     CAAdapterStopQueue();
 365
 366     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 367     return CA_STATUS_OK;
 368 }
 369
 370 void CATerminateEDR()
 371 {
 372     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 373
 374     // Stop EDR adapter
 375     CAStopEDR();
 376     // Terminate EDR Network Monitor
 377     CAEDRTerminateNetworkMonitor();
 378
 379     // Terminate Send/Receive data messages queues
 380     CAAdapterTerminateQueues();
 381
 382     g_networkPacketReceivedCallback = NULL;
 383     g_networkChangeCallback = NULL;
 384
 385     // Terminate thread pool
 386     g_edrThreadPool = NULL;
 387
 388     // Terminate EDR Client
 389     CAEDRClientTerminate();
 390
 391     // Terminate EDR Server
 392     CAEDRServerTerminate();
 393
 394     // Free LocalConnectivity information
 395     CAAdapterFreeLocalEndpoint(g_localConnectivity);
 396     g_localConnectivity = NULL;
 397
 398     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 399 }
 400
 401 CAResult_t CAStartServer()
 402 {
 403     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 404
 405     CAResult_t err = CA_STATUS_OK;
 406
 407     if (false == g_adapterState)
 408     {
 409         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 410         // Setting g_serverState for starting Rfcommserver when adapter starts
 411         g_serverState = true;
 412         return CA_STATUS_OK;
 413     }
 414
 415     if (-1 < g_serverId)
 416     {
 417         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Server is already in running state.");
 418         return CA_SERVER_STARTED_ALREADY;
 419     }
 420
 421     if (CA_STATUS_OK != (err = CAEDRServerStart(OIC_EDR_SERVICE_ID, &g_serverId, g_edrThreadPool)))
 422     {
 423         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 424                   err);
 425         return err;
 426     }
 427
 428     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 429     return err;
 430 }
 431
 432 CAResult_t CAEDRInitializeQueueHandlers()
 433 {
 434     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 435
 436     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 437         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 438     {
 439         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 440         return CA_STATUS_OK;
 441     }
 442
 443     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 444     return CA_STATUS_FAILED;
 445 }
 446
 447 CAResult_t CAEDRInitializeSendHandler()
 448 {
 449     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 450     // Check if the message queue is already initialized
 451     if (g_sendQueueHandle)
 452     {
 453         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 454         return CA_STATUS_OK;
 455     }
 456
 457     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 458     if (!g_sendQueueHandle)
 459     {
 460         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 461         return CA_MEMORY_ALLOC_FAILED;
 462     }
 463
 464     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 465                                                    CAAdapterDataSendHandler, CAEDRDataDestroyer))
 466     {
 467         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 468         return CA_STATUS_FAILED;
 469     }
 470     return CA_STATUS_OK;
 471 }
 472
 473 CAResult_t CAEDRInitializeReceiveHandler()
 474 {
 475     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 476     // Check if the message queue is already initialized
 477     if (g_recvQueueHandle)
 478     {
 479         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 480         return CA_STATUS_OK;
 481     }
 482
 483     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 484     if (!g_recvQueueHandle)
 485     {
 486         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 487         return CA_MEMORY_ALLOC_FAILED;
 488     }
 489
 490     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 491                                                    CAAdapterDataReceiverHandler,
 492                                                    CAEDRDataDestroyer))
 493     {
 494         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 495         return CA_STATUS_FAILED;
 496     }
 497
 498     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 499     return CA_STATUS_OK;
 500 }
 501
 502 void CAAdapterTerminateQueues()
 503 {
 504     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 505
 506     if (g_sendQueueHandle)
 507     {
 508         CAQueueingThreadDestroy(g_sendQueueHandle);
 509         g_sendQueueHandle = NULL;
 510     }
 511     if (g_recvQueueHandle)
 512     {
 513         CAQueueingThreadDestroy(g_recvQueueHandle);
 514         g_recvQueueHandle = NULL;
 515     }
 516
 517     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 518 }
 519
 520 void CAAdapterDataSendHandler(void *context)
 521 {
 522     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 523
 524     CAEDRData *message = (CAEDRData *) context;
 525     if (NULL == message)
 526     {
 527         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 528         return;
 529     }
 530
 531     const char *remoteAddress = NULL;
 532     const char *serviceUUID = NULL;
 533     uint32_t sentLength = 0;
 534
 535     if (NULL == message->remoteEndpoint)
 536     {
 537         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 538     }
 539     else
 540     {
 541         remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
 542         serviceUUID = message->remoteEndpoint->resourceUri;
 543     }
 544
 545     uint32_t dataSegmentLength = message->dataLen + CA_HEADER_LENGTH;
 546     uint32_t dataLen = message->dataLen;
 547     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "checking for fragmentation and the dataLen is %d",
 548               message->dataLen);
 549
 550     char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char));
 551     VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Memory allocation failed");
 552
 553     char* dataSegment = (char *) OICCalloc(dataSegmentLength, sizeof(char));
 554     if (NULL == dataSegment)
 555     {
 556         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed");
 557         OICFree(header);
 558         return;
 559     }
 560
 561     CAResult_t result = CAGenerateHeader(header, dataLen);
 562     if (CA_STATUS_OK != result)
 563     {
 564         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed");
 565         OICFree(header);
 566         OICFree(dataSegment);
 567         return ;
 568     }
 569
 570     memcpy(dataSegment, header, CA_HEADER_LENGTH);
 571     OICFree(header);
 572     uint32_t length = 0;
 573     if (CA_SUPPORTED_EDR_MTU_SIZE > dataSegmentLength)
 574     {
 575         length = dataSegmentLength;
 576         memcpy(dataSegment + CA_HEADER_LENGTH, message->data, dataLen);
 577     }
 578     else
 579     {
 580         length =  CA_SUPPORTED_EDR_MTU_SIZE;
 581         memcpy(dataSegment + CA_HEADER_LENGTH, message->data,
 582                CA_SUPPORTED_EDR_MTU_SIZE - CA_HEADER_LENGTH);
 583     }
 584
 585     uint32_t iter = dataSegmentLength / CA_SUPPORTED_EDR_MTU_SIZE;
 586     uint32_t index = 0;
 587     if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID, dataSegment, length,
 588                                             &sentLength))
 589     {
 590         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 591         OICFree(dataSegment);
 592         return;
 593     }
 594     OICFree(dataSegment);
 595
 596     for (index = 1; index < iter; index++)
 597     {
 598         // Send the remaining header.
 599         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending the chunk number [%d]", index);
 600
 601         if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 602                     message->data + ((index * CA_SUPPORTED_EDR_MTU_SIZE) - CA_HEADER_LENGTH),
 603                     CA_SUPPORTED_EDR_MTU_SIZE, &sentLength))
 604         {
 605             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 606             return;
 607         }
 608     }
 609
 610     uint32_t remainingLen = dataSegmentLength % CA_SUPPORTED_EDR_MTU_SIZE;
 611     if (remainingLen &&  (dataSegmentLength > CA_SUPPORTED_EDR_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_EDR_MTU_SIZE) - CA_HEADER_LENGTH,
 617                     remainingLen, &sentLength))
 618         {
 619             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 620             return;
 621         }
 622     }
 623
 624     OIC_LOG(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, data,
 635                                                        dataLength, sentLength))
 636         {
 637             OIC_LOG(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, dataLength,
 645                                                          sentLength))
 646         {
 647             OIC_LOG(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(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 657
 658     CAEDRData *message = (CAEDRData *) context;
 659     if (NULL == message)
 660     {
 661         OIC_LOG(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 (0 == totalDataLen)
 674         {
 675             OIC_LOG(ERROR, 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", totalDataLen);
 680
 681         defragData = (char *) OICMalloc(sizeof(char) * totalDataLen);
 682         if (!defragData)
 683         {
 684             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "defragData is null");
 685             return;
 686         }
 687
 688         const char *remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
 689         const char *serviceUUID = message->remoteEndpoint->resourceUri;
 690
 691         remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress, serviceUUID);
 692
 693         memcpy(defragData + recvDataLen, message->data + CA_HEADER_LENGTH,
 694                message->dataLen - CA_HEADER_LENGTH);
 695         recvDataLen += message->dataLen - CA_HEADER_LENGTH;
 696         g_isHeaderAvailable = true;
 697     }
 698     else
 699     {
 700         memcpy(defragData + recvDataLen, message->data, message->dataLen);
 701         recvDataLen += message->dataLen ;
 702     }
 703
 704     if (totalDataLen == recvDataLen)
 705     {
 706         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 707         g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen);
 708         recvDataLen = 0;
 709         totalDataLen = 0;
 710         remoteEndpoint = NULL;
 711         g_isHeaderAvailable = false;
 712     }
 713
 714     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 715 }
 716
 717 CAResult_t CAAdapterStartQueue()
 718 {
 719     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 720     // Start send queue thread
 721     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 722     {
 723         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 724         CAEDRClientUnsetCallbacks();
 725         //Disconnect all the client connections
 726         CAEDRClientDisconnectAll();
 727         return CA_STATUS_FAILED;
 728     }
 729
 730     // Start receive queue thread
 731     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 732     {
 733         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 734         CAEDRClientUnsetCallbacks();
 735         //Disconnect all the client connections
 736         CAEDRClientDisconnectAll();
 737         return CA_STATUS_FAILED;
 738     }
 739     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 740     return CA_STATUS_OK;
 741 }
 742
 743 CAResult_t CAAdapterStopQueue()
 744 {
 745     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 746     //Stop send queue thread
 747     CAQueueingThreadStop(g_sendQueueHandle);
 748
 749     //Stop receive queue thread
 750     CAQueueingThreadStop(g_recvQueueHandle);
 751     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 752     return CA_STATUS_OK;
 753 }
 754
 755 void CAAdapterRecvData(const char *remoteAddress, const void *data, uint32_t dataLength,
 756                        uint32_t *sentLength)
 757 {
 758     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 759
 760     if (false == g_adapterState)
 761     {
 762         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 763         *sentLength = 0;
 764         return;
 765     }
 766
 767     // Input validation
 768     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 769     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 770
 771     static const char serviceUUID[] = OIC_EDR_SERVICE_ID;
 772     // Create remote endpoint
 773     CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
 774                                                                        serviceUUID);
 775     if (NULL == remoteEndpoint)
 776     {
 777         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 778         return;
 779     }
 780
 781     // Add message to data queue
 782     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 783     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
 784     *sentLength = dataLength;
 785
 786     // Free remote endpoint
 787     CAAdapterFreeRemoteEndpoint(remoteEndpoint);
 788
 789     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 790 }
 791
 792 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const void *data,
 793                              uint32_t dataLength, uint32_t *sentLength)
 794 {
 795     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 796
 797     if (false == g_adapterState)
 798     {
 799         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 800         *sentLength = 0;
 801         return CA_STATUS_OK;
 802     }
 803     // Input validation
 804     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 805     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 806     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 807
 808     // Create remote endpoint
 809     CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
 810                                                                        serviceUUID);
 811     if (NULL == remoteEndpoint)
 812     {
 813         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 814         return CA_STATUS_FAILED;
 815     }
 816
 817     // Add message to data queue
 818     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 819     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof(CAEDRData));
 820     *sentLength = dataLength;
 821
 822     // Free remote endpoint
 823     CAAdapterFreeRemoteEndpoint(remoteEndpoint);
 824
 825     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 826     return CA_STATUS_OK;
 827 }
 828
 829 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 830 {
 831     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 832
 833     // Create localconnectivity
 834     if (NULL == g_localConnectivity)
 835     {
 836         CAEDRGetInterfaceInformation(&g_localConnectivity);
 837     }
 838
 839     if (CA_INTERFACE_UP == status)
 840     {
 841         if (false == g_adapterState)
 842         {
 843             // Get Bluetooth adapter state
 844             bool adapterState = false;
 845             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 846             {
 847                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 848                 return;
 849             }
 850
 851             if (false== adapterState)
 852             {
 853                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 854                 g_adapterState = false;
 855                 return;
 856             }
 857             CAEDRClientSetCallbacks();
 858             g_adapterState = true;
 859             CAAdapterStartQueue();
 860             // starting RFCommServer
 861             if (true == g_serverState)
 862             {
 863                 CAStartServer();
 864                 g_serverState = false;
 865             }
 866         }
 867     }
 868     else
 869     {
 870         g_adapterState = false;
 871     }
 872
 873     // Notify to upper layer
 874     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 875     {
 876         // Add notification task to thread pool
 877         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 878         if (NULL != event)
 879         {
 880             if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
 881                                                         CAEDROnNetworkStatusChanged,event))
 882             {
 883                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 884                 return;
 885             }
 886         }
 887     }
 888
 889     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 890 }
 891
 892 void CAEDROnNetworkStatusChanged(void *context)
 893 {
 894     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 895
 896     if (NULL == context)
 897     {
 898         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 899         return;
 900     }
 901
 902     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 903
 904     // Notify to upper layer
 905     if (g_networkChangeCallback)
 906     {
 907         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 908     }
 909
 910     // Free the created Network event
 911     CAEDRFreeNetworkEvent(networkEvent);
 912
 913     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 914 }
 915
 916 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CALocalConnectivity_t *connectivity,
 917                                            CANetworkStatus_t status)
 918 {
 919     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 920
 921     // Create CAEDRNetworkEvent
 922     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 923     if (NULL == event)
 924     {
 925         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 926         return NULL;
 927     }
 928
 929     // Create duplicate of Local connectivity
 930     event->info = CAAdapterCopyLocalEndpoint(connectivity);
 931     event->status = status;
 932     return event;
 933 }
 934
 935 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 936 {
 937     if (event)
 938     {
 939         CAAdapterFreeLocalEndpoint(event->info);
 940         OICFree(event);
 941     }
 942 }
 943
 944 CAEDRData *CACreateEDRData(const CARemoteEndpoint_t *remoteEndpoint, const void *data,
 945                            uint32_t dataLength)
 946 {
 947     CAEDRData *edrData = (CAEDRData *) OICMalloc(sizeof(CAEDRData));
 948     if (!edrData)
 949     {
 950         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 951         return NULL;
 952     }
 953
 954     edrData->remoteEndpoint = CAAdapterCopyRemoteEndpoint(remoteEndpoint);
 955     edrData->data = OICMalloc(dataLength);
 956     if (NULL == edrData->data)
 957     {
 958         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 959         CAFreeEDRData(edrData);
 960         return NULL;
 961     }
 962     memcpy(edrData->data, data, dataLength);
 963     edrData->dataLen = dataLength;
 964
 965     return edrData;
 966 }
 967
 968 void CAFreeEDRData(CAEDRData *edrData)
 969 {
 970     VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
 971
 972     CAAdapterFreeRemoteEndpoint(edrData->remoteEndpoint);
 973     OICFree(edrData->data);
 974     OICFree(edrData);
 975 }
 976
 977 void CAEDRDataDestroyer(void *data, uint32_t size)
 978 {
 979     CAEDRData *edrdata = (CAEDRData *) data;
 980
 981     CAFreeEDRData(edrdata);
 982 }
 983