Fix NULL pointer deferencing in policyengine.
[iotivity.git] / resource / csdk / connectivity / src / ip_adapter / android / caipnwmonitor.c
1 /******************************************************************
2  *
3  * Copyright 2014 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
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
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
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.
18  *
19  ******************************************************************/
20
21 #include "caipinterface.h"
22
23 #include <string.h>
24 #include <sys/ioctl.h>
25 #include <arpa/inet.h>
26 #include <linux/if.h>
27 #include <netdb.h>
28 #include <errno.h>
29 #include <unistd.h>
30
31 #include "caadapterutils.h"
32 #include "camutex.h"
33 #include "logger.h"
34 #include "oic_malloc.h"
35 #include "oic_string.h"
36 #include "org_iotivity_ca_CaIpInterface.h"
37
38 #define IP_MONITOR_TAG "IP_MONITOR"
39 #define MAX_INTERFACE_INFO_LENGTH (1024)
40
41 /**
42  * @var g_stopNetworkMonitor
43  * @brief  Used to stop the network monitor thread.
44  */
45 static bool g_stopNetworkMonitor = false;
46
47 /**
48  * @var g_stopNetworkMonitorMutex
49  * @brief  Mutex for synchronizing access to g_stopNetworkMonitor flag.
50  */
51 static ca_mutex g_stopNetworkMonitorMutex = NULL;
52
53 /**
54  * @struct CAIPNwMonitorContext
55  * @brief  Used for storing network monitor context information.
56  */
57 typedef struct
58 {
59     u_arraylist_t *netInterfaceList;
60     ca_thread_pool_t threadPool;
61     CANetworkStatus_t nwConnectivityStatus;
62     CAIPConnectionStateChangeCallback networkChangeCb;
63 } CAIPNetworkMonitorContext;
64
65 /**
66  * @var g_networkMonitorContext
67  * @brief  network monitor context.
68  */
69 static CAIPNetworkMonitorContext *g_networkMonitorContext = NULL;
70
71 /**
72  * @var g_networkMonitorContextMutex
73  * @brief  Mutex for synchronizing access to cached interface and IP address information.
74  */
75 static ca_mutex g_networkMonitorContextMutex = NULL;
76
77 /**
78  * @var g_jvm
79  * @brief pointer to store JavaVM
80  */
81 static JavaVM *g_jvm = NULL;
82
83 /**
84  * @var g_context
85  * @brief pointer to store Application Context
86  */
87 static jobject g_context = NULL;
88
89 /**
90  * @fn CAIPUpdateInterfaceInformation
91  * @brief This methods gets local interface name and IP address information.
92  */
93 static CAResult_t CAIPUpdateInterfaceInformation(u_arraylist_t **netInterfaceList);
94 /**
95  * @fn CACreateIPJNIInterfaceObject
96  * @brief creates new instance of CaIpInterface through JNI
97  */
98 static CAResult_t CACreateIPJNIInterfaceObject(jobject context);
99
100 /**
101  * @fn CAIPSendNetworkChangeCallback
102  * @brief updates network status to IP adapter
103  */
104 static void CAIPSendNetworkChangeCallback(CANetworkStatus_t currNetworkStatus);
105
106 CAResult_t CAIPJniInit()
107 {
108     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
109
110     OIC_LOG(DEBUG, IP_MONITOR_TAG, "CAIPJniInit");
111     g_jvm = CANativeJNIGetJavaVM();
112
113     if (!g_jvm)
114     {
115         OIC_LOG(ERROR, IP_MONITOR_TAG, "JNI initialize error");
116         return CA_STATUS_FAILED;
117     }
118
119     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
120     return CA_STATUS_OK;
121 }
122
123 CAResult_t CAIPJniSetContext()
124 {
125     OIC_LOG(DEBUG, IP_MONITOR_TAG, "CAIPJniSetContext");
126     g_context = (jobject) CANativeJNIGetContext();
127
128     if (!g_context)
129     {
130         OIC_LOG(ERROR, IP_MONITOR_TAG, "unable to get application context");
131         return CA_STATUS_FAILED;
132     }
133
134     return CA_STATUS_OK;
135 }
136
137 CAResult_t CACreateIPJNIInterfaceObject(jobject context)
138 {
139     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
140
141     OIC_LOG(DEBUG, IP_MONITOR_TAG, "CACreateIPJNIInterfaceObject");
142
143     VERIFY_NON_NULL(context, IP_MONITOR_TAG, "context");
144
145     JNIEnv* env;
146
147     if ((*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6) != JNI_OK)
148     {
149         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get JNIEnv pointer");
150         return CA_STATUS_FAILED;
151     }
152
153     //getApplicationContext
154     jclass contextClass = (*env)->FindClass(env, "android/content/Context");
155     if (!contextClass)
156     {
157         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get context object class");
158         return CA_STATUS_FAILED;
159     }
160
161     jmethodID getApplicationContextMethod = (*env)->GetMethodID(env, contextClass,
162                                                                 "getApplicationContext",
163                                                                 "()Landroid/content/Context;");
164     if (!getApplicationContextMethod)
165     {
166         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get getApplicationContext method");
167         return CA_STATUS_FAILED;
168     }
169
170     jobject gApplicationContext = (*env)->CallObjectMethod(env, context,
171                                                            getApplicationContextMethod);
172     if (!getApplicationContextMethod)
173     {
174         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get getApplicationContext");
175         return CA_STATUS_FAILED;
176     }
177
178     //Create CaIpInterface jni instance
179     jclass IPJniInterface = (*env)->FindClass(env, "org/iotivity/ca/CaIpInterface");
180     if (!IPJniInterface)
181     {
182         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get CaIpInterface class");
183         return CA_STATUS_FAILED;
184     }
185
186     jmethodID IPInterfaceConstructorMethod = (*env)->GetMethodID(env, IPJniInterface, "<init>",
187                                                                    "(Landroid/content/Context;)V");
188     if (!IPInterfaceConstructorMethod)
189     {
190         OIC_LOG(ERROR, IP_MONITOR_TAG, "Could not get CaIpInterface constructor method");
191         return CA_STATUS_FAILED;
192     }
193
194     (*env)->NewObject(env, IPJniInterface, IPInterfaceConstructorMethod, gApplicationContext);
195     OIC_LOG(DEBUG, IP_MONITOR_TAG, "Create CaIpInterface instance, success");
196
197     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
198     return CA_STATUS_OK;
199 }
200
201 static CAResult_t CAIPUpdateInterfaceInformation(u_arraylist_t **netInterfaceList)
202 {
203     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
204
205     VERIFY_NON_NULL(netInterfaceList, IP_MONITOR_TAG, "netInterfaceList is null");
206
207     /* Get a socket handle. */
208     int sck = -1;
209 #ifdef SOCK_CLOEXEC
210     sck = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
211 #endif
212
213     if ( -1 == sck)
214     {
215         sck=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
216     }
217
218     if (sck < 0)
219     {
220         OIC_LOG(ERROR, IP_MONITOR_TAG, "Error in socket creation");
221         return CA_STATUS_FAILED;
222     }
223
224     char buf[MAX_INTERFACE_INFO_LENGTH] = { 0 };
225     struct ifconf ifc;
226
227     /* Query available interfaces. */
228     ifc.ifc_len = MAX_INTERFACE_INFO_LENGTH;
229     ifc.ifc_buf = buf;
230
231     if (ioctl(sck, SIOCGIFCONF, &ifc) < 0)
232     {
233         close(sck);
234         OIC_LOG(ERROR, IP_MONITOR_TAG, "Failed to get interface info");
235         return CA_STATUS_FAILED;
236     }
237
238     /* Iterate through the list of interfaces. */
239     struct ifreq* ifr = ifc.ifc_req;
240     int32_t interfaces = ifc.ifc_len / sizeof(struct ifreq);
241
242     OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPUpdateInterfaceInformation : %d", interfaces);
243
244     if(0 == interfaces)
245     {
246         OIC_LOG(ERROR, IP_MONITOR_TAG, "no interfaces");
247         return CA_STATUS_FAILED;
248     }
249
250     for (int32_t i = 0; i < interfaces; i++)
251     {
252         struct ifreq temp_ifr = { 0 };
253         struct ifreq* item = &ifr[i];
254
255         char interfaceAddress[CA_IPADDR_SIZE] = { 0 };
256         char interfaceSubnetMask[CA_IPADDR_SIZE] = { 0 };
257         socklen_t len = sizeof(struct sockaddr_in);
258
259         OICStrcpy(temp_ifr.ifr_name, sizeof(temp_ifr.ifr_name), item->ifr_name);
260
261         if (ioctl(sck, SIOCGIFFLAGS, &temp_ifr))
262         {
263             OIC_LOG(ERROR, IP_MONITOR_TAG,
264                     "CAIPUpdateInterfaceInformation, SIOCGIFFLAGS Failed");
265             close(sck);
266             return CA_STATUS_FAILED;
267         }
268
269         if ((temp_ifr.ifr_flags & IFF_LOOPBACK)
270             || !(temp_ifr.ifr_flags & IFF_UP) || !(temp_ifr.ifr_flags & IFF_RUNNING))
271         {
272             OIC_LOG_V(ERROR, IP_MONITOR_TAG,
273                       "interface is not up or not running or loopback = %x", temp_ifr.ifr_flags);
274             continue;
275         }
276
277         if (AF_INET != ((struct sockaddr_in*) &item->ifr_addr)->sin_family)
278         {
279             continue;
280         }
281
282         //get the interface ip address
283         if (0 != getnameinfo(&item->ifr_addr, len, interfaceAddress, sizeof(interfaceAddress),
284                              NULL, 0, NI_NUMERICHOST))
285         {
286             OIC_LOG_V(ERROR, IP_MONITOR_TAG, "Failed to get IPAddress, Error code: %s",
287                     strerror(errno));
288             close(sck);
289             return CA_STATUS_FAILED;
290         }
291
292         if (ioctl((int) sck, SIOCGIFNETMASK, item) < 0)
293         {
294             OIC_LOG(ERROR, IP_MONITOR_TAG,
295                     "CAIPUpdateInterfaceInformation, SIOCGIFNETMASK Failed");
296             close(sck);
297             return CA_STATUS_FAILED;
298         }
299
300         // get the interface subnet mask
301         if (0 != getnameinfo(&item->ifr_netmask, len, interfaceSubnetMask,
302                              sizeof(interfaceSubnetMask), NULL, 0, NI_NUMERICHOST))
303         {
304             OIC_LOG_V(ERROR, IP_MONITOR_TAG, "Failed to get subnet mask, Error code: %s",
305                     strerror(errno));
306             close(sck);
307             return CA_STATUS_FAILED;
308         }
309
310         CANetInfo_t *netInfo = (CANetInfo_t *) OICCalloc(1, sizeof(CANetInfo_t));
311         if (!netInfo)
312         {
313             OIC_LOG(ERROR, IP_MONITOR_TAG, "Malloc failed");
314             close(sck);
315             return CA_MEMORY_ALLOC_FAILED;
316         }
317
318         // set interface name
319         OICStrcpy(netInfo->interfaceName, sizeof(netInfo->interfaceName), item->ifr_name);
320
321         // set local ip address
322         OICStrcpy(netInfo->ipAddress, sizeof(netInfo->ipAddress), interfaceAddress);
323
324         // set subnet mask
325         OICStrcpy(netInfo->subnetMask, sizeof(netInfo->subnetMask), interfaceSubnetMask);
326
327         CAResult_t result = u_arraylist_add(*netInterfaceList, (void *) netInfo);
328         if (CA_STATUS_OK != result)
329         {
330             OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!Thread exiting.");
331             close(sck);
332             return CA_STATUS_FAILED;
333         }
334
335         OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "ipAddress : %s, interfaceName : %s, subnetmask : %s",
336                 netInfo->ipAddress, netInfo->interfaceName, netInfo->subnetMask);
337     }
338
339     close(sck);
340     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
341     return CA_STATUS_OK;
342 }
343
344 static bool CACheckIsAnyInterfaceDown(const u_arraylist_t *netInterfaceList,
345                                       const CANetInfo_t *info)
346 {
347     VERIFY_NON_NULL_RET(netInterfaceList, IP_MONITOR_TAG, "netInterfaceList is null", false);
348     VERIFY_NON_NULL_RET(info, IP_MONITOR_TAG, "info is null", false);
349
350     uint32_t list_length = u_arraylist_length(netInterfaceList);
351     for (uint32_t list_index = 0; list_index < list_length; list_index++)
352     {
353         CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(netInterfaceList, list_index);
354         if (!netInfo)
355         {
356             continue;
357         }
358         if (strncmp(netInfo->interfaceName, info->interfaceName, strlen(info->interfaceName)) == 0)
359         {
360             return false;
361         }
362     }
363     OIC_LOG(DEBUG, IP_MONITOR_TAG, "Interface is down");
364     return true;
365 }
366
367 static bool CACheckIsInterfaceInfoChanged(const CANetInfo_t *info)
368 {
369     VERIFY_NON_NULL_RET(info, IP_MONITOR_TAG, "info is null", false);
370
371     ca_mutex_lock(g_networkMonitorContextMutex);
372
373     uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
374     for (uint32_t list_index = 0; list_index < list_length; list_index++)
375     {
376         CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(
377                                g_networkMonitorContext->netInterfaceList, list_index);
378         if (!netInfo)
379         {
380             continue;
381         }
382         if (strncmp(netInfo->interfaceName, info->interfaceName, strlen(info->interfaceName)) == 0)
383         {
384             if (strncmp(netInfo->ipAddress, info->ipAddress, strlen(info->ipAddress)) == 0)
385             {
386                 ca_mutex_unlock(g_networkMonitorContextMutex);
387                 return false;
388             }
389             else
390             {
391                 OIC_LOG(DEBUG, IP_MONITOR_TAG, "Network interface info changed");
392                 if (u_arraylist_remove(g_networkMonitorContext->netInterfaceList, list_index))
393                 {
394                     if (g_networkMonitorContext->networkChangeCb)
395                     {
396                         g_networkMonitorContext->networkChangeCb(netInfo->ipAddress,
397                                                                  CA_INTERFACE_DOWN);
398                     }
399                     OICFree(netInfo);
400                 }
401                 else
402                 {
403                     OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_remove failed");
404                 }
405                 break;
406             }
407         }
408     }
409
410     CANetInfo_t *newNetInfo = (CANetInfo_t *) OICMalloc(sizeof(CANetInfo_t));
411     if (!newNetInfo)
412     {
413         OIC_LOG(ERROR, IP_MONITOR_TAG, "newNetInfo malloc failed");
414         ca_mutex_unlock(g_networkMonitorContextMutex);
415         return false;
416     }
417     *newNetInfo = *info;
418
419     OIC_LOG(DEBUG, IP_MONITOR_TAG, "New Interface found");
420
421     CAResult_t result = u_arraylist_add(g_networkMonitorContext->netInterfaceList,
422                                         (void *) newNetInfo);
423     if (CA_STATUS_OK != result)
424     {
425         OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!");
426         OICFree(newNetInfo);
427         ca_mutex_unlock(g_networkMonitorContextMutex);
428         return false;
429     }
430     ca_mutex_unlock(g_networkMonitorContextMutex);
431
432     /*Callback will be unset only at the time of termination. By that time, all the threads will be
433       stopped gracefully. This callback is properly protected*/
434     if (g_networkMonitorContext->networkChangeCb)
435     {
436         g_networkMonitorContext->networkChangeCb(newNetInfo->ipAddress, CA_INTERFACE_UP);
437     }
438
439     return true;
440 }
441
442 static CAResult_t CAInitializeNetworkMonitorMutexes()
443 {
444     if (!g_networkMonitorContextMutex)
445     {
446         g_networkMonitorContextMutex = ca_mutex_new();
447         if (!g_networkMonitorContextMutex)
448         {
449             OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContextMutex Malloc  failed");
450             return CA_MEMORY_ALLOC_FAILED;
451         }
452     }
453
454     if (!g_stopNetworkMonitorMutex)
455     {
456         g_stopNetworkMonitorMutex = ca_mutex_new();
457         if (!g_stopNetworkMonitorMutex)
458         {
459             OIC_LOG(ERROR, IP_MONITOR_TAG, "g_stopNetworkMonitorMutex Malloc  failed");
460             ca_mutex_free(g_networkMonitorContextMutex);
461             return CA_MEMORY_ALLOC_FAILED;
462         }
463     }
464     return CA_STATUS_OK;
465 }
466
467 static void CADestroyNetworkMonitorMutexes()
468 {
469     ca_mutex_free(g_networkMonitorContextMutex);
470     g_networkMonitorContextMutex = NULL;
471
472     ca_mutex_free(g_stopNetworkMonitorMutex);
473     g_stopNetworkMonitorMutex = NULL;
474 }
475
476 CAResult_t CAIPInitializeNetworkMonitor(const ca_thread_pool_t threadPool)
477 {
478     OIC_LOG(DEBUG, IP_MONITOR_TAG, "CAIPInitializeNetworkMonitor IN");
479
480     VERIFY_NON_NULL(threadPool, IP_MONITOR_TAG, "threadPool is null");
481
482     CAResult_t ret = CAIPJniInit();
483     if (CA_STATUS_OK != ret)
484     {
485         OIC_LOG(ERROR, IP_MONITOR_TAG, "Initialization failed");
486         return ret;
487     }
488
489     ret = CAIPJniSetContext();
490     if (CA_STATUS_OK != ret)
491     {
492         OIC_LOG(ERROR, IP_MONITOR_TAG, "CAIPJniSetContext failed");
493         return ret;
494     }
495
496     ret = CACreateIPJNIInterfaceObject(g_context);
497     if (CA_STATUS_OK != ret)
498     {
499         OIC_LOG(ERROR, IP_MONITOR_TAG, "unable to create CaIpInterface instance");
500         return ret;
501     }
502
503     ret = CAInitializeNetworkMonitorMutexes();
504
505     if (CA_STATUS_OK != ret)
506     {
507         OIC_LOG(ERROR, IP_MONITOR_TAG, "CAInitializeNetworkMonitorMutexes failed");
508         return CA_STATUS_FAILED;
509     }
510
511     ca_mutex_lock(g_networkMonitorContextMutex);
512
513     g_networkMonitorContext = (CAIPNetworkMonitorContext *) OICCalloc(
514             1, sizeof(*g_networkMonitorContext));
515     if (!g_networkMonitorContext)
516     {
517         OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext Malloc  failed");
518         ca_mutex_unlock(g_networkMonitorContextMutex);
519         CADestroyNetworkMonitorMutexes();
520         return CA_MEMORY_ALLOC_FAILED;
521     }
522     g_networkMonitorContext->threadPool = threadPool;
523
524     g_networkMonitorContext->netInterfaceList = u_arraylist_create();
525     if (!g_networkMonitorContext->netInterfaceList)
526     {
527         OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_create failed");
528         OICFree(g_networkMonitorContext);
529         ca_mutex_unlock(g_networkMonitorContextMutex);
530         CADestroyNetworkMonitorMutexes();
531         return CA_MEMORY_ALLOC_FAILED;
532     }
533
534     CAIPUpdateInterfaceInformation(&g_networkMonitorContext->netInterfaceList);
535
536     if (u_arraylist_length(g_networkMonitorContext->netInterfaceList))
537     {
538         g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_UP;
539     }
540     else
541     {
542         g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_DOWN;
543     }
544
545     ca_mutex_unlock(g_networkMonitorContextMutex);
546
547     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
548     return CA_STATUS_OK;
549 }
550
551 void CAIPTerminateNetworkMonitor()
552 {
553     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
554
555     ca_mutex_lock(g_networkMonitorContextMutex);
556     g_networkMonitorContext->threadPool = NULL;
557
558     CAClearNetInterfaceInfoList(g_networkMonitorContext->netInterfaceList);
559
560     g_networkMonitorContext->netInterfaceList = NULL;
561     g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_DOWN;
562     g_networkMonitorContext->networkChangeCb = NULL;
563     g_networkMonitorContext->threadPool = NULL;
564
565     OICFree(g_networkMonitorContext);
566     g_networkMonitorContext = NULL;
567
568     ca_mutex_unlock(g_networkMonitorContextMutex);
569
570     ca_mutex_lock(g_stopNetworkMonitorMutex);
571     g_stopNetworkMonitor = true;
572     ca_mutex_unlock(g_stopNetworkMonitorMutex);
573
574     CADestroyNetworkMonitorMutexes();
575
576     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
577 }
578
579 CAResult_t CAIPStartNetworkMonitor()
580 {
581     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
582
583     ca_mutex_lock(g_stopNetworkMonitorMutex);
584     g_stopNetworkMonitor = false;
585     ca_mutex_unlock(g_stopNetworkMonitorMutex);
586
587     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
588     return CA_STATUS_OK;
589 }
590
591 CAResult_t CAIPStopNetworkMonitor()
592 {
593     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
594
595     ca_mutex_lock(g_networkMonitorContextMutex);
596     if (!g_networkMonitorContext)
597     {
598         OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext is null");
599         ca_mutex_unlock(g_networkMonitorContextMutex);
600         return CA_STATUS_FAILED;
601     }
602
603     ca_mutex_unlock(g_networkMonitorContextMutex);
604
605     ca_mutex_lock(g_stopNetworkMonitorMutex);
606     if (!g_stopNetworkMonitor)
607     {
608         g_stopNetworkMonitor = true;
609     }
610     else
611     {
612         OIC_LOG(DEBUG, IP_MONITOR_TAG, "CAIPStopNetworkMonitor, already stopped!");
613     }
614     ca_mutex_unlock(g_stopNetworkMonitorMutex);
615
616     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
617     return CA_STATUS_OK;
618 }
619
620 CAResult_t CAIPGetInterfaceInfo(u_arraylist_t **netInterfaceList)
621 {
622     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
623
624     VERIFY_NON_NULL(netInterfaceList, IP_MONITOR_TAG, "u_array_list is null");
625     VERIFY_NON_NULL(g_networkMonitorContext, IP_MONITOR_TAG, "g_networkMonitorContext is null");
626     VERIFY_NON_NULL(g_networkMonitorContextMutex, IP_MONITOR_TAG,
627                     "g_networkMonitorContextMutex is null");
628
629     // Get the interface and ipaddress information from cache
630     ca_mutex_lock(g_networkMonitorContextMutex);
631     if (!g_networkMonitorContext->netInterfaceList
632         || !(u_arraylist_length(g_networkMonitorContext->netInterfaceList)))
633     {
634         OIC_LOG(ERROR, IP_MONITOR_TAG, "Network not enabled");
635         ca_mutex_unlock(g_networkMonitorContextMutex);
636         return CA_ADAPTER_NOT_ENABLED;
637     }
638
639     uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
640     OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPGetInterfaceInfo list length [%d]",
641             list_length);
642     for (uint32_t list_index = 0; list_index < list_length; list_index++)
643     {
644         CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
645                 g_networkMonitorContext->netInterfaceList, list_index);
646         if (!info)
647         {
648             continue;
649         }
650         OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPGetInterfaceInfo ip [%s]",
651                   info->ipAddress);
652         CANetInfo_t *newNetinfo = (CANetInfo_t *) OICMalloc(sizeof(CANetInfo_t));
653         if (!newNetinfo)
654         {
655             OIC_LOG(ERROR, IP_MONITOR_TAG, "Malloc failed!");
656             ca_mutex_unlock(g_networkMonitorContextMutex);
657             return CA_MEMORY_ALLOC_FAILED;
658         }
659
660         *newNetinfo = *info;
661
662         CAResult_t result = u_arraylist_add(*netInterfaceList, (void *) newNetinfo);
663         if (CA_STATUS_OK != result)
664         {
665             OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!");
666             ca_mutex_unlock(g_networkMonitorContextMutex);
667             return CA_STATUS_FAILED;
668         }
669     }
670
671     ca_mutex_unlock(g_networkMonitorContextMutex);
672
673     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
674     return CA_STATUS_OK;
675 }
676
677 CAResult_t CAIPGetInterfaceSubnetMask(const char *ipAddress, char **subnetMask)
678 {
679     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
680
681     VERIFY_NON_NULL(subnetMask, IP_MONITOR_TAG, "subnet mask");
682     VERIFY_NON_NULL(ipAddress, IP_MONITOR_TAG, "ipAddress is null");
683     VERIFY_NON_NULL(g_networkMonitorContext, IP_MONITOR_TAG, "g_networkMonitorContext is null");
684     VERIFY_NON_NULL(g_networkMonitorContextMutex, IP_MONITOR_TAG,
685                     "g_networkMonitorContextMutex is null");
686
687     // Get the interface and ipaddress information from cache
688     ca_mutex_lock(g_networkMonitorContextMutex);
689     if (!g_networkMonitorContext->netInterfaceList
690         || (0 == u_arraylist_length(g_networkMonitorContext->netInterfaceList)))
691     {
692         OIC_LOG(DEBUG, IP_MONITOR_TAG, "Network not enabled");
693         ca_mutex_unlock(g_networkMonitorContextMutex);
694         return CA_ADAPTER_NOT_ENABLED;
695     }
696
697     uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
698     OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "list lenght [%d]", list_length);
699     for (uint32_t list_index = 0; list_index < list_length; list_index++)
700     {
701         CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
702                 g_networkMonitorContext->netInterfaceList, list_index);
703         if (!info)
704         {
705             continue;
706         }
707
708         if (strncmp(info->ipAddress, ipAddress, strlen(ipAddress)) == 0)
709         {
710             OIC_LOG_V(DEBUG, IP_MONITOR_TAG,
711                       "CAIPGetInterfaceSubnetMask subnetmask is %s", info->subnetMask);
712             *subnetMask = OICStrdup(info->subnetMask);
713             break;
714         }
715     }
716     ca_mutex_unlock(g_networkMonitorContextMutex);
717
718     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
719     return CA_STATUS_OK;
720 }
721
722 bool CAIPIsConnected()
723 {
724     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
725     if (!g_networkMonitorContextMutex || !g_networkMonitorContext)
726     {
727         OIC_LOG(ERROR, IP_MONITOR_TAG, "IP is not connected");
728         return false;
729     }
730
731     ca_mutex_lock(g_networkMonitorContextMutex);
732     if (0 == u_arraylist_length(g_networkMonitorContext->netInterfaceList))
733     {
734         OIC_LOG(ERROR, IP_MONITOR_TAG, "IP is not connected");
735         ca_mutex_unlock(g_networkMonitorContextMutex);
736         return false;
737     }
738     ca_mutex_unlock(g_networkMonitorContextMutex);
739
740     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
741     return true;
742 }
743
744 void CAIPSetConnectionStateChangeCallback(CAIPConnectionStateChangeCallback callback)
745 {
746     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
747     if (!g_networkMonitorContextMutex || !g_networkMonitorContext)
748     {
749         OIC_LOG(ERROR, IP_MONITOR_TAG, "CAIPSetConnectionStateChangeCallback failed");
750         return;
751     }
752     ca_mutex_lock(g_networkMonitorContextMutex);
753
754     g_networkMonitorContext->networkChangeCb = callback;
755
756     ca_mutex_unlock(g_networkMonitorContextMutex);
757
758     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
759 }
760
761 void CAIPSendNetworkChangeCallback(CANetworkStatus_t currNetworkStatus)
762 {
763     OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
764     ca_mutex_lock(g_stopNetworkMonitorMutex);
765
766     if (g_stopNetworkMonitor)
767     {
768         OIC_LOG(DEBUG, IP_MONITOR_TAG, "Stop Network Monitor Thread is called");
769         ca_mutex_unlock(g_stopNetworkMonitorMutex);
770         return;
771     }
772
773     ca_mutex_unlock(g_stopNetworkMonitorMutex);
774
775     ca_mutex_lock(g_networkMonitorContextMutex);
776
777     if (!g_networkMonitorContext)
778     {
779         OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext is NULL");
780         ca_mutex_unlock(g_networkMonitorContextMutex);
781         return;
782     }
783
784     if (!g_networkMonitorContext->networkChangeCb)
785     {
786         OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext->networkChangeCb is NULL");
787         ca_mutex_unlock(g_networkMonitorContextMutex);
788         return;
789     }
790
791     ca_mutex_unlock(g_networkMonitorContextMutex);
792
793     u_arraylist_t *netInterfaceList = u_arraylist_create();
794
795     VERIFY_NON_NULL_VOID(netInterfaceList, IP_MONITOR_TAG,
796                          "memory allocation failed for netInterfaceList");
797
798     // if network status is changed
799     CAResult_t ret = CAIPUpdateInterfaceInformation(&netInterfaceList);
800     if (CA_STATUS_OK != ret)
801     {
802         OIC_LOG(ERROR, IP_MONITOR_TAG, "could not update interface information");
803     }
804
805     ca_mutex_lock(g_networkMonitorContextMutex);
806     if (!g_networkMonitorContext->netInterfaceList)
807     {
808         OIC_LOG(ERROR, IP_MONITOR_TAG,
809                 "u_arraylist_create failed. Network Monitor thread stopped");
810         CAClearNetInterfaceInfoList(netInterfaceList);
811         ca_mutex_unlock(g_networkMonitorContextMutex);
812         return;
813     }
814
815     uint32_t listLength = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
816     for (uint32_t listIndex = 0; listIndex < listLength;)
817     {
818         CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
819                 g_networkMonitorContext->netInterfaceList, listIndex);
820         if (!info)
821         {
822             listIndex++;
823             continue;
824         }
825
826         bool ret = CACheckIsAnyInterfaceDown(netInterfaceList, info);
827         if (ret)
828         {
829             OIC_LOG(DEBUG, IP_MONITOR_TAG, "Interface is down");
830             if (u_arraylist_remove(g_networkMonitorContext->netInterfaceList, listIndex))
831             {
832                 OIC_LOG(DEBUG, IP_MONITOR_TAG, "u_arraylist_remove success");
833                 if (g_networkMonitorContext->networkChangeCb)
834                 {
835                     g_networkMonitorContext->networkChangeCb(info->ipAddress, CA_INTERFACE_DOWN);
836                 }
837                 OICFree(info);
838                 listLength--;
839             }
840             else
841             {
842                 OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_remove failed");
843                 break;
844             }
845         }
846         else
847         {
848             listIndex++;
849         }
850     }
851
852     ca_mutex_unlock(g_networkMonitorContextMutex);
853
854     listLength = u_arraylist_length(netInterfaceList);
855     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
856     {
857         CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(netInterfaceList, listIndex);
858         if (!info)
859         {
860             continue;
861         }
862         bool ret = CACheckIsInterfaceInfoChanged(info);
863         if (ret)
864         {
865             OIC_LOG(DEBUG, IP_MONITOR_TAG, "CACheckIsInterfaceInfoChanged true");
866         }
867     }
868
869     CAClearNetInterfaceInfoList(netInterfaceList);
870     OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
871 }
872
873 JNIEXPORT void JNICALL
874 Java_org_iotivity_ca_CaIpInterface_caIpStateEnabled(JNIEnv *env, jclass class)
875 {
876     CANetworkStatus_t currNetworkStatus = CA_INTERFACE_UP;
877     OIC_LOG(DEBUG, IP_MONITOR_TAG, "caIpStateEnabled");
878
879     CAIPSendNetworkChangeCallback(currNetworkStatus);
880 }
881
882 JNIEXPORT void JNICALL
883 Java_org_iotivity_ca_CaIpInterface_caIpStateDisabled(JNIEnv *env, jclass class)
884 {
885     CANetworkStatus_t currNetworkStatus = CA_INTERFACE_DOWN;
886     OIC_LOG(DEBUG, IP_MONITOR_TAG, "caIpStateDisabled");
887
888     CAIPSendNetworkChangeCallback(currNetworkStatus);
889 }
890