X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fbt_edr_adapter%2Fcaedradapter.c;h=4481499c871209aa4e865ffff2bd2a0ca484fcdf;hb=refs%2Ftags%2Fsubmit%2Ftizen_4.0%2F20171010.021147;hp=2db5548c81bdf913b8d3348efc645512ca79349c;hpb=55d1fe2483c28e509293b9e4908d2bdfe66fb5bc;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.c b/resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.c index 2db5548..4481499 100644 --- a/resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.c +++ b/resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.c @@ -29,74 +29,59 @@ #include "caedrinterface.h" #include "caadapterutils.h" #include "logger.h" -#include "camsgparser.h" #include "caqueueingthread.h" #include "oic_malloc.h" +#include "caremotehandler.h" +#include /** - * @var EDR_ADAPTER_TAG - * @brief Logging tag for module name. + * Logging tag for module name. */ -#define EDR_ADAPTER_TAG "CA_EDR_ADAPTER" +#define TAG "OIC_CA_EDR_ADAP" /** - * @var g_edrThreadPool - * @brief Reference to threadpool. + * Reference to threadpool. */ static ca_thread_pool_t g_edrThreadPool = NULL; /** - * @var g_sendQueueHandle - * @brief Queue handle for Send Data + * Queue handle for Send Data */ static CAQueueingThread_t *g_sendQueueHandle = NULL; /** - * @var g_recvQueueHandle - * @brief Queue handle for Receive Data + * Queue handle for Receive Data */ static CAQueueingThread_t *g_recvQueueHandle = NULL; /** - * @var g_isHeaderAvailable - * @brief to differentiate btw header and data packet. - */ -static bool g_isHeaderAvailable = false; - -/** - * @var g_adapterState - * @brief Storing Adapter state information + * Storing Adapter state information */ static bool g_adapterState = true; /** - * @var g_networkPacketReceivedCallback - * @brief Maintains the callback to be notified on receival of network packets from other - * Bluetooth devices. + * Maintains the callback to be notified on receival of network packets from other + * Bluetooth devices. */ static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL; /** - * @var g_networkChangeCallback - * @brief Maintains the callback to be notified on local bluetooth adapter status change. + * Maintains the callback to be notified on local bluetooth adapter status change. */ -static CANetworkChangeCallback g_networkChangeCallback = NULL; +static CAAdapterChangeCallback g_adapterChangeCallback = NULL; /** - * @var g_localConnectivity - * @brief Information of local Bluetooth adapter. + * error Callback to CA adapter */ -static CAEndpoint_t *g_localConnectivity = NULL; +static CAErrorHandleCallback g_errorCallback = NULL; /** - * @var g_serverId - * @brief Storing RfcommserverUUID + * Information of local Bluetooth adapter. */ -static int g_serverId = -1; +static CAEndpoint_t *g_localConnectivity = NULL; /** - * @var g_serverState - * @brief Storing Rfcommserver state information + * Storing Rfcommserver state information */ static bool g_serverState = false; @@ -108,21 +93,21 @@ void CAAdapterTerminateQueues(); void CAAdapterDataSendHandler(void *context); void CAAdapterDataReceiverHandler(void *context); CAResult_t CAAdapterStopQueue(); -void CAAdapterRecvData(const char *remoteAddress, const void *data, uint32_t dataLength, - uint32_t *sentLength); +CAResult_t 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, const void *data, - uint32_t dataLength, uint32_t *sentLength); -CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, - CANetworkStatus_t status); -CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID, - const 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); +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 CAEndpoint_t *remoteEndpoint, const void *data, +static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data, uint32_t dataLength); /** @@ -139,136 +124,162 @@ 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, - ca_thread_pool_t handle) + CAAdapterChangeCallback netCallback, + CAConnectionChangeCallback connCallback, + 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"); - VERIFY_NON_NULL(networkStateChangeCallback, EDR_ADAPTER_TAG, - "network state change callback is NULL"); - VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool handle is NULL"); + VERIFY_NON_NULL(registerCallback, TAG, "register callback is NULL"); + VERIFY_NON_NULL(packetReceivedCallback, TAG, "data receive callback is NULL"); + VERIFY_NON_NULL(netCallback, TAG, "adapter state change callback is NULL"); + VERIFY_NON_NULL(connCallback, TAG, "connection state change callback is NULL"); + VERIFY_NON_NULL(handle, TAG, "Thread pool handle is NULL"); // Register the callbacks - g_edrThreadPool = handle; g_networkPacketReceivedCallback = packetReceivedCallback; - g_networkChangeCallback = networkStateChangeCallback; + g_adapterChangeCallback = netCallback; + 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; + OIC_LOG_V(ERROR, TAG, "EDR N/w Monitor Initialize failed!, error number [%d]", res); + return res; } CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus); CAEDRSetPacketReceivedCallback(CAAdapterRecvData); - CAEDRInitializeClient(handle); - - CAConnectivityHandler_t handler; - handler.startAdapter = CAStartEDR; - handler.startListenServer = CAStartEDRListeningServer; - 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); + CAEDRSetErrorHandler(CAEDRErrorHandler); + res = CAEDRClientInitialize(); + if (CA_STATUS_OK != res) + { + OIC_LOG_V(ERROR, 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, TAG, "EDR Server Initialize failed, error number [%d]", res); + return res; } - OIC_LOG(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, 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) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor"); + OIC_LOG(ERROR, TAG, "Failed to Start n/w monitor"); } // Get Bluetooth adapter state bool adapterState = false; if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state"); + OIC_LOG(ERROR, TAG, "Failed to get adapter enable state"); return CA_STATUS_FAILED; } if (false == adapterState) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!"); + OIC_LOG(ERROR, TAG, "Bluetooth adapter is disabled!"); g_adapterState = false; return CA_ADAPTER_NOT_ENABLED; } if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks())) { - OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Start Network Monitor failed!, error number [%d] ", + OIC_LOG_V(ERROR, TAG, "Start Network Monitor failed!, error number [%d] ", ret); } + // Initialize Send/Receive data message queues + if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers())) + { + OIC_LOG_V(ERROR, 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, 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() +{ + 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, TAG, "Failed to Start Device discovery"); + } +#endif return CAStartServer(); } int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data, - uint32_t dataLength) + uint32_t dataLength, CADataType_t dataType) { - 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); + VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "Remote endpoint is null", -1); + VERIFY_NON_NULL_RET(data, TAG, "Data is null", -1); + (void)dataType; if (0 == dataLength) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!"); + OIC_LOG(ERROR, TAG, "Invalid input: data length is zero!"); return -1; } if (0 == strlen(remoteEndpoint->addr)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!"); + OIC_LOG(ERROR, TAG, "Invalid input: EDR Address is empty!"); return -1; } @@ -278,24 +289,26 @@ int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *dat 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); + OIC_LOG_V(ERROR, TAG, "Send unicast data failed!, error num [%d]", err); + g_errorCallback(remoteEndpoint, data, dataLength, err); return -1; } - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); return sentLength; } -int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength) +int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength, + CADataType_t dataType) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData"); + OIC_LOG(DEBUG, TAG, "IN - CASendEDRMulticastData"); + (void)dataType; // Input validation - VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1); + VERIFY_NON_NULL_RET(data, TAG, "Data is null", -1); if (0 == dataLength) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!"); + OIC_LOG(ERROR, TAG, "Invalid input: data length is zero!"); return -1; } @@ -304,54 +317,40 @@ int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, u 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); + OIC_LOG_V(ERROR, TAG, "Send multicast data failed!, error num [%d]", err); + g_errorCallback(endpoint, data, dataLength, err); return -1; } - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData"); + OIC_LOG(DEBUG, TAG, "OUT - CASendEDRMulticastData"); return sentLen; } 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"); + VERIFY_NON_NULL(info, TAG, "LocalConnectivity info is null"); CAResult_t err = CA_STATUS_OK; *size = 0; if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info))) { - OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, - "Failed to get local interface information!, error num [%d]", err); + OIC_LOG_V(ERROR, TAG, "Failed to get local interface information!, error num [%d]", err); return err; } *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 - if (-1 != g_serverId) - { - CAEDRServerStop(g_serverId); - g_serverId = -1; - } - - // Stop network monitor - CAEDRStopNetworkMonitor(); + CAEDRServerStop(); // Stop the adapter CAEDRClientUnsetCallbacks(); @@ -359,19 +358,17 @@ CAResult_t CAStopEDR() // Disconnect all the client connections CAEDRClientDisconnectAll(); + // Stop network monitor + CAEDRStopNetworkMonitor(); + // 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"); - - // Stop EDR adapter - CAStopEDR(); // Terminate EDR Network Monitor CAEDRTerminateNetworkMonitor(); @@ -379,7 +376,7 @@ void CATerminateEDR() CAAdapterTerminateQueues(); g_networkPacketReceivedCallback = NULL; - g_networkChangeCallback = NULL; + g_adapterChangeCallback = NULL; // Terminate thread pool g_edrThreadPool = NULL; @@ -391,79 +388,63 @@ void CATerminateEDR() CAEDRServerTerminate(); // Free LocalConnectivity information - CAAdapterFreeEndpoint(g_localConnectivity); + 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!"); + OIC_LOG(DEBUG, TAG, "Bluetooth adapter is disabled!"); // Setting g_serverState for starting Rfcommserver when adapter starts g_serverState = true; return CA_STATUS_OK; } - if (-1 < g_serverId) - { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Server is already in running state."); - return CA_SERVER_STARTED_ALREADY; - } - - if (CA_STATUS_OK != (err = CAEDRServerStart(OIC_EDR_SERVICE_ID, &g_serverId, 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]", + OIC_LOG_V(ERROR, 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()) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!"); + OIC_LOG(DEBUG, TAG, "Queue is initialized!"); 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) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!"); + OIC_LOG(DEBUG, TAG, "Already queue is initialized!"); return CA_STATUS_OK; } g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); if (!g_sendQueueHandle) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!"); + OIC_LOG(ERROR, TAG, "Memory allocation failed!"); return CA_MEMORY_ALLOC_FAILED; } if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool, CAAdapterDataSendHandler, CAEDRDataDestroyer)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread"); + OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread"); return CA_STATUS_FAILED; } return CA_STATUS_OK; @@ -471,37 +452,36 @@ CAResult_t CAEDRInitializeSendHandler() CAResult_t CAEDRInitializeReceiveHandler() { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); // Check if the message queue is already initialized if (g_recvQueueHandle) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!"); + OIC_LOG(DEBUG, TAG, "Already queue is initialized!"); return CA_STATUS_OK; } g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); if (!g_recvQueueHandle) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!"); + OIC_LOG(ERROR, TAG, "Memory allocation failed!"); 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"); + OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread"); + 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); @@ -512,213 +492,118 @@ void CAAdapterTerminateQueues() CAQueueingThreadDestroy(g_recvQueueHandle); g_recvQueueHandle = NULL; } - - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); } void CAAdapterDataSendHandler(void *context) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler"); + OIC_LOG(DEBUG, TAG, "IN - CAAdapterDataSendHandler"); CAEDRData *message = (CAEDRData *) context; - if (NULL == message) + if (!message) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!"); + OIC_LOG(ERROR, TAG, "Failed to get message!"); return; } - const char *remoteAddress = NULL; - const char *serviceUUID = OIC_EDR_SERVICE_ID; - uint32_t sentLength = 0; - - if (NULL == message->remoteEndpoint) - { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available"); - } - else - { - remoteAddress = message->remoteEndpoint->addr; - } - - uint32_t dataSegmentLength = message->dataLen + CA_HEADER_LENGTH; - uint32_t dataLen = message->dataLen; - OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "checking for fragmentation and the dataLen is %d", - message->dataLen); - - char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char)); - VERIFY_NON_NULL_VOID(header, EDR_ADAPTER_TAG, "Memory allocation failed"); - - char* dataSegment = (char *) OICCalloc(dataSegmentLength, sizeof(char)); - if (NULL == dataSegment) + if (!message->remoteEndpoint) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed"); - OICFree(header); + OIC_LOG(DEBUG, TAG, "remoteEndpoint is not available"); return; } - CAResult_t result = CAGenerateHeader(header, dataLen); - if (CA_STATUS_OK != result) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Generate header failed"); - OICFree(header); - OICFree(dataSegment); - return ; - } - - memcpy(dataSegment, header, CA_HEADER_LENGTH); - OICFree(header); - uint32_t length = 0; - if (CA_SUPPORTED_EDR_MTU_SIZE > dataSegmentLength) + const char *remoteAddress = message->remoteEndpoint->addr; + if(!remoteAddress) { - length = dataSegmentLength; - memcpy(dataSegment + CA_HEADER_LENGTH, message->data, dataLen); - } - else - { - length = CA_SUPPORTED_EDR_MTU_SIZE; - memcpy(dataSegment + CA_HEADER_LENGTH, message->data, - CA_SUPPORTED_EDR_MTU_SIZE - CA_HEADER_LENGTH); - } - - uint32_t iter = dataSegmentLength / CA_SUPPORTED_EDR_MTU_SIZE; - uint32_t index = 0; - if (CA_STATUS_OK != CAEDRClientSendData(remoteAddress, serviceUUID, dataSegment, length, - &sentLength)) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed"); - OICFree(dataSegment); + OIC_LOG(ERROR, 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_EDR_MTU_SIZE) - CA_HEADER_LENGTH), - CA_SUPPORTED_EDR_MTU_SIZE, &sentLength)) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed"); - return; - } - } - - uint32_t remainingLen = dataSegmentLength % CA_SUPPORTED_EDR_MTU_SIZE; - if (remainingLen && (dataSegmentLength > CA_SUPPORTED_EDR_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_EDR_MTU_SIZE) - CA_HEADER_LENGTH, - remainingLen, &sentLength)) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed"); - return; - } + OIC_LOG(ERROR, TAG, "CAEDRClientSendData API failed"); + CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result); + return; } - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); + OIC_LOG(DEBUG, TAG, "OUT"); } -CAResult_t CAEDRClientSendData(const char *remoteAddress, const char *serviceUUID, - const 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 ((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(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !"); - return CA_STATUS_FAILED; + OIC_LOG(ERROR, TAG, "Failed to send unicast data !"); + return result; } } else { - OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data); - if (CA_STATUS_OK != CAEDRClientSendMulticastData(serviceUUID, data, dataLength, - sentLength)) + OIC_LOG_V(DEBUG, TAG, "sending multicast data : %s", data); + result = CAEDRClientSendMulticastData(data, dataLength); + + if (CA_STATUS_OK != result) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !"); - return CA_STATUS_FAILED; + OIC_LOG(ERROR, TAG, "Failed to send multicast data !"); + return result; } } - return CA_STATUS_OK; + return result; } void CAAdapterDataReceiverHandler(void *context) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler"); + OIC_LOG(DEBUG, TAG, "IN_CAAdapterDataReceiverHandler"); - CAEDRData *message = (CAEDRData *) context; - if (NULL == message) + if (NULL == g_networkPacketReceivedCallback) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!"); + OIC_LOG(ERROR, TAG, "g_networkPacketReceivedCallback is NULL"); return; } - static uint32_t recvDataLen = 0; - static uint32_t totalDataLen = 0; - static char *defragData = NULL; - static CAEndpoint_t *remoteEndpoint = NULL; - - if (!g_isHeaderAvailable) + CAEDRData *message = (CAEDRData *) context; + if (NULL == message || NULL == message->remoteEndpoint) { - totalDataLen = CAParseHeader((char*)message->data); - if (0 == totalDataLen) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "totalDataLen is zero"); - return; - } + OIC_LOG(ERROR, TAG, "Failed to get message!"); + return; + } - OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "Total data to be accumulated [%d] bytes", totalDataLen); + CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_RFCOMM_BTEDR, + message->remoteEndpoint->addr, + 0); - defragData = (char *) OICMalloc(sizeof(char) * totalDataLen); - if (!defragData) - { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "defragData is null"); - return; - } + if (!remoteEndpoint) + { + OIC_LOG(ERROR, TAG, "remoteEndpoint is NULL"); + return; + } - const char *remoteAddress = message->remoteEndpoint->addr; - uint16_t port = message->remoteEndpoint->port; + OIC_LOG(DEBUG, TAG, "Sending data up !"); - remoteEndpoint = CAAdapterCreateEndpoint(0, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, port); + const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint }; - memcpy(defragData + recvDataLen, message->data + CA_HEADER_LENGTH, - message->dataLen - CA_HEADER_LENGTH); - recvDataLen += message->dataLen - CA_HEADER_LENGTH; - g_isHeaderAvailable = true; - } - else - { - memcpy(defragData + recvDataLen, message->data, message->dataLen); - recvDataLen += message->dataLen ; - } + g_networkPacketReceivedCallback(&sep, message->data, message->dataLen); - if (totalDataLen == recvDataLen) - { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !"); - g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen); - recvDataLen = 0; - totalDataLen = 0; - remoteEndpoint = NULL; - g_isHeaderAvailable = false; - } + CAFreeEndpoint(remoteEndpoint); - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler"); + OIC_LOG(DEBUG, TAG, "OUT_CAAdapterDataReceiverHandler"); } CAResult_t CAAdapterStartQueue() { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); // Start send queue thread if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread"); + OIC_LOG(ERROR, TAG, "Failed to Start Send Data Thread"); CAEDRClientUnsetCallbacks(); //Disconnect all the client connections CAEDRClientDisconnectAll(); @@ -728,53 +613,49 @@ CAResult_t CAAdapterStartQueue() // Start receive queue thread if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread"); + OIC_LOG(ERROR, TAG, "Failed to Start Receive Data Thread"); CAEDRClientUnsetCallbacks(); //Disconnect all the client connections 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 void *data, uint32_t dataLength, - uint32_t *sentLength) +CAResult_t 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!"); + OIC_LOG_V(ERROR, TAG, "Bluetooth adapter is disabled!"); *sentLength = 0; - return; + return CA_ADAPTER_NOT_ENABLED; } // Input validation - 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"); + VERIFY_NON_NULL(data, TAG, "Data is null"); + VERIFY_NON_NULL(sentLength, TAG, "Sent data length holder is null"); // Create remote endpoint - CAEndpoint_t *remoteEndpoint = CAAdapterCreateEndpoint(0, - CA_ADAPTER_RFCOMM_BTEDR, - remoteAddress, - 0); + CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_RFCOMM_BTEDR, + remoteAddress, 0); if (NULL == remoteEndpoint) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !"); - return; + OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !"); + return CA_STATUS_FAILED; } // Add message to data queue @@ -783,33 +664,56 @@ void CAAdapterRecvData(const char *remoteAddress, const void *data, uint32_t dat *sentLength = dataLength; // Free remote endpoint - CAAdapterFreeEndpoint(remoteEndpoint); + CAFreeEndpoint(remoteEndpoint); + + return CA_STATUS_OK; +} + +void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data, + uint32_t dataLength, CAResult_t result) +{ + // Input validation + VERIFY_NON_NULL_VOID(data, TAG, "Data is null"); + + // Create remote endpoint + CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR, + remoteAddress, 0); + if (!remoteEndpoint) + { + OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !"); + return; + } + + g_errorCallback(remoteEndpoint, data, dataLength, result); - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); + // Free remote endpoint + CAFreeEndpoint(remoteEndpoint); } -CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const void *data, +CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data, uint32_t dataLength, uint32_t *sentLength) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData"); + OIC_LOG(DEBUG, TAG, "IN - CAAdapterSendData"); if (false == g_adapterState) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!"); + OIC_LOG(ERROR, 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(data, EDR_ADAPTER_TAG, "Data is null"); - VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null"); + VERIFY_NON_NULL(serviceUUID, TAG, "service UUID is null"); + VERIFY_NON_NULL(data, TAG, "Data is null"); + VERIFY_NON_NULL(sentLength, TAG, "Sent data length holder is null"); // Create remote endpoint - CAEndpoint_t *remoteEndpoint = CAAdapterCreateEndpoint(0, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, 0); + CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_RFCOMM_BTEDR, + remoteAddress, 0); if (NULL == remoteEndpoint) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !"); - return CA_STATUS_FAILED; + OIC_LOG(ERROR, TAG, "Failed to create remote endpoint !"); + return CA_MEMORY_ALLOC_FAILED; } // Add message to data queue @@ -818,16 +722,14 @@ CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, *sentLength = dataLength; // Free remote endpoint - CAAdapterFreeEndpoint(remoteEndpoint); + CAFreeEndpoint(remoteEndpoint); - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData"); + OIC_LOG(DEBUG, TAG, "OUT - CAAdapterSendData"); return CA_STATUS_OK; } void CAEDRNotifyNetworkStatus(CANetworkStatus_t status) { - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); - // Create localconnectivity if (NULL == g_localConnectivity) { @@ -842,13 +744,13 @@ void CAEDRNotifyNetworkStatus(CANetworkStatus_t status) bool adapterState = false; if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state"); + OIC_LOG(ERROR, TAG, "Failed to get adapter enable state"); return; } - if (false== adapterState) + if (false == adapterState) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!"); + OIC_LOG(ERROR, TAG, "Bluetooth adapter is disabled!"); g_adapterState = false; return; } @@ -866,66 +768,72 @@ void CAEDRNotifyNetworkStatus(CANetworkStatus_t status) else { g_adapterState = false; + + CAResult_t res = CAQueueingThreadClearData(g_sendQueueHandle); + if (res != CA_STATUS_OK) + { + OIC_LOG_V(ERROR, TAG, "CAQueueingThreadClearData failed[%d]", res); + } + + res = CAQueueingThreadClearData(g_recvQueueHandle); + if (res != CA_STATUS_OK) + { + OIC_LOG_V(ERROR, TAG, "CAQueueingThreadClearData failed[%d]", res); + } } // Notify to upper layer - if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool) + if (g_adapterChangeCallback && g_localConnectivity && g_edrThreadPool) { // Add notification task to thread pool CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status); if (NULL != event) { if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool, - CAEDROnNetworkStatusChanged,event)) + CAEDROnNetworkStatusChanged, event, NULL)) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!"); + OIC_LOG(ERROR, TAG, "Failed to create threadpool!"); return; } } } - - 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!"); + OIC_LOG(ERROR, TAG, "context is NULL!"); return; } CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context; // Notify to upper layer - if (g_networkChangeCallback) + if (g_adapterChangeCallback) { - g_networkChangeCallback(networkEvent->info, networkEvent->status); + g_adapterChangeCallback(networkEvent->info->adapter, networkEvent->status); } // Free the created Network event CAEDRFreeNetworkEvent(networkEvent); - - OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); } CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, CANetworkStatus_t status) { - VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL); + VERIFY_NON_NULL_RET(connectivity, TAG, "connectivity is NULL", NULL); // Create CAEDRNetworkEvent CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent)); if (NULL == event) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!"); + OIC_LOG(ERROR, TAG, "Failed to allocate memory to network event!"); return NULL; } // Create duplicate of Local connectivity - event->info = CAAdapterCloneEndpoint(connectivity); + event->info = CACloneEndpoint(connectivity); event->status = status; return event; } @@ -934,27 +842,27 @@ void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event) { if (event) { - CAAdapterFreeEndpoint(event->info); + CAFreeEndpoint(event->info); OICFree(event); } } CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, - const void *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!"); + OIC_LOG(ERROR, TAG, "Memory allocation failed!"); return NULL; } - edrData->remoteEndpoint = CAAdapterCloneEndpoint(remoteEndpoint); + edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint); edrData->data = OICMalloc(dataLength); if (NULL == edrData->data) { - OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!"); + OIC_LOG(ERROR, TAG, "Memory allocation failed!"); CAFreeEDRData(edrData); return NULL; } @@ -966,17 +874,20 @@ CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, void CAFreeEDRData(CAEDRData *edrData) { - VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL"); + VERIFY_NON_NULL_VOID(edrData, TAG, "edrData is NULL"); - CAAdapterFreeEndpoint(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, TAG, "Destroy data too small %p %d", data, size); + } CAEDRData *edrdata = (CAEDRData *) data; CAFreeEDRData(edrdata); } -