X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fcaconnectivitymanager.c;h=98b3ffd1d02df18d93a52d704e81d77553e92891;hb=8c01dff2c5bc5496f7dc1632c498943ec6ecb015;hp=1eabcecfccc25572963e61b258d06f4beee99f96;hpb=935fdb9b67b6c10d007e652e9e2e028fd6ccfe09;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/connectivity/src/caconnectivitymanager.c b/resource/csdk/connectivity/src/caconnectivitymanager.c index 1eabcec..98b3ffd 100644 --- a/resource/csdk/connectivity/src/caconnectivitymanager.c +++ b/resource/csdk/connectivity/src/caconnectivitymanager.c @@ -21,6 +21,7 @@ #include #include #include +#include #include "cainterface.h" #include "caremotehandler.h" @@ -29,8 +30,15 @@ #include "canetworkconfigurator.h" #include "cainterfacecontroller.h" #include "logger.h" +#ifdef __WITH_DTLS__ +#include "caadapternetdtls.h" +#endif + +CAGlobals_t caglobals = { 0 }; + +#define TAG "CA_CONN_MGR" -#define TAG PCF("CA") +static bool g_isInitialized = false; #ifdef __WITH_DTLS__ // CAAdapterNetDTLS will register the callback. @@ -42,22 +50,41 @@ CAResult_t CAInitialize() { OIC_LOG(DEBUG, TAG, "CAInitialize"); - return CAInitializeMessageHandler();; + if (!g_isInitialized) + { + CAResult_t res = CAInitializeMessageHandler(); + if (res != CA_STATUS_OK) + { + OIC_LOG(ERROR, TAG, "CAInitialize has failed"); + return res; + } + g_isInitialized = true; + } + return CA_STATUS_OK; } void CATerminate() { OIC_LOG(DEBUG, TAG, "CATerminate"); - CATerminateMessageHandler(); + if (g_isInitialized) + { + CATerminateMessageHandler(); + CATerminateNetworkType(); - CATerminateNetworkType(); + g_isInitialized = false; + } } CAResult_t CAStartListeningServer() { OIC_LOG(DEBUG, TAG, "CAStartListeningServer"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } + return CAStartListeningServerAdapters(); } @@ -65,55 +92,79 @@ CAResult_t CAStartDiscoveryServer() { OIC_LOG(DEBUG, TAG, "CAStartDiscoveryServer"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } + return CAStartDiscoveryServerAdapters(); } -void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler) +void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler, + CAErrorCallback ErrorHandler) { OIC_LOG(DEBUG, TAG, "CARegisterHandler"); - CASetRequestResponseCallbacks(ReqHandler, RespHandler); + if(!g_isInitialized) + { + OIC_LOG(DEBUG, TAG, "CA is not initialized"); + return; + } + + CASetInterfaceCallbacks(ReqHandler, RespHandler, ErrorHandler); } #ifdef __WITH_DTLS__ -CAResult_t CARegisterDTLSCredentialsHandler( - CAGetDTLSCredentialsHandler GetDTLSCredentialsHandler) +CAResult_t CARegisterDTLSCredentialsHandler(CAGetDTLSCredentialsHandler GetDTLSCredentialsHandler) { OIC_LOG(DEBUG, TAG, "CARegisterDTLSCredentialsHandler"); + + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } + CADTLSSetCredentialsCallback(GetDTLSCredentialsHandler); return CA_STATUS_OK; } #endif //__WITH_DTLS__ -CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CATransportType_t transportType, - CARemoteEndpoint_t **remoteEndpoint) +CAResult_t CACreateEndpoint(CATransportFlags_t flags, + CATransportAdapter_t adapter, + const char *addr, + uint16_t port, + CAEndpoint_t **object) { - OIC_LOG(DEBUG, TAG, "CACreateRemoteEndpoint"); - - CARemoteEndpoint_t *remote = CACreateRemoteEndpointUriInternal(uri, transportType); + if (!object) + { + OIC_LOG(ERROR, TAG, "Invalid Parameter"); + return CA_STATUS_INVALID_PARAM; + } - if (remote == NULL) + CAEndpoint_t *endpoint = CACreateEndpointObject(flags, adapter, addr, port); + if (!endpoint) { - OIC_LOG(DEBUG, TAG, "remote is NULL!"); return CA_STATUS_FAILED; } - - *remoteEndpoint = remote; - + *object = endpoint; return CA_STATUS_OK; } -void CADestroyRemoteEndpoint(CARemoteEndpoint_t *rep) +void CADestroyEndpoint(CAEndpoint_t *rep) { - OIC_LOG(DEBUG, TAG, "CADestroyRemoteEndpoint"); + OIC_LOG(DEBUG, TAG, "CADestroyEndpoint"); - CADestroyRemoteEndpointInternal(rep); + CAFreeEndpoint(rep); } CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength) { OIC_LOG(DEBUG, TAG, "CAGenerateToken"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } return CAGenerateTokenInternal(token, tokenLength); } @@ -122,137 +173,242 @@ void CADestroyToken(CAToken_t token) OIC_LOG(DEBUG, TAG, "CADestroyToken"); CADestroyTokenInternal(token); -} -CAResult_t CAGetNetworkInformation(CALocalConnectivity_t **info, uint32_t *size) -{ - OIC_LOG(DEBUG, TAG, "CAGetNetworkInformation"); - - return CAGetNetworkInformationInternal(info, size); + OIC_LOG(DEBUG, TAG, "OUT"); } -CAResult_t CAFindResource(const CAURI_t resourceUri, const CAToken_t token, uint8_t tokenLength) +CAResult_t CAGetNetworkInformation(CAEndpoint_t **info, uint32_t *size) { - OIC_LOG(DEBUG, TAG, "CAFindResource"); + OIC_LOG(DEBUG, TAG, "CAGetNetworkInformation"); - return CADetachMessageResourceUri(resourceUri, token, tokenLength, NULL, 0); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } + return CAGetNetworkInformationInternal(info, size); } -CAResult_t CASendRequest(const CARemoteEndpoint_t *object,const CARequestInfo_t *requestInfo) +CAResult_t CASendRequest(const CAEndpoint_t *object,const CARequestInfo_t *requestInfo) { OIC_LOG(DEBUG, TAG, "CASendGetRequest"); - return CADetachRequestMessage(object, requestInfo); -} - -CAResult_t CASendRequestToAll(const CAGroupEndpoint_t *object, - const CARequestInfo_t *requestInfo) -{ - OIC_LOG(DEBUG, TAG, "CASendRequestToAll"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } - return CADetachRequestToAllMessage(object, requestInfo); + return CADetachRequestMessage(object, requestInfo); } -CAResult_t CASendNotification(const CARemoteEndpoint_t *object, - const CAResponseInfo_t *responseInfo) +CAResult_t CASendNotification(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo) { OIC_LOG(DEBUG, TAG, "CASendNotification"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } + return CADetachResponseMessage(object, responseInfo); } -CAResult_t CASendResponse(const CARemoteEndpoint_t *object, - const CAResponseInfo_t *responseInfo) +CAResult_t CASendResponse(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo) { OIC_LOG(DEBUG, TAG, "CASendResponse"); - return CADetachResponseMessage(object, responseInfo); - -} - -CAResult_t CAAdvertiseResource(const CAURI_t resourceUri,const CAToken_t token, - uint8_t tokenLength, const CAHeaderOption_t *options, - const uint8_t numOptions) -{ - OIC_LOG(DEBUG, TAG, "CAAdvertiseResource"); + if(!g_isInitialized) + { + return CA_STATUS_NOT_INITIALIZED; + } - return CADetachMessageResourceUri(resourceUri, token, tokenLength, options, numOptions); + return CADetachResponseMessage(object, responseInfo); } -CAResult_t CASelectNetwork(const uint32_t interestedNetwork) +CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork) { OIC_LOG_V(DEBUG, TAG, "Selected network : %d", interestedNetwork); - if (!(interestedNetwork & 0xf)) + if(!g_isInitialized) { - return CA_NOT_SUPPORTED; + return CA_STATUS_NOT_INITIALIZED; } CAResult_t res = CA_STATUS_OK; - if (interestedNetwork & CA_IPV4) + if (interestedNetwork & CA_ADAPTER_IP) { - res = CAAddNetworkType(CA_IPV4); - OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_IPV4) function returns error : %d", res); + res = CAAddNetworkType(CA_ADAPTER_IP); + OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns error : %d", res); } - - if (interestedNetwork & CA_EDR) + else if (interestedNetwork & CA_ADAPTER_RFCOMM_BTEDR) { - res = CAAddNetworkType(CA_EDR); - OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_EDR) function returns error : %d", res); + res = CAAddNetworkType(CA_ADAPTER_RFCOMM_BTEDR); + OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res); } - - if (interestedNetwork & CA_LE) + else if (interestedNetwork & CA_ADAPTER_GATT_BTLE) { - res = CAAddNetworkType(CA_LE); - OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_LE) function returns error : %d", res); + res = CAAddNetworkType(CA_ADAPTER_GATT_BTLE); + OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns error : %d", res); } + #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); + } + #endif + else + { + res = CA_NOT_SUPPORTED; + } return res; } -CAResult_t CAUnSelectNetwork(const uint32_t nonInterestedNetwork) +CAResult_t CAUnSelectNetwork(CATransportAdapter_t nonInterestedNetwork) { OIC_LOG_V(DEBUG, TAG, "unselected network : %d", nonInterestedNetwork); - if (!(nonInterestedNetwork & 0xf)) + if(!g_isInitialized) { - return CA_NOT_SUPPORTED; + return CA_STATUS_NOT_INITIALIZED; } CAResult_t res = CA_STATUS_OK; - if (nonInterestedNetwork & CA_IPV4) + if (nonInterestedNetwork & CA_ADAPTER_IP) { - res = CARemoveNetworkType(CA_IPV4); - OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_IPV4) function returns error : %d", res); + res = CARemoveNetworkType(CA_ADAPTER_IP); + OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns error : %d", res); } - - if (nonInterestedNetwork & CA_EDR) + else if (nonInterestedNetwork & CA_ADAPTER_RFCOMM_BTEDR) { - res = CARemoveNetworkType(CA_EDR); - OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_EDR) function returns error : %d", res); + res = CARemoveNetworkType(CA_ADAPTER_RFCOMM_BTEDR); + OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res); } - - if (nonInterestedNetwork & CA_LE) + else if (nonInterestedNetwork & CA_ADAPTER_GATT_BTLE) { - res = CARemoveNetworkType(CA_LE); - OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_LE) function returns error : %d", res); + res = CARemoveNetworkType(CA_ADAPTER_GATT_BTLE); + OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns error : %d", res); + } + #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); + } + #endif + else + { + res = CA_STATUS_FAILED; } - return res; } CAResult_t CAHandleRequestResponse() { - OIC_LOG(DEBUG, TAG, "CAHandleRequestResponse"); + if (!g_isInitialized) + { + OIC_LOG(ERROR, TAG, "not initialized"); + return CA_STATUS_NOT_INITIALIZED; + } CAHandleRequestResponseCallbacks(); return CA_STATUS_OK; } +#ifdef __WITH_DTLS__ + +CAResult_t CASelectCipherSuite(const uint16_t cipher) +{ + OIC_LOG_V(DEBUG, TAG, "CASelectCipherSuite"); + + return CADtlsSelectCipherSuite(cipher); +} + +CAResult_t CAEnableAnonECDHCipherSuite(const bool enable) +{ + OIC_LOG_V(DEBUG, TAG, "CAEnableAnonECDHCipherSuite"); + + return CADtlsEnableAnonECDHCipherSuite(enable); +} + +CAResult_t CAGenerateOwnerPSK(const CAEndpoint_t* endpoint, + const uint8_t* label, const size_t labelLen, + const uint8_t* rsrcServerDeviceID, const size_t rsrcServerDeviceIDLen, + const uint8_t* provServerDeviceID, const size_t provServerDeviceIDLen, + uint8_t* ownerPSK, const size_t ownerPSKSize) +{ + OIC_LOG_V(DEBUG, TAG, "IN : CAGenerateOwnerPSK"); + + CAResult_t res = CA_STATUS_OK; + + //newOwnerLabel and prevOwnerLabe can be NULL + if (!endpoint || !label || 0 == labelLen || !ownerPSK || 0 == ownerPSKSize) + { + return CA_STATUS_INVALID_PARAM; + } + + res = CADtlsGenerateOwnerPSK(endpoint, label, labelLen, + rsrcServerDeviceID, rsrcServerDeviceIDLen, + provServerDeviceID, provServerDeviceIDLen, + ownerPSK, ownerPSKSize); + if (CA_STATUS_OK != res) + { + OIC_LOG_V(ERROR, TAG, "Failed to CAGenerateOwnerPSK : %d", res); + } + + OIC_LOG_V(DEBUG, TAG, "OUT : CAGenerateOwnerPSK"); + + return res; +} + +CAResult_t CAInitiateHandshake(const CAEndpoint_t *endpoint) +{ + OIC_LOG_V(DEBUG, TAG, "IN : CAInitiateHandshake"); + CAResult_t res = CA_STATUS_OK; + + if (!endpoint) + { + return CA_STATUS_INVALID_PARAM; + } + + res = CADtlsInitiateHandshake(endpoint); + if (CA_STATUS_OK != res) + { + OIC_LOG_V(ERROR, TAG, "Failed to CADtlsInitiateHandshake : %d", res); + } + + OIC_LOG_V(DEBUG, TAG, "OUT : CAInitiateHandshake"); + + return res; +} + +CAResult_t CACloseDtlsSession(const CAEndpoint_t *endpoint) +{ + OIC_LOG_V(DEBUG, TAG, "IN : CACloseDtlsSession"); + CAResult_t res = CA_STATUS_OK; + + if (!endpoint) + { + return CA_STATUS_INVALID_PARAM; + } + + res = CADtlsClose(endpoint); + if (CA_STATUS_OK != res) + { + OIC_LOG_V(ERROR, TAG, "Failed to CADtlsClose : %d", res); + } + + OIC_LOG_V(DEBUG, TAG, "OUT : CACloseDtlsSession"); + + return res; +} +#endif /* __WITH_DTLS__ */