gvpe/src/util.C

/*
    util.C -- process management and other utility functions
    
    Most 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 <cstring>

#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <sys/mman.h>

#include <openssl/rand.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/evp.h>

#include "gettext.h"
#include "pidfile.h"
#include "dropin.h"

#include "global.h"
#include "conf.h"
#include "slog.h"
#include "protocol.h"

time_t now;

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 pkt_queue::put (tap_packet *p)
{
  if (queue[i])
    {
      delete queue[i];
      j = (j + 1) % QUEUEDEPTH;
    }

  queue[i] = p;

  i = (i + 1) % QUEUEDEPTH;
}

tap_packet *pkt_queue::get ()
{
  tap_packet *p = queue[j];

  if (p)
    {
      queue[j] = 0;
      j = (j + 1) % QUEUEDEPTH;
    }

  return p;
}

pkt_queue::pkt_queue ()
{
  memset (queue, 0, sizeof (queue));
  i = 0;
  j = 0;
}

pkt_queue::~pkt_queue ()
{
  for (i = QUEUEDEPTH; --i > 0; )
    delete queue[i];
}

sockinfo::operator const char *()
{
  static char hostport[15 + 1 + 5 + 1];
  in_addr ia = { host };

  sprintf (hostport, "%.15s:%d", inet_ntoa (ia), ntohs (port) & 0xffff);

  return hostport;
}

bool u32_rate_limiter::can (u32 host)
{
  iterator i;

  for (i = begin (); i != end (); )
    if (i->second <= now)
      {
        erase (i);
        i = begin ();
      }
    else
      ++i;

  i = find (host);

  if (i != end ())
    return false;

  insert (value_type (host, now + every));

  return true;
}

Revision:	1.1
Committed:	Sat Mar 1 15:53:03 2003 UTC (23 years, 8 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/*
2			util.C -- process management and other utility functions
3
4			Most of these are taken from tinc, see the AUTHORS file.
5
6			This program is free software; you can redistribute it and/or modify
7			it under the terms of the GNU General Public License as published by
8			the Free Software Foundation; either version 2 of the License, or
9			(at your option) any later version.
10
11			This program is distributed in the hope that it will be useful,
12			but WITHOUT ANY WARRANTY; without even the implied warranty of
13			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			GNU General Public License for more details.
15
16			You should have received a copy of the GNU General Public License
17			along with this program; if not, write to the Free Software
18			Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "config.h"
22
23			#include <cstdio>
24			#include <cstring>
25
26			#include <errno.h>
27			#include <signal.h>
28			#include <sys/types.h>
29			#include <unistd.h>
30			#include <time.h>
31			#include <sys/socket.h>
32			#include <netinet/in.h>
33			#include <arpa/inet.h>
34
35			#include <sys/mman.h>
36
37			#include <openssl/rand.h>
38			#include <openssl/rsa.h>
39			#include <openssl/pem.h>
40			#include <openssl/evp.h>
41
42			#include "gettext.h"
43			#include "pidfile.h"
44			#include "dropin.h"
45
46			#include "global.h"
47			#include "conf.h"
48			#include "slog.h"
49			#include "protocol.h"
50
51			time_t now;
52
53			int
54			write_pidfile (void)
55			{
56			int pid;
57
58			pid = check_pid (pidfilename);
59
60			if (pid)
61			{
62			fprintf (stderr, _("A vped is already running with pid %d.\n"), pid);
63			return 1;
64			}
65
66			/* if it's locked, write-protected, or whatever */
67			if (!write_pid (pidfilename))
68			return 1;
69
70			return 0;
71			}
72
73			int
74			kill_other (int signal)
75			{
76			int pid;
77
78			pid = read_pid (pidfilename);
79
80			if (!pid)
81			{
82			fprintf (stderr, _("No other vped is running.\n"));
83			return 1;
84			}
85
86			errno = 0; /* No error, sometimes errno is only changed on error */
87
88			/* ESRCH is returned when no process with that pid is found */
89			if (kill (pid, signal) && errno == ESRCH)
90			{
91			fprintf (stderr, _("The vped is no longer running. "));
92
93			fprintf (stderr, _("Removing stale lock file.\n"));
94			remove_pid (pidfilename);
95			}
96
97			return 0;
98			}
99
100			int
101			detach (int do_detach)
102			{
103			/* First check if we can open a fresh new pidfile */
104
105			if (write_pidfile ())
106			return -1;
107
108			/* If we succeeded in doing that, detach */
109
110			log_to (0);
111
112			if (do_detach)
113			{
114			if (daemon (0, 0) < 0)
115			{
116			log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
117
118			slog (L_ERR, _("couldn't detach from terminal: %s"), strerror (errno));
119			return -1;
120			}
121
122			/* Now UPDATE the pid in the pidfile, because we changed it... */
123
124			if (!write_pid (pidfilename))
125			return -1;
126
127			log_to (LOGTO_SYSLOG);
128			}
129			else
130			log_to (LOGTO_SYSLOG \| LOGTO_STDERR);
131
132			slog (L_INFO, _("vped %s (%s %s) starting"), VERSION, __DATE__, __TIME__);
133
134			return 0;
135			}
136
137			void
138			make_names (void)
139			{
140			if (!pidfilename)
141			pidfilename = LOCALSTATEDIR "/run/vped.pid";
142
143			if (!confbase)
144			asprintf (&confbase, "%s/vpe", CONFDIR);
145			}
146
147			void pkt_queue::put (tap_packet *p)
148			{
149			if (queue[i])
150			{
151			delete queue[i];
152			j = (j + 1) % QUEUEDEPTH;
153			}
154
155			queue[i] = p;
156
157			i = (i + 1) % QUEUEDEPTH;
158			}
159
160			tap_packet *pkt_queue::get ()
161			{
162			tap_packet *p = queue[j];
163
164			if (p)
165			{
166			queue[j] = 0;
167			j = (j + 1) % QUEUEDEPTH;
168			}
169
170			return p;
171			}
172
173			pkt_queue::pkt_queue ()
174			{
175			memset (queue, 0, sizeof (queue));
176			i = 0;
177			j = 0;
178			}
179
180			pkt_queue::~pkt_queue ()
181			{
182			for (i = QUEUEDEPTH; --i > 0; )
183			delete queue[i];
184			}
185
186			sockinfo::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
196			bool u32_rate_limiter::can (u32 host)
197			{
198			iterator i;
199
200			for (i = begin (); i != end (); )
201			if (i->second <= now)
202			{
203			erase (i);
204			i = begin ();
205			}
206			else
207			++i;
208
209			i = find (host);
210
211			if (i != end ())
212			return false;
213
214			insert (value_type (host, now + every));
215
216			return true;
217			}
218