#include "caleinterface.h"
#include "cacommon.h"
-#include "camutex.h"
+#include "octhread.h"
#include "caadapterutils.h"
+#ifdef __WITH_DTLS__
+#include "ca_adapter_net_ssl.h"
+#endif
#ifndef SINGLE_THREAD
#include "caqueueingthread.h"
#endif
#include "oic_malloc.h"
#include "oic_string.h"
#include "caremotehandler.h"
-#include "pdu.h"
+#include <coap/pdu.h>
/**
* Logging tag for module name.
/**
* Stores information of all the senders.
*
- * This structure will be used to track and defragment all incoming
- * data packet.
+ * This structure will be used to track and defragment all incoming data packet.
*/
typedef struct
{
uint32_t totalDataLen;
uint8_t *defragData;
CAEndpoint_t *remoteEndpoint;
- } CABLESenderInfo_t;
+ uint8_t refCount;
+} CABLESenderInfo_t;
typedef enum
{
} CABLEAdapter_t;
/**
+ * mtu size to use in fragmentation logic.
+ * default value is 20 byte.
+ */
+static uint16_t g_mtuSize = CA_DEFAULT_BLE_MTU_SIZE;
+
+/**
* Callback to provide the status of the network change to CA layer.
*/
static CAAdapterChangeCallback g_networkCallback = NULL;
*/
static CABLEAdapter_t g_adapterType = ADAPTER_EMPTY;
+#ifdef __WITH_DTLS__
+static CADataType_t g_dataType = CA_REQUEST_DATA;
+#endif
+
/**
* Mutex to synchronize the task to be executed on the GattServer
* function calls.
*/
-static ca_mutex g_bleIsServerMutex = NULL;
-
-/**
- * Mutex to synchronize the callback to be called for the network
- * changes.
- */
-static ca_mutex g_bleNetworkCbMutex = NULL;
+static oc_mutex g_bleIsServerMutex = NULL;
/**
* Mutex to synchronize the updates of the local LE address of the
* adapter.
*/
-static ca_mutex g_bleLocalAddressMutex = NULL;
+static oc_mutex g_bleLocalAddressMutex = NULL;
/**
* Reference to thread pool.
static ca_thread_pool_t g_bleAdapterThreadPool = NULL;
/**
- * Mutex to synchronize the task to be pushed to thread pool.
- */
-static ca_mutex g_bleAdapterThreadPoolMutex = NULL;
-
-/**
- * Mutex to synchronize the queing of the data from SenderQueue.
- */
-static ca_mutex g_bleClientSendDataMutex = NULL;
-
-/**
* Mutex to synchronize the queing of the data from ReceiverQueue.
*/
-static ca_mutex g_bleReceiveDataMutex = NULL;
+static oc_mutex g_bleClientReceiveDataMutex = NULL;
/**
- * Mutex to synchronize the queing of the data from SenderQueue.
- */
-static ca_mutex g_bleServerSendDataMutex = NULL;
-
-/**
- * Mutex to synchronize the callback to be called for the
- * adapterReqResponse.
+ * Mutex to synchronize the queing of the data from ReceiverQueue.
*/
-static ca_mutex g_bleAdapterReqRespCbMutex = NULL;
+static oc_mutex g_bleServerReceiveDataMutex = NULL;
/**
* Callback to be called when network packet received from either
*/
static CAErrorHandleCallback g_errorHandler = NULL;
+#ifdef __WITH_DTLS__
+static CAResult_t CALESecureReceiveDataCB(const CASecureEndpoint_t *endpoint,
+ const void *data, size_t dataLength);
+
+static ssize_t CALESecureSendDataCB(CAEndpoint_t *endpoint,
+ const void *data, size_t dataLength);
+#endif
+
#ifdef SINGLE_THREAD
/**
* Pointer to defragment received data from single threaded routine.
#ifndef SINGLE_THREAD
/**
- * Stop condition of recvhandler.
+ * Stop condition of Server recvhandler.
*/
-static bool g_dataBleReceiverHandlerState = false;
+static bool g_dataBleServerReceiverHandlerState = false;
/**
- * Sender information.
+ * Stop condition of Client recvhandler.
+ */
+static bool g_dataBleClientReceiverHandlerState = false;
+
+/**
+ * Sender information of Server.
*/
static u_arraylist_t *g_bleServerSenderInfo = NULL;
+/**
+ * Sender information of Client.
+ */
static u_arraylist_t *g_bleClientSenderInfo = NULL;
/**
+ * Mutex to synchronize access to all senderInfos
+ */
+static oc_mutex g_senderInfoMutex = NULL;
+
+/**
+ * Queue to process the outgoing packets from GATTServer.
+ */
+static CAQueueingThread_t *g_bleServerSendQueueHandle = NULL;
+
+/**
* Queue to process the outgoing packets from GATTClient.
*/
static CAQueueingThread_t *g_bleClientSendQueueHandle = NULL;
/**
- * Queue to process the incoming packets.
+ * Queue to process the incoming packets from GATTServer.
*/
-static CAQueueingThread_t *g_bleReceiverQueue = NULL;
+static CAQueueingThread_t *g_bleServerReceiverQueue = NULL;
/**
- * Queue to process the outgoing packets from GATTServer.
+ * Queue to process the incoming packets from GATTClient.
*/
-static CAQueueingThread_t *g_bleServerSendQueueHandle = NULL;
+static CAQueueingThread_t *g_bleClientReceiverQueue = NULL;
/**
* This function will be associated with the sender queue for
static void CALEClientSendDataThread(void *threadData);
/**
- * This function will be associated with the receiver queue.
- *
* This function will defragment the received data from each sender
* respectively and will send it up to CA layer. Respective sender's
* header will provide the length of the data sent.
*
+ * @param[in] threadData Data pushed to the queue which contains the
+ * info about RemoteEndpoint and Data.
+ * @param[in] receiverType Whether receiver is server or client.
+ */
+static void CALEDataReceiverHandler(void *threadData, CABLEAdapter_t receiverType);
+
+/**
+ * This function will be associated with the receiver queue for
+ * GattServer.
+ *
+ * This function will call the function CALEDataReceiverHandler()
+ * with server type to defragment the received data.
+ *
+ * @param[in] threadData Data pushed to the queue which contains the
+ * info about RemoteEndpoint and Data.
+ */
+static void CALEServerDataReceiverHandler(void *threadData);
+
+/**
+ * This function will be associated with the receiver queue for
+ * GattClient.
+ *
+ * This function will call the function CALEDataReceiverHandler()
+ * with client type to defragment the received data.
+ *
* @param[in] threadData Data pushed to the queue which contains the
* info about RemoteEndpoint and Data.
*/
-static void CALEDataReceiverHandler(void *threadData);
+static void CALEClientDataReceiverHandler(void *threadData);
/**
* This function will stop all queues created for GattServer and
/**
* This function will initialize the Receiver queue for
- * LEAdapter. This will initialize the queue to process the function
- * CABLEDataReceiverHandler() when ever the task is added to this
+ * GattServer. This will initialize the queue to process the function
+ * CALEServerDataReceiverHandler() when ever the task is added to this
+ * queue.
+ *
+ * @return ::CA_STATUS_OK or Appropriate error code
+ * @retval ::CA_STATUS_OK Successful
+ * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments
+ * @retval ::CA_STATUS_FAILED Operation failed
+ *
+ */
+static CAResult_t CAInitLEServerReceiverQueue();
+
+/**
+ * This function will initialize the Receiver queue for
+ * GattClient. This will initialize the queue to process the function
+ * CALEClientDataReceiverHandler() when ever the task is added to this
* queue.
*
* @return ::CA_STATUS_OK or Appropriate error code
* @retval ::CA_STATUS_FAILED Operation failed
*
*/
-static CAResult_t CAInitLEReceiverQueue();
+static CAResult_t CAInitLEClientReceiverQueue();
/**
* This function will create the Data required to send it in the
* @param[in] address target address to remove data in queue.
*/
static void CALERemoveSendQueueData(CAQueueingThread_t *queueHandle,
- ca_mutex mutex,
const char* address);
/**
/**
* get received data info and positioned index from the received data list
* for client / server which is matched same leAddress and port.
+ * CABLESenderInfo_t is reference counted structure, you must call
+ * CALEFreeSenderInfo on senderInfo to release reference.
*
* @param[in] leAddress target address to get serderInfo.
- * @param[in] port target port to get serderInfo.
+ * @param[in] port target port to get senderInfo.
* @param[in] senderInfoList received data list for client / server.
* @param[out] senderInfo Pointer to contain matched(leAddress and port)
* received data info.
uint32_t *senderIndex);
/**
+ * Add sender info to list.
+ *
+ * @param[in] u_arraylist_t Array list to add sender info to.
+ * @param[in] senderInfo Sender info to be added to list.
+ *
+ * @return true on success, otherwise false.
+ */
+static bool CALEAddSenderInfoToList(u_arraylist_t *senderInfoList,
+ CABLESenderInfo_t *senderInfo);
+
+/**
+ * Remove desired sender info from list.
+ *
+ * @param[in] u_arraylist_t Array list to remove sender info from.
+ * @param[in] senderInfo Sender info to be removed from list.
+ *
+ */
+static void CALERemoveSenderInfoFromList(u_arraylist_t *senderInfoList,
+ CABLESenderInfo_t *senderInfo);
+
+/**
+ * Free sender info. CABLESenderInfo_t is reference counted structure
+ * and info will be freed only when reference count reaches 0 or negative.
+ *
+ * @param[in] senderInfo Sender info to be freed.
+ *
+ */
+static CAResult_t CALEFreeSenderInfo(CABLESenderInfo_t *senderInfo);
+
+/**
* get ports related to remote address. It is need because multi application
* can have more than 2 senderInfo using same BLE address. So before remove
* receive queue data, should get port list from sender Info.
static CAResult_t CAInitLEServerQueues()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
- ca_mutex_lock(g_bleAdapterThreadPoolMutex);
-
CAResult_t result = CAInitLEServerSenderQueue();
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleServerSenderQueue failed");
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
+
return CA_STATUS_FAILED;
}
if (!g_bleServerSenderInfo)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
return CA_MEMORY_ALLOC_FAILED;
}
- result = CAInitLEReceiverQueue();
+ result = CAInitLEServerReceiverQueue();
if (CA_STATUS_OK != result)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEReceiverQueue failed");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEServerReceiverQueue failed");
u_arraylist_free(&g_bleServerSenderInfo);
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
return CA_STATUS_FAILED;
}
- g_dataBleReceiverHandlerState = true;
-
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ g_dataBleServerReceiverHandlerState = true;
return CA_STATUS_OK;
}
static CAResult_t CAInitLEClientQueues()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
- ca_mutex_lock(g_bleAdapterThreadPoolMutex);
-
CAResult_t result = CAInitLEClientSenderQueue();
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleClientSenderQueue failed");
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
return CA_STATUS_FAILED;
}
if (!g_bleClientSenderInfo)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
return CA_MEMORY_ALLOC_FAILED;
}
- result = CAInitLEReceiverQueue();
+ result = CAInitLEClientReceiverQueue();
if (CA_STATUS_OK != result)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEReceiverQueue failed");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitLEClientReceiverQueue failed");
u_arraylist_free(&g_bleClientSenderInfo);
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
return CA_STATUS_FAILED;
}
- g_dataBleReceiverHandlerState = true;
+ g_dataBleClientReceiverHandlerState = true;
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
+ return CA_STATUS_OK;
+}
+
+static CAResult_t CAInitLEServerReceiverQueue()
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+ // Check if the message queue is already initialized
+ if (g_bleServerReceiverQueue)
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!");
+ return CA_STATUS_OK;
+ }
+
+ // Create recv message queue
+ g_bleServerReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
+ if (!g_bleServerReceiverQueue)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
+ return CA_MEMORY_ALLOC_FAILED;
+ }
+
+ if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerReceiverQueue,
+ g_bleAdapterThreadPool,
+ CALEServerDataReceiverHandler,
+ CALEDataDestroyer))
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize server receiver queue thread");
+ OICFree(g_bleServerReceiverQueue);
+ g_bleServerReceiverQueue = NULL;
+ return CA_STATUS_FAILED;
+ }
+
+ if (CA_STATUS_OK != CAQueueingThreadStart(g_bleServerReceiverQueue))
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed ");
+ OICFree(g_bleServerReceiverQueue);
+ g_bleServerReceiverQueue = NULL;
+ return CA_STATUS_FAILED;
+ }
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
-static CAResult_t CAInitLEReceiverQueue()
+static CAResult_t CAInitLEClientReceiverQueue()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAInitLEReceiverQueue");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
// Check if the message queue is already initialized
- if (g_bleReceiverQueue)
+ if (g_bleClientReceiverQueue)
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!");
return CA_STATUS_OK;
}
// Create recv message queue
- g_bleReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
- if (!g_bleReceiverQueue)
+ g_bleClientReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
+ if (!g_bleClientReceiverQueue)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!");
return CA_MEMORY_ALLOC_FAILED;
}
- if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleReceiverQueue,
+ if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientReceiverQueue,
g_bleAdapterThreadPool,
- CALEDataReceiverHandler,
+ CALEClientDataReceiverHandler,
CALEDataDestroyer))
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread");
- OICFree(g_bleReceiverQueue);
- g_bleReceiverQueue = NULL;
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize client receiver queue thread");
+ OICFree(g_bleClientReceiverQueue);
+ g_bleClientReceiverQueue = NULL;
return CA_STATUS_FAILED;
}
- if (CA_STATUS_OK != CAQueueingThreadStart(g_bleReceiverQueue))
+ if (CA_STATUS_OK != CAQueueingThreadStart(g_bleClientReceiverQueue))
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed ");
- OICFree(g_bleReceiverQueue);
- g_bleReceiverQueue = NULL;
+ OICFree(g_bleClientReceiverQueue);
+ g_bleClientReceiverQueue = NULL;
return CA_STATUS_FAILED;
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
static CAResult_t CAInitLEServerSenderQueue()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAInitLEServerSenderQueue");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
// Check if the message queue is already initialized
if (g_bleServerSendQueueHandle)
{
return CA_STATUS_FAILED;
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
-static void CALEClearSenderInfoImpl(u_arraylist_t ** list)
+static void CALEClearSenderInfoImpl(u_arraylist_t **list)
{
+ oc_mutex_lock(g_senderInfoMutex);
const size_t length = u_arraylist_length(*list);
for (size_t i = 0; i < length; ++i)
{
}
}
u_arraylist_free(list);
+ oc_mutex_unlock(g_senderInfoMutex);
}
static void CALEClearSenderInfo()
static CAResult_t CAInitLEClientSenderQueue()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAInitLEClientSenderQueue");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
if (g_bleClientSendQueueHandle)
{
g_bleClientSendQueueHandle = NULL;
return CA_STATUS_FAILED;
}
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CAInitLEClientSenderQueue");
return CA_STATUS_OK;
}
static void CAStopLEQueues()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAStopLEQueues");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
- ca_mutex_lock(g_bleReceiveDataMutex);
- if (NULL != g_bleReceiverQueue)
+ oc_mutex_lock(g_bleServerReceiveDataMutex);
+ if (NULL != g_bleServerReceiverQueue)
{
- CAQueueingThreadStop(g_bleReceiverQueue);
+ CAQueueingThreadStop(g_bleServerReceiverQueue);
}
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(g_bleServerReceiveDataMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CAStopLEQueues");
+ oc_mutex_lock(g_bleClientReceiveDataMutex);
+ if (NULL != g_bleClientReceiverQueue)
+ {
+ CAQueueingThreadStop(g_bleClientReceiverQueue);
+ }
+ oc_mutex_unlock(g_bleClientReceiveDataMutex);
+
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static void CATerminateLEQueues()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
CAQueueingThreadDestroy(g_bleClientSendQueueHandle);
OICFree(g_bleClientSendQueueHandle);
g_bleClientSendQueueHandle = NULL;
OICFree(g_bleServerSendQueueHandle);
g_bleServerSendQueueHandle = NULL;
- CAQueueingThreadDestroy(g_bleReceiverQueue);
- OICFree(g_bleReceiverQueue);
- g_bleReceiverQueue = NULL;
+ CAQueueingThreadDestroy(g_bleServerReceiverQueue);
+ OICFree(g_bleServerReceiverQueue);
+ g_bleServerReceiverQueue = NULL;
- CALEClearSenderInfo();
+ CAQueueingThreadDestroy(g_bleClientReceiverQueue);
+ OICFree(g_bleClientReceiverQueue);
+ g_bleClientReceiverQueue = NULL;
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ CALEClearSenderInfo();
}
static CAResult_t CALEGetSenderInfo(const char *leAddress,
"NULL index argument",
CA_STATUS_INVALID_PARAM);
+ oc_mutex_lock(g_senderInfoMutex);
const uint32_t listLength = u_arraylist_length(senderInfoList);
const uint32_t addrLength = strlen(leAddress);
for (uint32_t index = 0; index < listLength; index++)
continue;
}
- if (!strncmp(info->remoteEndpoint->addr, leAddress, addrLength))
+ if (!strncmp(info->remoteEndpoint->addr, leAddress, addrLength)
+ && info->remoteEndpoint->port == port)
{
- if (info->remoteEndpoint->port == port)
+ *senderIndex = index;
+ if (senderInfo)
{
- *senderIndex = index;
- if (senderInfo)
- {
- *senderInfo = info;
- }
- return CA_STATUS_OK;
+ *senderInfo = info;
+ (*senderInfo)->refCount++;
}
+ oc_mutex_unlock(g_senderInfoMutex);
+ return CA_STATUS_OK;
}
}
+ oc_mutex_unlock(g_senderInfoMutex);
return CA_STATUS_FAILED;
}
-static void CALEDataReceiverHandler(void *threadData)
+static bool CALEAddSenderInfoToList(u_arraylist_t *senderInfoList, CABLESenderInfo_t *senderInfo)
+{
+ oc_mutex_lock(g_senderInfoMutex);
+ senderInfo->refCount++;
+ if (!u_arraylist_add(senderInfoList,(void *)senderInfo))
+ {
+ senderInfo->refCount--;
+ oc_mutex_unlock(g_senderInfoMutex);
+ return false;
+ }
+ oc_mutex_unlock(g_senderInfoMutex);
+ return true;
+}
+
+static void CALERemoveSenderInfoFromList(u_arraylist_t *senderInfoList, CABLESenderInfo_t *senderInfo)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CALEDataReceiverHandler");
+ oc_mutex_lock(g_senderInfoMutex);
+ uint32_t idx;
+ bool elemFound = u_arraylist_get_index(senderInfoList, (const void*)senderInfo, &idx);
+ if(elemFound)
+ {
+ void *info = u_arraylist_remove(senderInfoList, idx);
+ if (info != NULL)
+ {
+ senderInfo->refCount--;
+ }
+ }
+ oc_mutex_unlock(g_senderInfoMutex);
+}
- ca_mutex_lock(g_bleReceiveDataMutex);
+static CAResult_t CALEFreeSenderInfo(CABLESenderInfo_t *senderInfo)
+{
+ VERIFY_NON_NULL_RET(senderInfo,
+ CALEADAPTER_TAG,
+ "NULL senderInfo to remove argument",
+ CA_STATUS_INVALID_PARAM);
- if (g_dataBleReceiverHandlerState)
+ oc_mutex_lock(g_senderInfoMutex);
+ senderInfo->refCount--;
+ if(senderInfo->refCount <= 0)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "checking for DE Fragmentation");
+ OICFree(senderInfo->defragData);
+ OICFree(senderInfo->remoteEndpoint);
+ OICFree(senderInfo);
+ }
+ oc_mutex_unlock(g_senderInfoMutex);
+ return CA_STATUS_OK;
+}
+
+static void CALEDataReceiverHandler(void *threadData, CABLEAdapter_t receiverType)
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+
+ oc_mutex bleReceiveDataMutex = NULL;
+ bool dataBleReceiverHandlerState = false;
+ switch (receiverType)
+ {
+ case ADAPTER_CLIENT:
+ bleReceiveDataMutex = g_bleClientReceiveDataMutex;
+ dataBleReceiverHandlerState = g_dataBleClientReceiverHandlerState;
+ break;
+ case ADAPTER_SERVER:
+ bleReceiveDataMutex = g_bleServerReceiveDataMutex;
+ dataBleReceiverHandlerState = g_dataBleServerReceiverHandlerState;
+ break;
+ default:
+ OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Unsupported receiver type : %d", receiverType);
+ return;
+ }
+
+ oc_mutex_lock(bleReceiveDataMutex);
+
+ if (dataBleReceiverHandlerState)
+ {
CALEData_t *bleData = (CALEData_t *) threadData;
if (!bleData)
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bleData!");
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
if (!(bleData->senderInfo))
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "sender info is not available");
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
if (!(bleData->remoteEndpoint))
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "Client RemoteEndPoint NULL!!");
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "RemoteEndPoint NULL!!");
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
uint16_t destPort = 0;
CAParseHeader(bleData->data, &startFlag, &sourcePort, &secureFlag, &destPort);
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
+ OIC_LOG_V(INFO, CALEADAPTER_TAG,
"header info: startFlag[%X] sourcePort[%d] secureFlag[%X] destPort[%d]",
startFlag, sourcePort, secureFlag, destPort);
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"this packet is not valid for this app(port mismatch[mine:%d, packet:%d])",
g_localBLESourcePort, destPort);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
{
OIC_LOG(ERROR, CALEADAPTER_TAG,
"This packet is start packet but exist senderInfo. Remove senderInfo");
- u_arraylist_remove(bleData->senderInfo, senderIndex);
- OICFree(senderInfo->defragData);
- OICFree(senderInfo);
+ CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
+ CALEFreeSenderInfo(senderInfo);
senderInfo = NULL;
senderIndex = 0;
}
else
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "This packet is wrong packet! ignore.");
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
- CABLESenderInfo_t *newSender = OICMalloc(sizeof(CABLESenderInfo_t));
+ CABLESenderInfo_t *newSender = OICCalloc(1, sizeof(CABLESenderInfo_t));
if (!newSender)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed for new sender");
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
- newSender->recvDataLen = 0;
- newSender->totalDataLen = 0;
- newSender->defragData = NULL;
- newSender->remoteEndpoint = NULL;
OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header");
newSender->totalDataLen = totalLength;
-
if (!(newSender->totalDataLen))
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "Total Data Length is parsed as 0!!!");
- OICFree(newSender);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALEFreeSenderInfo(newSender);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
size_t dataOnlyLen =
bleData->dataLen - (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE);
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Total data to be accumulated [%u] bytes",
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "Total data to be accumulated [%u] bytes",
newSender->totalDataLen);
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "data received in the first packet [%u] bytes",
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "data received in the first packet [%zu] bytes",
dataOnlyLen);
newSender->defragData = OICCalloc(newSender->totalDataLen + 1,
if (NULL == newSender->defragData)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!");
- OICFree(newSender);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALEFreeSenderInfo(newSender);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
+ CATransportFlags_t flags = CA_DEFAULT_FLAGS;
+#ifdef __WITH_DTLS__
+ if (CA_BLE_PACKET_SECURE == secureFlag)
+ {
+ flags |= CA_SECURE;
+ }
+#endif
const char *remoteAddress = bleData->remoteEndpoint->addr;
- newSender->remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
+ newSender->remoteEndpoint = CACreateEndpointObject(flags,
CA_ADAPTER_GATT_BTLE,
remoteAddress,
bleData->remoteEndpoint->port);
if (NULL == newSender->remoteEndpoint)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "remoteEndpoint is NULL!");
- OICFree(newSender->defragData);
- OICFree(newSender);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALEFreeSenderInfo(newSender);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
if (newSender->recvDataLen + dataOnlyLen > newSender->totalDataLen)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "buffer is smaller than received data");
- OICFree(newSender->defragData);
- CAFreeEndpoint(newSender->remoteEndpoint);
- OICFree(newSender);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALEFreeSenderInfo(newSender);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
memcpy(newSender->defragData,
dataOnlyLen);
newSender->recvDataLen += dataOnlyLen;
- u_arraylist_add(bleData->senderInfo,(void *)newSender);
+ newSender->refCount = 1;
- //Getting newSender index position in bleSenderInfo array list
- if (CA_STATUS_OK !=
- CALEGetSenderInfo(newSender->remoteEndpoint->addr,
- newSender->remoteEndpoint->port,
- bleData->senderInfo,
- NULL, &senderIndex))
+ if (!CALEAddSenderInfoToList(bleData->senderInfo, newSender))
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "Existing sender index not found!!");
- OICFree(newSender->defragData);
- CAFreeEndpoint(newSender->remoteEndpoint);
- OICFree(newSender);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to add sender info!");
+ CALEFreeSenderInfo(newSender);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
+
senderInfo = newSender;
}
else
if (senderInfo->recvDataLen + dataOnlyLen > senderInfo->totalDataLen)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Data Length exceeding error!! Receiving [%d] total length [%d]",
+ "Data Length exceeding error!! Receiving [%zu] total length [%u]",
senderInfo->recvDataLen + dataOnlyLen, senderInfo->totalDataLen);
- u_arraylist_remove(bleData->senderInfo, senderIndex);
- OICFree(senderInfo->defragData);
- OICFree(senderInfo);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
+ CALEFreeSenderInfo(senderInfo);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%d]",
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%zu]",
dataOnlyLen);
memcpy(senderInfo->defragData + senderInfo->recvDataLen,
bleData->data + CA_BLE_HEADER_SIZE,
dataOnlyLen);
senderInfo->recvDataLen += dataOnlyLen;
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "totalDatalength [%d] received Datalen [%d]",
- senderInfo->totalDataLen, senderInfo->recvDataLen);
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "totalDatalength [%d] received Datalen [%d]",
+ senderInfo->totalDataLen, senderInfo->recvDataLen);
}
if (senderInfo->totalDataLen == senderInfo->recvDataLen)
{
- ca_mutex_lock(g_bleAdapterReqRespCbMutex);
if (NULL == g_networkPacketReceivedCallback)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "gReqRespCallback is NULL!");
-
- u_arraylist_remove(bleData->senderInfo, senderIndex);
- OICFree(senderInfo->defragData);
- OICFree(senderInfo);
- ca_mutex_unlock(g_bleAdapterReqRespCbMutex);
- ca_mutex_unlock(g_bleReceiveDataMutex);
+ CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
+ CALEFreeSenderInfo(senderInfo);
+ oc_mutex_unlock(bleReceiveDataMutex);
return;
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "[CALEDataReceiverHandler] Sending data up !");
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "[CALEDataReceiverHandler] Received data up !");
const CASecureEndpoint_t tmp =
{
.endpoint = *senderInfo->remoteEndpoint
};
- g_networkPacketReceivedCallback(&tmp,
- senderInfo->defragData,
- senderInfo->recvDataLen);
- ca_mutex_unlock(g_bleAdapterReqRespCbMutex);
- u_arraylist_remove(bleData->senderInfo, senderIndex);
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "endpoint flags : %d", tmp.endpoint.flags);
+#ifdef __WITH_DTLS__
+ if (CA_SECURE & tmp.endpoint.flags)
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "Secure data received");
+ switch (receiverType)
+ {
+ case ADAPTER_CLIENT:
+ g_dataType = CA_REQUEST_DATA;
+ break;
+ case ADAPTER_SERVER:
+ g_dataType = CA_RESPONSE_DATA;
+ break;
+ default:
+ OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Unsupported rcvr type:%d",receiverType);
+ CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
+ senderInfo->remoteEndpoint = NULL;
+ senderInfo->defragData = NULL;
+ CALEFreeSenderInfo(senderInfo);
+ oc_mutex_unlock(bleReceiveDataMutex);
+ return;
+ }
+
+ if (CA_STATUS_FAILED == CAdecryptSsl(&tmp,
+ senderInfo->defragData,
+ senderInfo->recvDataLen))
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAdecryptSsl failed");
+ }
+ else
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "CAdecryptSsl successed");
+ }
+ OICFree(senderInfo->defragData);
+ }
+ else
+ {
+#endif
+ OIC_LOG(INFO, CALEADAPTER_TAG, "Non-Secure data received");
+ g_networkPacketReceivedCallback(&tmp,
+ senderInfo->defragData,
+ senderInfo->recvDataLen);
+#ifdef __WITH_DTLS__
+ }
+#endif
+
+ CALERemoveSenderInfoFromList(bleData->senderInfo, senderInfo);
senderInfo->remoteEndpoint = NULL;
senderInfo->defragData = NULL;
- OICFree(senderInfo);
+ CALEFreeSenderInfo(senderInfo);
+ oc_mutex_unlock(bleReceiveDataMutex);
+ return;
}
+ CALEFreeSenderInfo(senderInfo);
}
- ca_mutex_unlock(g_bleReceiveDataMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ oc_mutex_unlock(bleReceiveDataMutex);
+}
+
+
+static void CALEServerDataReceiverHandler(void *threadData)
+{
+ CALEDataReceiverHandler(threadData, ADAPTER_SERVER);
+}
+
+static void CALEClientDataReceiverHandler(void *threadData)
+{
+ CALEDataReceiverHandler(threadData, ADAPTER_CLIENT);
}
static void CALEServerSendDataThread(void *threadData)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CALEServerSendDataThread");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
CALEData_t * const bleData = (CALEData_t *) threadData;
if (!bleData)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bledata!");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid bledata!");
+ return;
+ }
+
+ if (!bleData->remoteEndpoint)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid endpoint of bledata!");
return;
}
+#if defined(__TIZEN__) || defined(__ANDROID__)
+ // get MTU size
+ g_mtuSize = CALEServerGetMtuSize(bleData->remoteEndpoint->addr);
+#endif
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "MTU size [%d]", g_mtuSize);
+
uint32_t midPacketCount = 0;
size_t remainingLen = 0;
size_t totalLength = 0;
CAResult_t result = CAGenerateVariableForFragmentation(bleData->dataLen,
&midPacketCount,
&remainingLen,
- &totalLength);
+ &totalLength,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateVariableForFragmentation failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Packet info: data size[%d] midPacketCount[%d] remainingLen[%d] totalLength[%d]",
+ "Packet info: data size[%d] midPacketCount[%u] remainingLen[%zu] totalLength[%zu]",
bleData->dataLen, midPacketCount, remainingLen, totalLength);
OIC_LOG_V(DEBUG,
CALEADAPTER_TAG,
- "Server total Data length with header is [%u]",
+ "Server total Data length with header is [%zu]",
totalLength);
uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
if (NULL != bleData->remoteEndpoint) //Unicast Data
{
- secureFlag = bleData->remoteEndpoint->flags == CA_SECURE ?
+ secureFlag = (bleData->remoteEndpoint->flags & CA_SECURE) ?
CA_BLE_PACKET_SECURE : CA_BLE_PACKET_NON_SECURE;
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This Packet is secure? %d", secureFlag);
result = CAGenerateHeader(dataHeader,
CA_BLE_PACKET_START,
g_localBLESourcePort,
secureFlag,
CA_BLE_MULTICAST_PORT);
}
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "header info: secureFlag[%X]", secureFlag);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeaderPayloadLength failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
uint32_t length = 0;
uint32_t dataLen = 0;
- if (CA_SUPPORTED_BLE_MTU_SIZE > totalLength)
+ if (g_mtuSize > totalLength)
{
- length = totalLength;
+ length = (uint32_t)totalLength;
dataLen = bleData->dataLen;
}
else
{
- length = CA_SUPPORTED_BLE_MTU_SIZE;
- dataLen = CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
+ length = g_mtuSize;
+ dataLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
}
result = CAMakeFirstDataSegment(dataSegment,
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
CALEADAPTER_TAG,
"Update characteristics failed, result [%d]",
result);
-
- g_errorHandler(bleData->remoteEndpoint,
- bleData->data,
- bleData->dataLen,
- result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint,
+ bleData->data,
+ bleData->dataLen,
+ result);
+ }
return;
}
OIC_LOG_V(DEBUG,
CALEADAPTER_TAG,
- "Server Sent data length [%u]",
+ "Server Sent Unicast First Data - data length [%u]",
length);
result = CAGenerateHeader(dataHeader,
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
for (index = 0; index < iter; index++)
{
// Send the remaining header.
- OIC_LOG_V(DEBUG,
- CALEADAPTER_TAG,
- "Sending the chunk number [%u]",
- index);
-
result = CAMakeRemainDataSegment(dataSegment,
+ g_mtuSize - CA_BLE_HEADER_SIZE,
bleData->data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE,
+ bleData->dataLen,
index,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
CAUpdateCharacteristicsToGattClient(
bleData->remoteEndpoint->addr,
dataSegment,
- CA_SUPPORTED_BLE_MTU_SIZE);
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Update characteristics failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]",
- CA_SUPPORTED_BLE_MTU_SIZE);
+ g_mtuSize);
}
- if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE))
+ if (remainingLen && (totalLength > g_mtuSize))
{
// send the last segment of the data (Ex: 22 bytes of 622
// bytes of data when MTU is 200)
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
-
result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
remainingLen,
+ bleData->data,
+ bleData->dataLen,
index,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
CALEADAPTER_TAG,
"Update characteristics failed, result [%d]",
result);
- g_errorHandler(bleData->remoteEndpoint,
- bleData->data,
- bleData->dataLen,
- result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint,
+ bleData->data,
+ bleData->dataLen,
+ result);
+ }
return;
}
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Server Sent data length [%d]", remainingLen + CA_BLE_HEADER_SIZE);
+ OIC_LOG_V(DEBUG,
+ CALEADAPTER_TAG,
+ "Server Sent Unicast Last Data - data length [%zu]",
+ remainingLen + CA_BLE_HEADER_SIZE);
}
}
else
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "Server Sending Multicast data");
- result = CAUpdateCharacteristicsToAllGattClients(dataSegment, length);
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
- result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]", length);
-
- result = CAGenerateHeader(dataHeader,
- CA_BLE_PACKET_NOT_START,
- g_localBLESourcePort,
- secureFlag,
- CA_BLE_MULTICAST_PORT);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- for (index = 0; index < iter; index++)
- {
- // Send the remaining header.
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Sending the chunk number [%d]", index);
-
- result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE,
- index,
- dataHeader);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- result = CAUpdateCharacteristicsToAllGattClients(
- dataSegment,
- CA_SUPPORTED_BLE_MTU_SIZE);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
- result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%u]",
- CA_SUPPORTED_BLE_MTU_SIZE);
- }
-
- if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE))
- {
- // send the last segment of the data
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
-
- result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
- remainingLen,
- index,
- dataHeader);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- result = CAUpdateCharacteristicsToAllGattClients(
- dataSegment,
- remainingLen + CA_BLE_HEADER_SIZE);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
- result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Server Sent data length [%d]", remainingLen + CA_BLE_HEADER_SIZE);
- }
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "BLE Multicast is not supported");
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CALEServerSendDataThread");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static void CALEClientSendDataThread(void *threadData)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CALEClientSendDataThread");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
CALEData_t *bleData = (CALEData_t *) threadData;
if (!bleData)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bledata!");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid bledata!");
+ return;
+ }
+
+ if (!bleData->remoteEndpoint)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Invalid endpoint of bledata!");
return;
}
+#if defined(__ANDROID__)
+ // get MTU size
+ if (false == CALEClientIsConnected(bleData->remoteEndpoint->addr))
+ {
+ // triggering to gatt connect and MTU negotiation
+ CAResult_t res = CALEClientSendNegotiationMessage(
+ bleData->remoteEndpoint->addr);
+
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG_V(ERROR,
+ CALEADAPTER_TAG,
+ "CALEClientSendNegotiationMessage has failed, result [%d]",
+ res);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint,
+ bleData->data,
+ bleData->dataLen,
+ res);
+ }
+ return;
+ }
+ }
+#endif
+#if defined(__TIZEN__) || defined(__ANDROID__)
+ g_mtuSize = CALEClientGetMtuSize(bleData->remoteEndpoint->addr);
+#endif
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "MTU size [%d]", g_mtuSize);
+
uint32_t midPacketCount = 0;
size_t remainingLen = 0;
size_t totalLength = 0;
CAResult_t result = CAGenerateVariableForFragmentation(bleData->dataLen,
&midPacketCount,
&remainingLen,
- &totalLength);
+ &totalLength,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateVariableForFragmentation failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Packet info: data size[%d] midPacketCount[%d] remainingLen[%d] totalLength[%d]",
+ "Packet info: data size[%d] midPacketCount[%u] remainingLen[%zu] totalLength[%zu]",
bleData->dataLen, midPacketCount, remainingLen, totalLength);
uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
if (NULL != bleData->remoteEndpoint) //Unicast Data
{
- secureFlag = bleData->remoteEndpoint->flags == CA_SECURE ?
+ secureFlag = (bleData->remoteEndpoint->flags & CA_SECURE) ?
CA_BLE_PACKET_SECURE : CA_BLE_PACKET_NON_SECURE;
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This Packet is secure? %d", secureFlag);
result = CAGenerateHeader(dataHeader,
CA_BLE_PACKET_START,
g_localBLESourcePort,
CA_BLE_MULTICAST_PORT);
}
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "header info: secureFlag[%X]", secureFlag);
+
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeaderPayloadLength failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
uint32_t length = 0;
uint32_t dataLen = 0;
- if (CA_SUPPORTED_BLE_MTU_SIZE > totalLength)
+ if (g_mtuSize > totalLength)
{
- length = totalLength;
+ length = (uint32_t)totalLength;
dataLen = bleData->dataLen;
}
else
{
- length = CA_SUPPORTED_BLE_MTU_SIZE;
- dataLen = CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
+ length = g_mtuSize;
+ dataLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
}
result = CAMakeFirstDataSegment(dataSegment,
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
CALEADAPTER_TAG,
"Update characteristics failed, result [%d]",
result);
- g_errorHandler(bleData->remoteEndpoint,
- bleData->data,
- bleData->dataLen,
- result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint,
+ bleData->data,
+ bleData->dataLen,
+ result);
+ }
return;
}
-
OIC_LOG_V(DEBUG,
CALEADAPTER_TAG,
- "Client Sent Data length is [%u]",
+ "Client Sent Unicast First Data - data length [%u]",
length);
result = CAGenerateHeader(dataHeader,
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
for (index = 0; index < iter; index++)
{
result = CAMakeRemainDataSegment(dataSegment,
+ g_mtuSize - CA_BLE_HEADER_SIZE,
bleData->data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE,
+ bleData->dataLen,
index,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
result = CAUpdateCharacteristicsToGattServer(
bleData->remoteEndpoint->addr,
dataSegment,
- CA_SUPPORTED_BLE_MTU_SIZE,
+ g_mtuSize,
LE_UNICAST, 0);
if (CA_STATUS_OK != result)
CALEADAPTER_TAG,
"Update characteristics failed, result [%d]",
result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Client Sent Data length is [%d]",
- CA_SUPPORTED_BLE_MTU_SIZE);
+ OIC_LOG_V(DEBUG,
+ CALEADAPTER_TAG,
+ "Client Sent Unicast %d Data - data(mtu) length [%hu]",
+ index + 1,
+ g_mtuSize);
}
- if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE))
+ if (remainingLen && (totalLength > g_mtuSize))
{
// send the last segment of the data (Ex: 22 bytes of 622
// bytes of data when MTU is 200)
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
-
result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
remainingLen,
+ bleData->data,
+ bleData->dataLen,
index,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG,
"Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
{
OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ if (g_errorHandler)
+ {
+ g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
+ }
return;
}
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Client Sent Data length is [%d]", remainingLen + CA_BLE_HEADER_SIZE);
+ OIC_LOG_V(DEBUG,
+ CALEADAPTER_TAG,
+ "Client Sent Unicast Last Data - data length [%zu]",
+ remainingLen + CA_BLE_HEADER_SIZE);
}
}
else
{
//Sending Mulitcast Data
- // Send the first segment with the header.
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending Multicast Data");
- result = CAUpdateCharacteristicsToAllGattServers(dataSegment, length);
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Update characteristics (all) failed, result [%d]", result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return ;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Client Sent Data length is [%d]", length);
-
- result = CAGenerateHeader(dataHeader,
- CA_BLE_PACKET_NOT_START,
- g_localBLESourcePort,
- secureFlag,
- 0);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "CAGenerateHeader failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- // Send the remaining header.
- for (index = 0; index < iter; index++)
- {
- result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE,
- index,
- dataHeader);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- result = CAUpdateCharacteristicsToAllGattServers(
- dataSegment,
- CA_SUPPORTED_BLE_MTU_SIZE);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]",
- result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Client Sent Data length is [%d]",
- CA_SUPPORTED_BLE_MTU_SIZE);
- }
-
- if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE))
- {
- // send the last segment of the data (Ex: 22 bytes of 622
- // bytes of data when MTU is 200)
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
-
- result = CAMakeRemainDataSegment(dataSegment,
- bleData->data,
- remainingLen,
- index,
- dataHeader);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Making data segment failed, result [%d]", result);
- g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result);
- return;
- }
-
- result =
- CAUpdateCharacteristicsToAllGattServers(
- dataSegment,
- remainingLen + CA_BLE_HEADER_SIZE);
-
- if (CA_STATUS_OK != result)
- {
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
- "Update characteristics (all) failed, result [%d]", result);
- CALEErrorHandler(NULL, bleData->data, bleData->dataLen, result);
- return;
- }
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
- "Client Sent Data length is [%d]", remainingLen + CA_BLE_HEADER_SIZE);
- }
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "Client Sending Multicast Data");
+ OIC_LOG(DEBUG, CALEADAPTER_TAG, "BLE Multicast is not supported");
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CABLEClientSendDataThread");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint,
{
if ((size_t)size < sizeof(CALEData_t *))
{
- OIC_LOG_V(ERROR, CALEADAPTER_TAG,
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
"Destroy data too small %p %d", data, size);
}
CALEData_t *ledata = (CALEData_t *) data;
static void CALEDataReceiverHandlerSingleThread(const uint8_t *data,
uint32_t dataLen)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
data + CA_BLE_HEADER_SIZE,
dataOnlyLen);
g_singleThreadReceiveData->recvDataLen += dataOnlyLen;
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "totalDatalength [%d] received Datalen [%d]",
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "totalDatalength [%d] received Datalen [%d]",
g_singleThreadReceiveData->totalDataLen, g_singleThreadReceiveData->recvDataLen);
}
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static CAResult_t CALEServerSendDataSingleThread(const uint8_t *data,
uint32_t dataLen)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
CAResult_t result = CAGenerateVariableForFragmentation(dataLen,
&midPacketCount,
&remainingLen,
- &totalLength);
+ &totalLength,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
uint32_t length = 0;
uint32_t dataOnlyLen = 0;
- if (CA_SUPPORTED_BLE_MTU_SIZE > totalLength)
+ if (g_mtuSize > totalLength)
{
length = totalLength;
dataOnlyLen = dataLen;
}
else
{
- length = CA_SUPPORTED_BLE_MTU_SIZE;
- dataOnlyLen = CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
+ length = g_mtuSize;
+ dataOnlyLen = g_mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE;
}
result = CAMakeFirstDataSegment(dataSegment,
for (uint32_t iter = 0; iter < dataLimit; iter++)
{
result = CAMakeRemainDataSegment(dataSegment,
+ g_mtuSize - CA_BLE_HEADER_SIZE,
data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE,
+ dataLen,
iter,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
result = CAUpdateCharacteristicsToAllGattClients(
dataSegment,
- CA_SUPPORTED_BLE_MTU_SIZE);
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
CALEDoEvents();
}
- if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE))
+ if (remainingLen && (totalLength > g_mtuSize))
{
// send the last segment of the data
OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk");
result = CAMakeRemainDataSegment(dataSegment,
- data,
remainingLen,
+ data,
+ dataLen,
dataLimit,
- dataHeader);
+ dataHeader,
+ g_mtuSize);
if (CA_STATUS_OK != result)
{
static CAResult_t CAInitLEAdapterMutex()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAInitLEAdapterMutex");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
if (NULL == g_bleIsServerMutex)
{
- g_bleIsServerMutex = ca_mutex_new();
+ g_bleIsServerMutex = oc_mutex_new();
if (NULL == g_bleIsServerMutex)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- return CA_STATUS_FAILED;
- }
- }
-
- if (NULL == g_bleNetworkCbMutex)
- {
- g_bleNetworkCbMutex = ca_mutex_new();
- if (NULL == g_bleNetworkCbMutex)
- {
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- CATerminateLEAdapterMutex();
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
return CA_STATUS_FAILED;
}
}
if (NULL == g_bleLocalAddressMutex)
{
- g_bleLocalAddressMutex = ca_mutex_new();
+ g_bleLocalAddressMutex = oc_mutex_new();
if (NULL == g_bleLocalAddressMutex)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- CATerminateLEAdapterMutex();
- return CA_STATUS_FAILED;
- }
- }
-
- if (NULL == g_bleAdapterThreadPoolMutex)
- {
- g_bleAdapterThreadPoolMutex = ca_mutex_new();
- if (NULL == g_bleAdapterThreadPoolMutex)
- {
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
CATerminateLEAdapterMutex();
return CA_STATUS_FAILED;
}
}
- if (NULL == g_bleClientSendDataMutex)
- {
- g_bleClientSendDataMutex = ca_mutex_new();
- if (NULL == g_bleClientSendDataMutex)
- {
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- CATerminateLEAdapterMutex();
- return CA_STATUS_FAILED;
- }
- }
+
- if (NULL == g_bleServerSendDataMutex)
+ if (NULL == g_bleServerReceiveDataMutex)
{
- g_bleServerSendDataMutex = ca_mutex_new();
- if (NULL == g_bleServerSendDataMutex)
+ g_bleServerReceiveDataMutex = oc_mutex_new();
+ if (NULL == g_bleServerReceiveDataMutex)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- CATerminateLEAdapterMutex();
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
return CA_STATUS_FAILED;
}
}
- if (NULL == g_bleAdapterReqRespCbMutex)
+ if (NULL == g_bleClientReceiveDataMutex)
{
- g_bleAdapterReqRespCbMutex = ca_mutex_new();
- if (NULL == g_bleAdapterReqRespCbMutex)
+ g_bleClientReceiveDataMutex = oc_mutex_new();
+ if (NULL == g_bleClientReceiveDataMutex)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
- CATerminateLEAdapterMutex();
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
return CA_STATUS_FAILED;
}
}
- if (NULL == g_bleReceiveDataMutex)
+ if (NULL == g_senderInfoMutex)
{
- g_bleReceiveDataMutex = ca_mutex_new();
- if (NULL == g_bleReceiveDataMutex)
+ g_senderInfoMutex = oc_mutex_new();
+ if (NULL == g_senderInfoMutex)
{
- OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed");
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "oc_mutex_new failed");
return CA_STATUS_FAILED;
}
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
static void CATerminateLEAdapterMutex()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CATerminateLEAdapterMutex");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
- ca_mutex_free(g_bleIsServerMutex);
+ oc_mutex_free(g_bleIsServerMutex);
g_bleIsServerMutex = NULL;
- ca_mutex_free(g_bleNetworkCbMutex);
- g_bleNetworkCbMutex = NULL;
-
- ca_mutex_free(g_bleLocalAddressMutex);
+
+ oc_mutex_free(g_bleLocalAddressMutex);
g_bleLocalAddressMutex = NULL;
- ca_mutex_free(g_bleAdapterThreadPoolMutex);
- g_bleAdapterThreadPoolMutex = NULL;
-
- ca_mutex_free(g_bleClientSendDataMutex);
- g_bleClientSendDataMutex = NULL;
-
- ca_mutex_free(g_bleServerSendDataMutex);
- g_bleServerSendDataMutex = NULL;
-
- ca_mutex_free(g_bleAdapterReqRespCbMutex);
- g_bleAdapterReqRespCbMutex = NULL;
+ oc_mutex_free(g_bleServerReceiveDataMutex);
+ g_bleServerReceiveDataMutex = NULL;
- ca_mutex_free(g_bleReceiveDataMutex);
- g_bleReceiveDataMutex = NULL;
+ oc_mutex_free(g_bleClientReceiveDataMutex);
+ g_bleClientReceiveDataMutex = NULL;
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ oc_mutex_free(g_senderInfoMutex);
+ g_senderInfoMutex = NULL;
}
/**
static CAResult_t CALEAdapterGattServerStart()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Before CAStartLEGattServer");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+ CAResult_t result = CA_STATUS_FAILED;
+
+ if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
+ {
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
+ caglobals.bleFlags);
+ return CA_STATUS_OK;
+ }
- CAResult_t result = CAStartLEGattServer();
+#ifndef DISABLE_BLE_SERVER
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "Starting LE GATT Server");
+ result = CAStartLEGattServer();
+#endif
#ifndef SINGLE_THREAD
/*
*/
if (CA_STATUS_OK == result)
{
- ca_mutex_lock(g_bleServerSendDataMutex);
result = CAQueueingThreadStart(g_bleServerSendQueueHandle);
- ca_mutex_unlock(g_bleServerSendDataMutex);
-
if (CA_STATUS_OK != result)
{
OIC_LOG_V(ERROR,
static CAResult_t CALEAdapterGattServerStop()
{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+
+ if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
+ {
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
+ caglobals.bleFlags);
+ return CA_STATUS_OK;
+ }
+
#ifndef SINGLE_THREAD
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEAdapterGattServerStop");
- CAResult_t result = CAStopLEGattServer();
- ca_mutex_lock(g_bleServerSendDataMutex);
- if (CA_STATUS_OK == result)
+ CAResult_t res = CAQueueingThreadStop(g_bleServerSendQueueHandle);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAQueueingThreadStop has failed");
+ }
+ res = CAStopLEGattServer();
+ if (CA_STATUS_OK != res)
{
- result = CAQueueingThreadStop(g_bleServerSendQueueHandle);
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAStopLEGattServer has failed");
}
- ca_mutex_unlock(g_bleServerSendDataMutex);
- return result;
+ return res;
#else
return CAStopLEGattServer();
#endif
static CAResult_t CALEAdapterGattClientStart()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "Before CAStartLEGattClient");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
CAResult_t result = CAStartLEGattClient();
*/
if (CA_STATUS_OK == result)
{
- ca_mutex_lock(g_bleClientSendDataMutex);
result = CAQueueingThreadStart(g_bleClientSendQueueHandle);
- ca_mutex_unlock(g_bleClientSendDataMutex);
-
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR,
static CAResult_t CALEAdapterGattClientStop()
{
#ifndef SINGLE_THREAD
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEAdapterGattClientStop");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
CAStopLEGattClient();
- ca_mutex_lock(g_bleClientSendDataMutex);
CAResult_t result = CAQueueingThreadStop(g_bleClientSendQueueHandle);
- ca_mutex_unlock(g_bleClientSendDataMutex);
-
+
return result;
#else
CAStopLEGattClient();
#endif
}
+#ifdef __WITH_DTLS__
+static ssize_t CALESecureSendDataCB(CAEndpoint_t *endpoint, const void *data, size_t dataLen)
+{
+ VERIFY_NON_NULL(endpoint, CALEADAPTER_TAG, "endpoint is NULL");
+ VERIFY_NON_NULL(data, CALEADAPTER_TAG, "data is NULL");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "encrypted datalen = %zd", dataLen);
+
+ CAResult_t result;
+ CADataType_t dataType = g_dataType;
+ ssize_t ret = 0;
+
+ if (ADAPTER_SERVER == g_adapterType ||
+ (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
+ {
+ result = CALEAdapterServerSendData(endpoint, data, dataLen);
+ if (CA_STATUS_OK != result)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for server failed" );
+
+ if (g_errorHandler)
+ {
+ g_errorHandler(endpoint, data, dataLen, result);
+ }
+ return ret;
+ }
+ ret = (ssize_t)dataLen;
+ }
+ else if (ADAPTER_CLIENT == g_adapterType ||
+ (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_REQUEST_DATA == dataType) ||
+ (ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_FOR_RES == dataType))
+ {
+ result = CALEAdapterClientSendData(endpoint, data, dataLen);
+ if (CA_STATUS_OK != result)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for client failed" );
+
+ if (g_errorHandler)
+ {
+ g_errorHandler(endpoint, data, dataLen, result);
+ }
+ return ret;
+ }
+ ret = (ssize_t)dataLen;
+ }
+ else
+ {
+ OIC_LOG_V(ERROR, CALEADAPTER_TAG,
+ "Can't Send Message adapterType = %d, dataType = %d", g_adapterType, dataType);
+ return ret;
+ }
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
+ return ret;
+}
+
+CAResult_t CALESecureReceiveDataCB(const CASecureEndpoint_t *sep, const void *data,
+ size_t dataLen)
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+
+ VERIFY_NON_NULL(sep, CALEADAPTER_TAG, "sep is NULL");
+ VERIFY_NON_NULL(data, CALEADAPTER_TAG, "data is NULL");
+
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
+ "Secure Data Receive - decrypted datalen = %zd", dataLen);
+
+ if (dataLen <= 0)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "incorrect dataLen, derecypt fail !");
+ return CA_STATUS_INVALID_PARAM;
+ }
+
+ OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
+
+ CAResult_t res = CA_STATUS_OK;
+ if (g_networkPacketReceivedCallback)
+ {
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG,
+ "[CALESecureReceiveDataCB] Secure flags = %d, %x",
+ sep->endpoint.flags, sep->endpoint.flags);
+ OIC_LOG(DEBUG, CALEADAPTER_TAG,
+ "[CALESecureReceiveDataCB] Received data up !");
+ res = g_networkPacketReceivedCallback(sep, data, dataLen);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Error parsing CoAP data, res = %d", res);
+ }
+ }
+ return res;
+}
+#endif
+
CAResult_t CAInitializeLE(CARegisterConnectivityCallback registerCallback,
CANetworkPacketReceivedCallback reqRespCallback,
CAAdapterChangeCallback netCallback,
CAErrorHandleCallback errorCallback,
ca_thread_pool_t handle)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
//Input validation
VERIFY_NON_NULL(registerCallback, CALEADAPTER_TAG, "RegisterConnectivity callback is null");
}
CAInitializeLEAdapter();
- CASetLEClientThreadPoolHandle(handle);
-
result = CAInitializeLEGattClient();
if (CA_STATUS_OK != result)
{
return CA_STATUS_FAILED;
}
+ CASetLEClientThreadPoolHandle(handle);
+
CASetLEReqRespClientCallback(CALEAdapterClientReceivedData);
CASetLEServerThreadPoolHandle(handle);
result = CAInitializeLEGattServer();
g_errorHandler = errorCallback;
+#ifdef __WITH_DTLS__
+ if (CA_STATUS_OK != CAinitSslAdapter())
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to init SSL adapter");
+ }
+ else
+ {
+ CAsetSslAdapterCallbacks(CALESecureReceiveDataCB, CALESecureSendDataCB,
+ CA_ADAPTER_GATT_BTLE);
+ }
+#endif
+
static const CAConnectivityHandler_t connHandler =
{
.startAdapter = CAStartLE,
};
registerCallback(connHandler);
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
-
return CA_STATUS_OK;
}
static CAResult_t CAStartLE()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CAStartLE");
-
return CAStartLEAdapter();
}
static CAResult_t CAStopLE()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+
#ifndef SINGLE_THREAD
CAStopLEQueues();
#endif
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
default:
break;
}
- ca_mutex_unlock(g_bleIsServerMutex);
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
-
+ oc_mutex_unlock(g_bleIsServerMutex);
return CAStopLEAdapter();
}
static void CATerminateLE()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
CASetLEReqRespServerCallback(NULL);
CASetLEReqRespClientCallback(NULL);
CASetLEReqRespAdapterCallback(NULL);
CATerminateLENetworkMonitor();
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
break;
}
g_adapterType = ADAPTER_EMPTY;
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
#ifndef SINGLE_THREAD
CATerminateLEQueues();
#endif
- CATerminateLEAdapterMutex();
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+#ifdef __WITH_DTLS__
+ CAsetSslAdapterCallbacks(NULL, NULL, CA_ADAPTER_GATT_BTLE);
+#endif
+
+ CATerminateLEAdapterMutex();
}
static CAResult_t CAStartLEListeningServer()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAStartLEListeningServer");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
+
+ if (caglobals.bleFlags & CA_LE_SERVER_DISABLE)
+ {
+ OIC_LOG_V(INFO, CALEADAPTER_TAG, "server flag of configure is disable [%d]",
+ caglobals.bleFlags);
+ return CA_STATUS_OK;
+ }
+
#ifndef ROUTING_GATEWAY
CAResult_t result = CA_STATUS_OK;
#ifndef SINGLE_THREAD
}
#endif
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_CLIENT:
default:
g_adapterType = ADAPTER_SERVER;
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
result = CAGetLEAdapterState();
if (CA_STATUS_OK != result)
result = CALEAdapterGattServerStart();
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return result;
#else
// Routing Gateway only supports BLE client mode.
static CAResult_t CAStartLEDiscoveryServer()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CAStartLEDiscoveryServer");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
CAResult_t result = CA_STATUS_OK;
#ifndef SINGLE_THREAD
result = CAInitLEClientQueues();
}
#endif
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
default:
g_adapterType = ADAPTER_CLIENT;
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
result = CAGetLEAdapterState();
if (CA_STATUS_OK != result)
result = CALEAdapterGattClientStart();
}
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return result;
}
static CAResult_t CAReadLEData()
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
#ifdef SINGLE_THREAD
CACheckLEData();
#endif
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
uint32_t dataLen,
CADataType_t dataType)
{
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN - CASendLEUnicastData : type(%d)", dataType);
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "type(%d)", dataType);
//Input validation
VERIFY_NON_NULL_RET(endpoint, CALEADAPTER_TAG, "Remote endpoint is null", -1);
OIC_LOG(ERROR, CALEADAPTER_TAG, "g_adapterType is Empty");
}
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
if (ADAPTER_SERVER == g_adapterType ||
(ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
{
+#ifdef __WITH_DTLS__
+ if (endpoint && endpoint->flags & CA_SECURE)
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG,
+ "Response Data or server - secured data send(caadapternetdtlsencrypt) call");
+ OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
+ g_dataType = dataType;
+ oc_mutex_unlock(g_bleIsServerMutex);
+
+ result = CAencryptSsl(endpoint, (void *)data, dataLen);
+ if (CA_STATUS_OK != result)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "caadapternetdtlsencrypt failed!");
+ return -1;
+ }
+ return dataLen;
+ }
+ else
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG,
+ "server or both - none secured data send(CALEAdapterServerSendData) call");
+ result = CALEAdapterServerSendData(endpoint, data, dataLen);
+ }
+#else
result = CALEAdapterServerSendData(endpoint, data, dataLen);
+#endif
if (CA_STATUS_OK != result)
{
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for server failed");
if (g_errorHandler)
{
return -1;
}
}
-
- if (ADAPTER_CLIENT == g_adapterType ||
+ else if (ADAPTER_CLIENT == g_adapterType ||
(ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_REQUEST_DATA == dataType) ||
(ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_FOR_RES == dataType))
{
+#ifdef __WITH_DTLS__
+ if (endpoint && endpoint->flags & CA_SECURE)
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG,
+ "Request Data or client - secured data send(caadapternetdtlsencrypt) call");
+ OIC_LOG_BUFFER(DEBUG, CALEADAPTER_TAG, data, dataLen);
+ g_dataType = dataType;
+ oc_mutex_unlock(g_bleIsServerMutex);
+
+ result = CAencryptSsl(endpoint, (void *)data, dataLen);
+ if (CA_STATUS_OK != result)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "caadapternetdtlsencrypt failed!");
+ return -1;
+ }
+ return dataLen;
+ }
+ else
+ {
+ OIC_LOG(DEBUG, CALEADAPTER_TAG,
+ "client or both - none secured data send(CALEAdapterClientSendData) call");
+ result = CALEAdapterClientSendData(endpoint, data, dataLen);
+ }
+#else
result = CALEAdapterClientSendData(endpoint, data, dataLen);
+#endif
if (CA_STATUS_OK != result)
{
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data for client failed" );
- if (g_errorHandler)
- {
- g_errorHandler(endpoint, data, dataLen, result);
- }
+ if (g_errorHandler)
+ {
+ g_errorHandler(endpoint, data, dataLen, result);
+ }
return -1;
}
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return dataLen;
}
uint32_t dataLen,
CADataType_t dataType)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CASendLEMulticastData");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
//Input validation
VERIFY_NON_NULL_RET(data, CALEADAPTER_TAG, "Data is null", -1);
OIC_LOG(ERROR, CALEADAPTER_TAG, "g_adapterType is Empty");
}
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
if (ADAPTER_SERVER == g_adapterType ||
(ADAPTER_BOTH_CLIENT_SERVER == g_adapterType && CA_RESPONSE_DATA == dataType))
{
result = CALEAdapterServerSendData(NULL, data, dataLen);
if (CA_STATUS_OK != result)
{
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
OIC_LOG(ERROR, CALEADAPTER_TAG, "Send multicast data for server failed" );
result = CALEAdapterClientSendData(NULL, data, dataLen);
if (CA_STATUS_OK != result)
{
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
OIC_LOG(ERROR, CALEADAPTER_TAG, "Send Multicast data for client failed" );
return -1;
}
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CASendLEMulticastData");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return dataLen;
}
static CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
VERIFY_NON_NULL(info, CALEADAPTER_TAG, "CALocalConnectivity info is null");
}
OICStrcpy((*info)->addr, sizeof((*info)->addr), local_address);
- ca_mutex_lock(g_bleLocalAddressMutex);
+ oc_mutex_lock(g_bleLocalAddressMutex);
OICStrcpy(g_localBLEAddress, sizeof(g_localBLEAddress), local_address);
- ca_mutex_unlock(g_bleLocalAddressMutex);
+ oc_mutex_unlock(g_bleLocalAddressMutex);
(*info)->adapter = CA_ADAPTER_GATT_BTLE;
*size = 1;
OICFree(local_address);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return CA_STATUS_OK;
}
static CAResult_t CALERegisterNetworkNotifications(CAAdapterChangeCallback netCallback,
CAConnectionChangeCallback connCallback)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
- ca_mutex_lock(g_bleNetworkCbMutex);
g_networkCallback = netCallback;
g_connectionCallback = connCallback;
- ca_mutex_unlock(g_bleNetworkCbMutex);
CAResult_t res = CA_STATUS_OK;
if (netCallback)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "CASetLENWConnectionStateChangedCb failed!");
}
}
+ else
+ {
+ res = CAUnSetLENWConnectionStateChangedCb();
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "CAUnSetLENWConnectionStateChangedCb failed!");
+ }
+ }
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return res;
}
static void CALEConnectionStateChangedCb(CATransportAdapter_t adapter, const char* address,
bool isConnected)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CALEConnectionStateChangedCb");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
(void)adapter;
+ CAEndpoint_t localEndpoint = { .adapter = CA_ADAPTER_GATT_BTLE };
+ OICStrcpy(localEndpoint.addr, sizeof(localEndpoint.addr), address);
+
#ifdef __TIZEN__
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
default:
break;
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
#endif
if(!isConnected)
// remove data of send queue.
if (g_bleClientSendQueueHandle)
{
- CALERemoveSendQueueData(g_bleClientSendQueueHandle,
- g_bleClientSendDataMutex,
- address);
+ CALERemoveSendQueueData(g_bleClientSendQueueHandle, address);
}
if (g_bleServerSendQueueHandle)
{
- CALERemoveSendQueueData(g_bleServerSendQueueHandle,
- g_bleServerSendDataMutex,
- address);
+ CALERemoveSendQueueData(g_bleServerSendQueueHandle, address);
}
#endif
- }
- CAEndpoint_t localEndpoint = { .adapter = CA_ADAPTER_GATT_BTLE };
- OICStrcpy(localEndpoint.addr, sizeof(localEndpoint.addr), address);
+#ifdef __WITH_DTLS__
+#if defined(__TIZEN__) && !defined(SINGLE_THREAD)
+ // CAcloseSslConnection returns CAResult_t instead of void*, but the size is the same and crash shouldn't occur
+ pthread_t ccThread;
+ pthread_attr_t attr;
+ int initAttrRes = -1;
+ int pthreadCreateRes = -1;
+ int detachStatusRes = -1;
+ int memoryAllocationRes = -1;
+
+ do
+ {
+ initAttrRes = pthread_attr_init(&attr);
+ if (initAttrRes != 0)
+ {
+ break;
+ }
+ CAEndpoint_t *localEndpointCpyPtr = OICMalloc(sizeof(CAEndpoint_t));
+
+ if(NULL == localEndpointCpyPtr)
+ {
+ memoryAllocationRes = -1;
+ break;
+ }
+ else
+ {
+ memoryAllocationRes = 0;
+ }
+
+ (*localEndpointCpyPtr) = localEndpoint;
+ // this piece of code is reached on the main thread
+ // CAcloseSslConnection might wait for too long (network + mutexes) and watchdog might kill it
+ // Asynchronous call protects this function from watchdog
+ pthreadCreateRes = pthread_create(&ccThread, &attr, (void *(*)(void*))&CAcloseSslConnectionFreeEndpoint, (void*)localEndpointCpyPtr);
+
+ if (pthreadCreateRes != 0)
+ {
+ break;
+ }
+ detachStatusRes = pthread_detach(ccThread);
+ }while (0);
+
+ // regardless of CAcloseSslConnection result, the function will continue and g_connectionCallback will be called
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "CAcloseSslConnection pthread_init [%d], mem_alloc [%d] pthread_create [%d], pthread_detach [%d]",
+ initAttrRes, memoryAllocationRes, pthreadCreateRes, detachStatusRes);
+#else
+ CAcloseSslConnection(&localEndpoint);
+#endif
+#endif
+ }
- ca_mutex_lock(g_bleNetworkCbMutex);
if (g_connectionCallback)
{
g_connectionCallback(&localEndpoint, isConnected);
}
- ca_mutex_unlock(g_bleNetworkCbMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static void CALEDeviceStateChangedCb(CAAdapterState_t adapter_state)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN - CALEDeviceStateChangedCb");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
if (CA_ADAPTER_ENABLED == adapter_state)
{
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
default:
break;
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
}
else
{
- ca_mutex_lock(g_bleIsServerMutex);
+ oc_mutex_lock(g_bleIsServerMutex);
switch (g_adapterType)
{
case ADAPTER_SERVER:
default:
break;
}
- ca_mutex_unlock(g_bleIsServerMutex);
+ oc_mutex_unlock(g_bleIsServerMutex);
}
- ca_mutex_lock(g_bleNetworkCbMutex);
if (NULL != g_networkCallback)
{
g_networkCallback(CA_ADAPTER_GATT_BTLE, adapter_state);
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "g_networkCallback is NULL");
}
- ca_mutex_unlock(g_bleNetworkCbMutex);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
static CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint,
const uint8_t *data,
uint32_t dataLen)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
#ifndef SINGLE_THREAD
VERIFY_NON_NULL_RET(g_bleClientSendQueueHandle, CALEADAPTER_TAG,
"g_bleClientSendQueueHandle is NULL",
CA_STATUS_FAILED);
- VERIFY_NON_NULL_RET(g_bleClientSendDataMutex, CALEADAPTER_TAG,
- "g_bleClientSendDataMutex is NULL",
- CA_STATUS_FAILED);
-
- VERIFY_NON_NULL_RET(g_bleClientSendQueueHandle, CALEADAPTER_TAG,
- "g_bleClientSendQueueHandle",
- CA_STATUS_FAILED);
-
+
OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%u]", dataLen);
CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLen, NULL);
return CA_MEMORY_ALLOC_FAILED;
}
// Add message to send queue
- ca_mutex_lock(g_bleClientSendDataMutex);
- CAQueueingThreadAddData(g_bleClientSendQueueHandle, bleData, sizeof(CALEData_t));
- ca_mutex_unlock(g_bleClientSendDataMutex);
+
+ CAResult_t res = CAQueueingThreadAddData(g_bleClientSendQueueHandle, bleData,
+ sizeof(CALEData_t));
+ if (CA_STATUS_OK != res)
+ {
+ CALEDataDestroyer(bleData, sizeof(CALEData_t));
+ }
#endif
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
const uint8_t *data,
uint32_t dataLen)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
}
#else
VERIFY_NON_NULL_RET(g_bleServerSendQueueHandle, CALEADAPTER_TAG,
- "BleClientReceiverQueue is NULL",
- CA_STATUS_FAILED);
- VERIFY_NON_NULL_RET(g_bleServerSendDataMutex, CALEADAPTER_TAG,
- "BleClientSendDataMutex is NULL",
- CA_STATUS_FAILED);
-
- VERIFY_NON_NULL_RET(g_bleServerSendQueueHandle, CALEADAPTER_TAG, "sendQueueHandle",
+ "g_bleServerSendQueueHandle is NULL",
CA_STATUS_FAILED);
OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%d]", dataLen);
}
// Add message to send queue
- ca_mutex_lock(g_bleServerSendDataMutex);
- CAQueueingThreadAddData(g_bleServerSendQueueHandle,
- bleData,
- sizeof(CALEData_t));
- ca_mutex_unlock(g_bleServerSendDataMutex);
+
+ CAResult_t res = CAQueueingThreadAddData(g_bleServerSendQueueHandle,
+ bleData,
+ sizeof(CALEData_t));
+ if (CA_STATUS_OK != res)
+ {
+ CALEDataDestroyer(bleData, sizeof(CALEData_t));
+ }
#endif
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return CA_STATUS_OK;
}
uint32_t dataLength,
uint32_t *sentLength)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
//Input validation
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null");
g_singleThreadReceiveData->recvDataLen);
}
g_singleThreadReceiveData->remoteEndpoint = NULL;
+ OICFree(g_singleThreadReceiveData->defragData);
g_singleThreadReceiveData->defragData = NULL;
OICFree(g_singleThreadReceiveData);
g_singleThreadReceiveData = NULL;
}
#else
- VERIFY_NON_NULL_RET(g_bleReceiverQueue,
+ VERIFY_NON_NULL_RET(g_bleServerReceiverQueue,
CALEADAPTER_TAG,
- "g_bleReceiverQueue",
+ "g_bleServerReceiverQueue",
CA_STATUS_FAILED);
//Add message to data queue
// Create bleData to add to queue
OIC_LOG_V(DEBUG,
CALEADAPTER_TAG,
- "Data received from LE layer [%d]",
+ "Data received from LE Server layer [%d]",
dataLength);
CALEData_t * const bleData =
CAFreeEndpoint(remoteEndpoint);
// Add message to receiver queue
- CAQueueingThreadAddData(g_bleReceiverQueue, bleData, sizeof(CALEData_t));
+ CAQueueingThreadAddData(g_bleServerReceiverQueue, bleData, sizeof(CALEData_t));
*sentLength = dataLength;
#endif
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
return CA_STATUS_OK;
}
uint32_t dataLength,
uint32_t *sentLength)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
//Input validation
VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null");
VERIFY_NON_NULL(sentLength, CALEADAPTER_TAG, "Sent data length holder is null");
#ifndef SINGLE_THREAD
- VERIFY_NON_NULL_RET(g_bleReceiverQueue, CALEADAPTER_TAG,
- "g_bleReceiverQueue",
+ VERIFY_NON_NULL_RET(g_bleClientReceiverQueue, CALEADAPTER_TAG,
+ "g_bleClientReceiverQueue",
CA_STATUS_FAILED);
//Add message to data queue
return CA_STATUS_FAILED;
}
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data received from LE layer [%u]", dataLength);
-
// Create bleData to add to queue
- CALEData_t *bleData = CACreateLEData(remoteEndpoint, data,
- dataLength, g_bleClientSenderInfo);
+ OIC_LOG_V(DEBUG,
+ CALEADAPTER_TAG,
+ "Data received from LE Client layer [%u]",
+ dataLength);
+
+ CALEData_t * const bleData =
+ CACreateLEData(remoteEndpoint, data, dataLength, g_bleClientSenderInfo);
+
if (!bleData)
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!");
CAFreeEndpoint(remoteEndpoint);
// Add message to receiver queue
- CAQueueingThreadAddData(g_bleReceiverQueue, bleData, sizeof(CALEData_t));
+ CAQueueingThreadAddData(g_bleClientReceiverQueue, bleData, sizeof(CALEData_t));
*sentLength = dataLength;
#endif
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
static void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
- ca_mutex_lock(g_bleAdapterThreadPoolMutex);
g_bleAdapterThreadPool = handle;
- ca_mutex_unlock(g_bleAdapterThreadPoolMutex);
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
+
}
static void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
-
- ca_mutex_lock(g_bleAdapterReqRespCbMutex);
-
g_networkPacketReceivedCallback = callback;
- ca_mutex_unlock(g_bleAdapterReqRespCbMutex);
-
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT");
}
static void CALEErrorHandler(const char *remoteAddress,
uint32_t dataLen,
CAResult_t result)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEErrorHandler IN");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
VERIFY_NON_NULL_VOID(data, CALEADAPTER_TAG, "Data is null");
CAFreeEndpoint(rep);
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEErrorHandler OUT");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
}
#ifndef SINGLE_THREAD
-static void CALERemoveSendQueueData(CAQueueingThread_t *queueHandle, ca_mutex mutex,
- const char* address)
+static bool CALEClearQueueAddressDataContext(void *data, uint32_t size, void *ctx)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALERemoveSendQueueData");
+ if (NULL == data || NULL == ctx)
+ {
+ return false;
+ }
- VERIFY_NON_NULL_VOID(queueHandle, CALEADAPTER_TAG, "queueHandle");
- VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
+ CALEData_t *caLeData = (CALEData_t *)data;
+ const char *address = (const char *)ctx;
- ca_mutex_lock(mutex);
- while (u_queue_get_size(queueHandle->dataQueue) > 0)
+ if (NULL != caLeData && NULL != caLeData->remoteEndpoint)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "get data from queue");
- u_queue_message_t *message = u_queue_get_element(queueHandle->dataQueue);
- if (NULL != message)
+ if (!strcasecmp(caLeData->remoteEndpoint->addr, address))
{
- CALEData_t *bleData = (CALEData_t *) message->msg;
- if (bleData && bleData->remoteEndpoint)
- {
- if (!strcmp(bleData->remoteEndpoint->addr, address))
- {
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "found the message of disconnected device");
- if (NULL != queueHandle->destroy)
- {
- queueHandle->destroy(message->msg, message->size);
- }
- else
- {
- OICFree(message->msg);
- }
-
- OICFree(message);
- }
- }
+ return true;
}
}
- ca_mutex_unlock(mutex);
+ return false;
+}
+
+static void CALERemoveSendQueueData(CAQueueingThread_t *queueHandle, const char* address)
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
+
+ VERIFY_NON_NULL_VOID(queueHandle, CALEADAPTER_TAG, "queueHandle");
+ VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
+
+ CAResult_t res = CAQueueingThreadClearContextData(queueHandle,
+ CALEClearQueueAddressDataContext,
+ address);
+ if (CA_STATUS_OK != res)
+ {
+
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Could not clear the send queue");
+ }
+
}
static void CALERemoveReceiveQueueData(u_arraylist_t *dataInfoList, const char* address)
{
- OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALERemoveReceiveQueueData");
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "%s", __func__);
VERIFY_NON_NULL_VOID(dataInfoList, CALEADAPTER_TAG, "dataInfoList");
VERIFY_NON_NULL_VOID(address, CALEADAPTER_TAG, "address");
if (CA_STATUS_OK == CALEGetPortsFromSenderInfo(address, dataInfoList, portList))
{
uint32_t arrayLength = u_arraylist_length(portList);
- for (int i = 0; i < arrayLength; i++)
+ for (uint32_t i = 0; i < arrayLength; i++)
{
- uint16_t port = u_arraylist_get(portList, i);
- OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "port : %X", port);
+ uint16_t *port = (uint16_t *)u_arraylist_get(portList, i);
+ if (!port)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to get port from sender info !");
+ u_arraylist_destroy(portList);
+ return;
+ }
- if (CA_STATUS_OK == CALEGetSenderInfo(address, port,
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "port : %X", *port);
+
+ if (CA_STATUS_OK == CALEGetSenderInfo(address, *port,
dataInfoList, &senderInfo,
&senderIndex))
{
- u_arraylist_remove(dataInfoList, senderIndex);
- OICFree(senderInfo->defragData);
- OICFree(senderInfo->remoteEndpoint);
- OICFree(senderInfo);
-
OIC_LOG(DEBUG, CALEADAPTER_TAG,
"SenderInfo is removed for disconnection");
+ CALERemoveSenderInfoFromList(dataInfoList, senderInfo);
+ CALEFreeSenderInfo(senderInfo);
}
else
{
if (!strncmp(info->remoteEndpoint->addr, leAddress, addrLength))
{
- u_arraylist_add(portList, (void *) info->remoteEndpoint->port);
+ uint16_t *port = (uint16_t *)OICMalloc(sizeof(uint16_t));
+ if (!port)
+ {
+ OIC_LOG(ERROR, CALEADAPTER_TAG, "memory allocation failed!");
+ return CA_MEMORY_ALLOC_FAILED;
+ }
+ *port = info->remoteEndpoint->port;
+ u_arraylist_add(portList, (void *)port);
}
}
}
}
#endif
+
+void CALEStartGattServer()
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
+
+ oc_mutex_lock(g_bleIsServerMutex);
+ switch (g_adapterType)
+ {
+ case ADAPTER_SERVER:
+ CALEAdapterGattServerStart();
+ break;
+ case ADAPTER_CLIENT:
+ CALEAdapterGattClientStart();
+ break;
+ case ADAPTER_BOTH_CLIENT_SERVER:
+ CALEAdapterGattServerStart();
+ CALEAdapterGattClientStart();
+ break;
+ default:
+ break;
+ }
+ oc_mutex_unlock(g_bleIsServerMutex);
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
+}
+
+void CALEStopGattServer()
+{
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "IN %s", __func__);
+
+ oc_mutex_lock(g_bleIsServerMutex);
+ switch (g_adapterType)
+ {
+ case ADAPTER_SERVER:
+ CALEAdapterGattServerStop();
+ break;
+ case ADAPTER_CLIENT:
+ CALEAdapterGattClientStop();
+ break;
+ case ADAPTER_BOTH_CLIENT_SERVER:
+ CALEAdapterGattServerStop();
+ CALEAdapterGattClientStop();
+ break;
+ default:
+ break;
+ }
+ oc_mutex_unlock(g_bleIsServerMutex);
+ OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "OUT %s", __func__);
+}
projects / platform / upstream / iotivity.git / blobdiff