******************************************************************/
/**
- * @file caedradapter.c
- * @brief This file contains the APIs for EDR adapter.
+ * @file
+ *
+ * This file contains the APIs for EDR adapter.
*/
#include "caedradapter.h"
#include "caedrinterface.h"
#include "caadapterutils.h"
#include "logger.h"
-#include "camsgparser.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 gEDRThreadPool
+ * @var g_edrThreadPool
* @brief Reference to threadpool.
*/
-static u_thread_pool_t gEDRThreadPool = NULL;
+static ca_thread_pool_t g_edrThreadPool = NULL;
/**
- * @var gSendQueueHandle
+ * @var g_sendQueueHandle
* @brief Queue handle for Send Data
*/
-static CAQueueingThread_t *gSendQueueHandle = NULL;
+static CAQueueingThread_t *g_sendQueueHandle = NULL;
/**
- * @var gRecvQueueHandle
+ * @var g_recvQueueHandle
* @brief Queue handle for Receive Data
*/
-static CAQueueingThread_t *gRecvQueueHandle = NULL;
+static CAQueueingThread_t *g_recvQueueHandle = NULL;
/**
- * @var isHeaderAvailable
- * @brief to differentiate btw header and data packet.
- */
-static CABool_t isHeaderAvailable = CA_FALSE;
-
-/**
- * @var gAdapterState
+ * @var g_adapterState
* @brief Storing Adapter state information
*/
-static CABool_t gAdapterState = CA_TRUE;
+static bool g_adapterState = true;
/**
- * @var gNetworkPacketReceivedCallback
+ * @var g_networkPacketReceivedCallback
* @brief Maintains the callback to be notified on receival of network packets from other
* Bluetooth devices.
*/
-static CANetworkPacketReceivedCallback gNetworkPacketReceivedCallback = NULL;
+static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
/**
- * @var gNetworkChangeCallback
+ * @var g_networkChangeCallback
* @brief Maintains the callback to be notified on local bluetooth adapter status change.
*/
-static CANetworkChangeCallback gNetworkChangeCallback = NULL;
+static CANetworkChangeCallback g_networkChangeCallback = NULL;
/**
- * @var gLocalConnectivity
- * @brief Information of local Bluetooth adapter.
+ * @var g_errorCallback
+ * @brief error Callback to CA adapter
*/
-static CALocalConnectivity_t *gLocalConnectivity = NULL;
+static CAErrorHandleCallback g_errorCallback = NULL;
/**
- * @var gServerId
- * @brief Storing RfcommserverUUID
+ * @var g_localConnectivity
+ * @brief Information of local Bluetooth adapter.
*/
-static int32_t gServerId = -1;
+static CAEndpoint_t *g_localConnectivity = NULL;
/**
- * @var gServerState
+ * @var g_serverState
* @brief Storing Rfcommserver state information
*/
-static CABool_t gServerState = CA_FALSE;
+static bool g_serverState = false;
-static CAResult_t CAStartServer(void);
-static CAResult_t CAEDRInitializeQueueHandlers(void);
-CAResult_t CAEDRInitializeSendHandler(void);
-CAResult_t CAEDRInitializeReceiveHandler(void);
-void CAAdapterTerminateQueues(void);
+static CAResult_t CAStartServer();
+static CAResult_t CAEDRInitializeQueueHandlers();
+CAResult_t CAEDRInitializeSendHandler();
+CAResult_t CAEDRInitializeReceiveHandler();
+void CAAdapterTerminateQueues();
void CAAdapterDataSendHandler(void *context);
void CAAdapterDataReceiverHandler(void *context);
CAResult_t CAAdapterStopQueue();
-void CAAdapterRecvData(const char *remoteAddress, void *data,
- uint32_t dataLength, uint32_t *sentLength);
+void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
+ uint32_t *sentLength);
void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
void CAEDROnNetworkStatusChanged(void *context);
CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
- void *data, uint32_t dataLength, uint32_t *sentLength);
-CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CALocalConnectivity_t *connectivity,
- CANetworkStatus_t status);
-CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID,
- void *data, uint32_t dataLength, uint32_t *sentLength);
+ 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);
+
/**
* @fn CACreateEDRData
* @brief Helper function to create CAEDRData
*/
-static CAEDRData *CACreateEDRData(const CARemoteEndpoint_t *remoteEndpoint, void *data,
- uint32_t dataLength);
+static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data,
+ uint32_t dataLength);
/**
* @fn CAFreeEDRData
*/
void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
+static void CAEDRDataDestroyer(void *data, uint32_t size);
+
+static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
+ uint32_t dataLength, CAResult_t result);
+
CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
CANetworkPacketReceivedCallback packetReceivedCallback,
CANetworkChangeCallback networkStateChangeCallback,
- u_thread_pool_t handle)
+ CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
{
- OIC_LOG_V(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");
VERIFY_NON_NULL(networkStateChangeCallback, EDR_ADAPTER_TAG,
"network state change callback is NULL");
- VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool hanlde is NULL");
+ VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool handle is NULL");
// Register the callbacks
- gEDRThreadPool = handle;
- gNetworkPacketReceivedCallback = packetReceivedCallback;
- gNetworkChangeCallback = networkStateChangeCallback;
+ g_edrThreadPool = handle;
+ g_networkPacketReceivedCallback = packetReceivedCallback;
+ g_networkChangeCallback = networkStateChangeCallback;
+ g_errorCallback = errorCallback;
// Initialize EDR Network Monitor
- CAResult_t err = CAEDRInitializeNetworkMonitor();
- 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);
- CAEDRInitializeClient();
-
- CAConnectivityHandler_t handler;
- handler.startAdapter = CAStartEDR;
- handler.startListenServer = CAStartEDRListeningServer;
- handler.startDiscoverServer = CAStartEDRDiscoveryServer;
- handler.sendData = CASendEDRUnicastData;
- handler.sendDataToAll = CASendEDRMulticastData;
- handler.GetnetInfo = CAGetEDRInterfaceInformation;
- handler.readData = CAReadEDRData;
- handler.stopAdapter = CAStopEDR;
- handler.terminate = CATerminateEDR;
- registerCallback(handler, CA_EDR);
+ CAEDRSetErrorHandler(CAEDRErrorHandler);
+ 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;
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ 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(void)
+CAResult_t CAStartEDR()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
//Start Monitoring EDR Network
CAResult_t ret = CAEDRStartNetworkMonitor();
- if(CA_STATUS_OK != ret)
+ if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor");
}
// Get Bluetooth adapter state
- CABool_t adapterState = CA_FALSE;
+ bool adapterState = false;
if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
return CA_STATUS_FAILED;
}
- if (CA_FALSE == adapterState)
+ if (false == adapterState)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
- gAdapterState = CA_FALSE;
- return CA_STATUS_OK;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
+ g_adapterState = false;
+ return CA_ADAPTER_NOT_ENABLED;
}
if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
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_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return ret;
}
-CAResult_t CAStartEDRListeningServer(void)
+CAResult_t CAStartEDRListeningServer()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
return CAStartServer();
}
-CAResult_t CAStartEDRDiscoveryServer(void)
+CAResult_t CAStopEDRListeningServer()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
+ return CAEDRServerStop();
+}
+CAResult_t CAStartEDRDiscoveryServer()
+{
return CAStartServer();
}
-uint32_t CASendEDRUnicastData(const CARemoteEndpoint_t *remoteEndpoint, void *data,
- uint32_t dataLength)
+int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
+ uint32_t dataLength)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- CAResult_t err = CA_STATUS_OK;
-
// Input validation
- VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", 0);
- VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", 0);
+ 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);
- if (0 == strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
+ if (0 == dataLength)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
- return 0;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
+ return -1;
}
- if (0 == dataLength)
+ if (0 == strlen(remoteEndpoint->addr))
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
- return 0;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
+ return -1;
}
uint32_t sentLength = 0;
const char *serviceUUID = OIC_EDR_SERVICE_ID;
- const char *address = remoteEndpoint->addressInfo.BT.btMacAddress;
- if (CA_STATUS_OK != (err = CAAdapterSendData(address, serviceUUID, data,
- dataLength, &sentLength)))
+ const char *address = remoteEndpoint->addr;
+ CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
+ if (CA_STATUS_OK != err)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
- return 0;
+ g_errorCallback(remoteEndpoint, data, dataLength, err);
+ return -1;
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return sentLength;
}
-uint32_t CASendEDRMulticastData(void *data, uint32_t dataLength)
+int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- CAResult_t err = CA_STATUS_OK;
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
// Input validation
- VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", 0);
+ VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
if (0 == dataLength)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
- return 0;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
+ return -1;
}
uint32_t sentLen = 0;
const char *serviceUUID = OIC_EDR_SERVICE_ID;
- if (CA_STATUS_OK != (err = CAAdapterSendData(NULL, serviceUUID, data, dataLength,
- &sentLen)))
+ CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
+ if (CA_STATUS_OK != err)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]",
- err);
- return 0;
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
+ g_errorCallback(endpoint, data, dataLength, err);
+ return -1;
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
return sentLen;
}
-
-CAResult_t CAGetEDRInterfaceInformation(CALocalConnectivity_t **info, uint32_t *size)
+CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
{
- OIC_LOG_V(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_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return err;
}
-CAResult_t CAReadEDRData(void)
+CAResult_t CAReadEDRData()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
return CAEDRManagerReadData();
}
-CAResult_t CAStopEDR(void)
+CAResult_t CAStopEDR()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Stop RFComm server if it is running
- if (-1 != gServerId)
- {
- CAEDRServerStop(gServerId);
- gServerId = -1;
- }
+ CAEDRServerStop();
// Stop network monitor
CAEDRStopNetworkMonitor();
// Stop Send and receive Queue
CAAdapterStopQueue();
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
-void CATerminateEDR(void)
+void CATerminateEDR()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Terminate EDR Network Monitor
CAEDRTerminateNetworkMonitor();
- // Terminate BT Client
- CAEDRTerminateClient();
-
// Terminate Send/Receive data messages queues
CAAdapterTerminateQueues();
- gNetworkPacketReceivedCallback = NULL;
- gNetworkChangeCallback = NULL;
+ g_networkPacketReceivedCallback = NULL;
+ g_networkChangeCallback = NULL;
// Terminate thread pool
- gEDRThreadPool = NULL;
+ g_edrThreadPool = NULL;
- // Free LocalConnectivity information
- CAAdapterFreeLocalEndpoint(gLocalConnectivity);
- gLocalConnectivity = NULL;
+ // Terminate EDR Client
+ CAEDRClientTerminate();
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ // Terminate EDR Server
+ CAEDRServerTerminate();
+
+ // Free LocalConnectivity information
+ CAFreeEndpoint(g_localConnectivity);
+ g_localConnectivity = NULL;
}
-CAResult_t CAStartServer(void)
+CAResult_t CAStartServer()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- CAResult_t err = CA_STATUS_OK;
-
- if (CA_FALSE == gAdapterState)
+ if (false == g_adapterState)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
- // Setting gServerState for starting Rfcommserver when adapter starts
- gServerState = TRUE;
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
+ // Setting g_serverState for starting Rfcommserver when adapter starts
+ g_serverState = true;
return CA_STATUS_OK;
}
- if (-1 < gServerId)
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Server is already in running state.");
- return CA_STATUS_OK;
- }
-
- if (CA_STATUS_OK != (err = CAEDRServerStart(OIC_EDR_SERVICE_ID, &gServerId)))
+ 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_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return err;
}
-CAResult_t CAEDRInitializeQueueHandlers(void)
+CAResult_t CAEDRInitializeQueueHandlers()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (CA_STATUS_OK == CAEDRInitializeSendHandler()
&& CA_STATUS_OK == CAEDRInitializeReceiveHandler())
{
return CA_STATUS_OK;
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_FAILED;
}
-CAResult_t CAEDRInitializeSendHandler(void)
+CAResult_t CAEDRInitializeSendHandler()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
// Check if the message queue is already initialized
- if (gSendQueueHandle)
+ if (g_sendQueueHandle)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
return CA_STATUS_OK;
}
- gSendQueueHandle = OICMalloc(sizeof(CAQueueingThread_t));
- if (!gSendQueueHandle)
+ g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
+ if (!g_sendQueueHandle)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
return CA_MEMORY_ALLOC_FAILED;
}
- if (CA_STATUS_OK != CAQueueingThreadInitialize(gSendQueueHandle, gEDRThreadPool,
- CAAdapterDataSendHandler, NULL))
+ if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
+ CAAdapterDataSendHandler, CAEDRDataDestroyer))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
return CA_STATUS_FAILED;
return CA_STATUS_OK;
}
-CAResult_t CAEDRInitializeReceiveHandler(void)
+CAResult_t CAEDRInitializeReceiveHandler()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
// Check if the message queue is already initialized
- if (gRecvQueueHandle)
+ if (g_recvQueueHandle)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
return CA_STATUS_OK;
}
- gRecvQueueHandle = OICMalloc(sizeof(CAQueueingThread_t));
- if (!gRecvQueueHandle)
+ g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
+ if (!g_recvQueueHandle)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
return CA_MEMORY_ALLOC_FAILED;
}
- if (CA_STATUS_OK != CAQueueingThreadInitialize(gRecvQueueHandle, gEDRThreadPool,
- CAAdapterDataReceiverHandler, NULL))
+
+ if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
+ CAAdapterDataReceiverHandler,
+ CAEDRDataDestroyer))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
+ OICFree(g_recvQueueHandle);
+ g_recvQueueHandle = NULL;
return CA_STATUS_FAILED;
}
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
return CA_STATUS_OK;
}
-void CAAdapterTerminateQueues(void)
+void CAAdapterTerminateQueues()
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- if (gSendQueueHandle)
+ if (g_sendQueueHandle)
{
- CAQueueingThreadDestroy(gSendQueueHandle);
- gSendQueueHandle = NULL;
+ CAQueueingThreadDestroy(g_sendQueueHandle);
+ g_sendQueueHandle = NULL;
}
- if (gRecvQueueHandle)
+ if (g_recvQueueHandle)
{
- CAQueueingThreadDestroy(gRecvQueueHandle);
- gRecvQueueHandle = NULL;
+ CAQueueingThreadDestroy(g_recvQueueHandle);
+ g_recvQueueHandle = NULL;
}
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAAdapterDataSendHandler(void *context)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
CAEDRData *message = (CAEDRData *) context;
- if (message == NULL)
+ if (!message)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
return;
}
- const char *remoteAddress = NULL;
- const char *serviceUUID = NULL;
- uint32_t sentLength = 0;
-
- remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
- serviceUUID = message->remoteEndpoint->resourceUri;
- char *dataSegment = NULL;
- int32_t datalen = message->dataLen;
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "checking for fragmentation and the dataLen is %d",
- datalen);
-
-
- char *header = (char *) OICMalloc(sizeof(char) * CA_HEADER_LENGTH);
- VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Malloc failed");
-
- dataSegment = (char *) OICMalloc(sizeof(char) * message->dataLen + CA_HEADER_LENGTH);
- if (NULL == dataSegment)
+ if (!message->remoteEndpoint)
{
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Malloc failed");
- OICFree(header);
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
return;
}
- memset(header, 0x0, sizeof(char) * CA_HEADER_LENGTH );
- memset(dataSegment, 0x0, sizeof(char) * message->dataLen );
-
- CAResult_t result = CAGenerateHeader(header, message->dataLen);
- if (CA_STATUS_OK != result )
+ const char *remoteAddress = message->remoteEndpoint->addr;
+ if(!remoteAddress)
{
- OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed");
- OICFree(header);
- OICFree(dataSegment);
- return ;
- }
-
- memcpy(dataSegment, header, CA_HEADER_LENGTH);
- OICFree(header);
- int32_t length = 0;
- if (CA_SUPPORTED_BLE_MTU_SIZE >= message->dataLen)
- {
- length = message->dataLen + CA_HEADER_LENGTH;
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "length [%d]", length);
- memcpy(dataSegment + CA_HEADER_LENGTH, message->data, message->dataLen);
- }
- else
- {
- length = CA_SUPPORTED_BLE_MTU_SIZE;
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "length [%d]", length);
- memcpy(dataSegment + CA_HEADER_LENGTH, message->data,
- CA_SUPPORTED_BLE_MTU_SIZE - CA_HEADER_LENGTH);
- }
-
- int32_t iter = message->dataLen / CA_SUPPORTED_BLE_MTU_SIZE;
- int32_t index = 0;
- if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
- dataSegment, length, &sentLength))
- {
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
- OICFree(dataSegment);
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
+ //Error cannot be sent if remote address is NULL
return;
}
- OICFree(dataSegment);
- for (index = 1; index < iter; index++)
+ CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
+ if(CA_STATUS_OK != result)
{
- // Send the remaining header.
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending the chunk number [%d]", index);
-
- if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
- message->data + ((index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH),
- CA_SUPPORTED_BLE_MTU_SIZE, &sentLength))
- {
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
- return;
- }
- }
-
- if (message->dataLen / 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, EDR_ADAPTER_TAG, "Sending the last chunk");
- if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID,
- message->data + (index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH,
- message->dataLen % CA_SUPPORTED_BLE_MTU_SIZE + CA_HEADER_LENGTH, &sentLength))
- {
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
- return;
- }
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
+ CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
+ return;
}
- // Free message
- CAFreeEDRData(message);
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
-CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID,
- void *data, uint32_t dataLength, uint32_t *sentLength)
+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.
- if (strlen(remoteAddress)) //Unicast data
+ if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
{
- if (CA_STATUS_OK != CAEDRClientSendUnicastData(remoteAddress, serviceUUID,
- data, dataLength, sentLength))
+ result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
+ if (CA_STATUS_OK != result)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
+ return result;
}
}
else
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data");
- if (CA_STATUS_OK != CAEDRClientSendMulticastData(serviceUUID, data,
- dataLength, sentLength))
+ OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
+ result = CAEDRClientSendMulticastData(data, dataLength);
+
+ if (CA_STATUS_OK != result)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
+ return result;
}
}
- return CA_STATUS_OK;
+ return result;
}
+
void CAAdapterDataReceiverHandler(void *context)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
+ if (NULL == g_networkPacketReceivedCallback)
+ {
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "g_networkPacketReceivedCallback is NULL");
+ return;
+ }
CAEDRData *message = (CAEDRData *) context;
- if (message == NULL)
+ if (NULL == message || NULL == message->remoteEndpoint)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
return;
}
- const char *remoteAddress = NULL;
- const char *serviceUUID = NULL;
- static uint32_t recvDataLen = 0;
- static uint32_t totalDataLen = 0;
- static char *defragData = NULL;
- static CARemoteEndpoint_t *remoteEndpoint = NULL;
- if (!isHeaderAvailable)
- {
- char *header = (char *) OICMalloc(sizeof(char) * CA_HEADER_LENGTH);
+ CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
+ CA_ADAPTER_RFCOMM_BTEDR,
+ message->remoteEndpoint->addr,
+ 0);
- if (NULL == header)
- {
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Out of memory (header)!");
- return;
- }
- memcpy(header, (char *)message->data, CA_HEADER_LENGTH);
- totalDataLen = CAParseHeader(header);
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Total data to be accumulated [%d] bytes",
- totalDataLen);
- defragData = NULL;
- if (totalDataLen == 0)
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, " totalDataLen is zero");
- OICFree(header);
- return;
- }
- defragData = (char *) OICMalloc(sizeof(char) * totalDataLen);
- OICFree(header);
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
- remoteAddress = message->remoteEndpoint->addressInfo.BT.btMacAddress;
- serviceUUID = message->remoteEndpoint->resourceUri;
+ const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
- remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
- serviceUUID);
+ g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
- memcpy(defragData + recvDataLen, message->data + CA_HEADER_LENGTH,
- message->dataLen - CA_HEADER_LENGTH);
- recvDataLen += message->dataLen - CA_HEADER_LENGTH;
- isHeaderAvailable = CA_TRUE;
- }
- else
- {
- memcpy(defragData + recvDataLen, message->data, message->dataLen);
- recvDataLen += message->dataLen ;
- }
- CAFreeEDRData(message);
- if (totalDataLen == recvDataLen)
- {
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
- gNetworkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen);
- recvDataLen = 0;
- totalDataLen = 0;
- remoteEndpoint = NULL;
- isHeaderAvailable = CA_FALSE;
- }
+ CAFreeEndpoint(remoteEndpoint);
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ 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(gSendQueueHandle))
+ if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
CAEDRClientUnsetCallbacks();
}
// Start receive queue thread
- if (CA_STATUS_OK != CAQueueingThreadStart(gRecvQueueHandle))
+ if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
CAEDRClientUnsetCallbacks();
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(gSendQueueHandle);
+ CAQueueingThreadStop(g_sendQueueHandle);
//Stop receive queue thread
- CAQueueingThreadStop(gRecvQueueHandle);
- OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ CAQueueingThreadStop(g_recvQueueHandle);
+
return CA_STATUS_OK;
}
-void CAAdapterRecvData(const char *remoteAddress, void *data,
- uint32_t dataLength, uint32_t *sentLength)
+void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
+ uint32_t *sentLength)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
- if (CA_FALSE == gAdapterState)
+ if (false == g_adapterState)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
*sentLength = 0;
return;
}
- char *serviceUUID = OIC_EDR_SERVICE_ID;
-
// Input validation
- VERIFY_NON_NULL_VOID(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
// Create remote endpoint
- CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
- serviceUUID);
+ CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
+ CA_ADAPTER_RFCOMM_BTEDR,
+ remoteAddress, 0);
if (NULL == remoteEndpoint)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
return;
}
// Add message to data queue
CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
- CAQueueingThreadAddData(gRecvQueueHandle, edrData, sizeof(CARemoteEndpoint_t));
+ CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
*sentLength = dataLength;
// Free remote endpoint
- CAAdapterFreeRemoteEndpoint(remoteEndpoint);
+ CAFreeEndpoint(remoteEndpoint);
+}
+
+void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
+ uint32_t dataLength, CAResult_t result)
+{
+ // Input validation
+ VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
+
+ // Create remote endpoint
+ CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
+ remoteAddress, 0);
+ if (!remoteEndpoint)
+ {
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
+ return;
+ }
+
+ g_errorCallback(remoteEndpoint, data, dataLength, result);
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
- return;
+ // Free remote endpoint
+ CAFreeEndpoint(remoteEndpoint);
}
-CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
- void *data, uint32_t dataLength, uint32_t *sentLength)
+CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
+ uint32_t dataLength, uint32_t *sentLength)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
- if (CA_FALSE == gAdapterState)
+ if (false == g_adapterState)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
*sentLength = 0;
- return CA_STATUS_OK;
+ return CA_ADAPTER_NOT_ENABLED;
}
// Input validation
VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
// Create remote endpoint
- CARemoteEndpoint_t *remoteEndpoint = CAAdapterCreateRemoteEndpoint(CA_EDR, remoteAddress,
- serviceUUID);
+ CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
+ CA_ADAPTER_RFCOMM_BTEDR,
+ remoteAddress, 0);
if (NULL == remoteEndpoint)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
+ return CA_MEMORY_ALLOC_FAILED;
}
// Add message to data queue
CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
- CAQueueingThreadAddData(gSendQueueHandle, edrData, sizeof(CARemoteEndpoint_t));
+ CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
*sentLength = dataLength;
// Free remote endpoint
- CAAdapterFreeRemoteEndpoint(remoteEndpoint);
+ CAFreeEndpoint(remoteEndpoint);
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
+ OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
return CA_STATUS_OK;
}
void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
// Create localconnectivity
- if (NULL == gLocalConnectivity)
+ if (NULL == g_localConnectivity)
{
- CAEDRGetInterfaceInformation(&gLocalConnectivity);
+ CAEDRGetInterfaceInformation(&g_localConnectivity);
}
- if(CA_INTERFACE_UP == status)
+ if (CA_INTERFACE_UP == status)
{
- if(CA_FALSE == gAdapterState)
+ if (false == g_adapterState)
{
// Get Bluetooth adapter state
- CABool_t adapterState = CA_FALSE;
+ bool adapterState = false;
if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
return;
}
- if (CA_FALSE== adapterState)
+ if (false == adapterState)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
- gAdapterState = CA_FALSE;
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
+ g_adapterState = false;
return;
}
CAEDRClientSetCallbacks();
- gAdapterState = CA_TRUE;
+ g_adapterState = true;
CAAdapterStartQueue();
// starting RFCommServer
- if(CA_TRUE == gServerState)
+ if (true == g_serverState)
{
CAStartServer();
- gServerState = CA_FALSE;
+ g_serverState = false;
}
}
}
else
{
- gAdapterState = CA_FALSE;
+ g_adapterState = false;
}
- // Notity to upper layer
- if (gNetworkChangeCallback && gLocalConnectivity && gEDRThreadPool)
+ // Notify to upper layer
+ if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
{
// Add notification task to thread pool
- CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(gLocalConnectivity, status);
+ CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
if (NULL != event)
{
- if (CA_STATUS_OK != u_thread_pool_add_task(gEDRThreadPool, CAEDROnNetworkStatusChanged,
- event))
+ if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
+ CAEDROnNetworkStatusChanged,event))
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
return;
}
}
}
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
void CAEDROnNetworkStatusChanged(void *context)
{
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "IN");
-
if (NULL == context)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
return;
}
CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
- // Notity to upper layer
- if (gNetworkChangeCallback)
+ // Notify to upper layer
+ if (g_networkChangeCallback)
{
- gNetworkChangeCallback(networkEvent->info, networkEvent->status);
+ g_networkChangeCallback(networkEvent->info, networkEvent->status);
}
// Free the created Network event
CAEDRFreeNetworkEvent(networkEvent);
-
- OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
}
-CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CALocalConnectivity_t *connectivity,
+CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
CANetworkStatus_t status)
{
VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
if (NULL == event)
{
- OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
+ OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
return NULL;
}
// Create duplicate of Local connectivity
- event->info = CAAdapterCopyLocalEndpoint(connectivity);
+ event->info = CACloneEndpoint(connectivity);
event->status = status;
return event;
}
{
if (event)
{
- CAAdapterFreeLocalEndpoint(event->info);
+ CAFreeEndpoint(event->info);
OICFree(event);
}
}
-CAEDRData *CACreateEDRData(const CARemoteEndpoint_t *remoteEndpoint, void *data,
- uint32_t dataLength)
+CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
+ 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!");
return NULL;
}
- edrData->remoteEndpoint = CAAdapterCopyRemoteEndpoint(remoteEndpoint);
- edrData->data = (void *)OICMalloc(dataLength);
+ edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
+
+ edrData->data = OICMalloc(dataLength);
if (NULL == edrData->data)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
void CAFreeEDRData(CAEDRData *edrData)
{
- if (!edrData)
- return;
+ VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
- CAAdapterFreeRemoteEndpoint(edrData->remoteEndpoint);
+ CAFreeEndpoint(edrData->remoteEndpoint);
OICFree(edrData->data);
OICFree(edrData);
}
+void CAEDRDataDestroyer(void *data, uint32_t size)
+{
+ if ((size_t)size < sizeof(CAEDRData))
+ {
+ OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
+ }
+ CAEDRData *edrdata = (CAEDRData *) data;
+
+ CAFreeEDRData(edrdata);
+}