gvpe/src/util.C

/*
    util.C -- process management and other utility functions
    Copyright (C) 2003 Marc Lehmann <pcg@goof.com>
    
    Some of these are taken from tinc, see the AUTHORS file.
 
    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
    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 this program; 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 (pidfilename);

  if (pid)
    {
      fprintf (stderr, _("A vped 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;
}

int
kill_other (int signal)
{
  int pid;

  pid = read_pid (pidfilename);

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

      fprintf (stderr, _("Removing stale lock file.\n"));
      remove_pid (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 (pidfilename))
        return -1;

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

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

  return 0;
}

void
make_names (void)
{
  if (!pidfilename)
    pidfilename = LOCALSTATEDIR "/run/vped.pid";

  if (!confbase)
    asprintf (&confbase, "%s/vpe", CONFDIR);
}

void run_script (const run_script_cb &cb, bool wait)
{
  int pid;

  if ((pid = fork ()) == 0)
    {
      char *filename;
      asprintf (&filename, "%s/%s", confbase, cb());
      execl (filename, filename, (char *) 0);
      exit (126);
    }
  else if (pid > 0)
    {
      if (wait)
        {
          waitpid (pid, 0, 0);
          /* TODO: check status */
        }
    }
}

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