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 up."), VERSION, __DATE__, __TIME__);

  return 0;
}

pid_t
run_script (const run_script_cb &cb, bool wait)
{
  sigset_t oldset;

  if (wait)
    {
      sigset_t sigchld;
      sigemptyset (&sigchld);
      sigaddset (&sigchld, SIGCHLD);
      sigprocmask (SIG_BLOCK, &sigchld, &oldset);
    }

  pid_t pid = fork ();

  if (pid == 0)
    {
      sigprocmask (SIG_SETMASK, &oldset, 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);

          sigprocmask (SIG_SETMASK, &oldset, 0);

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

  return pid;
}

#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.24
Committed:	Sun Aug 10 14:48:57 2008 UTC (15 years, 9 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_2, rel-2_21, rel-2_22
Changes since 1.23:	+1 -1 lines
Log Message:	* empty log message *
#	Content
1	/*
2	util.C -- process management and other utility functions
3	Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4
5	Some of these are taken from tinc, see the AUTHORS file.
6
7	This file is part of GVPE.
8
9	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	*/
33
34	#include "config.h"
35
36	#include <cstdio>
37	#include <cstdlib>
38	#include <cstring>
39
40	#include <errno.h>
41	#include <signal.h>
42	#include <sys/types.h>
43	#include <sys/wait.h>
44	#include <unistd.h>
45	#include <time.h>
46
47	#include "netcompat.h"
48
49	#include "gettext.h"
50	#include "pidfile.h"
51	#include "dropin.h"
52
53	#include "global.h"
54	#include "conf.h"
55	#include "util.h"
56	#include "slog.h"
57
58	int
59	write_pidfile (void)
60	{
61	int pid;
62
63	pid = check_pid (conf.pidfilename);
64
65	if (pid)
66	{
67	fprintf (stderr, _("A gvpe daemon is already running with pid %d.\n"), pid);
68	return 1;
69	}
70
71	/* if it's locked, write-protected, or whatever */
72	if (!write_pid (conf.pidfilename))
73	return 1;
74
75	return 0;
76	}
77
78	int
79	kill_other (int signal)
80	{
81	int pid;
82
83	pid = read_pid (conf.pidfilename);
84
85	if (!pid)
86	{
87	fprintf (stderr, _("No other gvpe daemon is running.\n"));
88	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	fprintf (stderr, _("The gvpe daemon is no longer running. "));
97
98	fprintf (stderr, _("Removing stale lock file.\n"));
99	remove_pid (conf.pidfilename);
100	}
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	if (!write_pid (conf.pidfilename))
130	return -1;
131
132	log_to (LOGTO_SYSLOG);
133	}
134	else
135	log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
136
137	slog (L_INFO, _("gvpe daemon %s (%s %s) starting up."), VERSION, __DATE__, __TIME__);
138
139	return 0;
140	}
141
142	pid_t
143	run_script (const run_script_cb &cb, bool wait)
144	{
145	sigset_t oldset;
146
147	if (wait)
148	{
149	sigset_t sigchld;
150	sigemptyset (&sigchld);
151	sigaddset (&sigchld, SIGCHLD);
152	sigprocmask (SIG_BLOCK, &sigchld, &oldset);
153	}
154
155	pid_t pid = fork ();
156
157	if (pid == 0)
158	{
159	sigprocmask (SIG_SETMASK, &oldset, 0);
160
161	execl ("/bin/sh", "/bin/sh", "-c", cb (), (char *) 0);
162	exit (EXIT_FAILURE);
163	}
164	else if (pid > 0)
165	{
166	if (wait)
167	{
168	int status;
169	int res = waitpid (pid, &status, 0);
170
171	sigprocmask (SIG_SETMASK, &oldset, 0);
172
173	if (res < 0)
174	{
175	slog (L_WARN, _("waiting for an external command failed: %s."),
176	strerror (errno));
177	return 0;
178	}
179	else if (!WIFEXITED (status) \|\| WEXITSTATUS (status) != EXIT_SUCCESS)
180	{
181	slog (L_WARN, _("external command returned with exit status %d (%04x)."),
182	WEXITSTATUS (status), status);
183	return 0;
184	}
185	}
186	}
187	else
188	{
189	slog (L_ERR, _("unable to fork, exiting: %s"), strerror (errno));
190	exit (EXIT_FAILURE);
191	}
192
193	return pid;
194	}
195
196	#if ENABLE_HTTP_PROXY
197	// works like strdup
198	u8 *
199	base64_encode (const u8 *data, unsigned int len)
200	{
201	const static char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
202
203	unsigned int t, i;
204	const u8 *end = data + len;
205	u8 res = new u8 [4 ((len + 2) / 3) + 1];
206	u8 *out = res;
207
208	while (data <= end - 3)
209	{
210	t = (((data[0] << 8) \| data[1]) << 8) \| data[2];
211	data += 3;
212
213	*out++ = base64[(t >> 18) & 0x3f];
214	*out++ = base64[(t >> 12) & 0x3f];
215	*out++ = base64[(t >> 6) & 0x3f];
216	*out++ = base64[(t ) & 0x3f];
217	}
218
219	for (t = 0, i = 0; data < end; i++)
220	t = (t << 8) \| *data++;
221
222	switch (i)
223	{
224	case 2:
225	*out++ = base64[(t >> 10) & 0x3f];
226	*out++ = base64[(t >> 4) & 0x3f];
227	*out++ = base64[(t << 2) & 0x3f];
228	*out++ = '=';
229	break;
230	case 1:
231	*out++ = base64[(t >> 2) & 0x3f];
232	*out++ = base64[(t << 4) & 0x3f];
233	*out++ = '=';
234	*out++ = '=';
235	break;
236	}
237
238	*out++ = 0;
239
240	return res;
241	}
242	#endif
243
244	void
245	id2mac (unsigned int id, void *m)
246	{
247	mac &p = (mac )m;
248
249	if (id)
250	{
251	p[0] = 0xfe;
252	p[1] = 0xfd;
253	p[2] = 0x80;
254	p[3] = 0x00;
255	p[4] = id >> 8;
256	p[5] = id;
257	}
258	else
259	{
260	p[0] = 0xff;
261	p[1] = 0xff;
262	p[2] = 0xff;
263	p[3] = 0xff;
264	p[4] = 0xff;
265	p[5] = 0xff;
266	}
267	}
268