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 "cafragmentation.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 CAEndpoint_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(CAEndpoint_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 CAEndpoint_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_ADAPTER_RFCOMM_BTEDR);
 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 CAEndpoint_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->addr))
 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->addr;
 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 CAEndpoint_t *endpoint, 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 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
 316 {
 317     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 318
 319     VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
 320
 321     CAResult_t err = CA_STATUS_OK;
 322     *size = 0;
 323     if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
 324     {
 325         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 326                   "Failed to get local interface information!, error num [%d]", err);
 327         return err;
 328     }
 329
 330     *size = 1;
 331     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 332     return err;
 333 }
 334
 335 CAResult_t CAReadEDRData()
 336 {
 337     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 338
 339     return CAEDRManagerReadData();
 340 }
 341
 342 CAResult_t CAStopEDR()
 343 {
 344     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 345
 346     // Stop RFComm server if it is running
 347     if (-1 != g_serverId)
 348     {
 349         CAEDRServerStop(g_serverId);
 350         g_serverId = -1;
 351     }
 352
 353     // Stop network monitor
 354     CAEDRStopNetworkMonitor();
 355
 356     // Stop the adapter
 357     CAEDRClientUnsetCallbacks();
 358
 359     // Disconnect all the client connections
 360     CAEDRClientDisconnectAll();
 361
 362     // Stop Send and receive Queue
 363     CAAdapterStopQueue();
 364
 365     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 366     return CA_STATUS_OK;
 367 }
 368
 369 void CATerminateEDR()
 370 {
 371     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 372
 373     // Stop EDR adapter
 374     CAStopEDR();
 375     // Terminate EDR Network Monitor
 376     CAEDRTerminateNetworkMonitor();
 377
 378     // Terminate Send/Receive data messages queues
 379     CAAdapterTerminateQueues();
 380
 381     g_networkPacketReceivedCallback = NULL;
 382     g_networkChangeCallback = NULL;
 383
 384     // Terminate thread pool
 385     g_edrThreadPool = NULL;
 386
 387     // Terminate EDR Client
 388     CAEDRClientTerminate();
 389
 390     // Terminate EDR Server
 391     CAEDRServerTerminate();
 392
 393     // Free LocalConnectivity information
 394     CAAdapterFreeEndpoint(g_localConnectivity);
 395     g_localConnectivity = NULL;
 396
 397     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 398 }
 399
 400 CAResult_t CAStartServer()
 401 {
 402     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 403
 404     CAResult_t err = CA_STATUS_OK;
 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     if (-1 < g_serverId)
 415     {
 416         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Server is already in running state.");
 417         return CA_SERVER_STARTED_ALREADY;
 418     }
 419
 420     if (CA_STATUS_OK != (err = CAEDRServerStart(OIC_EDR_SERVICE_ID, &g_serverId, g_edrThreadPool)))
 421     {
 422         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 423                   err);
 424         return err;
 425     }
 426
 427     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 428     return err;
 429 }
 430
 431 CAResult_t CAEDRInitializeQueueHandlers()
 432 {
 433     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 434
 435     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 436         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 437     {
 438         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 439         return CA_STATUS_OK;
 440     }
 441
 442     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 443     return CA_STATUS_FAILED;
 444 }
 445
 446 CAResult_t CAEDRInitializeSendHandler()
 447 {
 448     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 449     // Check if the message queue is already initialized
 450     if (g_sendQueueHandle)
 451     {
 452         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 453         return CA_STATUS_OK;
 454     }
 455
 456     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 457     if (!g_sendQueueHandle)
 458     {
 459         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 460         return CA_MEMORY_ALLOC_FAILED;
 461     }
 462
 463     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 464                                                    CAAdapterDataSendHandler, CAEDRDataDestroyer))
 465     {
 466         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 467         return CA_STATUS_FAILED;
 468     }
 469     return CA_STATUS_OK;
 470 }
 471
 472 CAResult_t CAEDRInitializeReceiveHandler()
 473 {
 474     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 475     // Check if the message queue is already initialized
 476     if (g_recvQueueHandle)
 477     {
 478         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 479         return CA_STATUS_OK;
 480     }
 481
 482     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 483     if (!g_recvQueueHandle)
 484     {
 485         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 486         return CA_MEMORY_ALLOC_FAILED;
 487     }
 488
 489     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 490                                                    CAAdapterDataReceiverHandler,
 491                                                    CAEDRDataDestroyer))
 492     {
 493         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 494         return CA_STATUS_FAILED;
 495     }
 496
 497     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 498     return CA_STATUS_OK;
 499 }
 500
 501 void CAAdapterTerminateQueues()
 502 {
 503     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 504
 505     if (g_sendQueueHandle)
 506     {
 507         CAQueueingThreadDestroy(g_sendQueueHandle);
 508         g_sendQueueHandle = NULL;
 509     }
 510     if (g_recvQueueHandle)
 511     {
 512         CAQueueingThreadDestroy(g_recvQueueHandle);
 513         g_recvQueueHandle = NULL;
 514     }
 515
 516     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 517 }
 518
 519 void CAAdapterDataSendHandler(void *context)
 520 {
 521     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 522
 523     CAEDRData *message = (CAEDRData *) context;
 524     if (NULL == message)
 525     {
 526         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 527         return;
 528     }
 529
 530     const char *remoteAddress = NULL;
 531     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 532     uint32_t sentLength = 0;
 533
 534     if (NULL == message->remoteEndpoint)
 535     {
 536         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 537     }
 538     else
 539     {
 540         remoteAddress = message->remoteEndpoint->addr;
 541     }
 542
 543     uint32_t dataSegmentLength = message->dataLen + CA_HEADER_LENGTH;
 544     uint32_t dataLen = message->dataLen;
 545     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "checking for fragmentation and the dataLen is %d",
 546               message->dataLen);
 547
 548     char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char));
 549     VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Memory allocation failed");
 550
 551     char* dataSegment = (char *) OICCalloc(dataSegmentLength, sizeof(char));
 552     if (NULL == dataSegment)
 553     {
 554         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed");
 555         OICFree(header);
 556         return;
 557     }
 558
 559     CAResult_t result = CAGenerateHeader(header, dataLen);
 560     if (CA_STATUS_OK != result)
 561     {
 562         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed");
 563         OICFree(header);
 564         OICFree(dataSegment);
 565         return ;
 566     }
 567
 568     memcpy(dataSegment, header, CA_HEADER_LENGTH);
 569     OICFree(header);
 570     uint32_t length = 0;
 571     if (CA_SUPPORTED_EDR_MTU_SIZE > dataSegmentLength)
 572     {
 573         length = dataSegmentLength;
 574         memcpy(dataSegment + CA_HEADER_LENGTH, message->data, dataLen);
 575     }
 576     else
 577     {
 578         length =  CA_SUPPORTED_EDR_MTU_SIZE;
 579         memcpy(dataSegment + CA_HEADER_LENGTH, message->data,
 580                CA_SUPPORTED_EDR_MTU_SIZE - CA_HEADER_LENGTH);
 581     }
 582
 583     uint32_t iter = dataSegmentLength / CA_SUPPORTED_EDR_MTU_SIZE;
 584     uint32_t index = 0;
 585     if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID, dataSegment, length,
 586                                             &sentLength))
 587     {
 588         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 589         OICFree(dataSegment);
 590         return;
 591     }
 592     OICFree(dataSegment);
 593
 594     for (index = 1; index < iter; index++)
 595     {
 596         // Send the remaining header.
 597         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending the chunk number [%d]", index);
 598
 599         if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 600                     message->data + ((index * CA_SUPPORTED_EDR_MTU_SIZE) - CA_HEADER_LENGTH),
 601                     CA_SUPPORTED_EDR_MTU_SIZE, &sentLength))
 602         {
 603             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 604             return;
 605         }
 606     }
 607
 608     uint32_t remainingLen = dataSegmentLength % CA_SUPPORTED_EDR_MTU_SIZE;
 609     if (remainingLen &&  (dataSegmentLength > CA_SUPPORTED_EDR_MTU_SIZE))
 610     {
 611         // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200)
 612         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending the last chunk");
 613         if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
 614                     message->data + (index * CA_SUPPORTED_EDR_MTU_SIZE) - CA_HEADER_LENGTH,
 615                     remainingLen, &sentLength))
 616         {
 617             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 618             return;
 619         }
 620     }
 621
 622     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 623 }
 624
 625 CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID,
 626                                const void *data, uint32_t dataLength, uint32_t *sentLength)
 627 {
 628
 629     // Send the first segment with the header.
 630     if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
 631     {
 632         if (CA_STATUS_OK != CAEDRClientSendUnicastData(remoteAddress, serviceUUID, data,
 633                                                        dataLength, sentLength))
 634         {
 635             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
 636             return CA_STATUS_FAILED;
 637         }
 638     }
 639     else
 640     {
 641         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
 642         if (CA_STATUS_OK != CAEDRClientSendMulticastData(serviceUUID, data, dataLength,
 643                                                          sentLength))
 644         {
 645             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
 646             return CA_STATUS_FAILED;
 647         }
 648     }
 649     return CA_STATUS_OK;
 650 }
 651
 652 void CAAdapterDataReceiverHandler(void *context)
 653 {
 654     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 655
 656     CAEDRData *message = (CAEDRData *) context;
 657     if (NULL == message)
 658     {
 659         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 660         return;
 661     }
 662
 663     static uint32_t recvDataLen = 0;
 664     static uint32_t totalDataLen = 0;
 665     static char *defragData = NULL;
 666     static CAEndpoint_t *remoteEndpoint = NULL;
 667
 668     if (!g_isHeaderAvailable)
 669     {
 670         totalDataLen = CAParseHeader((char*)message->data);
 671         if (0 == totalDataLen)
 672         {
 673             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "totalDataLen is zero");
 674             return;
 675         }
 676
 677         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Total data to be accumulated [%d] bytes", totalDataLen);
 678
 679         defragData = (char *) OICMalloc(sizeof(char) * totalDataLen);
 680         if (!defragData)
 681         {
 682             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "defragData is null");
 683             return;
 684         }
 685
 686         const char *remoteAddress = message->remoteEndpoint->addr;
 687         uint16_t port = message->remoteEndpoint->port;
 688
 689         remoteEndpoint = CAAdapterCreateEndpoint(0, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, port);
 690
 691         memcpy(defragData + recvDataLen, message->data + CA_HEADER_LENGTH,
 692                message->dataLen - CA_HEADER_LENGTH);
 693         recvDataLen += message->dataLen - CA_HEADER_LENGTH;
 694         g_isHeaderAvailable = true;
 695     }
 696     else
 697     {
 698         memcpy(defragData + recvDataLen, message->data, message->dataLen);
 699         recvDataLen += message->dataLen ;
 700     }
 701
 702     if (totalDataLen == recvDataLen)
 703     {
 704         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 705         g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen);
 706         recvDataLen = 0;
 707         totalDataLen = 0;
 708         remoteEndpoint = NULL;
 709         g_isHeaderAvailable = false;
 710     }
 711
 712     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 713 }
 714
 715 CAResult_t CAAdapterStartQueue()
 716 {
 717     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 718     // Start send queue thread
 719     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 720     {
 721         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 722         CAEDRClientUnsetCallbacks();
 723         //Disconnect all the client connections
 724         CAEDRClientDisconnectAll();
 725         return CA_STATUS_FAILED;
 726     }
 727
 728     // Start receive queue thread
 729     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 730     {
 731         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 732         CAEDRClientUnsetCallbacks();
 733         //Disconnect all the client connections
 734         CAEDRClientDisconnectAll();
 735         return CA_STATUS_FAILED;
 736     }
 737     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 738     return CA_STATUS_OK;
 739 }
 740
 741 CAResult_t CAAdapterStopQueue()
 742 {
 743     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 744     //Stop send queue thread
 745     CAQueueingThreadStop(g_sendQueueHandle);
 746
 747     //Stop receive queue thread
 748     CAQueueingThreadStop(g_recvQueueHandle);
 749     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 750     return CA_STATUS_OK;
 751 }
 752
 753 void CAAdapterRecvData(const char *remoteAddress, const void *data, uint32_t dataLength,
 754                        uint32_t *sentLength)
 755 {
 756     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 757
 758     if (false == g_adapterState)
 759     {
 760         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 761         *sentLength = 0;
 762         return;
 763     }
 764
 765     // Input validation
 766     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 767     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 768
 769     // Create remote endpoint
 770     CAEndpoint_t *remoteEndpoint = CAAdapterCreateEndpoint(0,
 771                                                         CA_ADAPTER_RFCOMM_BTEDR,
 772                                                         remoteAddress,
 773                                                         0);
 774     if (NULL == remoteEndpoint)
 775     {
 776         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 777         return;
 778     }
 779
 780     // Add message to data queue
 781     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 782     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
 783     *sentLength = dataLength;
 784
 785     // Free remote endpoint
 786     CAAdapterFreeEndpoint(remoteEndpoint);
 787
 788     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 789 }
 790
 791 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const void *data,
 792                              uint32_t dataLength, uint32_t *sentLength)
 793 {
 794     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 795
 796     if (false == g_adapterState)
 797     {
 798         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 799         *sentLength = 0;
 800         return CA_STATUS_OK;
 801     }
 802     // Input validation
 803     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 804     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 805     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 806
 807     // Create remote endpoint
 808     CAEndpoint_t *remoteEndpoint = CAAdapterCreateEndpoint(0, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, 0);
 809     if (NULL == remoteEndpoint)
 810     {
 811         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 812         return CA_STATUS_FAILED;
 813     }
 814
 815     // Add message to data queue
 816     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 817     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
 818     *sentLength = dataLength;
 819
 820     // Free remote endpoint
 821     CAAdapterFreeEndpoint(remoteEndpoint);
 822
 823     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 824     return CA_STATUS_OK;
 825 }
 826
 827 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 828 {
 829     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 830
 831     // Create localconnectivity
 832     if (NULL == g_localConnectivity)
 833     {
 834         CAEDRGetInterfaceInformation(&g_localConnectivity);
 835     }
 836
 837     if (CA_INTERFACE_UP == status)
 838     {
 839         if (false == g_adapterState)
 840         {
 841             // Get Bluetooth adapter state
 842             bool adapterState = false;
 843             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 844             {
 845                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 846                 return;
 847             }
 848
 849             if (false== adapterState)
 850             {
 851                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 852                 g_adapterState = false;
 853                 return;
 854             }
 855             CAEDRClientSetCallbacks();
 856             g_adapterState = true;
 857             CAAdapterStartQueue();
 858             // starting RFCommServer
 859             if (true == g_serverState)
 860             {
 861                 CAStartServer();
 862                 g_serverState = false;
 863             }
 864         }
 865     }
 866     else
 867     {
 868         g_adapterState = false;
 869     }
 870
 871     // Notify to upper layer
 872     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 873     {
 874         // Add notification task to thread pool
 875         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 876         if (NULL != event)
 877         {
 878             if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
 879                                                         CAEDROnNetworkStatusChanged,event))
 880             {
 881                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 882                 return;
 883             }
 884         }
 885     }
 886
 887     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 888 }
 889
 890 void CAEDROnNetworkStatusChanged(void *context)
 891 {
 892     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 893
 894     if (NULL == context)
 895     {
 896         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 897         return;
 898     }
 899
 900     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 901
 902     // Notify to upper layer
 903     if (g_networkChangeCallback)
 904     {
 905         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 906     }
 907
 908     // Free the created Network event
 909     CAEDRFreeNetworkEvent(networkEvent);
 910
 911     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 912 }
 913
 914 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
 915                                            CANetworkStatus_t status)
 916 {
 917     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 918
 919     // Create CAEDRNetworkEvent
 920     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 921     if (NULL == event)
 922     {
 923         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 924         return NULL;
 925     }
 926
 927     // Create duplicate of Local connectivity
 928     event->info = CAAdapterCloneEndpoint(connectivity);
 929     event->status = status;
 930     return event;
 931 }
 932
 933 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 934 {
 935     if (event)
 936     {
 937         CAAdapterFreeEndpoint(event->info);
 938         OICFree(event);
 939     }
 940 }
 941
 942 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
 943                                         const void *data, uint32_t dataLength)
 944 {
 945     CAEDRData *edrData = (CAEDRData *)OICMalloc(sizeof (CAEDRData));
 946     if (!edrData)
 947     {
 948         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 949         return NULL;
 950     }
 951
 952     edrData->remoteEndpoint = CAAdapterCloneEndpoint(remoteEndpoint);
 953
 954     edrData->data = OICMalloc(dataLength);
 955     if (NULL == edrData->data)
 956     {
 957         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 958         CAFreeEDRData(edrData);
 959         return NULL;
 960     }
 961     memcpy(edrData->data, data, dataLength);
 962     edrData->dataLen = dataLength;
 963
 964     return edrData;
 965 }
 966
 967 void CAFreeEDRData(CAEDRData *edrData)
 968 {
 969     VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
 970
 971     CAAdapterFreeEndpoint(edrData->remoteEndpoint);
 972     OICFree(edrData->data);
 973     OICFree(edrData);
 974 }
 975
 976 void CAEDRDataDestroyer(void *data, uint32_t size)
 977 {
 978     CAEDRData *edrdata = (CAEDRData *) data;
 979
 980     CAFreeEDRData(edrdata);
 981 }
 982