gvpe/src/util.C

/*
    util.C -- process management and other utility functions
    Copyright (C) 2003-2008 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 3 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 this program; if not, see <http://www.gnu.org/licenses/>.
   
    Additional permission under GNU GPL version 3 section 7
   
    If you modify this Program, or any covered work, by linking or
    combining it with the OpenSSL project's OpenSSL library (or a modified
    version of that library), containing parts covered by the terms of the
    OpenSSL or SSLeay licenses, the licensors of this Program grant you
    additional permission to convey the resulting work.  Corresponding
    Source for a non-source form of such a combination shall include the
    source code for the parts of OpenSSL used as well as that of the
    covered work.
*/

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