X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fbt_le_adapter%2Fcaleadapter.c;h=9a46051a927b53de38b64afcb5f1b1f37ab93cef;hb=9d5949060f992881916284e39ccb44437aa44fc1;hp=ebf1f101921a817e37d6bdca764d5455a64866c7;hpb=d8ae5d4d45753ae6fa74fd02a05a8d20838a45a7;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/connectivity/src/bt_le_adapter/caleadapter.c b/resource/csdk/connectivity/src/bt_le_adapter/caleadapter.c index ebf1f10..9a46051 100644 --- a/resource/csdk/connectivity/src/bt_le_adapter/caleadapter.c +++ b/resource/csdk/connectivity/src/bt_le_adapter/caleadapter.c @@ -39,16 +39,49 @@ */ #define CALEADAPTER_TAG "LAD" + +/** + * Stores the information of the Data to be sent from the queues. + * + * This structure will be pushed to the sender/receiver queue for + * processing. + */ +typedef struct +{ + /// Remote endpoint contains the information of remote device. + CAEndpoint_t *remoteEndpoint; + + /// Data to be transmitted over LE transport. + uint8_t *data; + + /// Length of the data being transmitted. + uint32_t dataLen; +} CALEData_t; + +/** + * Stores information of all the senders. + * + * This structure will be used to track and defragment all incoming + * data packet. + */ +typedef struct +{ + uint32_t recvDataLen; + uint32_t totalDataLen; + uint8_t *defragData; + CAEndpoint_t *remoteEndpoint; + } CABLESenderInfo_t; + /** * Callback to provide the status of the network change to CA layer. */ static CANetworkChangeCallback g_networkCallback = NULL; /** - * bleAddress of the local adapter. Value will be initialized to zero, and will - * be updated later. + * bleAddress of the local adapter. Value will be initialized to zero, + * and will be updated later. */ -static char g_localBLEAddress[18] = {0}; +static char g_localBLEAddress[18] = { 0 }; /** * Variable to differentiate btw GattServer and GattClient. @@ -56,23 +89,25 @@ static char g_localBLEAddress[18] = {0}; static bool g_isServer = false; /** - * Mutex to synchronize the task to be executed on the GattServer function - * calls. + * Mutex to synchronize the task to be executed on the GattServer + * function calls. */ static ca_mutex g_bleIsServerMutex = NULL; /** - * Mutex to synchronize the callback to be called for the network changes. + * Mutex to synchronize the callback to be called for the network + * changes. */ static ca_mutex g_bleNetworkCbMutex = NULL; /** - * Mutex to synchronize the updation of the local LE address of the adapter. + * Mutex to synchronize the updates of the local LE address of the + * adapter. */ static ca_mutex g_bleLocalAddressMutex = NULL; /** - * reference to threadpool. + * Reference to thread pool. */ static ca_thread_pool_t g_bleAdapterThreadPool = NULL; @@ -89,7 +124,7 @@ static ca_mutex g_bleClientSendDataMutex = NULL; /** * Mutex to synchronize the queing of the data from ReceiverQueue. */ -static ca_mutex g_bleClientReceiveDataMutex = NULL; +static ca_mutex g_bleReceiveDataMutex = NULL; /** @@ -98,17 +133,13 @@ static ca_mutex g_bleClientReceiveDataMutex = NULL; static ca_mutex g_bleServerSendDataMutex = NULL; /** - * Mutex to synchronize the queing of the data from ReceiverQueue. - */ -static ca_mutex g_bleServerReceiveDataMutex = NULL; - -/** - * Mutex to synchronize the callback to be called for the adapterReqResponse. + * Mutex to synchronize the callback to be called for the + * adapterReqResponse. */ static ca_mutex g_bleAdapterReqRespCbMutex = NULL; /** - * Callback to be called when network packet recieved from either + * Callback to be called when network packet received from either * GattServer or GattClient. */ static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL; @@ -124,8 +155,9 @@ static CAErrorHandleCallback g_errorHandler = NULL; static CAAdapterState_t g_bleAdapterState = CA_ADAPTER_DISABLED; /** - * status of BLE Server Status. - * This ENUM provides information of LE Adapter Server status. + * BLE Server Status. + * + * This enumeration provides information of LE Adapter Server status. */ typedef enum { @@ -135,65 +167,67 @@ typedef enum } CALeServerStatus; /** - * structure to maintain the status of the server. + * Structure to maintain the status of the server. */ static CALeServerStatus gLeServerStatus = CA_SERVER_NOTSTARTED; /** -* This function is used to register network change notification callback. -* -* @param[in] netCallback CANetworkChangeCallback callback which will be -* set for the change in nwk. -* -* @return 0 on success otherwise a positive error value. -* @retval CA_STATUS_OK Successful. -* @retval CA_STATUS_INVALID_PARAM Invalid input argumets. -* @retval CA_STATUS_FAILED Operation failed. -* -*/ -CAResult_t CALERegisterNetworkNotifications(CANetworkChangeCallback netCallback); + * Register network change notification callback. + * + * @param[in] netCallback CANetworkChangeCallback callback which will + * be set for the change in network. + * + * @return 0 on success otherwise a positive error value. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + * + */ +static CAResult_t CALERegisterNetworkNotifications(CANetworkChangeCallback netCallback); /** -* Used to Set the gThreadPool handle which is required for spawning new thread. -* -* @param[in] handle - Thread pool handle which is given by above layer for -* using thread creation task. -* -*/ -void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle); + * Set the thread pool handle which is required for spawning new + * thread. + * + * @param[in] handle Thread pool handle which is given by above layer + * for using thread creation task. + * + */ +static void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle); /** -* This function is used to call the callback to the upper layer when the -* device state gets changed. -* -* @param[in] adapter_state New state of the adapter to be notified to the -* upper layer. -* -*/ -void CALEDeviceStateChangedCb( CAAdapterState_t adapter_state); + * Call the callback to the upper layer when the device state gets + * changed. + * + * @param[in] adapter_state New state of the adapter to be notified to + * the upper layer. + */ +static void CALEDeviceStateChangedCb(CAAdapterState_t adapter_state); /** -* Used to initialize all required mutex variable for LE Adapter implementation. -* -* @return 0 on success otherwise a positive error value. -* @retval CA_STATUS_OK Successful. -* @retval CA_STATUS_INVALID_PARAM Invalid input argumets. -* @retval CA_STATUS_FAILED Operation failed. -* -*/ -CAResult_t CAInitLEAdapterMutex(); + * Used to initialize all required mutex variable for LE Adapter + * implementation. + * + * @return 0 on success otherwise a positive error value. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + * + */ +static CAResult_t CAInitLEAdapterMutex(); /** -* Used to terminate all required mutex variable for LE adapter implementation. -* -*/ -void CATerminateLEAdapterMutex(); + * Terminate all required mutex variables for LE adapter + * implementation. + */ +static void CATerminateLEAdapterMutex(); /** -* prepares and notify error through error callback. -* -*/ -static void CALEErrorHandler(const char *remoteAddress, const void *data, uint32_t dataLen, + * Prepares and notify error through error callback. + */ +static void CALEErrorHandler(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLen, CAResult_t result); #ifndef SINGLE_THREAD @@ -203,6 +237,11 @@ static void CALEErrorHandler(const char *remoteAddress, const void *data, uint32 static bool g_dataReceiverHandlerState = false; /** + * Sender information. + */ +static u_arraylist_t *g_senderInfo = NULL; + +/** * Queue to process the outgoing packets from GATTClient. */ static CAQueueingThread_t *g_bleClientSendQueueHandle = NULL; @@ -210,7 +249,7 @@ static CAQueueingThread_t *g_bleClientSendQueueHandle = NULL; /** * Queue to process the incoming packets to GATT Client. */ -static CAQueueingThread_t *g_bleClientReceiverQueue = NULL; +static CAQueueingThread_t *g_bleReceiverQueue = NULL; /** * Queue to process the outgoing packets from GATTServer. @@ -218,38 +257,343 @@ static CAQueueingThread_t *g_bleClientReceiverQueue = NULL; static CAQueueingThread_t *g_bleServerSendQueueHandle = NULL; /** - * Queue to process the incoming packets to GATTServer. + * Starting LE connectivity adapters. + * + * As its peer to peer it does not require to start any servers. + * + * @return ::CA_STATUS_OK or Appropriate error code. */ -static CAQueueingThread_t *g_bleServerReceiverQueue = NULL; +static CAResult_t CAStartLE(); /** -* Used to free data. -* -*/ -static void CALEDataDestroyer(void *data, uint32_t size); + * Start listening server for receiving multicast search requests. + * + * Transport Specific Behavior: + * LE Starts GATT Server with prefixed UUID and Characteristics + * per OIC Specification. + * @return ::CA_STATUS_OK or Appropriate error code. + */ +static CAResult_t CAStartLEListeningServer(); -void CAInitLEQueues() -{ - OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); +/** + * Sarting discovery of servers for receiving multicast + * advertisements. + * + * Transport Specific Behavior: + * LE Starts GATT Server with prefixed UUID and Characteristics + * per OIC Specification. + * + * @return ::CA_STATUS_OK or Appropriate error code + */ +static CAResult_t CAStartLEDiscoveryServer(); - CAResult_t result = CAInitLEServerQueues(); - if (CA_STATUS_OK != result) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleServerQueues failed"); - return; - } +/** + * Send data to the endpoint using the adapter connectivity. + * + * @param[in] endpoint Remote Endpoint information (like MAC address, + * reference URI and connectivity type) to which + * the unicast data has to be sent. + * @param[in] data Data which required to be sent. + * @param[in] dataLen Size of data to be sent. + * + * @note dataLen must be > 0. + * + * @return The number of bytes sent on the network, or -1 on error. + */ +static int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint, + const void *data, + uint32_t dataLen); - result = CAInitLEClientQueues(); - if (CA_STATUS_OK != result) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleClientQueues failed"); - return; - } +/** + * Send multicast data to the endpoint using the LE connectivity. + * + * @param[in] endpoint Remote Endpoint information to which the + * multicast data has to be sent. + * @param[in] data Data which required to be sent. + * @param[in] dataLen Size of data to be sent. + * + * @note dataLen must be > 0. + * + * @return The number of bytes sent on the network, or -1 on error. + */ +static int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint, + const void *data, + uint32_t dataLen); - OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); -} +/** + * Get LE Connectivity network information. + * + * @param[out] info Local connectivity information structures. + * @param[out] size Number of local connectivity structures. + * + * @return ::CA_STATUS_OK or Appropriate error code. + */ +static CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, + uint32_t *size); + +/** + * Read Synchronous API callback. + * + * @return ::CA_STATUS_OK or Appropriate error code. + */ +static CAResult_t CAReadLEData(); + +/** + * Stopping the adapters and close socket connections. + * + * LE Stops all GATT servers and GATT Clients. + * + * @return ::CA_STATUS_OK or Appropriate error code. + */ +static CAResult_t CAStopLE(); + +/** + * Terminate the LE connectivity adapter. + * + * Configuration information will be deleted from further use. + */ +static void CATerminateLE(); + +/** + * Set the NetworkPacket received callback to CA layer from adapter + * layer. + * + * @param[in] callback Callback handle sent from the upper layer. + */ +static void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback); -CAResult_t CAInitLEServerQueues() +/** + * Push the data from CA layer to the Sender processor queue. + * + * @param[in] remoteEndpoint Remote endpoint information of the + * server. + * @param[in] data Data to be transmitted from LE. + * @param[in] dataLen Length of the Data being transmitted. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLen); + +/** + * Push the data from CA layer to the Sender processor queue. + * + * @param[in] remoteEndpoint Remote endpoint information of the + * server. + * @param[in] data Data to be transmitted from LE. + * @param[in] dataLen Length of the Data being transmitted. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLen); + +/** + * This function will receive the data from the GattServer and add the + * data to the Server receiver queue. + * + * @param[in] remoteAddress Remote address of the device from where + * data is received. + * @param[in] data Actual data recevied from the remote + * device. + * @param[in] dataLength Length of the data received from the + * remote device. + * @param[in] sentLength Length of the data sent from the remote + * device. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + * + */ +static CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLength, + uint32_t *sentLength); + +/** + * This function will receive the data from the GattClient and add the + * data into the Client receiver queue. + * + * @param[in] remoteAddress Remote address of the device from where + * data is received. + * @param[in] data Actual data recevied from the remote + * device. + * @param[in] dataLength Length of the data received from the + * remote device. + * @param[in] sentLength Length of the data sent from the remote + * device. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLength, + uint32_t *sentLength); + +/** + * This function will be associated with the sender queue for + * GattServer. + * + * This function will fragment the data to the MTU of the transport + * and send the data in fragments to the adapters. The function will + * be blocked until all data is sent out from the adapter. + * + * @param[in] threadData Data pushed to the queue which contains the + * info about RemoteEndpoint and Data. + */ +static void CALEServerSendDataThread(void *threadData); + +/** + * This function will be associated with the sender queue for + * GattClient. + * + * This function will fragment the data to the MTU of the transport + * and send the data in fragments to the adapters. The function will + * be blocked until all data is sent out from the adapter. + * + * @param[in] threadData Data pushed to the queue which contains the + * info about RemoteEndpoint and Data. + */ +static void CALEClientSendDataThread(void *threadData); + +/** + * This function will be associated with the receiver queue. + * + * This function will defragment the received data from each sender + * respectively and will send it up to CA layer. Respective sender's + * header will provide the length of the data sent. + * + * @param[in] threadData Data pushed to the queue which contains the + * info about RemoteEndpoint and Data. + */ +static void CALEDataReceiverHandler(void *threadData); + +/** + * This function will stop all queues created for GattServer and + * GattClient. All four queues will be be stopped with this function + * invocations. + */ +static void CAStopLEQueues(); + +/** + * This function will terminate all queues created for GattServer and + * GattClient. All four queues will be be terminated with this + * function invocations. + */ +static void CATerminateLEQueues(); + +/** + * This function will initalize the Receiver and Sender queues for + * GattServer. This function will in turn call the functions + * CAInitBleServerReceiverQueue() and CAInitBleServerSenderQueue() to + * initialize the queues. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CAInitLEServerQueues(); + +/** + * This function will initalize the Receiver and Sender queues for + * GattClient. This function will inturn call the functions + * CAInitBleClientReceiverQueue() and CAInitBleClientSenderQueue() to + * initialize the queues. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + * + */ +static CAResult_t CAInitLEClientQueues(); + +/** + * This function will initalize the Receiver queue for + * GattServer. This will initialize the queue to process the function + * CABLEServerSendDataThread() when ever the task is added to this + * queue. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CAInitLEServerSenderQueue(); + +/** + * This function will initalize the Receiver queue for + * GattClient. This will initialize the queue to process the function + * CABLEClientSendDataThread() when ever the task is added to this + * queue. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CAResult_t CAInitLEClientSenderQueue(); + +/** + * This function will initialize the Receiver queue for + * LEAdapter. This will initialize the queue to process the function + * CABLEDataReceiverHandler() when ever the task is added to this + * queue. + * + * @return ::CA_STATUS_OK or Appropriate error code + * @retval ::CA_STATUS_OK Successful + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments + * @retval ::CA_STATUS_FAILED Operation failed + * + */ +static CAResult_t CAInitLEReceiverQueue(); + +/** + * This function will create the Data required to send it in the + * queue. + * + * @param[in] remoteEndpoint Remote endpoint information of the + * server. + * @param[in] data Data to be transmitted from LE. + * @param[in] dataLength Length of the Data being transmitted. + * + * @return ::CA_STATUS_OK or Appropriate error code. + * @retval ::CA_STATUS_OK Successful. + * @retval ::CA_STATUS_INVALID_PARAM Invalid input arguments. + * @retval ::CA_STATUS_FAILED Operation failed. + */ +static CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLength); + +/** + * Used to free the BLE information stored in the sender/receiver + * queues. + * + * @param[in] bleData Information for a particular data segment. + */ +static void CAFreeLEData(CALEData_t *bleData); + +/** + * Free data. + */ +static void CALEDataDestroyer(void *data, uint32_t size); + +static CAResult_t CAInitLEServerQueues() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -263,7 +607,7 @@ CAResult_t CAInitLEServerQueues() return CA_STATUS_FAILED; } - result = CAInitLEServerReceiverQueue(); + result = CAInitLEReceiverQueue(); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleServerReceiverQueue failed"); @@ -279,7 +623,7 @@ CAResult_t CAInitLEServerQueues() return CA_STATUS_OK; } -CAResult_t CAInitLEClientQueues() +static CAResult_t CAInitLEClientQueues() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -293,7 +637,7 @@ CAResult_t CAInitLEClientQueues() return CA_STATUS_FAILED; } - result = CAInitLEClientReceiverQueue(); + result = CAInitLEReceiverQueue(); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "CAInitBleClientReceiverQueue failed"); @@ -309,39 +653,49 @@ CAResult_t CAInitLEClientQueues() return CA_STATUS_OK; } -CAResult_t CAInitLEServerSenderQueue() +static CAResult_t CAInitLEReceiverQueue() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); // Check if the message queue is already initialized - if (g_bleServerSendQueueHandle) + if (g_bleReceiverQueue) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Queue is already initialized!"); + OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!"); return CA_STATUS_OK; } - // Create send message queue - g_bleServerSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); - if (!g_bleServerSendQueueHandle) + // Create recv message queue + g_bleReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); + if (!g_bleReceiverQueue) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); return CA_MEMORY_ALLOC_FAILED; } - if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerSendQueueHandle, - g_bleAdapterThreadPool, - CALEServerSendDataThread, CALEDataDestroyer)) + g_senderInfo = u_arraylist_create(); + if (!g_senderInfo) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "ClientInfo memory allcation failed!"); + OICFree(g_bleReceiverQueue); + g_bleReceiverQueue = NULL; + return CA_MEMORY_ALLOC_FAILED; + } + + if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleReceiverQueue, g_bleAdapterThreadPool, + CALEDataReceiverHandler, CALEDataDestroyer)) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread"); - OICFree(g_bleServerSendQueueHandle); - g_bleServerSendQueueHandle = NULL; + OICFree(g_bleReceiverQueue); + g_bleReceiverQueue = NULL; + u_arraylist_free(&g_senderInfo); return CA_STATUS_FAILED; } - if (CA_STATUS_OK != CAQueueingThreadStart(g_bleServerSendQueueHandle)) + if (CA_STATUS_OK != CAQueueingThreadStart(g_bleReceiverQueue)) { OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed "); - OICFree(g_bleServerSendQueueHandle); - g_bleServerSendQueueHandle = NULL; + OICFree(g_bleReceiverQueue); + g_bleReceiverQueue = NULL; + u_arraylist_free(&g_senderInfo); return CA_STATUS_FAILED; } @@ -349,39 +703,39 @@ CAResult_t CAInitLEServerSenderQueue() return CA_STATUS_OK; } -CAResult_t CAInitLEClientSenderQueue() +static CAResult_t CAInitLEServerSenderQueue() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - - if (g_bleClientSendQueueHandle) + // Check if the message queue is already initialized + if (g_bleServerSendQueueHandle) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!"); + OIC_LOG(DEBUG, CALEADAPTER_TAG, "Queue is already initialized!"); return CA_STATUS_OK; } // Create send message queue - g_bleClientSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); - if (!g_bleClientSendQueueHandle) + g_bleServerSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); + if (!g_bleServerSendQueueHandle) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); return CA_MEMORY_ALLOC_FAILED; } - if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientSendQueueHandle, + if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerSendQueueHandle, g_bleAdapterThreadPool, - CALEClientSendDataThread, CALEDataDestroyer)) + CALEServerSendDataThread, CALEDataDestroyer)) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread"); - OICFree(g_bleClientSendQueueHandle); - g_bleClientSendQueueHandle = NULL; + OICFree(g_bleServerSendQueueHandle); + g_bleServerSendQueueHandle = NULL; return CA_STATUS_FAILED; } - if (CA_STATUS_OK != CAQueueingThreadStart(g_bleClientSendQueueHandle)) + if (CA_STATUS_OK != CAQueueingThreadStart(g_bleServerSendQueueHandle)) { OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed "); - OICFree(g_bleClientSendQueueHandle); - g_bleClientSendQueueHandle = NULL; + OICFree(g_bleServerSendQueueHandle); + g_bleServerSendQueueHandle = NULL; return CA_STATUS_FAILED; } @@ -389,82 +743,61 @@ CAResult_t CAInitLEClientSenderQueue() return CA_STATUS_OK; } -CAResult_t CAInitLEServerReceiverQueue() +static void CALEClearSenderInfo() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - // Check if the message queue is already initialized - if (g_bleServerReceiverQueue) - { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!"); - return CA_STATUS_OK; - } - // Create send message queue - g_bleServerReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); - if (!g_bleServerReceiverQueue) + uint32_t listIndex = 0; + uint32_t listLength = u_arraylist_length(g_senderInfo); + for (listIndex = 0; listIndex < listLength; listIndex++) { - OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); - OICFree(g_bleServerSendQueueHandle); - return CA_MEMORY_ALLOC_FAILED; - } - - if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleServerReceiverQueue, g_bleAdapterThreadPool, - CALEServerDataReceiverHandler, CALEDataDestroyer)) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread"); - OICFree(g_bleServerReceiverQueue); - g_bleServerReceiverQueue = NULL; - return CA_STATUS_FAILED; - } + CABLESenderInfo_t *info = (CABLESenderInfo_t *) u_arraylist_get(g_senderInfo, listIndex); + if(!info) + { + continue; + } - if (CA_STATUS_OK != CAQueueingThreadStart(g_bleServerReceiverQueue)) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed "); - OICFree(g_bleServerReceiverQueue); - g_bleServerReceiverQueue = NULL; - return CA_STATUS_FAILED; + OICFree(info->defragData); + CAFreeEndpoint(info->remoteEndpoint); + OICFree(info); } - + u_arraylist_free(&g_senderInfo); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); - return CA_STATUS_OK; } -CAResult_t CAInitLEClientReceiverQueue() +static CAResult_t CAInitLEClientSenderQueue() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - // Check if the message queue is already initialized - if (g_bleClientReceiverQueue) + if (g_bleClientSendQueueHandle) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "Already queue is initialized!"); + return CA_STATUS_OK; } - else + + // Create send message queue + g_bleClientSendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); + if (!g_bleClientSendQueueHandle) { - // Create send message queue - g_bleClientReceiverQueue = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t)); - if (!g_bleClientReceiverQueue) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); - OICFree(g_bleClientSendQueueHandle); - return CA_MEMORY_ALLOC_FAILED; - } + OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); + return CA_MEMORY_ALLOC_FAILED; + } - if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientReceiverQueue, - g_bleAdapterThreadPool, - CALEClientDataReceiverHandler, NULL)) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread"); - OICFree(g_bleClientSendQueueHandle); - OICFree(g_bleClientReceiverQueue); - g_bleClientReceiverQueue = NULL; - return CA_STATUS_FAILED; - } + if (CA_STATUS_OK != CAQueueingThreadInitialize(g_bleClientSendQueueHandle, + g_bleAdapterThreadPool, + CALEClientSendDataThread, CALEDataDestroyer)) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to Initialize send queue thread"); + OICFree(g_bleClientSendQueueHandle); + g_bleClientSendQueueHandle = NULL; + return CA_STATUS_FAILED; } - if (CA_STATUS_OK != CAQueueingThreadStart(g_bleClientReceiverQueue)) + + if (CA_STATUS_OK != CAQueueingThreadStart(g_bleClientSendQueueHandle)) { OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_thread_pool_add_task failed "); - OICFree(g_bleClientReceiverQueue); - g_bleClientReceiverQueue = NULL; + OICFree(g_bleClientSendQueueHandle); + g_bleClientSendQueueHandle = NULL; return CA_STATUS_FAILED; } @@ -472,7 +805,7 @@ CAResult_t CAInitLEClientReceiverQueue() return CA_STATUS_OK; } -void CAStopLEQueues() +static void CAStopLEQueues() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -483,13 +816,6 @@ void CAStopLEQueues() } ca_mutex_unlock(g_bleClientSendDataMutex); - ca_mutex_lock(g_bleClientReceiveDataMutex); - if (NULL != g_bleClientReceiverQueue) - { - CAQueueingThreadStop(g_bleClientReceiverQueue); - } - ca_mutex_unlock(g_bleClientReceiveDataMutex); - ca_mutex_lock(g_bleServerSendDataMutex); if (NULL != g_bleServerSendQueueHandle) { @@ -497,17 +823,17 @@ void CAStopLEQueues() } ca_mutex_unlock(g_bleServerSendDataMutex); - ca_mutex_lock(g_bleServerReceiveDataMutex); - if (NULL != g_bleServerReceiverQueue) + ca_mutex_lock(g_bleReceiveDataMutex); + if (NULL != g_bleReceiverQueue) { - CAQueueingThreadStop(g_bleServerReceiverQueue); + CAQueueingThreadStop(g_bleReceiverQueue); } - ca_mutex_unlock(g_bleServerReceiveDataMutex); + ca_mutex_unlock(g_bleReceiveDataMutex); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CATerminateLEQueues() +static void CATerminateLEQueues() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -515,142 +841,61 @@ void CATerminateLEQueues() OICFree(g_bleClientSendQueueHandle); g_bleClientSendQueueHandle = NULL; - - CAQueueingThreadDestroy(g_bleClientReceiverQueue); - OICFree(g_bleClientReceiverQueue); - g_bleClientReceiverQueue = NULL; - - CAQueueingThreadDestroy(g_bleServerSendQueueHandle); OICFree(g_bleServerSendQueueHandle); g_bleServerSendQueueHandle = NULL; + CAQueueingThreadDestroy(g_bleReceiverQueue); + OICFree(g_bleReceiverQueue); + g_bleReceiverQueue = NULL; - CAQueueingThreadDestroy(g_bleServerReceiverQueue); - OICFree(g_bleServerReceiverQueue); - g_bleServerReceiverQueue = NULL; + CALEClearSenderInfo(); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CALEServerDataReceiverHandler(void *threadData) +static CAResult_t CALEGetSenderInfo(const char *leAddress, + CABLESenderInfo_t **senderInfo, + uint32_t *senderIndex) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - - static uint32_t recvDataLen = 0; - static uint32_t totalDataLen = 0; - static char *defragData = NULL; - static bool isHeaderAvailable = false; - static CAEndpoint_t *remoteEndpoint = NULL; - - ca_mutex_lock(g_bleServerReceiveDataMutex); - - if (g_dataReceiverHandlerState) - { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "checking for DE Fragmentation"); - - CALEData_t *bleData = (CALEData_t *) threadData; - if (!bleData) + VERIFY_NON_NULL_RET(leAddress, + CALEADAPTER_TAG, + "NULL BLE address argument", + CA_STATUS_INVALID_PARAM); + VERIFY_NON_NULL_RET(senderIndex, + CALEADAPTER_TAG, + "NULL index argument", + CA_STATUS_INVALID_PARAM); + + const uint32_t listLength = u_arraylist_length(g_senderInfo); + const uint32_t addrLength = strlen(leAddress); + for (uint32_t index = 0; index < listLength; index++) + { + CABLESenderInfo_t *info = (CABLESenderInfo_t *) u_arraylist_get(g_senderInfo, index); + if(!info || !(info->remoteEndpoint)) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bleData!"); - ca_mutex_unlock(g_bleServerReceiveDataMutex); - return; + continue; } - OIC_LOG(DEBUG, CALEADAPTER_TAG, "checking for DE Fragmentation"); - - if (!isHeaderAvailable) - { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header"); - totalDataLen = CAParseHeader((char*)bleData->data); - - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Total data to be accumulated [%d] bytes", totalDataLen); - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "data received in the first packet [%d] bytes", bleData->dataLen); - - defragData = (char *) OICCalloc(totalDataLen + 1, sizeof(char)); - if (NULL == defragData) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!"); - ca_mutex_unlock(g_bleServerReceiveDataMutex); - return; - } - - const char *remoteAddress = bleData->remoteEndpoint->addr; - - remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_GATT_BTLE, - remoteAddress, 0); - - memcpy(defragData + recvDataLen, bleData->data + CA_HEADER_LENGTH, - bleData->dataLen - CA_HEADER_LENGTH); - recvDataLen += bleData->dataLen - CA_HEADER_LENGTH; - isHeaderAvailable = true; - } - else - { - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%d]", bleData->dataLen); - memcpy(defragData + recvDataLen, bleData->data, bleData->dataLen); - recvDataLen += bleData->dataLen ; - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "totalDatalength [%d] recveived Datalen [%d]", - totalDataLen, recvDataLen); - } - if (totalDataLen == recvDataLen) + if(!strncmp(info->remoteEndpoint->addr, leAddress, addrLength)) { - ca_mutex_lock(g_bleAdapterReqRespCbMutex); - if (NULL == g_networkPacketReceivedCallback) + *senderIndex = index; + if(senderInfo) { - OIC_LOG(ERROR, CALEADAPTER_TAG, "gReqRespCallback is NULL!"); - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - remoteEndpoint = NULL; - defragData = NULL; - ca_mutex_unlock(g_bleAdapterReqRespCbMutex); - ca_mutex_unlock(g_bleServerReceiveDataMutex); - return; + *senderInfo = info; } - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending data up !"); - g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen); - - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - - recvDataLen = 0; - totalDataLen = 0; - isHeaderAvailable = false; - remoteEndpoint = NULL; - defragData = NULL; - ca_mutex_unlock(g_bleAdapterReqRespCbMutex); - } - - if (false == g_dataReceiverHandlerState) - { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "GATTClient is terminating. Cleaning up"); - recvDataLen = 0; - totalDataLen = 0; - isHeaderAvailable = false; - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - remoteEndpoint = NULL; - defragData = NULL; - ca_mutex_unlock(g_bleServerReceiveDataMutex); - return; + return CA_STATUS_OK; } } - ca_mutex_unlock(g_bleServerReceiveDataMutex); - OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); + + return CA_STATUS_FAILED; } -void CALEClientDataReceiverHandler(void *threadData) +static void CALEDataReceiverHandler(void *threadData) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - static const char *remoteAddress = NULL; - static uint32_t recvDataLen = 0; - static uint32_t totalDataLen = 0; - static char *defragData = NULL; - static bool isHeaderAvailable = false; - static CAEndpoint_t *remoteEndpoint = NULL; - - ca_mutex_lock(g_bleClientReceiveDataMutex); + ca_mutex_lock(g_bleReceiveDataMutex); if (g_dataReceiverHandlerState) { @@ -659,108 +904,170 @@ void CALEClientDataReceiverHandler(void *threadData) CALEData_t *bleData = (CALEData_t *) threadData; if (!bleData) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid wifidata!"); - ca_mutex_unlock(g_bleClientReceiveDataMutex); + OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bleData!"); + ca_mutex_unlock(g_bleReceiveDataMutex); return; } - OIC_LOG(DEBUG, CALEADAPTER_TAG, "checking for DE Fragmentation"); + if(!(bleData->remoteEndpoint)) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "Client RemoteEndPoint NULL!!"); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } - if (!isHeaderAvailable) + CABLESenderInfo_t *senderInfo = NULL; + uint32_t senderIndex = 0; + + if(CA_STATUS_OK != CALEGetSenderInfo(bleData->remoteEndpoint->addr, + &senderInfo, &senderIndex)) { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header"); + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "This is a new client [%s]", + bleData->remoteEndpoint->addr); + } - totalDataLen = CAParseHeader(bleData->data); - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Total data to be accumulated [%d] bytes", - totalDataLen); - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data received in the first packet [%d] bytes", - bleData->dataLen); + if(!senderInfo) + { + CABLESenderInfo_t *newSender = OICMalloc(sizeof(CABLESenderInfo_t)); + if(!newSender) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed for new sender"); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } + newSender->recvDataLen = 0; + newSender->totalDataLen = 0; + newSender->defragData = NULL; + newSender->remoteEndpoint = NULL; - defragData = (char *) OICMalloc(sizeof(char) * totalDataLen); - if (NULL == defragData) + OIC_LOG(DEBUG, CALEADAPTER_TAG, "Parsing the header"); + newSender->totalDataLen = CAParseHeader(bleData->data, + bleData->dataLen); + if(!(newSender->totalDataLen)) { - OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!"); - ca_mutex_unlock(g_bleClientReceiveDataMutex); + OIC_LOG(ERROR, CALEADAPTER_TAG, "Total Data Length is parsed as 0!!!"); + OICFree(newSender); + ca_mutex_unlock(g_bleReceiveDataMutex); return; } - remoteAddress = bleData->remoteEndpoint->addr; + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Total data to be accumulated [%u] bytes", + newSender->totalDataLen); + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "data received in the first packet [%u] bytes", + bleData->dataLen); - remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_GATT_BTLE, - remoteAddress, 0); + newSender->defragData = OICCalloc(newSender->totalDataLen + 1, + sizeof(*newSender->defragData)); + + if (NULL == newSender->defragData) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "defragData is NULL!"); + OICFree(newSender); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } - memcpy(defragData, bleData->data + CA_HEADER_LENGTH, - bleData->dataLen - CA_HEADER_LENGTH); - recvDataLen += bleData->dataLen - CA_HEADER_LENGTH; - isHeaderAvailable = true; + const char *remoteAddress = bleData->remoteEndpoint->addr; + newSender->remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_GATT_BTLE, remoteAddress, 0); + if (NULL == newSender->remoteEndpoint) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "remoteEndpoint is NULL!"); + OICFree(newSender->defragData); + OICFree(newSender); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } + memcpy(newSender->defragData, bleData->data + CA_HEADER_LENGTH, + bleData->dataLen - CA_HEADER_LENGTH); + newSender->recvDataLen += bleData->dataLen - CA_HEADER_LENGTH; + u_arraylist_add(g_senderInfo,(void *)newSender); + + //Getting newSender index position in g_senderInfo array list + if(CA_STATUS_OK != + CALEGetSenderInfo(newSender->remoteEndpoint->addr, NULL, &senderIndex)) + { + OIC_LOG(ERROR, CALEADAPTER_TAG, "Existing sender index not found!!"); + OICFree(newSender->defragData); + CAFreeEndpoint(newSender->remoteEndpoint); + OICFree(newSender); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } + senderInfo = newSender; } else { + if(senderInfo->recvDataLen + bleData->dataLen > senderInfo->totalDataLen) + { + OIC_LOG_V(ERROR, CALEADAPTER_TAG, + "Data Length exceeding error!! Receiving [%d] total length [%d]", + senderInfo->recvDataLen + bleData->dataLen, senderInfo->totalDataLen); + u_arraylist_remove(g_senderInfo, senderIndex); + OICFree(senderInfo->defragData); + OICFree(senderInfo); + ca_mutex_unlock(g_bleReceiveDataMutex); + return; + } OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Copying the data of length [%d]", bleData->dataLen); - memcpy(defragData + recvDataLen, bleData->data, bleData->dataLen); - recvDataLen += bleData->dataLen ; + memcpy(senderInfo->defragData + senderInfo->recvDataLen, bleData->data, + bleData->dataLen); + senderInfo->recvDataLen += bleData->dataLen ; OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "totalDatalength [%d] recveived Datalen [%d]", - totalDataLen, recvDataLen); + senderInfo->totalDataLen, senderInfo->recvDataLen); } - if (totalDataLen == recvDataLen) + + if (senderInfo->totalDataLen == senderInfo->recvDataLen) { ca_mutex_lock(g_bleAdapterReqRespCbMutex); if (NULL == g_networkPacketReceivedCallback) { OIC_LOG(ERROR, CALEADAPTER_TAG, "gReqRespCallback is NULL!"); - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - remoteEndpoint = NULL; - defragData = NULL; + + u_arraylist_remove(g_senderInfo, senderIndex); + OICFree(senderInfo->defragData); + OICFree(senderInfo); ca_mutex_unlock(g_bleAdapterReqRespCbMutex); - ca_mutex_unlock(g_bleClientReceiveDataMutex); + ca_mutex_unlock(g_bleReceiveDataMutex); return; } OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending data up !"); - g_networkPacketReceivedCallback(remoteEndpoint, defragData, recvDataLen); - recvDataLen = 0; - totalDataLen = 0; - isHeaderAvailable = false; - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - remoteEndpoint = NULL; - defragData = NULL; + g_networkPacketReceivedCallback(senderInfo->remoteEndpoint, + senderInfo->defragData, senderInfo->recvDataLen); ca_mutex_unlock(g_bleAdapterReqRespCbMutex); - } - - if (false == g_dataReceiverHandlerState) - { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "GATTClient is terminating. Cleaning up"); - OICFree(defragData); - CAFreeEndpoint(remoteEndpoint); - remoteEndpoint = NULL; - defragData = NULL; - ca_mutex_unlock(g_bleClientReceiveDataMutex); - return; + u_arraylist_remove(g_senderInfo, senderIndex); + senderInfo->remoteEndpoint = NULL; + senderInfo->defragData = NULL; + OICFree(senderInfo); } } - ca_mutex_unlock(g_bleClientReceiveDataMutex); + ca_mutex_unlock(g_bleReceiveDataMutex); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CALEServerSendDataThread(void *threadData) +static void CALEServerSendDataThread(void *threadData) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - CALEData_t *bleData = (CALEData_t *) threadData; + CALEData_t * const bleData = (CALEData_t *) threadData; if (!bleData) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "Invalid bledata!"); return; } - char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char)); + uint8_t * const header = OICCalloc(CA_HEADER_LENGTH, 1); VERIFY_NON_NULL_VOID(header, CALEADAPTER_TAG, "Malloc failed"); - int32_t totalLength = bleData->dataLen + CA_HEADER_LENGTH; + const uint32_t totalLength = bleData->dataLen + CA_HEADER_LENGTH; + + OIC_LOG_V(DEBUG, + CALEADAPTER_TAG, + "Server total Data length with header is [%u]", + totalLength); + + uint8_t * const dataSegment = OICCalloc(totalLength, 1); - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server total Data length with header is [%d]", totalLength); - char *dataSegment = (char *) OICCalloc(totalLength + 1, sizeof(char)); if (NULL == dataSegment) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Malloc failed"); @@ -768,19 +1075,21 @@ void CALEServerSendDataThread(void *threadData) return; } - CAResult_t result = CAGenerateHeader(header, bleData->dataLen); + CAResult_t result = CAGenerateHeader(header, + CA_HEADER_LENGTH, + bleData->dataLen); if (CA_STATUS_OK != result ) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Generate header failed"); OICFree(header); OICFree(dataSegment); - return ; + return; } memcpy(dataSegment, header, CA_HEADER_LENGTH); OICFree(header); - int32_t length = 0; + uint32_t length = 0; if (CA_SUPPORTED_BLE_MTU_SIZE > totalLength) { length = totalLength; @@ -793,31 +1102,49 @@ void CALEServerSendDataThread(void *threadData) CA_SUPPORTED_BLE_MTU_SIZE - CA_HEADER_LENGTH); } - int32_t iter = totalLength / CA_SUPPORTED_BLE_MTU_SIZE; - int32_t index = 0; + uint32_t iter = totalLength / CA_SUPPORTED_BLE_MTU_SIZE; + uint32_t index = 0; + // Send the first segment with the header. - if (NULL != bleData->remoteEndpoint) //Sending Unicast Data + if (NULL != bleData->remoteEndpoint) // Sending Unicast Data { OIC_LOG(DEBUG, CALEADAPTER_TAG, "Server Sending Unicast Data"); + result = CAUpdateCharacteristicsToGattClient( bleData->remoteEndpoint->addr, dataSegment, length); + if (CA_STATUS_OK != result) { - OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]", result); - g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result); + OIC_LOG_V(ERROR, + CALEADAPTER_TAG, + "Update characteristics failed, result [%d]", + result); + + g_errorHandler(bleData->remoteEndpoint, + bleData->data, + bleData->dataLen, + result); OICFree(dataSegment); return; } - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]", length); + OIC_LOG_V(DEBUG, + CALEADAPTER_TAG, + "Server Sent data length [%u]", + length); for (index = 1; index < iter; index++) { // Send the remaining header. - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Sending the chunk number [%d]", index); - result = CAUpdateCharacteristicsToGattClient( - bleData->remoteEndpoint->addr, - bleData->data + ((index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH), - CA_SUPPORTED_BLE_MTU_SIZE); + OIC_LOG_V(DEBUG, + CALEADAPTER_TAG, + "Sending the chunk number [%u]", + index); + + result = + CAUpdateCharacteristicsToGattClient( + bleData->remoteEndpoint->addr, + bleData->data + ((index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH), + CA_SUPPORTED_BLE_MTU_SIZE); if (CA_STATUS_OK != result) { OIC_LOG_V(ERROR, CALEADAPTER_TAG, @@ -830,10 +1157,13 @@ void CALEServerSendDataThread(void *threadData) CA_SUPPORTED_BLE_MTU_SIZE); } - int32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; + const uint32_t remainingLen = + totalLength % CA_SUPPORTED_BLE_MTU_SIZE; + if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE)) { - // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200) + // send the last segment of the data (Ex: 22 bytes of 622 + // bytes of data when MTU is 200) OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk"); result = CAUpdateCharacteristicsToGattClient( bleData->remoteEndpoint->addr, @@ -841,9 +1171,14 @@ void CALEServerSendDataThread(void *threadData) remainingLen); if (CA_STATUS_OK != result) { - OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]", - result); - g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result); + OIC_LOG_V(ERROR, + CALEADAPTER_TAG, + "Update characteristics failed, result [%d]", + result); + g_errorHandler(bleData->remoteEndpoint, + bleData->data, + bleData->dataLen, + result); OICFree(dataSegment); return; } @@ -878,10 +1213,10 @@ void CALEServerSendDataThread(void *threadData) OICFree(dataSegment); return; } - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%d]", CA_SUPPORTED_BLE_MTU_SIZE); + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Server Sent data length [%u]", CA_SUPPORTED_BLE_MTU_SIZE); } - int32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; + const uint32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE)) { // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200) @@ -905,7 +1240,7 @@ void CALEServerSendDataThread(void *threadData) OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CALEClientSendDataThread(void *threadData) +static void CALEClientSendDataThread(void *threadData) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -916,11 +1251,11 @@ void CALEClientSendDataThread(void *threadData) return; } - char *header = (char *) OICCalloc(CA_HEADER_LENGTH, sizeof(char)); + uint8_t * const header = OICCalloc(CA_HEADER_LENGTH, 1); VERIFY_NON_NULL_VOID(header, CALEADAPTER_TAG, "Malloc failed"); - uint32_t totalLength = bleData->dataLen + CA_HEADER_LENGTH; - char *dataSegment = (char *) OICCalloc(totalLength + 1, sizeof(char)); + const uint32_t totalLength = bleData->dataLen + CA_HEADER_LENGTH; + uint8_t *dataSegment = OICCalloc(totalLength, 1); if (NULL == dataSegment) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Malloc failed"); @@ -928,7 +1263,9 @@ void CALEClientSendDataThread(void *threadData) return; } - CAResult_t result = CAGenerateHeader(header, bleData->dataLen); + CAResult_t result = CAGenerateHeader(header, + CA_HEADER_LENGTH, + bleData->dataLen); if (CA_STATUS_OK != result ) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Generate header failed"); @@ -943,37 +1280,51 @@ void CALEClientSendDataThread(void *threadData) if (CA_SUPPORTED_BLE_MTU_SIZE > totalLength) { length = totalLength; - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "length [%d]", length); - memcpy(dataSegment + CA_HEADER_LENGTH, bleData->data, bleData->dataLen); + memcpy(dataSegment + CA_HEADER_LENGTH, + bleData->data, + bleData->dataLen); } else { length = CA_SUPPORTED_BLE_MTU_SIZE; - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "length [%d]", length); - memcpy(dataSegment + CA_HEADER_LENGTH, bleData->data, + memcpy(dataSegment + CA_HEADER_LENGTH, + bleData->data, CA_SUPPORTED_BLE_MTU_SIZE - CA_HEADER_LENGTH); } - uint32_t iter = totalLength / CA_SUPPORTED_BLE_MTU_SIZE; + const uint32_t iter = totalLength / CA_SUPPORTED_BLE_MTU_SIZE; uint32_t index = 0; if (NULL != bleData->remoteEndpoint) //Sending Unicast Data { OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending Unicast Data"); // Send the first segment with the header. - result = CAUpdateCharacteristicsToGattServer(bleData->remoteEndpoint->addr, - dataSegment, - length, - LE_UNICAST, 0); + result = + CAUpdateCharacteristicsToGattServer( + bleData->remoteEndpoint->addr, + dataSegment, + length, + LE_UNICAST, + 0); if (CA_STATUS_OK != result) { - OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]", result); - g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result); + OIC_LOG_V(ERROR, + CALEADAPTER_TAG, + "Update characteristics failed, result [%d]", + result); + g_errorHandler(bleData->remoteEndpoint, + bleData->data, + bleData->dataLen, + result); OICFree(dataSegment); - return ; + return; } - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Client Sent Data length is [%d]", length); + OIC_LOG_V(DEBUG, + CALEADAPTER_TAG, + "Client Sent Data length is [%u]", + length); + for (index = 1; index < iter; index++) { // Send the remaining header. @@ -984,8 +1335,10 @@ void CALEClientSendDataThread(void *threadData) LE_UNICAST, 0); if (CA_STATUS_OK != result) { - OIC_LOG_V(ERROR, CALEADAPTER_TAG, "Update characteristics failed, result [%d]", - result); + OIC_LOG_V(ERROR, + CALEADAPTER_TAG, + "Update characteristics failed, result [%d]", + result); g_errorHandler(bleData->remoteEndpoint, bleData->data, bleData->dataLen, result); OICFree(dataSegment); return; @@ -994,10 +1347,11 @@ void CALEClientSendDataThread(void *threadData) CA_SUPPORTED_BLE_MTU_SIZE); } - uint32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; + const uint32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE)) { - // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200) + // send the last segment of the data (Ex: 22 bytes of 622 + // bytes of data when MTU is 200) OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk"); result = CAUpdateCharacteristicsToGattServer( bleData->remoteEndpoint->addr, @@ -1050,13 +1404,15 @@ void CALEClientSendDataThread(void *threadData) } uint32_t remainingLen = totalLength % CA_SUPPORTED_BLE_MTU_SIZE; - if ( remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE)) + if (remainingLen && (totalLength > CA_SUPPORTED_BLE_MTU_SIZE)) { - // send the last segment of the data (Ex: 22 bytes of 622 bytes of data when MTU is 200) + // send the last segment of the data (Ex: 22 bytes of 622 + // bytes of data when MTU is 200) OIC_LOG(DEBUG, CALEADAPTER_TAG, "Sending the last chunk"); - result = CAUpdateCharacteristicsToAllGattServers( - bleData->data + (index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH, - remainingLen); + result = + CAUpdateCharacteristicsToAllGattServers( + bleData->data + (index * CA_SUPPORTED_BLE_MTU_SIZE) - CA_HEADER_LENGTH, + remainingLen); if (CA_STATUS_OK != result) { OIC_LOG_V(ERROR, CALEADAPTER_TAG, @@ -1075,10 +1431,12 @@ void CALEClientSendDataThread(void *threadData) OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT - CABLEClientSendDataThread"); } -CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint, const void *data, - uint32_t dataLength) +static CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLength) { - CALEData_t *bleData = (CALEData_t *) OICMalloc(sizeof(CALEData_t)); + CALEData_t * const bleData = OICMalloc(sizeof(CALEData_t)); + if (!bleData) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); @@ -1086,20 +1444,22 @@ CALEData_t *CACreateLEData(const CAEndpoint_t *remoteEndpoint, const void *data, } bleData->remoteEndpoint = CACloneEndpoint(remoteEndpoint); - bleData->data = (void *)OICCalloc(dataLength + 1, 1); + bleData->data = OICCalloc(dataLength + 1, 1); + if (NULL == bleData->data) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Memory allocation failed!"); CAFreeLEData(bleData); return NULL; } + memcpy(bleData->data, data, dataLength); bleData->dataLen = dataLength; return bleData; } -void CAFreeLEData(CALEData_t *bleData) +static void CAFreeLEData(CALEData_t *bleData) { VERIFY_NON_NULL_VOID(bleData, CALEADAPTER_TAG, "Param bleData is NULL"); @@ -1108,15 +1468,20 @@ void CAFreeLEData(CALEData_t *bleData) OICFree(bleData); } -void CALEDataDestroyer(void *data, uint32_t size) +static void CALEDataDestroyer(void *data, uint32_t size) { + if ((size_t)size < sizeof(CALEData_t *)) + { + OIC_LOG_V(ERROR, CALEADAPTER_TAG, + "Destroy data too small %p %d", data, size); + } CALEData_t *ledata = (CALEData_t *) data; CAFreeLEData(ledata); } #endif -CAResult_t CAInitLEAdapterMutex() +static CAResult_t CAInitLEAdapterMutex() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1174,17 +1539,6 @@ CAResult_t CAInitLEAdapterMutex() } } - if (NULL == g_bleClientReceiveDataMutex) - { - g_bleClientReceiveDataMutex = ca_mutex_new(); - if (NULL == g_bleClientReceiveDataMutex) - { - OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed"); - CATerminateLEAdapterMutex(); - return CA_STATUS_FAILED; - } - } - if (NULL == g_bleServerSendDataMutex) { g_bleServerSendDataMutex = ca_mutex_new(); @@ -1196,10 +1550,10 @@ CAResult_t CAInitLEAdapterMutex() } } - if (NULL == g_bleServerReceiveDataMutex) + if (NULL == g_bleAdapterReqRespCbMutex) { - g_bleServerReceiveDataMutex = ca_mutex_new(); - if (NULL == g_bleServerReceiveDataMutex) + g_bleAdapterReqRespCbMutex = ca_mutex_new(); + if (NULL == g_bleAdapterReqRespCbMutex) { OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed"); CATerminateLEAdapterMutex(); @@ -1207,13 +1561,12 @@ CAResult_t CAInitLEAdapterMutex() } } - if (NULL == g_bleAdapterReqRespCbMutex) + if (NULL == g_bleReceiveDataMutex) { - g_bleAdapterReqRespCbMutex = ca_mutex_new(); - if (NULL == g_bleAdapterReqRespCbMutex) + g_bleReceiveDataMutex = ca_mutex_new(); + if (NULL == g_bleReceiveDataMutex) { OIC_LOG(ERROR, CALEADAPTER_TAG, "ca_mutex_new failed"); - CATerminateLEAdapterMutex(); return CA_STATUS_FAILED; } } @@ -1222,7 +1575,7 @@ CAResult_t CAInitLEAdapterMutex() return CA_STATUS_OK; } -void CATerminateLEAdapterMutex() +static void CATerminateLEAdapterMutex() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1241,25 +1594,23 @@ void CATerminateLEAdapterMutex() ca_mutex_free(g_bleClientSendDataMutex); g_bleClientSendDataMutex = NULL; - ca_mutex_free(g_bleClientReceiveDataMutex); - g_bleClientReceiveDataMutex = NULL; - ca_mutex_free(g_bleServerSendDataMutex); g_bleServerSendDataMutex = NULL; - ca_mutex_free(g_bleServerReceiveDataMutex); - g_bleServerReceiveDataMutex = NULL; - ca_mutex_free(g_bleAdapterReqRespCbMutex); g_bleAdapterReqRespCbMutex = NULL; + ca_mutex_free(g_bleReceiveDataMutex); + g_bleReceiveDataMutex = NULL; + OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } CAResult_t CAInitializeLE(CARegisterConnectivityCallback registerCallback, CANetworkPacketReceivedCallback reqRespCallback, CANetworkChangeCallback netCallback, - CAErrorHandleCallback errorCallback, ca_thread_pool_t handle) + CAErrorHandleCallback errorCallback, + ca_thread_pool_t handle) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1297,16 +1648,19 @@ CAResult_t CAInitializeLE(CARegisterConnectivityCallback registerCallback, g_errorHandler = errorCallback; - CAConnectivityHandler_t connHandler; - connHandler.startAdapter = CAStartLE; - connHandler.stopAdapter = CAStopLE; - connHandler.startListenServer = CAStartLEListeningServer; - connHandler.startDiscoveryServer = CAStartLEDiscoveryServer; - connHandler.sendData = CASendLEUnicastData; - connHandler.sendDataToAll = CASendLEMulticastData; - connHandler.GetnetInfo = CAGetLEInterfaceInformation; - connHandler.readData = CAReadLEData; - connHandler.terminate = CATerminateLE; + static const CAConnectivityHandler_t connHandler = + { + .startAdapter = CAStartLE, + .stopAdapter = CAStopLE, + .startListenServer = CAStartLEListeningServer, + .startDiscoveryServer = CAStartLEDiscoveryServer, + .sendData = CASendLEUnicastData, + .sendDataToAll = CASendLEMulticastData, + .GetnetInfo = CAGetLEInterfaceInformation, + .readData = CAReadLEData, + .terminate = CATerminateLE + }; + registerCallback(connHandler, CA_ADAPTER_GATT_BTLE); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); @@ -1314,15 +1668,14 @@ CAResult_t CAInitializeLE(CARegisterConnectivityCallback registerCallback, return CA_STATUS_OK; } -CAResult_t CAStartLE() +static CAResult_t CAStartLE() { - OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - OIC_LOG(DEBUG, CALEADAPTER_TAG, "CAStartLE, not implemented"); - OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); - return CA_STATUS_OK; + OIC_LOG(DEBUG, CALEADAPTER_TAG, __func__); + + return CAStartLEAdapter(); } -CAResult_t CAStopLE() +static CAResult_t CAStopLE() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); #ifndef SINGLE_THREAD @@ -1345,7 +1698,7 @@ CAResult_t CAStopLE() return CA_STATUS_OK; } -void CATerminateLE() +static void CATerminateLE() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1374,7 +1727,7 @@ void CATerminateLE() OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -CAResult_t CAStartLEListeningServer() +static CAResult_t CAStartLEListeningServer() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); CAResult_t result = CA_STATUS_OK; @@ -1411,7 +1764,7 @@ CAResult_t CAStartLEListeningServer() return CA_STATUS_OK; } -CAResult_t CAStartLEDiscoveryServer() +static CAResult_t CAStartLEDiscoveryServer() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); CAResult_t result = CA_STATUS_OK; @@ -1447,24 +1800,7 @@ CAResult_t CAStartLEDiscoveryServer() return CA_STATUS_OK; } -CAResult_t CAStartLENotifyServer() -{ - OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - - OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); - return CA_STATUS_OK; -} - -uint32_t CASendLENotification(const CAEndpoint_t *endpoint, const void *data, - uint32_t dataLen) -{ - OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - - OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); - return 0; -} - -CAResult_t CAReadLEData() +static CAResult_t CAReadLEData() { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); #ifdef SINGLE_THREAD @@ -1474,7 +1810,9 @@ CAResult_t CAReadLEData() return CA_STATUS_OK; } -int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLen) +static int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint, + const void *data, + uint32_t dataLen) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1493,7 +1831,7 @@ int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint, const void *data, uint OIC_LOG(ERROR, CALEADAPTER_TAG, "Send unicast data failed\n"); if (g_errorHandler) { - g_errorHandler((void *) endpoint, (void *) data, dataLen, result); + g_errorHandler(endpoint, data, dataLen, result); } ca_mutex_unlock(g_bleIsServerMutex); return -1; @@ -1519,7 +1857,9 @@ int32_t CASendLEUnicastData(const CAEndpoint_t *endpoint, const void *data, uint return dataLen; } -int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLen) +static int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint, + const void *data, + uint32_t dataLen) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1570,7 +1910,7 @@ int32_t CASendLEMulticastData(const CAEndpoint_t *endpoint, const void *data, ui return dataLen; } -CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, uint32_t *size) +static CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, uint32_t *size) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1624,7 +1964,7 @@ CAResult_t CAGetLEInterfaceInformation(CAEndpoint_t **info, uint32_t *size) return CA_STATUS_OK; } -CAResult_t CALERegisterNetworkNotifications(CANetworkChangeCallback netCallback) +static CAResult_t CALERegisterNetworkNotifications(CANetworkChangeCallback netCallback) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1653,15 +1993,17 @@ CAResult_t CALERegisterNetworkNotifications(CANetworkChangeCallback netCallback) return res; } -void CALEDeviceStateChangedCb( CAAdapterState_t adapter_state) +static void CALEDeviceStateChangedCb(CAAdapterState_t adapter_state) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); VERIFY_NON_NULL_VOID(g_localBLEAddress, CALEADAPTER_TAG, "g_localBLEAddress is null"); - CAEndpoint_t localEndpoint = {}; + CAEndpoint_t localEndpoint = { .adapter = CA_ADAPTER_GATT_BTLE }; ca_mutex_lock(g_bleLocalAddressMutex); - OICStrcpy(localEndpoint.addr, sizeof(localEndpoint.addr), g_localBLEAddress); + OICStrcpy(localEndpoint.addr, + sizeof(localEndpoint.addr), + g_localBLEAddress); ca_mutex_unlock(g_bleLocalAddressMutex); g_bleAdapterState = adapter_state; @@ -1692,9 +2034,9 @@ void CALEDeviceStateChangedCb( CAAdapterState_t adapter_state) OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint, - const void *data, - uint32_t dataLen) +static CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLen) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1710,7 +2052,7 @@ CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint, VERIFY_NON_NULL_RET(g_bleClientSendQueueHandle, CALEADAPTER_TAG, "g_bleClientSendQueueHandle", CA_STATUS_FAILED); - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%d]", dataLen); + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%u]", dataLen); CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLen); if (!bleData) @@ -1727,63 +2069,67 @@ CAResult_t CALEAdapterClientSendData(const CAEndpoint_t *remoteEndpoint, return CA_STATUS_OK; } - -CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint, - const void *data, - uint32_t dataLen) +static CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint, + const uint8_t *data, + uint32_t dataLen) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL"); #ifdef SINGLE_THREAD - char header[CA_HEADER_LENGTH] = {0}; + uint8_t header[CA_HEADER_LENGTH] = { 0 }; - CAResult_t result = CAGenerateHeader(header, dataLen); + CAResult_t result = + CAGenerateHeader(header, CA_HEADER_LENGTH, dataLen); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Generate header failed"); - return -1; + return CA_STATUS_FAILED; } if (!CAIsLEConnected()) { OIC_LOG(ERROR, CALEADAPTER_TAG, "le not conn"); - return -1; + return CA_STATUS_FAILED; } result = CAUpdateCharacteristicsToAllGattClients(header, CA_HEADER_LENGTH); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Update characteristics failed"); - return -1; + return CA_STATUS_FAILED; } - int32_t dataLimit = dataLen / CA_SUPPORTED_BLE_MTU_SIZE; - for (int32_t iter = 0; iter < dataLimit; iter++) + const uint32_t dataLimit = dataLen / CA_SUPPORTED_BLE_MTU_SIZE; + for (uint32_t iter = 0; iter < dataLimit; iter++) { - result = CAUpdateCharacteristicsToAllGattClients((data + - (iter * CA_SUPPORTED_BLE_MTU_SIZE)), - CA_SUPPORTED_BLE_MTU_SIZE); + result = + CAUpdateCharacteristicsToAllGattClients( + data + (iter * CA_SUPPORTED_BLE_MTU_SIZE), + CA_SUPPORTED_BLE_MTU_SIZE); + if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Update characteristics failed"); - return -1; + return CA_STATUS_FAILED; } + CALEDoEvents(); } - uint8_t remainingLen = dataLen % CA_SUPPORTED_BLE_MTU_SIZE; - if(remainingLen) + const uint32_t remainingLen = dataLen % CA_SUPPORTED_BLE_MTU_SIZE; + if (remainingLen) { - result = CAUpdateCharacteristicsToAllGattClients((data + - (dataLimit * CA_SUPPORTED_BLE_MTU_SIZE)), - remainingLen); + result = + CAUpdateCharacteristicsToAllGattClients( + data + (dataLimit * CA_SUPPORTED_BLE_MTU_SIZE), + remainingLen); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Update characteristics failed"); - return -1; + return CA_STATUS_FAILED; } CALEDoEvents(); } @@ -1800,47 +2146,59 @@ CAResult_t CALEAdapterServerSendData(const CAEndpoint_t *remoteEndpoint, OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data Sending to LE layer [%d]", dataLen); - CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLen); + CALEData_t * const bleData = + CACreateLEData(remoteEndpoint, data, dataLen); + if (!bleData) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!"); return CA_MEMORY_ALLOC_FAILED; } + // Add message to send queue ca_mutex_lock(g_bleServerSendDataMutex); - CAQueueingThreadAddData(g_bleServerSendQueueHandle, bleData, sizeof(CALEData_t)); + CAQueueingThreadAddData(g_bleServerSendQueueHandle, + bleData, + sizeof(CALEData_t)); ca_mutex_unlock(g_bleServerSendDataMutex); #endif OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); return CA_STATUS_OK; } -CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, const char *serviceUUID, - const void *data, uint32_t dataLength, - uint32_t *sentLength) +static CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLength, + uint32_t *sentLength) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); //Input validation - VERIFY_NON_NULL(serviceUUID, CALEADAPTER_TAG, "service UUID is null"); VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null"); VERIFY_NON_NULL(sentLength, CALEADAPTER_TAG, "Sent data length holder is null"); #ifdef SINGLE_THREAD if(g_networkPacketReceivedCallback) { - CAEndpoint_t endPoint = { 0 }; // will be filled by upper layer - endPoint.adapter = CA_ADAPTER_GATT_BTLE; + CAEndpoint_t endPoint = + { .adapter = CA_ADAPTER_GATT_BTLE }; // will be filled by + // upper layer + g_networkPacketReceivedCallback(&endPoint, data, dataLength); } #else - VERIFY_NON_NULL_RET(g_bleServerReceiverQueue, CALEADAPTER_TAG, "g_bleServerReceiverQueue", + VERIFY_NON_NULL_RET(g_bleReceiverQueue, + CALEADAPTER_TAG, + "g_bleReceiverQueue", CA_STATUS_FAILED); //Add message to data queue - CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, - CA_ADAPTER_GATT_BTLE, - remoteAddress, 0); + CAEndpoint_t * const remoteEndpoint = + CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_GATT_BTLE, + remoteAddress, + 0); + if (NULL == remoteEndpoint) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create remote endpoint !"); @@ -1848,9 +2206,14 @@ CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, const char * } // Create bleData to add to queue - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data received from LE layer [%d]", dataLength); + OIC_LOG_V(DEBUG, + CALEADAPTER_TAG, + "Data received from LE layer [%d]", + dataLength); + + CALEData_t * const bleData = + CACreateLEData(remoteEndpoint, data, dataLength); - CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLength); if (!bleData) { OIC_LOG(ERROR, CALEADAPTER_TAG, "Failed to create bledata!"); @@ -1859,8 +2222,8 @@ CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, const char * } CAFreeEndpoint(remoteEndpoint); - // Add message to send queue - CAQueueingThreadAddData(g_bleServerReceiverQueue, bleData, sizeof(CALEData_t)); + // Add message to receiver queue + CAQueueingThreadAddData(g_bleReceiverQueue, bleData, sizeof(CALEData_t)); *sentLength = dataLength; #endif @@ -1868,18 +2231,18 @@ CAResult_t CALEAdapterServerReceivedData(const char *remoteAddress, const char * return CA_STATUS_OK; } -CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, const char *serviceUUID, - const void *data, uint32_t dataLength, - uint32_t *sentLength) +static CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLength, + uint32_t *sentLength) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); //Input validation - VERIFY_NON_NULL(serviceUUID, CALEADAPTER_TAG, "service UUID is null"); VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Data is null"); VERIFY_NON_NULL(sentLength, CALEADAPTER_TAG, "Sent data length holder is null"); #ifndef SINGLE_THREAD - VERIFY_NON_NULL_RET(g_bleClientReceiverQueue, CALEADAPTER_TAG, "g_bleClientReceiverQueue", + VERIFY_NON_NULL_RET(g_bleReceiverQueue, CALEADAPTER_TAG, "g_bleReceiverQueue", CA_STATUS_FAILED); //Add message to data queue @@ -1892,7 +2255,7 @@ CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, const char * return CA_STATUS_FAILED; } - OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data received from LE layer [%d]", dataLength); + OIC_LOG_V(DEBUG, CALEADAPTER_TAG, "Data received from LE layer [%u]", dataLength); // Create bleData to add to queue CALEData_t *bleData = CACreateLEData(remoteEndpoint, data, dataLength); @@ -1904,8 +2267,8 @@ CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, const char * } CAFreeEndpoint(remoteEndpoint); - // Add message to send queue - CAQueueingThreadAddData(g_bleClientReceiverQueue, bleData, sizeof(CALEData_t)); + // Add message to receiver queue + CAQueueingThreadAddData(g_bleReceiverQueue, bleData, sizeof(CALEData_t)); *sentLength = dataLength; #endif @@ -1913,18 +2276,18 @@ CAResult_t CALEAdapterClientReceivedData(const char *remoteAddress, const char * return CA_STATUS_OK; } -void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle) +static void CASetLEAdapterThreadPoolHandle(ca_thread_pool_t handle) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); - ca_mutex_unlock(g_bleAdapterThreadPoolMutex); + ca_mutex_lock(g_bleAdapterThreadPoolMutex); g_bleAdapterThreadPool = handle; ca_mutex_unlock(g_bleAdapterThreadPoolMutex); OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback) +static void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN"); @@ -1937,17 +2300,24 @@ void CASetLEReqRespAdapterCallback(CANetworkPacketReceivedCallback callback) OIC_LOG(DEBUG, CALEADAPTER_TAG, "OUT"); } -void CALEErrorHandler(const char *remoteAddress, const void *data, uint32_t dataLen, - CAResult_t result) +static void CALEErrorHandler(const char *remoteAddress, + const uint8_t *data, + uint32_t dataLen, + CAResult_t result) { OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEErrorHandler IN"); VERIFY_NON_NULL_VOID(data, CALEADAPTER_TAG, "Data is null"); - CAEndpoint_t *rep = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_GATT_BTLE, - remoteAddress, 0); - //if required, will be used to build remote end point + + CAEndpoint_t *rep = CACreateEndpointObject(CA_DEFAULT_FLAGS, + CA_ADAPTER_GATT_BTLE, + remoteAddress, + 0); + + // if required, will be used to build remote endpoint g_errorHandler(rep, data, dataLen, result); CAFreeEndpoint(rep); + OIC_LOG(DEBUG, CALEADAPTER_TAG, "CALEErrorHandler OUT"); }