resource/csdk/connectivity/src/bt_le_adapter/caleadapter.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 #include "caleadapter.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include "cafragmentation.h"
  26
  27 #include "caleinterface.h"
  28 #include "cacommon.h"
  29 #include "octhread.h"
  30 #include "caadapterutils.h"
  31 #ifdef __WITH_DTLS__
  32 #include "ca_adapter_net_ssl.h"
  33 #endif
  34 #ifndef SINGLE_THREAD
  35 #include "caqueueingthread.h"
  36 #endif
  37 #if defined(__TIZEN__) || defined(__ANDROID__)
  38 #include "caleserver.h"
  39 #include "caleclient.h"
  40 #endif
  41 #include "oic_malloc.h"
  42 #include "oic_string.h"
  43 #include "caremotehandler.h"
  44 #include <coap/pdu.h>
  45
  46 /**
  47  * Logging tag for module name.
  48  */
  49 #define CALEADAPTER_TAG "OIC_CA_LE_ADAP"
  50
  51 /**
  52  * Stores information of all the senders.
  53  *
  54  * This structure will be used to track and defragment all incoming data packet.
  55  */
  56 typedef struct
  57 {
  58     uint32_t recvDataLen;
  59     uint32_t totalDataLen;
  60     uint8_t *defragData;
  61     CAEndpoint_t *remoteEndpoint;
  62     uint8_t refCount;
  63 } CABLESenderInfo_t;
  64
  65 typedef enum
  66 {
  67     ADAPTER_EMPTY = 1,
  68     ADAPTER_BOTH_CLIENT_SERVER,
  69     ADAPTER_CLIENT,
  70     ADAPTER_SERVER
  71 } CABLEAdapter_t;
  72
  73 /**
  74  * mtu size to use in fragmentation logic.
  75  * default value is 20 byte.
  76  */
  77 static uint16_t g_mtuSize = CA_DEFAULT_BLE_MTU_SIZE;
  78
  79 /**
  80  * Callback to provide the status of the network change to CA layer.
  81  */
  82 static CAAdapterChangeCallback g_networkCallback = NULL;
  83
  84 /**
  85  * Callback to provide the status of the connection change to CA layer.
  86  */
  87 static CAConnectionChangeCallback g_connectionCallback = NULL;
  88
  89 /**
  90  * Own port value to identify packet owner. Default port value is 1.
  91  */
  92 static uint8_t g_localBLESourcePort = 1;
  93
  94 /**
  95  * bleAddress of the local adapter. Value will be initialized to zero,
  96  * and will be updated later.
  97  */
  98 static char g_localBLEAddress[18] = { 0 };
  99
 100 /**
 101  * Variable to differentiate btw GattServer and GattClient.
 102  */
 103 static CABLEAdapter_t g_adapterType = ADAPTER_EMPTY;
 104
 105 #ifdef __WITH_DTLS__
 106 static CADataType_t g_dataType = CA_REQUEST_DATA;
 107 #endif
 108
 109 /**
 110  * Mutex to synchronize the task to be executed on the GattServer
 111  * function calls.
 112  */
 113 static oc_mutex g_bleIsServerMutex = NULL;
 114
 115 /**
 116  * Mutex to synchronize the updates of the local LE address of the
 117  * adapter.
 118  */
 119 static oc_mutex g_bleLocalAddressMutex = NULL;
 120
 121 /**
 122  * Reference to thread pool.
 123  */
 124 static ca_thread_pool_t g_bleAdapterThreadPool = NULL;
 125
 126 /**
 127  * Mutex to synchronize the queing of the data from ReceiverQueue.
 128  */
 129 static oc_mutex g_bleClientReceiveDataMutex = NULL;
 130
 131 /**
 132  * Mutex to synchronize the queing of the data from ReceiverQueue.
 133  */
 134 static oc_mutex g_bleServerReceiveDataMutex = NULL;
 135
 136 /**
 137  * Callback to be called when network packet received from either
 138  * GattServer or GattClient.
 139  */
 140 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
 141
 142 /**
 143  * Callback to notify error from the BLE adapter.
 144  */
 145 static CAErrorHandleCallback g_errorHandler = NULL;
 146
 147 #ifdef __WITH_DTLS__
 148 static CAResult_t CALESecureReceiveDataCB(const CASecureEndpoint_t *endpoint,
 149                                  const void *data, size_t dataLength);
 150
 151 static ssize_t CALESecureSendDataCB(CAEndpoint_t *endpoint,
 152                              const void *data, size_t dataLength);
 153 #endif
 154
 155 #ifdef SINGLE_THREAD
 156 /**
 157  * Pointer to defragment received data from single threaded routine.
 158  */
 159 static CABLESenderInfo_t *g_singleThreadReceiveData = NULL;
 160
 161 /**
 162  * This function will be associated with the receive for single thread.
 163  *
 164  * This function will defragment the received data from sender
 165  * respectively and will send it up to CA layer. Respective sender's
 166  * header will provide the length of the data sent.
 167  *
 168  * @param[in] data       Actual data received from the remote
 169  *                       device.
 170  * @param[in] dataLen    Length of the data received from the
 171  *                       remote device.
 172  */
 173 static void CALEDataReceiverHandlerSingleThread(const uint8_t *data,
 174                                                 uint32_t dataLen);
 175
 176 /**
 177  * This function will be associated with the send for single threaded
 178  * GattServer.
 179  *
 180  * This function will fragment the data to the MTU of the transport
 181  * and send the data in fragments to the adapters. The function will
 182  * be blocked until all data is sent out from the adapter.
 183  *
 184  * @param[in] data       Data to be transmitted from LE.
 185  * @param[in] dataLen    Length of the Data being transmitted.
 186  */
 187 static CAResult_t CALEServerSendDataSingleThread(const uint8_t *data,
 188                                                  uint32_t dataLen);
 189 #endif
 190
 191 /**
 192  * Register network change notification callback.
 193  *
 194  * @param[in]  netCallback  CAAdapterChangeCallback callback which will
 195  *                          be set for the change in adapter.
 196  * @param[in]  connCallback CAConnectionChangeCallback callback which will
 197  *                          be set for the change in connection.
 198  *
 199  * @return  0 on success otherwise a positive error value.
 200  * @retval  ::CA_STATUS_OK  Successful.
 201  * @retval  ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 202  * @retval  ::CA_STATUS_FAILED Operation failed.
 203  *
 204  */
 205 static CAResult_t CALERegisterNetworkNotifications(CAAdapterChangeCallback netCallback,
 206                                                    CAConnectionChangeCallback connCallback);
 207
 208 /**
 209  * Set the thread pool handle which is required for spawning new
 210  * thread.
 211  *
 212  * @param[in] handle Thread pool handle which is given by above layer
 213  *                   for using thread creation task.
 214  *
 215  */
 216 static void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle);
 217
 218 /**
 219  * Call the callback to the upper layer when the adapter state gets
 220  * changed.
 221  *
 222  * @param[in] adapter_state New state of the adapter to be notified to
 223  *                          the upper layer.
 224  */
 225 static void CALEDeviceStateChangedCb(CAAdapterState_t adapter_state);
 226
 227 /**
 228  * Call the callback to the upper layer when the device connection state gets
 229  * changed.
 230  *
 231  * @param[in] address      LE address of the device to be notified to the upper layer.
 232  * @param[in] isConnected  whether connection state is connected or not.
 233  */
 234 static void CALEConnectionStateChangedCb(CATransportAdapter_t adapter, const char* address,
 235                                          bool isConnected);
 236
 237 /**
 238  * Used to initialize all required mutex variable for LE Adapter
 239  * implementation.
 240  *
 241  * @return  0 on success otherwise a positive error value.
 242  * @retval  ::CA_STATUS_OK  Successful.
 243  * @retval  ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 244  * @retval  ::CA_STATUS_FAILED Operation failed.
 245  *
 246  */
 247 static CAResult_t CAInitLEAdapterMutex();
 248
 249 /**
 250  * Terminate all required mutex variables for LE adapter
 251  * implementation.
 252  */
 253 static void CATerminateLEAdapterMutex();
 254
 255 /**
 256  * Prepares and notify error through error callback.
 257  */
 258 static void CALEErrorHandler(const char *remoteAddress,
 259                              const uint8_t *data,
 260                              uint32_t dataLen,
 261                              CAResult_t result);
 262
 263 #ifndef SINGLE_THREAD
 264 /**
 265  * Stop condition of Server recvhandler.
 266  */
 267 static bool g_dataBleServerReceiverHandlerState = false;
 268
 269 /**
 270  * Stop condition of Client recvhandler.
 271  */
 272 static bool g_dataBleClientReceiverHandlerState = false;
 273
 274 /**
 275  * Sender information of Server.
 276  */
 277 static u_arraylist_t *g_bleServerSenderInfo = NULL;
 278
 279 /**
 280  * Sender information of Client.
 281  */
 282 static u_arraylist_t *g_bleClientSenderInfo = NULL;
 283
 284 /**
 285  * Mutex to synchronize access to all senderInfos
 286  */
 287 static oc_mutex g_senderInfoMutex = NULL;
 288
 289 /**
 290  * Queue to process the outgoing packets from GATTServer.
 291  */
 292 static CAQueueingThread_t *g_bleServerSendQueueHandle = NULL;
 293
 294 /**
 295  * Queue to process the outgoing packets from GATTClient.
 296  */
 297 static CAQueueingThread_t *g_bleClientSendQueueHandle = NULL;
 298
 299 /**
 300  * Queue to process the incoming packets from GATTServer.
 301  */
 302 static CAQueueingThread_t *g_bleServerReceiverQueue = NULL;
 303
 304 /**
 305  * Queue to process the incoming packets from GATTClient.
 306  */
 307 static CAQueueingThread_t *g_bleClientReceiverQueue = NULL;
 308
 309 /**
 310  * This function will be associated with the sender queue for
 311  * GattServer.
 312  *
 313  * This function will fragment the data to the MTU of the transport
 314  * and send the data in fragments to the adapters. The function will
 315  * be blocked until all data is sent out from the adapter.
 316  *
 317  * @param[in] threadData Data pushed to the queue which contains the
 318  *                       info about RemoteEndpoint and Data.
 319  */
 320 static void CALEServerSendDataThread(void *threadData);
 321
 322 /**
 323  * This function will be associated with the sender queue for
 324  * GattClient.
 325  *
 326  * This function will fragment the data to the MTU of the transport
 327  * and send the data in fragments to the adapters. The function will
 328  * be blocked until all data is sent out from the adapter.
 329  *
 330  * @param[in] threadData Data pushed to the queue which contains the
 331  *                       info about RemoteEndpoint and Data.
 332  */
 333 static void CALEClientSendDataThread(void *threadData);
 334
 335 /**
 336  * This function will defragment the received data from each sender
 337  * respectively and will send it up to CA layer.  Respective sender's
 338  * header will provide the length of the data sent.
 339  *
 340  * @param[in] threadData   Data pushed to the queue which contains the
 341  *                         info about RemoteEndpoint and Data.
 342  * @param[in] receiverType Whether receiver is server or client.
 343  */
 344 static void CALEDataReceiverHandler(void *threadData, CABLEAdapter_t receiverType);
 345
 346 /**
 347  * This function will be associated with the receiver queue for
 348  * GattServer.
 349  *
 350  * This function will call the function CALEDataReceiverHandler()
 351  * with server type to defragment the received data.
 352  *
 353  * @param[in] threadData Data pushed to the queue which contains the
 354  *                       info about RemoteEndpoint and Data.
 355  */
 356 static void CALEServerDataReceiverHandler(void *threadData);
 357
 358 /**
 359  * This function will be associated with the receiver queue for
 360  * GattClient.
 361  *
 362  * This function will call the function CALEDataReceiverHandler()
 363  * with client type to defragment the received data.
 364  *
 365  * @param[in] threadData Data pushed to the queue which contains the
 366  *                       info about RemoteEndpoint and Data.
 367  */
 368 static void CALEClientDataReceiverHandler(void *threadData);
 369
 370 /**
 371  * This function will stop all queues created for GattServer and
 372  * GattClient. All four queues will be be stopped with this function
 373  * invocations.
 374  */
 375 static void CAStopLEQueues();
 376
 377 /**
 378  * This function will terminate all queues created for GattServer and
 379  * GattClient. All four queues will be be terminated with this
 380  * function invocations.
 381  */
 382 static void CATerminateLEQueues();
 383
 384 /**
 385  * This function will initalize the Receiver and Sender queues for
 386  * GattServer. This function will in turn call the functions
 387  * CAInitBleServerReceiverQueue() and CAInitBleServerSenderQueue() to
 388  * initialize the queues.
 389  *
 390  * @return ::CA_STATUS_OK or Appropriate error code.
 391  * @retval ::CA_STATUS_OK  Successful.
 392  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 393  * @retval ::CA_STATUS_FAILED Operation failed.
 394  */
 395 static CAResult_t CAInitLEServerQueues();
 396
 397 /**
 398  * This function will initalize the Receiver and Sender queues for
 399  * GattClient. This function will inturn call the functions
 400  * CAInitBleClientReceiverQueue() and CAInitBleClientSenderQueue() to
 401  * initialize the queues.
 402  *
 403  * @return ::CA_STATUS_OK or Appropriate error code.
 404  * @retval ::CA_STATUS_OK  Successful.
 405  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 406  * @retval ::CA_STATUS_FAILED Operation failed.
 407  *
 408  */
 409 static CAResult_t CAInitLEClientQueues();
 410
 411 /**
 412  * This function will initalize the Receiver queue for
 413  * GattServer. This will initialize the queue to process the function
 414  * CABLEServerSendDataThread() when ever the task is added to this
 415  * queue.
 416  *
 417  * @return ::CA_STATUS_OK or Appropriate error code.
 418  * @retval ::CA_STATUS_OK  Successful.
 419  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 420  * @retval ::CA_STATUS_FAILED Operation failed.
 421  */
 422 static CAResult_t CAInitLEServerSenderQueue();
 423
 424 /**
 425  * This function will initalize the Receiver queue for
 426  * GattClient. This will initialize the queue to process the function
 427  * CABLEClientSendDataThread() when ever the task is added to this
 428  * queue.
 429  *
 430  * @return ::CA_STATUS_OK or Appropriate error code.
 431  * @retval ::CA_STATUS_OK  Successful.
 432  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 433  * @retval ::CA_STATUS_FAILED Operation failed.
 434  */
 435 static CAResult_t CAInitLEClientSenderQueue();
 436
 437 /**
 438  * This function will initialize the Receiver queue for
 439  * GattServer. This will initialize the queue to process the function
 440  * CALEServerDataReceiverHandler() when ever the task is added to this
 441  * queue.
 442  *
 443  * @return ::CA_STATUS_OK or Appropriate error code
 444  * @retval ::CA_STATUS_OK  Successful
 445  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments
 446  * @retval ::CA_STATUS_FAILED Operation failed
 447  *
 448  */
 449 static CAResult_t CAInitLEServerReceiverQueue();
 450
 451 /**
 452  * This function will initialize the Receiver queue for
 453  * GattClient. This will initialize the queue to process the function
 454  * CALEClientDataReceiverHandler() when ever the task is added to this
 455  * queue.
 456  *
 457  * @return ::CA_STATUS_OK or Appropriate error code
 458  * @retval ::CA_STATUS_OK  Successful
 459  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments
 460  * @retval ::CA_STATUS_FAILED Operation failed
 461  *
 462  */
 463 static CAResult_t CAInitLEClientReceiverQueue();
 464
 465 /**
 466  * This function will create the Data required to send it in the
 467  * queue.
 468  *
 469  * @param[in] remoteEndpoint Remote endpoint information of the
 470  *                           server.
 471  * @param[in] data           Data to be transmitted from LE.
 472  * @param[in] dataLength     Length of the Data being transmitted.
 473  *
 474  * @return ::CA_STATUS_OK or Appropriate error code.
 475  * @retval ::CA_STATUS_OK  Successful.
 476  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
 477  * @retval ::CA_STATUS_FAILED Operation failed.
 478  */
 479 static CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint,
 480                                   const uint8_t *data,
 481                                   uint32_t dataLength,
 482                                   u_arraylist_t *senderInfo);
 483
 484 /**
 485  * Used to free the BLE information stored in the sender/receiver
 486  * queues.
 487  *
 488  * @param[in] bleData Information for a particular data segment.
 489  */
 490 static void CAFreeLEData(CALEData_t *bleData);
 491
 492 /**
 493  * Free data.
 494  */
 495 static void CALEDataDestroyer(void *data, uint32_t size);
 496
 497 #ifndef SINGLE_THREAD
 498 /**
 499  * remove request or response data of send queue.
 500  *
 501  * @param[in] queueHandle    queue to process the outgoing packets.
 502  * @param[in] mutex          mutex related to sender for client / server.
 503  * @param[in] address        target address to remove data in queue.
 504  */
 505 static void CALERemoveSendQueueData(CAQueueingThread_t *queueHandle,
 506                                     const char* address);
 507
 508 /**
 509  * remove all received data of data list from receive queue.
 510  *
 511  * @param[in] dataInfoList   received data list to remove for client / server.
 512  * @param[in] address        target address to remove data in queue.
 513  */
 514 static void CALERemoveReceiveQueueData(u_arraylist_t *dataInfoList,
 515                                        const char* address);
 516
 517 /**
 518  * get received data info and positioned index from the received data list
 519  * for client / server which is matched same leAddress and port.
 520  * CABLESenderInfo_t is reference counted structure, you must call
 521  * CALEFreeSenderInfo on senderInfo to release reference.
 522  *
 523  * @param[in]  leAddress       target address to get serderInfo.
 524  * @param[in]  port            target port to get senderInfo.
 525  * @param[in]  senderInfoList  received data list for client / server.
 526  * @param[out] senderInfo      Pointer to contain matched(leAddress and port)
 527  *                             received data info.
 528  * @param[out] senderIndex     Pointer to contain matched(leAddress and port)
 529  *                             received data info index.
 530  */
 531 static CAResult_t CALEGetSenderInfo(const char *leAddress,
 532                                     const uint16_t port,
 533                                     u_arraylist_t *senderInfoList,
 534                                     CABLESenderInfo_t **senderInfo,
 535                                     uint32_t *senderIndex);
 536
 537 /**
 538  * Add sender info to list.
 539  *
 540  * @param[in] u_arraylist_t   Array list to add sender info to.
 541  * @param[in] senderInfo      Sender info to be added to list.
 542  *
 543  * @return true on success, otherwise false.
 544  */
 545 static bool CALEAddSenderInfoToList(u_arraylist_t *senderInfoList,
 546                                           CABLESenderInfo_t *senderInfo);
 547
 548 /**
 549  * Remove desired sender info from list.
 550  *
 551  * @param[in] u_arraylist_t   Array list to remove sender info from.
 552  * @param[in] senderInfo      Sender info to be removed from list.
 553  *
 554  */
 555 static void CALERemoveSenderInfoFromList(u_arraylist_t *senderInfoList,
 556                                          CABLESenderInfo_t *senderInfo);
 557
 558 /**
 559  * Free sender info. CABLESenderInfo_t is reference counted structure
 560  * and info will be freed only when reference count reaches 0 or negative.
 561  *
 562  * @param[in] senderInfo      Sender info to be freed.
 563  *
 564  */
 565 static CAResult_t CALEFreeSenderInfo(CABLESenderInfo_t *senderInfo);
 566
 567 /**
 568  * get ports related to remote address. It is need because multi application
 569  * can have more than 2 senderInfo using same BLE address. So before remove
 570  * receive queue data, should get port list from sender Info.
 571  *
 572  * @param[in]  leAddress       target address to get port in serderInfo.
 573  * @param[in]  senderInfoList  received data list to remove for client / server.
 574  * @param[out] portList        target port list related to leAddress.
 575  */
 576 static CAResult_t CALEGetPortsFromSenderInfo(const char *leAddress,
 577                                             u_arraylist_t *senderInfoList,
 578                                             u_arraylist_t *portList);
 579 #endif
 580
 581 static CAResult_t CAInitLEServerQueues()
 582 {
 583     CAResult_t result = CAInitLEServerSenderQueue();
 584     if (CA_STATUS_OK != result)
 585     {
 586         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleServerSenderQueue failed");
 587
 588         return CA_STATUS_FAILED;
 589     }
 590
 591     g_bleServerSenderInfo = u_arraylist_create();
 592     if (!g_bleServerSenderInfo)
 593     {
 594         OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
 595         return CA_MEMORY_ALLOC_FAILED;
 596     }
 597
 598     result = CAInitLEServerReceiverQueue();
 599     if (CA_STATUS_OK != result)
 600     {
 601         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEServerReceiverQueue failed");
 602         u_arraylist_free(&g_bleServerSenderInfo);
 603         return CA_STATUS_FAILED;
 604     }
 605
 606     g_dataBleServerReceiverHandlerState = true;
 607     return CA_STATUS_OK;
 608 }
 609
 610 static CAResult_t CAInitLEClientQueues()
 611 {
 612     CAResult_t result = CAInitLEClientSenderQueue();
 613     if (CA_STATUS_OK != result)
 614     {
 615         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleClientSenderQueue failed");
 616         return CA_STATUS_FAILED;
 617     }
 618
 619     g_bleClientSenderInfo = u_arraylist_create();
 620     if (!g_bleClientSenderInfo)
 621     {
 622         OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
 623         return CA_MEMORY_ALLOC_FAILED;
 624     }
 625
 626     result = CAInitLEClientReceiverQueue();
 627     if (CA_STATUS_OK != result)
 628     {
 629         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEClientReceiverQueue failed");
 630         u_arraylist_free(&g_bleClientSenderInfo);
 631         return CA_STATUS_FAILED;
 632     }
 633
 634     g_dataBleClientReceiverHandlerState = true;
 635
 636     return CA_STATUS_OK;
 637 }
 638
 639 static CAResult_t CAInitLEServerReceiverQueue()
 640 {
 641     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
 642     // Check if the message queue is already initialized
 643     if (g_bleServerReceiverQueue)
 644     {
 645         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!");
 646         return CA_STATUS_OK;
 647     }
 648
 649     // Create recv message queue
 650     g_bleServerReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 651     if (!g_bleServerReceiverQueue)
 652     {
 653         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
 654         return CA_MEMORY_ALLOC_FAILED;
 655     }
 656
 657     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerReceiverQueue,
 658                                                    g_bleAdapterThreadPool,
 659                                                    CALEServerDataReceiverHandler,
 660                                                    CALEDataDestroyer))
 661     {
 662         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize server receiver queue thread");
 663         OICFree(g_bleServerReceiverQueue);
 664         g_bleServerReceiverQueue = NULL;
 665         return CA_STATUS_FAILED;
 666     }
 667
 668     if (CA_STATUS_OK != CAQueueingThreadStart(g_bleServerReceiverQueue))
 669     {
 670         OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed ");
 671         OICFree(g_bleServerReceiverQueue);
 672         g_bleServerReceiverQueue = NULL;
 673         return CA_STATUS_FAILED;
 674     }
 675
 676     return CA_STATUS_OK;
 677 }
 678
 679 static CAResult_t CAInitLEClientReceiverQueue()
 680 {
 681     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
 682     // Check if the message queue is already initialized
 683     if (g_bleClientReceiverQueue)
 684     {
 685         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!");
 686         return CA_STATUS_OK;
 687     }
 688
 689     // Create recv message queue
 690     g_bleClientReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 691     if (!g_bleClientReceiverQueue)
 692     {
 693         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
 694         return CA_MEMORY_ALLOC_FAILED;
 695     }
 696
 697     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientReceiverQueue,
 698                                                    g_bleAdapterThreadPool,
 699                                                    CALEClientDataReceiverHandler,
 700                                                    CALEDataDestroyer))
 701     {
 702         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize client receiver queue thread");
 703         OICFree(g_bleClientReceiverQueue);
 704         g_bleClientReceiverQueue = NULL;
 705         return CA_STATUS_FAILED;
 706     }
 707
 708     if (CA_STATUS_OK != CAQueueingThreadStart(g_bleClientReceiverQueue))
 709     {
 710         OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed ");
 711         OICFree(g_bleClientReceiverQueue);
 712         g_bleClientReceiverQueue = NULL;
 713         return CA_STATUS_FAILED;
 714     }
 715
 716     return CA_STATUS_OK;
 717 }
 718
 719 static CAResult_t CAInitLEServerSenderQueue()
 720 {
 721     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
 722     // Check if the message queue is already initialized
 723     if (g_bleServerSendQueueHandle)
 724     {
 725         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Queue is already initialized!");
 726         return CA_STATUS_OK;
 727     }
 728
 729     // Create send message queue
 730     g_bleServerSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 731     if (!g_bleServerSendQueueHandle)
 732     {
 733         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
 734         return CA_MEMORY_ALLOC_FAILED;
 735     }
 736
 737     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerSendQueueHandle,
 738                                                    g_bleAdapterThreadPool,
 739                                                    CALEServerSendDataThread,
 740                                                    CALEDataDestroyer))
 741     {
 742         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread");
 743         OICFree(g_bleServerSendQueueHandle);
 744         g_bleServerSendQueueHandle = NULL;
 745         return CA_STATUS_FAILED;
 746     }
 747
 748     return CA_STATUS_OK;
 749 }
 750
 751 static void CALEClearSenderInfoImpl(u_arraylist_t **list)
 752 {
 753     oc_mutex_lock(g_senderInfoMutex);
 754     const size_t length = u_arraylist_length(*list);
 755     for (size_t i = 0; i < length; ++i)
 756     {
 757         CABLESenderInfo_t * const info =
 758                 (CABLESenderInfo_t *) u_arraylist_get(*list, i);
 759         if (info)
 760          {
 761              OICFree(info->defragData);
 762              CAFreeEndpoint(info->remoteEndpoint);
 763              OICFree(info);
 764          }
 765     }
 766     u_arraylist_free(list);
 767     oc_mutex_unlock(g_senderInfoMutex);
 768 }
 769
 770 static void CALEClearSenderInfo()
 771 {
 772     CALEClearSenderInfoImpl(&g_bleServerSenderInfo);
 773     CALEClearSenderInfoImpl(&g_bleClientSenderInfo);
 774 }
 775
 776 static CAResult_t CAInitLEClientSenderQueue()
 777 {
 778     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
 779
 780     if (g_bleClientSendQueueHandle)
 781     {
 782         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!");
 783         return CA_STATUS_OK;
 784     }
 785
 786     // Create send message queue
 787     g_bleClientSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 788     if (!g_bleClientSendQueueHandle)
 789     {
 790         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
 791         return CA_MEMORY_ALLOC_FAILED;
 792     }
 793
 794     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientSendQueueHandle,
 795                                                    g_bleAdapterThreadPool,
 796                                                    CALEClientSendDataThread, CALEDataDestroyer))
 797     {
 798         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread");
 799         OICFree(g_bleClientSendQueueHandle);
 800         g_bleClientSendQueueHandle = NULL;
 801         return CA_STATUS_FAILED;
 802     }
 803     return CA_STATUS_OK;
 804 }
 805
 806 static void CAStopLEQueues()
 807 {
 808     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
 809
 810     oc_mutex_lock(g_bleServerReceiveDataMutex);
 811     if (NULL != g_bleServerReceiverQueue)
 812     {
 813         CAQueueingThreadStop(g_bleServerReceiverQueue);
 814     }
 815     oc_mutex_unlock(g_bleServerReceiveDataMutex);
 816
 817     oc_mutex_lock(g_bleClientReceiveDataMutex);
 818     if (NULL != g_bleClientReceiverQueue)
 819     {
 820         CAQueueingThreadStop(g_bleClientReceiverQueue);
 821     }
 822     oc_mutex_unlock(g_bleClientReceiveDataMutex);
 823
 824     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
 825 }
 826
 827 static void CATerminateLEQueues()
 828 {
 829     CAQueueingThreadDestroy(g_bleClientSendQueueHandle);
 830     OICFree(g_bleClientSendQueueHandle);
 831     g_bleClientSendQueueHandle = NULL;
 832
 833     CAQueueingThreadDestroy(g_bleServerSendQueueHandle);
 834     OICFree(g_bleServerSendQueueHandle);
 835     g_bleServerSendQueueHandle = NULL;
 836
 837     CAQueueingThreadDestroy(g_bleServerReceiverQueue);
 838     OICFree(g_bleServerReceiverQueue);
 839     g_bleServerReceiverQueue = NULL;
 840
 841     CAQueueingThreadDestroy(g_bleClientReceiverQueue);
 842     OICFree(g_bleClientReceiverQueue);
 843     g_bleClientReceiverQueue = NULL;
 844
 845     CALEClearSenderInfo();
 846 }
 847
 848 static CAResult_t CALEGetSenderInfo(const char *leAddress,
 849                                     const uint16_t port,
 850                                     u_arraylist_t *senderInfoList,
 851                                     CABLESenderInfo_t **senderInfo,
 852                                     uint32_t *senderIndex)
 853 {
 854     VERIFY_NON_NULL_RET(leAddress,
 855                         CALEADAPTER_TAG,
 856                         "NULL BLE address argument",
 857                         CA_STATUS_INVALID_PARAM);
 858     VERIFY_NON_NULL_RET(senderIndex,
 859                         CALEADAPTER_TAG,
 860                         "NULL index argument",
 861                         CA_STATUS_INVALID_PARAM);
 862
 863     oc_mutex_lock(g_senderInfoMutex);
 864     const uint32_t listLength = u_arraylist_length(senderInfoList);
 865     const uint32_t addrLength = strlen(leAddress);
 866     for (uint32_t index = 0; index < listLength; index++)
 867     {
 868         CABLESenderInfo_t *info = (CABLESenderInfo_t *) u_arraylist_get(senderInfoList, index);
 869         if (!info || !(info->remoteEndpoint))
 870         {
 871             continue;
 872         }
 873
 874         if (!strncmp(info->remoteEndpoint->addr, leAddress, addrLength)
 875             && info->remoteEndpoint->port == port)
 876         {
 877             *senderIndex = index;
 878             if (senderInfo)
 879             {
 880                 *senderInfo = info;
 881                 (*senderInfo)->refCount++;
 882             }
 883             oc_mutex_unlock(g_senderInfoMutex);
 884             return CA_STATUS_OK;
 885         }
 886     }
 887
 888     oc_mutex_unlock(g_senderInfoMutex);
 889     return CA_STATUS_FAILED;
 890 }
 891
 892 static bool CALEAddSenderInfoToList(u_arraylist_t *senderInfoList, CABLESenderInfo_t *senderInfo)
 893 {
 894     oc_mutex_lock(g_senderInfoMutex);
 895     senderInfo->refCount++;
 896     if (!u_arraylist_add(senderInfoList,(void *)senderInfo))
 897     {
 898         senderInfo->refCount--;
 899         oc_mutex_unlock(g_senderInfoMutex);
 900         return false;
 901     }
 902     oc_mutex_unlock(g_senderInfoMutex);
 903     return true;
 904 }
 905
 906 static void CALERemoveSenderInfoFromList(u_arraylist_t *senderInfoList, CABLESenderInfo_t *senderInfo)
 907 {
 908     oc_mutex_lock(g_senderInfoMutex);
 909     uint32_t idx;
 910     bool elemFound = u_arraylist_get_index(senderInfoList, (const void*)senderInfo, &idx);
 911     if(elemFound)
 912     {
 913         void *info = u_arraylist_remove(senderInfoList, idx);
 914         if (info != NULL)
 915         {
 916             senderInfo->refCount--;
 917         }
 918     }
 919     oc_mutex_unlock(g_senderInfoMutex);
 920 }
 921
 922 static CAResult_t CALEFreeSenderInfo(CABLESenderInfo_t *senderInfo)
 923 {
 924     VERIFY_NON_NULL_RET(senderInfo,
 925                         CALEADAPTER_TAG,
 926                         "NULL senderInfo to remove argument",
 927                         CA_STATUS_INVALID_PARAM);
 928
 929     oc_mutex_lock(g_senderInfoMutex);
 930     senderInfo->refCount--;
 931     if(senderInfo->refCount <= 0)
 932     {
 933         OICFree(senderInfo->defragData);
 934         OICFree(senderInfo->remoteEndpoint);
 935         OICFree(senderInfo);
 936     }
 937     oc_mutex_unlock(g_senderInfoMutex);
 938     return CA_STATUS_OK;
 939 }
 940
 941 static void CALEDataReceiverHandler(void *threadData, CABLEAdapter_t receiverType)
 942 {
 943     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
 944
 945     oc_mutex bleReceiveDataMutex = NULL;
 946     bool dataBleReceiverHandlerState = false;
 947
 948     switch (receiverType)
 949     {
 950         case ADAPTER_CLIENT:
 951             bleReceiveDataMutex = g_bleClientReceiveDataMutex;
 952             dataBleReceiverHandlerState = g_dataBleClientReceiverHandlerState;
 953             break;
 954         case ADAPTER_SERVER:
 955             bleReceiveDataMutex = g_bleServerReceiveDataMutex;
 956             dataBleReceiverHandlerState = g_dataBleServerReceiverHandlerState;
 957             break;
 958         default:
 959             OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Unsupported receiver type : %d", receiverType);
 960             return;
 961     }
 962
 963     oc_mutex_lock(bleReceiveDataMutex);
 964
 965     if (dataBleReceiverHandlerState)
 966     {
 967         CALEData_t *bleData = (CALEData_t *) threadData;
 968         if (!bleData)
 969         {
 970             OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bleData!");
 971             oc_mutex_unlock(bleReceiveDataMutex);
 972             return;
 973         }
 974
 975         if (!(bleData->senderInfo))
 976         {
 977             OIC_LOG(ERROR, CALEADAPTER_TAG, "sender info is not available");
 978             oc_mutex_unlock(bleReceiveDataMutex);
 979             return;
 980         }
 981
 982         if (!(bleData->remoteEndpoint))
 983         {
 984             OIC_LOG(ERROR, CALEADAPTER_TAG, "RemoteEndPoint NULL!!");
 985             oc_mutex_unlock(bleReceiveDataMutex);
 986             return;
 987         }
 988
 989         CABLESenderInfo_t *senderInfo = NULL;
 990         uint32_t senderIndex = 0;
 991
 992         //packet parsing
 993         CABLEPacketStart_t startFlag = CA_BLE_PACKET_NOT_START;
 994         CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
 995         uint16_t sourcePort = 0;
 996         uint16_t destPort = 0;
 997
 998         CAParseHeader(bleData->data, &startFlag, &sourcePort, &secureFlag, &destPort);
 999         OIC_LOG_V(INFO, CALEADAPTER_TAG,
1000                   "header info: startFlag[%X] sourcePort[%d] secureFlag[%X] destPort[%d]",
1001                   startFlag, sourcePort, secureFlag, destPort);
1002
1003         if (destPort != g_localBLESourcePort && destPort != CA_BLE_MULTICAST_PORT)
1004         {
1005             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1006                       "this packet is not valid for this app(port mismatch[mine:%d, packet:%d])",
1007                       g_localBLESourcePort, destPort);
1008             oc_mutex_unlock(bleReceiveDataMutex);
1009             return;
1010         }
1011
1012         bleData->remoteEndpoint->port = sourcePort;
1013
1014         if (CA_STATUS_OK != CALEGetSenderInfo(bleData->remoteEndpoint->addr,
1015                                               bleData->remoteEndpoint->port,
1016                                               bleData->senderInfo,
1017                                               &senderInfo, &senderIndex))
1018         {
1019             OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This is a new client [%s:%X]",
1020                       bleData->remoteEndpoint->addr, bleData->remoteEndpoint->port);
1021         }
1022         else
1023         {
1024             if (startFlag)
1025             {
1026                 OIC_LOG(ERROR, CALEADAPTER_TAG,
1027                         "This packet is start packet but exist senderInfo. Remove senderInfo");
1028                 CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
1029                 CALEFreeSenderInfo(senderInfo);
1030                 senderInfo = NULL;
1031                 senderIndex = 0;
1032             }
1033         }
1034
1035         if (!senderInfo)
1036         {
1037             uint32_t totalLength = 0;
1038             if (startFlag)
1039             {
1040                 CAParseHeaderPayloadLength(bleData->data, CA_BLE_LENGTH_HEADER_SIZE, &totalLength);
1041             }
1042             else
1043             {
1044                 OIC_LOG(ERROR, CALEADAPTER_TAG, "This packet is wrong packet! ignore.");
1045                 oc_mutex_unlock(bleReceiveDataMutex);
1046                 return;
1047             }
1048
1049             CABLESenderInfo_t *newSender = OICCalloc(1, sizeof(CABLESenderInfo_t));
1050             if (!newSender)
1051             {
1052                 OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed for new sender");
1053                 oc_mutex_unlock(bleReceiveDataMutex);
1054                 return;
1055             }
1056
1057             OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header");
1058
1059             newSender->totalDataLen = totalLength;
1060             if (!(newSender->totalDataLen))
1061             {
1062                 OIC_LOG(ERROR, CALEADAPTER_TAG, "Total Data Length is parsed as 0!!!");
1063                 CALEFreeSenderInfo(newSender);
1064                 oc_mutex_unlock(bleReceiveDataMutex);
1065                 return;
1066             }
1067
1068             size_t dataOnlyLen =
1069                 bleData->dataLen - (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE);
1070             OIC_LOG_V(INFO, CALEADAPTER_TAG, "Total data to be accumulated [%u] bytes",
1071                       newSender->totalDataLen);
1072             OIC_LOG_V(INFO, CALEADAPTER_TAG, "data received in the first packet [%zu] bytes",
1073                       dataOnlyLen);
1074
1075             newSender->defragData = OICCalloc(newSender->totalDataLen + 1,
1076                                               sizeof(*newSender->defragData));
1077
1078             if (NULL == newSender->defragData)
1079             {
1080                 OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!");
1081                 CALEFreeSenderInfo(newSender);
1082                 oc_mutex_unlock(bleReceiveDataMutex);
1083                 return;
1084             }
1085             CATransportFlags_t flags = CA_DEFAULT_FLAGS;
1086 #ifdef __WITH_DTLS__
1087             if (CA_BLE_PACKET_SECURE == secureFlag)
1088             {
1089                 flags |= CA_SECURE;
1090             }
1091 #endif
1092
1093             const char *remoteAddress = bleData->remoteEndpoint->addr;
1094             newSender->remoteEndpoint = CACreateEndpointObject(flags,
1095                                                                CA_ADAPTER_GATT_BTLE,
1096                                                                remoteAddress,
1097                                                                bleData->remoteEndpoint->port);
1098
1099             if (NULL == newSender->remoteEndpoint)
1100             {
1101                 OIC_LOG(ERROR, CALEADAPTER_TAG, "remoteEndpoint is NULL!");
1102                 CALEFreeSenderInfo(newSender);
1103                 oc_mutex_unlock(bleReceiveDataMutex);
1104                 return;
1105             }
1106
1107             if (newSender->recvDataLen + dataOnlyLen > newSender->totalDataLen)
1108             {
1109                 OIC_LOG(ERROR, CALEADAPTER_TAG, "buffer is smaller than received data");
1110                 CALEFreeSenderInfo(newSender);
1111                 oc_mutex_unlock(bleReceiveDataMutex);
1112                 return;
1113             }
1114             memcpy(newSender->defragData,
1115                    bleData->data + (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE),
1116                    dataOnlyLen);
1117             newSender->recvDataLen += dataOnlyLen;
1118
1119             newSender->refCount = 1;
1120
1121             if (!CALEAddSenderInfoToList(bleData->senderInfo, newSender))
1122             {
1123                 OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to add sender info!");
1124                 CALEFreeSenderInfo(newSender);
1125                 oc_mutex_unlock(bleReceiveDataMutex);
1126                 return;
1127             }
1128
1129             senderInfo = newSender;
1130         }
1131         else
1132         {
1133             size_t dataOnlyLen = bleData->dataLen - CA_BLE_HEADER_SIZE;
1134             if (senderInfo->recvDataLen + dataOnlyLen > senderInfo->totalDataLen)
1135             {
1136                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1137                           "Data Length exceeding error!! Receiving [%zu] total length [%u]",
1138                           senderInfo->recvDataLen + dataOnlyLen, senderInfo->totalDataLen);
1139                 CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
1140                 CALEFreeSenderInfo(senderInfo);
1141                 oc_mutex_unlock(bleReceiveDataMutex);
1142                 return;
1143             }
1144             OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%zu]",
1145                       dataOnlyLen);
1146             memcpy(senderInfo->defragData + senderInfo->recvDataLen,
1147                    bleData->data + CA_BLE_HEADER_SIZE,
1148                    dataOnlyLen);
1149             senderInfo->recvDataLen += dataOnlyLen;
1150             OIC_LOG_V(INFO, CALEADAPTER_TAG, "totalDatalength  [%d] received Datalen [%d]",
1151                       senderInfo->totalDataLen, senderInfo->recvDataLen);
1152         }
1153
1154         if (senderInfo->totalDataLen == senderInfo->recvDataLen)
1155         {
1156             if (NULL == g_networkPacketReceivedCallback)
1157             {
1158                 OIC_LOG(ERROR, CALEADAPTER_TAG, "gReqRespCallback is NULL!");
1159                 CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
1160                 CALEFreeSenderInfo(senderInfo);
1161                 oc_mutex_unlock(bleReceiveDataMutex);
1162                 return;
1163             }
1164
1165             OIC_LOG(DEBUG, CALEADAPTER_TAG, "[CALEDataReceiverHandler] Received data up !");
1166
1167             const CASecureEndpoint_t tmp =
1168                 {
1169                     .endpoint = *senderInfo->remoteEndpoint
1170                 };
1171
1172             OIC_LOG_V(INFO, CALEADAPTER_TAG, "endpoint flags : %d", tmp.endpoint.flags);
1173 #ifdef __WITH_DTLS__
1174             if (CA_SECURE & tmp.endpoint.flags)
1175             {
1176                 OIC_LOG(DEBUG, CALEADAPTER_TAG, "Secure data received");
1177                 switch (receiverType)
1178                 {
1179                     case ADAPTER_CLIENT:
1180                         g_dataType = CA_REQUEST_DATA;
1181                         break;
1182                     case ADAPTER_SERVER:
1183                         g_dataType = CA_RESPONSE_DATA;
1184                         break;
1185                     default:
1186                         OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Unsupported rcvr type:%d",receiverType);
1187                         CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
1188                         senderInfo->remoteEndpoint = NULL;
1189                         senderInfo->defragData = NULL;
1190                         CALEFreeSenderInfo(senderInfo);
1191                         oc_mutex_unlock(bleReceiveDataMutex);
1192                         return;
1193                 }
1194
1195                 if (CA_STATUS_FAILED == CAdecryptSsl(&tmp,
1196                                                 senderInfo->defragData,
1197                                                 senderInfo->recvDataLen))
1198                 {
1199                     OIC_LOG(ERROR, CALEADAPTER_TAG, "CAdecryptSsl failed");
1200                 }
1201                 else
1202                 {
1203                     OIC_LOG(DEBUG, CALEADAPTER_TAG, "CAdecryptSsl successed");
1204                 }
1205                 OICFree(senderInfo->defragData);
1206             }
1207             else
1208             {
1209 #endif
1210                 OIC_LOG(INFO, CALEADAPTER_TAG, "Non-Secure data received");
1211                 g_networkPacketReceivedCallback(&tmp,
1212                                                 senderInfo->defragData,
1213                                                 senderInfo->recvDataLen);
1214 #ifdef __WITH_DTLS__
1215             }
1216 #endif
1217
1218             CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
1219             senderInfo->remoteEndpoint = NULL;
1220             senderInfo->defragData = NULL;
1221             CALEFreeSenderInfo(senderInfo);
1222             oc_mutex_unlock(bleReceiveDataMutex);
1223             return;
1224         }
1225         CALEFreeSenderInfo(senderInfo);
1226     }
1227     oc_mutex_unlock(bleReceiveDataMutex);
1228 }
1229
1230
1231 static void CALEServerDataReceiverHandler(void *threadData)
1232 {
1233     CALEDataReceiverHandler(threadData, ADAPTER_SERVER);
1234 }
1235
1236 static void CALEClientDataReceiverHandler(void *threadData)
1237 {
1238     CALEDataReceiverHandler(threadData, ADAPTER_CLIENT);
1239 }
1240
1241 static void CALEServerSendDataThread(void *threadData)
1242 {
1243     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
1244
1245     CALEData_t * const bleData = (CALEData_t *) threadData;
1246     if (!bleData)
1247     {
1248         OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid bledata!");
1249         return;
1250     }
1251
1252     if (!bleData->remoteEndpoint)
1253     {
1254         OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid endpoint of bledata!");
1255         return;
1256     }
1257
1258 #if defined(__TIZEN__) || defined(__ANDROID__)
1259     // get MTU size
1260     g_mtuSize = CALEServerGetMtuSize(bleData->remoteEndpoint->addr);
1261 #endif
1262     OIC_LOG_V(INFO, CALEADAPTER_TAG, "MTU size [%d]", g_mtuSize);
1263
1264     uint32_t midPacketCount = 0;
1265     size_t remainingLen = 0;
1266     size_t totalLength = 0;
1267     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
1268
1269     CAResult_t result = CAGenerateVariableForFragmentation(bleData->dataLen,
1270                                                            &midPacketCount,
1271                                                            &remainingLen,
1272                                                            &totalLength,
1273                                                            g_mtuSize);
1274
1275     if (CA_STATUS_OK != result)
1276     {
1277         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1278                   "CAGenerateVariableForFragmentation failed, result [%d]", result);
1279         if (g_errorHandler)
1280         {
1281             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1282         }
1283         return;
1284     }
1285
1286     OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
1287               "Packet info: data size[%d] midPacketCount[%u] remainingLen[%zu] totalLength[%zu]",
1288               bleData->dataLen, midPacketCount, remainingLen, totalLength);
1289
1290     OIC_LOG_V(DEBUG,
1291               CALEADAPTER_TAG,
1292               "Server total Data length with header is [%zu]",
1293               totalLength);
1294
1295     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
1296     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
1297
1298     if (NULL != bleData->remoteEndpoint) //Unicast Data
1299     {
1300         secureFlag = (bleData->remoteEndpoint->flags & CA_SECURE) ?
1301             CA_BLE_PACKET_SECURE : CA_BLE_PACKET_NON_SECURE;
1302
1303         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This Packet is secure? %d", secureFlag);
1304         result = CAGenerateHeader(dataHeader,
1305                                   CA_BLE_PACKET_START,
1306                                   g_localBLESourcePort,
1307                                   secureFlag,
1308                                   bleData->remoteEndpoint->port);
1309     }
1310     else                                //Multicast Data
1311     {
1312         result = CAGenerateHeader(dataHeader,
1313                                   CA_BLE_PACKET_START,
1314                                   g_localBLESourcePort,
1315                                   secureFlag,
1316                                   CA_BLE_MULTICAST_PORT);
1317     }
1318     OIC_LOG_V(INFO, CALEADAPTER_TAG, "header info: secureFlag[%X]", secureFlag);
1319
1320     if (CA_STATUS_OK != result)
1321     {
1322         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1323                   "CAGenerateHeader failed, result [%d]", result);
1324         if (g_errorHandler)
1325         {
1326             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1327         }
1328         return;
1329     }
1330
1331     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
1332     result = CAGenerateHeaderPayloadLength(lengthHeader,
1333                                            CA_BLE_LENGTH_HEADER_SIZE,
1334                                            bleData->dataLen);
1335
1336     if (CA_STATUS_OK != result)
1337     {
1338         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1339                   "CAGenerateHeaderPayloadLength failed, result [%d]", result);
1340         if (g_errorHandler)
1341         {
1342             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1343         }
1344         return;
1345     }
1346
1347     uint32_t length = 0;
1348     uint32_t dataLen = 0;
1349     if (g_mtuSize > totalLength)
1350     {
1351         length = (uint32_t)totalLength;
1352         dataLen = bleData->dataLen;
1353     }
1354     else
1355     {
1356         length = g_mtuSize;
1357         dataLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
1358     }
1359
1360     result = CAMakeFirstDataSegment(dataSegment,
1361                                     bleData->data, dataLen,
1362                                     dataHeader, lengthHeader);
1363
1364     if (CA_STATUS_OK != result)
1365     {
1366         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1367                   "Making data segment failed, result [%d]", result);
1368         if (g_errorHandler)
1369         {
1370             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1371         }
1372         return;
1373     }
1374
1375     const uint32_t iter = midPacketCount;
1376     uint32_t index = 0;
1377
1378     // Send the first segment with the header.
1379     if (NULL != bleData->remoteEndpoint) // Sending Unicast Data
1380     {
1381         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Server Sending Unicast Data");
1382
1383         result = CAUpdateCharacteristicsToGattClient(
1384                     bleData->remoteEndpoint->addr, dataSegment, length);
1385
1386         if (CA_STATUS_OK != result)
1387         {
1388             OIC_LOG_V(ERROR,
1389                       CALEADAPTER_TAG,
1390                       "Update characteristics failed, result [%d]",
1391                       result);
1392             if (g_errorHandler)
1393             {
1394                 g_errorHandler(bleData->remoteEndpoint,
1395                                bleData->data,
1396                                bleData->dataLen,
1397                                result);
1398             }
1399             return;
1400         }
1401
1402         OIC_LOG_V(DEBUG,
1403                   CALEADAPTER_TAG,
1404                   "Server Sent Unicast First Data - data length [%u]",
1405                   length);
1406
1407         result = CAGenerateHeader(dataHeader,
1408                                   CA_BLE_PACKET_NOT_START,
1409                                   g_localBLESourcePort,
1410                                   secureFlag,
1411                                   bleData->remoteEndpoint->port);
1412
1413         if (CA_STATUS_OK != result)
1414         {
1415             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1416                       "CAGenerateHeader failed, result [%d]", result);
1417             if (g_errorHandler)
1418             {
1419                 g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1420             }
1421             return;
1422         }
1423
1424         for (index = 0; index < iter; index++)
1425         {
1426             // Send the remaining header.
1427             result = CAMakeRemainDataSegment(dataSegment,
1428                                              g_mtuSize - CA_BLE_HEADER_SIZE,
1429                                              bleData->data,
1430                                              bleData->dataLen,
1431                                              index,
1432                                              dataHeader,
1433                                              g_mtuSize);
1434
1435             if (CA_STATUS_OK != result)
1436             {
1437                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1438                             "Making data segment failed, result [%d]", result);
1439                 if (g_errorHandler)
1440                 {
1441                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1442                 }
1443                 return;
1444             }
1445
1446             result =
1447                 CAUpdateCharacteristicsToGattClient(
1448                     bleData->remoteEndpoint->addr,
1449                     dataSegment,
1450                     g_mtuSize);
1451
1452             if (CA_STATUS_OK != result)
1453             {
1454                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1455                             "Update characteristics failed, result [%d]", result);
1456                 if (g_errorHandler)
1457                 {
1458                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1459                 }
1460                 return;
1461             }
1462             OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]",
1463                                                g_mtuSize);
1464         }
1465
1466         if (remainingLen && (totalLength > g_mtuSize))
1467         {
1468             // send the last segment of the data (Ex: 22 bytes of 622
1469             // bytes of data when MTU is 200)
1470             result = CAMakeRemainDataSegment(dataSegment,
1471                                              remainingLen,
1472                                              bleData->data,
1473                                              bleData->dataLen,
1474                                              index,
1475                                              dataHeader,
1476                                              g_mtuSize);
1477
1478             if (CA_STATUS_OK != result)
1479             {
1480                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1481                             "Making data segment failed, result [%d]", result);
1482                 if (g_errorHandler)
1483                 {
1484                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1485                 }
1486                 return;
1487             }
1488
1489             result = CAUpdateCharacteristicsToGattClient(
1490                          bleData->remoteEndpoint->addr,
1491                          dataSegment,
1492                          remainingLen + CA_BLE_HEADER_SIZE);
1493
1494             if (CA_STATUS_OK != result)
1495             {
1496                 OIC_LOG_V(ERROR,
1497                           CALEADAPTER_TAG,
1498                           "Update characteristics failed, result [%d]",
1499                           result);
1500                 if (g_errorHandler)
1501                 {
1502                     g_errorHandler(bleData->remoteEndpoint,
1503                                    bleData->data,
1504                                    bleData->dataLen,
1505                                    result);
1506                 }
1507                 return;
1508             }
1509             OIC_LOG_V(DEBUG,
1510                       CALEADAPTER_TAG,
1511                       "Server Sent Unicast Last Data - data length [%zu]",
1512                       remainingLen + CA_BLE_HEADER_SIZE);
1513         }
1514      }
1515     else
1516     {
1517         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Server Sending Multicast data");
1518         OIC_LOG(DEBUG, CALEADAPTER_TAG, "BLE Multicast is not supported");
1519     }
1520
1521     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
1522 }
1523
1524 static void CALEClientSendDataThread(void *threadData)
1525 {
1526     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
1527
1528     CALEData_t *bleData = (CALEData_t *) threadData;
1529     if (!bleData)
1530     {
1531         OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid bledata!");
1532         return;
1533     }
1534
1535     if (!bleData->remoteEndpoint)
1536     {
1537         OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid endpoint of bledata!");
1538         return;
1539     }
1540
1541 #if defined(__ANDROID__)
1542     // get MTU size
1543     if (false == CALEClientIsConnected(bleData->remoteEndpoint->addr))
1544     {
1545         // triggering to gatt connect and MTU negotiation
1546         CAResult_t res = CALEClientSendNegotiationMessage(
1547                 bleData->remoteEndpoint->addr);
1548
1549         if (CA_STATUS_OK != res)
1550         {
1551             OIC_LOG_V(ERROR,
1552                       CALEADAPTER_TAG,
1553                       "CALEClientSendNegotiationMessage has failed, result [%d]",
1554                       res);
1555             if (g_errorHandler)
1556             {
1557                 g_errorHandler(bleData->remoteEndpoint,
1558                                bleData->data,
1559                                bleData->dataLen,
1560                                res);
1561             }
1562             return;
1563         }
1564     }
1565 #endif
1566 #if defined(__TIZEN__) || defined(__ANDROID__)
1567     g_mtuSize = CALEClientGetMtuSize(bleData->remoteEndpoint->addr);
1568 #endif
1569     OIC_LOG_V(INFO, CALEADAPTER_TAG, "MTU size [%d]", g_mtuSize);
1570
1571     uint32_t midPacketCount = 0;
1572     size_t remainingLen = 0;
1573     size_t totalLength = 0;
1574     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
1575
1576     CAResult_t result = CAGenerateVariableForFragmentation(bleData->dataLen,
1577                                                            &midPacketCount,
1578                                                            &remainingLen,
1579                                                            &totalLength,
1580                                                            g_mtuSize);
1581
1582     if (CA_STATUS_OK != result)
1583     {
1584         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1585                   "CAGenerateVariableForFragmentation failed, result [%d]", result);
1586         if (g_errorHandler)
1587         {
1588             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1589         }
1590         return;
1591     }
1592
1593     OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
1594               "Packet info: data size[%d] midPacketCount[%u] remainingLen[%zu] totalLength[%zu]",
1595               bleData->dataLen, midPacketCount, remainingLen, totalLength);
1596
1597     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
1598     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
1599
1600     if (NULL != bleData->remoteEndpoint) //Unicast Data
1601     {
1602         secureFlag = (bleData->remoteEndpoint->flags & CA_SECURE) ?
1603             CA_BLE_PACKET_SECURE : CA_BLE_PACKET_NON_SECURE;
1604
1605         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This Packet is secure? %d", secureFlag);
1606         result = CAGenerateHeader(dataHeader,
1607                                   CA_BLE_PACKET_START,
1608                                   g_localBLESourcePort,
1609                                   secureFlag,
1610                                   bleData->remoteEndpoint->port);
1611     }
1612     else                                //Multicast Data
1613     {
1614         result = CAGenerateHeader(dataHeader,
1615                                   CA_BLE_PACKET_START,
1616                                   g_localBLESourcePort,
1617                                   secureFlag,
1618                                   CA_BLE_MULTICAST_PORT);
1619     }
1620
1621     OIC_LOG_V(INFO, CALEADAPTER_TAG, "header info: secureFlag[%X]", secureFlag);
1622
1623     if (CA_STATUS_OK != result)
1624     {
1625         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1626                   "CAGenerateHeader failed, result [%d]", result);
1627         if (g_errorHandler)
1628         {
1629             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1630         }
1631         return;
1632     }
1633
1634     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
1635     result = CAGenerateHeaderPayloadLength(lengthHeader,
1636                                            CA_BLE_LENGTH_HEADER_SIZE,
1637                                            bleData->dataLen);
1638
1639     if (CA_STATUS_OK != result)
1640     {
1641         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1642                   "CAGenerateHeaderPayloadLength failed, result [%d]", result);
1643         if (g_errorHandler)
1644         {
1645             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1646         }
1647         return;
1648     }
1649
1650     uint32_t length = 0;
1651     uint32_t dataLen = 0;
1652     if (g_mtuSize > totalLength)
1653     {
1654         length = (uint32_t)totalLength;
1655         dataLen = bleData->dataLen;
1656     }
1657     else
1658     {
1659         length = g_mtuSize;
1660         dataLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
1661     }
1662
1663     result = CAMakeFirstDataSegment(dataSegment,
1664                                     bleData->data, dataLen,
1665                                     dataHeader, lengthHeader);
1666
1667     if (CA_STATUS_OK != result)
1668     {
1669         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1670                   "Making data segment failed, result [%d]", result);
1671         if (g_errorHandler)
1672         {
1673             g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1674         }
1675         return;
1676     }
1677
1678     const uint32_t iter = midPacketCount;
1679     uint32_t index = 0;
1680     if (NULL != bleData->remoteEndpoint) //Sending Unicast Data
1681     {
1682         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending Unicast Data");
1683         // Send the first segment with the header.
1684         result =
1685             CAUpdateCharacteristicsToGattServer(
1686                 bleData->remoteEndpoint->addr,
1687                 dataSegment,
1688                 length,
1689                 LE_UNICAST,
1690                 0);
1691
1692         if (CA_STATUS_OK != result)
1693         {
1694             OIC_LOG_V(ERROR,
1695                       CALEADAPTER_TAG,
1696                       "Update characteristics failed, result [%d]",
1697                       result);
1698             if (g_errorHandler)
1699             {
1700                 g_errorHandler(bleData->remoteEndpoint,
1701                                bleData->data,
1702                                bleData->dataLen,
1703                                result);
1704             }
1705             return;
1706         }
1707         OIC_LOG_V(DEBUG,
1708                   CALEADAPTER_TAG,
1709                   "Client Sent Unicast First Data - data length [%u]",
1710                   length);
1711
1712         result = CAGenerateHeader(dataHeader,
1713                                   CA_BLE_PACKET_NOT_START,
1714                                   g_localBLESourcePort,
1715                                   secureFlag,
1716                                   bleData->remoteEndpoint->port);
1717
1718         if (CA_STATUS_OK != result)
1719         {
1720             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1721                       "CAGenerateHeader failed, result [%d]", result);
1722             if (g_errorHandler)
1723             {
1724                 g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1725             }
1726             return;
1727         }
1728
1729         for (index = 0; index < iter; index++)
1730         {
1731             result = CAMakeRemainDataSegment(dataSegment,
1732                                              g_mtuSize - CA_BLE_HEADER_SIZE,
1733                                              bleData->data,
1734                                              bleData->dataLen,
1735                                              index,
1736                                              dataHeader,
1737                                              g_mtuSize);
1738
1739             if (CA_STATUS_OK != result)
1740             {
1741                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1742                             "Making data segment failed, result [%d]", result);
1743                 if (g_errorHandler)
1744                 {
1745                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1746                 }
1747                 return;
1748             }
1749
1750             // Send the remaining header.
1751             result = CAUpdateCharacteristicsToGattServer(
1752                      bleData->remoteEndpoint->addr,
1753                      dataSegment,
1754                      g_mtuSize,
1755                      LE_UNICAST, 0);
1756
1757             if (CA_STATUS_OK != result)
1758             {
1759                 OIC_LOG_V(ERROR,
1760                           CALEADAPTER_TAG,
1761                           "Update characteristics failed, result [%d]",
1762                           result);
1763                 if (g_errorHandler)
1764                 {
1765                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1766                 }
1767                 return;
1768             }
1769             OIC_LOG_V(DEBUG,
1770                       CALEADAPTER_TAG,
1771                       "Client Sent Unicast %d Data - data(mtu) length [%hu]",
1772                       index + 1,
1773                       g_mtuSize);
1774         }
1775
1776         if (remainingLen && (totalLength > g_mtuSize))
1777         {
1778             // send the last segment of the data (Ex: 22 bytes of 622
1779             // bytes of data when MTU is 200)
1780             result = CAMakeRemainDataSegment(dataSegment,
1781                                              remainingLen,
1782                                              bleData->data,
1783                                              bleData->dataLen,
1784                                              index,
1785                                              dataHeader,
1786                                              g_mtuSize);
1787
1788             if (CA_STATUS_OK != result)
1789             {
1790                 OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1791                             "Making data segment failed, result [%d]", result);
1792                 if (g_errorHandler)
1793                 {
1794                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1795                 }
1796                 return;
1797             }
1798
1799             result = CAUpdateCharacteristicsToGattServer(
1800                      bleData->remoteEndpoint->addr,
1801                      dataSegment,
1802                      remainingLen + CA_BLE_HEADER_SIZE,
1803                      LE_UNICAST, 0);
1804
1805             if (CA_STATUS_OK != result)
1806             {
1807                 OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
1808                                                    result);
1809                 if (g_errorHandler)
1810                 {
1811                     g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
1812                 }
1813                 return;
1814             }
1815             OIC_LOG_V(DEBUG,
1816                       CALEADAPTER_TAG,
1817                       "Client Sent Unicast Last Data - data length [%zu]",
1818                       remainingLen + CA_BLE_HEADER_SIZE);
1819         }
1820     }
1821     else
1822     {
1823         //Sending Mulitcast Data
1824         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Client Sending Multicast Data");
1825         OIC_LOG(DEBUG, CALEADAPTER_TAG, "BLE Multicast is not supported");
1826     }
1827
1828     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
1829 }
1830
1831 static CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint,
1832                                   const uint8_t *data,
1833                                   uint32_t dataLength,
1834                                   u_arraylist_t *senderInfo)
1835 {
1836     CALEData_t * const bleData = OICMalloc(sizeof(CALEData_t));
1837
1838     if (!bleData)
1839     {
1840         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
1841         return NULL;
1842     }
1843
1844     bleData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
1845     bleData->data = OICCalloc(dataLength + 1, 1);
1846
1847     if (NULL == bleData->data)
1848     {
1849         OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
1850         CAFreeLEData(bleData);
1851         return NULL;
1852     }
1853
1854     memcpy(bleData->data, data, dataLength);
1855     bleData->dataLen = dataLength;
1856     if (senderInfo)
1857     {
1858         bleData->senderInfo = senderInfo;
1859     }
1860
1861     return bleData;
1862 }
1863
1864 static void CAFreeLEData(CALEData_t *bleData)
1865 {
1866     VERIFY_NON_NULL_VOID(bleData, CALEADAPTER_TAG, "Param bleData is NULL");
1867
1868     CAFreeEndpoint(bleData->remoteEndpoint);
1869     OICFree(bleData->data);
1870     OICFree(bleData);
1871 }
1872
1873 static void CALEDataDestroyer(void *data, uint32_t size)
1874 {
1875     if ((size_t)size < sizeof(CALEData_t *))
1876     {
1877         OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
1878                   "Destroy data too small %p %d", data, size);
1879     }
1880     CALEData_t *ledata = (CALEData_t *) data;
1881
1882     CAFreeLEData(ledata);
1883 }
1884 #endif
1885
1886 #ifdef SINGLE_THREAD
1887 static void CALEDataReceiverHandlerSingleThread(const uint8_t *data,
1888                                                 uint32_t dataLen)
1889 {
1890     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
1891
1892     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
1893
1894     //packet parsing
1895     CABLEPacketStart_t startFlag = CA_BLE_PACKET_NOT_START;
1896     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
1897     uint16_t sourcePort = 0;
1898     uint16_t destPort = 0;
1899
1900     CAParseHeader(data, &startFlag, &sourcePort, &secureFlag, &destPort);
1901     OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
1902               "header info: startFlag[%X] sourcePort[%d] secureFlag[%X] destPort[%d]",
1903               startFlag, sourcePort, secureFlag, destPort);
1904
1905     if (destPort != g_localBLESourcePort && destPort != CA_BLE_MULTICAST_PORT)
1906     {
1907         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1908                   "this packet is not valid for this app(port mismatch[mine:%d, packet:%d])",
1909                   g_localBLESourcePort, destPort);
1910         return;
1911     }
1912
1913     if (startFlag)
1914     {
1915         if (g_singleThreadReceiveData)
1916         {
1917             OIC_LOG(ERROR, CALEADAPTER_TAG,
1918                     "This packet is start packet but exist senderInfo. Remove senderInfo");
1919             OICFree(g_singleThreadReceiveData->defragData);
1920             OICFree(g_singleThreadReceiveData);
1921             g_singleThreadReceiveData = NULL;
1922         }
1923
1924         uint32_t totalLength = 0;
1925         CAParseHeaderPayloadLength(data, CA_BLE_LENGTH_HEADER_SIZE, &totalLength);
1926
1927         g_singleThreadReceiveData = OICMalloc(sizeof(CABLESenderInfo_t));
1928
1929         if (!g_singleThreadReceiveData)
1930         {
1931             OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed for new sender");
1932             return;
1933         }
1934         g_singleThreadReceiveData->recvDataLen = 0;
1935         g_singleThreadReceiveData->totalDataLen = 0;
1936         g_singleThreadReceiveData->defragData = NULL;
1937         g_singleThreadReceiveData->remoteEndpoint = NULL;
1938
1939         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header");
1940
1941         g_singleThreadReceiveData->totalDataLen = totalLength;
1942
1943         if (!(g_singleThreadReceiveData->totalDataLen))
1944         {
1945             OIC_LOG(ERROR, CALEADAPTER_TAG, "Total Data Length is parsed as 0!!!");
1946             OICFree(g_singleThreadReceiveData);
1947             return;
1948         }
1949
1950         size_t dataOnlyLen = dataLen - (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE);
1951         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Total data to be accumulated [%u] bytes",
1952                   g_singleThreadReceiveData->totalDataLen);
1953         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "data received in the first packet [%u] bytes",
1954                   dataOnlyLen);
1955
1956         g_singleThreadReceiveData->defragData =
1957             OICCalloc(g_singleThreadReceiveData->totalDataLen + 1,
1958                     sizeof(*g_singleThreadReceiveData->defragData));
1959
1960         if (NULL == g_singleThreadReceiveData->defragData)
1961         {
1962             OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!");
1963             OICFree(g_singleThreadReceiveData);
1964             return;
1965         }
1966
1967         if (g_singleThreadReceiveData->recvDataLen + dataOnlyLen
1968                 > g_singleThreadReceiveData->totalDataLen)
1969         {
1970             OIC_LOG(ERROR, CALEADAPTER_TAG, "buffer is smaller than received data");
1971             OICFree(g_singleThreadReceiveData->defragData);
1972             OICFree(g_singleThreadReceiveData);
1973             return;
1974         }
1975         memcpy(g_singleThreadReceiveData->defragData,
1976                data + (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE),
1977                dataOnlyLen);
1978         g_singleThreadReceiveData->recvDataLen += dataOnlyLen;
1979     }
1980     else
1981     {
1982         size_t dataOnlyLen = dataLen - CA_BLE_HEADER_SIZE;
1983         if (g_singleThreadReceiveData->recvDataLen + dataOnlyLen
1984                 > g_singleThreadReceiveData->totalDataLen)
1985         {
1986             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
1987                       "Data Length exceeding error!! Receiving [%d] total length [%d]",
1988                       g_singleThreadReceiveData->recvDataLen + dataOnlyLen,
1989                       g_singleThreadReceiveData->totalDataLen);
1990             OICFree(g_singleThreadReceiveData->defragData);
1991             OICFree(g_singleThreadReceiveData);
1992             return;
1993         }
1994         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%d]",
1995                   dataOnlyLen);
1996         memcpy(g_singleThreadReceiveData->defragData + g_singleThreadReceiveData->recvDataLen,
1997                data + CA_BLE_HEADER_SIZE,
1998                dataOnlyLen);
1999         g_singleThreadReceiveData->recvDataLen += dataOnlyLen;
2000         OIC_LOG_V(INFO, CALEADAPTER_TAG, "totalDatalength  [%d] received Datalen [%d]",
2001                 g_singleThreadReceiveData->totalDataLen, g_singleThreadReceiveData->recvDataLen);
2002     }
2003     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
2004 }
2005
2006 static CAResult_t CALEServerSendDataSingleThread(const uint8_t *data,
2007                                                  uint32_t dataLen)
2008 {
2009     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__););
2010
2011     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
2012
2013     uint32_t midPacketCount = 0;
2014     size_t remainingLen = 0;
2015     size_t totalLength = 0;
2016     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
2017
2018     CAResult_t result = CAGenerateVariableForFragmentation(dataLen,
2019                                                            &midPacketCount,
2020                                                            &remainingLen,
2021                                                            &totalLength,
2022                                                            g_mtuSize);
2023
2024     if (CA_STATUS_OK != result)
2025     {
2026         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2027                   "CAGenerateVariableForFragmentation failed, result [%d]", result);
2028         return result;
2029     }
2030
2031     OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
2032               "Packet info: data size[%d] midPacketCount[%d] remainingLen[%d] totalLength[%d]",
2033               dataLen, midPacketCount, remainingLen, totalLength);
2034
2035     OIC_LOG_V(DEBUG,
2036               CALEADAPTER_TAG,
2037               "Server total Data length with header is [%u]",
2038               totalLength);
2039
2040     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
2041     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
2042
2043     result = CAGenerateHeader(dataHeader,
2044                               CA_BLE_PACKET_START,
2045                               g_localBLESourcePort,
2046                               CA_BLE_PACKET_NON_SECURE,
2047                               CA_BLE_MULTICAST_PORT);
2048
2049     if (CA_STATUS_OK != result)
2050     {
2051         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2052                   "CAGenerateHeader failed, result [%d]", result);
2053         return result;
2054     }
2055
2056     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
2057     result = CAGenerateHeaderPayloadLength(lengthHeader,
2058                                            CA_BLE_LENGTH_HEADER_SIZE,
2059                                            dataLen);
2060
2061     if (CA_STATUS_OK != result)
2062     {
2063         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2064                   "CAGenerateHeaderPayloadLength failed, result [%d]", result);
2065         return result;
2066     }
2067
2068     uint32_t length = 0;
2069     uint32_t dataOnlyLen = 0;
2070     if (g_mtuSize > totalLength)
2071     {
2072         length = totalLength;
2073         dataOnlyLen = dataLen;
2074     }
2075     else
2076     {
2077         length = g_mtuSize;
2078         dataOnlyLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
2079     }
2080
2081     result = CAMakeFirstDataSegment(dataSegment,
2082                                     data, dataOnlyLen,
2083                                     dataHeader, lengthHeader);
2084
2085     if (CA_STATUS_OK != result)
2086     {
2087         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2088                   "Making data segment failed, result [%d]", result);
2089         return result;
2090     }
2091
2092     OIC_LOG(DEBUG, CALEADAPTER_TAG, "Server Sending Multicast data");
2093     result = CAUpdateCharacteristicsToAllGattClients(dataSegment, length);
2094     if (CA_STATUS_OK != result)
2095     {
2096         OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
2097                 result);
2098         return result;
2099     }
2100
2101     CALEDoEvents();
2102
2103     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]", length);
2104
2105     result = CAGenerateHeader(dataHeader,
2106                               CA_BLE_PACKET_NOT_START,
2107                               g_localBLESourcePort,
2108                               CA_BLE_PACKET_NON_SECURE,
2109                               CA_BLE_MULTICAST_PORT);
2110
2111     if (CA_STATUS_OK != result)
2112     {
2113         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2114                   "CAGenerateHeader failed, result [%d]", result);
2115         return result;
2116     }
2117
2118     const uint32_t dataLimit = midPacketCount;
2119     for (uint32_t iter = 0; iter < dataLimit; iter++)
2120     {
2121         result = CAMakeRemainDataSegment(dataSegment,
2122                                          g_mtuSize - CA_BLE_HEADER_SIZE,
2123                                          data,
2124                                          dataLen,
2125                                          iter,
2126                                          dataHeader,
2127                                          g_mtuSize);
2128
2129         if (CA_STATUS_OK != result)
2130         {
2131             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2132                     "Making data segment failed, result [%d]", result);
2133             return result;
2134         }
2135
2136         result = CAUpdateCharacteristicsToAllGattClients(
2137                      dataSegment,
2138                      g_mtuSize);
2139
2140         if (CA_STATUS_OK != result)
2141         {
2142             OIC_LOG(ERROR, CALEADAPTER_TAG, "Update characteristics failed");
2143             return result;
2144         }
2145
2146         CALEDoEvents();
2147     }
2148
2149     if (remainingLen && (totalLength > g_mtuSize))
2150     {
2151         // send the last segment of the data
2152         OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
2153
2154         result = CAMakeRemainDataSegment(dataSegment,
2155                                          remainingLen,
2156                                          data,
2157                                          dataLen,
2158                                          dataLimit,
2159                                          dataHeader,
2160                                          g_mtuSize);
2161
2162         if (CA_STATUS_OK != result)
2163         {
2164             OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2165                     "Making data segment failed, result [%d]", result);
2166             return result;
2167         }
2168
2169         result = CAUpdateCharacteristicsToAllGattClients(
2170                      dataSegment,
2171                      remainingLen + CA_BLE_HEADER_SIZE);
2172
2173         if (CA_STATUS_OK != result)
2174         {
2175             OIC_LOG(ERROR, CALEADAPTER_TAG, "Update characteristics failed");
2176             return result;
2177         }
2178         CALEDoEvents();
2179     }
2180
2181     return result;
2182 }
2183 #endif
2184
2185 static CAResult_t CAInitLEAdapterMutex()
2186 {
2187     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2188
2189     if (NULL == g_bleIsServerMutex)
2190     {
2191         g_bleIsServerMutex = oc_mutex_new();
2192         if (NULL == g_bleIsServerMutex)
2193         {
2194             OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
2195             return CA_STATUS_FAILED;
2196         }
2197     }
2198
2199     if (NULL == g_bleLocalAddressMutex)
2200     {
2201         g_bleLocalAddressMutex = oc_mutex_new();
2202         if (NULL == g_bleLocalAddressMutex)
2203         {
2204             OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
2205             CATerminateLEAdapterMutex();
2206             return CA_STATUS_FAILED;
2207         }
2208     }
2209
2210
2211
2212     if (NULL == g_bleServerReceiveDataMutex)
2213     {
2214         g_bleServerReceiveDataMutex = oc_mutex_new();
2215         if (NULL == g_bleServerReceiveDataMutex)
2216         {
2217             OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
2218             return CA_STATUS_FAILED;
2219         }
2220     }
2221
2222     if (NULL == g_bleClientReceiveDataMutex)
2223     {
2224         g_bleClientReceiveDataMutex = oc_mutex_new();
2225         if (NULL == g_bleClientReceiveDataMutex)
2226         {
2227             OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
2228             return CA_STATUS_FAILED;
2229         }
2230     }
2231
2232     if (NULL == g_senderInfoMutex)
2233     {
2234         g_senderInfoMutex = oc_mutex_new();
2235         if (NULL == g_senderInfoMutex)
2236         {
2237             OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
2238             return CA_STATUS_FAILED;
2239         }
2240     }
2241
2242     return CA_STATUS_OK;
2243 }
2244
2245 static void CATerminateLEAdapterMutex()
2246 {
2247     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2248
2249     oc_mutex_free(g_bleIsServerMutex);
2250     g_bleIsServerMutex = NULL;
2251
2252
2253     oc_mutex_free(g_bleLocalAddressMutex);
2254     g_bleLocalAddressMutex = NULL;
2255
2256     oc_mutex_free(g_bleServerReceiveDataMutex);
2257     g_bleServerReceiveDataMutex = NULL;
2258
2259     oc_mutex_free(g_bleClientReceiveDataMutex);
2260     g_bleClientReceiveDataMutex = NULL;
2261
2262     oc_mutex_free(g_senderInfoMutex);
2263     g_senderInfoMutex = NULL;
2264 }
2265
2266 /**
2267  * Starting LE connectivity adapters.
2268  *
2269  * As its peer to peer it does not require to start any servers.
2270  *
2271  * @return ::CA_STATUS_OK or Appropriate error code.
2272  */
2273 static CAResult_t CAStartLE();
2274
2275 /**
2276  * Start listening server for receiving multicast search requests.
2277  *
2278  * Transport Specific Behavior:
2279  *   LE  Starts GATT Server with prefixed UUID and Characteristics
2280  *   per OIC Specification.
2281  * @return  ::CA_STATUS_OK or Appropriate error code.
2282  */
2283 static CAResult_t CAStartLEListeningServer();
2284
2285 /**
2286  * Stops listening server from receiving multicast search requests.
2287  *
2288  * Transport Specific Behavior:
2289  *   LE  Starts GATT Server with prefixed UUID and Characteristics
2290  *   per OIC Specification.
2291  * @return  ::CA_STATUS_OK or Appropriate error code.
2292  */
2293 static CAResult_t CAStopLEListeningServer();
2294
2295 /**
2296  * Sarting discovery of servers for receiving multicast
2297  * advertisements.
2298  *
2299  * Transport Specific Behavior:
2300  *   LE  Starts GATT Server with prefixed UUID and Characteristics
2301  *   per OIC Specification.
2302  *
2303  * @return ::CA_STATUS_OK or Appropriate error code
2304  */
2305 static CAResult_t CAStartLEDiscoveryServer();
2306
2307 /**
2308  * Send data to the endpoint using the adapter connectivity.
2309  *
2310  * @param[in] endpoint Remote Endpoint information (like MAC address,
2311  *                     reference URI and connectivity type) to which
2312  *                     the unicast data has to be sent.
2313  * @param[in] data     Data which required to be sent.
2314  * @param[in] dataLen  Size of data to be sent.
2315  *
2316  * @note  dataLen must be > 0.
2317  *
2318  * @return The number of bytes sent on the network, or -1 on error.
2319  */
2320 static int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint,
2321                                    const void *data,
2322                                    uint32_t dataLen,
2323                                    CADataType_t dataType);
2324
2325 /**
2326  * Send multicast data to the endpoint using the LE connectivity.
2327  *
2328  * @param[in] endpoint Remote Endpoint information to which the
2329  *                     multicast data has to be sent.
2330  * @param[in] data     Data which required to be sent.
2331  * @param[in] dataLen  Size of data to be sent.
2332  *
2333  * @note  dataLen must be > 0.
2334  *
2335  * @return The number of bytes sent on the network, or -1 on error.
2336  */
2337 static int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint,
2338                                      const void *data,
2339                                      uint32_t dataLen,
2340                                      CADataType_t dataType);
2341
2342 /**
2343  * Get LE Connectivity network information.
2344  *
2345  * @param[out] info Local connectivity information structures.
2346  * @param[out] size Number of local connectivity structures.
2347  *
2348  * @return ::CA_STATUS_OK or Appropriate error code.
2349  */
2350 static CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info,
2351                                               uint32_t *size);
2352
2353 /**
2354  * Read Synchronous API callback.
2355  *
2356  * @return  ::CA_STATUS_OK or Appropriate error code.
2357  */
2358 static CAResult_t CAReadLEData();
2359
2360 /**
2361  * Stopping the adapters and close socket connections.
2362  *
2363  * LE Stops all GATT servers and GATT Clients.
2364  *
2365  * @return ::CA_STATUS_OK or Appropriate error code.
2366  */
2367 static CAResult_t CAStopLE();
2368
2369 /**
2370  * Terminate the LE connectivity adapter.
2371  *
2372  * Configuration information will be deleted from further use.
2373  */
2374 static void CATerminateLE();
2375
2376 /**
2377  * This function will receive the data from the GattServer and add the
2378  * data to the Server receiver queue.
2379  *
2380  * @param[in] remoteAddress Remote address of the device from where
2381  *                          data is received.
2382  * @param[in] data          Actual data received from the remote
2383  *                          device.
2384  * @param[in] dataLength    Length of the data received from the
2385  *                          remote device.
2386  * @param[in] sentLength    Length of the data sent from the remote
2387  *                          device.
2388  *
2389  * @return ::CA_STATUS_OK or Appropriate error code.
2390  * @retval ::CA_STATUS_OK  Successful.
2391  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
2392  * @retval ::CA_STATUS_FAILED Operation failed.
2393  *
2394  */
2395 static CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress,
2396                                                 const uint8_t *data,
2397                                                 uint32_t dataLength,
2398                                                 uint32_t *sentLength);
2399
2400 /**
2401  * This function will receive the data from the GattClient and add the
2402  * data into the Client receiver queue.
2403  *
2404  * @param[in] remoteAddress Remote address of the device from where
2405  *                          data is received.
2406  * @param[in] data          Actual data recevied from the remote
2407  *                          device.
2408  * @param[in] dataLength    Length of the data received from the
2409  *                          remote device.
2410  * @param[in] sentLength    Length of the data sent from the remote
2411  *                          device.
2412  *
2413  * @return ::CA_STATUS_OK or Appropriate error code.
2414  * @retval ::CA_STATUS_OK  Successful.
2415  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
2416  * @retval ::CA_STATUS_FAILED Operation failed.
2417  */
2418 static CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress,
2419                                                 const uint8_t *data,
2420                                                 uint32_t dataLength,
2421                                                 uint32_t *sentLength);
2422
2423 /**
2424  * Set the NetworkPacket received callback to CA layer from adapter
2425  * layer.
2426  *
2427  * @param[in] callback Callback handle sent from the upper layer.
2428  */
2429 static void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback);
2430
2431 /**
2432  * Push the data from CA layer to the Sender processor queue.
2433  *
2434  * @param[in] remoteEndpoint Remote endpoint information of the
2435  *                           server.
2436  * @param[in] data           Data to be transmitted from LE.
2437  * @param[in] dataLen        Length of the Data being transmitted.
2438  *
2439  * @return ::CA_STATUS_OK or Appropriate error code.
2440  * @retval ::CA_STATUS_OK  Successful.
2441  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
2442  * @retval ::CA_STATUS_FAILED Operation failed.
2443  */
2444 static CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint,
2445                                             const uint8_t *data,
2446                                             uint32_t dataLen);
2447
2448 /**
2449  * Push the data from CA layer to the Sender processor queue.
2450  *
2451  * @param[in] remoteEndpoint Remote endpoint information of the
2452  *                           server.
2453  * @param[in] data           Data to be transmitted from LE.
2454  * @param[in] dataLen        Length of the Data being transmitted.
2455  *
2456  * @return ::CA_STATUS_OK or Appropriate error code.
2457  * @retval ::CA_STATUS_OK  Successful.
2458  * @retval ::CA_STATUS_INVALID_PARAM  Invalid input arguments.
2459  * @retval ::CA_STATUS_FAILED Operation failed.
2460  */
2461 static CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint,
2462                                             const uint8_t *data,
2463                                             uint32_t dataLen);
2464
2465 static CAResult_t CALEAdapterGattServerStart()
2466 {
2467     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2468     CAResult_t result = CA_STATUS_FAILED;
2469
2470     if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
2471     {
2472         OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
2473                   caglobals.bleFlags);
2474         return CA_STATUS_OK;
2475     }
2476
2477 #ifndef DISABLE_BLE_SERVER
2478     OIC_LOG_V(INFO, CALEADAPTER_TAG, "Starting LE GATT Server");
2479     result = CAStartLEGattServer();
2480 #endif
2481
2482 #ifndef SINGLE_THREAD
2483     /*
2484       Don't start the server side sending queue thread until the
2485       server itself has actually started.
2486     */
2487     if (CA_STATUS_OK == result)
2488     {
2489         result = CAQueueingThreadStart(g_bleServerSendQueueHandle);
2490         if (CA_STATUS_OK != result)
2491         {
2492             OIC_LOG_V(ERROR,
2493                       CALEADAPTER_TAG,
2494                       "Unable to start server queuing thread (%d)",
2495                       result);
2496         }
2497     }
2498 #endif
2499
2500     return result;
2501 }
2502
2503 static CAResult_t CALEAdapterGattServerStop()
2504 {
2505     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2506
2507     if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
2508     {
2509         OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
2510                   caglobals.bleFlags);
2511         return CA_STATUS_OK;
2512     }
2513
2514 #ifndef SINGLE_THREAD
2515
2516     CAResult_t res = CAQueueingThreadStop(g_bleServerSendQueueHandle);
2517     if (CA_STATUS_OK != res)
2518     {
2519         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAQueueingThreadStop has failed");
2520     }
2521     res = CAStopLEGattServer();
2522     if (CA_STATUS_OK != res)
2523     {
2524         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAStopLEGattServer has failed");
2525     }
2526
2527     return res;
2528 #else
2529     return CAStopLEGattServer();
2530 #endif
2531 }
2532
2533 static CAResult_t CALEAdapterGattClientStart()
2534 {
2535     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2536
2537     CAResult_t result = CAStartLEGattClient();
2538
2539 #ifndef SINGLE_THREAD
2540     /*
2541       Don't start the client side sending queue thread until the
2542       client itself has actually started.
2543     */
2544     if (CA_STATUS_OK == result)
2545     {
2546         result = CAQueueingThreadStart(g_bleClientSendQueueHandle);
2547         if (CA_STATUS_OK != result)
2548         {
2549             OIC_LOG(ERROR,
2550                     CALEADAPTER_TAG,
2551                     "Unable to start client queuing thread");
2552         }
2553     }
2554 #endif
2555
2556     return result;
2557 }
2558
2559 static CAResult_t CALEAdapterGattClientStop()
2560 {
2561 #ifndef SINGLE_THREAD
2562     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2563     CAStopLEGattClient();
2564
2565     CAResult_t result = CAQueueingThreadStop(g_bleClientSendQueueHandle);
2566
2567     return result;
2568 #else
2569     CAStopLEGattClient();
2570
2571     return CA_STATUS_OK;
2572 #endif
2573 }
2574
2575 #ifdef __WITH_DTLS__
2576 static ssize_t CALESecureSendDataCB(CAEndpoint_t *endpoint, const void *data, size_t dataLen)
2577 {
2578     VERIFY_NON_NULL(endpoint, CALEADAPTER_TAG, "endpoint is NULL");
2579     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "data is NULL");
2580     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
2581     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "encrypted datalen = %zd", dataLen);
2582
2583     CAResult_t result;
2584     CADataType_t dataType = g_dataType;
2585     ssize_t ret = 0;
2586
2587     if (ADAPTER_SERVER == g_adapterType ||
2588             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
2589     {
2590         result = CALEAdapterServerSendData(endpoint, data, dataLen);
2591         if (CA_STATUS_OK != result)
2592         {
2593             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for server failed" );
2594
2595              if (g_errorHandler)
2596              {
2597                  g_errorHandler(endpoint, data, dataLen, result);
2598              }
2599              return ret;
2600         }
2601         ret = (ssize_t)dataLen;
2602     }
2603     else if (ADAPTER_CLIENT == g_adapterType ||
2604             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_REQUEST_DATA == dataType) ||
2605             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_FOR_RES == dataType))
2606     {
2607         result = CALEAdapterClientSendData(endpoint, data, dataLen);
2608         if (CA_STATUS_OK != result)
2609         {
2610             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for client failed" );
2611
2612              if (g_errorHandler)
2613              {
2614                  g_errorHandler(endpoint, data, dataLen, result);
2615              }
2616              return ret;
2617         }
2618         ret = (ssize_t)dataLen;
2619     }
2620     else
2621     {
2622         OIC_LOG_V(ERROR, CALEADAPTER_TAG,
2623                   "Can't Send Message adapterType = %d, dataType = %d", g_adapterType, dataType);
2624         return ret;
2625     }
2626     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
2627     return ret;
2628 }
2629
2630 CAResult_t CALESecureReceiveDataCB(const CASecureEndpoint_t *sep, const void *data,
2631                           size_t dataLen)
2632 {
2633     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2634
2635     VERIFY_NON_NULL(sep, CALEADAPTER_TAG, "sep is NULL");
2636     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "data is NULL");
2637
2638     OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
2639               "Secure Data Receive - decrypted datalen = %zd", dataLen);
2640
2641     if (dataLen <= 0)
2642     {
2643         OIC_LOG(ERROR, CALEADAPTER_TAG, "incorrect dataLen, derecypt fail !");
2644         return CA_STATUS_INVALID_PARAM;
2645     }
2646
2647     OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
2648
2649     CAResult_t res = CA_STATUS_OK;
2650     if (g_networkPacketReceivedCallback)
2651     {
2652         OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
2653                   "[CALESecureReceiveDataCB] Secure flags = %d, %x",
2654                   sep->endpoint.flags, sep->endpoint.flags);
2655         OIC_LOG(DEBUG, CALEADAPTER_TAG,
2656                   "[CALESecureReceiveDataCB] Received data up !");
2657         res = g_networkPacketReceivedCallback(sep, data, dataLen);
2658         if (CA_STATUS_OK != res)
2659         {
2660             OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Error parsing CoAP data, res = %d", res);
2661         }
2662     }
2663     return res;
2664 }
2665 #endif
2666
2667 CAResult_t CAInitializeLE(CARegisterConnectivityCallback registerCallback,
2668                           CANetworkPacketReceivedCallback reqRespCallback,
2669                           CAAdapterChangeCallback netCallback,
2670                           CAConnectionChangeCallback connCallback,
2671                           CAErrorHandleCallback errorCallback,
2672                           ca_thread_pool_t handle)
2673 {
2674     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2675
2676     //Input validation
2677     VERIFY_NON_NULL(registerCallback, CALEADAPTER_TAG, "RegisterConnectivity callback is null");
2678     VERIFY_NON_NULL(reqRespCallback, CALEADAPTER_TAG, "PacketReceived Callback is null");
2679     VERIFY_NON_NULL(netCallback, CALEADAPTER_TAG, "NetworkChange Callback is null");
2680     VERIFY_NON_NULL(connCallback, CALEADAPTER_TAG, "ConnectionChange Callback is null");
2681
2682     CAResult_t result = CA_STATUS_OK;
2683     result = CAInitLEAdapterMutex();
2684     if (CA_STATUS_OK != result)
2685     {
2686         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleAdapterMutex failed!");
2687         return CA_STATUS_FAILED;
2688     }
2689
2690     result = CAInitializeLENetworkMonitor();
2691     if (CA_STATUS_OK != result)
2692     {
2693         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitializeLENetworkMonitor() failed");
2694         return CA_STATUS_FAILED;
2695     }
2696     CAInitializeLEAdapter();
2697
2698     result = CAInitializeLEGattClient();
2699     if (CA_STATUS_OK != result)
2700     {
2701         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitializeLEGattClient() failed");
2702         return CA_STATUS_FAILED;
2703     }
2704
2705     CASetLEClientThreadPoolHandle(handle);
2706
2707     CASetLEReqRespClientCallback(CALEAdapterClientReceivedData);
2708     CASetLEServerThreadPoolHandle(handle);
2709     result = CAInitializeLEGattServer();
2710     if (CA_STATUS_OK != result)
2711     {
2712         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitializeLEGattServer() failed");
2713         return CA_STATUS_FAILED;
2714     }
2715
2716     CASetLEAdapterThreadPoolHandle(handle);
2717     CASetLEReqRespServerCallback(CALEAdapterServerReceivedData);
2718     CASetLEReqRespAdapterCallback(reqRespCallback);
2719
2720     CASetBLEClientErrorHandleCallback(CALEErrorHandler);
2721     CASetBLEServerErrorHandleCallback(CALEErrorHandler);
2722     CALERegisterNetworkNotifications(netCallback, connCallback);
2723
2724     g_errorHandler = errorCallback;
2725
2726 #ifdef __WITH_DTLS__
2727      if (CA_STATUS_OK != CAinitSslAdapter())
2728     {
2729         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to init SSL adapter");
2730     }
2731     else
2732     {
2733         CAsetSslAdapterCallbacks(CALESecureReceiveDataCB, CALESecureSendDataCB,
2734                                  CA_ADAPTER_GATT_BTLE);
2735     }
2736 #endif
2737
2738     static const CAConnectivityHandler_t connHandler =
2739         {
2740             .startAdapter = CAStartLE,
2741             .stopAdapter = CAStopLE,
2742             .startListenServer = CAStartLEListeningServer,
2743             .stopListenServer = CAStopLEListeningServer,
2744             .startDiscoveryServer = CAStartLEDiscoveryServer,
2745             .sendData = CASendLEUnicastData,
2746             .sendDataToAll = CASendLEMulticastData,
2747             .GetnetInfo = CAGetLEInterfaceInformation,
2748             .readData = CAReadLEData,
2749             .terminate = CATerminateLE,
2750             .cType = CA_ADAPTER_GATT_BTLE
2751         };
2752
2753     registerCallback(connHandler);
2754     return CA_STATUS_OK;
2755 }
2756
2757 static CAResult_t CAStartLE()
2758 {
2759     return CAStartLEAdapter();
2760 }
2761
2762 static CAResult_t CAStopLE()
2763 {
2764
2765 #ifndef SINGLE_THREAD
2766     CAStopLEQueues();
2767 #endif
2768
2769     oc_mutex_lock(g_bleIsServerMutex);
2770     switch (g_adapterType)
2771     {
2772         case ADAPTER_SERVER:
2773             CALEAdapterGattServerStop();
2774             break;
2775         case ADAPTER_CLIENT:
2776             CALEAdapterGattClientStop();
2777             break;
2778         case ADAPTER_BOTH_CLIENT_SERVER:
2779             CALEAdapterGattServerStop();
2780             CALEAdapterGattClientStop();
2781             break;
2782         default:
2783             break;
2784     }
2785     oc_mutex_unlock(g_bleIsServerMutex);
2786     return CAStopLEAdapter();
2787 }
2788
2789 static void CATerminateLE()
2790 {
2791     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
2792
2793     CASetLEReqRespServerCallback(NULL);
2794     CASetLEReqRespClientCallback(NULL);
2795     CALERegisterNetworkNotifications(NULL, NULL);
2796     CASetLEReqRespAdapterCallback(NULL);
2797     CATerminateLENetworkMonitor();
2798
2799     oc_mutex_lock(g_bleIsServerMutex);
2800     switch (g_adapterType)
2801     {
2802         case ADAPTER_SERVER:
2803             CATerminateLEGattServer();
2804             break;
2805         case ADAPTER_CLIENT:
2806             CATerminateLEGattClient();
2807             break;
2808         case ADAPTER_BOTH_CLIENT_SERVER:
2809             CATerminateLEGattServer();
2810             CATerminateLEGattClient();
2811             break;
2812         default:
2813             break;
2814     }
2815     g_adapterType = ADAPTER_EMPTY;
2816     oc_mutex_unlock(g_bleIsServerMutex);
2817
2818 #ifndef SINGLE_THREAD
2819     CATerminateLEQueues();
2820 #endif
2821
2822 #ifdef __WITH_DTLS__
2823     CAsetSslAdapterCallbacks(NULL, NULL, CA_ADAPTER_GATT_BTLE);
2824 #endif
2825
2826     CATerminateLEAdapterMutex();
2827 }
2828
2829 static CAResult_t CAStartLEListeningServer()
2830 {
2831     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
2832
2833     if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
2834     {
2835         OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
2836                   caglobals.bleFlags);
2837         return CA_STATUS_OK;
2838     }
2839
2840 #ifndef ROUTING_GATEWAY
2841     CAResult_t result = CA_STATUS_OK;
2842 #ifndef SINGLE_THREAD
2843     result = CAInitLEServerQueues();
2844     if (CA_STATUS_OK != result)
2845     {
2846         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEServerQueues failed");
2847         return result;
2848     }
2849 #endif
2850
2851     oc_mutex_lock(g_bleIsServerMutex);
2852     switch (g_adapterType)
2853     {
2854         case ADAPTER_CLIENT:
2855             g_adapterType = ADAPTER_BOTH_CLIENT_SERVER;
2856             break;
2857         case ADAPTER_BOTH_CLIENT_SERVER:
2858             break;
2859         default:
2860             g_adapterType = ADAPTER_SERVER;
2861     }
2862     oc_mutex_unlock(g_bleIsServerMutex);
2863
2864     result = CAGetLEAdapterState();
2865     if (CA_STATUS_OK != result)
2866     {
2867         if (CA_ADAPTER_NOT_ENABLED == result)
2868         {
2869             OIC_LOG(DEBUG,
2870                     CALEADAPTER_TAG,
2871                     "Listen Server will be started once BT Adapter is enabled");
2872             result = CA_STATUS_OK;
2873         }
2874     }
2875     else
2876     {
2877         result = CALEAdapterGattServerStart();
2878     }
2879
2880     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
2881     return result;
2882 #else
2883     // Routing Gateway only supports BLE client mode.
2884     OIC_LOG(ERROR, CALEADAPTER_TAG, "LE server not supported in Routing Gateway");
2885     return CA_NOT_SUPPORTED;
2886 #endif
2887 }
2888
2889 static CAResult_t CAStopLEListeningServer()
2890 {
2891     OIC_LOG(ERROR, CALEADAPTER_TAG, "Listen server stop not supported.");
2892     return CA_NOT_SUPPORTED;
2893 }
2894
2895 static CAResult_t CAStartLEDiscoveryServer()
2896 {
2897     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
2898     CAResult_t result = CA_STATUS_OK;
2899 #ifndef SINGLE_THREAD
2900     result = CAInitLEClientQueues();
2901     if (CA_STATUS_OK != result)
2902     {
2903         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEClientQueues failed");
2904         return result;
2905     }
2906 #endif
2907
2908     oc_mutex_lock(g_bleIsServerMutex);
2909     switch (g_adapterType)
2910     {
2911         case ADAPTER_SERVER:
2912             g_adapterType = ADAPTER_BOTH_CLIENT_SERVER;
2913             break;
2914         case ADAPTER_BOTH_CLIENT_SERVER:
2915             break;
2916         default:
2917             g_adapterType = ADAPTER_CLIENT;
2918     }
2919     oc_mutex_unlock(g_bleIsServerMutex);
2920
2921     result = CAGetLEAdapterState();
2922     if (CA_STATUS_OK != result)
2923     {
2924         if (CA_ADAPTER_NOT_ENABLED == result)
2925         {
2926             OIC_LOG(DEBUG,
2927                     CALEADAPTER_TAG,
2928                     "Discovery Server will be started once BT Adapter is enabled");
2929             result = CA_STATUS_OK;
2930         }
2931     }
2932     else
2933     {
2934         result = CALEAdapterGattClientStart();
2935     }
2936
2937     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
2938     return result;
2939 }
2940
2941 static CAResult_t CAReadLEData()
2942 {
2943 #ifdef SINGLE_THREAD
2944     CACheckLEData();
2945 #endif
2946     return CA_STATUS_OK;
2947 }
2948
2949 static int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint,
2950                                    const void *data,
2951                                    uint32_t dataLen,
2952                                    CADataType_t dataType)
2953 {
2954     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
2955     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "type(%d)", dataType);
2956
2957     //Input validation
2958     VERIFY_NON_NULL_RET(endpoint, CALEADAPTER_TAG, "Remote endpoint is null", -1);
2959     VERIFY_NON_NULL_RET(data, CALEADAPTER_TAG, "Data is null", -1);
2960
2961     CAResult_t result = CA_STATUS_FAILED;
2962
2963     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "g_adapterType: %d", g_adapterType);
2964     if (ADAPTER_EMPTY == g_adapterType)
2965     {
2966         OIC_LOG(ERROR, CALEADAPTER_TAG, "g_adapterType is Empty");
2967     }
2968
2969     oc_mutex_lock(g_bleIsServerMutex);
2970     if (ADAPTER_SERVER == g_adapterType ||
2971             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
2972     {
2973 #ifdef __WITH_DTLS__
2974         if (endpoint && endpoint->flags & CA_SECURE)
2975         {
2976             OIC_LOG(DEBUG, CALEADAPTER_TAG,
2977                     "Response Data or server - secured data send(caadapternetdtlsencrypt) call");
2978             OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
2979             g_dataType = dataType;
2980             oc_mutex_unlock(g_bleIsServerMutex);
2981
2982             result = CAencryptSsl(endpoint, (void *)data, dataLen);
2983             if (CA_STATUS_OK != result)
2984             {
2985                 OIC_LOG(ERROR, CALEADAPTER_TAG, "caadapternetdtlsencrypt failed!");
2986                 return -1;
2987             }
2988             return dataLen;
2989         }
2990         else
2991         {
2992             OIC_LOG(DEBUG, CALEADAPTER_TAG,
2993                     "server or both - none secured data send(CALEAdapterServerSendData) call");
2994             result = CALEAdapterServerSendData(endpoint, data, dataLen);
2995         }
2996 #else
2997         result = CALEAdapterServerSendData(endpoint, data, dataLen);
2998 #endif
2999         if (CA_STATUS_OK != result)
3000         {
3001             oc_mutex_unlock(g_bleIsServerMutex);
3002             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for server failed");
3003             if (g_errorHandler)
3004             {
3005                 g_errorHandler(endpoint, data, dataLen, result);
3006             }
3007
3008             return -1;
3009         }
3010     }
3011     else if (ADAPTER_CLIENT == g_adapterType ||
3012             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_REQUEST_DATA == dataType) ||
3013             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_FOR_RES == dataType))
3014     {
3015 #ifdef __WITH_DTLS__
3016         if (endpoint && endpoint->flags & CA_SECURE)
3017         {
3018             OIC_LOG(DEBUG, CALEADAPTER_TAG,
3019                     "Request Data or client - secured data send(caadapternetdtlsencrypt) call");
3020             OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
3021             g_dataType = dataType;
3022             oc_mutex_unlock(g_bleIsServerMutex);
3023
3024             result = CAencryptSsl(endpoint, (void *)data, dataLen);
3025             if (CA_STATUS_OK != result)
3026             {
3027                 OIC_LOG(ERROR, CALEADAPTER_TAG, "caadapternetdtlsencrypt failed!");
3028                 return -1;
3029             }
3030             return dataLen;
3031         }
3032         else
3033         {
3034             OIC_LOG(DEBUG, CALEADAPTER_TAG,
3035                     "client or both - none secured data send(CALEAdapterClientSendData) call");
3036             result = CALEAdapterClientSendData(endpoint, data, dataLen);
3037         }
3038 #else
3039         result = CALEAdapterClientSendData(endpoint, data, dataLen);
3040 #endif
3041         if (CA_STATUS_OK != result)
3042         {
3043             oc_mutex_unlock(g_bleIsServerMutex);
3044             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for client failed" );
3045
3046             if (g_errorHandler)
3047             {
3048                 g_errorHandler(endpoint, data, dataLen, result);
3049             }
3050             return -1;
3051         }
3052     }
3053     oc_mutex_unlock(g_bleIsServerMutex);
3054
3055     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3056     return dataLen;
3057 }
3058
3059 static int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint,
3060                                      const void *data,
3061                                      uint32_t dataLen,
3062                                      CADataType_t dataType)
3063 {
3064     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3065
3066     //Input validation
3067     VERIFY_NON_NULL_RET(data, CALEADAPTER_TAG, "Data is null", -1);
3068
3069     if (0 >= dataLen)
3070     {
3071         OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid Parameter");
3072         return -1;
3073     }
3074
3075     CAResult_t result = CA_STATUS_FAILED;
3076
3077     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "g_adapterType: %d", g_adapterType);
3078     if (ADAPTER_EMPTY == g_adapterType)
3079     {
3080         OIC_LOG(ERROR, CALEADAPTER_TAG, "g_adapterType is Empty");
3081     }
3082
3083     oc_mutex_lock(g_bleIsServerMutex);
3084     if (ADAPTER_SERVER == g_adapterType ||
3085             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
3086     {
3087         result = CALEAdapterServerSendData(NULL, data, dataLen);
3088         if (CA_STATUS_OK != result)
3089         {
3090             oc_mutex_unlock(g_bleIsServerMutex);
3091
3092             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send multicast data for server failed" );
3093
3094             if (g_errorHandler)
3095             {
3096                 g_errorHandler(endpoint, data, dataLen, result);
3097             }
3098             return -1;
3099         }
3100     }
3101
3102     if (ADAPTER_CLIENT == g_adapterType ||
3103             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_REQUEST_DATA == dataType) ||
3104             (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_FOR_RES == dataType))
3105     {
3106         result = CALEAdapterClientSendData(NULL, data, dataLen);
3107         if (CA_STATUS_OK != result)
3108         {
3109             oc_mutex_unlock(g_bleIsServerMutex);
3110
3111             OIC_LOG(ERROR, CALEADAPTER_TAG, "Send Multicast data for client failed" );
3112
3113             if (g_errorHandler)
3114             {
3115                 g_errorHandler(endpoint, data, dataLen, result);
3116             }
3117             return -1;
3118         }
3119     }
3120     oc_mutex_unlock(g_bleIsServerMutex);
3121
3122     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3123     return dataLen;
3124 }
3125
3126 static CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
3127 {
3128     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3129
3130     VERIFY_NON_NULL(info, CALEADAPTER_TAG, "CALocalConnectivity info is null");
3131
3132     char *local_address = NULL;
3133
3134     CAResult_t res = CAGetLEAddress(&local_address);
3135     if (CA_STATUS_OK != res)
3136     {
3137         OIC_LOG(ERROR, CALEADAPTER_TAG, "CAGetLEAddress has failed");
3138         return res;
3139     }
3140
3141     if (NULL == local_address)
3142     {
3143         OIC_LOG(ERROR, CALEADAPTER_TAG, "local_address is NULL");
3144         return CA_STATUS_FAILED;
3145     }
3146
3147     *size = 0;
3148     (*info) = (CAEndpoint_t *) OICCalloc(1, sizeof(CAEndpoint_t));
3149     if (NULL == (*info))
3150     {
3151         OIC_LOG(ERROR, CALEADAPTER_TAG, "Malloc failure!");
3152         OICFree(local_address);
3153         return CA_STATUS_FAILED;
3154     }
3155
3156     size_t local_address_len = strlen(local_address);
3157
3158     if(local_address_len >= sizeof(g_localBLEAddress) ||
3159             local_address_len >= MAX_ADDR_STR_SIZE_CA - 1)
3160     {
3161         OIC_LOG(ERROR, CALEADAPTER_TAG, "local_address is too long");
3162         OICFree(*info);
3163         OICFree(local_address);
3164         return CA_STATUS_FAILED;
3165     }
3166
3167     OICStrcpy((*info)->addr, sizeof((*info)->addr), local_address);
3168     oc_mutex_lock(g_bleLocalAddressMutex);
3169     OICStrcpy(g_localBLEAddress, sizeof(g_localBLEAddress), local_address);
3170     oc_mutex_unlock(g_bleLocalAddressMutex);
3171
3172     (*info)->adapter = CA_ADAPTER_GATT_BTLE;
3173     *size = 1;
3174     OICFree(local_address);
3175
3176     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3177     return CA_STATUS_OK;
3178 }
3179
3180 static CAResult_t CALERegisterNetworkNotifications(CAAdapterChangeCallback netCallback,
3181                                                    CAConnectionChangeCallback connCallback)
3182 {
3183     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3184
3185     g_networkCallback = netCallback;
3186     g_connectionCallback = connCallback;
3187     CAResult_t res = CA_STATUS_OK;
3188     if (netCallback)
3189     {
3190         res = CASetLEAdapterStateChangedCb(CALEDeviceStateChangedCb);
3191         if (CA_STATUS_OK != res)
3192         {
3193             OIC_LOG(ERROR, CALEADAPTER_TAG, "CASetLEAdapterStateChangedCb failed!");
3194         }
3195     }
3196     else
3197     {
3198         res = CAUnSetLEAdapterStateChangedCb();
3199         if (CA_STATUS_OK != res)
3200         {
3201             OIC_LOG(ERROR, CALEADAPTER_TAG, "CASetLEAdapterStateChangedCb failed!");
3202         }
3203     }
3204
3205     if (g_connectionCallback)
3206     {
3207         res = CASetLENWConnectionStateChangedCb(CALEConnectionStateChangedCb);
3208         if (CA_STATUS_OK != res)
3209         {
3210             OIC_LOG(ERROR, CALEADAPTER_TAG, "CASetLENWConnectionStateChangedCb failed!");
3211         }
3212     }
3213     else
3214     {
3215         res = CAUnSetLENWConnectionStateChangedCb();
3216         if (CA_STATUS_OK != res)
3217         {
3218             OIC_LOG(ERROR, CALEADAPTER_TAG, "CAUnSetLENWConnectionStateChangedCb failed!");
3219         }
3220     }
3221
3222     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3223     return res;
3224 }
3225
3226 static void CALEConnectionStateChangedCb(CATransportAdapter_t adapter, const char* address,
3227                                          bool isConnected)
3228 {
3229     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3230
3231     VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
3232     (void)adapter;
3233
3234     CAEndpoint_t localEndpoint = { .adapter = CA_ADAPTER_GATT_BTLE };
3235     OICStrcpy(localEndpoint.addr, sizeof(localEndpoint.addr), address);
3236
3237 #ifdef __TIZEN__
3238     oc_mutex_lock(g_bleIsServerMutex);
3239     switch (g_adapterType)
3240     {
3241         case ADAPTER_SERVER:
3242             CALEGattServerConnectionStateChanged(isConnected, address);
3243             break;
3244         case ADAPTER_CLIENT:
3245             CALEGattConnectionStateChanged(isConnected, address);
3246             break;
3247         case ADAPTER_BOTH_CLIENT_SERVER:
3248             CALEGattConnectionStateChanged(isConnected, address);
3249             CALEGattServerConnectionStateChanged(isConnected, address);
3250             break;
3251         default:
3252             break;
3253     }
3254     oc_mutex_unlock(g_bleIsServerMutex);
3255 #endif
3256
3257     if(!isConnected)
3258     {
3259 #ifndef SINGLE_THREAD
3260         if(g_bleClientSenderInfo)
3261         {
3262             CALERemoveReceiveQueueData(g_bleClientSenderInfo, address);
3263         }
3264
3265         if(g_bleServerSenderInfo)
3266         {
3267             CALERemoveReceiveQueueData(g_bleServerSenderInfo, address);
3268         }
3269
3270         // remove data of send queue.
3271         if (g_bleClientSendQueueHandle)
3272         {
3273             CALERemoveSendQueueData(g_bleClientSendQueueHandle, address);
3274         }
3275
3276         if (g_bleServerSendQueueHandle)
3277         {
3278             CALERemoveSendQueueData(g_bleServerSendQueueHandle, address);
3279         }
3280 #endif
3281
3282 #ifdef __WITH_DTLS__
3283 #if defined(__TIZEN__) && !defined(SINGLE_THREAD)
3284         // CAcloseSslConnection returns CAResult_t instead of void*, but the size is the same and crash shouldn't occur
3285         pthread_t ccThread;
3286         pthread_attr_t attr;
3287         int initAttrRes = -1;
3288         int pthreadCreateRes = -1;
3289         int detachStatusRes = -1;
3290         int memoryAllocationRes = -1;
3291
3292         do
3293         {
3294             initAttrRes = pthread_attr_init(&attr);
3295             if (initAttrRes != 0)
3296             {
3297                 break;
3298             }
3299             CAEndpoint_t *localEndpointCpyPtr = OICMalloc(sizeof(CAEndpoint_t));
3300
3301             if(NULL == localEndpointCpyPtr)
3302             {
3303                 memoryAllocationRes = -1;
3304                 break;
3305             }
3306             else
3307             {
3308                 memoryAllocationRes = 0;
3309             }
3310
3311             (*localEndpointCpyPtr) = localEndpoint;
3312             // this piece of code is reached on the main thread
3313             // CAcloseSslConnection might wait for too long (network + mutexes) and watchdog might kill it
3314             // Asynchronous call protects this function from watchdog
3315             pthreadCreateRes = pthread_create(&ccThread, &attr, (void *(*)(void*))&CAcloseSslConnectionFreeEndpoint, (void*)localEndpointCpyPtr);
3316
3317             if (pthreadCreateRes != 0)
3318             {
3319                 break;
3320             }
3321             detachStatusRes = pthread_detach(ccThread);
3322         }while (0);
3323
3324         // regardless of CAcloseSslConnection result, the function will continue and g_connectionCallback will be called
3325         OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "CAcloseSslConnection pthread_init [%d], mem_alloc [%d] pthread_create [%d], pthread_detach [%d]",
3326                 initAttrRes, memoryAllocationRes, pthreadCreateRes, detachStatusRes);
3327 #else
3328         CAcloseSslConnection(&localEndpoint);
3329 #endif
3330 #endif
3331     }
3332
3333     if (g_connectionCallback)
3334     {
3335         g_connectionCallback(&localEndpoint, isConnected);
3336     }
3337
3338     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3339 }
3340
3341 static void CALEDeviceStateChangedCb(CAAdapterState_t adapter_state)
3342 {
3343     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3344
3345     if (CA_ADAPTER_ENABLED == adapter_state)
3346     {
3347         oc_mutex_lock(g_bleIsServerMutex);
3348         switch (g_adapterType)
3349         {
3350             case ADAPTER_SERVER:
3351                 CALEAdapterGattServerStart();
3352                 break;
3353             case ADAPTER_CLIENT:
3354                 CALEAdapterGattClientStart();
3355                 break;
3356             case ADAPTER_BOTH_CLIENT_SERVER:
3357                 CALEAdapterGattServerStart();
3358                 CALEAdapterGattClientStart();
3359                 break;
3360             default:
3361                 break;
3362         }
3363         oc_mutex_unlock(g_bleIsServerMutex);
3364     }
3365     else
3366     {
3367         oc_mutex_lock(g_bleIsServerMutex);
3368         switch (g_adapterType)
3369         {
3370             case ADAPTER_SERVER:
3371                 CALEAdapterGattServerStop();
3372                 break;
3373             case ADAPTER_CLIENT:
3374                 CALEAdapterGattClientStop();
3375                 break;
3376             case ADAPTER_BOTH_CLIENT_SERVER:
3377                 CALEAdapterGattServerStop();
3378                 CALEAdapterGattClientStop();
3379                 break;
3380             default:
3381                 break;
3382         }
3383         oc_mutex_unlock(g_bleIsServerMutex);
3384     }
3385
3386     if (NULL != g_networkCallback)
3387     {
3388         g_networkCallback(CA_ADAPTER_GATT_BTLE, adapter_state);
3389     }
3390     else
3391     {
3392         OIC_LOG(ERROR, CALEADAPTER_TAG, "g_networkCallback is NULL");
3393     }
3394
3395     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3396 }
3397
3398 static CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint,
3399                                             const uint8_t *data,
3400                                             uint32_t dataLen)
3401 {
3402     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
3403 #ifndef SINGLE_THREAD
3404     VERIFY_NON_NULL_RET(g_bleClientSendQueueHandle, CALEADAPTER_TAG,
3405                         "g_bleClientSendQueueHandle is  NULL",
3406                         CA_STATUS_FAILED);
3407
3408     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%u]", dataLen);
3409
3410     CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLen, NULL);
3411     if (!bleData)
3412     {
3413         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!");
3414         return CA_MEMORY_ALLOC_FAILED;
3415     }
3416     // Add message to send queue
3417
3418     CAResult_t res = CAQueueingThreadAddData(g_bleClientSendQueueHandle, bleData,
3419                                              sizeof(CALEData_t));
3420     if (CA_STATUS_OK != res)
3421     {
3422         CALEDataDestroyer(bleData, sizeof(CALEData_t));
3423     }
3424 #endif
3425     return CA_STATUS_OK;
3426 }
3427
3428 static CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint,
3429                                             const uint8_t *data,
3430                                             uint32_t dataLen)
3431 {
3432     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3433
3434     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
3435
3436 #ifdef SINGLE_THREAD
3437     if (!CAIsLEConnected())
3438     {
3439         OIC_LOG(ERROR, CALEADAPTER_TAG, "le not conn");
3440         return CA_STATUS_FAILED;
3441     }
3442
3443     CAResult_t result = CALEServerSendDataSingleThread(data, dataLen);
3444     if (CA_STATUS_OK != result)
3445     {
3446         OIC_LOG(ERROR, CALEADAPTER_TAG, "CALEServerSendDataSingleThread failed");
3447         return CA_STATUS_FAILED;
3448     }
3449 #else
3450     VERIFY_NON_NULL_RET(g_bleServerSendQueueHandle, CALEADAPTER_TAG,
3451                         "g_bleServerSendQueueHandle is NULL",
3452                         CA_STATUS_FAILED);
3453
3454     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%d]", dataLen);
3455
3456     CALEData_t * const bleData =
3457         CACreateLEData(remoteEndpoint, data, dataLen, NULL);
3458
3459     if (!bleData)
3460     {
3461         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!");
3462         return CA_MEMORY_ALLOC_FAILED;
3463     }
3464
3465     // Add message to send queue
3466
3467     CAResult_t res = CAQueueingThreadAddData(g_bleServerSendQueueHandle,
3468                                            bleData,
3469                                            sizeof(CALEData_t));
3470     if (CA_STATUS_OK != res)
3471     {
3472         CALEDataDestroyer(bleData, sizeof(CALEData_t));
3473     }
3474 #endif
3475     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3476     return CA_STATUS_OK;
3477 }
3478
3479 static CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress,
3480                                                 const uint8_t *data,
3481                                                 uint32_t dataLength,
3482                                                 uint32_t *sentLength)
3483 {
3484     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3485
3486     //Input validation
3487     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null");
3488     VERIFY_NON_NULL(sentLength, CALEADAPTER_TAG, "Sent data length holder is null");
3489
3490 #ifdef SINGLE_THREAD
3491     CALEDataReceiverHandlerSingleThread(data, dataLength);
3492
3493     if (g_singleThreadReceiveData->totalDataLen == g_singleThreadReceiveData->recvDataLen)
3494     {
3495         if(g_networkPacketReceivedCallback)
3496         {
3497             // will be filled by upper layer
3498             const CASecureEndpoint_t endpoint =
3499                 { .endpoint = { .adapter = CA_ADAPTER_GATT_BTLE } };
3500
3501             g_networkPacketReceivedCallback(&endpoint,
3502                                             g_singleThreadReceiveData->defragData,
3503                                             g_singleThreadReceiveData->recvDataLen);
3504         }
3505         g_singleThreadReceiveData->remoteEndpoint = NULL;
3506         OICFree(g_singleThreadReceiveData->defragData);
3507         g_singleThreadReceiveData->defragData = NULL;
3508         OICFree(g_singleThreadReceiveData);
3509         g_singleThreadReceiveData = NULL;
3510     }
3511 #else
3512     VERIFY_NON_NULL_RET(g_bleServerReceiverQueue,
3513                         CALEADAPTER_TAG,
3514                         "g_bleServerReceiverQueue",
3515                         CA_STATUS_FAILED);
3516
3517     //Add message to data queue
3518     CAEndpoint_t * const remoteEndpoint =
3519         CACreateEndpointObject(CA_DEFAULT_FLAGS,
3520                                CA_ADAPTER_GATT_BTLE,
3521                                remoteAddress,
3522                                0);
3523
3524     if (NULL == remoteEndpoint)
3525     {
3526         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create remote endpoint !");
3527         return CA_STATUS_FAILED;
3528     }
3529
3530     // Create bleData to add to queue
3531     OIC_LOG_V(DEBUG,
3532               CALEADAPTER_TAG,
3533               "Data received from LE Server layer [%d]",
3534               dataLength);
3535
3536     CALEData_t * const bleData =
3537         CACreateLEData(remoteEndpoint, data, dataLength, g_bleServerSenderInfo);
3538
3539     if (!bleData)
3540     {
3541         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!");
3542         CAFreeEndpoint(remoteEndpoint);
3543         return CA_MEMORY_ALLOC_FAILED;
3544     }
3545
3546     CAFreeEndpoint(remoteEndpoint);
3547     // Add message to receiver queue
3548     CAQueueingThreadAddData(g_bleServerReceiverQueue, bleData, sizeof(CALEData_t));
3549
3550     *sentLength = dataLength;
3551 #endif
3552     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3553     return CA_STATUS_OK;
3554 }
3555
3556 static CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress,
3557                                                 const uint8_t *data,
3558                                                 uint32_t dataLength,
3559                                                 uint32_t *sentLength)
3560 {
3561     //Input validation
3562     VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null");
3563     VERIFY_NON_NULL(sentLength, CALEADAPTER_TAG, "Sent data length holder is null");
3564 #ifndef SINGLE_THREAD
3565     VERIFY_NON_NULL_RET(g_bleClientReceiverQueue, CALEADAPTER_TAG,
3566                         "g_bleClientReceiverQueue",
3567                         CA_STATUS_FAILED);
3568
3569     //Add message to data queue
3570     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
3571                                                           CA_ADAPTER_GATT_BTLE,
3572                                                           remoteAddress, 0);
3573     if (NULL == remoteEndpoint)
3574     {
3575         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create remote endpoint !");
3576         return CA_STATUS_FAILED;
3577     }
3578
3579     // Create bleData to add to queue
3580     OIC_LOG_V(DEBUG,
3581               CALEADAPTER_TAG,
3582               "Data received from LE Client layer [%u]",
3583               dataLength);
3584
3585     CALEData_t * const bleData =
3586         CACreateLEData(remoteEndpoint, data, dataLength, g_bleClientSenderInfo);
3587
3588     if (!bleData)
3589     {
3590         OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!");
3591         CAFreeEndpoint(remoteEndpoint);
3592         return CA_MEMORY_ALLOC_FAILED;
3593     }
3594
3595     CAFreeEndpoint(remoteEndpoint);
3596     // Add message to receiver queue
3597     CAQueueingThreadAddData(g_bleClientReceiverQueue, bleData, sizeof(CALEData_t));
3598
3599     *sentLength = dataLength;
3600 #endif
3601     return CA_STATUS_OK;
3602 }
3603
3604 static void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle)
3605 {
3606     g_bleAdapterThreadPool = handle;
3607
3608 }
3609
3610 static void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback)
3611 {
3612     g_networkPacketReceivedCallback = callback;
3613
3614 }
3615
3616 static void CALEErrorHandler(const char *remoteAddress,
3617                              const uint8_t *data,
3618                              uint32_t dataLen,
3619                              CAResult_t result)
3620 {
3621     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3622
3623     VERIFY_NON_NULL_VOID(data, CALEADAPTER_TAG, "Data is null");
3624
3625     CAEndpoint_t *rep = CACreateEndpointObject(CA_DEFAULT_FLAGS,
3626                                                CA_ADAPTER_GATT_BTLE,
3627                                                remoteAddress,
3628                                                0);
3629
3630     // if required, will be used to build remote endpoint
3631     g_errorHandler(rep, data, dataLen, result);
3632
3633     CAFreeEndpoint(rep);
3634
3635     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3636 }
3637
3638 #ifndef SINGLE_THREAD
3639 static bool CALEClearQueueAddressDataContext(void *data, uint32_t size, void *ctx)
3640 {
3641     if (NULL == data || NULL == ctx)
3642     {
3643         return false;
3644     }
3645
3646     CALEData_t *caLeData = (CALEData_t *)data;
3647     const char *address = (const char *)ctx;
3648
3649     if (NULL != caLeData && NULL != caLeData->remoteEndpoint)
3650     {
3651         if (!strcasecmp(caLeData->remoteEndpoint->addr, address))
3652         {
3653             return true;
3654         }
3655     }
3656     return false;
3657 }
3658
3659 static void CALERemoveSendQueueData(CAQueueingThread_t *queueHandle, const char* address)
3660 {
3661     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
3662
3663     VERIFY_NON_NULL_VOID(queueHandle, CALEADAPTER_TAG, "queueHandle");
3664     VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
3665
3666     CAResult_t res = CAQueueingThreadClearContextData(queueHandle,
3667                                                       CALEClearQueueAddressDataContext,
3668                                                       address);
3669     if (CA_STATUS_OK != res)
3670     {
3671
3672         OIC_LOG(ERROR, CALEADAPTER_TAG, "Could not clear the send queue");
3673     }
3674
3675 }
3676
3677 static void CALERemoveReceiveQueueData(u_arraylist_t *dataInfoList, const char* address)
3678 {
3679     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
3680
3681     VERIFY_NON_NULL_VOID(dataInfoList, CALEADAPTER_TAG, "dataInfoList");
3682     VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
3683
3684     CABLESenderInfo_t *senderInfo = NULL;
3685     uint32_t senderIndex = 0;
3686
3687     u_arraylist_t *portList = u_arraylist_create();
3688     if (CA_STATUS_OK == CALEGetPortsFromSenderInfo(address, dataInfoList, portList))
3689     {
3690         uint32_t arrayLength = u_arraylist_length(portList);
3691         for (uint32_t i = 0; i < arrayLength; i++)
3692         {
3693             uint16_t *port = (uint16_t *)u_arraylist_get(portList, i);
3694             if (!port)
3695             {
3696                 OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to get port from sender info !");
3697                 u_arraylist_destroy(portList);
3698                 return;
3699             }
3700
3701             OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "port : %X", *port);
3702
3703             if (CA_STATUS_OK == CALEGetSenderInfo(address, *port,
3704                                                   dataInfoList, &senderInfo,
3705                                                   &senderIndex))
3706             {
3707                 OIC_LOG(DEBUG, CALEADAPTER_TAG,
3708                         "SenderInfo is removed for disconnection");
3709                 CALERemoveSenderInfoFromList(dataInfoList, senderInfo);
3710                 CALEFreeSenderInfo(senderInfo);
3711             }
3712             else
3713             {
3714                 OIC_LOG(DEBUG, CALEADAPTER_TAG, "SenderInfo doesn't exist");
3715             }
3716         }
3717     }
3718     u_arraylist_destroy(portList);
3719 }
3720
3721 static CAResult_t CALEGetPortsFromSenderInfo(const char *leAddress,
3722                                             u_arraylist_t *senderInfoList,
3723                                             u_arraylist_t *portList)
3724 {
3725     VERIFY_NON_NULL(leAddress,
3726                     CALEADAPTER_TAG,
3727                     "NULL BLE address argument");
3728
3729     const uint32_t listLength = u_arraylist_length(senderInfoList);
3730     const uint32_t addrLength = strlen(leAddress);
3731
3732     for (uint32_t index = 0; index < listLength; index++)
3733     {
3734         CABLESenderInfo_t *info = (CABLESenderInfo_t *) u_arraylist_get(senderInfoList, index);
3735         if (!info || !(info->remoteEndpoint))
3736         {
3737             continue;
3738         }
3739
3740         if (!strncmp(info->remoteEndpoint->addr, leAddress, addrLength))
3741         {
3742             uint16_t *port = (uint16_t *)OICMalloc(sizeof(uint16_t));
3743             if (!port)
3744             {
3745                 OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
3746                 return CA_MEMORY_ALLOC_FAILED;
3747             }
3748             *port = info->remoteEndpoint->port;
3749             u_arraylist_add(portList, (void *)port);
3750         }
3751     }
3752
3753     if (u_arraylist_length(portList) != 0)
3754     {
3755         return CA_STATUS_OK;
3756     }
3757     else
3758     {
3759         return CA_STATUS_FAILED;
3760     }
3761 }
3762 #endif
3763
3764 void CALEStartGattServer()
3765 {
3766     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3767
3768     oc_mutex_lock(g_bleIsServerMutex);
3769     switch (g_adapterType)
3770     {
3771         case ADAPTER_SERVER:
3772             CALEAdapterGattServerStart();
3773              break;
3774         case ADAPTER_CLIENT:
3775             CALEAdapterGattClientStart();
3776             break;
3777         case ADAPTER_BOTH_CLIENT_SERVER:
3778             CALEAdapterGattServerStart();
3779             CALEAdapterGattClientStart();
3780             break;
3781         default:
3782             break;
3783     }
3784     oc_mutex_unlock(g_bleIsServerMutex);
3785     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3786 }
3787
3788 void CALEStopGattServer()
3789 {
3790     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
3791
3792     oc_mutex_lock(g_bleIsServerMutex);
3793     switch (g_adapterType)
3794     {
3795         case ADAPTER_SERVER:
3796             CALEAdapterGattServerStop();
3797             break;
3798         case ADAPTER_CLIENT:
3799             CALEAdapterGattClientStop();
3800             break;
3801         case ADAPTER_BOTH_CLIENT_SERVER:
3802             CALEAdapterGattServerStop();
3803             CALEAdapterGattClientStop();
3804             break;
3805         default:
3806             break;
3807     }
3808     oc_mutex_unlock(g_bleIsServerMutex);
3809     OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
3810 }