#include "cathreadpool.h"
#include "caipadapter.h"
#include "cainterface.h"
+#include "caipinterface.h"
#include <coap/utlist.h>
+#include "octhread.h"
#ifdef RA_ADAPTER
#include "caraadapter.h"
#include "catcpadapter.h"
#endif
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+#include "ca_adapter_net_ssl.h"
+#endif
+
#define TAG "OIC_CA_INF_CTR"
#define CA_MEMORY_ALLOC_CHECK(arg) {if (arg == NULL) \
static struct CANetworkCallback_t * g_networkChangeCallbackList = NULL;
/**
+ * Mutex to synchronize network change list.
+ */
+static oc_mutex g_mutexNetCallbackList = NULL;
+
+/**
* network callback structure is handling
* for adapter state changed and connection state changed event.
*/
return index;
}
}
+ OIC_LOG_V(ERROR, TAG, "adapter info [%d]", g_numberOfAdapters);
return -1;
}
return CA_STATUS_INVALID_PARAM;
}
+ oc_mutex_lock(g_mutexNetCallbackList);
CANetworkCallback_t* callback = NULL;
LL_FOREACH(g_networkChangeCallbackList, callback)
{
if (callback && adapterCB == callback->adapter && connCB == callback->conn)
{
OIC_LOG(DEBUG, TAG, "this callback is already added");
+ oc_mutex_unlock(g_mutexNetCallbackList);
return CA_STATUS_OK;
}
}
if (NULL == callback)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed during registration");
+ oc_mutex_unlock(g_mutexNetCallbackList);
return CA_MEMORY_ALLOC_FAILED;
}
callback->adapter = adapterCB;
callback->conn = connCB;
LL_APPEND(g_networkChangeCallbackList, callback);
+ oc_mutex_unlock(g_mutexNetCallbackList);
+ OIC_LOG_V(INFO, TAG, "Added NetworkStateChanged Callback [%p]", callback);
+
return CA_STATUS_OK;
}
{
OIC_LOG(DEBUG, TAG, "Remove NetworkStateChanged Callback");
+ oc_mutex_lock(g_mutexNetCallbackList);
CANetworkCallback_t* callback = NULL;
LL_FOREACH(g_networkChangeCallbackList, callback)
{
{
OIC_LOG(DEBUG, TAG, "remove specific callback");
LL_DELETE(g_networkChangeCallbackList, callback);
+ oc_mutex_unlock(g_mutexNetCallbackList);
OICFree(callback);
return CA_STATUS_OK;
}
}
- return CA_STATUS_OK;
-}
+ oc_mutex_unlock(g_mutexNetCallbackList);
-/**
- * Remove all network callback from the network callback list
- */
-static void RemoveAllNetworkStateChangedCallback()
-{
- OIC_LOG(DEBUG, TAG, "Remove All NetworkStateChanged Callback");
-
- CANetworkCallback_t* callback = NULL;
- LL_FOREACH(g_networkChangeCallbackList, callback)
- {
- OIC_LOG(DEBUG, TAG, "remove all callbacks");
- LL_DELETE(g_networkChangeCallbackList, callback);
- OICFree(callback);
- }
+ return CA_STATUS_OK;
}
#ifdef RA_ADAPTER
}
#endif
-static void CAReceivedPacketCallback(const CASecureEndpoint_t *sep,
- const void *data, uint32_t dataLen)
+static CAResult_t CAReceivedPacketCallback(const CASecureEndpoint_t *sep,
+ const void *data, uint32_t dataLen)
{
if (g_networkPacketReceivedCallback != NULL)
{
- g_networkPacketReceivedCallback(sep, data, dataLen);
+ return g_networkPacketReceivedCallback(sep, data, dataLen);
}
else
{
- OIC_LOG(ERROR, TAG, "network packet received callback is NULL!");
+ OIC_LOG(INFO, TAG, "network packet received callback is NULL!");
+ return CA_STATUS_OK;
}
}
static void CAAdapterChangedCallback(CATransportAdapter_t adapter, CANetworkStatus_t status)
{
+
+ oc_mutex_lock(g_mutexNetCallbackList);
// Call the callback.
CANetworkCallback_t* callback = NULL;
LL_FOREACH(g_networkChangeCallbackList, callback)
{
if (callback && callback->adapter)
{
+ OIC_LOG_V(INFO, TAG, "IN application adapter changed callback [%p]", callback);
if (CA_INTERFACE_UP == status)
{
callback->adapter(adapter, true);
{
callback->adapter(adapter, false);
}
+ OIC_LOG_V(INFO, TAG, "OUT application adapter changed callback [%p]", callback);
}
}
+ oc_mutex_unlock(g_mutexNetCallbackList);
OIC_LOG_V(DEBUG, TAG, "[%d] adapter status is changed to [%d]", adapter, status);
}
#if defined(TCP_ADAPTER) || defined(EDR_ADAPTER) || defined(LE_ADAPTER)
static void CAConnectionChangedCallback(const CAEndpoint_t *info, bool isConnected)
{
+ oc_mutex_lock(g_mutexNetCallbackList);
// Call the callback.
CANetworkCallback_t* callback = NULL;
LL_FOREACH(g_networkChangeCallbackList, callback)
callback->conn(info, isConnected);
}
}
+ oc_mutex_unlock(g_mutexNetCallbackList);
OIC_LOG_V(DEBUG, TAG, "[%s] connection status is changed to [%d]", info->addr, isConnected);
}
#endif
}
}
-void CAInitializeAdapters(ca_thread_pool_t handle)
+static void CADestroyMutex()
+{
+ if (g_mutexNetCallbackList)
+ {
+ oc_mutex_free(g_mutexNetCallbackList);
+ g_mutexNetCallbackList = NULL;
+ }
+}
+
+static CAResult_t CACreateMutex()
{
- OIC_LOG(DEBUG, TAG, "initialize adapters..");
+ if (!g_mutexNetCallbackList)
+ {
+ g_mutexNetCallbackList = oc_mutex_new();
+ if (!g_mutexNetCallbackList)
+ {
+ return CA_STATUS_FAILED;
+ }
+ }
+
+ return CA_STATUS_OK;
+}
+
+void CAInitializeAdapters(ca_thread_pool_t handle, CATransportAdapter_t transportType)
+{
+ OIC_LOG_V(DEBUG, TAG, "initialize adapters %d", transportType);
+
+ if (CA_STATUS_OK != CACreateMutex())
+ {
+ OIC_LOG(ERROR, TAG, "Failed to create mutex!");
+ }
+
+ // Initialize ssl adapter.
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+ if (CA_STATUS_OK != CAinitSslAdapter())
+ {
+ OIC_LOG(ERROR, TAG, "Failed to init SSL adapter");
+ }
+#endif
// Initialize adapters and register callback.
#ifdef IP_ADAPTER
- CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_IP) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAAdapterErrorHandleCallback, handle);
+ }
#endif /* IP_ADAPTER */
#ifdef EDR_ADAPTER
- CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_RFCOMM_BTEDR) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* EDR_ADAPTER */
#ifdef LE_ADAPTER
- CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_GATT_BTLE) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* LE_ADAPTER */
#ifdef RA_ADAPTER
- CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- handle);
+ if ((transportType & CA_ADAPTER_REMOTE_ACCESS) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ handle);
+ }
#endif /* RA_ADAPTER */
#ifdef TCP_ADAPTER
- CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_TCP) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
+ }
#endif /* TCP_ADAPTER */
#ifdef NFC_ADAPTER
- CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
- CAAdapterErrorHandleCallback, handle);
+ if ((transportType & CA_ADAPTER_NFC) || (CA_DEFAULT_ADAPTER == transportType)
+ || (transportType == CA_ALL_ADAPTERS))
+ {
+ CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
+ CAAdapterErrorHandleCallback, handle);
+ }
#endif /* NFC_ADAPTER */
}
}
}
+CAResult_t CAUnsetNetworkMonitorCallbacks(CAAdapterStateChangedCB adapterCB,
+ CAConnectionStateChangedCB connCB)
+{
+ OIC_LOG(DEBUG, TAG, "Unset network monitoring callback");
+ CAResult_t res = RemoveNetworkStateChangedCallback(adapterCB, connCB);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "RemoveNetworkStateChangedCallback has failed");
+ }
+ return res;
+}
+
void CASetErrorHandleCallback(CAErrorHandleCallback errorCallback)
{
OIC_LOG(DEBUG, TAG, "Set error handle callback");
resSize += tempSize[index];
}
+#ifndef __TIZENRT__
OIC_LOG_V(DEBUG,
TAG,
"%" PRIu32 " adapter network info size is %" PRIu32 " res:%d",
index,
tempSize[index],
res);
+#endif
}
}
if (-1 == index)
{
- OIC_LOG(ERROR, TAG, "unknown transport type!");
+ OIC_LOG_V(ERROR, TAG, "unknown transport type[%d]", connType);
return CA_STATUS_INVALID_PARAM;
}
void CATerminateAdapters()
{
+ CADestroyMutex();
+
for (uint32_t index = 0; index < g_numberOfAdapters; index++)
{
if (g_adapterHandler[index].terminate != NULL)
}
}
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+ CAdeinitSslAdapter();
+#endif
+
OICFree(g_adapterHandler);
g_adapterHandler = NULL;
g_numberOfAdapters = 0;
}
#endif
+#ifdef IP_ADAPTER
+CAResult_t CASetMulticastTTL(size_t ttl)
+{
+ return CAIPSetMulticastTTL(ttl);
+}
+
+CAResult_t CAGetMulticastTTL(size_t *ttl)
+{
+ return CAIPGetMulticastTTL(ttl);
+}
+#endif
+
+#ifdef TCP_ADAPTER
+CAResult_t CADisconnectSession(const CAEndpoint_t *endpoint)
+{
+ return CATCPDisconnectSession(endpoint);
+}
+#endif
+
+#ifdef LE_ADAPTER
+void CAStartGattServer()
+{
+ CALEStartGattServer();
+}
+
+void CAStopGattServer()
+{
+ CALEStopGattServer();
+}
+#endif