ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/util.C
(Generate patch)

Comparing gvpe/src/util.C (file contents):
Revision 1.1 by pcg, Sat Mar 1 15:53:03 2003 UTC vs.
Revision 1.28 by root, Thu Jan 9 08:15:05 2014 UTC

1/* 1/*
2 util.C -- process management and other utility functions 2 util.C -- process management and other utility functions
3 Copyright (C) 2003-2011 Marc Lehmann <gvpe@schmorp.de>
3 4
4 Most of these are taken from tinc, see the AUTHORS file. 5 Some of these are taken from tinc, see the AUTHORS file.
5 6
7 This file is part of GVPE.
8
6 This program is free software; you can redistribute it and/or modify 9 GVPE is free software; you can redistribute it and/or modify it
7 it under the terms of the GNU General Public License as published by 10 under the terms of the GNU General Public License as published by the
8 the Free Software Foundation; either version 2 of the License, or 11 Free Software Foundation; either version 3 of the License, or (at your
9 (at your option) any later version. 12 option) any later version.
10 13
11 This program is distributed in the hope that it will be useful, 14 This program is distributed in the hope that it will be useful, but
12 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 GNU General Public License for more details. 17 Public License for more details.
15 18
16 You should have received a copy of the GNU General Public License 19 You should have received a copy of the GNU General Public License along
17 along with this program; if not, write to the Free Software 20 with this program; if not, see <http://www.gnu.org/licenses/>.
18 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 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.
19*/ 32*/
20 33
21#include "config.h" 34#include "config.h"
22 35
23#include <cstdio> 36#include <cstdio>
37#include <cstdlib>
24#include <cstring> 38#include <cstring>
39
40#include <queue>
25 41
26#include <errno.h> 42#include <errno.h>
27#include <signal.h> 43#include <signal.h>
28#include <sys/types.h> 44#include <sys/types.h>
45#include <sys/wait.h>
29#include <unistd.h> 46#include <unistd.h>
30#include <time.h> 47#include <time.h>
31#include <sys/socket.h>
32#include <netinet/in.h>
33#include <arpa/inet.h>
34 48
35#include <sys/mman.h> 49#if ENABLE_PTHREADS
50# include <pthread.h>
51#endif
36 52
37#include <openssl/rand.h> 53#include <openssl/rand.h>
38#include <openssl/rsa.h> 54
39#include <openssl/pem.h> 55#include "netcompat.h"
40#include <openssl/evp.h>
41 56
42#include "gettext.h" 57#include "gettext.h"
43#include "pidfile.h" 58#include "pidfile.h"
44#include "dropin.h" 59#include "dropin.h"
45 60
46#include "global.h" 61#include "global.h"
47#include "conf.h" 62#include "conf.h"
63#include "util.h"
48#include "slog.h" 64#include "slog.h"
49#include "protocol.h"
50
51time_t now;
52 65
53int 66int
54write_pidfile (void) 67write_pidfile (void)
55{ 68{
56 int pid; 69 int pid;
57 70
58 pid = check_pid (pidfilename); 71 pid = check_pid (conf.pidfilename);
59 72
60 if (pid) 73 if (pid)
61 { 74 {
62 fprintf (stderr, _("A vped is already running with pid %d.\n"), pid); 75 fprintf (stderr, _("A gvpe daemon is already running with pid %d.\n"), pid);
63 return 1; 76 return 1;
64 } 77 }
65 78
66 /* if it's locked, write-protected, or whatever */ 79 /* if it's locked, write-protected, or whatever */
67 if (!write_pid (pidfilename)) 80 if (!write_pid (conf.pidfilename))
68 return 1; 81 return 1;
69 82
70 return 0; 83 return 0;
71} 84}
72 85
73int 86int
74kill_other (int signal) 87kill_other (int signal)
75{ 88{
76 int pid; 89 int pid;
77 90
78 pid = read_pid (pidfilename); 91 pid = read_pid (conf.pidfilename);
79 92
80 if (!pid) 93 if (!pid)
81 { 94 {
82 fprintf (stderr, _("No other vped is running.\n")); 95 fprintf (stderr, _("No other gvpe daemon is running.\n"));
83 return 1; 96 return 1;
84 } 97 }
85 98
86 errno = 0; /* No error, sometimes errno is only changed on error */ 99 errno = 0; /* No error, sometimes errno is only changed on error */
87 100
88 /* ESRCH is returned when no process with that pid is found */ 101 /* ESRCH is returned when no process with that pid is found */
89 if (kill (pid, signal) && errno == ESRCH) 102 if (kill (pid, signal) && errno == ESRCH)
90 { 103 {
91 fprintf (stderr, _("The vped is no longer running. ")); 104 fprintf (stderr, _("The gvpe daemon is no longer running. "));
92 105
93 fprintf (stderr, _("Removing stale lock file.\n")); 106 fprintf (stderr, _("Removing stale lock file.\n"));
94 remove_pid (pidfilename); 107 remove_pid (conf.pidfilename);
95 } 108 }
96 109
97 return 0; 110 return 0;
98} 111}
99 112
… …
119 return -1; 132 return -1;
120 } 133 }
121 134
122 /* Now UPDATE the pid in the pidfile, because we changed it... */ 135 /* Now UPDATE the pid in the pidfile, because we changed it... */
123 136
124 if (!write_pid (pidfilename)) 137 if (!write_pid (conf.pidfilename))
125 return -1; 138 return -1;
126 139
127 log_to (LOGTO_SYSLOG); 140 log_to (LOGTO_SYSLOG);
128 } 141 }
129 else 142 else
130 log_to (LOGTO_SYSLOG | LOGTO_STDERR); 143 log_to (LOGTO_SYSLOG | LOGTO_STDERR);
131 144
132 slog (L_INFO, _("vped %s (%s %s) starting"), VERSION, __DATE__, __TIME__); 145 slog (L_INFO, _("gvpe daemon %s (%s %s) starting up."), VERSION, __DATE__, __TIME__);
133 146
134 return 0; 147 return 0;
135} 148}
136 149
150/*****************************************************************************/
151
152pid_t
153run_script (const run_script_cb &cb, bool wait)
154{
155 sigset_t oldset;
156
157 if (wait)
158 {
159 sigset_t sigchld;
160 sigemptyset (&sigchld);
161 sigaddset (&sigchld, SIGCHLD);
162 sigprocmask (SIG_BLOCK, &sigchld, &oldset);
163 }
164
165 pid_t pid = fork ();
166
167 if (pid == 0)
168 {
169 sigprocmask (SIG_SETMASK, &oldset, 0);
170
171 execl ("/bin/sh", "/bin/sh", "-c", cb (), (char *) 0);
172 exit (EXIT_FAILURE);
173 }
174 else if (pid > 0)
175 {
176 if (wait)
177 {
178 int status;
179 int res = waitpid (pid, &status, 0);
180
181 sigprocmask (SIG_SETMASK, &oldset, 0);
182
183 if (res < 0)
184 {
185 slog (L_WARN, _("waiting for an external command failed: %s."),
186 strerror (errno));
187 return 0;
188 }
189 else if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS)
190 {
191 slog (L_WARN, _("external command returned with exit status %d (%04x)."),
192 WEXITSTATUS (status), status);
193 return 0;
194 }
195 }
196 }
197 else
198 {
199 slog (L_ERR, _("unable to fork, exiting: %s"), strerror (errno));
200 exit (EXIT_FAILURE);
201 }
202
203 return pid;
204}
205
206/*****************************************************************************/
207
208#if 0 /* not yet used */
209
210#if ENABLE_PTHREADS
211struct async_cb
212{
213 callback<void ()> work_cb;
214 callback<void ()> done_cb;
215};
216
217static ev::async async_done_w;
218static std::queue< callback<void ()> > async_q;
219
220static callback<void ()> work_cb;
221
222static void *
223async_exec (void *)
224{
225 work_cb ();
226 async_done_w.send ();
227
228 return 0;
229}
230
231static void
232async_q_next ()
233{
234 work_cb = async_q.front (); async_q.pop ();
235
236 sigset_t fullsigset, oldsigset;
237 pthread_attr_t attr;
238 pthread_t tid;
239
240 pthread_attr_init (&attr);
241 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
242 //pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < X_STACKSIZE ? X_STACKSIZE : PTHREAD_STACK_MIN);
243 sigfillset (&fullsigset);
244 pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
245
246 if (pthread_create (&tid, &attr, async_exec, 0))
247 async_exec (0);
248
249 pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
250 pthread_attr_destroy (&attr);
251}
252
253namespace {
254 void
255 async_done (ev::async &w, int revents)
256 {
257 callback<void ()> done_cb = async_q.front (); async_q.pop ();
258
259 if (async_q.empty ())
260 async_done_w.stop ();
261 else
262 async_q_next ();
263
264 done_cb ();
265 }
266};
267
137void 268void
138make_names (void) 269async (callback<void ()> work_cb, callback<void ()> done_cb)
139{ 270{
140 if (!pidfilename) 271 bool was_empty = async_q.empty ();
141 pidfilename = LOCALSTATEDIR "/run/vped.pid";
142 272
143 if (!confbase) 273 async_q.push (work_cb);
144 asprintf (&confbase, "%s/vpe", CONFDIR); 274 async_q.push (done_cb);
145}
146 275
147void pkt_queue::put (tap_packet *p) 276 if (was_empty)
148{
149 if (queue[i])
150 {
151 delete queue[i];
152 j = (j + 1) % QUEUEDEPTH;
153 } 277 {
154 278 async_done_w.set<async_done> ();
155 queue[i] = p; 279 async_done_w.start ();
156 280 async_q_next ();
157 i = (i + 1) % QUEUEDEPTH;
158}
159
160tap_packet *pkt_queue::get ()
161{
162 tap_packet *p = queue[j];
163
164 if (p)
165 { 281 }
166 queue[j] = 0; 282}
167 j = (j + 1) % QUEUEDEPTH; 283
284#else
285
286void
287async (callback<void ()> work_cb, callback<void ()> done_cb)
288{
289 work_cb ();
290 done_cb ();
291}
292
293#endif
294
295#endif
296
297/*****************************************************************************/
298
299void hexdump (const char *header, void *data, int len)
300{
301 u8 *p = (u8 *)data;
302
303 printf ("%s:", header);
304
305 while (len--)
306 printf (" %02x", *p++);
307
308 printf ("\n");
309}
310
311/*****************************************************************************/
312
313#if ENABLE_HTTP_PROXY
314// works like strdup
315u8 *
316base64_encode (const u8 *data, unsigned int len)
317{
318 const static char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
319
320 unsigned int t, i;
321 const u8 *end = data + len;
322 u8 *res = new u8 [4 * ((len + 2) / 3) + 1];
323 u8 *out = res;
324
325 while (data <= end - 3)
168 } 326 {
169 327 t = (((data[0] << 8) | data[1]) << 8) | data[2];
170 return p; 328 data += 3;
171}
172
173pkt_queue::pkt_queue ()
174{
175 memset (queue, 0, sizeof (queue));
176 i = 0;
177 j = 0;
178}
179
180pkt_queue::~pkt_queue ()
181{
182 for (i = QUEUEDEPTH; --i > 0; )
183 delete queue[i];
184}
185
186sockinfo::operator const char *()
187{
188 static char hostport[15 + 1 + 5 + 1];
189 in_addr ia = { host };
190
191 sprintf (hostport, "%.15s:%d", inet_ntoa (ia), ntohs (port) & 0xffff);
192
193 return hostport;
194}
195
196bool u32_rate_limiter::can (u32 host)
197{
198 iterator i;
199
200 for (i = begin (); i != end (); )
201 if (i->second <= now)
202 { 329
203 erase (i); 330 *out++ = base64[(t >> 18) & 0x3f];
204 i = begin (); 331 *out++ = base64[(t >> 12) & 0x3f];
332 *out++ = base64[(t >> 6) & 0x3f];
333 *out++ = base64[(t ) & 0x3f];
205 } 334 }
206 else
207 ++i;
208 335
209 i = find (host); 336 for (t = 0, i = 0; data < end; i++)
337 t = (t << 8) | *data++;
210 338
211 if (i != end ()) 339 switch (i)
212 return false; 340 {
341 case 2:
342 *out++ = base64[(t >> 10) & 0x3f];
343 *out++ = base64[(t >> 4) & 0x3f];
344 *out++ = base64[(t << 2) & 0x3f];
345 *out++ = '=';
346 break;
347 case 1:
348 *out++ = base64[(t >> 2) & 0x3f];
349 *out++ = base64[(t << 4) & 0x3f];
350 *out++ = '=';
351 *out++ = '=';
352 break;
353 }
213 354
214 insert (value_type (host, now + every)); 355 *out++ = 0;
215 356
216 return true; 357 return res;
217} 358}
359#endif
218 360
361bool
362slow_memeq (const void *a, const void *b, int len)
363{
364 volatile const u8 *pa = (const u8 *)a;
365 volatile const u8 *pb = (const u8 *)b;
366 u8 diff = 0;
367
368 while (len--)
369 diff |= *pa++ ^ *pb++;
370
371 return !diff;
372}
373
374void
375id2mac (unsigned int id, void *m)
376{
377 mac &p = *(mac *)m;
378
379 if (id)
380 {
381 p[0] = 0xfe;
382 p[1] = 0xfd;
383 p[2] = 0x80;
384 p[3] = 0x00;
385 p[4] = id >> 8;
386 p[5] = id;
387 }
388 else
389 {
390 p[0] = 0xff;
391 p[1] = 0xff;
392 p[2] = 0xff;
393 p[3] = 0xff;
394 p[4] = 0xff;
395 p[5] = 0xff;
396 }
397}
398
399/*****************************************************************************/
400
401void rand_fill (void *data, int len)
402{
403 int l = RAND_bytes ((unsigned char *)data, len);
404
405 if (l > 0)
406 return;
407 else if (l == 0)
408 slog (L_WARN, _("Not enough random entropy to generate secure keys. Using weaker pseudo-random session keys."));
409 else
410 fatal (_("RAND_bytes failed, aborting."));
411}
412

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines