#include <stdint.h>
#include <stdbool.h>
+#include "ocrandom.h"
#include "cainterface.h"
#include "caremotehandler.h"
#include "camessagehandler.h"
#include "caadapternetdtls.h"
#endif
-CAGlobals_t caglobals = { 0 };
+#ifdef TCP_ADAPTER
+#include "catcpadapter.h"
+#endif
+
+CAGlobals_t caglobals = { .clientFlags = 0,
+ .serverFlags = 0, };
-#define TAG "CA_CONN_MGR"
+#define TAG "OIC_CA_CONN_MGR"
static bool g_isInitialized = false;
#ifdef __WITH_DTLS__
// CAAdapterNetDTLS will register the callback.
// Taking callback all the way through adapters not the right approach, hence calling here.
-extern void CADTLSSetCredentialsCallback(CAGetDTLSCredentialsHandler credCallback);
+extern void CADTLSSetCredentialsCallback(CAGetDTLSPskCredentialsHandler credCallback);
+#endif
+
+#ifdef __WITH_X509__
+// CAAdapterNetDTLS will register the callback.
+// Taking callback all the way through adapters not the right approach, hence calling here.
+extern void CADTLSSetX509CredentialsCallback(CAGetDTLSX509CredentialsHandler credCallback);
+extern void CADTLSSetCrlCallback(CAGetDTLSCrlHandler crlCallback);
#endif
CAResult_t CAInitialize()
{
+ OIC_LOG_V(DEBUG, TAG, "IoTivity version is v%s", IOTIVITY_VERSION);
OIC_LOG(DEBUG, TAG, "CAInitialize");
if (!g_isInitialized)
{
+ if (0 != OCSeedRandom())
+ {
+ OIC_LOG(ERROR, TAG, "Seed Random Failed");
+ }
+
CAResult_t res = CAInitializeMessageHandler();
if (res != CA_STATUS_OK)
{
}
g_isInitialized = true;
}
+
return CA_STATUS_OK;
}
return CAStartListeningServerAdapters();
}
+CAResult_t CAStopListeningServer()
+{
+ OIC_LOG(DEBUG, TAG, "CAStopListeningServer");
+
+ if(!g_isInitialized)
+ {
+ return CA_STATUS_NOT_INITIALIZED;
+ }
+
+ return CAStopListeningServerAdapters();
+}
+
CAResult_t CAStartDiscoveryServer()
{
OIC_LOG(DEBUG, TAG, "CAStartDiscoveryServer");
}
#ifdef __WITH_DTLS__
-CAResult_t CARegisterDTLSCredentialsHandler(CAGetDTLSCredentialsHandler GetDTLSCredentialsHandler)
+CAResult_t CARegisterDTLSHandshakeCallback(CAErrorCallback dtlsHandshakeCallback)
+{
+ OIC_LOG(DEBUG, TAG, "CARegisterDTLSHandshakeCallback");
+
+ if(!g_isInitialized)
+ {
+ return CA_STATUS_NOT_INITIALIZED;
+ }
+
+ CADTLSSetHandshakeCallback(dtlsHandshakeCallback);
+
+ return CA_STATUS_OK;
+}
+
+CAResult_t CARegisterDTLSCredentialsHandler(CAGetDTLSPskCredentialsHandler GetDTLSCredentialsHandler)
{
OIC_LOG(DEBUG, TAG, "CARegisterDTLSCredentialsHandler");
}
#endif //__WITH_DTLS__
+#ifdef __WITH_X509__
+CAResult_t CARegisterDTLSX509CredentialsHandler(CAGetDTLSX509CredentialsHandler GetDTLSX509CredentialsHandler)
+{
+ OIC_LOG(DEBUG, TAG, "CARegisterDTLSX509CredentialsHandler");
+
+ if(!g_isInitialized)
+ {
+ return CA_STATUS_NOT_INITIALIZED;
+ }
+
+ CADTLSSetX509CredentialsCallback(GetDTLSX509CredentialsHandler);
+ return CA_STATUS_OK;
+}
+
+CAResult_t CARegisterDTLSCrlHandler(CAGetDTLSCrlHandler GetDTLSCrlHandler)
+{
+ OIC_LOG(DEBUG, TAG, "CARegisterDTLSCrlHandler");
+
+ if(!g_isInitialized)
+ {
+ return CA_STATUS_NOT_INITIALIZED;
+ }
+
+ CADTLSSetCrlCallback(GetDTLSCrlHandler);
+ return CA_STATUS_OK;
+}
+#endif //__WITH_X509__
+
CAResult_t CACreateEndpoint(CATransportFlags_t flags,
CATransportAdapter_t adapter,
const char *addr,
{
OIC_LOG(DEBUG, TAG, "CAGenerateToken");
- if(!g_isInitialized)
- {
- return CA_STATUS_NOT_INITIALIZED;
- }
return CAGenerateTokenInternal(token, tokenLength);
}
return CAGetNetworkInformationInternal(info, size);
}
-CAResult_t CASendRequest(const CAEndpoint_t *object,const CARequestInfo_t *requestInfo)
+static CAResult_t CASendMessageMultiAdapter(const CAEndpoint_t *object, const void *sendMsg,
+ CADataType_t dataType)
{
- OIC_LOG(DEBUG, TAG, "CASendGetRequest");
+ OIC_LOG(DEBUG, TAG, "CASendMessageMultipleAdapter");
- if(!g_isInitialized)
+ CATransportAdapter_t connTypes[] = {
+ CA_ADAPTER_IP
+#ifdef LE_ADAPTER
+ ,CA_ADAPTER_GATT_BTLE
+#endif
+#ifdef EDR_ADAPTER
+ ,CA_ADAPTER_RFCOMM_BTEDR
+#endif
+#ifdef NFC_ADAPTER
+ ,CA_ADAPTER_NFC
+#endif
+#ifdef RA_ADAPTER
+ ,CA_ADAPTER_REMOTE_ACCESS
+#endif
+#ifdef TCP_ADAPTER
+ ,CA_ADAPTER_TCP
+#endif
+ };
+
+ CAEndpoint_t *cloneEp = CACloneEndpoint(object);
+ if (!cloneEp)
{
- return CA_STATUS_NOT_INITIALIZED;
+ OIC_LOG(ERROR, TAG, "Failed to clone CAEndpoint");
+ return CA_MEMORY_ALLOC_FAILED;
}
- return CADetachRequestMessage(object, requestInfo);
+ CAResult_t ret = CA_STATUS_OK;
+ size_t numConnTypes = sizeof(connTypes) / sizeof(connTypes[0]);
+
+ for (size_t i = 0; i < numConnTypes && ret == CA_STATUS_OK; i++)
+ {
+ cloneEp->adapter = connTypes[i];
+ ret = CADetachSendMessage(cloneEp, sendMsg, dataType);
+ }
+ CAFreeEndpoint(cloneEp);
+ return ret;
}
-CAResult_t CASendNotification(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
+CAResult_t CASendRequest(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
{
- OIC_LOG(DEBUG, TAG, "CASendNotification");
+ OIC_LOG(DEBUG, TAG, "CASendRequest");
if(!g_isInitialized)
{
return CA_STATUS_NOT_INITIALIZED;
}
- return CADetachResponseMessage(object, responseInfo);
-
+ if (requestInfo && requestInfo->isMulticast &&
+ (object->adapter == CA_DEFAULT_ADAPTER || object->adapter == CA_ALL_ADAPTERS))
+ {
+ return CASendMessageMultiAdapter(object, requestInfo, CA_REQUEST_DATA);
+ }
+ else
+ {
+ return CADetachSendMessage(object, requestInfo, CA_REQUEST_DATA);
+ }
}
CAResult_t CASendResponse(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
return CA_STATUS_NOT_INITIALIZED;
}
- return CADetachResponseMessage(object, responseInfo);
-
+ if (responseInfo && responseInfo->isMulticast &&
+ (object->adapter == CA_DEFAULT_ADAPTER || object->adapter == CA_ALL_ADAPTERS))
+ {
+ return CASendMessageMultiAdapter(object, responseInfo, CA_RESPONSE_DATA);
+ }
+ else
+ {
+ return CADetachSendMessage(object, responseInfo, CA_RESPONSE_DATA);
+ }
}
CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
if (interestedNetwork & CA_ADAPTER_IP)
{
res = CAAddNetworkType(CA_ADAPTER_IP);
- OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns result: %d", res);
}
else if (interestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
{
res = CAAddNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
- OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
}
else if (interestedNetwork & CA_ADAPTER_GATT_BTLE)
{
res = CAAddNetworkType(CA_ADAPTER_GATT_BTLE);
- OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
}
- #ifdef RA_ADAPTER
+#ifdef RA_ADAPTER
else if (interestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
{
res = CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS);
- OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns error : %d",
- res);
+ OIC_LOG_V(DEBUG, TAG,
+ "CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d", res);
+ }
+#endif
+
+#ifdef TCP_ADAPTER
+ else if (interestedNetwork & CA_ADAPTER_TCP)
+ {
+ res = CAAddNetworkType(CA_ADAPTER_TCP);
+ OIC_LOG_V(DEBUG, TAG,
+ "CAAddNetworkType(CA_ADAPTER_TCP) function returns result : %d", res);
+ }
+#endif
+ else if (interestedNetwork & CA_ADAPTER_NFC)
+ {
+ res = CAAddNetworkType(CA_ADAPTER_NFC);
+ OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_ADAPTER_NFC) function returns result : %d", res);
}
- #endif
else
{
res = CA_NOT_SUPPORTED;
if (nonInterestedNetwork & CA_ADAPTER_IP)
{
res = CARemoveNetworkType(CA_ADAPTER_IP);
- OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns result : %d", res);
}
else if (nonInterestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
{
res = CARemoveNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
- OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
}
else if (nonInterestedNetwork & CA_ADAPTER_GATT_BTLE)
{
res = CARemoveNetworkType(CA_ADAPTER_GATT_BTLE);
- OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns error : %d", res);
+ OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
}
- #ifdef RA_ADAPTER
+#ifdef RA_ADAPTER
else if (nonInterestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
{
res = CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS);
- OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns error : %d",
- res);
+ OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d",
+ res);
}
- #endif
+#endif
+
+
+#ifdef TCP_ADAPTER
+ else if (nonInterestedNetwork & CA_ADAPTER_TCP)
+ {
+ res = CARemoveNetworkType(CA_ADAPTER_TCP);
+ OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_TCP) function returns result : %d",
+ res);
+ }
+#endif
+
else
{
res = CA_STATUS_FAILED;
}
#ifdef __WITH_DTLS__
-
CAResult_t CASelectCipherSuite(const uint16_t cipher)
{
OIC_LOG_V(DEBUG, TAG, "CASelectCipherSuite");
}
#endif /* __WITH_DTLS__ */
+
+#ifdef TCP_ADAPTER
+void CARegisterKeepAliveHandler(CAKeepAliveConnectedCallback ConnHandler,
+ CAKeepAliveDisconnectedCallback DisconnHandler)
+{
+ CATCPSetKeepAliveCallbacks(ConnHandler, DisconnHandler);
+}
+#endif