gvpe/src/util.C

/*
    util.C -- process management and other utility functions
    Copyright (C) 2003-2011 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 <queue>

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

#if ENABLE_PTHREADS
# include <pthread.h>
#endif

#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 0 /* not yet used */

#if ENABLE_PTHREADS
struct async_cb
{
  callback<void ()> work_cb;
  callback<void ()> done_cb;
};

static ev::async async_done_w;
static std::queue< callback<void ()> > async_q;

static callback<void ()> work_cb;

static void *
async_exec (void *)
{
  work_cb ();
  async_done_w.send ();

  return 0;
}

static void
async_q_next ()
{
  work_cb = async_q.front (); async_q.pop ();

  sigset_t fullsigset, oldsigset;
  pthread_attr_t attr;
  pthread_t tid;

  pthread_attr_init (&attr);
  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
  //pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < X_STACKSIZE ? X_STACKSIZE : PTHREAD_STACK_MIN);
  sigfillset (&fullsigset);
  pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);

  if (pthread_create (&tid, &attr, async_exec, 0))
    async_exec (0);

  pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
  pthread_attr_destroy (&attr);
}

namespace {
  void
  async_done (ev::async &w, int revents)
  {
    callback<void ()> done_cb = async_q.front (); async_q.pop ();

    if (async_q.empty ())
      async_done_w.stop ();
    else
      async_q_next ();

    done_cb ();
  }
};

void
async (callback<void ()> work_cb, callback<void ()> done_cb)
{
  bool was_empty = async_q.empty ();

  async_q.push (work_cb);
  async_q.push (done_cb);

  if (was_empty)
    {
      async_done_w.set<async_done> ();
      async_done_w.start ();
      async_q_next ();
    }
}

#else

void
async (callback<void ()> work_cb, callback<void ()> done_cb)
{
  work_cb ();
  done_cb ();
}

#endif

#endif

/*****************************************************************************/

void hexdump (const char *header, void *data, int len)
{
  u8 *p = (u8 *)data;

  printf ("%s:", header);

  while (len--)
    printf (" %02x", *p++);

  printf ("\n");
}

/*****************************************************************************/

#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.26
Committed:	Wed Jul 17 05:34:17 2013 UTC (10 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.25:	+14 -0 lines
Log Message:	* empty log message *
#	Content
1	/*
2	util.C -- process management and other utility functions
3	Copyright (C) 2003-2011 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 <queue>
41
42	#include <errno.h>
43	#include <signal.h>
44	#include <sys/types.h>
45	#include <sys/wait.h>
46	#include <unistd.h>
47	#include <time.h>
48
49	#if ENABLE_PTHREADS
50	# include <pthread.h>
51	#endif
52
53	#include "netcompat.h"
54
55	#include "gettext.h"
56	#include "pidfile.h"
57	#include "dropin.h"
58
59	#include "global.h"
60	#include "conf.h"
61	#include "util.h"
62	#include "slog.h"
63
64	int
65	write_pidfile (void)
66	{
67	int pid;
68
69	pid = check_pid (conf.pidfilename);
70
71	if (pid)
72	{
73	fprintf (stderr, _("A gvpe daemon is already running with pid %d.\n"), pid);
74	return 1;
75	}
76
77	/* if it's locked, write-protected, or whatever */
78	if (!write_pid (conf.pidfilename))
79	return 1;
80
81	return 0;
82	}
83
84	int
85	kill_other (int signal)
86	{
87	int pid;
88
89	pid = read_pid (conf.pidfilename);
90
91	if (!pid)
92	{
93	fprintf (stderr, _("No other gvpe daemon is running.\n"));
94	return 1;
95	}
96
97	errno = 0; /* No error, sometimes errno is only changed on error */
98
99	/* ESRCH is returned when no process with that pid is found */
100	if (kill (pid, signal) && errno == ESRCH)
101	{
102	fprintf (stderr, _("The gvpe daemon is no longer running. "));
103
104	fprintf (stderr, _("Removing stale lock file.\n"));
105	remove_pid (conf.pidfilename);
106	}
107
108	return 0;
109	}
110
111	int
112	detach (int do_detach)
113	{
114	/* First check if we can open a fresh new pidfile */
115
116	if (write_pidfile ())
117	return -1;
118
119	/* If we succeeded in doing that, detach */
120
121	log_to (0);
122
123	if (do_detach)
124	{
125	if (daemon (0, 0) < 0)
126	{
127	log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
128
129	slog (L_ERR, _("couldn't detach from terminal: %s"), strerror (errno));
130	return -1;
131	}
132
133	/* Now UPDATE the pid in the pidfile, because we changed it... */
134
135	if (!write_pid (conf.pidfilename))
136	return -1;
137
138	log_to (LOGTO_SYSLOG);
139	}
140	else
141	log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
142
143	slog (L_INFO, _("gvpe daemon %s (%s %s) starting up."), VERSION, __DATE__, __TIME__);
144
145	return 0;
146	}
147
148	/*****************************************************************************/
149
150	pid_t
151	run_script (const run_script_cb &cb, bool wait)
152	{
153	sigset_t oldset;
154
155	if (wait)
156	{
157	sigset_t sigchld;
158	sigemptyset (&sigchld);
159	sigaddset (&sigchld, SIGCHLD);
160	sigprocmask (SIG_BLOCK, &sigchld, &oldset);
161	}
162
163	pid_t pid = fork ();
164
165	if (pid == 0)
166	{
167	sigprocmask (SIG_SETMASK, &oldset, 0);
168
169	execl ("/bin/sh", "/bin/sh", "-c", cb (), (char *) 0);
170	exit (EXIT_FAILURE);
171	}
172	else if (pid > 0)
173	{
174	if (wait)
175	{
176	int status;
177	int res = waitpid (pid, &status, 0);
178
179	sigprocmask (SIG_SETMASK, &oldset, 0);
180
181	if (res < 0)
182	{
183	slog (L_WARN, _("waiting for an external command failed: %s."),
184	strerror (errno));
185	return 0;
186	}
187	else if (!WIFEXITED (status) \|\| WEXITSTATUS (status) != EXIT_SUCCESS)
188	{
189	slog (L_WARN, _("external command returned with exit status %d (%04x)."),
190	WEXITSTATUS (status), status);
191	return 0;
192	}
193	}
194	}
195	else
196	{
197	slog (L_ERR, _("unable to fork, exiting: %s"), strerror (errno));
198	exit (EXIT_FAILURE);
199	}
200
201	return pid;
202	}
203
204	/*****************************************************************************/
205
206	#if 0 /* not yet used */
207
208	#if ENABLE_PTHREADS
209	struct async_cb
210	{
211	callback<void ()> work_cb;
212	callback<void ()> done_cb;
213	};
214
215	static ev::async async_done_w;
216	static std::queue< callback<void ()> > async_q;
217
218	static callback<void ()> work_cb;
219
220	static void *
221	async_exec (void *)
222	{
223	work_cb ();
224	async_done_w.send ();
225
226	return 0;
227	}
228
229	static void
230	async_q_next ()
231	{
232	work_cb = async_q.front (); async_q.pop ();
233
234	sigset_t fullsigset, oldsigset;
235	pthread_attr_t attr;
236	pthread_t tid;
237
238	pthread_attr_init (&attr);
239	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
240	//pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < X_STACKSIZE ? X_STACKSIZE : PTHREAD_STACK_MIN);
241	sigfillset (&fullsigset);
242	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
243
244	if (pthread_create (&tid, &attr, async_exec, 0))
245	async_exec (0);
246
247	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
248	pthread_attr_destroy (&attr);
249	}
250
251	namespace {
252	void
253	async_done (ev::async &w, int revents)
254	{
255	callback<void ()> done_cb = async_q.front (); async_q.pop ();
256
257	if (async_q.empty ())
258	async_done_w.stop ();
259	else
260	async_q_next ();
261
262	done_cb ();
263	}
264	};
265
266	void
267	async (callback<void ()> work_cb, callback<void ()> done_cb)
268	{
269	bool was_empty = async_q.empty ();
270
271	async_q.push (work_cb);
272	async_q.push (done_cb);
273
274	if (was_empty)
275	{
276	async_done_w.set<async_done> ();
277	async_done_w.start ();
278	async_q_next ();
279	}
280	}
281
282	#else
283
284	void
285	async (callback<void ()> work_cb, callback<void ()> done_cb)
286	{
287	work_cb ();
288	done_cb ();
289	}
290
291	#endif
292
293	#endif
294
295	/*****************************************************************************/
296
297	void hexdump (const char header, void data, int len)
298	{
299	u8 p = (u8 )data;
300
301	printf ("%s:", header);
302
303	while (len--)
304	printf (" %02x", *p++);
305
306	printf ("\n");
307	}
308
309	/*****************************************************************************/
310
311	#if ENABLE_HTTP_PROXY
312	// works like strdup
313	u8 *
314	base64_encode (const u8 *data, unsigned int len)
315	{
316	const static char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
317
318	unsigned int t, i;
319	const u8 *end = data + len;
320	u8 res = new u8 [4 ((len + 2) / 3) + 1];
321	u8 *out = res;
322
323	while (data <= end - 3)
324	{
325	t = (((data[0] << 8) \| data[1]) << 8) \| data[2];
326	data += 3;
327
328	*out++ = base64[(t >> 18) & 0x3f];
329	*out++ = base64[(t >> 12) & 0x3f];
330	*out++ = base64[(t >> 6) & 0x3f];
331	*out++ = base64[(t ) & 0x3f];
332	}
333
334	for (t = 0, i = 0; data < end; i++)
335	t = (t << 8) \| *data++;
336
337	switch (i)
338	{
339	case 2:
340	*out++ = base64[(t >> 10) & 0x3f];
341	*out++ = base64[(t >> 4) & 0x3f];
342	*out++ = base64[(t << 2) & 0x3f];
343	*out++ = '=';
344	break;
345	case 1:
346	*out++ = base64[(t >> 2) & 0x3f];
347	*out++ = base64[(t << 4) & 0x3f];
348	*out++ = '=';
349	*out++ = '=';
350	break;
351	}
352
353	*out++ = 0;
354
355	return res;
356	}
357	#endif
358
359	void
360	id2mac (unsigned int id, void *m)
361	{
362	mac &p = (mac )m;
363
364	if (id)
365	{
366	p[0] = 0xfe;
367	p[1] = 0xfd;
368	p[2] = 0x80;
369	p[3] = 0x00;
370	p[4] = id >> 8;
371	p[5] = id;
372	}
373	else
374	{
375	p[0] = 0xff;
376	p[1] = 0xff;
377	p[2] = 0xff;
378	p[3] = 0xff;
379	p[4] = 0xff;
380	p[5] = 0xff;
381	}
382	}
383