-/******************************************************************
+/* ****************************************************************
*
* Copyright 2014 Samsung Electronics All Rights Reserved.
*
#include "oic_string.h"
/**
- * @def TAG
- * @brief Logging tag for module name
+ * Logging tag for module name.
*/
-#define TAG "IP_ADAP"
+#define TAG "OIC_CA_IP_ADAP"
#ifndef SINGLE_THREAD
/**
- * @var CAIPData
- * @brief Holds inter thread ip data information.
+ * Holds inter thread ip data information.
*/
typedef struct
{
void *data;
uint32_t dataLen;
bool isMulticast;
-} CAIPData;
+} CAIPData_t;
/**
- * @var g_sendQueueHandle
- * @brief Queue handle for Send Data
+ * Queue handle for Send Data.
*/
static CAQueueingThread_t *g_sendQueueHandle = NULL;
#endif
/**
- * @var g_networkPacketCallback
- * @brief Network Packet Received Callback to CA
+ * Network Packet Received Callback to CA.
*/
static CANetworkPacketReceivedCallback g_networkPacketCallback = NULL;
/**
- * @var g_networkChangeCallback
- * @brief Network Changed Callback to CA
+ * Network Changed Callback to CA.
*/
static CANetworkChangeCallback g_networkChangeCallback = NULL;
/**
- * @var g_errorCallback
- * @brief error Callback to CA adapter
+ * error Callback to CA adapter.
*/
static CAErrorHandleCallback g_errorCallback = NULL;
-static void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint,
+static void CAIPPacketReceivedCB(const CASecureEndpoint_t *endpoint,
const void *data, uint32_t dataLength);
#ifdef __WITH_DTLS__
static void CAIPPacketSendCB(CAEndpoint_t *endpoint,
static void CAIPSendDataThread(void *threadData);
-static CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint,
- const void *data, uint32_t dataLength,
- bool isMulticast);
-void CAFreeIPData(CAIPData *ipData);
+static CAIPData_t *CACreateIPData(const CAEndpoint_t *remoteEndpoint,
+ const void *data, uint32_t dataLength,
+ bool isMulticast);
+
+void CAFreeIPData(CAIPData_t *ipData);
static void CADataDestroyer(void *data, uint32_t size);
CAResult_t CAIPInitializeQueueHandles()
{
- 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 CAIPDeinitializeQueueHandles()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
CAQueueingThreadDestroy(g_sendQueueHandle);
OICFree(g_sendQueueHandle);
g_sendQueueHandle = NULL;
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
#endif // SINGLE_THREAD
void CAIPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status)
{
- OIC_LOG(DEBUG, TAG, "IN");
+ (void)ipAddress;
+ (void)status;
}
#ifdef __WITH_DTLS__
static void CAIPPacketSendCB(CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
CAIPSendData(endpoint, data, dataLength, false);
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
#endif
-void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint, const void *data,
+
+void CAIPPacketReceivedCB(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);
-
- void *buf = OICCalloc(dataLength + 1, sizeof (char));
- if (!buf)
- {
- OIC_LOG(ERROR, TAG, "Memory Allocation failed!");
- return;
- }
- memcpy(buf, data, dataLength);
+ OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", sep->endpoint.addr, sep->endpoint.port);
if (g_networkPacketCallback)
{
- g_networkPacketCallback(endpoint, buf, dataLength);
- }
- else
- {
- OICFree(buf);
+ g_networkPacketCallback(sep, data, dataLength);
}
- OIC_LOG(DEBUG, TAG, "OUT");
}
-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)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
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);
}
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
static void CAInitializeIPGlobals()
}
caglobals.ip.ipv6enabled = flags & CA_IPV6;
caglobals.ip.ipv4enabled = flags & CA_IPV4;
+ caglobals.ip.dualstack = caglobals.ip.ipv6enabled && caglobals.ip.ipv4enabled;
}
CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
CADTLSSetAdapterCallbacks(CAIPPacketReceivedCB, CAIPPacketSendCB, 0);
#endif
- CAConnectivityHandler_t ipHandler;
- ipHandler.startAdapter = CAStartIP;
- ipHandler.startListenServer = CAStartIPListeningServer;
- ipHandler.startDiscoveryServer = CAStartIPDiscoveryServer;
- ipHandler.sendData = CASendIPUnicastData;
- ipHandler.sendDataToAll = CASendIPMulticastData;
- ipHandler.GetnetInfo = CAGetIPInterfaceInformation;
- ipHandler.readData = CAReadIPData;
- ipHandler.stopAdapter = CAStopIP;
- ipHandler.terminate = CATerminateIP;
- registerCallback(ipHandler, CA_ADAPTER_IP);
+ static const CAConnectivityHandler_t ipHandler =
+ {
+ .startAdapter = CAStartIP,
+ .stopAdapter = CAStopIP,
+ .startListenServer = CAStartIPListeningServer,
+ .stopListenServer = CAStopIPListeningServer,
+ .startDiscoveryServer = CAStartIPDiscoveryServer,
+ .sendData = CASendIPUnicastData,
+ .sendDataToAll = CASendIPMulticastData,
+ .GetnetInfo = CAGetIPInterfaceInformation,
+ .readData = CAReadIPData,
+ .terminate = CATerminateIP,
+ .cType = CA_ADAPTER_IP
+ };
+ registerCallback(ipHandler);
OIC_LOG(INFO, TAG, "OUT IntializeIP is Success");
return CA_STATUS_OK;
CAResult_t CAStartIP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
+ CAIPStartNetworkMonitor();
#ifdef SINGLE_THREAD
uint16_t unicastPort = 55555;
// Address is hardcoded as we are using Single Interface
#endif
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
CAResult_t CAStartIPListeningServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
+ CAResult_t ret = CAIPStartListenServer();
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG_V(ERROR, TAG, "Failed to start listening server![%d]", ret);
+ return ret;
+ }
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
+CAResult_t CAStopIPListeningServer()
+{
+ CAResult_t ret = CAIPStopListenServer();
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG_V(ERROR, TAG, "Failed to stop listening server![%d]", ret);
+ }
+
+ return ret;
+}
+
CAResult_t CAStartIPDiscoveryServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
return CAStartIPListeningServer();
}
static int32_t CAQueueIPData(bool isMulticast, const CAEndpoint_t *endpoint,
- const void *data, uint32_t dataLength)
+ const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
VERIFY_NON_NULL_RET(endpoint, TAG, "remoteEndpoint", -1);
VERIFY_NON_NULL_RET(data, TAG, "data", -1);
#ifdef SINGLE_THREAD
CAIPSendData(endpoint, data, dataLength, isMulticast);
+ return dataLength;
#else
VERIFY_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
// Create IPData to add to queue
- CAIPData *ipData = CACreateIPData(endpoint, data, dataLength, isMulticast);
+ CAIPData_t *ipData = CACreateIPData(endpoint, data, dataLength, isMulticast);
if (!ipData)
{
OIC_LOG(ERROR, TAG, "Failed to create ipData!");
return -1;
}
// Add message to send queue
- CAQueueingThreadAddData(g_sendQueueHandle, ipData, sizeof(CAIPData));
-
- OIC_LOG(DEBUG, TAG, "OUT");
- return dataLength;
+ CAQueueingThreadAddData(g_sendQueueHandle, ipData, sizeof(CAIPData_t));
#endif // SINGLE_THREAD
+
+ return dataLength;
}
int32_t CASendIPUnicastData(const CAEndpoint_t *endpoint,
const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
return CAQueueIPData(false, endpoint, data, dataLength);
}
int32_t CASendIPMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
{
- OIC_LOG(DEBUG, TAG, "IN");
return CAQueueIPData(true, endpoint, data, dataLength);
}
CAResult_t CAReadIPData()
{
- OIC_LOG(DEBUG, TAG, "IN");
CAIPPullData();
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
CAResult_t CAStopIP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
#ifdef __WITH_DTLS__
CAAdapterNetDtlsDeInit();
#endif
{
CAQueueingThreadStop(g_sendQueueHandle);
}
-
- CAIPDeinitializeQueueHandles();
#endif
+ CAIPStopNetworkMonitor();
CAIPStopServer();
+ //Re-initializing the Globals to start them again
+ CAInitializeIPGlobals();
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
void CATerminateIP()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
#ifdef __WITH_DTLS__
CADTLSSetAdapterCallbacks(NULL, NULL, 0);
#endif
CAIPSetPacketReceiveCallback(NULL);
#ifndef SINGLE_THREAD
+ CADeInitializeIPGlobals();
CAIPDeinitializeQueueHandles();
#endif
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
#ifndef SINGLE_THREAD
void CAIPSendDataThread(void *threadData)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- CAIPData *ipData = (CAIPData *) threadData;
+ CAIPData_t *ipData = (CAIPData_t *) threadData;
if (!ipData)
{
OIC_LOG(DEBUG, TAG, "Invalid ip data!");
{
//Processing for sending unicast
#ifdef __WITH_DTLS__
- if (ipData->remoteEndpoint->flags & CA_SECURE)
+ if (ipData->remoteEndpoint && ipData->remoteEndpoint->flags & CA_SECURE)
{
OIC_LOG(DEBUG, TAG, "CAAdapterNetDtlsEncrypt called!");
CAResult_t result = CAAdapterNetDtlsEncrypt(ipData->remoteEndpoint,
CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
#endif
}
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
#endif
#ifndef SINGLE_THREAD
-
-CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
- uint32_t dataLength, bool isMulticast)
+CAIPData_t *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
+ uint32_t dataLength, bool isMulticast)
{
+ VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
VERIFY_NON_NULL_RET(data, TAG, "IPData is NULL", NULL);
- CAIPData *ipData = (CAIPData *) OICMalloc(sizeof(CAIPData));
+ CAIPData_t *ipData = (CAIPData_t *) OICMalloc(sizeof(*ipData));
if (!ipData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return ipData;
}
-void CAFreeIPData(CAIPData *ipData)
+void CAFreeIPData(CAIPData_t *ipData)
{
VERIFY_NON_NULL_VOID(ipData, TAG, "ipData is NULL");
void CADataDestroyer(void *data, uint32_t size)
{
- CAIPData *etdata = (CAIPData *) data;
+ if (size < sizeof(CAIPData_t))
+ {
+ OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size);
+ }
+ CAIPData_t *etdata = (CAIPData_t *) data;
CAFreeIPData(etdata);
}
#endif // SINGLE_THREAD
-
projects / platform / upstream / iotivity.git / blobdiff