#include "caedrinterface.h"
#include "caadapterutils.h"
#include "logger.h"
-#include "cafragmentation.h"
#include "caqueueingthread.h"
#include "oic_malloc.h"
#include "caremotehandler.h"
+#include "pdu.h"
/**
* @var EDR_ADAPTER_TAG
* @brief Logging tag for module name.
*/
-#define EDR_ADAPTER_TAG "CA_EDR_ADAPTER"
+#define EDR_ADAPTER_TAG "OIC_CA_EDR_ADAP"
/**
* @var g_edrThreadPool
*/
static bool g_serverState = false;
-/**
- * Stores information of all the senders.
- *
- * This structure will be used to track and defragment all incoming
- * data packet.
- */
-typedef struct
-{
- uint32_t recvDataLen;
- uint32_t totalDataLen;
- uint8_t *defragData;
- CAEndpoint_t *remoteEndpoint;
-} CAEDRSenderInfo_t;
-
-/**
- * Sender information.
- */
-static u_arraylist_t *g_senderInfo = NULL;
-
static CAResult_t CAStartServer();
static CAResult_t CAEDRInitializeQueueHandlers();
CAResult_t CAEDRInitializeSendHandler();
uint32_t *sentLength);
void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
void CAEDROnNetworkStatusChanged(void *context);
-CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
- uint32_t dataLength, uint32_t *sentLength);
-CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
- CANetworkStatus_t status);
-
-CAResult_t CAEDRClientSendData(const char *remoteAddress,
- const uint8_t *data,
+CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
+ const uint8_t *data, uint32_t dataLength, uint32_t *sentLength);
+CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, CANetworkStatus_t status);
+CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
uint32_t dataLength);
/**
static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
uint32_t dataLength, CAResult_t result);
-static void CAEDRClearSenderInfo();
-
CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
CANetworkPacketReceivedCallback packetReceivedCallback,
CANetworkChangeCallback networkStateChangeCallback,
CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Input validation
VERIFY_NON_NULL(registerCallback, EDR_ADAPTER_TAG, "register callback is NULL");
VERIFY_NON_NULL(packetReceivedCallback, EDR_ADAPTER_TAG, "data receive callback is NULL");
g_errorCallback = errorCallback;
// Initialize EDR Network Monitor
- CAResult_t err = CAEDRInitializeNetworkMonitor(handle);
- if (CA_STATUS_OK != err)
+ CAResult_t res = CAEDRInitializeNetworkMonitor(handle);
+ if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR N/w Monitor Initialize failed!, error number [%d]",
- err);
- return err;
+ res);
+ return res;
}
CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
CAEDRSetErrorHandler(CAEDRErrorHandler);
- CAEDRInitializeClient(handle);
-
- CAConnectivityHandler_t handler;
- handler.startAdapter = CAStartEDR;
- handler.startListenServer = CAStartEDRListeningServer;
- handler.stopListenServer = CAStopEDRListeningServer;
- handler.startDiscoveryServer = CAStartEDRDiscoveryServer;
- handler.sendData = CASendEDRUnicastData;
- handler.sendDataToAll = CASendEDRMulticastData;
- handler.GetnetInfo = CAGetEDRInterfaceInformation;
- handler.readData = CAReadEDRData;
- handler.stopAdapter = CAStopEDR;
- handler.terminate = CATerminateEDR;
- registerCallback(handler, CA_ADAPTER_RFCOMM_BTEDR);
+ res = CAEDRClientInitialize();
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Client Initialize failed, error number [%d]", res);
+ return res;
+ }
- // Initialize Send/Receive data message queues
- if (CA_STATUS_OK != CAEDRInitializeQueueHandlers())
+ res = CAEDRServerInitialize(handle);
+ if (CA_STATUS_OK != res)
{
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAAdapterInitializeQueues API failed");
- CATerminateEDR();
- return CA_STATUS_FAILED;
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Server Initialize failed, error number [%d]", res);
+ return res;
}
+ static const CAConnectivityHandler_t handler =
+ {
+ .startAdapter = CAStartEDR,
+ .stopAdapter = CAStopEDR,
+ .startListenServer = CAStartEDRListeningServer,
+ .stopListenServer = CAStopEDRListeningServer,
+ .startDiscoveryServer = CAStartEDRDiscoveryServer,
+ .sendData = CASendEDRUnicastData,
+ .sendDataToAll = CASendEDRMulticastData,
+ .GetnetInfo = CAGetEDRInterfaceInformation,
+ .readData = CAReadEDRData,
+ .terminate = CATerminateEDR,
+ .cType = CA_ADAPTER_RFCOMM_BTEDR
+ };
+ registerCallback(handler);
+
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
CAResult_t CAStartEDR()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
//Start Monitoring EDR Network
CAResult_t ret = CAEDRStartNetworkMonitor();
if (CA_STATUS_OK != ret)
ret);
}
+ // Initialize Send/Receive data message queues
+ if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers()))
+ {
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
+ "CAAdapterInitializeQueues failed!, error number [%d] ", ret);
+ CATerminateEDR();
+ return CA_STATUS_FAILED;
+ }
+
+ // Start Send/Receive data message queues
if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return ret;
}
CAResult_t CAStartEDRListeningServer()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
return CAStartServer();
}
CAResult_t CAStopEDRListeningServer()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
return CAEDRServerStop();
}
CAResult_t CAStartEDRDiscoveryServer()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
+#ifdef __TIZEN__
+ // Start device discovery
+ CAResult_t result = CAEDRStartDeviceDiscovery();
+ if(CA_STATUS_OK != result)
+ {
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Failed to Start Device discovery");
+ }
+#endif
return CAStartServer();
}
int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
uint32_t dataLength)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Input validation
VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
return -1;
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return sentLength;
}
CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
CAResult_t err = CA_STATUS_OK;
}
*size = 1;
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return err;
}
CAResult_t CAReadEDRData()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
return CAEDRManagerReadData();
}
CAResult_t CAStopEDR()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Stop RFComm server if it is running
CAEDRServerStop();
// Stop Send and receive Queue
CAAdapterStopQueue();
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
void CATerminateEDR()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Terminate EDR Network Monitor
CAEDRTerminateNetworkMonitor();
// Free LocalConnectivity information
CAFreeEndpoint(g_localConnectivity);
g_localConnectivity = NULL;
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
CAResult_t CAStartServer()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- CAResult_t err = CA_STATUS_OK;
-
if (false == g_adapterState)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
return CA_STATUS_OK;
}
- if (CA_STATUS_OK != (err = CAEDRServerStart(g_edrThreadPool)))
+ CAResult_t err = CA_STATUS_OK;
+ if (CA_STATUS_OK != (err = CAEDRServerStart()))
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
err);
return err;
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return err;
}
CAResult_t CAEDRInitializeQueueHandlers()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (CA_STATUS_OK == CAEDRInitializeSendHandler()
&& CA_STATUS_OK == CAEDRInitializeReceiveHandler())
{
return CA_STATUS_OK;
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_FAILED;
}
CAResult_t CAEDRInitializeSendHandler()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Check if the message queue is already initialized
if (g_sendQueueHandle)
{
CAResult_t CAEDRInitializeReceiveHandler()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Check if the message queue is already initialized
if (g_recvQueueHandle)
{
return CA_MEMORY_ALLOC_FAILED;
}
- g_senderInfo = u_arraylist_create();
- if (!g_senderInfo)
- {
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "ClientInfo memory allcation failed!");
- OICFree(g_recvQueueHandle);
- g_recvQueueHandle = NULL;
- return CA_MEMORY_ALLOC_FAILED;
- }
if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
CAAdapterDataReceiverHandler,
CAEDRDataDestroyer))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
- u_arraylist_free(&g_senderInfo);
OICFree(g_recvQueueHandle);
g_recvQueueHandle = NULL;
return CA_STATUS_FAILED;
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
void CAAdapterTerminateQueues()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (g_sendQueueHandle)
{
CAQueueingThreadDestroy(g_sendQueueHandle);
CAQueueingThreadDestroy(g_recvQueueHandle);
g_recvQueueHandle = NULL;
}
-
- CAEDRClearSenderInfo();
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAAdapterDataSendHandler(void *context)
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
CAEDRData *message = (CAEDRData *) context;
- if (NULL == message)
+ if (!message)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
return;
}
- const char *remoteAddress = NULL;
-
- if (NULL == message->remoteEndpoint)
+ if (!message->remoteEndpoint)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
return;
}
- else
- {
- remoteAddress = message->remoteEndpoint->addr;
- }
+ const char *remoteAddress = message->remoteEndpoint->addr;
if(!remoteAddress)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
return;
}
- uint32_t dataSegmentLength = message->dataLen + CA_HEADER_LENGTH;
-
- uint8_t *header = (uint8_t *) OICCalloc(CA_HEADER_LENGTH, sizeof(uint8_t));
- VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Memory allocation failed");
-
- uint8_t* dataSegment = (uint8_t *) OICCalloc(dataSegmentLength, sizeof(uint8_t));
- if (NULL == dataSegment)
- {
- CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, CA_SEND_FAILED);
- OICFree(header);
- return;
- }
-
- CAResult_t result = CAGenerateHeader(header, CA_HEADER_LENGTH, message->dataLen);
- if (CA_STATUS_OK != result)
- {
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed");
- OICFree(header);
- OICFree(dataSegment);
- CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
- return;
- }
-
- memcpy(dataSegment, header, CA_HEADER_LENGTH);
- OICFree(header);
-
- memcpy(dataSegment + CA_HEADER_LENGTH, message->data, message->dataLen);
-
- result = CAEDRClientSendData(remoteAddress, dataSegment, dataSegmentLength);
- OICFree(dataSegment);
-
- if (CA_STATUS_OK != result)
+ CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
+ if(CA_STATUS_OK != result)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
-CAResult_t CAEDRClientSendData(const char *remoteAddress,
- const uint8_t *data,
+CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
uint32_t dataLength)
{
-
CAResult_t result = CA_SEND_FAILED;
// Send the first segment with the header.
return result;
}
-static void CAEDRClearSenderInfo()
-{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- uint32_t listIndex = 0;
- uint32_t listLength = u_arraylist_length(g_senderInfo);
- for (listIndex = 0; listIndex < listLength; listIndex++)
- {
- CAEDRSenderInfo_t *info = (CAEDRSenderInfo_t *) u_arraylist_get(g_senderInfo, listIndex);
- if (!info)
- {
- continue;
- }
-
- OICFree(info->defragData);
- CAFreeEndpoint(info->remoteEndpoint);
- OICFree(info);
- }
- u_arraylist_free(&g_senderInfo);
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
-}
-
-static CAResult_t CAEDRGetSenderInfo(const char *edrAddress,
- CAEDRSenderInfo_t **senderInfo,
- uint32_t *senderIndex)
-{
- VERIFY_NON_NULL_RET(edrAddress,
- EDR_ADAPTER_TAG,
- "NULL edr address argument",
- CA_STATUS_INVALID_PARAM);
- VERIFY_NON_NULL_RET(senderIndex,
- EDR_ADAPTER_TAG,
- "NULL index argument",
- CA_STATUS_INVALID_PARAM);
-
- const uint32_t listLength = u_arraylist_length(g_senderInfo);
- const uint32_t addrLength = strlen(edrAddress);
- for (uint32_t index = 0; index < listLength; index++)
- {
- CAEDRSenderInfo_t *info = (CAEDRSenderInfo_t *) u_arraylist_get(g_senderInfo, index);
- if (!info || !(info->remoteEndpoint))
- {
- continue;
- }
-
- if (!strncmp(info->remoteEndpoint->addr, edrAddress, addrLength))
- {
- *senderIndex = index;
- if (senderInfo)
- {
- *senderInfo = info;
- }
- return CA_STATUS_OK;
- }
- }
-
- return CA_STATUS_FAILED;
-}
-
void CAAdapterDataReceiverHandler(void *context)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
return;
}
- uint32_t dataLen = 0;
- CAEDRSenderInfo_t *senderInfo = NULL;
- uint32_t senderIndex = 0;
+ CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
+ CA_ADAPTER_RFCOMM_BTEDR,
+ message->remoteEndpoint->addr,
+ 0);
- while (dataLen < message->dataLen)
+ if (!remoteEndpoint)
{
- if(CA_STATUS_OK != CAEDRGetSenderInfo(message->remoteEndpoint->addr,
- &senderInfo, &senderIndex))
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "This is a new client [%s]",
- message->remoteEndpoint->addr);
- }
-
- if (!senderInfo)
- {
- CAEDRSenderInfo_t *newSender = OICMalloc(sizeof(CAEDRSenderInfo_t));
- if (!newSender)
- {
- return;
- }
- newSender->recvDataLen = 0;
- newSender->totalDataLen = 0;
- newSender->defragData = NULL;
- newSender->remoteEndpoint = NULL;
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Parsing the header");
- newSender->totalDataLen = CAParseHeader(message->data + dataLen,
- message->dataLen - dataLen);
- if(!(newSender->totalDataLen))
- {
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Total Data Length is parsed as 0!!!");
- OICFree(newSender);
- return;
- }
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Total data to be accumulated [%u] bytes",
- newSender->totalDataLen);
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "data received in the first packet [%u] bytes",
- message->dataLen);
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "remoteEndpoint is NULL");
+ return;
+ }
- newSender->defragData = OICCalloc(newSender->totalDataLen,
- sizeof(*newSender->defragData));
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
- if (NULL == newSender->defragData)
- {
- OICFree(newSender);
- return;
- }
+ const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
- newSender->remoteEndpoint = CACloneEndpoint(message->remoteEndpoint);
- if (NULL == newSender->remoteEndpoint)
- {
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "remoteEndpoint is NULL!");
- OICFree(newSender->defragData);
- OICFree(newSender);
- return;
- }
+ g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
- if (message->dataLen - CA_HEADER_LENGTH - dataLen <= newSender->totalDataLen)
- {
- memcpy(newSender->defragData, message->data + dataLen + CA_HEADER_LENGTH,
- message->dataLen - dataLen - CA_HEADER_LENGTH);
- newSender->recvDataLen += message->dataLen - dataLen - CA_HEADER_LENGTH;
- u_arraylist_add(g_senderInfo,(void *)newSender);
- dataLen = message->dataLen;
- }
- else
- {
- memcpy(newSender->defragData, message->data + dataLen + CA_HEADER_LENGTH,
- newSender->totalDataLen);
- newSender->recvDataLen = newSender->totalDataLen;
- u_arraylist_add(g_senderInfo,(void *)newSender);
- dataLen += newSender->totalDataLen + CA_HEADER_LENGTH;
- }
- //Getting newSender index position in g_senderInfo array list
- if (CA_STATUS_OK !=
- CAEDRGetSenderInfo(newSender->remoteEndpoint->addr, NULL, &senderIndex))
- {
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Existing sender index not found!!");
- OICFree(newSender->defragData);
- CAFreeEndpoint(newSender->remoteEndpoint);
- OICFree(newSender);
- return;
- }
- senderInfo = newSender;
- }
- else
- {
- if (senderInfo->recvDataLen + message->dataLen - dataLen <= senderInfo->totalDataLen)
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Copying the data of length [%d]",
- message->dataLen - dataLen);
- memcpy(senderInfo->defragData + senderInfo->recvDataLen, message->data + dataLen,
- message->dataLen - dataLen);
- senderInfo->recvDataLen += message->dataLen - dataLen;
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "totalDatalength [%d] recveived Datalen [%d]",
- senderInfo->totalDataLen, senderInfo->recvDataLen);
- dataLen = message->dataLen;
- }
- else
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Copying the data of length [%d]",
- senderInfo->totalDataLen - senderInfo->recvDataLen);
- memcpy(senderInfo->defragData + senderInfo->recvDataLen, message->data + dataLen,
- senderInfo->totalDataLen - senderInfo->recvDataLen);
- dataLen += senderInfo->totalDataLen - senderInfo->recvDataLen;
- senderInfo->recvDataLen = senderInfo->totalDataLen;
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "totalDatalength [%d] recveived Datalen [%d]",
- senderInfo->totalDataLen, senderInfo->recvDataLen);
- }
- }
+ CAFreeEndpoint(remoteEndpoint);
- if (senderInfo->totalDataLen == senderInfo->recvDataLen)
- {
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
-
- CASecureEndpoint_t sep = {.endpoint = *(senderInfo->remoteEndpoint)};
- g_networkPacketReceivedCallback(&sep, senderInfo->defragData, senderInfo->recvDataLen);
- u_arraylist_remove(g_senderInfo, senderIndex);
- senderInfo->remoteEndpoint = NULL;
- senderInfo->defragData = NULL;
- OICFree(senderInfo);
- senderInfo = NULL;
- }
- }
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
}
CAResult_t CAAdapterStartQueue()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Start send queue thread
if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
{
CAEDRClientDisconnectAll();
return CA_STATUS_FAILED;
}
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
+
return CA_STATUS_OK;
}
CAResult_t CAAdapterStopQueue()
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
//Stop send queue thread
CAQueueingThreadStop(g_sendQueueHandle);
//Stop receive queue thread
CAQueueingThreadStop(g_recvQueueHandle);
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
+
return CA_STATUS_OK;
}
void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
uint32_t *sentLength)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (false == g_adapterState)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
// Free remote endpoint
CAFreeEndpoint(remoteEndpoint);
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
uint32_t dataLength, CAResult_t result)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Input validation
VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
// Free remote endpoint
CAFreeEndpoint(remoteEndpoint);
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Create localconnectivity
if (NULL == g_localConnectivity)
{
return;
}
- if (false== adapterState)
+ if (false == adapterState)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
g_adapterState = false;
}
}
}
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAEDROnNetworkStatusChanged(void *context)
{
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (NULL == context)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
// Free the created Network event
CAEDRFreeNetworkEvent(networkEvent);
-
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
}
CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
- const uint8_t *data, uint32_t dataLength)
+ const uint8_t *data, uint32_t dataLength)
{
- CAEDRData *edrData = (CAEDRData *)OICMalloc(sizeof (CAEDRData));
+ CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
if (!edrData)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
{
if ((size_t)size < sizeof(CAEDRData))
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d",
- data, size);
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
}
CAEDRData *edrdata = (CAEDRData *) data;
projects / platform / upstream / iotivity.git / blobdiff