2000-03-26 00:33:07 +00:00
|
|
|
/*
|
|
|
|
net.c -- most of the network code
|
2006-04-26 13:52:58 +00:00
|
|
|
Copyright (C) 1998-2005 Ivo Timmermans,
|
2009-03-05 13:12:36 +00:00
|
|
|
2000-2009 Guus Sliepen <guus@tinc-vpn.org>
|
2000-03-26 00:33:07 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
|
2009-09-24 22:01:00 +00:00
|
|
|
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.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2000-03-26 00:33:07 +00:00
|
|
|
*/
|
|
|
|
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "system.h"
|
2000-11-15 01:06:13 +00:00
|
|
|
|
2001-07-04 08:41:36 +00:00
|
|
|
#include <openssl/rand.h>
|
2000-03-26 00:33:07 +00:00
|
|
|
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "utils.h"
|
|
|
|
#include "avl_tree.h"
|
2002-02-18 16:25:19 +00:00
|
|
|
#include "conf.h"
|
|
|
|
#include "connection.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "device.h"
|
|
|
|
#include "event.h"
|
|
|
|
#include "graph.h"
|
|
|
|
#include "logger.h"
|
2002-02-18 16:25:19 +00:00
|
|
|
#include "meta.h"
|
|
|
|
#include "net.h"
|
|
|
|
#include "netutl.h"
|
|
|
|
#include "process.h"
|
|
|
|
#include "protocol.h"
|
|
|
|
#include "route.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "subnet.h"
|
2003-07-29 22:59:01 +00:00
|
|
|
#include "xalloc.h"
|
2000-03-26 00:33:07 +00:00
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
bool do_purge = false;
|
2003-08-17 12:05:08 +00:00
|
|
|
volatile bool running = false;
|
2000-03-26 00:33:07 +00:00
|
|
|
|
2002-03-01 14:09:31 +00:00
|
|
|
time_t now = 0;
|
|
|
|
|
2002-09-04 13:48:52 +00:00
|
|
|
/* Purge edges and subnets of unreachable nodes. Use carefully. */
|
2002-02-10 21:57:54 +00:00
|
|
|
|
2003-07-06 23:16:29 +00:00
|
|
|
static void purge(void)
|
2002-02-10 21:57:54 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
avl_node_t *nnode, *nnext, *enode, *enext, *snode, *snext;
|
|
|
|
node_t *n;
|
|
|
|
edge_t *e;
|
|
|
|
subnet_t *s;
|
|
|
|
|
|
|
|
cp();
|
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(PROTOCOL) logger(LOG_DEBUG, _("Purging unreachable nodes"));
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-08-22 15:04:26 +00:00
|
|
|
/* Remove all edges and subnets owned by unreachable nodes. */
|
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
for(nnode = node_tree->head; nnode; nnode = nnext) {
|
|
|
|
nnext = nnode->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
n = nnode->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(!n->status.reachable) {
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(SCARY_THINGS) logger(LOG_DEBUG, _("Purging node %s (%s)"), n->name,
|
2002-09-09 21:25:28 +00:00
|
|
|
n->hostname);
|
|
|
|
|
|
|
|
for(snode = n->subnet_tree->head; snode; snode = snext) {
|
|
|
|
snext = snode->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
s = snode->data;
|
2003-11-17 15:30:18 +00:00
|
|
|
if(!tunnelserver)
|
|
|
|
send_del_subnet(broadcast, s);
|
2002-09-09 21:25:28 +00:00
|
|
|
subnet_del(n, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
for(enode = n->edge_tree->head; enode; enode = enext) {
|
|
|
|
enext = enode->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
e = enode->data;
|
2003-11-17 15:30:18 +00:00
|
|
|
if(!tunnelserver)
|
|
|
|
send_del_edge(broadcast, e);
|
2002-09-09 21:25:28 +00:00
|
|
|
edge_del(e);
|
|
|
|
}
|
2003-08-22 15:04:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
|
|
|
|
|
|
|
|
for(nnode = node_tree->head; nnode; nnode = nnext) {
|
|
|
|
nnext = nnode->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
n = nnode->data;
|
2003-08-22 15:04:26 +00:00
|
|
|
|
|
|
|
if(!n->status.reachable) {
|
|
|
|
for(enode = edge_weight_tree->head; enode; enode = enext) {
|
|
|
|
enext = enode->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
e = enode->data;
|
2003-08-22 15:04:26 +00:00
|
|
|
|
|
|
|
if(e->to == n)
|
|
|
|
break;
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-08-22 15:04:26 +00:00
|
|
|
if(!enode)
|
|
|
|
node_del(n);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
2002-02-10 21:57:54 +00:00
|
|
|
}
|
|
|
|
|
2002-03-27 14:02:36 +00:00
|
|
|
/*
|
|
|
|
put all file descriptors in an fd_set array
|
|
|
|
While we're at it, purge stuff that needs to be removed.
|
|
|
|
*/
|
2006-01-19 17:13:18 +00:00
|
|
|
static int build_fdset(fd_set *readset, fd_set *writeset)
|
2002-03-27 14:02:36 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
avl_node_t *node, *next;
|
|
|
|
connection_t *c;
|
2003-01-17 00:37:20 +00:00
|
|
|
int i, max = 0;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
cp();
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
FD_ZERO(readset);
|
|
|
|
FD_ZERO(writeset);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
for(node = connection_tree->head; node; node = next) {
|
|
|
|
next = node->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
c = node->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(c->status.remove) {
|
|
|
|
connection_del(c);
|
|
|
|
if(!connection_tree->head)
|
|
|
|
purge();
|
2003-01-17 00:37:20 +00:00
|
|
|
} else {
|
2006-01-19 17:13:18 +00:00
|
|
|
FD_SET(c->socket, readset);
|
|
|
|
if(c->outbuflen > 0)
|
|
|
|
FD_SET(c->socket, writeset);
|
2003-01-17 00:37:20 +00:00
|
|
|
if(c->socket > max)
|
|
|
|
max = c->socket;
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for(i = 0; i < listen_sockets; i++) {
|
2006-01-19 17:13:18 +00:00
|
|
|
FD_SET(listen_socket[i].tcp, readset);
|
2003-01-17 00:37:20 +00:00
|
|
|
if(listen_socket[i].tcp > max)
|
|
|
|
max = listen_socket[i].tcp;
|
2006-01-19 17:13:18 +00:00
|
|
|
FD_SET(listen_socket[i].udp, readset);
|
2003-01-17 00:37:20 +00:00
|
|
|
if(listen_socket[i].udp > max)
|
|
|
|
max = listen_socket[i].udp;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
2009-09-15 20:59:01 +00:00
|
|
|
if(device_fd >= 0)
|
|
|
|
FD_SET(device_fd, readset);
|
2003-01-17 00:37:20 +00:00
|
|
|
if(device_fd > max)
|
|
|
|
max = device_fd;
|
|
|
|
|
|
|
|
return max;
|
2002-03-27 14:02:36 +00:00
|
|
|
}
|
|
|
|
|
2000-03-26 00:33:07 +00:00
|
|
|
/*
|
2001-07-20 20:25:10 +00:00
|
|
|
Terminate a connection:
|
2001-10-30 16:34:32 +00:00
|
|
|
- Close the socket
|
2003-07-22 20:55:21 +00:00
|
|
|
- Remove associated edge and tell other connections about it if report = true
|
2001-10-30 16:34:32 +00:00
|
|
|
- Check if we need to retry making an outgoing connection
|
2001-07-20 20:25:10 +00:00
|
|
|
- Deactivate the host
|
2000-03-26 00:33:07 +00:00
|
|
|
*/
|
2003-07-22 20:55:21 +00:00
|
|
|
void terminate_connection(connection_t *c, bool report)
|
2000-03-26 00:33:07 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
cp();
|
|
|
|
|
|
|
|
if(c->status.remove)
|
|
|
|
return;
|
2002-02-18 16:25:19 +00:00
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(CONNECTIONS) logger(LOG_NOTICE, _("Closing connection with %s (%s)"),
|
2002-09-09 21:25:28 +00:00
|
|
|
c->name, c->hostname);
|
2001-10-30 16:34:32 +00:00
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
c->status.remove = true;
|
|
|
|
c->status.active = false;
|
2002-03-27 14:02:36 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
if(c->node)
|
|
|
|
c->node->connection = NULL;
|
2002-09-04 13:48:52 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
if(c->socket)
|
2003-07-29 22:59:01 +00:00
|
|
|
closesocket(c->socket);
|
2002-09-04 13:48:52 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
if(c->edge) {
|
2003-11-17 15:30:18 +00:00
|
|
|
if(report && !tunnelserver)
|
2002-09-09 21:25:28 +00:00
|
|
|
send_del_edge(broadcast, c->edge);
|
2002-02-10 21:57:54 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
edge_del(c->edge);
|
2002-09-04 13:48:52 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
/* Run MST and SSSP algorithms */
|
2002-09-04 13:48:52 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
graph();
|
2003-08-28 15:27:12 +00:00
|
|
|
|
|
|
|
/* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
|
|
|
|
|
|
|
|
if(report && !c->node->status.reachable) {
|
|
|
|
edge_t *e;
|
|
|
|
e = lookup_edge(c->node, myself);
|
|
|
|
if(e) {
|
2003-11-17 15:30:18 +00:00
|
|
|
if(!tunnelserver)
|
|
|
|
send_del_edge(broadcast, e);
|
2003-08-28 15:27:12 +00:00
|
|
|
edge_del(e);
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
2002-09-03 20:43:26 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
/* Check if this was our outgoing connection */
|
2001-10-30 16:34:32 +00:00
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
if(c->outgoing) {
|
|
|
|
retry_outgoing(c->outgoing);
|
|
|
|
c->outgoing = NULL;
|
|
|
|
}
|
2006-01-19 17:13:18 +00:00
|
|
|
|
|
|
|
free(c->outbuf);
|
|
|
|
c->outbuf = NULL;
|
|
|
|
c->outbuflen = 0;
|
|
|
|
c->outbufsize = 0;
|
|
|
|
c->outbufstart = 0;
|
2000-03-26 00:33:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-05-14 13:02:20 +00:00
|
|
|
Check if the other end is active.
|
|
|
|
If we have sent packets, but didn't receive any,
|
|
|
|
then possibly the other end is dead. We send a
|
|
|
|
PING request over the meta connection. If the other
|
|
|
|
end does not reply in time, we consider them dead
|
|
|
|
and close the connection.
|
2000-03-26 00:33:07 +00:00
|
|
|
*/
|
2003-07-06 23:16:29 +00:00
|
|
|
static void check_dead_connections(void)
|
2000-03-26 00:33:07 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
avl_node_t *node, *next;
|
|
|
|
connection_t *c;
|
|
|
|
|
|
|
|
cp();
|
|
|
|
|
|
|
|
for(node = connection_tree->head; node; node = next) {
|
|
|
|
next = node->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
c = node->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(c->last_ping_time + pingtimeout < now) {
|
|
|
|
if(c->status.active) {
|
|
|
|
if(c->status.pinged) {
|
2006-08-08 13:29:17 +00:00
|
|
|
ifdebug(CONNECTIONS) logger(LOG_INFO, _("%s (%s) didn't respond to PING in %ld seconds"),
|
2006-01-19 17:13:18 +00:00
|
|
|
c->name, c->hostname, now - c->last_ping_time);
|
2003-07-22 20:55:21 +00:00
|
|
|
c->status.timeout = true;
|
|
|
|
terminate_connection(c, true);
|
2006-01-19 17:13:18 +00:00
|
|
|
} else if(c->last_ping_time + pinginterval < now) {
|
2002-09-09 21:25:28 +00:00
|
|
|
send_ping(c);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(c->status.remove) {
|
2003-07-12 17:41:48 +00:00
|
|
|
logger(LOG_WARNING, _("Old connection_t for %s (%s) status %04x still lingering, deleting..."),
|
2009-09-09 10:04:08 +00:00
|
|
|
c->name, c->hostname, bitfield_to_int(&c->status, sizeof c->status));
|
2002-09-09 21:25:28 +00:00
|
|
|
connection_del(c);
|
|
|
|
continue;
|
|
|
|
}
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(CONNECTIONS) logger(LOG_WARNING, _("Timeout from %s (%s) during authentication"),
|
2002-09-09 21:25:28 +00:00
|
|
|
c->name, c->hostname);
|
2004-06-21 14:37:52 +00:00
|
|
|
if(c->status.connecting) {
|
|
|
|
c->status.connecting = false;
|
|
|
|
closesocket(c->socket);
|
|
|
|
do_outgoing_connection(c);
|
|
|
|
} else {
|
|
|
|
terminate_connection(c, false);
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
2006-01-19 17:13:18 +00:00
|
|
|
|
|
|
|
if(c->outbuflen > 0 && c->last_flushed_time + pingtimeout < now) {
|
|
|
|
if(c->status.active) {
|
|
|
|
ifdebug(CONNECTIONS) logger(LOG_INFO,
|
2006-08-08 13:29:17 +00:00
|
|
|
_("%s (%s) could not flush for %ld seconds (%d bytes remaining)"),
|
2006-01-19 17:13:18 +00:00
|
|
|
c->name, c->hostname, now - c->last_flushed_time, c->outbuflen);
|
|
|
|
c->status.timeout = true;
|
|
|
|
terminate_connection(c, true);
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
2000-03-26 00:33:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-10-27 12:13:17 +00:00
|
|
|
check all connections to see if anything
|
|
|
|
happened on their sockets
|
2000-03-26 00:33:07 +00:00
|
|
|
*/
|
2006-01-19 17:13:18 +00:00
|
|
|
static void check_network_activity(fd_set * readset, fd_set * writeset)
|
2000-03-26 00:33:07 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
connection_t *c;
|
|
|
|
avl_node_t *node;
|
|
|
|
int result, i;
|
2006-03-19 13:06:21 +00:00
|
|
|
socklen_t len = sizeof(result);
|
2002-09-09 21:25:28 +00:00
|
|
|
vpn_packet_t packet;
|
|
|
|
|
|
|
|
cp();
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
/* check input from kernel */
|
2009-09-15 20:59:01 +00:00
|
|
|
if(device_fd >= 0 && FD_ISSET(device_fd, readset)) {
|
2009-01-03 21:33:55 +00:00
|
|
|
if(read_packet(&packet)) {
|
|
|
|
packet.priority = 0;
|
2003-12-12 19:52:25 +00:00
|
|
|
route(myself, &packet);
|
2009-01-03 21:33:55 +00:00
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
/* check meta connections */
|
2002-09-09 21:25:28 +00:00
|
|
|
for(node = connection_tree->head; node; node = node->next) {
|
2003-08-28 21:05:11 +00:00
|
|
|
c = node->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(c->status.remove)
|
|
|
|
continue;
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
if(FD_ISSET(c->socket, readset)) {
|
2002-09-09 21:25:28 +00:00
|
|
|
if(c->status.connecting) {
|
2003-07-22 20:55:21 +00:00
|
|
|
c->status.connecting = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
getsockopt(c->socket, SOL_SOCKET, SO_ERROR, &result, &len);
|
|
|
|
|
|
|
|
if(!result)
|
|
|
|
finish_connecting(c);
|
|
|
|
else {
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(CONNECTIONS) logger(LOG_DEBUG,
|
2002-09-09 21:25:28 +00:00
|
|
|
_("Error while connecting to %s (%s): %s"),
|
|
|
|
c->name, c->hostname, strerror(result));
|
2003-07-29 22:59:01 +00:00
|
|
|
closesocket(c->socket);
|
2002-09-09 21:25:28 +00:00
|
|
|
do_outgoing_connection(c);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
if(!receive_meta(c)) {
|
2002-09-09 21:25:28 +00:00
|
|
|
terminate_connection(c, c->status.active);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2006-01-19 17:13:18 +00:00
|
|
|
|
|
|
|
if(FD_ISSET(c->socket, writeset)) {
|
|
|
|
if(!flush_meta(c)) {
|
|
|
|
terminate_connection(c, c->status.active);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for(i = 0; i < listen_sockets; i++) {
|
2006-01-19 17:13:18 +00:00
|
|
|
if(FD_ISSET(listen_socket[i].udp, readset))
|
2002-09-09 21:25:28 +00:00
|
|
|
handle_incoming_vpn_data(listen_socket[i].udp);
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
if(FD_ISSET(listen_socket[i].tcp, readset))
|
2002-09-09 21:25:28 +00:00
|
|
|
handle_new_meta_connection(listen_socket[i].tcp);
|
|
|
|
}
|
2001-10-30 16:34:32 +00:00
|
|
|
}
|
|
|
|
|
2000-03-26 00:33:07 +00:00
|
|
|
/*
|
2000-04-30 01:15:47 +00:00
|
|
|
this is where it all happens...
|
2000-03-26 00:33:07 +00:00
|
|
|
*/
|
2003-08-02 20:50:38 +00:00
|
|
|
int main_loop(void)
|
2000-03-26 00:33:07 +00:00
|
|
|
{
|
2006-01-19 17:13:18 +00:00
|
|
|
fd_set readset, writeset;
|
2002-09-09 21:25:28 +00:00
|
|
|
struct timeval tv;
|
2003-01-17 00:37:20 +00:00
|
|
|
int r, maxfd;
|
2006-11-11 14:11:16 +00:00
|
|
|
time_t last_ping_check, last_config_check, last_graph_dump;
|
2002-09-09 21:25:28 +00:00
|
|
|
event_t *event;
|
|
|
|
|
|
|
|
cp();
|
|
|
|
|
|
|
|
last_ping_check = now;
|
2003-04-03 11:43:17 +00:00
|
|
|
last_config_check = now;
|
2006-11-11 14:11:16 +00:00
|
|
|
last_graph_dump = now;
|
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
srand(now);
|
|
|
|
|
2003-08-02 20:50:38 +00:00
|
|
|
running = true;
|
|
|
|
|
|
|
|
while(running) {
|
2002-09-09 21:25:28 +00:00
|
|
|
now = time(NULL);
|
|
|
|
|
2003-12-20 19:47:53 +00:00
|
|
|
// tv.tv_sec = 1 + (rand() & 7); /* Approx. 5 seconds, randomized to prevent global synchronisation effects */
|
|
|
|
tv.tv_sec = 1;
|
2002-09-09 21:25:28 +00:00
|
|
|
tv.tv_usec = 0;
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
maxfd = build_fdset(&readset, &writeset);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2009-09-15 20:59:01 +00:00
|
|
|
#ifdef HAVE_MINGW
|
|
|
|
LeaveCriticalSection(&mutex);
|
|
|
|
#endif
|
2006-01-19 17:13:18 +00:00
|
|
|
r = select(maxfd + 1, &readset, &writeset, NULL, &tv);
|
2009-09-15 20:59:01 +00:00
|
|
|
#ifdef HAVE_MINGW
|
|
|
|
EnterCriticalSection(&mutex);
|
|
|
|
#endif
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(r < 0) {
|
|
|
|
if(errno != EINTR && errno != EAGAIN) {
|
2003-07-12 17:41:48 +00:00
|
|
|
logger(LOG_ERR, _("Error while waiting for input: %s"),
|
2002-09-09 21:25:28 +00:00
|
|
|
strerror(errno));
|
|
|
|
cp_trace();
|
|
|
|
dump_connections();
|
2003-08-02 20:50:38 +00:00
|
|
|
return 1;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-01-19 17:13:18 +00:00
|
|
|
check_network_activity(&readset, &writeset);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(do_purge) {
|
|
|
|
purge();
|
2003-07-22 20:55:21 +00:00
|
|
|
do_purge = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Let's check if everybody is still alive */
|
|
|
|
|
|
|
|
if(last_ping_check + pingtimeout < now) {
|
|
|
|
check_dead_connections();
|
|
|
|
last_ping_check = now;
|
|
|
|
|
|
|
|
if(routing_mode == RMODE_SWITCH)
|
2003-12-12 19:52:25 +00:00
|
|
|
age_subnets();
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
age_past_requests();
|
|
|
|
|
|
|
|
/* Should we regenerate our key? */
|
|
|
|
|
|
|
|
if(keyexpires < now) {
|
2009-04-02 23:05:23 +00:00
|
|
|
avl_node_t *node;
|
|
|
|
node_t *n;
|
|
|
|
|
|
|
|
ifdebug(STATUS) logger(LOG_INFO, _("Expiring symmetric keys"));
|
|
|
|
|
|
|
|
for(node = node_tree->head; node; node = node->next) {
|
|
|
|
n = node->data;
|
|
|
|
if(n->inkey) {
|
|
|
|
free(n->inkey);
|
|
|
|
n->inkey = NULL;
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
send_key_changed(broadcast, myself);
|
|
|
|
keyexpires = now + keylifetime;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-19 21:50:05 +00:00
|
|
|
if(sigalrm) {
|
|
|
|
logger(LOG_INFO, _("Flushing event queue"));
|
|
|
|
expire_events();
|
|
|
|
sigalrm = false;
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
while((event = get_expired_event())) {
|
|
|
|
event->handler(event->data);
|
2006-11-11 22:44:15 +00:00
|
|
|
free_event(event);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(sighup) {
|
2003-04-03 11:43:17 +00:00
|
|
|
connection_t *c;
|
|
|
|
avl_node_t *node;
|
|
|
|
char *fname;
|
|
|
|
struct stat s;
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
sighup = false;
|
2003-04-03 11:43:17 +00:00
|
|
|
|
|
|
|
/* Reread our own configuration file */
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-04-03 11:43:17 +00:00
|
|
|
exit_configuration(&config_tree);
|
2002-09-09 21:25:28 +00:00
|
|
|
init_configuration(&config_tree);
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
if(!read_server_config()) {
|
2003-07-12 17:41:48 +00:00
|
|
|
logger(LOG_ERR, _("Unable to reread configuration file, exitting."));
|
2003-08-02 20:50:38 +00:00
|
|
|
return 1;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
2003-04-03 11:43:17 +00:00
|
|
|
/* Close connections to hosts that have a changed or deleted host config file */
|
|
|
|
|
|
|
|
for(node = connection_tree->head; node; node = node->next) {
|
2003-08-28 21:05:11 +00:00
|
|
|
c = node->data;
|
2003-04-03 11:43:17 +00:00
|
|
|
|
2009-09-08 16:18:36 +00:00
|
|
|
xasprintf(&fname, "%s/hosts/%s", confbase, c->name);
|
2003-04-03 11:43:17 +00:00
|
|
|
if(stat(fname, &s) || s.st_mtime > last_config_check)
|
|
|
|
terminate_connection(c, c->status.active);
|
|
|
|
free(fname);
|
|
|
|
}
|
|
|
|
|
|
|
|
last_config_check = now;
|
2002-02-18 16:25:19 +00:00
|
|
|
|
2003-04-03 11:43:17 +00:00
|
|
|
/* Try to make outgoing connections */
|
|
|
|
|
|
|
|
try_outgoing_connections();
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
2006-11-11 14:11:16 +00:00
|
|
|
|
|
|
|
/* Dump graph if wanted every 60 seconds*/
|
|
|
|
|
|
|
|
if(last_graph_dump + 60 < now) {
|
|
|
|
dump_graph();
|
|
|
|
last_graph_dump = now;
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
2003-08-02 20:50:38 +00:00
|
|
|
|
|
|
|
return 0;
|
2000-03-26 00:33:07 +00:00
|
|
|
}
|