X-Git-Url: https://tinc-vpn.org/git/browse?p=tinc;a=blobdiff_plain;f=src%2Fprocess.c;h=9a918158f336beb989d474157078be7c32c6ac64;hp=d618427d5357c3f89ea13e23809851d8d5043e29;hb=e169244e4b10dbcc1910c0f7fd811304d5b1a5a5;hpb=b413257e10ae0645da43583dd8f84a1f74df5bd7

diff --git a/src/process.c b/src/process.c
index d618427d..9a918158 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1,7 +1,7 @@
 /*
     process.c -- process management functions
-    Copyright (C) 1999-2001 Ivo Timmermans <itimmermans@bigfoot.com>,
-                  2000,2001 Guus Sliepen <guus@sliepen.warande.net>
+    Copyright (C) 1999-2003 Ivo Timmermans <ivo@o2w.nl>,
+                  2000-2003 Guus Sliepen <guus@sliepen.eu.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -17,34 +17,22 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: process.c,v 1.1.2.22 2001/03/13 09:55:14 guus Exp $
+    $Id: process.c,v 1.1.2.56 2003/07/21 14:47:43 guus Exp $
 */
 
-#include "config.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <stdio.h>
-#include <string.h>
-#include <syslog.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <termios.h>
-
-#include <pidfile.h>
-#include <utils.h>
-#include <xalloc.h>
+#include "system.h"
 
 #include "conf.h"
+#include "connection.h"
+#include "device.h"
+#include "edge.h"
+#include "logger.h"
+#include "node.h"
+#include "pidfile.h"
 #include "process.h"
 #include "subnet.h"
-#include "connection.h"
-
-#include "system.h"
+#include "utils.h"
+#include "xalloc.h"
 
 /* If zero, don't detach from the terminal. */
 int do_detach = 1;
@@ -52,27 +40,35 @@ int do_detach = 1;
 extern char *identname;
 extern char *pidfilename;
 extern char **g_argv;
+extern int use_logfile;
 
 sigset_t emptysigset;
 
-void memory_full(int size)
+static int saved_debug_level = -1;
+
+extern int sighup;
+extern int sigalrm;
+extern int do_purge;
+
+static void memory_full(int size)
 {
-  syslog(LOG_ERR, _("Memory exhausted (couldn't allocate %d bytes), exiting."), size);
-  cp_trace();
-  exit(1);
+	logger(LOG_ERR, _("Memory exhausted (couldn't allocate %d bytes), exitting."), size);
+	cp_trace();
+	exit(1);
 }
 
 /* Some functions the less gifted operating systems might lack... */
 
 #ifndef HAVE_FCLOSEALL
-int fcloseall(void)
+static int fcloseall(void)
 {
-  fflush(stdin);
-  fflush(stdout);
-  fflush(stderr);
-  fclose(stdin);
-  fclose(stdout);
-  fclose(stderr);
+	fflush(stdin);
+	fflush(stdout);
+	fflush(stderr);
+	fclose(stdin);
+	fclose(stdout);
+	fclose(stderr);
+	return 0;
 }
 #endif
 
@@ -81,66 +77,81 @@ int fcloseall(void)
 */
 void cleanup_and_exit(int c)
 {
-cp
-  close_network_connections();
+	cp();
+
+	close_network_connections();
 
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_INFO, _("Total bytes written: tap %d, socket %d; bytes read: tap %d, socket %d"),
-	   total_tap_out, total_socket_out, total_tap_in, total_socket_in);
+	ifdebug(CONNECTIONS)
+		dump_device_stats();
 
-  syslog(LOG_NOTICE, _("Terminating"));
+	logger(LOG_NOTICE, _("Terminating"));
 
-  closelog();
-  exit(c);
+	closelogger();
+	exit(c);
 }
 
 /*
   check for an existing tinc for this net, and write pid to pidfile
 */
-int write_pidfile(void)
+static int write_pidfile(void)
 {
-  int pid;
-cp
-  if((pid = check_pid(pidfilename)))
-    {
-      if(netname)
-	fprintf(stderr, _("A tincd is already running for net `%s' with pid %d.\n"),
-		netname, pid);
-      else
-	fprintf(stderr, _("A tincd is already running with pid %d.\n"), pid);
-      return 1;
-    }
-
-  /* if it's locked, write-protected, or whatever */
-  if(!write_pid(pidfilename))
-    return 1;
-cp
-  return 0;
+	int pid;
+
+	cp();
+
+	pid = check_pid(pidfilename);
+
+	if(pid) {
+		if(netname)
+			fprintf(stderr, _("A tincd is already running for net `%s' with pid %d.\n"),
+					netname, pid);
+		else
+			fprintf(stderr, _("A tincd is already running with pid %d.\n"), pid);
+		return 1;
+	}
+
+	/* if it's locked, write-protected, or whatever */
+	if(!write_pid(pidfilename))
+		return 1;
+
+	return 0;
 }
 
 /*
   kill older tincd for this net
 */
-int kill_other(void)
+int kill_other(int signal)
 {
-  int pid;
-cp
-  if(!(pid = read_pid(pidfilename)))
-    {
-      if(netname)
-	fprintf(stderr, _("No other tincd is running for net `%s'.\n"), netname);
-      else
-	fprintf(stderr, _("No other tincd is running.\n"));
-      return 1;
-    }
-
-  errno = 0;    /* No error, sometimes errno is only changed on error */
-  /* ESRCH is returned when no process with that pid is found */
-  if(kill(pid, SIGTERM) && errno == ESRCH)
-    fprintf(stderr, _("Removing stale lock file.\n"));
-  remove_pid(pidfilename);
-cp
-  return 0;
+	int pid;
+
+	cp();
+
+	pid = read_pid(pidfilename);
+
+	if(!pid) {
+		if(netname)
+			fprintf(stderr, _("No other tincd is running for net `%s'.\n"),
+					netname);
+		else
+			fprintf(stderr, _("No other tincd is running.\n"));
+		return 1;
+	}
+
+	errno = 0;					/* No error, sometimes errno is only changed on error */
+
+	/* ESRCH is returned when no process with that pid is found */
+	if(kill(pid, signal) && errno == ESRCH) {
+		if(netname)
+			fprintf(stderr, _("The tincd for net `%s' is no longer running. "),
+					netname);
+		else
+			fprintf(stderr, _("The tincd is no longer running. "));
+
+		fprintf(stderr, _("Removing stale lock file.\n"));
+		remove_pid(pidfilename);
+	}
+
+	return 0;
 }
 
 /*
@@ -148,138 +159,136 @@ cp
 */
 int detach(void)
 {
-cp
-  setup_signals();
+	cp();
 
-  /* First check if we can open a fresh new pidfile */
-  
-  if(write_pidfile())
-    return -1;
+	setup_signals();
 
-  /* If we succeeded in doing that, detach */
+	/* First check if we can open a fresh new pidfile */
 
-  closelog();
+	if(write_pidfile())
+		return -1;
 
-  if(do_detach)
-    {
-      if(daemon(0, 0) < 0)
-	{
-	  fprintf(stderr, _("Couldn't detach from terminal: %m"));
-	  return -1;
+	/* If we succeeded in doing that, detach */
+
+	closelogger();
+
+	if(do_detach) {
+		if(daemon(0, 0) < 0) {
+			fprintf(stderr, _("Couldn't detach from terminal: %s"),
+					strerror(errno));
+			return -1;
+		}
+
+		/* Now UPDATE the pid in the pidfile, because we changed it... */
+
+		if(!write_pid(pidfilename))
+			return -1;
 	}
 
-      /* Now UPDATE the pid in the pidfile, because we changed it... */
-      
-      if(!write_pid(pidfilename))
-        return -1;
-    }
-  
-  openlog(identname, LOG_CONS | LOG_PID, LOG_DAEMON);
-
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_NOTICE, _("tincd %s (%s %s) starting, debug level %d"),
-	   VERSION, __DATE__, __TIME__, debug_lvl);
-  else
-    syslog(LOG_NOTICE, _("tincd %s starting"), VERSION);
-
-  xalloc_fail_func = memory_full;
-cp
-  return 0;
+	openlogger(identname, use_logfile?LOGMODE_FILE:(do_detach?LOGMODE_SYSLOG:LOGMODE_STDERR));
+
+	logger(LOG_NOTICE, _("tincd %s (%s %s) starting, debug level %d"),
+			   VERSION, __DATE__, __TIME__, debug_level);
+
+	xalloc_fail_func = memory_full;
+
+	return 0;
 }
 
 /*
-  Execute the program name, with sane environment.  All output will be
-  redirected to syslog.
+  Execute the program name, with sane environment.
 */
-void _execute_script(const char *name)  __attribute__ ((noreturn));
-void _execute_script(const char *name)
+static void _execute_script(const char *scriptname, char **envp)
+	__attribute__ ((noreturn));
+static void _execute_script(const char *scriptname, char **envp)
 {
-  char *scriptname;
-  char *s;
-cp
-  if(netname)
-    {
-      asprintf(&s, "NETNAME=%s", netname);
-      putenv(s);	/* Don't free s! see man 3 putenv */
-    }
-#ifdef HAVE_UNSETENV
-  else
-    {
-      unsetenv("NETNAME");
-    }
-#endif
+	int save_errno;
+
+	cp();
+
+	while(*envp)
+		putenv(*envp++);
+
+	chdir("/");
+
+	closelogger();
+
+	/* Close all file descriptors */
+	fcloseall();
+
+	execl(scriptname, NULL);
+	/* No return on success */
+
+	save_errno = errno;
 
-  chdir("/");
-  
-  asprintf(&scriptname, "%s/%s", confbase, name);
-
-  /* Close all file descriptors */
-  closelog();		/* <- this means we cannot use syslog() here anymore! */
-  fcloseall();
-
-  execl(scriptname, NULL);
-  /* No return on success */
-  
-  if(errno != ENOENT)	/* Ignore if the file does not exist */
-    exit(1);		/* Some error while trying execl(). */
-  else
-    exit(0);
+	openlogger(identname, use_logfile?LOGMODE_FILE:(do_detach?LOGMODE_SYSLOG:LOGMODE_STDERR));
+	logger(LOG_ERR, _("Could not execute `%s': %s"), scriptname,
+		   strerror(save_errno));
+	exit(save_errno);
 }
 
 /*
   Fork and execute the program pointed to by name.
 */
-int execute_script(const char *name)
+int execute_script(const char *name, char **envp)
 {
-  pid_t pid;
-  int status;
-cp
-  if((pid = fork()) < 0)
-    {
-      syslog(LOG_ERR, _("System call `%s' failed: %m"),
-	     "fork");
-      return -1;
-    }
-
-  if(pid)
-    {
-      if(debug_lvl >= DEBUG_STATUS)
-        syslog(LOG_INFO, _("Executing script %s"), name);
-
-      if(waitpid(pid, &status, 0) == pid)
-        {
-          if(WIFEXITED(status))		/* Child exited by itself */
-            {
-              if(WEXITSTATUS(status))
-                {
-                  syslog(LOG_ERR, _("Process %d (%s) exited with non-zero status %d"), pid, name, WEXITSTATUS(status));
-                  return -1;
-                }
-              else
-                return 0;
-            }
-          else if(WIFSIGNALED(status))	/* Child was killed by a signal */
-	    {
-	      syslog(LOG_ERR, _("Process %d (%s) was killed by signal %d (%s)"),
-		     pid, name, WTERMSIG(status), strsignal(WTERMSIG(status)));
-	      return -1;
-	    }
-          else				/* Something strange happened */
-            {
-	      syslog(LOG_ERR, _("Process %d (%s) terminated abnormally"), pid, name);
-	      return -1;
-            }
-        }
-      else
-        {
-          syslog(LOG_ERR, _("System call `%s' failed: %m"), "waitpid");
-          return -1;
-        }
-    }
-cp
-  /* Child here */
-
-  _execute_script(name);
+	pid_t pid;
+	int status;
+	struct stat s;
+	char *scriptname;
+
+	cp();
+
+	asprintf(&scriptname, "%s/%s", confbase, name);
+
+	/* First check if there is a script */
+
+	if(stat(scriptname, &s))
+		return 0;
+
+	pid = fork();
+
+	if(pid < 0) {
+		logger(LOG_ERR, _("System call `%s' failed: %s"), "fork",
+			   strerror(errno));
+		return -1;
+	}
+
+	if(pid) {
+		ifdebug(STATUS) logger(LOG_INFO, _("Executing script %s"), name);
+
+		free(scriptname);
+
+		if(waitpid(pid, &status, 0) == pid) {
+			if(WIFEXITED(status)) {	/* Child exited by itself */
+				if(WEXITSTATUS(status)) {
+					logger(LOG_ERR, _("Process %d (%s) exited with non-zero status %d"),
+						   pid, name, WEXITSTATUS(status));
+					return -1;
+				} else
+					return 0;
+			} else if(WIFSIGNALED(status)) {	/* Child was killed by a signal */
+				logger(LOG_ERR, _("Process %d (%s) was killed by signal %d (%s)"), pid,
+					   name, WTERMSIG(status), strsignal(WTERMSIG(status)));
+				return -1;
+			} else {			/* Something strange happened */
+				logger(LOG_ERR, _("Process %d (%s) terminated abnormally"), pid,
+					   name);
+				return -1;
+			}
+		} else if (errno != EINTR) {
+			logger(LOG_ERR, _("System call `%s' failed: %s"), "waitpid",
+				   strerror(errno));
+			return -1;
+		}
+
+		/* Why do we get EINTR? */
+		return 0;
+	}
+
+	/* Child here */
+
+	_execute_script(scriptname, envp);
 }
 
 
@@ -287,147 +296,161 @@ cp
   Signal handlers.
 */
 
-RETSIGTYPE
-sigterm_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigterm_handler(int a)
 {
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_NOTICE, _("Got TERM signal"));
+	logger(LOG_NOTICE, _("Got TERM signal"));
+
+	cleanup_and_exit(0);
+}
 
-  cleanup_and_exit(0);
+static RETSIGTYPE sigquit_handler(int a)
+{
+	logger(LOG_NOTICE, _("Got QUIT signal"));
+	cleanup_and_exit(0);
 }
 
-RETSIGTYPE
-sigquit_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE fatal_signal_square(int a)
 {
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_NOTICE, _("Got QUIT signal"));
-  cleanup_and_exit(0);
+	logger(LOG_ERR, _("Got another fatal signal %d (%s): not restarting."), a,
+		   strsignal(a));
+	cp_trace();
+	exit(1);
 }
 
-RETSIGTYPE
-sigsegv_square(int a, siginfo_t *info, void *b)
+static RETSIGTYPE fatal_signal_handler(int a)
 {
-  syslog(LOG_ERR, _("Got another SEGV signal: not restarting"));
-  cp_trace();
-  exit(1);
+	struct sigaction act;
+	logger(LOG_ERR, _("Got fatal signal %d (%s)"), a, strsignal(a));
+	cp_trace();
+
+	if(do_detach) {
+		logger(LOG_NOTICE, _("Trying to re-execute in 5 seconds..."));
+
+		act.sa_handler = fatal_signal_square;
+		act.sa_mask = emptysigset;
+		act.sa_flags = 0;
+		sigaction(SIGSEGV, &act, NULL);
+
+		close_network_connections();
+		sleep(5);
+		remove_pid(pidfilename);
+		execvp(g_argv[0], g_argv);
+	} else {
+		logger(LOG_NOTICE, _("Not restarting."));
+		exit(1);
+	}
 }
 
-RETSIGTYPE
-sigsegv_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sighup_handler(int a)
 {
-  struct sigaction act;
-  syslog(LOG_ERR, _("Got SEGV signal"));
-  cp_trace();
-
-  if(do_detach)
-    {
-      syslog(LOG_NOTICE, _("Trying to re-execute in 5 seconds..."));
-
-      act.sa_handler = NULL;
-      act.sa_mask = emptysigset;
-      act.sa_flags = SA_SIGINFO;
-      act.sa_sigaction = sigsegv_square;
-
-      close_network_connections();
-      sleep(5);
-      remove_pid(pidfilename);
-      execvp(g_argv[0], g_argv);
-    }
-  else
-    {
-      syslog(LOG_NOTICE, _("Not restarting."));
-      exit(0);
-    }
+	logger(LOG_NOTICE, _("Got HUP signal"));
+	sighup = 1;
 }
 
-RETSIGTYPE
-sighup_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigint_handler(int a)
 {
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_NOTICE, _("Got HUP signal"));
-  sighup = 1;
+	if(saved_debug_level != -1) {
+		logger(LOG_NOTICE, _("Reverting to old debug level (%d)"),
+			saved_debug_level);
+		debug_level = saved_debug_level;
+		saved_debug_level = -1;
+	} else {
+		logger(LOG_NOTICE,
+			_("Temporarily setting debug level to 5.  Kill me with SIGINT again to go back to level %d."),
+			debug_level);
+		saved_debug_level = debug_level;
+		debug_level = 5;
+	}
 }
 
-RETSIGTYPE
-sigint_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigalrm_handler(int a)
 {
-  if(debug_lvl > DEBUG_NOTHING)
-    syslog(LOG_NOTICE, _("Got INT signal, exiting"));
-  cleanup_and_exit(0);
+	logger(LOG_NOTICE, _("Got ALRM signal"));
+	sigalrm = 1;
 }
 
-RETSIGTYPE
-sigusr1_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigusr1_handler(int a)
 {
-  dump_connection_list();
+	dump_connections();
 }
 
-RETSIGTYPE
-sigusr2_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigusr2_handler(int a)
 {
-  dump_subnet_list();
+	dump_device_stats();
+	dump_nodes();
+	dump_edges();
+	dump_subnets();
 }
 
-RETSIGTYPE
-unexpected_signal_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE sigwinch_handler(int a)
 {
-  syslog(LOG_WARNING, _("Got unexpected signal %d (%s)"), a, strsignal(a));
-  cp_trace();
+	extern int do_purge;
+	do_purge = 1;
 }
 
-RETSIGTYPE
-ignore_signal_handler(int a, siginfo_t *info, void *b)
+static RETSIGTYPE unexpected_signal_handler(int a)
 {
-  if(debug_lvl >= DEBUG_SCARY_THINGS)
-  {
-    syslog(LOG_WARNING, _("Got unexpected signal %d (%s)"), a, strsignal(a));
-    cp_trace();
-  }
+	logger(LOG_WARNING, _("Got unexpected signal %d (%s)"), a, strsignal(a));
+	cp_trace();
 }
 
-struct {
-  int signal;
-  void (*handler)(int, siginfo_t *, void *);
+static RETSIGTYPE ignore_signal_handler(int a)
+{
+	ifdebug(SCARY_THINGS) logger(LOG_DEBUG, _("Ignored signal %d (%s)"), a, strsignal(a));
+}
+
+static struct {
+	int signal;
+	void (*handler)(int);
 } sighandlers[] = {
-  { SIGHUP, sighup_handler },
-  { SIGTERM, sigterm_handler },
-  { SIGQUIT, sigquit_handler },
-  { SIGSEGV, sigsegv_handler },
-  { SIGPIPE, ignore_signal_handler },
-  { SIGINT, sigint_handler },
-  { SIGUSR1, sigusr1_handler },
-  { SIGUSR2, sigusr2_handler },
-  { SIGCHLD, ignore_signal_handler },
-  { SIGALRM, ignore_signal_handler },
-  { 0, NULL }
+	{
+	SIGHUP, sighup_handler}, {
+	SIGTERM, sigterm_handler}, {
+	SIGQUIT, sigquit_handler}, {
+	SIGSEGV, fatal_signal_handler}, {
+	SIGBUS, fatal_signal_handler}, {
+	SIGILL, fatal_signal_handler}, {
+	SIGPIPE, ignore_signal_handler}, {
+	SIGINT, sigint_handler}, {
+	SIGUSR1, sigusr1_handler}, {
+	SIGUSR2, sigusr2_handler}, {
+	SIGCHLD, ignore_signal_handler}, {
+	SIGALRM, sigalrm_handler}, {
+	SIGWINCH, sigwinch_handler}, {
+	0, NULL}
 };
 
-void
-setup_signals(void)
+void setup_signals(void)
 {
-  int i;
-  struct sigaction act;
-
-  sigemptyset(&emptysigset);
-  act.sa_handler = NULL;
-  act.sa_mask = emptysigset;
-  act.sa_flags = SA_SIGINFO;
-
-  /* Set a default signal handler for every signal, errors will be
-     ignored. */
-  for(i = 0; i < NSIG; i++) 
-    {
-      act.sa_sigaction = unexpected_signal_handler;
-      sigaction(i, &act, NULL);
-    }
-
-  /* Then, for each known signal that we want to catch, assign a
-     handler to the signal, with error checking this time. */
-  for(i = 0; sighandlers[i].signal; i++)
-    {
-      act.sa_sigaction = sighandlers[i].handler;
-      if(sigaction(sighandlers[i].signal, &act, NULL) < 0)
-	fprintf(stderr, _("Installing signal handler for signal %d (%s) failed: %m\n"),
-		sighandlers[i].signal, strsignal(sighandlers[i].signal));
-    }
+	int i;
+	struct sigaction act;
+
+	sigemptyset(&emptysigset);
+	act.sa_handler = NULL;
+	act.sa_mask = emptysigset;
+	act.sa_flags = 0;
+
+	/* Set a default signal handler for every signal, errors will be
+	   ignored. */
+	for(i = 0; i < NSIG; i++) {
+		if(!do_detach)
+			act.sa_handler = SIG_DFL;
+		else
+			act.sa_handler = unexpected_signal_handler;
+		sigaction(i, &act, NULL);
+	}
+
+	/* If we didn't detach, allow coredumps */
+	if(!do_detach)
+		sighandlers[3].handler = SIG_DFL;
+
+	/* Then, for each known signal that we want to catch, assign a
+	   handler to the signal, with error checking this time. */
+	for(i = 0; sighandlers[i].signal; i++) {
+		act.sa_handler = sighandlers[i].handler;
+		if(sigaction(sighandlers[i].signal, &act, NULL) < 0)
+			fprintf(stderr, _("Installing signal handler for signal %d (%s) failed: %s\n"),
+					sighandlers[i].signal, strsignal(sighandlers[i].signal),
+					strerror(errno));
+	}
 }