1 /******************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
27 #include "cainterface.h"
28 #include "caremotehandler.h"
29 #include "camessagehandler.h"
30 #include "caprotocolmessage.h"
31 #include "canetworkconfigurator.h"
32 #include "cainterfacecontroller.h"
34 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
35 #include "ca_adapter_net_ssl.h"
36 #endif // __WITH_DTLS__ or __WITH_TLS__
39 #include "catcpadapter.h"
42 CAGlobals_t caglobals = { .clientFlags = 0,
45 #define TAG "OIC_CA_CONN_MGR"
47 static bool g_isInitialized = false;
49 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
50 // Taking callback all the way through adapters not the right approach, hence calling here.
51 extern void CAsetPkixInfoCallback(CAgetPkixInfoHandler infCallback);
52 extern void CAsetPskCredentialsCallback(CAgetPskCredentialsHandler credCallback);
53 extern void CAsetCredentialTypesCallback(CAgetCredentialTypesHandler credCallback);
54 #endif // __WITH_DTLS__ or __WITH_TLS__
57 CAResult_t CAInitialize()
59 OIC_LOG_V(DEBUG, TAG, "IoTivity version is v%s", IOTIVITY_VERSION);
60 OIC_LOG(DEBUG, TAG, "CAInitialize");
64 if (0 != OCSeedRandom())
66 OIC_LOG(ERROR, TAG, "Seed Random Failed");
69 CAResult_t res = CAInitializeMessageHandler();
70 if (res != CA_STATUS_OK)
72 OIC_LOG(ERROR, TAG, "CAInitialize has failed");
75 g_isInitialized = true;
83 OIC_LOG(DEBUG, TAG, "CATerminate");
87 CATerminateMessageHandler();
88 CATerminateNetworkType();
90 g_isInitialized = false;
94 CAResult_t CAStartListeningServer()
96 OIC_LOG(DEBUG, TAG, "CAStartListeningServer");
100 return CA_STATUS_NOT_INITIALIZED;
103 return CAStartListeningServerAdapters();
106 CAResult_t CAStopListeningServer()
108 OIC_LOG(DEBUG, TAG, "CAStopListeningServer");
110 if (!g_isInitialized)
112 return CA_STATUS_NOT_INITIALIZED;
115 return CAStopListeningServerAdapters();
118 CAResult_t CAStartDiscoveryServer()
120 OIC_LOG(DEBUG, TAG, "CAStartDiscoveryServer");
122 if (!g_isInitialized)
124 return CA_STATUS_NOT_INITIALIZED;
127 return CAStartDiscoveryServerAdapters();
130 void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler,
131 CAErrorCallback ErrorHandler)
133 OIC_LOG(DEBUG, TAG, "CARegisterHandler");
135 if (!g_isInitialized)
137 OIC_LOG(DEBUG, TAG, "CA is not initialized");
141 CASetInterfaceCallbacks(ReqHandler, RespHandler, ErrorHandler);
144 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
145 #ifdef _ENABLE_MULTIPLE_OWNER_
146 const CASecureEndpoint_t *CAGetSecureEndpointData(const CAEndpoint_t *peer)
148 OIC_LOG(DEBUG, TAG, "IN CAGetSecurePeerInfo");
150 if (!g_isInitialized)
152 OIC_LOG(DEBUG, TAG, "CA is not initialized");
156 OIC_LOG(DEBUG, TAG, "OUT CAGetSecurePeerInfo");
157 return GetCASecureEndpointData(peer);
159 #endif //_ENABLE_MULTIPLE_OWNER_
161 CAResult_t CAregisterSslHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
163 OIC_LOG(DEBUG, TAG, "CAregisterSslHandshakeCallback");
166 return CA_STATUS_NOT_INITIALIZED;
169 CAsetSslHandshakeCallback(tlsHandshakeCallback);
173 CAResult_t CAregisterPskCredentialsHandler(CAgetPskCredentialsHandler getTlsCredentialsHandler)
175 OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
177 if (!g_isInitialized)
179 return CA_STATUS_NOT_INITIALIZED;
181 CAsetPskCredentialsCallback(getTlsCredentialsHandler);
182 OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
186 CAResult_t CAregisterPkixInfoHandler(CAgetPkixInfoHandler getPkixInfoHandler)
188 OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
190 if (!g_isInitialized)
192 return CA_STATUS_NOT_INITIALIZED;
194 CAsetPkixInfoCallback(getPkixInfoHandler);
195 OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
199 CAResult_t CAregisterGetCredentialTypesHandler(CAgetCredentialTypesHandler getCredTypesHandler)
201 OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
203 if (!g_isInitialized)
205 return CA_STATUS_NOT_INITIALIZED;
207 CAsetCredentialTypesCallback(getCredTypesHandler);
208 OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
211 #endif // __WITH_DTLS__ or __WITH_TLS__
213 CAResult_t CACreateEndpoint(CATransportFlags_t flags,
214 CATransportAdapter_t adapter,
217 CAEndpoint_t **object)
221 OIC_LOG(ERROR, TAG, "Invalid Parameter");
222 return CA_STATUS_INVALID_PARAM;
225 CAEndpoint_t *endpoint = CACreateEndpointObject(flags, adapter, addr, port);
228 return CA_STATUS_FAILED;
234 void CADestroyEndpoint(CAEndpoint_t *rep)
236 OIC_LOG(DEBUG, TAG, "CADestroyEndpoint");
241 CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
243 OIC_LOG(DEBUG, TAG, "CAGenerateToken");
245 return CAGenerateTokenInternal(token, tokenLength);
248 void CADestroyToken(CAToken_t token)
250 OIC_LOG(DEBUG, TAG, "CADestroyToken");
252 CADestroyTokenInternal(token);
254 OIC_LOG(DEBUG, TAG, "OUT");
257 CAResult_t CAGetNetworkInformation(CAEndpoint_t **info, uint32_t *size)
259 OIC_LOG(DEBUG, TAG, "CAGetNetworkInformation");
261 if (!g_isInitialized)
263 return CA_STATUS_NOT_INITIALIZED;
266 return CAGetNetworkInformationInternal(info, size);
269 static CAResult_t CASendMessageMultiAdapter(const CAEndpoint_t *object, const void *sendMsg,
270 CADataType_t dataType)
272 OIC_LOG(DEBUG, TAG, "CASendMessageMultipleAdapter");
274 CATransportAdapter_t connTypes[] = {
277 ,CA_ADAPTER_GATT_BTLE
280 ,CA_ADAPTER_RFCOMM_BTEDR
286 ,CA_ADAPTER_REMOTE_ACCESS
293 CAEndpoint_t *cloneEp = CACloneEndpoint(object);
296 OIC_LOG(ERROR, TAG, "Failed to clone CAEndpoint");
297 return CA_MEMORY_ALLOC_FAILED;
300 CAResult_t ret = CA_STATUS_OK;
301 size_t numConnTypes = sizeof(connTypes) / sizeof(connTypes[0]);
303 for (size_t i = 0; i < numConnTypes && ret == CA_STATUS_OK; i++)
305 cloneEp->adapter = connTypes[i];
306 ret = CADetachSendMessage(cloneEp, sendMsg, dataType);
308 CAFreeEndpoint(cloneEp);
312 CAResult_t CASendRequest(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
314 OIC_LOG(DEBUG, TAG, "CASendRequest");
316 if (!g_isInitialized)
318 return CA_STATUS_NOT_INITIALIZED;
321 if (requestInfo && requestInfo->isMulticast &&
322 (object->adapter == CA_DEFAULT_ADAPTER || object->adapter == CA_ALL_ADAPTERS))
324 return CASendMessageMultiAdapter(object, requestInfo, CA_REQUEST_DATA);
328 return CADetachSendMessage(object, requestInfo, CA_REQUEST_DATA);
332 CAResult_t CASendResponse(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
334 OIC_LOG(DEBUG, TAG, "CASendResponse");
336 if (!g_isInitialized)
338 return CA_STATUS_NOT_INITIALIZED;
341 if (!responseInfo || !object)
343 return CA_STATUS_INVALID_PARAM;
346 if (responseInfo->isMulticast &&
347 (object->adapter == CA_DEFAULT_ADAPTER || object->adapter == CA_ALL_ADAPTERS))
349 return CASendMessageMultiAdapter(object, responseInfo, responseInfo->info.dataType);
353 return CADetachSendMessage(object, responseInfo, responseInfo->info.dataType);
357 CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
359 OIC_LOG_V(DEBUG, TAG, "Selected network : %d", interestedNetwork);
361 if (!g_isInitialized)
363 return CA_STATUS_NOT_INITIALIZED;
366 CAResult_t res = CA_STATUS_OK;
368 if (interestedNetwork & CA_ADAPTER_IP)
370 res = CAAddNetworkType(CA_ADAPTER_IP);
371 OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns result: %d", res);
373 else if (interestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
375 res = CAAddNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
376 OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
378 else if (interestedNetwork & CA_ADAPTER_GATT_BTLE)
380 res = CAAddNetworkType(CA_ADAPTER_GATT_BTLE);
381 OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
385 else if (interestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
387 res = CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS);
388 OIC_LOG_V(DEBUG, TAG,
389 "CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d", res);
394 else if (interestedNetwork & CA_ADAPTER_TCP)
396 res = CAAddNetworkType(CA_ADAPTER_TCP);
397 OIC_LOG_V(DEBUG, TAG,
398 "CAAddNetworkType(CA_ADAPTER_TCP) function returns result : %d", res);
401 else if (interestedNetwork & CA_ADAPTER_NFC)
403 res = CAAddNetworkType(CA_ADAPTER_NFC);
404 OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_ADAPTER_NFC) function returns result : %d", res);
408 res = CA_NOT_SUPPORTED;
413 CAResult_t CAUnSelectNetwork(CATransportAdapter_t nonInterestedNetwork)
415 OIC_LOG_V(DEBUG, TAG, "unselected network : %d", nonInterestedNetwork);
417 if (!g_isInitialized)
419 return CA_STATUS_NOT_INITIALIZED;
422 CAResult_t res = CA_STATUS_OK;
424 if (nonInterestedNetwork & CA_ADAPTER_IP)
426 res = CARemoveNetworkType(CA_ADAPTER_IP);
427 OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns result : %d", res);
429 else if (nonInterestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
431 res = CARemoveNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
432 OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
434 else if (nonInterestedNetwork & CA_ADAPTER_GATT_BTLE)
436 res = CARemoveNetworkType(CA_ADAPTER_GATT_BTLE);
437 OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
440 else if (nonInterestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
442 res = CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS);
443 OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d",
450 else if (nonInterestedNetwork & CA_ADAPTER_TCP)
452 res = CARemoveNetworkType(CA_ADAPTER_TCP);
453 OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_TCP) function returns result : %d",
460 res = CA_STATUS_FAILED;
465 CAResult_t CAHandleRequestResponse()
467 if (!g_isInitialized)
469 OIC_LOG(ERROR, TAG, "not initialized");
470 return CA_STATUS_NOT_INITIALIZED;
473 CAHandleRequestResponseCallbacks();
478 CAResult_t CASelectCipherSuite(const uint16_t cipher, CATransportAdapter_t adapter)
480 OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
481 OIC_LOG_V(DEBUG, TAG, "cipher : %d , CATransportAdapter : %d", cipher, adapter);
482 CAResult_t res = CA_STATUS_FAILED;
483 #if defined (__WITH_DTLS__) || defined(__WITH_TLS__)
484 res = CAsetTlsCipherSuite(cipher);
485 if (CA_STATUS_OK != res)
487 OIC_LOG_V(ERROR, TAG, "Failed to CAsetTlsCipherSuite : %d", res);
490 OIC_LOG(ERROR, TAG, "Method not supported");
492 OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
496 CAResult_t CAEnableAnonECDHCipherSuite(const bool enable)
498 OIC_LOG_V(DEBUG, TAG, "CAEnableAnonECDHCipherSuite");
499 CAResult_t res = CA_STATUS_FAILED;
500 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
501 // TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256 0xFF00 replaces 0xC018
502 // TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0xC037
503 res = CAsetTlsCipherSuite(enable ? 0xFF00 : 0xC037);
504 if (CA_STATUS_OK != res)
506 OIC_LOG_V(ERROR, TAG, "Failed to CAsetTlsCipherSuite : %d", res);
509 OIC_LOG(ERROR, TAG, "Method not supported");
511 OIC_LOG_V(ERROR, TAG, "Out %s", __func__);
515 CAResult_t CAGenerateOwnerPSK(const CAEndpoint_t* endpoint,
516 const uint8_t* label, const size_t labelLen,
517 const uint8_t* rsrcServerDeviceID, const size_t rsrcServerDeviceIDLen,
518 const uint8_t* provServerDeviceID, const size_t provServerDeviceIDLen,
519 uint8_t* ownerPSK, const size_t ownerPskSize)
521 OIC_LOG_V(DEBUG, TAG, "IN : CAGenerateOwnerPSK");
522 CAResult_t res = CA_STATUS_FAILED;
523 #if defined (__WITH_DTLS__) || defined(__WITH_TLS__)
524 //newOwnerLabel and prevOwnerLabe can be NULL
525 if (!endpoint || !label || 0 == labelLen || !ownerPSK || 0 == ownerPskSize)
527 return CA_STATUS_INVALID_PARAM;
530 res = CAsslGenerateOwnerPsk(endpoint, label, labelLen,
531 rsrcServerDeviceID, rsrcServerDeviceIDLen,
532 provServerDeviceID, provServerDeviceIDLen,
533 ownerPSK, ownerPskSize);
534 if (CA_STATUS_OK != res)
536 OIC_LOG_V(ERROR, TAG, "Failed to CAGenerateOwnerPSK : %d", res);
539 OIC_LOG(ERROR, TAG, "Method not supported");
541 OIC_LOG_V(DEBUG, TAG, "OUT : CAGenerateOwnerPSK");
545 CAResult_t CAInitiateHandshake(const CAEndpoint_t *endpoint)
547 OIC_LOG_V(DEBUG, TAG, "IN : CAInitiateHandshake");
548 CAResult_t res = CA_STATUS_FAILED;
549 #if defined (__WITH_DTLS__) || defined(__WITH_TLS__)
552 return CA_STATUS_INVALID_PARAM;
555 res = CAinitiateSslHandshake(endpoint);
556 if (CA_STATUS_OK != res)
558 OIC_LOG_V(ERROR, TAG, "Failed to CAinitiateSslHandshake : %d", res);
561 OIC_LOG(ERROR, TAG, "Method not supported");
563 OIC_LOG_V(DEBUG, TAG, "OUT : CAInitiateHandshake");
567 CAResult_t CAcloseSslSession(const CAEndpoint_t *endpoint)
569 OIC_LOG_V(DEBUG, TAG, "IN : CAcloseSslSession");
570 CAResult_t res = CA_STATUS_FAILED;
571 #if defined (__WITH_DTLS__) || defined(__WITH_TLS__)
574 return CA_STATUS_INVALID_PARAM;
577 res = CAcloseSslConnection(endpoint);
578 if (CA_STATUS_OK != res)
580 OIC_LOG_V(ERROR, TAG, "Failed to CAsslClose : %d", res);
583 OIC_LOG(ERROR, TAG, "Method not supported");
585 OIC_LOG_V(DEBUG, TAG, "OUT : CAcloseSslSession");
590 void CARegisterKeepAliveHandler(CAKeepAliveConnectionCallback ConnHandler)
592 CATCPSetKeepAliveCallbacks(ConnHandler);