#include <string.h>
#include <stdint.h>
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
+#endif
+#include <inttypes.h>
+
+#include "cainterface.h"
#include "catcpadapter.h"
#include "catcpinterface.h"
#include "caqueueingthread.h"
/**
* Logging tag for module name.
*/
-#define TAG "TCP_ADAP"
+#define TAG "OIC_CA_TCP_ADAP"
/**
* Holds internal thread TCP data information.
bool isMulticast;
} CATCPData;
-#define CA_TCP_TIMEOUT 1000
-
#define CA_TCP_LISTEN_BACKLOG 3
+#define CA_TCP_SELECT_TIMEOUT 10
+
/**
* Queue handle for Send Data.
*/
*/
static CAErrorHandleCallback g_errorCallback = NULL;
-static void CATCPPacketReceivedCB(const CAEndpoint_t *endpoint,
- const void *data, size_t dataLength);
+static void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep,
+ const void *data, uint32_t dataLength);
+
+/**
+ * KeepAlive Connected Callback to CA adapter.
+ */
+static CAKeepAliveConnectedCallback g_connCallback = NULL;
+
+/**
+ * KeepAlive Disconnected Callback to CA adapter.
+ */
+static CAKeepAliveDisconnectedCallback g_disconnCallback = NULL;
static CAResult_t CATCPInitializeQueueHandles();
bool isMulticast);
void CAFreeTCPData(CATCPData *ipData);
-static void CADataDestroyer(void *data, size_t size);
+static void CADataDestroyer(void *data, uint32_t size);
CAResult_t CATCPInitializeQueueHandles()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
// Check if the message queue is already initialized
if (g_sendQueueHandle)
{
return CA_STATUS_FAILED;
}
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
void CATCPDeinitializeQueueHandles()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
CAQueueingThreadDestroy(g_sendQueueHandle);
OICFree(g_sendQueueHandle);
g_sendQueueHandle = NULL;
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
void CATCPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status)
{
(void)ipAddress;
(void)status;
- OIC_LOG(DEBUG, TAG, "IN");
}
-void CATCPPacketReceivedCB(const CAEndpoint_t *endpoint, const void *data,
- size_t dataLength)
+void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep, const void *data,
+ uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- VERIFY_NON_NULL_VOID(endpoint, TAG, "ipAddress is NULL");
+ VERIFY_NON_NULL_VOID(sep, TAG, "sep is NULL");
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
- OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", endpoint->addr, endpoint->port);
+ OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", sep->endpoint.addr, sep->endpoint.port);
if (g_networkPacketCallback)
{
- g_networkPacketCallback(endpoint, data, dataLength);
+ g_networkPacketCallback(sep, data, dataLength);
}
- OIC_LOG(DEBUG, TAG, "OUT");
}
void CATCPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
- size_t dataLength, CAResult_t result)
+ uint32_t dataLength, CAResult_t result)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
-
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
if (g_errorCallback)
{
g_errorCallback(endpoint, data, dataLength, result);
}
+}
+
+static void CATCPKeepAliveHandler(const char *addr, uint16_t port, bool isConnected)
+{
+ CAEndpoint_t endpoint = { .adapter = CA_ADAPTER_TCP,
+ .port = port };
+ OICStrcpy(endpoint.addr, sizeof(endpoint.addr), addr);
+
+ if (isConnected)
+ {
+ g_connCallback(&endpoint);
+ }
+ else
+ {
+ g_disconnCallback(&endpoint);
+ }
+}
+
+void CATCPSetKeepAliveCallbacks(CAKeepAliveConnectedCallback ConnHandler,
+ CAKeepAliveDisconnectedCallback DisconnHandler)
+{
+ g_connCallback = ConnHandler;
+ g_disconnCallback = DisconnHandler;
- OIC_LOG(DEBUG, TAG, "OUT");
+ CATCPSetKeepAliveCallback(CATCPKeepAliveHandler);
}
static void CAInitializeTCPGlobals()
{
- caglobals.tcp.selectTimeout = CA_TCP_TIMEOUT;
+ caglobals.tcp.selectTimeout = CA_TCP_SELECT_TIMEOUT;
caglobals.tcp.listenBacklog = CA_TCP_LISTEN_BACKLOG;
caglobals.tcp.svrlist = NULL;
CAConnectivityHandler_t TCPHandler = {
.startAdapter = CAStartTCP,
.startListenServer = CAStartTCPListeningServer,
+ .stopListenServer = CAStopTCPListeningServer,
.startDiscoveryServer = CAStartTCPDiscoveryServer,
.sendData = CASendTCPUnicastData,
.sendDataToAll = CASendTCPMulticastData,
.GetnetInfo = CAGetTCPInterfaceInformation,
.readData = CAReadTCPData,
.stopAdapter = CAStopTCP,
- .terminate = CATerminateTCP };
- registerCallback(TCPHandler, CA_ADAPTER_TCP);
+ .terminate = CATerminateTCP,
+ .cType = CA_ADAPTER_TCP};
+
+ registerCallback(TCPHandler);
OIC_LOG(INFO, TAG, "OUT IntializeTCP is Success");
return CA_STATUS_OK;
CAResult_t CAStartTCP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
if (CA_STATUS_OK != CATCPInitializeQueueHandles())
{
OIC_LOG(ERROR, TAG, "Failed to Initialize Queue Handle");
return ret;
}
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
CAResult_t CAStartTCPListeningServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
+ return CA_STATUS_OK;
+}
- OIC_LOG(DEBUG, TAG, "OUT");
+CAResult_t CAStopTCPListeningServer()
+{
return CA_STATUS_OK;
}
CAResult_t CAStartTCPDiscoveryServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
static size_t CAQueueTCPData(bool isMulticast, const CAEndpoint_t *endpoint,
const void *data, size_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- VERIFY_NON_NULL_RET(endpoint, TAG, "remoteEndpoint", -1);
+ VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", -1);
VERIFY_NON_NULL_RET(data, TAG, "data", -1);
if (0 == dataLength)
VERIFY_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
// Create TCPData to add to queue
- CATCPData *TCPData = CACreateTCPData(endpoint, data, dataLength, isMulticast);
- if (!TCPData)
+ CATCPData *tcpData = CACreateTCPData(endpoint, data, dataLength, isMulticast);
+ if (!tcpData)
{
OIC_LOG(ERROR, TAG, "Failed to create ipData!");
return -1;
}
// Add message to send queue
- CAQueueingThreadAddData(g_sendQueueHandle, TCPData, sizeof(CATCPData));
+ CAQueueingThreadAddData(g_sendQueueHandle, tcpData, sizeof(CATCPData));
- OIC_LOG(DEBUG, TAG, "OUT");
return dataLength;
}
int32_t CASendTCPUnicastData(const CAEndpoint_t *endpoint,
const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
return CAQueueTCPData(false, endpoint, data, dataLength);
}
int32_t CASendTCPMulticastData(const CAEndpoint_t *endpoint,
const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
return CAQueueTCPData(true, endpoint, data, dataLength);
}
CAResult_t CAReadTCPData()
{
- OIC_LOG(DEBUG, TAG, "IN");
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
CAResult_t CAStopTCP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
if (g_sendQueueHandle && g_sendQueueHandle->threadMutex)
{
CAQueueingThreadStop(g_sendQueueHandle);
}
- CATCPDeinitializeQueueHandles();
-
CATCPStopServer();
- OIC_LOG(DEBUG, TAG, "OUT");
+ //Re-initializing the Globals to start them again
+ CAInitializeTCPGlobals();
+
return CA_STATUS_OK;
}
void CATerminateTCP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
CATCPSetPacketReceiveCallback(NULL);
CATCPDeinitializeQueueHandles();
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
void CATCPSendDataThread(void *threadData)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- CATCPData *TCPData = (CATCPData *) threadData;
- if (!TCPData)
+ CATCPData *tcpData = (CATCPData *) threadData;
+ if (!tcpData)
{
OIC_LOG(DEBUG, TAG, "Invalid TCP data!");
return;
}
- if (TCPData->isMulticast)
+ if (tcpData->isMulticast)
{
//Processing for sending multicast
OIC_LOG(DEBUG, TAG, "Send Multicast Data is called, not supported");
else
{
//Processing for sending unicast
- CATCPSendData(TCPData->remoteEndpoint, TCPData->data, TCPData->dataLen, false);
+ CATCPSendData(tcpData->remoteEndpoint, tcpData->data, tcpData->dataLen, false);
}
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
CATCPData *CACreateTCPData(const CAEndpoint_t *remoteEndpoint, const void *data,
size_t dataLength, bool isMulticast)
{
- VERIFY_NON_NULL_RET(data, TAG, "TCPData is NULL", NULL);
+ VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
+ VERIFY_NON_NULL_RET(data, TAG, "data is NULL", NULL);
- CATCPData *TCPData = (CATCPData *) OICMalloc(sizeof(CATCPData));
- if (!TCPData)
+ CATCPData *tcpData = (CATCPData *) OICCalloc(1, sizeof(*tcpData));
+ if (!tcpData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return NULL;
}
- TCPData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
- TCPData->data = (void *) OICMalloc(dataLength);
- if (!TCPData->data)
+ tcpData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
+ tcpData->data = (void *) OICMalloc(dataLength);
+ if (!tcpData->data)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
- CAFreeTCPData(TCPData);
+ CAFreeTCPData(tcpData);
return NULL;
}
- memcpy(TCPData->data, data, dataLength);
- TCPData->dataLen = dataLength;
+ memcpy(tcpData->data, data, dataLength);
+ tcpData->dataLen = dataLength;
- TCPData->isMulticast = isMulticast;
+ tcpData->isMulticast = isMulticast;
- return TCPData;
+ return tcpData;
}
-void CAFreeTCPData(CATCPData *TCPData)
+void CAFreeTCPData(CATCPData *tcpData)
{
- VERIFY_NON_NULL_VOID(TCPData, TAG, "TCPData is NULL");
+ VERIFY_NON_NULL_VOID(tcpData, TAG, "tcpData is NULL");
- CAFreeEndpoint(TCPData->remoteEndpoint);
- OICFree(TCPData->data);
- OICFree(TCPData);
+ CAFreeEndpoint(tcpData->remoteEndpoint);
+ OICFree(tcpData->data);
+ OICFree(tcpData);
}
-void CADataDestroyer(void *data, size_t size)
+void CADataDestroyer(void *data, uint32_t size)
{
if (size < sizeof(CATCPData))
{
- OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size);
+ OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %" PRIu32, data, size);
}
CATCPData *TCPData = (CATCPData *) data;
projects / platform / upstream / iotivity.git / blobdiff