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 <coap/utlist.h>
41 #include "caraadapter.h"
45 #include "catcpadapter.h"
48 #define TAG "OIC_CA_INF_CTR"
50 #define CA_MEMORY_ALLOC_CHECK(arg) {if (arg == NULL) \
51 {OIC_LOG(ERROR, TAG, "memory error");goto memory_error_exit;} }
53 static CAConnectivityHandler_t *g_adapterHandler = NULL;
55 static uint32_t g_numberOfAdapters = 0;
57 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
59 static CAErrorHandleCallback g_errorHandleCallback = NULL;
61 static struct CANetworkCallback_t * g_networkChangeCallbackList = NULL;
64 * network callback structure is handling
65 * for adapter state changed and connection state changed event.
67 typedef struct CANetworkCallback_t {
69 /** Linked list; for multiple callback list.*/
70 struct CANetworkCallback_t * next;
72 /** Adapter state changed event callback. */
73 CAAdapterStateChangedCB adapter;
75 /** Connection state changed event callback. */
76 CAConnectionStateChangedCB conn;
78 } CANetworkCallback_t;
80 static int CAGetAdapterIndex(CATransportAdapter_t cType)
82 for (uint32_t index=0 ; index < g_numberOfAdapters ; index++)
84 if (cType == g_adapterHandler[index].cType )
92 static void CARegisterCallback(CAConnectivityHandler_t handler)
94 if (handler.startAdapter == NULL ||
95 handler.startListenServer == NULL ||
96 handler.stopListenServer == NULL ||
97 handler.startDiscoveryServer == NULL ||
98 handler.sendData == NULL ||
99 handler.sendDataToAll == NULL ||
100 handler.GetnetInfo == NULL ||
101 handler.readData == NULL ||
102 handler.stopAdapter == NULL ||
103 handler.terminate == NULL)
105 OIC_LOG(ERROR, TAG, "connectivity handler is not enough to be used!");
108 uint32_t numberofAdapters = g_numberOfAdapters + 1;
109 CAConnectivityHandler_t *adapterHandler = OICRealloc(g_adapterHandler,
110 (numberofAdapters) * sizeof(*adapterHandler));
111 if (NULL == adapterHandler)
113 OIC_LOG(ERROR, TAG, "Memory allocation failed during registration");
116 g_adapterHandler = adapterHandler;
117 g_numberOfAdapters = numberofAdapters;
118 g_adapterHandler[g_numberOfAdapters-1] = handler;
120 OIC_LOG_V(DEBUG, TAG, "%d type adapter, register complete!", handler.cType);
124 * Add a network callback from caller to the network callback list
126 * @param adapterCB adapter state changed callback
127 * @param connCB connection state changed callback
132 static CAResult_t AddNetworkStateChangedCallback(CAAdapterStateChangedCB adapterCB,
133 CAConnectionStateChangedCB connCB)
135 OIC_LOG(DEBUG, TAG, "Add NetworkStateChanged Callback");
137 if (!adapterCB || !connCB)
139 OIC_LOG(ERROR, TAG, "parameter is null");
140 return CA_STATUS_INVALID_PARAM;
143 CANetworkCallback_t* callback = NULL;
144 LL_FOREACH(g_networkChangeCallbackList, callback)
146 if (callback && adapterCB == callback->adapter && connCB == callback->conn)
148 OIC_LOG(DEBUG, TAG, "this callback is already added");
153 callback = (CANetworkCallback_t *) OICCalloc(1, sizeof(CANetworkCallback_t));
154 if (NULL == callback)
156 OIC_LOG(ERROR, TAG, "Memory allocation failed during registration");
157 return CA_MEMORY_ALLOC_FAILED;
160 callback->adapter = adapterCB;
161 callback->conn = connCB;
162 LL_APPEND(g_networkChangeCallbackList, callback);
167 * Remove a network callback from the network callback list
169 * @param adapterCB adapter state changed callback
170 * @param connCB connection state changed callback
175 static CAResult_t RemoveNetworkStateChangedCallback(CAAdapterStateChangedCB adapterCB,
176 CAConnectionStateChangedCB connCB)
178 OIC_LOG(DEBUG, TAG, "Remove NetworkStateChanged Callback");
180 CANetworkCallback_t* callback = NULL;
181 LL_FOREACH(g_networkChangeCallbackList, callback)
183 if (callback && adapterCB == callback->adapter && connCB == callback->conn)
185 OIC_LOG(DEBUG, TAG, "remove specific callback");
186 LL_DELETE(g_networkChangeCallbackList, callback);
195 * Remove all network callback from the network callback list
197 static void RemoveAllNetworkStateChangedCallback()
199 OIC_LOG(DEBUG, TAG, "Remove All NetworkStateChanged Callback");
201 CANetworkCallback_t* callback = NULL;
202 LL_FOREACH(g_networkChangeCallbackList, callback)
204 OIC_LOG(DEBUG, TAG, "remove all callbacks");
205 LL_DELETE(g_networkChangeCallbackList, callback);
211 CAResult_t CASetAdapterRAInfo(const CARAInfo_t *caraInfo)
213 return CASetRAInfo(caraInfo);
217 static void CAReceivedPacketCallback(const CASecureEndpoint_t *sep,
218 const void *data, uint32_t dataLen)
220 if (g_networkPacketReceivedCallback != NULL)
222 g_networkPacketReceivedCallback(sep, data, dataLen);
226 OIC_LOG(ERROR, TAG, "network packet received callback is NULL!");
230 static void CAAdapterChangedCallback(CATransportAdapter_t adapter, CANetworkStatus_t status)
232 // Call the callback.
233 CANetworkCallback_t* callback = NULL;
234 LL_FOREACH(g_networkChangeCallbackList, callback)
236 if (callback && callback->adapter)
238 if (CA_INTERFACE_UP == status)
240 callback->adapter(adapter, true);
242 else if (CA_INTERFACE_DOWN == status)
244 callback->adapter(adapter, false);
248 OIC_LOG_V(DEBUG, TAG, "[%d] adapter status is changed to [%d]", adapter, status);
251 #if defined(TCP_ADAPTER) || defined(EDR_ADAPTER) || defined(LE_ADAPTER)
252 static void CAConnectionChangedCallback(const CAEndpoint_t *info, bool isConnected)
254 // Call the callback.
255 CANetworkCallback_t* callback = NULL;
256 LL_FOREACH(g_networkChangeCallbackList, callback)
258 if (callback && callback->conn)
260 callback->conn(info, isConnected);
263 OIC_LOG_V(DEBUG, TAG, "[%s] connection status is changed to [%d]", info->addr, isConnected);
267 static void CAAdapterErrorHandleCallback(const CAEndpoint_t *endpoint,
268 const void *data, uint32_t dataLen,
271 OIC_LOG(DEBUG, TAG, "received error from adapter in interfacecontroller");
273 // Call the callback.
274 if (g_errorHandleCallback != NULL)
276 g_errorHandleCallback(endpoint, data, dataLen, result);
280 void CAInitializeAdapters(ca_thread_pool_t handle)
282 OIC_LOG(DEBUG, TAG, "initialize adapters..");
284 // Initialize adapters and register callback.
286 CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
287 CAAdapterErrorHandleCallback, handle);
288 #endif /* IP_ADAPTER */
291 CAInitializeEDR(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
292 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
293 #endif /* EDR_ADAPTER */
296 CAInitializeLE(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
297 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
298 #endif /* LE_ADAPTER */
301 CAInitializeRA(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
303 #endif /* RA_ADAPTER */
306 CAInitializeTCP(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
307 CAConnectionChangedCallback, CAAdapterErrorHandleCallback, handle);
308 #endif /* TCP_ADAPTER */
311 CAInitializeNFC(CARegisterCallback, CAReceivedPacketCallback, CAAdapterChangedCallback,
312 CAAdapterErrorHandleCallback, handle);
313 #endif /* NFC_ADAPTER */
316 void CASetPacketReceivedCallback(CANetworkPacketReceivedCallback callback)
318 OIC_LOG(DEBUG, TAG, "Set Receiver handle callback");
320 g_networkPacketReceivedCallback = callback;
323 void CASetNetworkMonitorCallbacks(CAAdapterStateChangedCB adapterCB,
324 CAConnectionStateChangedCB connCB)
326 OIC_LOG(DEBUG, TAG, "Set network monitoring callback");
327 CAResult_t res = AddNetworkStateChangedCallback(adapterCB, connCB);
328 if (CA_STATUS_OK != res)
330 OIC_LOG(ERROR, TAG, "AddNetworkStateChangedCallback has failed");
334 CAResult_t CAUnsetNetworkMonitorCallbacks(CAAdapterStateChangedCB adapterCB,
335 CAConnectionStateChangedCB connCB)
337 OIC_LOG(DEBUG, TAG, "Unset network monitoring callback");
338 CAResult_t res = RemoveNetworkStateChangedCallback(adapterCB, connCB);
339 if (CA_STATUS_OK != res)
341 OIC_LOG(ERROR, TAG, "RemoveNetworkStateChangedCallback has failed");
346 void CASetErrorHandleCallback(CAErrorHandleCallback errorCallback)
348 OIC_LOG(DEBUG, TAG, "Set error handle callback");
349 g_errorHandleCallback = errorCallback;
352 CAResult_t CAStartAdapter(CATransportAdapter_t transportType)
354 OIC_LOG_V(DEBUG, TAG, "Start the adapter of CAConnectivityType[%d]", transportType);
356 int index = CAGetAdapterIndex(transportType);
359 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
360 return CA_STATUS_FAILED;
363 CAResult_t res = CA_STATUS_FAILED;
364 if (g_adapterHandler[index].startAdapter != NULL)
366 res = g_adapterHandler[index].startAdapter();
372 void CAStopAdapter(CATransportAdapter_t transportType)
374 OIC_LOG_V(DEBUG, TAG, "Stop the adapter of CATransportType[%d]", transportType);
376 int index = CAGetAdapterIndex(transportType);
379 OIC_LOG(ERROR, TAG, "unknown transport type!");
383 if (g_adapterHandler[index].stopAdapter != NULL)
385 g_adapterHandler[index].stopAdapter();
389 CAResult_t CAGetNetworkInfo(CAEndpoint_t **info, uint32_t *size)
391 if (info == NULL || size == NULL)
393 return CA_STATUS_INVALID_PARAM;
396 CAEndpoint_t **tempInfo = (CAEndpoint_t**) OICCalloc(g_numberOfAdapters, sizeof(*tempInfo));
399 OIC_LOG(ERROR, TAG, "Out of memory!");
400 return CA_MEMORY_ALLOC_FAILED;
402 uint32_t *tempSize =(uint32_t*) OICCalloc(g_numberOfAdapters, sizeof(*tempSize));
405 OIC_LOG(ERROR, TAG, "Out of memory!");
407 return CA_MEMORY_ALLOC_FAILED;
410 CAResult_t res = CA_STATUS_FAILED;
412 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
414 if (g_adapterHandler[index].GetnetInfo != NULL)
416 // #1. get information for each adapter
417 res = g_adapterHandler[index].GetnetInfo(&tempInfo[index],
421 if (res == CA_STATUS_OK)
423 resSize += tempSize[index];
428 "%" PRIu32 " adapter network info size is %" PRIu32 " res:%d",
435 OIC_LOG_V(DEBUG, TAG, "network info total size is %zu!", resSize);
441 if (res == CA_ADAPTER_NOT_ENABLED || res == CA_NOT_SUPPORTED)
447 return CA_STATUS_FAILED;
451 // #3. add data into result
453 CAEndpoint_t *resInfo = (CAEndpoint_t *) OICCalloc(resSize, sizeof (*resInfo));
454 CA_MEMORY_ALLOC_CHECK(resInfo);
460 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
463 if (tempSize[index] == 0)
470 sizeof(*resInfo) * tempSize[index]);
472 resInfo += tempSize[index];
475 OICFree(tempInfo[index]);
476 tempInfo[index] = NULL;
481 OIC_LOG(DEBUG, TAG, "each network info save success!");
484 // memory error label.
487 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
489 OICFree(tempInfo[index]);
490 tempInfo[index] = NULL;
495 return CA_MEMORY_ALLOC_FAILED;
498 CAResult_t CASendUnicastData(const CAEndpoint_t *endpoint, const void *data, uint32_t length,
499 CADataType_t dataType)
501 if (endpoint == NULL)
503 OIC_LOG(DEBUG, TAG, "Invalid endpoint");
504 return CA_STATUS_INVALID_PARAM;
508 u_arraylist_t *list = CAGetSelectedNetworkList();
511 OIC_LOG(ERROR, TAG, "No selected network");
512 return CA_SEND_FAILED;
514 CATransportAdapter_t requestedAdapter = endpoint->adapter ? endpoint->adapter : CA_ALL_ADAPTERS;
516 for (uint32_t i = 0; i < u_arraylist_length(list); i++)
518 void* ptrType = u_arraylist_get(list, i);
525 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
526 if (0 == (connType & requestedAdapter))
531 int index = CAGetAdapterIndex(connType);
535 OIC_LOG(ERROR, TAG, "unknown transport type!");
536 return CA_STATUS_INVALID_PARAM;
539 int32_t sentDataLen = 0;
541 if (NULL != g_adapterHandler[index].sendData)
543 OIC_LOG(DEBUG, TAG, "unicast message to adapter");
544 sentDataLen = g_adapterHandler[index].sendData(endpoint, data, length, dataType);
547 if (sentDataLen != (int32_t)length)
549 OIC_LOG(ERROR, TAG, "error in sending data. Error will be reported in adapter");
551 //in case of single thread, no error handler. Report error immediately
552 return CA_SEND_FAILED;
561 CAResult_t CASendMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t length,
562 CADataType_t dataType)
564 u_arraylist_t *list = CAGetSelectedNetworkList();
567 OIC_LOG(DEBUG, TAG, "No selected network");
568 return CA_SEND_FAILED;
571 CATransportAdapter_t requestedAdapter = endpoint->adapter ? endpoint->adapter : CA_ALL_ADAPTERS;
572 size_t selectedLength = u_arraylist_length(list);
573 for (size_t i = 0; i < selectedLength; i++)
575 void* ptrType = u_arraylist_get(list, i);
582 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
583 if (0 == (connType & requestedAdapter))
588 int index = CAGetAdapterIndex(connType);
591 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
595 uint32_t sentDataLen = 0;
597 if (NULL != g_adapterHandler[index].sendDataToAll)
599 void *payload = (void *) OICMalloc(length);
602 OIC_LOG(ERROR, TAG, "Out of memory!");
603 return CA_MEMORY_ALLOC_FAILED;
605 memcpy(payload, data, length);
606 sentDataLen = g_adapterHandler[index].sendDataToAll(endpoint, payload, length, dataType);
610 if (sentDataLen != length)
612 OIC_LOG(ERROR, TAG, "sendDataToAll failed! Error will be reported from adapter");
614 //in case of single thread, no error handler. Report error immediately
615 return CA_SEND_FAILED;
623 CAResult_t CAStartListeningServerAdapters()
625 CAResult_t result = CA_STATUS_FAILED;
627 u_arraylist_t *list = CAGetSelectedNetworkList();
630 OIC_LOG(ERROR, TAG, "No selected network");
634 size_t length = u_arraylist_length(list);
635 for (size_t i = 0; i < length; i++)
637 void* ptrType = u_arraylist_get(list, i);
644 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
646 int index = CAGetAdapterIndex(connType);
649 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
653 if (g_adapterHandler[index].startListenServer != NULL)
655 const CAResult_t tmp =
656 g_adapterHandler[index].startListenServer();
658 // Successful listen if at least one adapter started.
659 if (CA_STATUS_OK == tmp)
669 CAResult_t CAStopListeningServerAdapters()
671 u_arraylist_t *list = CAGetSelectedNetworkList();
674 OIC_LOG(ERROR, TAG, "No selected network");
675 return CA_STATUS_FAILED;
678 size_t length = u_arraylist_length(list);
679 for (size_t i = 0; i < length; i++)
681 void* ptrType = u_arraylist_get(list, i);
687 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
689 int index = CAGetAdapterIndex(connType);
692 OIC_LOG(ERROR, TAG, "unknown connectivity type!");
696 if (g_adapterHandler[index].stopListenServer != NULL)
698 g_adapterHandler[index].stopListenServer();
705 CAResult_t CAStartDiscoveryServerAdapters()
707 CAResult_t result = CA_STATUS_FAILED;
709 u_arraylist_t *list = CAGetSelectedNetworkList();
713 OIC_LOG(ERROR, TAG, "No selected network");
717 size_t length = u_arraylist_length(list);
718 for (size_t i = 0; i < length; i++)
720 void* ptrType = u_arraylist_get(list, i);
727 CATransportAdapter_t connType = *(CATransportAdapter_t *)ptrType;
729 int index = CAGetAdapterIndex(connType);
732 OIC_LOG(DEBUG, TAG, "unknown connectivity type!");
736 if (g_adapterHandler[index].startDiscoveryServer != NULL)
738 const CAResult_t tmp =
739 g_adapterHandler[index].startDiscoveryServer();
741 // Successful discovery if at least one adapter started.
742 if (CA_STATUS_OK == tmp)
752 void CATerminateAdapters()
754 for (uint32_t index = 0; index < g_numberOfAdapters; index++)
756 if (g_adapterHandler[index].terminate != NULL)
758 g_adapterHandler[index].terminate();
762 OICFree(g_adapterHandler);
763 g_adapterHandler = NULL;
764 g_numberOfAdapters = 0;
768 CAResult_t CAReadData()
770 u_arraylist_t *list = CAGetSelectedNetworkList();
774 return CA_STATUS_FAILED;
778 for (i = 0; i < u_arraylist_length(list); i++)
780 void *ptrType = u_arraylist_get(list, i);
783 OIC_LOG(ERROR, TAG, "get list fail");
784 return CA_STATUS_FAILED;
787 CATransportAdapter_t connType = *(CATransportAdapter_t *) ptrType;
789 int index = CAGetAdapterIndex(connType);
792 OIC_LOG(DEBUG, TAG, "unknown connectivity type!");
796 if (g_adapterHandler[index].readData != NULL)
798 g_adapterHandler[index].readData();