#include <string.h>
#include <stdint.h>
+#include "caipnwmonitor.h"
#include "caipinterface.h"
#include "caqueueingthread.h"
#include "caadapterutils.h"
#ifdef __WITH_DTLS__
-#include "caadapternetdtls.h"
+#include "ca_adapter_net_ssl.h"
+#ifdef WITH_TCP
+#include "catcpinterface.h"
#endif
-#include "camutex.h"
+#endif
+
+#include "octhread.h"
#include "uarraylist.h"
#include "caremotehandler.h"
#include "logger.h"
/**
* Network Changed Callback to CA.
*/
-static CANetworkChangeCallback g_networkChangeCallback = NULL;
+static CAAdapterChangeCallback g_networkChangeCallback = NULL;
/**
* error Callback to CA adapter.
*/
static CAErrorHandleCallback g_errorCallback = NULL;
-static void CAIPPacketReceivedCB(const CASecureEndpoint_t *endpoint,
- const void *data, uint32_t dataLength);
+static CAResult_t CAIPPacketReceivedCB(const CASecureEndpoint_t *endpoint,
+ const void *data, size_t dataLength);
#ifdef __WITH_DTLS__
-static void CAIPPacketSendCB(CAEndpoint_t *endpoint,
- const void *data, uint32_t dataLength);
+static ssize_t CAIPPacketSendCB(CAEndpoint_t *endpoint,
+ const void *data, size_t dataLength);
#endif
#ifndef SINGLE_THREAD
#endif // SINGLE_THREAD
-void CAIPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status)
+void CAIPAdapterHandler(CATransportAdapter_t adapter, CANetworkStatus_t status)
{
- (void)ipAddress;
- (void)status;
+ if (g_networkChangeCallback)
+ {
+ g_networkChangeCallback(adapter, status);
+ }
+ else
+ {
+ OIC_LOG(ERROR, TAG, "g_networkChangeCallback is NULL");
+ }
+
+ if (CA_INTERFACE_DOWN == status)
+ {
+ OIC_LOG(DEBUG, TAG, "Network status for IP is down");
+
+ CAResult_t res = CAQueueingThreadClearData(g_sendQueueHandle);
+ if (res != CA_STATUS_OK)
+ {
+ OIC_LOG_V(ERROR, TAG, "CAQueueingThreadClearData failed[%d]", res);
+ }
+
+#ifdef __WITH_DTLS__
+#ifdef WITH_TCP
+ CATCPCloseInProgressConnections();
+#endif
+ OIC_LOG(DEBUG, TAG, "close all ssl session");
+ CAcloseSslConnectionAll(CA_ADAPTER_IP);
+#endif
+ }
}
#ifdef __WITH_DTLS__
-static void CAIPPacketSendCB(CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
+static ssize_t CAIPPacketSendCB(CAEndpoint_t *endpoint, const void *data, size_t dataLength)
{
- VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
- VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
+ VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint is NULL", -1);
+ VERIFY_NON_NULL_RET(data, TAG, "data is NULL", -1);
CAIPSendData(endpoint, data, dataLength, false);
+ return dataLength;
}
#endif
-void CAIPPacketReceivedCB(const CASecureEndpoint_t *sep, const void *data,
- uint32_t dataLength)
+CAResult_t CAIPPacketReceivedCB(const CASecureEndpoint_t *sep, const void *data,
+ size_t dataLength)
{
- VERIFY_NON_NULL_VOID(sep, TAG, "sep is NULL");
- VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
+ VERIFY_NON_NULL(sep, TAG, "sep is NULL");
+ VERIFY_NON_NULL(data, TAG, "data is NULL");
OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", sep->endpoint.addr, sep->endpoint.port);
+ CAResult_t res = CA_STATUS_OK;
if (g_networkPacketCallback)
{
- g_networkPacketCallback(sep, data, dataLength);
+ res = g_networkPacketCallback(sep, data, dataLength);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "Error parsing CoAP data");
+ }
}
+ return res;
}
-void CAIPErrorHandler (const CAEndpoint_t *endpoint, const void *data,
- uint32_t dataLength, CAResult_t result)
+void CAIPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
+ uint32_t dataLength, CAResult_t result)
{
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
- void *buf = (void*)OICMalloc(sizeof(char) * dataLength);
- if (!buf)
- {
- OIC_LOG(ERROR, TAG, "Memory Allocation failed!");
- return;
- }
- memcpy(buf, data, dataLength);
if (g_errorCallback)
{
- g_errorCallback(endpoint, buf, dataLength, result);
- }
- else
- {
- OICFree(buf);
+ g_errorCallback(endpoint, data, dataLength, result);
}
}
{
flags |= caglobals.serverFlags;
}
+//TODO Enable once TizenRT supports IPv6
+#ifndef __TIZENRT__
caglobals.ip.ipv6enabled = flags & CA_IPV6;
+#endif
caglobals.ip.ipv4enabled = flags & CA_IPV4;
caglobals.ip.dualstack = caglobals.ip.ipv6enabled && caglobals.ip.ipv4enabled;
}
CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
CANetworkPacketReceivedCallback networkPacketCallback,
- CANetworkChangeCallback netCallback,
+ CAAdapterChangeCallback netCallback,
CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
{
OIC_LOG(DEBUG, TAG, "IN");
CAInitializeIPGlobals();
caglobals.ip.threadpool = handle;
+ CAIPSetErrorHandler(CAIPErrorHandler);
CAIPSetPacketReceiveCallback(CAIPPacketReceivedCB);
-#ifdef __WITH_DTLS__
- CAAdapterNetDtlsInit();
- CADTLSSetAdapterCallbacks(CAIPPacketReceivedCB, CAIPPacketSendCB, 0);
+#ifdef __WITH_DTLS__
+ CAsetSslAdapterCallbacks(CAIPPacketReceivedCB, CAIPPacketSendCB, CA_ADAPTER_IP);
#endif
static const CAConnectivityHandler_t ipHandler =
CAResult_t CAStartIP()
{
- CAIPStartNetworkMonitor();
+ // Specific the port number received from application.
+ caglobals.ip.u6.port = caglobals.ports.udp.u6;
+ caglobals.ip.u6s.port = caglobals.ports.udp.u6s;
+ caglobals.ip.u4.port = caglobals.ports.udp.u4;
+ caglobals.ip.u4s.port = caglobals.ports.udp.u4s;
+
+ CAIPStartNetworkMonitor(CAIPAdapterHandler, CA_ADAPTER_IP);
#ifdef SINGLE_THREAD
uint16_t unicastPort = 55555;
// Address is hardcoded as we are using Single Interface
}
// Start send queue thread
+#ifndef __TIZENRT__
if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
+#else
+ if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle, "IoT_IPSendQueue"))
+#endif
{
OIC_LOG(ERROR, TAG, "Failed to Start Send Data Thread");
return CA_STATUS_FAILED;
}
int32_t CASendIPUnicastData(const CAEndpoint_t *endpoint,
- const void *data, uint32_t dataLength)
+ const void *data, uint32_t dataLength,
+ CADataType_t dataType)
{
+ (void)dataType;
return CAQueueIPData(false, endpoint, data, dataLength);
}
-int32_t CASendIPMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
+int32_t CASendIPMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength,
+ CADataType_t dataType)
{
+ (void)dataType;
return CAQueueIPData(true, endpoint, data, dataLength);
}
CAResult_t CAStopIP()
{
-#ifdef __WITH_DTLS__
- CAAdapterNetDtlsDeInit();
-#endif
-
#ifndef SINGLE_THREAD
if (g_sendQueueHandle && g_sendQueueHandle->threadMutex)
{
}
#endif
- CAIPStopNetworkMonitor();
+ CAIPStopNetworkMonitor(CA_ADAPTER_IP);
CAIPStopServer();
//Re-initializing the Globals to start them again
CAInitializeIPGlobals();
void CATerminateIP()
{
#ifdef __WITH_DTLS__
- CADTLSSetAdapterCallbacks(NULL, NULL, 0);
+ CAsetSslAdapterCallbacks(NULL, NULL, CA_ADAPTER_IP);
#endif
CAIPSetPacketReceiveCallback(NULL);
#ifdef __WITH_DTLS__
if (ipData->remoteEndpoint && ipData->remoteEndpoint->flags & CA_SECURE)
{
- OIC_LOG(DEBUG, TAG, "CAAdapterNetDtlsEncrypt called!");
- CAResult_t result = CAAdapterNetDtlsEncrypt(ipData->remoteEndpoint,
- ipData->data, ipData->dataLen);
+ OIC_LOG(INFO, TAG, "DTLS encrypt called");
+ CAResult_t result = CAencryptSsl(ipData->remoteEndpoint, ipData->data, ipData->dataLen);
if (CA_STATUS_OK != result)
{
- OIC_LOG(ERROR, TAG, "CAAdapterNetDtlsEncrypt failed!");
+ OIC_LOG(ERROR, TAG, "CAencryptSsl failed!");
}
- OIC_LOG_V(DEBUG, TAG,
- "CAAdapterNetDtlsEncrypt returned with result[%d]", result);
+ OIC_LOG_V(INFO, TAG, "CAencryptSsl returned with result[%d]", result);
}
else
{
projects / platform / upstream / iotivity.git / blobdiff