1 /******************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
24 * This file contains the APIs for EDR adapter.
27 #include "caedradapter.h"
29 #include "caedrinterface.h"
30 #include "caadapterutils.h"
32 #include "caqueueingthread.h"
33 #include "oic_malloc.h"
34 #include "caremotehandler.h"
38 * Logging tag for module name.
40 #define TAG "OIC_CA_EDR_ADAP"
43 * Reference to threadpool.
45 static ca_thread_pool_t g_edrThreadPool = NULL;
48 * Queue handle for Send Data
50 static CAQueueingThread_t *g_sendQueueHandle = NULL;
53 * Queue handle for Receive Data
55 static CAQueueingThread_t *g_recvQueueHandle = NULL;
58 * Storing Adapter state information
60 static bool g_adapterState = true;
63 * Maintains the callback to be notified on receival of network packets from other
66 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
69 * Maintains the callback to be notified on local bluetooth adapter status change.
71 static CAAdapterChangeCallback g_adapterChangeCallback = NULL;
74 * error Callback to CA adapter
76 static CAErrorHandleCallback g_errorCallback = NULL;
79 * Information of local Bluetooth adapter.
81 static CAEndpoint_t *g_localConnectivity = NULL;
84 * Storing Rfcommserver state information
86 static bool g_serverState = false;
88 static CAResult_t CAStartServer();
89 static CAResult_t CAEDRInitializeQueueHandlers();
90 CAResult_t CAEDRInitializeSendHandler();
91 CAResult_t CAEDRInitializeReceiveHandler();
92 void CAAdapterTerminateQueues();
93 void CAAdapterDataSendHandler(void *context);
94 void CAAdapterDataReceiverHandler(void *context);
95 CAResult_t CAAdapterStopQueue();
96 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
97 uint32_t *sentLength);
98 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
99 void CAEDROnNetworkStatusChanged(void *context);
100 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
101 const uint8_t *data, uint32_t dataLength, uint32_t *sentLength);
102 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, CANetworkStatus_t status);
103 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
104 uint32_t dataLength);
107 * @fn CACreateEDRData
108 * @brief Helper function to create CAEDRData
110 static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data,
111 uint32_t dataLength);
115 * @brief Free the Created EDR data
117 static void CAFreeEDRData(CAEDRData *edrData);
120 * @fn CAEDRFreeNetworkEvent
121 * @brief Free the memory associated with @event.
123 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
125 static void CAEDRDataDestroyer(void *data, uint32_t size);
127 static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
128 uint32_t dataLength, CAResult_t result);
130 CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
131 CANetworkPacketReceivedCallback packetReceivedCallback,
132 CAAdapterChangeCallback netCallback,
133 CAConnectionChangeCallback connCallback,
134 CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
137 VERIFY_NON_NULL(registerCallback, TAG, "register callback is NULL");
138 VERIFY_NON_NULL(packetReceivedCallback, TAG, "data receive callback is NULL");
139 VERIFY_NON_NULL(netCallback, TAG, "adapter state change callback is NULL");
140 VERIFY_NON_NULL(connCallback, TAG, "connection state change callback is NULL");
141 VERIFY_NON_NULL(handle, TAG, "Thread pool handle is NULL");
143 // Register the callbacks
144 g_edrThreadPool = handle;
145 g_networkPacketReceivedCallback = packetReceivedCallback;
146 g_adapterChangeCallback = netCallback;
147 g_errorCallback = errorCallback;
149 // Initialize EDR Network Monitor
150 CAResult_t res = CAEDRInitializeNetworkMonitor(handle);
151 if (CA_STATUS_OK != res)
153 OIC_LOG_V(ERROR, TAG, "EDR N/w Monitor Initialize failed!, error number [%d]", res);
157 CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
158 CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
159 CAEDRSetErrorHandler(CAEDRErrorHandler);
160 res = CAEDRClientInitialize();
161 if (CA_STATUS_OK != res)
163 OIC_LOG_V(ERROR, TAG, "EDR Client Initialize failed, error number [%d]", res);
167 res = CAEDRServerInitialize(handle);
168 if (CA_STATUS_OK != res)
170 OIC_LOG_V(ERROR, TAG, "EDR Server Initialize failed, error number [%d]", res);
174 static const CAConnectivityHandler_t handler =
176 .startAdapter = CAStartEDR,
177 .stopAdapter = CAStopEDR,
178 .startListenServer = CAStartEDRListeningServer,
179 .stopListenServer = CAStopEDRListeningServer,
180 .startDiscoveryServer = CAStartEDRDiscoveryServer,
181 .sendData = CASendEDRUnicastData,
182 .sendDataToAll = CASendEDRMulticastData,
183 .GetnetInfo = CAGetEDRInterfaceInformation,
184 .readData = CAReadEDRData,
185 .terminate = CATerminateEDR,
186 .cType = CA_ADAPTER_RFCOMM_BTEDR
188 registerCallback(handler);
190 OIC_LOG(DEBUG, TAG, "OUT");
194 CAResult_t CAStartEDR()
196 //Start Monitoring EDR Network
197 CAResult_t ret = CAEDRStartNetworkMonitor();
198 if (CA_STATUS_OK != ret)
200 OIC_LOG(ERROR, TAG, "Failed to Start n/w monitor");
203 // Get Bluetooth adapter state
204 bool adapterState = false;
205 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
207 OIC_LOG(ERROR, TAG, "Failed to get adapter enable state");
208 return CA_STATUS_FAILED;
211 if (false == adapterState)
213 OIC_LOG(ERROR, TAG, "Bluetooth adapter is disabled!");
214 g_adapterState = false;
215 return CA_ADAPTER_NOT_ENABLED;
218 if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
220 OIC_LOG_V(ERROR, TAG, "Start Network Monitor failed!, error number [%d] ",
224 // Initialize Send/Receive data message queues
225 if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers()))
227 OIC_LOG_V(ERROR, TAG,
228 "CAAdapterInitializeQueues failed!, error number [%d] ", ret);
230 return CA_STATUS_FAILED;
233 // Start Send/Receive data message queues
234 if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
236 OIC_LOG_V(ERROR, TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
242 CAResult_t CAStartEDRListeningServer()
244 return CAStartServer();
247 CAResult_t CAStopEDRListeningServer()
249 return CAEDRServerStop();
252 CAResult_t CAStartEDRDiscoveryServer()
255 // Start device discovery
256 CAResult_t result = CAEDRStartDeviceDiscovery();
257 if(CA_STATUS_OK != result)
259 OIC_LOG(DEBUG, TAG, "Failed to Start Device discovery");
263 return CAStartServer();
266 int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
270 VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "Remote endpoint is null", -1);
271 VERIFY_NON_NULL_RET(data, TAG, "Data is null", -1);
275 OIC_LOG(ERROR, TAG, "Invalid input: data length is zero!");
279 if (0 == strlen(remoteEndpoint->addr))
281 OIC_LOG(ERROR, TAG, "Invalid input: EDR Address is empty!");
285 uint32_t sentLength = 0;
286 const char *serviceUUID = OIC_EDR_SERVICE_ID;
287 const char *address = remoteEndpoint->addr;
288 CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
289 if (CA_STATUS_OK != err)
291 OIC_LOG_V(ERROR, TAG, "Send unicast data failed!, error num [%d]", err);
292 g_errorCallback(remoteEndpoint, data, dataLength, err);
299 int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
301 OIC_LOG(DEBUG, TAG, "IN - CASendEDRMulticastData");
304 VERIFY_NON_NULL_RET(data, TAG, "Data is null", -1);
308 OIC_LOG(ERROR, TAG, "Invalid input: data length is zero!");
312 uint32_t sentLen = 0;
313 const char *serviceUUID = OIC_EDR_SERVICE_ID;
314 CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
315 if (CA_STATUS_OK != err)
317 OIC_LOG_V(ERROR, TAG, "Send multicast data failed!, error num [%d]", err);
318 g_errorCallback(endpoint, data, dataLength, err);
322 OIC_LOG(DEBUG, TAG, "OUT - CASendEDRMulticastData");
326 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
328 VERIFY_NON_NULL(info, TAG, "LocalConnectivity info is null");
330 CAResult_t err = CA_STATUS_OK;
332 if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
334 OIC_LOG_V(ERROR, TAG, "Failed to get local interface information!, error num [%d]", err);
342 CAResult_t CAReadEDRData()
344 return CAEDRManagerReadData();
347 CAResult_t CAStopEDR()
349 // Stop RFComm server if it is running
352 // Stop network monitor
353 CAEDRStopNetworkMonitor();
356 CAEDRClientUnsetCallbacks();
358 // Disconnect all the client connections
359 CAEDRClientDisconnectAll();
361 // Stop Send and receive Queue
362 CAAdapterStopQueue();
367 void CATerminateEDR()
369 // Terminate EDR Network Monitor
370 CAEDRTerminateNetworkMonitor();
372 // Terminate Send/Receive data messages queues
373 CAAdapterTerminateQueues();
375 g_networkPacketReceivedCallback = NULL;
376 g_adapterChangeCallback = NULL;
378 // Terminate thread pool
379 g_edrThreadPool = NULL;
381 // Terminate EDR Client
382 CAEDRClientTerminate();
384 // Terminate EDR Server
385 CAEDRServerTerminate();
387 // Free LocalConnectivity information
388 CAFreeEndpoint(g_localConnectivity);
389 g_localConnectivity = NULL;
392 CAResult_t CAStartServer()
394 if (false == g_adapterState)
396 OIC_LOG(DEBUG, TAG, "Bluetooth adapter is disabled!");
397 // Setting g_serverState for starting Rfcommserver when adapter starts
398 g_serverState = true;
402 CAResult_t err = CA_STATUS_OK;
403 if (CA_STATUS_OK != (err = CAEDRServerStart()))
405 OIC_LOG_V(ERROR, TAG, "Failed to start RFCOMM server!, error num [%d]",
413 CAResult_t CAEDRInitializeQueueHandlers()
415 if (CA_STATUS_OK == CAEDRInitializeSendHandler()
416 && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
418 OIC_LOG(DEBUG, TAG, "Queue is initialized!");
422 return CA_STATUS_FAILED;
425 CAResult_t CAEDRInitializeSendHandler()
427 // Check if the message queue is already initialized
428 if (g_sendQueueHandle)
430 OIC_LOG(DEBUG, TAG, "Already queue is initialized!");
434 g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
435 if (!g_sendQueueHandle)
437 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
438 return CA_MEMORY_ALLOC_FAILED;
441 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
442 CAAdapterDataSendHandler, CAEDRDataDestroyer))
444 OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread");
445 return CA_STATUS_FAILED;
450 CAResult_t CAEDRInitializeReceiveHandler()
452 // Check if the message queue is already initialized
453 if (g_recvQueueHandle)
455 OIC_LOG(DEBUG, TAG, "Already queue is initialized!");
459 g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
460 if (!g_recvQueueHandle)
462 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
463 return CA_MEMORY_ALLOC_FAILED;
467 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
468 CAAdapterDataReceiverHandler,
471 OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread");
472 OICFree(g_recvQueueHandle);
473 g_recvQueueHandle = NULL;
474 return CA_STATUS_FAILED;
480 void CAAdapterTerminateQueues()
482 if (g_sendQueueHandle)
484 CAQueueingThreadDestroy(g_sendQueueHandle);
485 g_sendQueueHandle = NULL;
487 if (g_recvQueueHandle)
489 CAQueueingThreadDestroy(g_recvQueueHandle);
490 g_recvQueueHandle = NULL;
494 void CAAdapterDataSendHandler(void *context)
496 OIC_LOG(DEBUG, TAG, "IN - CAAdapterDataSendHandler");
498 CAEDRData *message = (CAEDRData *) context;
501 OIC_LOG(ERROR, TAG, "Failed to get message!");
505 if (!message->remoteEndpoint)
507 OIC_LOG(DEBUG, TAG, "remoteEndpoint is not available");
511 const char *remoteAddress = message->remoteEndpoint->addr;
514 OIC_LOG(ERROR, TAG, "EDR Send Message error");
515 //Error cannot be sent if remote address is NULL
519 CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
520 if(CA_STATUS_OK != result)
522 OIC_LOG(ERROR, TAG, "CAEDRClientSendData API failed");
523 CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
527 OIC_LOG(DEBUG, TAG, "OUT");
530 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
533 CAResult_t result = CA_SEND_FAILED;
535 // Send the first segment with the header.
536 if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
538 result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
539 if (CA_STATUS_OK != result)
541 OIC_LOG(ERROR, TAG, "Failed to send unicast data !");
547 OIC_LOG_V(DEBUG, TAG, "sending multicast data : %s", data);
548 result = CAEDRClientSendMulticastData(data, dataLength);
550 if (CA_STATUS_OK != result)
552 OIC_LOG(ERROR, TAG, "Failed to send multicast data !");
559 void CAAdapterDataReceiverHandler(void *context)
561 OIC_LOG(DEBUG, TAG, "IN_CAAdapterDataReceiverHandler");
563 if (NULL == g_networkPacketReceivedCallback)
565 OIC_LOG(ERROR, TAG, "g_networkPacketReceivedCallback is NULL");
569 CAEDRData *message = (CAEDRData *) context;
570 if (NULL == message || NULL == message->remoteEndpoint)
572 OIC_LOG(ERROR, TAG, "Failed to get message!");
576 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
577 CA_ADAPTER_RFCOMM_BTEDR,
578 message->remoteEndpoint->addr,
583 OIC_LOG(ERROR, TAG, "remoteEndpoint is NULL");
587 OIC_LOG(DEBUG, TAG, "Sending data up !");
589 const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
591 g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
593 CAFreeEndpoint(remoteEndpoint);
595 OIC_LOG(DEBUG, TAG, "OUT_CAAdapterDataReceiverHandler");
598 CAResult_t CAAdapterStartQueue()
600 // Start send queue thread
601 if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
603 OIC_LOG(ERROR, TAG, "Failed to Start Send Data Thread");
604 CAEDRClientUnsetCallbacks();
605 //Disconnect all the client connections
606 CAEDRClientDisconnectAll();
607 return CA_STATUS_FAILED;
610 // Start receive queue thread
611 if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
613 OIC_LOG(ERROR, TAG, "Failed to Start Receive Data Thread");
614 CAEDRClientUnsetCallbacks();
615 //Disconnect all the client connections
616 CAEDRClientDisconnectAll();
617 return CA_STATUS_FAILED;
623 CAResult_t CAAdapterStopQueue()
625 //Stop send queue thread
626 CAQueueingThreadStop(g_sendQueueHandle);
628 //Stop receive queue thread
629 CAQueueingThreadStop(g_recvQueueHandle);
634 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
635 uint32_t *sentLength)
637 if (false == g_adapterState)
639 OIC_LOG_V(ERROR, TAG, "Bluetooth adapter is disabled!");
645 VERIFY_NON_NULL_VOID(data, TAG, "Data is null");
646 VERIFY_NON_NULL_VOID(sentLength, TAG, "Sent data length holder is null");
648 // Create remote endpoint
649 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
650 CA_ADAPTER_RFCOMM_BTEDR,
652 if (NULL == remoteEndpoint)
654 OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !");
658 // Add message to data queue
659 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
660 CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
661 *sentLength = dataLength;
663 // Free remote endpoint
664 CAFreeEndpoint(remoteEndpoint);
667 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
668 uint32_t dataLength, CAResult_t result)
671 VERIFY_NON_NULL_VOID(data, TAG, "Data is null");
673 // Create remote endpoint
674 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
678 OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !");
682 g_errorCallback(remoteEndpoint, data, dataLength, result);
684 // Free remote endpoint
685 CAFreeEndpoint(remoteEndpoint);
688 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
689 uint32_t dataLength, uint32_t *sentLength)
691 OIC_LOG(DEBUG, TAG, "IN - CAAdapterSendData");
693 if (false == g_adapterState)
695 OIC_LOG(ERROR, TAG, "Bluetooth adapter is disabled!");
697 return CA_ADAPTER_NOT_ENABLED;
700 VERIFY_NON_NULL(serviceUUID, TAG, "service UUID is null");
701 VERIFY_NON_NULL(data, TAG, "Data is null");
702 VERIFY_NON_NULL(sentLength, TAG, "Sent data length holder is null");
704 // Create remote endpoint
705 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
706 CA_ADAPTER_RFCOMM_BTEDR,
708 if (NULL == remoteEndpoint)
710 OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !");
711 return CA_MEMORY_ALLOC_FAILED;
714 // Add message to data queue
715 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
716 CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
717 *sentLength = dataLength;
719 // Free remote endpoint
720 CAFreeEndpoint(remoteEndpoint);
722 OIC_LOG(DEBUG, TAG, "OUT - CAAdapterSendData");
726 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
728 // Create localconnectivity
729 if (NULL == g_localConnectivity)
731 CAEDRGetInterfaceInformation(&g_localConnectivity);
734 if (CA_INTERFACE_UP == status)
736 if (false == g_adapterState)
738 // Get Bluetooth adapter state
739 bool adapterState = false;
740 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
742 OIC_LOG(ERROR, TAG, "Failed to get adapter enable state");
746 if (false == adapterState)
748 OIC_LOG(ERROR, TAG, "Bluetooth adapter is disabled!");
749 g_adapterState = false;
752 CAEDRClientSetCallbacks();
753 g_adapterState = true;
754 CAAdapterStartQueue();
755 // starting RFCommServer
756 if (true == g_serverState)
759 g_serverState = false;
765 g_adapterState = false;
768 // Notify to upper layer
769 if (g_adapterChangeCallback && g_localConnectivity && g_edrThreadPool)
771 // Add notification task to thread pool
772 CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
775 if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
776 CAEDROnNetworkStatusChanged,event))
778 OIC_LOG(ERROR, TAG, "Failed to create threadpool!");
785 void CAEDROnNetworkStatusChanged(void *context)
789 OIC_LOG(ERROR, TAG, "context is NULL!");
793 CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
795 // Notify to upper layer
796 if (g_adapterChangeCallback)
798 g_adapterChangeCallback(networkEvent->info->adapter, networkEvent->status);
801 // Free the created Network event
802 CAEDRFreeNetworkEvent(networkEvent);
805 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
806 CANetworkStatus_t status)
808 VERIFY_NON_NULL_RET(connectivity, TAG, "connectivity is NULL", NULL);
810 // Create CAEDRNetworkEvent
811 CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
814 OIC_LOG(ERROR, TAG, "Failed to allocate memory to network event!");
818 // Create duplicate of Local connectivity
819 event->info = CACloneEndpoint(connectivity);
820 event->status = status;
824 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
828 CAFreeEndpoint(event->info);
833 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
834 const uint8_t *data, uint32_t dataLength)
836 CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
839 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
843 edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
845 edrData->data = OICMalloc(dataLength);
846 if (NULL == edrData->data)
848 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
849 CAFreeEDRData(edrData);
852 memcpy(edrData->data, data, dataLength);
853 edrData->dataLen = dataLength;
858 void CAFreeEDRData(CAEDRData *edrData)
860 VERIFY_NON_NULL_VOID(edrData, TAG, "edrData is NULL");
862 CAFreeEndpoint(edrData->remoteEndpoint);
863 OICFree(edrData->data);
867 void CAEDRDataDestroyer(void *data, uint32_t size)
869 if ((size_t)size < sizeof(CAEDRData))
871 OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size);
873 CAEDRData *edrdata = (CAEDRData *) data;
875 CAFreeEDRData(edrdata);