gvpe/src/util.C

/*
    util.C -- process management and other utility functions
    Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>
    
    Some of these are taken from tinc, see the AUTHORS file.
 
    This file is part of GVPE.

    GVPE is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with gvpe; if not, write to the Free Software
    Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "config.h"

#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <time.h>

#include "netcompat.h"

#include "gettext.h"
#include "pidfile.h"
#include "dropin.h"

#include "global.h"
#include "conf.h"
#include "util.h"
#include "slog.h"

int
write_pidfile (void)
{
  int pid;

  pid = check_pid (conf.pidfilename);

  if (pid)
    {
      fprintf (stderr, _("A gvpe daemon is already running with pid %d.\n"), pid);
      return 1;
    }

  /* if it's locked, write-protected, or whatever */
  if (!write_pid (conf.pidfilename))
    return 1;

  return 0;
}

int
kill_other (int signal)
{
  int pid;

  pid = read_pid (conf.pidfilename);

  if (!pid)
    {
      fprintf (stderr, _("No other gvpe daemon 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)
    {
      fprintf (stderr, _("The gvpe daemon is no longer running. "));

      fprintf (stderr, _("Removing stale lock file.\n"));
      remove_pid (conf.pidfilename);
    }

  return 0;
}

int
detach (int do_detach)
{
  /* First check if we can open a fresh new pidfile */

  if (write_pidfile ())
    return -1;

  /* If we succeeded in doing that, detach */

  log_to (0);

  if (do_detach)
    {
      if (daemon (0, 0) < 0)
        {
          log_to (LOGTO_SYSLOG | LOGTO_STDERR);

          slog (L_ERR, _("couldn't detach from terminal: %s"), strerror (errno));
          return -1;
        }

      /* Now UPDATE the pid in the pidfile, because we changed it... */

      if (!write_pid (conf.pidfilename))
        return -1;

      log_to (LOGTO_SYSLOG);
    }
  else
    log_to (LOGTO_SYSLOG | LOGTO_STDERR);

  slog (L_INFO, _("gvpe daemon %s (%s %s) starting"), VERSION, __DATE__, __TIME__);

  return 0;
}

bool run_script (const run_script_cb &cb, bool wait)
{
  if (wait)
    signal (SIGCHLD, SIG_DFL); // this is extremely ugly, but I did not feel like implementing a complete wait() event logic. It's easier to write this long comment to make your editor happy.

  int pid = fork ();

  if (pid == 0)
    {
      execl ("/bin/sh", "/bin/sh", "-c", cb (), (char *) 0);
      exit (EXIT_FAILURE);
    }
  else if (pid > 0)
    {
      if (wait)
        {
          int status;
          int res = waitpid (pid, &status, 0);

          signal (SIGCHLD, SIG_IGN);

          if (res < 0)
            {
              slog (L_WARN, _("waiting for an external command failed: %s."),
                    strerror (errno));
              return false;
            }
          else if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS)
            {
              slog (L_WARN, _("external command returned with exit status %d (%04x)."),
                    WEXITSTATUS (status), status);
              return false;
            }
        }
    }
  else
    {
      slog (L_ERR, _("unable to fork, exiting: %s"), strerror (errno));
      exit (EXIT_FAILURE);
    }

  return true;
}

#if ENABLE_HTTP_PROXY
// works like strdup
u8 *
base64_encode (const u8 *data, unsigned int len)
{
  const static char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

  unsigned int t, i;
  const u8 *end = data + len;
  u8 *res = new u8 [4 * ((len + 2) / 3) + 1];
  u8 *out = res;

  while (data <= end - 3)
    {
      t = (((data[0] << 8) | data[1]) << 8) | data[2];
      data += 3;
      
      *out++ = base64[(t >> 18) & 0x3f];
      *out++ = base64[(t >> 12) & 0x3f];
      *out++ = base64[(t >>  6) & 0x3f];
      *out++ = base64[(t      ) & 0x3f];
    }

  for (t = 0, i = 0; data < end; i++)
    t = (t << 8) | *data++;

  switch (i)
    {
      case 2:
        *out++ = base64[(t >> 10) & 0x3f];
        *out++ = base64[(t >>  4) & 0x3f];
        *out++ = base64[(t <<  2) & 0x3f];
        *out++ = '=';
        break;
      case 1:
        *out++ = base64[(t >>  2) & 0x3f];
        *out++ = base64[(t <<  4) & 0x3f];
        *out++ = '=';
        *out++ = '=';
        break;
    }

  *out++ = 0;

  return res;
}
#endif

void
id2mac (unsigned int id, void *m)
{
  mac &p = *(mac *)m;

  if (id)
    {
      p[0] = 0xfe;
      p[1] = 0xfd;
      p[2] = 0x80;
      p[3] = 0x00;
      p[4] = id >> 8;
      p[5] = id;
    }
  else
    {
      p[0] = 0xff;
      p[1] = 0xff;
      p[2] = 0xff;
      p[3] = 0xff;
      p[4] = 0xff;
      p[5] = 0xff;
    }
}

Revision:	1.20
Committed:	Fri Apr 8 16:12:49 2005 UTC (19 years, 1 month ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1_9
Changes since 1.19:	+14 -3 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/*
2			util.C -- process management and other utility functions
3	pcg	1.16	Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>
4	pcg	1.1
5	pcg	1.3	Some of these are taken from tinc, see the AUTHORS file.
6	pcg	1.1
7	pcg	1.16	This file is part of GVPE.
8
9			GVPE is free software; you can redistribute it and/or modify
10	pcg	1.1	it under the terms of the GNU General Public License as published by
11			the Free Software Foundation; either version 2 of the License, or
12			(at your option) any later version.
13
14			This program is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			GNU General Public License for more details.
18
19			You should have received a copy of the GNU General Public License
20	pcg	1.16	along with gvpe; if not, write to the Free Software
21	pcg	1.1	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22			*/
23
24			#include "config.h"
25
26			#include <cstdio>
27	pcg	1.12	#include <cstdlib>
28	pcg	1.1	#include <cstring>
29
30			#include <errno.h>
31			#include <signal.h>
32			#include <sys/types.h>
33	pcg	1.4	#include <sys/wait.h>
34	pcg	1.1	#include <unistd.h>
35			#include <time.h>
36
37	pcg	1.8	#include "netcompat.h"
38	pcg	1.1
39	pcg	1.18	#include "gettext.h"
40	pcg	1.1	#include "pidfile.h"
41			#include "dropin.h"
42
43			#include "global.h"
44			#include "conf.h"
45	pcg	1.5	#include "util.h"
46	pcg	1.1	#include "slog.h"
47
48			int
49			write_pidfile (void)
50			{
51			int pid;
52
53	pcg	1.13	pid = check_pid (conf.pidfilename);
54	pcg	1.1
55			if (pid)
56			{
57	pcg	1.15	fprintf (stderr, _("A gvpe daemon is already running with pid %d.\n"), pid);
58	pcg	1.1	return 1;
59			}
60
61			/* if it's locked, write-protected, or whatever */
62	pcg	1.13	if (!write_pid (conf.pidfilename))
63	pcg	1.1	return 1;
64
65			return 0;
66			}
67
68			int
69			kill_other (int signal)
70			{
71			int pid;
72
73	pcg	1.13	pid = read_pid (conf.pidfilename);
74	pcg	1.1
75			if (!pid)
76			{
77	pcg	1.15	fprintf (stderr, _("No other gvpe daemon is running.\n"));
78	pcg	1.1	return 1;
79			}
80
81			errno = 0; /* No error, sometimes errno is only changed on error */
82
83			/* ESRCH is returned when no process with that pid is found */
84			if (kill (pid, signal) && errno == ESRCH)
85			{
86	pcg	1.15	fprintf (stderr, _("The gvpe daemon is no longer running. "));
87	pcg	1.1
88			fprintf (stderr, _("Removing stale lock file.\n"));
89	pcg	1.13	remove_pid (conf.pidfilename);
90	pcg	1.1	}
91
92			return 0;
93			}
94
95			int
96			detach (int do_detach)
97			{
98			/* First check if we can open a fresh new pidfile */
99
100			if (write_pidfile ())
101			return -1;
102
103			/* If we succeeded in doing that, detach */
104
105			log_to (0);
106
107			if (do_detach)
108			{
109			if (daemon (0, 0) < 0)
110			{
111			log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
112
113			slog (L_ERR, _("couldn't detach from terminal: %s"), strerror (errno));
114			return -1;
115			}
116
117			/* Now UPDATE the pid in the pidfile, because we changed it... */
118
119	pcg	1.13	if (!write_pid (conf.pidfilename))
120	pcg	1.1	return -1;
121
122			log_to (LOGTO_SYSLOG);
123			}
124			else
125			log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
126
127	pcg	1.15	slog (L_INFO, _("gvpe daemon %s (%s %s) starting"), VERSION, __DATE__, __TIME__);
128	pcg	1.1
129			return 0;
130			}
131
132	pcg	1.19	bool run_script (const run_script_cb &cb, bool wait)
133	pcg	1.4	{
134	pcg	1.20	if (wait)
135			signal (SIGCHLD, SIG_DFL); // this is extremely ugly, but I did not feel like implementing a complete wait() event logic. It's easier to write this long comment to make your editor happy.
136	pcg	1.4
137	pcg	1.20	int pid = fork ();
138
139			if (pid == 0)
140	pcg	1.4	{
141	pcg	1.19	execl ("/bin/sh", "/bin/sh", "-c", cb (), (char *) 0);
142			exit (EXIT_FAILURE);
143	pcg	1.4	}
144			else if (pid > 0)
145			{
146			if (wait)
147			{
148	pcg	1.19	int status;
149	pcg	1.20	int res = waitpid (pid, &status, 0);
150
151			signal (SIGCHLD, SIG_IGN);
152	pcg	1.19
153	pcg	1.20	if (res < 0)
154	pcg	1.19	{
155			slog (L_WARN, _("waiting for an external command failed: %s."),
156			strerror (errno));
157			return false;
158			}
159			else if (!WIFEXITED (status) \|\| WEXITSTATUS (status) != EXIT_SUCCESS)
160			{
161			slog (L_WARN, _("external command returned with exit status %d (%04x)."),
162			WEXITSTATUS (status), status);
163			return false;
164			}
165	pcg	1.4	}
166			}
167	pcg	1.20	else
168			{
169			slog (L_ERR, _("unable to fork, exiting: %s"), strerror (errno));
170			exit (EXIT_FAILURE);
171			}
172	pcg	1.19
173			return true;
174	pcg	1.4	}
175	pcg	1.7
176			#if ENABLE_HTTP_PROXY
177			// works like strdup
178			u8 *
179			base64_encode (const u8 *data, unsigned int len)
180			{
181			const static char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
182
183			unsigned int t, i;
184			const u8 *end = data + len;
185			u8 res = new u8 [4 ((len + 2) / 3) + 1];
186			u8 *out = res;
187
188			while (data <= end - 3)
189			{
190			t = (((data[0] << 8) \| data[1]) << 8) \| data[2];
191			data += 3;
192
193			*out++ = base64[(t >> 18) & 0x3f];
194			*out++ = base64[(t >> 12) & 0x3f];
195			*out++ = base64[(t >> 6) & 0x3f];
196			*out++ = base64[(t ) & 0x3f];
197			}
198
199			for (t = 0, i = 0; data < end; i++)
200			t = (t << 8) \| *data++;
201
202			switch (i)
203			{
204			case 2:
205			*out++ = base64[(t >> 10) & 0x3f];
206			*out++ = base64[(t >> 4) & 0x3f];
207			*out++ = base64[(t << 2) & 0x3f];
208			*out++ = '=';
209			break;
210			case 1:
211			*out++ = base64[(t >> 2) & 0x3f];
212			*out++ = base64[(t << 4) & 0x3f];
213			*out++ = '=';
214			*out++ = '=';
215			break;
216			}
217
218			*out++ = 0;
219
220			return res;
221			}
222			#endif
223
224	pcg	1.10	void
225			id2mac (unsigned int id, void *m)
226			{
227			mac &p = (mac )m;
228
229			if (id)
230			{
231			p[0] = 0xfe;
232			p[1] = 0xfd;
233			p[2] = 0x80;
234			p[3] = 0x00;
235			p[4] = id >> 8;
236			p[5] = id;
237			}
238			else
239			{
240			p[0] = 0xff;
241			p[1] = 0xff;
242			p[2] = 0xff;
243			p[3] = 0xff;
244			p[4] = 0xff;
245			p[5] = 0xff;
246			}
247			}
248