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 "oic_malloc.h"
28 #include "caadapterutils.h"
29 #include "canetworkconfigurator.h"
30 #include "cainterfacecontroller.h"
31 #include "caedradapter.h"
32 #include "caleadapter.h"
33 #include "canfcadapter.h"
34 #include "caremotehandler.h"
35 #include "cathreadpool.h"
36 #include "caipadapter.h"
37 #include "cainterface.h"
38 #include "caipinterface.h"
39 #include <coap/utlist.h>
42 #include "caraadapter.h"
46 #include "catcpadapter.h"
49 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
50 #include "ca_adapter_net_ssl.h"
53 #define TAG "OIC_CA_INF_CTR"
55 #define CA_MEMORY_ALLOC_CHECK(arg) {if (arg == NULL) \
56 {OIC_LOG(ERROR, TAG, "memory error");goto memory_error_exit;} }
58 static CAConnectivityHandler_t *g_adapterHandler = NULL;
60 static uint32_t g_numberOfAdapters = 0;
62 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
64 static CAErrorHandleCallback g_errorHandleCallback = NULL;
66 static struct CANetworkCallback_t * g_networkChangeCallbackList = NULL;
69 * network callback structure is handling
70 * for adapter state changed and connection state changed event.
72 typedef struct CANetworkCallback_t {
74 /** Linked list; for multiple callback list.*/
75 struct CANetworkCallback_t * next;
77 /** Adapter state changed event callback. */
78 CAAdapterStateChangedCB adapter;
80 /** Connection state changed event callback. */
81 CAConnectionStateChangedCB conn;
83 } CANetworkCallback_t;
85 static int CAGetAdapterIndex(CATransportAdapter_t cType)
87 for (uint32_t index=0 ; index < g_numberOfAdapters ; index++)
89 if (cType == g_adapterHandler[index].cType )
94 OIC_LOG_V(ERROR, TAG, "adapter info [%d]", g_numberOfAdapters);
98 static void CARegisterCallback(CAConnectivityHandler_t handler)
100 if (handler.startAdapter == NULL ||
101 handler.startListenServer == NULL ||
102 handler.stopListenServer == NULL ||
103 handler.startDiscoveryServer == NULL ||
104 handler.sendData == NULL ||
105 handler.sendDataToAll == NULL ||
106 handler.GetnetInfo == NULL ||
107 handler.readData == NULL ||
108 handler.stopAdapter == NULL ||
109 handler.terminate == NULL)
111 OIC_LOG(ERROR, TAG, "connectivity handler is not enough to be used!");
114 uint32_t numberofAdapters = g_numberOfAdapters + 1;
115 CAConnectivityHandler_t *adapterHandler = OICRealloc(g_adapterHandler,
116 (numberofAdapters) * sizeof(*adapterHandler));
117 if (NULL == adapterHandler)
119 OIC_LOG(ERROR, TAG, "Memory allocation failed during registration");
122 g_adapterHandler = adapterHandler;
123 g_numberOfAdapters = numberofAdapters;
124 g_adapterHandler[g_numberOfAdapters-1] = handler;
126 OIC_LOG_V(DEBUG, TAG, "%d type adapter, register complete!", handler.cType);
130 * Add a network callback from caller to the network callback list
132 * @param adapterCB adapter state changed callback
133 * @param connCB connection state changed callback
138 static CAResult_t AddNetworkStateChangedCallback(CAAdapterStateChangedCB adapterCB,
139 CAConnectionStateChangedCB connCB)
141 OIC_LOG(DEBUG, TAG, "Add NetworkStateChanged Callback");
143 if (!adapterCB || !connCB)
145 OIC_LOG(ERROR, TAG, "parameter is null");
146 return CA_STATUS_INVALID_PARAM;
149 CANetworkCallback_t* callback = NULL;
150 LL_FOREACH(g_networkChangeCallbackList, callback)
152 if (callback && adapterCB == callback->adapter && connCB == callback->conn)
154 OIC_LOG(DEBUG, TAG, "this callback is already added");
159 callback = (CANetworkCallback_t *) OICCalloc(1, sizeof(CANetworkCallback_t));
160 if (NULL == callback)
162 OIC_LOG(ERROR, TAG, "Memory allocation failed during registration");
163 return CA_MEMORY_ALLOC_FAILED;
166 callback->adapter = adapterCB;
167 callback->conn = connCB;
168 LL_APPEND(g_networkChangeCallbackList, callback);
169 OIC_LOG_V(INFO, TAG, "Added NetworkStateChanged Callback [%p]", callback);
175 * Remove a network callback from the network callback list
177 * @param adapterCB adapter state changed callback
178 * @param connCB connection state changed callback
183 static CAResult_t RemoveNetworkStateChangedCallback(CAAdapterStateChangedCB adapterCB,
184 CAConnectionStateChangedCB connCB)
186 OIC_LOG(DEBUG, TAG, "Remove NetworkStateChanged Callback");
188 CANetworkCallback_t* callback = NULL;
189 LL_FOREACH(g_networkChangeCallbackList, callback)
191 if (callback && adapterCB == callback->adapter && connCB == callback->conn)
193 OIC_LOG(DEBUG, TAG, "remove specific callback");
194 LL_DELETE(g_networkChangeCallbackList, callback);
203 CAResult_t CASetAdapterRAInfo(const CARAInfo_t *caraInfo)
205 return CASetRAInfo(caraInfo);
209 static CAResult_t CAReceivedPacketCallback(const CASecureEndpoint_t *sep,
210 const void *data, uint32_t dataLen)
212 if (g_networkPacketReceivedCallback != NULL)
214 return g_networkPacketReceivedCallback(sep, data, dataLen);
218 OIC_LOG(INFO, TAG, "network packet received callback is NULL!");
223 static void CAAdapterChangedCallback(CATransportAdapter_t adapter, CANetworkStatus_t status)
225 // Call the callback.
226 CANetworkCallback_t* callback = NULL;
227 LL_FOREACH(g_networkChangeCallbackList, callback)
229 if (callback && callback->adapter)
231 OIC_LOG_V(INFO, TAG, "IN application adapter changed callback [%p]", callback);
232 if (CA_INTERFACE_UP == status)
234 callback->adapter(adapter, true);
236 else if (CA_INTERFACE_DOWN == status)
238 callback->adapter(adapter, false);
240 OIC_LOG_V(INFO, TAG, "OUT application adapter changed callback [%p]", callback);
243 OIC_LOG_V(DEBUG, TAG, "[%d] adapter status is changed to [%d]", adapter, status);
246 #if defined(TCP_ADAPTER) || defined(EDR_ADAPTER) || defined(LE_ADAPTER)
247 static void CAConnectionChangedCallback(const CAEndpoint_t *info, bool isConnected)
249 // Call the callback.
250 CANetworkCallback_t* callback = NULL;
251 LL_FOREACH(g_networkChangeCallbackList, callback)
253 if (callback && callback->conn)
255 callback->conn(info, isConnected);
258 OIC_LOG_V(DEBUG, TAG, "[%s] connection status is changed to [%d]", info->addr, isConnected);
262 static void CAAdapterErrorHandleCallback(const CAEndpoint_t *endpoint,
263 const void *data, uint32_t dataLen,
266 OIC_LOG(DEBUG, TAG, "received error from adapter in interfacecontroller");
268 // Call the callback.
269 if (g_errorHandleCallback != NULL)
271 g_errorHandleCallback(endpoint, data, dataLen, result);
275 void CAInitializeAdapters(ca_thread_pool_t handle, CATransportAdapter_t transportType)
277 OIC_LOG_V(DEBUG, TAG, "initialize adapters %d", transportType);
279 // Initialize ssl adapter.
280 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
281 if (CA_STATUS_OK != CAinitSslAdapter())
283 OIC_LOG(ERROR, TAG, "Failed to init SSL adapter");
287 // Initialize adapters and register callback.
289 if ((transportType & CA_ADAPTER_IP) || (CA_DEFAULT_ADAPTER == transportType)
290 || (transportType == CA_ALL_ADAPTERS))
292 CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
293 CAAdapterErrorHandleCallback, handle);
295 #endif /* IP_ADAPTER */
298 if ((transportType & CA_ADAPTER_RFCOMM_BTEDR) || (CA_DEFAULT_ADAPTER == transportType)
299 || (transportType == CA_ALL_ADAPTERS))
301 CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
302 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
304 #endif /* EDR_ADAPTER */
307 if ((transportType & CA_ADAPTER_GATT_BTLE) || (CA_DEFAULT_ADAPTER == transportType)
308 || (transportType == CA_ALL_ADAPTERS))
310 CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
311 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
313 #endif /* LE_ADAPTER */
316 if ((transportType & CA_ADAPTER_REMOTE_ACCESS) || (CA_DEFAULT_ADAPTER == transportType)
317 || (transportType == CA_ALL_ADAPTERS))
319 CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
322 #endif /* RA_ADAPTER */
325 if ((transportType & CA_ADAPTER_TCP) || (CA_DEFAULT_ADAPTER == transportType)
326 || (transportType == CA_ALL_ADAPTERS))
328 CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
329 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
331 #endif /* TCP_ADAPTER */
334 if ((transportType & CA_ADAPTER_NFC) || (CA_DEFAULT_ADAPTER == transportType)
335 || (transportType == CA_ALL_ADAPTERS))
337 CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
338 CAAdapterErrorHandleCallback, handle);
340 #endif /* NFC_ADAPTER */
343 void CASetPacketReceivedCallback(CANetworkPacketReceivedCallback callback)
345 OIC_LOG(DEBUG, TAG, "Set Receiver handle callback");
347 g_networkPacketReceivedCallback = callback;
350 void CASetNetworkMonitorCallbacks(CAAdapterStateChangedCB adapterCB,
351 CAConnectionStateChangedCB connCB)
353 OIC_LOG(DEBUG, TAG, "Set network monitoring callback");
354 CAResult_t res = AddNetworkStateChangedCallback(adapterCB, connCB);
355 if (CA_STATUS_OK != res)
357 OIC_LOG(ERROR, TAG, "AddNetworkStateChangedCallback has failed");
361 CAResult_t CAUnsetNetworkMonitorCallbacks(CAAdapterStateChangedCB adapterCB,
362 CAConnectionStateChangedCB connCB)
364 OIC_LOG(DEBUG, TAG, "Unset network monitoring callback");
365 CAResult_t res = RemoveNetworkStateChangedCallback(adapterCB, connCB);
366 if (CA_STATUS_OK != res)
368 OIC_LOG(ERROR, TAG, "RemoveNetworkStateChangedCallback has failed");
373 void CASetErrorHandleCallback(CAErrorHandleCallback errorCallback)
375 OIC_LOG(DEBUG, TAG, "Set error handle callback");
376 g_errorHandleCallback = errorCallback;
379 CAResult_t CAStartAdapter(CATransportAdapter_t transportType)
381 OIC_LOG_V(DEBUG, TAG, "Start the adapter of CAConnectivityType[%d]", transportType);
383 int index = CAGetAdapterIndex(transportType);
386 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
387 return CA_STATUS_FAILED;
390 CAResult_t res = CA_STATUS_FAILED;
391 if (g_adapterHandler[index].startAdapter != NULL)
393 res = g_adapterHandler[index].startAdapter();
399 void CAStopAdapter(CATransportAdapter_t transportType)
401 OIC_LOG_V(DEBUG, TAG, "Stop the adapter of CATransportType[%d]", transportType);
403 int index = CAGetAdapterIndex(transportType);
406 OIC_LOG(ERROR, TAG, "unknown transport type!");
410 if (g_adapterHandler[index].stopAdapter != NULL)
412 g_adapterHandler[index].stopAdapter();
416 CAResult_t CAGetNetworkInfo(CAEndpoint_t **info, uint32_t *size)
418 if (info == NULL || size == NULL)
420 return CA_STATUS_INVALID_PARAM;
423 CAEndpoint_t **tempInfo = (CAEndpoint_t**) OICCalloc(g_numberOfAdapters, sizeof(*tempInfo));
426 OIC_LOG(ERROR, TAG, "Out of memory!");
427 return CA_MEMORY_ALLOC_FAILED;
429 uint32_t *tempSize =(uint32_t*) OICCalloc(g_numberOfAdapters, sizeof(*tempSize));
432 OIC_LOG(ERROR, TAG, "Out of memory!");
434 return CA_MEMORY_ALLOC_FAILED;
437 CAResult_t res = CA_STATUS_FAILED;
439 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
441 if (g_adapterHandler[index].GetnetInfo != NULL)
443 // #1. get information for each adapter
444 res = g_adapterHandler[index].GetnetInfo(&tempInfo[index],
448 if (res == CA_STATUS_OK)
450 resSize += tempSize[index];
456 "%" PRIu32 " adapter network info size is %" PRIu32 " res:%d",
464 OIC_LOG_V(DEBUG, TAG, "network info total size is %zu!", resSize);
470 if (res == CA_ADAPTER_NOT_ENABLED || res == CA_NOT_SUPPORTED)
476 return CA_STATUS_FAILED;
480 // #3. add data into result
482 CAEndpoint_t *resInfo = (CAEndpoint_t *) OICCalloc(resSize, sizeof (*resInfo));
483 CA_MEMORY_ALLOC_CHECK(resInfo);
489 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
492 if (tempSize[index] == 0)
499 sizeof(*resInfo) * tempSize[index]);
501 resInfo += tempSize[index];
504 OICFree(tempInfo[index]);
505 tempInfo[index] = NULL;
510 OIC_LOG(DEBUG, TAG, "each network info save success!");
513 // memory error label.
516 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
518 OICFree(tempInfo[index]);
519 tempInfo[index] = NULL;
524 return CA_MEMORY_ALLOC_FAILED;
527 CAResult_t CASendUnicastData(const CAEndpoint_t *endpoint, const void *data, uint32_t length,
528 CADataType_t dataType)
530 if (endpoint == NULL)
532 OIC_LOG(DEBUG, TAG, "Invalid endpoint");
533 return CA_STATUS_INVALID_PARAM;
537 u_arraylist_t *list = CAGetSelectedNetworkList();
540 OIC_LOG(ERROR, TAG, "No selected network");
541 return CA_SEND_FAILED;
543 CATransportAdapter_t requestedAdapter = endpoint->adapter ? endpoint->adapter : CA_ALL_ADAPTERS;
545 for (uint32_t i = 0; i < u_arraylist_length(list); i++)
547 void* ptrType = u_arraylist_get(list, i);
554 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
555 if (0 == (connType & requestedAdapter))
560 int index = CAGetAdapterIndex(connType);
564 OIC_LOG_V(ERROR, TAG, "unknown transport type[%d]", connType);
565 return CA_STATUS_INVALID_PARAM;
568 int32_t sentDataLen = 0;
570 if (NULL != g_adapterHandler[index].sendData)
572 OIC_LOG(DEBUG, TAG, "unicast message to adapter");
573 sentDataLen = g_adapterHandler[index].sendData(endpoint, data, length, dataType);
576 if (sentDataLen != (int32_t)length)
578 OIC_LOG(ERROR, TAG, "error in sending data. Error will be reported in adapter");
580 //in case of single thread, no error handler. Report error immediately
581 return CA_SEND_FAILED;
590 CAResult_t CASendMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t length,
591 CADataType_t dataType)
593 u_arraylist_t *list = CAGetSelectedNetworkList();
596 OIC_LOG(DEBUG, TAG, "No selected network");
597 return CA_SEND_FAILED;
600 CATransportAdapter_t requestedAdapter = endpoint->adapter ? endpoint->adapter : CA_ALL_ADAPTERS;
601 size_t selectedLength = u_arraylist_length(list);
602 for (size_t i = 0; i < selectedLength; i++)
604 void* ptrType = u_arraylist_get(list, i);
611 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
612 if (0 == (connType & requestedAdapter))
617 int index = CAGetAdapterIndex(connType);
620 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
624 uint32_t sentDataLen = 0;
626 if (NULL != g_adapterHandler[index].sendDataToAll)
628 void *payload = (void *) OICMalloc(length);
631 OIC_LOG(ERROR, TAG, "Out of memory!");
632 return CA_MEMORY_ALLOC_FAILED;
634 memcpy(payload, data, length);
635 sentDataLen = g_adapterHandler[index].sendDataToAll(endpoint, payload, length, dataType);
639 if (sentDataLen != length)
641 OIC_LOG(ERROR, TAG, "sendDataToAll failed! Error will be reported from adapter");
643 //in case of single thread, no error handler. Report error immediately
644 return CA_SEND_FAILED;
652 CAResult_t CAStartListeningServerAdapters()
654 CAResult_t result = CA_STATUS_FAILED;
656 u_arraylist_t *list = CAGetSelectedNetworkList();
659 OIC_LOG(ERROR, TAG, "No selected network");
663 size_t length = u_arraylist_length(list);
664 for (size_t i = 0; i < length; i++)
666 void* ptrType = u_arraylist_get(list, i);
673 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
675 int index = CAGetAdapterIndex(connType);
678 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
682 if (g_adapterHandler[index].startListenServer != NULL)
684 const CAResult_t tmp =
685 g_adapterHandler[index].startListenServer();
687 // Successful listen if at least one adapter started.
688 if (CA_STATUS_OK == tmp)
698 CAResult_t CAStopListeningServerAdapters()
700 u_arraylist_t *list = CAGetSelectedNetworkList();
703 OIC_LOG(ERROR, TAG, "No selected network");
704 return CA_STATUS_FAILED;
707 size_t length = u_arraylist_length(list);
708 for (size_t i = 0; i < length; i++)
710 void* ptrType = u_arraylist_get(list, i);
716 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
718 int index = CAGetAdapterIndex(connType);
721 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
725 if (g_adapterHandler[index].stopListenServer != NULL)
727 g_adapterHandler[index].stopListenServer();
734 CAResult_t CAStartDiscoveryServerAdapters()
736 CAResult_t result = CA_STATUS_FAILED;
738 u_arraylist_t *list = CAGetSelectedNetworkList();
742 OIC_LOG(ERROR, TAG, "No selected network");
746 size_t length = u_arraylist_length(list);
747 for (size_t i = 0; i < length; i++)
749 void* ptrType = u_arraylist_get(list, i);
756 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
758 int index = CAGetAdapterIndex(connType);
761 OIC_LOG(DEBUG, TAG, "unknown connectivity type!");
765 if (g_adapterHandler[index].startDiscoveryServer != NULL)
767 const CAResult_t tmp =
768 g_adapterHandler[index].startDiscoveryServer();
770 // Successful discovery if at least one adapter started.
771 if (CA_STATUS_OK == tmp)
781 void CATerminateAdapters()
783 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
785 if (g_adapterHandler[index].terminate != NULL)
787 g_adapterHandler[index].terminate();
791 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
792 CAdeinitSslAdapter();
795 OICFree(g_adapterHandler);
796 g_adapterHandler = NULL;
797 g_numberOfAdapters = 0;
801 CAResult_t CAReadData()
803 u_arraylist_t *list = CAGetSelectedNetworkList();
807 return CA_STATUS_FAILED;
811 for (i = 0; i < u_arraylist_length(list); i++)
813 void *ptrType = u_arraylist_get(list, i);
816 OIC_LOG(ERROR, TAG, "get list fail");
817 return CA_STATUS_FAILED;
820 CATransportAdapter_t connType = *(CATransportAdapter_t *) ptrType;
822 int index = CAGetAdapterIndex(connType);
825 OIC_LOG(DEBUG, TAG, "unknown connectivity type!");
829 if (g_adapterHandler[index].readData != NULL)
831 g_adapterHandler[index].readData();
840 CAResult_t CASetMulticastTTL(size_t ttl)
842 return CAIPSetMulticastTTL(ttl);
845 CAResult_t CAGetMulticastTTL(size_t *ttl)
847 return CAIPGetMulticastTTL(ttl);
852 CAResult_t CADisconnectSession(const CAEndpoint_t *endpoint)
854 return CATCPDisconnectSession(endpoint);
859 void CAStartGattServer()
861 CALEStartGattServer();
864 void CAStopGattServer()
866 CALEStopGattServer();