ocserv: renamed main_loop

This avoids warnings and static analyzers complains about
libev functions hiding the global 'loop' variable.

Signed-off-by: Nikos Mavrogiannopoulos <n.mavrogiannopoulos@gmail.com>

src/main-ctl-unix.c

@@ -251,7 +251,7 @@ static void method_reload(method_ctx *ctx, int cfd, uint8_t * msg,
 
 	mslog(ctx->s, NULL, LOG_DEBUG, "ctl: reload");
 
-	ev_feed_signal_event (loop, SIGHUP);
+	ev_feed_signal_event (main_loop, SIGHUP);
 
 	rep.status = 1;
 
@@ -273,7 +273,7 @@ static void method_stop(method_ctx *ctx, int cfd, uint8_t * msg,
 
 	mslog(ctx->s, NULL, LOG_DEBUG, "ctl: stop");
 
-	ev_feed_signal_event (loop, SIGTERM);
+	ev_feed_signal_event (main_loop, SIGTERM);
 
 	rep.status = 1;
 
@@ -870,7 +870,7 @@ struct ctl_watcher_st {
 
 static void ctl_cmd_wacher_cb(EV_P_ ev_io *w, int revents)
 {
-	main_server_st *s = ev_userdata(loop);
+	main_server_st *s = ev_userdata(main_loop);
 	int ret;
 	size_t length;
 	uint8_t cmd;
@@ -951,7 +951,7 @@ static void ctl_handle_commands(main_server_st * s)
 	wst->fd = cfd;
 
 	ev_io_init(&wst->ctl_cmd_io, ctl_cmd_wacher_cb, wst->fd, EV_READ);
-	ev_io_start(loop, &wst->ctl_cmd_io);
+	ev_io_start(main_loop, &wst->ctl_cmd_io);
 
 	return;
  fail:

src/main-proc.c

@@ -100,8 +100,8 @@ void remove_proc(main_server_st * s, struct proc_st *proc, unsigned flags)
 {
 	pid_t pid;
 
-	ev_io_stop(EV_A_ &proc->io);
-	ev_child_stop(EV_A_ &proc->ev_child);
+	ev_io_stop(main_loop, &proc->io);
+	ev_child_stop(main_loop, &proc->ev_child);
 
 	list_del(&proc->list);
 	s->stats.active_clients--;

src/main.c

@@ -91,7 +91,7 @@ static void resume_accept_cb (EV_P_ ev_timer *w, int revents);
 
 int syslog_open = 0;
 sigset_t sig_default_set;
-struct ev_loop *loop = NULL;
+struct ev_loop *main_loop = NULL;
 static unsigned allow_broken_clients = 0;
 
 typedef struct sec_mod_watcher_st {
@@ -463,8 +463,8 @@ void clear_lists(main_server_st *s)
 		if (ctmp->tun_lease.fd >= 0)
 			close(ctmp->tun_lease.fd);
 		list_del(&ctmp->list);
-		ev_child_stop(EV_A_ &ctmp->ev_child);
-		ev_io_stop(EV_A_ &ctmp->io);
+		ev_child_stop(main_loop, &ctmp->ev_child);
+		ev_io_stop(main_loop, &ctmp->io);
 		safe_memset(ctmp, 0, sizeof(*ctmp));
 		talloc_free(ctmp);
 		s->proc_list.total--;
@@ -472,7 +472,7 @@ void clear_lists(main_server_st *s)
 
 	list_for_each_safe(&s->script_list.head, script_tmp, script_pos, list) {
 		list_del(&script_tmp->list);
-		ev_child_stop(loop, &script_tmp->ev_child);
+		ev_child_stop(main_loop, &script_tmp->ev_child);
 		talloc_free(script_tmp);
 	}
 
@@ -483,18 +483,18 @@ void clear_lists(main_server_st *s)
 	if_address_cleanup(s);
 
 	/* clear libev state */
-	if (loop) {
-		ev_io_stop (loop, &ctl_watcher);
+	if (main_loop) {
+		ev_io_stop (main_loop, &ctl_watcher);
 		for (i = 0; i < s->sec_mod_instance_count; i++) {
-			ev_io_stop (loop, &sec_mod_watchers[i].sec_mod_watcher);
-			ev_child_stop (loop, &sec_mod_watchers[i].child_watcher);
+			ev_io_stop (main_loop, &sec_mod_watchers[i].sec_mod_watcher);
+			ev_child_stop (main_loop, &sec_mod_watchers[i].child_watcher);
 		}
-		ev_timer_stop(loop, &maintenance_watcher);
+		ev_timer_stop(main_loop, &maintenance_watcher);
 #if defined(CAPTURE_LATENCY_SUPPORT)
-		ev_timer_stop(loop, &latency_watcher);		
+		ev_timer_stop(main_loop, &latency_watcher);		
 #endif
 		/* free memory and descriptors by the event loop */
-		ev_loop_destroy (loop);
+		ev_loop_destroy (main_loop);
 	}
 }
 
@@ -924,7 +924,7 @@ static void terminate_server(main_server_st * s)
 		total--;
 	}
 
-	ev_break (loop, EVBREAK_ALL);
+	ev_break (main_loop, EVBREAK_ALL);
 }
 
 static void graceful_shutdown_watcher_cb(EV_P_ ev_timer *w, int revents)
@@ -1289,7 +1289,7 @@ static void maintenance_sig_watcher_cb(struct ev_loop *loop, ev_signal *w, int r
 
 static void syserr_cb (const char *msg)
 {
-	main_server_st *s = ev_userdata(loop);
+	main_server_st *s = ev_userdata(main_loop);
 
 	mslog(s, NULL, LOG_ERR, "libev fatal error: %s", msg);
 	abort();
@@ -1485,8 +1485,8 @@ int main(int argc, char** argv)
 		exit(1);
 	}
 
-	loop = EV_DEFAULT;
-	if (loop == NULL) {
+	main_loop = EV_DEFAULT;
+	if (main_loop == NULL) {
 		mslog(s, NULL, LOG_ERR, "could not initialise libev");
 		exit(1);
 	}
@@ -1540,7 +1540,7 @@ int main(int argc, char** argv)
 	/* increase the number of our allowed file descriptors */
 	update_fd_limits(s, 1);
 
-	ev_set_userdata (loop, s);
+	ev_set_userdata (main_loop, s);
 	ev_set_syserr_cb(syserr_cb);
 
 	ev_init(&ctl_watcher, ctl_watcher_cb);
@@ -1551,56 +1551,56 @@ int main(int argc, char** argv)
 
 	ev_init (&int_sig_watcher, term_sig_watcher_cb);
 	ev_signal_set (&int_sig_watcher, SIGINT);
-	ev_signal_start (loop, &int_sig_watcher);
+	ev_signal_start (main_loop, &int_sig_watcher);
 
 	ev_init (&term_sig_watcher, term_sig_watcher_cb);
 	ev_signal_set (&term_sig_watcher, SIGTERM);
-	ev_signal_start (loop, &term_sig_watcher);
+	ev_signal_start (main_loop, &term_sig_watcher);
 
 	ev_init (&reload_sig_watcher, reload_sig_watcher_cb);
 	ev_signal_set (&reload_sig_watcher, SIGHUP);
-	ev_signal_start (loop, &reload_sig_watcher);
+	ev_signal_start (main_loop, &reload_sig_watcher);
 
 	/* set the standard fds we watch */
 	list_for_each(&s->listen_list.head, ltmp, list) {
 		if (ltmp->fd == -1) continue;
 
-		ev_io_start (loop, &ltmp->io);
+		ev_io_start (main_loop, &ltmp->io);
 	}
 
 	for (i = 0; i < s->sec_mod_instance_count; i ++) {
 		ev_io_set(&sec_mod_watchers[i].sec_mod_watcher, s->sec_mod_instances[i].sec_mod_fd, EV_READ);
-		ev_io_start (loop, &sec_mod_watchers[i].sec_mod_watcher);
+		ev_io_start (main_loop, &sec_mod_watchers[i].sec_mod_watcher);
 	}
 
 	ctl_handler_set_fds(s, &ctl_watcher);
 
-	ev_io_start (loop, &ctl_watcher);
+	ev_io_start (main_loop, &ctl_watcher);
 
 	for (i = 0; i < s->sec_mod_instance_count; i ++) {
 		ev_child_init(&sec_mod_watchers[i].child_watcher, sec_mod_child_watcher_cb, s->sec_mod_instances[i].sec_mod_pid, 0);
-		ev_child_start (loop, &sec_mod_watchers[i].child_watcher);
+		ev_child_start (main_loop, &sec_mod_watchers[i].child_watcher);
 	}
 
 	ev_init(&maintenance_watcher, maintenance_watcher_cb);
 	ev_timer_set(&maintenance_watcher, MAIN_MAINTENANCE_TIME, MAIN_MAINTENANCE_TIME);
-	ev_timer_start(loop, &maintenance_watcher);
+	ev_timer_start(main_loop, &maintenance_watcher);
 
 	ev_init(&graceful_shutdown_watcher, graceful_shutdown_watcher_cb);
 
 #if defined(CAPTURE_LATENCY_SUPPORT)
 	ev_init(&latency_watcher, latency_watcher_cb);
 	ev_timer_set(&latency_watcher, LATENCY_AGGREGATION_TIME, LATENCY_AGGREGATION_TIME);
-	ev_timer_start(loop, &latency_watcher);
+	ev_timer_start(main_loop, &latency_watcher);
 #endif
 
 	/* allow forcing maintenance with SIGUSR2 */
 	ev_init (&maintenance_sig_watcher, maintenance_sig_watcher_cb);
 	ev_signal_set (&maintenance_sig_watcher, SIGUSR2);
-	ev_signal_start (loop, &maintenance_sig_watcher);
+	ev_signal_start (main_loop, &maintenance_sig_watcher);
 
 	/* Main server loop */
-	ev_run (loop, 0);
+	ev_run (main_loop, 0);
 
 	/* try to clean-up everything allocated to ease checks 
 	 * for memory leaks.

src/main.h

@@ -49,7 +49,7 @@
 extern int saved_argc;
 extern char **saved_argv;
 
-extern struct ev_loop *loop;
+extern struct ev_loop *main_loop;
 extern ev_timer maintainance_watcher;
 
 #define MAIN_MAINTENANCE_TIME (900)

src/script-list.h

@@ -41,7 +41,7 @@ struct script_wait_st *stmp;
 	stmp->pid = pid;
 
 	ev_child_init(&stmp->ev_child, script_child_watcher_cb, pid, 0);
-	ev_child_start(loop, &stmp->ev_child);
+	ev_child_start(main_loop, &stmp->ev_child);
 
 	list_add(&s->script_list.head, &(stmp->list));
 }
@@ -57,7 +57,7 @@ inline static pid_t remove_from_script_list(main_server_st* s, struct proc_st* p
 	list_for_each_safe(&s->script_list.head, stmp, spos, list) {
 		if (stmp->proc == proc) {
 			list_del(&stmp->list);
-			ev_child_stop(loop, &stmp->ev_child);
+			ev_child_stop(main_loop, &stmp->ev_child);
 			if (stmp->pid > 0) {
 				kill(stmp->pid, SIGTERM);
 				ret = stmp->pid;