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 ******************************************************************/
20 #include "caipadapter.h"
27 #include "caipinterface.h"
28 #include "caqueueingthread.h"
29 #include "caadapterutils.h"
31 #include "caadapternetdtls.h"
34 #include "uarraylist.h"
35 #include "caremotehandler.h"
37 #include "oic_malloc.h"
38 #include "oic_string.h"
42 * @brief Logging tag for module name
44 #define IP_ADAPTER_TAG "IPAD"
48 * @brief Port to listen for incoming data
58 * @brief Secured (unicast) port number as defined in COAP Specification, RFC-7252.
60 #define CA_SECURE_PORT 5684
64 * @brief Multicast port number as defined in COAP Specification, RFC-7252.
66 #define CA_MCAST_PORT 5683
69 * @def CA_MULTICAST_IP
70 * @brief Multicast IP Address as defined in COAP Specification, RFC-7252.
72 #define CA_MULTICAST_IP "224.0.1.187"
77 * @brief Holds inter thread ip data information.
81 CAEndpoint_t *remoteEndpoint;
88 * @var g_sendQueueHandle
89 * @brief Queue handle for Send Data
91 static CAQueueingThread_t *g_sendQueueHandle = NULL;
95 * @var g_networkPacketCallback
96 * @brief Network Packet Received Callback to CA
98 static CANetworkPacketReceivedCallback g_networkPacketCallback = NULL;
101 * @var g_networkChangeCallback
102 * @brief Network Changed Callback to CA
104 static CANetworkChangeCallback g_networkChangeCallback = NULL;
107 * @var g_errorCallback
108 * @brief error Callback to CA adapter
110 static CAErrorHandleCallback g_errorCallback = NULL;
114 * @brief ThreadPool for storing ca_thread_pool_t handle passed from CA
116 static ca_thread_pool_t g_threadPool = NULL;
118 static void CAIPNotifyNetworkChange(const char *address, uint16_t port,
119 CANetworkStatus_t status);
121 static void CAIPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status);
123 static void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint,
124 const void *data, uint32_t dataLength);
125 static void CAIPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
126 uint32_t dataLength, CAResult_t result);
128 static uint32_t CAIPPacketSendCB(const CAEndpoint_t *endpoint,
129 const void *data, uint32_t dataLength);
132 static CAResult_t CAIPStopServers();
134 #ifndef SINGLE_THREAD
136 static CAResult_t CAIPInitializeQueueHandles();
138 static void CAIPDeinitializeQueueHandles();
140 static void CAIPSendDataThread(void *threadData);
142 static CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint,
143 const void *data, uint32_t dataLength, bool isMulticast);
144 void CAFreeIPData(CAIPData *ipData);
146 static void CADataDestroyer(void *data, uint32_t size);
148 CAResult_t CAIPInitializeQueueHandles()
150 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
152 // Check if the message queue is already initialized
153 if (g_sendQueueHandle)
155 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "send queue handle is already initialized!");
159 // Create send message queue
160 g_sendQueueHandle = OICMalloc(sizeof(CAQueueingThread_t));
161 if (!g_sendQueueHandle)
163 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory allocation failed!");
164 return CA_MEMORY_ALLOC_FAILED;
167 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_threadPool,
168 CAIPSendDataThread, CADataDestroyer))
170 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Failed to Initialize send queue thread");
171 OICFree(g_sendQueueHandle);
172 g_sendQueueHandle = NULL;
173 return CA_STATUS_FAILED;
176 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
180 void CAIPDeinitializeQueueHandles()
182 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
184 CAQueueingThreadDestroy(g_sendQueueHandle);
185 OICFree(g_sendQueueHandle);
186 g_sendQueueHandle = NULL;
188 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
191 void CAIPSendDataThread(void *threadData)
193 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
195 CAIPData *ipData = (CAIPData *) threadData;
196 uint32_t sentData = -1;
200 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Invalid ip data!");
204 if (ipData->isMulticast)
206 //Processing for sending multicast
207 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Send Multicast Data is called");
208 strncpy(ipData->remoteEndpoint->addr, CA_MULTICAST_IP, MAX_ADDR_STR_SIZE_CA);
209 ipData->remoteEndpoint->port = CA_MCAST_PORT;
210 sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, true);
214 //Processing for sending unicast
216 if (ipData->remoteEndpoint->flags & CA_SECURE)
218 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "CAAdapterNetDtlsEncrypt called!");
219 CAResult_t result = CAAdapterNetDtlsEncrypt(ipData->remoteEndpoint,
220 ipData->data, ipData->dataLen);
221 if (CA_STATUS_OK != result)
223 OIC_LOG(ERROR, IP_ADAPTER_TAG, "CAAdapterNetDtlsEncrypt failed!");
226 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG,
227 "CAAdapterNetDtlsEncrypt returned with result[%d]", result);
231 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Send Unicast Data is called");
232 sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
235 sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
241 g_errorCallback(ipData->remoteEndpoint, ipData->data, ipData->dataLen,
245 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
248 CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
249 uint32_t dataLength, bool isMulticast)
251 VERIFY_NON_NULL_RET(data, IP_ADAPTER_TAG, "IPData is NULL", NULL);
253 CAIPData *ipData = (CAIPData *) OICMalloc(sizeof(CAIPData));
256 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory allocation failed!");
260 ipData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
261 ipData->data = (void *) OICMalloc(dataLength);
264 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory allocation failed!");
265 CAFreeIPData(ipData);
269 memcpy(ipData->data, data, dataLength);
270 ipData->dataLen = dataLength;
272 ipData->isMulticast = isMulticast;
277 void CAFreeIPData(CAIPData *ipData)
279 VERIFY_NON_NULL_VOID(ipData, IP_ADAPTER_TAG, "ipData is NULL");
281 CAFreeEndpoint(ipData->remoteEndpoint);
282 OICFree(ipData->data);
286 void CADataDestroyer(void *data, uint32_t size)
288 CAIPData *etdata = (CAIPData *) data;
290 CAFreeIPData(etdata);
294 void CAIPNotifyNetworkChange(const char *address, uint16_t port, CANetworkStatus_t status)
296 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
298 VERIFY_NON_NULL_VOID(address, IP_ADAPTER_TAG, "address is NULL");
300 CAEndpoint_t *localEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
305 OIC_LOG(ERROR, IP_ADAPTER_TAG, "localEndpoint creation failed!");
309 if (g_networkChangeCallback)
311 g_networkChangeCallback(localEndpoint, status);
315 OIC_LOG(ERROR, IP_ADAPTER_TAG, "g_networkChangeCallback is NULL");
318 CAFreeEndpoint(localEndpoint);
320 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
323 void CAIPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status)
325 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
327 VERIFY_NON_NULL_VOID(ipAddress, IP_ADAPTER_TAG, "ipAddress is NULL");
329 if (CA_INTERFACE_UP == status)
331 uint16_t port = CA_PORT;
332 CAResult_t ret = CAIPStartUnicastServer(ipAddress, &port, false);
333 if (CA_STATUS_OK == ret)
335 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Unicast server started on %d port", port);
339 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to start Unicast server port[%d]", ret);
343 port = CA_SECURE_PORT;
344 ret = CAIPStartUnicastServer(ipAddress, &port, true);
345 if (CA_STATUS_OK == ret)
347 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Secure Unicast server started on %d", port);
351 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to start secure Unicast server [%d]",
355 ret = CAIPStartMulticastServer(ipAddress, CA_MULTICAST_IP, CA_MCAST_PORT);
356 if (CA_STATUS_OK == ret)
358 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Multicast server started on port[%d]",
363 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to start Multicast server port[%d]",
367 // Notify network change to CA
368 CAIPNotifyNetworkChange(ipAddress, port, status);
372 CAIPNotifyNetworkChange(ipAddress, 0, status);
374 // Stop Unicast, Secured unicast and Multicast servers
375 CAIPStopServer(ipAddress);
378 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
382 uint32_t CAIPPacketSendCB(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
384 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
386 VERIFY_NON_NULL_RET(endpoint, IP_ADAPTER_TAG, "endpoint is NULL", 0);
387 VERIFY_NON_NULL_RET(data, IP_ADAPTER_TAG, "data is NULL", 0);
389 uint32_t sentLength = CAIPSendData(endpoint, data, dataLength, false);
393 g_errorCallback(endpoint, data, dataLength, CA_SEND_FAILED);
396 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Successfully sent %d of encrypted data!", sentLength);
398 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
404 void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint, const void *data,
407 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
409 VERIFY_NON_NULL_VOID(endpoint, IP_ADAPTER_TAG, "ipAddress is NULL");
410 VERIFY_NON_NULL_VOID(data, IP_ADAPTER_TAG, "data is NULL");
412 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Address: %s, port:%d", endpoint->addr, endpoint->port);
414 void *buf = OICCalloc(dataLength + 1, sizeof (char));
417 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory Allocation failed!");
420 memcpy(buf, data, dataLength);
422 if (g_networkPacketCallback)
424 g_networkPacketCallback(endpoint, buf, dataLength);
430 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
433 void CAIPErrorHandler (const CAEndpoint_t *endpoint, const void *data,
434 uint32_t dataLength, CAResult_t result)
436 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
438 VERIFY_NON_NULL_VOID(endpoint, IP_ADAPTER_TAG, "endpoint is NULL");
440 VERIFY_NON_NULL_VOID(data, IP_ADAPTER_TAG, "data is NULL");
442 void *buf = (void*)OICMalloc(sizeof(char) * dataLength);
445 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory Allocation failed!");
448 memcpy(buf, data, dataLength);
451 g_errorCallback(endpoint, buf, dataLength, result);
458 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
463 int32_t CAIPSendDataInternal(const CAEndpoint_t *remoteEndpoint, const void *data,
464 uint32_t dataLength, bool isMulticast)
466 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
469 // If remoteEndpoint is NULL, its Multicast, else its Unicast.
472 CAIPSendData(remoteEndpoint, data, dataLength, false);
476 CAEndpoint_t ep = { 0 };
477 strcpy(ep.addr, CA_MULTICAST_IP);
478 ep.port = CA_MCAST_PORT;
479 CAIPSendData(&ep, data, dataLength, true);
482 VERIFY_NON_NULL_RET(g_sendQueueHandle, IP_ADAPTER_TAG, "sendQueueHandle", -1);
484 // Create IPData to add to queue
485 CAIPData *ipData = CACreateIPData(remoteEndpoint, data, dataLength, isMulticast);
489 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Failed to create ipData!");
494 // Add message to send queue
495 CAQueueingThreadAddData(g_sendQueueHandle, ipData, sizeof(CAIPData));
498 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
502 CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
503 CANetworkPacketReceivedCallback networkPacketCallback,
504 CANetworkChangeCallback netCallback,
505 CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
507 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
508 VERIFY_NON_NULL(registerCallback, IP_ADAPTER_TAG, "registerCallback");
509 VERIFY_NON_NULL(networkPacketCallback, IP_ADAPTER_TAG, "networkPacketCallback");
510 VERIFY_NON_NULL(netCallback, IP_ADAPTER_TAG, "netCallback");
511 #ifndef SINGLE_THREAD
512 VERIFY_NON_NULL(handle, IP_ADAPTER_TAG, "thread pool handle");
515 g_threadPool = handle;
516 g_networkChangeCallback = netCallback;
517 g_networkPacketCallback = networkPacketCallback;
518 g_errorCallback = errorCallback;
520 CAResult_t ret = CAIPInitializeNetworkMonitor(g_threadPool);
521 if (CA_STATUS_OK != ret)
523 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to initialize n/w monitor[%d]", ret);
526 CAIPSetConnectionStateChangeCallback(CAIPConnectionStateCB);
528 ret = CAIPInitializeServer(g_threadPool);
529 if (CA_STATUS_OK != ret)
531 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to initialize server![%d]", ret);
536 CAIPSetPacketReceiveCallback(CAIPPacketReceivedCB);
537 CAIPSetErrorHandleCallback(CAIPErrorHandler);
539 CAAdapterNetDtlsInit();
541 CADTLSSetAdapterCallbacks(CAIPPacketReceivedCB, CAIPPacketSendCB, 0);
544 CAConnectivityHandler_t ipHandler;
545 ipHandler.startAdapter = CAStartIP;
546 ipHandler.startListenServer = CAStartIPListeningServer;
547 ipHandler.startDiscoveryServer = CAStartIPDiscoveryServer;
548 ipHandler.sendData = CASendIPUnicastData;
549 ipHandler.sendDataToAll = CASendIPMulticastData;
550 ipHandler.GetnetInfo = CAGetIPInterfaceInformation;
551 ipHandler.readData = CAReadIPData;
552 ipHandler.stopAdapter = CAStopIP;
553 ipHandler.terminate = CATerminateIP;
554 registerCallback(ipHandler, CA_ADAPTER_IP);
556 #ifndef SINGLE_THREAD
557 if (CA_STATUS_OK != CAIPInitializeQueueHandles())
559 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Failed to Initialize Queue Handle");
561 return CA_STATUS_FAILED;
564 OIC_LOG(INFO, IP_ADAPTER_TAG, "OUT");
568 CAResult_t CAStartIP()
570 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
572 // Start monitoring IP network
573 CAResult_t ret = CAIPStartNetworkMonitor();
574 if (CA_STATUS_OK != ret)
576 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Failed to Start n/w monitor");
580 #ifndef SINGLE_THREAD
581 // Start send queue thread
582 if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
584 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Failed to Start Send Data Thread");
585 return CA_STATUS_FAILED;
589 bool retVal = CAIPIsConnected();
592 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IP is not Connected");
597 uint16_t unicastPort = CA_PORT;
598 // Address is hardcoded as we are using Single Interface
599 ret = CAIPStartUnicastServer("0.0.0.0", &unicastPort, false);
600 if (CA_STATUS_OK != ret)
602 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Start unicast serv failed[%d]", ret);
606 u_arraylist_t *netInterfaceList = u_arraylist_create();
608 VERIFY_NON_NULL(netInterfaceList, IP_ADAPTER_TAG, "netInterfaceList is NULL");
610 ret = CAIPGetInterfaceInfo(&netInterfaceList);
611 if (CA_STATUS_OK != ret)
613 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to get IP interface info [%d]", ret);
614 CAClearNetInterfaceInfoList(netInterfaceList);
618 uint32_t listIndex = 0;
619 uint32_t listLength = u_arraylist_length(netInterfaceList);
620 for (listIndex = 0; listIndex < listLength; listIndex++)
622 CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(netInterfaceList, listIndex);
627 uint16_t unicastPort = CA_PORT;
628 ret = CAIPStartUnicastServer(netInfo->ipAddress, &unicastPort, false);
629 if (CA_STATUS_OK == ret)
631 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Unicast server started on %d port",
636 unicastPort = CA_SECURE_PORT;
637 ret = CAIPStartUnicastServer(netInfo->ipAddress, &unicastPort, true);
639 if (CA_STATUS_OK == ret)
641 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG,
642 "Secure Unicast server started on %d port", unicastPort);
646 CAClearNetInterfaceInfoList(netInterfaceList);
648 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
652 CAResult_t CAStartIPListeningServer()
654 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
656 CAResult_t ret = CA_STATUS_OK;
657 bool retVal = CAIPIsConnected();
660 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IP not Connected");
665 //uint16_t multicastPort = CA_MCAST_PORT;
666 ret = CAIPStartMulticastServer("0.0.0.0", CA_MULTICAST_IP, CA_MCAST_PORT);
667 if (CA_STATUS_OK != ret)
669 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Start multicast failed[%d]", ret);
672 u_arraylist_t *netInterfaceList = u_arraylist_create();
674 VERIFY_NON_NULL(netInterfaceList, IP_ADAPTER_TAG, "netInterfaceList is NULL");
676 ret = CAIPGetInterfaceInfo(&netInterfaceList);
677 if (CA_STATUS_OK != ret)
679 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "Failed to get IP interface info [%d]", ret);
680 CAClearNetInterfaceInfoList(netInterfaceList);
684 uint32_t listIndex = 0;
685 uint32_t listLength = u_arraylist_length(netInterfaceList);
686 for (listIndex = 0; listIndex < listLength; listIndex++)
689 CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(netInterfaceList, listIndex);
695 OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Ip address for multicast interface %s",
697 ret = CAIPStartMulticastServer(netInfo->ipAddress, CA_MULTICAST_IP, CA_MCAST_PORT);
698 if (CA_STATUS_OK == ret)
700 OIC_LOG(INFO, IP_ADAPTER_TAG, "Multicast Server is Started Successfully");
704 CAClearNetInterfaceInfoList(netInterfaceList);
706 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
710 CAResult_t CAStartIPDiscoveryServer()
712 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
713 /* Both listening and discovery server are same */
714 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
715 return CAStartIPListeningServer();
718 int32_t CASendIPUnicastData(const CAEndpoint_t *remoteEndpoint,
719 const void *data, uint32_t dataLength)
721 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
723 VERIFY_NON_NULL_RET(remoteEndpoint, IP_ADAPTER_TAG, "remoteEndpoint", -1);
724 VERIFY_NON_NULL_RET(data, IP_ADAPTER_TAG, "data", -1);
727 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Invalid Data Length");
731 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
732 return CAIPSendDataInternal(remoteEndpoint, data, dataLength, false);
735 int32_t CASendIPMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
737 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
739 VERIFY_NON_NULL_RET(data, IP_ADAPTER_TAG, "data", -1);
742 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Invalid Data Length");
746 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
747 return CAIPSendDataInternal(endpoint, data, dataLength, true);
750 CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
752 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
754 VERIFY_NON_NULL(info, IP_ADAPTER_TAG, "info is NULL");
755 VERIFY_NON_NULL(size, IP_ADAPTER_TAG, "size is NULL");
757 bool retVal = CAIPIsConnected();
760 OIC_LOG(ERROR, IP_ADAPTER_TAG, "IP not Connected");
761 return CA_ADAPTER_NOT_ENABLED;
764 u_arraylist_t *netInterfaceList = u_arraylist_create();
766 VERIFY_NON_NULL(netInterfaceList, IP_ADAPTER_TAG, "netInterfaceList is NULL");
768 CAResult_t ret = CAIPGetInterfaceInfo(&netInterfaceList);
769 if (CA_STATUS_OK != ret)
771 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "CAIPGetInterfaceInfo failed:%d", ret);
772 CAClearNetInterfaceInfoList(netInterfaceList);
776 uint32_t listLength = u_arraylist_length(netInterfaceList);
777 uint32_t netInfoSize = listLength;
782 netInfoSize = listLength * 2;
786 CAEndpoint_t *conInfo = (CAEndpoint_t *)OICCalloc(netInfoSize, sizeof (CAEndpoint_t));
789 OIC_LOG(ERROR, IP_ADAPTER_TAG, "Malloc Failed");
790 CAClearNetInterfaceInfoList(netInterfaceList);
791 return CA_MEMORY_ALLOC_FAILED;
794 uint32_t listIndex = 0;
796 for (listIndex = 0; listIndex < listLength; listIndex++)
798 CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(netInterfaceList, listIndex);
804 conInfo[count].adapter = CA_ADAPTER_IP;
805 conInfo[count].flags = 0;
806 conInfo[count].port = CAGetServerPortNum(netInfo->ipAddress, false);
807 OICStrcpy(conInfo[count].addr,
808 sizeof(conInfo[count].addr),
812 // copy secure unicast server information
815 conInfo[count].adapter = CA_ADAPTER_IP;
816 conInfo[count].flags = CA_SECURE;
817 conInfo[count].port = CAGetServerPortNum(netInfo->ipAddress, true);
818 OICStrcpy(conInfo[count].addr,
819 sizeof(conInfo[count].addr),
827 CAClearNetInterfaceInfoList(netInterfaceList);
829 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
833 CAResult_t CAReadIPData()
835 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
837 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
841 CAResult_t CAIPStopServers()
843 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
845 // Stop all unicast and multicast servers.
846 if (CA_STATUS_OK == CAIPStopAllServers())
848 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "CAIPStopAllServers success");
851 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
855 CAResult_t CAStopIP()
857 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
860 CAAdapterNetDtlsDeInit();
863 // Stop IP network monitor
864 CAIPStopNetworkMonitor();
866 #ifndef SINGLE_THREAD
867 // Stop send queue thread
868 if (g_sendQueueHandle)
870 CAQueueingThreadStop(g_sendQueueHandle);
874 // Stop Unicast, Secured unicast and Multicast servers running
875 CAResult_t result = CAIPStopServers();
876 if (CA_STATUS_OK != result)
878 OIC_LOG_V(ERROR, IP_ADAPTER_TAG, "stop srv fail:%d", result);
881 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
887 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
893 CADTLSSetAdapterCallbacks(NULL, NULL, 0);
896 CAIPSetPacketReceiveCallback(NULL);
898 // Terminate IP server
899 CAIPTerminateServer();
901 // Terminate network monitor
902 CAIPSetConnectionStateChangeCallback(NULL);
903 CAIPTerminateNetworkMonitor();
905 #ifndef SINGLE_THREAD
906 // Terminate message queue handler
907 CAIPDeinitializeQueueHandles();
910 OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");