bc32b7cc7763e0e14eb27e23d1a2a64da042fba0
[tinc] / src / net.c
1 /*
2     net.c -- most of the network code
3     Copyright (C) 1998,1999,2000 Ivo Timmermans <itimmermans@bigfoot.com>,
4                             2000 Guus Sliepen <guus@sliepen.warande.net>
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: net.c,v 1.35.4.68 2000/11/07 21:43:28 guus Exp $
21 */
22
23 #include "config.h"
24
25 #include <arpa/inet.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <linux/sockios.h>
29 #include <net/if.h>
30 #include <netdb.h>
31 #include <netinet/in.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <sys/signal.h>
36 #include <sys/socket.h>
37 #include <sys/time.h>
38 #include <sys/types.h>
39 #include <syslog.h>
40 #include <unistd.h>
41 #include <sys/ioctl.h>
42 #include <openssl/rand.h>
43 #include <openssl/evp.h>
44 #include <openssl/err.h>
45
46 #ifdef HAVE_TUNTAP
47 #include LINUX_IF_TUN_H
48 #endif
49
50 #include <utils.h>
51 #include <xalloc.h>
52
53 #include "conf.h"
54 #include "connlist.h"
55 #include "meta.h"
56 #include "net.h"
57 #include "netutl.h"
58 #include "protocol.h"
59 #include "subnet.h"
60
61 #include "system.h"
62
63 int tap_fd = -1;
64 int taptype = TAP_TYPE_ETHERTAP;
65 int total_tap_in = 0;
66 int total_tap_out = 0;
67 int total_socket_in = 0;
68 int total_socket_out = 0;
69
70 config_t *upstreamcfg;
71 static int seconds_till_retry;
72
73 int keylifetime = 0;
74 int keyexpires = 0;
75
76 char *unknown = NULL;
77
78 subnet_t mymac;
79
80 /*
81   Execute the given script.
82   This function doesn't really belong here.
83 */
84 int execute_script(const char *name)
85 {
86   char *scriptname;
87   pid_t pid;
88   char *s;
89
90   if((pid = fork()) < 0)
91     {
92       syslog(LOG_ERR, _("System call `%s' failed: %m"),
93              "fork");
94       return -1;
95     }
96
97   if(pid)
98     {
99       return 0;
100     }
101
102   /* Child here */
103
104   if(netname)
105     {
106       asprintf(&s, "NETNAME=%s", netname);
107       putenv(s);        /* Don't free s! see man 3 putenv */
108     }
109   else
110     {
111       unsetenv("NETNAME");
112     }
113
114   chdir(confbase);      /* This cannot fail since we already read config files from this directory. */
115   
116   asprintf(&scriptname, "%s/%s", confbase, name);
117   execl(scriptname, NULL);
118
119   /* No return on success */
120   
121   if(errno != ENOENT)  /* Ignore if the file does not exist */
122     syslog(LOG_WARNING, _("Error executing `%s': %m"), scriptname);
123
124   /* No need to free things */
125
126   exit(0);
127 }
128
129 int xsend(conn_list_t *cl, vpn_packet_t *inpkt)
130 {
131   vpn_packet_t outpkt;
132   int outlen, outpad;
133   EVP_CIPHER_CTX ctx;
134 cp
135   outpkt.len = inpkt->len;
136   
137   /* Encrypt the packet */
138   
139   EVP_EncryptInit(&ctx, cl->cipher_pkttype, cl->cipher_pktkey, cl->cipher_pktkey + cl->cipher_pkttype->key_len);
140   EVP_EncryptUpdate(&ctx, outpkt.data, &outlen, inpkt->data, inpkt->len);
141   EVP_EncryptFinal(&ctx, outpkt.data + outlen, &outpad);
142   outlen += outpad + 2;
143
144 /* Bypass
145   outlen = outpkt.len + 2;
146   memcpy(&outpkt, inpkt, outlen);
147 */  
148
149   if(debug_lvl >= DEBUG_TRAFFIC)
150     syslog(LOG_ERR, _("Sending packet of %d bytes to %s (%s)"),
151            outlen, cl->name, cl->hostname);
152
153   total_socket_out += outlen;
154
155   if((send(cl->socket, (char *) &(outpkt.len), outlen, 0)) < 0)
156     {
157       syslog(LOG_ERR, _("Error sending packet to %s (%s): %m"),
158              cl->name, cl->hostname);
159       return -1;
160     }
161 cp
162   return 0;
163 }
164
165 int xrecv(conn_list_t *cl, vpn_packet_t *inpkt)
166 {
167   vpn_packet_t outpkt;
168   int outlen, outpad;
169   EVP_CIPHER_CTX ctx;
170 cp
171   outpkt.len = inpkt->len;
172
173   /* Decrypt the packet */
174
175   EVP_DecryptInit(&ctx, myself->cipher_pkttype, myself->cipher_pktkey, myself->cipher_pktkey + myself->cipher_pkttype->key_len);
176   EVP_DecryptUpdate(&ctx, outpkt.data, &outlen, inpkt->data, inpkt->len + 8);
177   EVP_DecryptFinal(&ctx, outpkt.data + outlen, &outpad);
178   outlen += outpad;
179
180 /* Bypass
181   outlen = outpkt.len+2;
182   memcpy(&outpkt, inpkt, outlen);
183 */
184      
185   if(debug_lvl >= DEBUG_TRAFFIC)
186     syslog(LOG_ERR, _("Writing packet of %d bytes to tap device"),
187            outpkt.len, outlen);
188
189   /* Fix mac address */
190
191   memcpy(outpkt.data, mymac.net.mac.address.x, 6);
192
193   if(taptype == TAP_TYPE_TUNTAP)
194     {
195       if(write(tap_fd, outpkt.data, outpkt.len) < 0)
196         syslog(LOG_ERR, _("Can't write to tun/tap device: %m"));
197       else
198         total_tap_out += outpkt.len;
199     }
200   else  /* ethertap */
201     {
202       if(write(tap_fd, outpkt.data - 2, outpkt.len + 2) < 0)
203         syslog(LOG_ERR, _("Can't write to ethertap device: %m"));
204       else
205         total_tap_out += outpkt.len + 2;
206     }
207 cp
208   return 0;
209 }
210
211 /*
212   add the given packet of size s to the
213   queue q, be it the send or receive queue
214 */
215 void add_queue(packet_queue_t **q, void *packet, size_t s)
216 {
217   queue_element_t *e;
218 cp
219   e = xmalloc(sizeof(*e));
220   e->packet = xmalloc(s);
221   memcpy(e->packet, packet, s);
222
223   if(!*q)
224     {
225       *q = xmalloc(sizeof(**q));
226       (*q)->head = (*q)->tail = NULL;
227     }
228
229   e->next = NULL;                       /* We insert at the tail */
230
231   if((*q)->tail)                        /* Do we have a tail? */
232     {
233       (*q)->tail->next = e;
234       e->prev = (*q)->tail;
235     }
236   else                                  /* No tail -> no head too */
237     {
238       (*q)->head = e;
239       e->prev = NULL;
240     }
241
242   (*q)->tail = e;
243 cp
244 }
245
246 /* Remove a queue element */
247 void del_queue(packet_queue_t **q, queue_element_t *e)
248 {
249 cp
250   free(e->packet);
251
252   if(e->next)                           /* There is a successor, so we are not tail */
253     {
254       if(e->prev)                       /* There is a predecessor, so we are not head */
255         {
256           e->next->prev = e->prev;
257           e->prev->next = e->next;
258         }
259       else                              /* We are head */
260         {
261           e->next->prev = NULL;
262           (*q)->head = e->next;
263         }
264     }
265   else                                  /* We are tail (or all alone!) */
266     {          
267       if(e->prev)                       /* We are not alone :) */
268         {
269           e->prev->next = NULL;
270           (*q)->tail = e->prev;
271         }
272       else                              /* Adieu */
273         {
274           free(*q);
275           *q = NULL;
276         }
277     }
278     
279   free(e);
280 cp
281 }
282
283 /*
284   flush a queue by calling function for
285   each packet, and removing it when that
286   returned a zero exit code
287 */
288 void flush_queue(conn_list_t *cl, packet_queue_t **pq,
289                  int (*function)(conn_list_t*,vpn_packet_t*))
290 {
291   queue_element_t *p, *next = NULL;
292 cp
293   for(p = (*pq)->head; p != NULL; )
294     {
295       next = p->next;
296
297       if(!function(cl, p->packet))
298         del_queue(pq, p);
299         
300       p = next;
301     }
302
303   if(debug_lvl >= DEBUG_TRAFFIC)
304     syslog(LOG_DEBUG, _("Queue flushed"));
305 cp
306 }
307
308 /*
309   flush the send&recv queues
310   void because nothing goes wrong here, packets
311   remain in the queue if something goes wrong
312 */
313 void flush_queues(conn_list_t *cl)
314 {
315 cp
316   if(cl->sq)
317     {
318       if(debug_lvl >= DEBUG_TRAFFIC)
319         syslog(LOG_DEBUG, _("Flushing send queue for %s (%s)"),
320                cl->name, cl->hostname);
321       flush_queue(cl, &(cl->sq), xsend);
322     }
323
324   if(cl->rq)
325     {
326       if(debug_lvl >=  DEBUG_TRAFFIC)
327         syslog(LOG_DEBUG, _("Flushing receive queue for %s (%s)"),
328                cl->name, cl->hostname);
329       flush_queue(cl, &(cl->rq), xrecv);
330     }
331 cp
332 }
333
334 /*
335   send a packet to the given vpn ip.
336 */
337 int send_packet(ip_t to, vpn_packet_t *packet)
338 {
339   conn_list_t *cl;
340   subnet_t *subnet;
341 cp
342   if((subnet = lookup_subnet_ipv4(to)) == NULL)
343     {
344       if(debug_lvl >= DEBUG_TRAFFIC)
345         {
346           syslog(LOG_NOTICE, _("Trying to look up %d.%d.%d.%d in connection list failed!"),
347                  IP_ADDR_V(to));
348         }
349
350       return -1;
351     }
352
353   cl = subnet->owner;
354     
355   if(cl == myself)
356     {
357       if(debug_lvl >= DEBUG_TRAFFIC)
358         {
359           syslog(LOG_NOTICE, _("Packet with destination %d.%d.%d.%d is looping back to us!"),
360                  IP_ADDR_V(to));
361         }
362
363       return -1;
364     }
365
366   /* If we ourselves have indirectdata flag set, we should send only to our uplink! */
367
368   /* FIXME - check for indirection and reprogram it The Right Way(tm) this time. */
369   
370   /* Connections are now opened beforehand...
371
372   if(!cl->status.dataopen)
373     if(setup_vpn_connection(cl) < 0)
374       {
375         syslog(LOG_ERR, _("Could not open UDP connection to %s (%s)"),
376                cl->name, cl->hostname);
377         return -1;
378       }
379   */
380       
381   if(!cl->status.validkey)
382     {
383 /* FIXME: Don't queue until everything else is fixed.
384       if(debug_lvl >= DEBUG_TRAFFIC)
385         syslog(LOG_INFO, _("No valid key known yet for %s (%s), queueing packet"),
386                cl->name, cl->hostname);
387       add_queue(&(cl->sq), packet, packet->len + 2);
388 */
389       if(!cl->status.waitingforkey)
390         send_req_key(myself, cl);                       /* Keys should be sent to the host running the tincd */
391       return 0;
392     }
393
394   if(!cl->status.active)
395     {
396 /* FIXME: Don't queue until everything else is fixed.
397       if(debug_lvl >= DEBUG_TRAFFIC)
398         syslog(LOG_INFO, _("%s (%s) is not ready, queueing packet"),
399                cl->name, cl->hostname);
400       add_queue(&(cl->sq), packet, packet->len + 2);
401 */
402       return 0; /* We don't want to mess up, do we? */
403     }
404
405   /* can we send it? can we? can we? huh? */
406 cp
407   return xsend(cl, packet);
408 }
409
410 /*
411   open the local ethertap device
412 */
413 int setup_tap_fd(void)
414 {
415   int nfd;
416   const char *tapfname;
417   config_t const *cfg;
418   struct ifreq ifr;
419
420 cp  
421   if((cfg = get_config_val(config, config_tapdevice)))
422     tapfname = cfg->data.ptr;
423   else
424 #ifdef HAVE_TUNTAP
425     tapfname = "/dev/misc/net/tun";
426 #else
427     tapfname = "/dev/tap0";
428 #endif
429 cp
430   if((nfd = open(tapfname, O_RDWR | O_NONBLOCK)) < 0)
431     {
432       syslog(LOG_ERR, _("Could not open %s: %m"), tapfname);
433       return -1;
434     }
435 cp
436   tap_fd = nfd;
437
438   /* Set default MAC address for ethertap devices */
439   
440   taptype = TAP_TYPE_ETHERTAP;
441   mymac.type = SUBNET_MAC;
442   mymac.net.mac.address.x[0] = 0xfe;
443   mymac.net.mac.address.x[1] = 0xfd;
444   mymac.net.mac.address.x[2] = 0x00;
445   mymac.net.mac.address.x[3] = 0x00;
446   mymac.net.mac.address.x[4] = 0x00;
447   mymac.net.mac.address.x[5] = 0x00;
448
449 #ifdef HAVE_TUNTAP
450   /* Ok now check if this is an old ethertap or a new tun/tap thingie */
451   memset(&ifr, 0, sizeof(ifr));
452 cp
453   ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
454   if (netname)
455     strncpy(ifr.ifr_name, netname, IFNAMSIZ);
456 cp
457   if (!ioctl(tap_fd, TUNSETIFF, (void *) &ifr))
458   {
459     syslog(LOG_INFO, _("%s is a new style tun/tap device"), tapfname);
460     taptype = TAP_TYPE_TUNTAP;
461   }
462 #endif
463 cp
464   return 0;
465 }
466
467 /*
468   set up the socket that we listen on for incoming
469   (tcp) connections
470 */
471 int setup_listen_meta_socket(int port)
472 {
473   int nfd, flags;
474   struct sockaddr_in a;
475   const int one = 1;
476   config_t const *cfg;
477 cp
478   if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
479     {
480       syslog(LOG_ERR, _("Creating metasocket failed: %m"));
481       return -1;
482     }
483
484   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
485     {
486       syslog(LOG_ERR, _("System call `%s' failed: %m"),
487              "setsockopt");
488       return -1;
489     }
490
491   if(setsockopt(nfd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)))
492     {
493       syslog(LOG_ERR, _("System call `%s' failed: %m"),
494              "setsockopt");
495       return -1;
496     }
497
498   flags = fcntl(nfd, F_GETFL);
499   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
500     {
501       syslog(LOG_ERR, _("System call `%s' failed: %m"),
502              "fcntl");
503       return -1;
504     }
505
506   if((cfg = get_config_val(config, config_interface)))
507     {
508       if(setsockopt(nfd, SOL_SOCKET, SO_KEEPALIVE, cfg->data.ptr, strlen(cfg->data.ptr)))
509         {
510           syslog(LOG_ERR, _("Unable to bind listen socket to interface %s: %m"), cfg->data.ptr);
511           return -1;
512         }
513     }
514
515   memset(&a, 0, sizeof(a));
516   a.sin_family = AF_INET;
517   a.sin_port = htons(port);
518   
519   if((cfg = get_config_val(config, config_interfaceip)))
520     a.sin_addr.s_addr = htonl(cfg->data.ip->address);
521   else
522     a.sin_addr.s_addr = htonl(INADDR_ANY);
523
524   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
525     {
526       syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
527       return -1;
528     }
529
530   if(listen(nfd, 3))
531     {
532       syslog(LOG_ERR, _("System call `%s' failed: %m"),
533              "listen");
534       return -1;
535     }
536 cp
537   return nfd;
538 }
539
540 /*
541   setup the socket for incoming encrypted
542   data (the udp part)
543 */
544 int setup_vpn_in_socket(int port)
545 {
546   int nfd, flags;
547   struct sockaddr_in a;
548   const int one = 1;
549 cp
550   if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
551     {
552       syslog(LOG_ERR, _("Creating socket failed: %m"));
553       return -1;
554     }
555
556   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
557     {
558       syslog(LOG_ERR, _("System call `%s' failed: %m"),
559              "setsockopt");
560       return -1;
561     }
562
563   flags = fcntl(nfd, F_GETFL);
564   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
565     {
566       syslog(LOG_ERR, _("System call `%s' failed: %m"),
567              "fcntl");
568       return -1;
569     }
570
571   memset(&a, 0, sizeof(a));
572   a.sin_family = AF_INET;
573   a.sin_port = htons(port);
574   a.sin_addr.s_addr = htonl(INADDR_ANY);
575
576   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
577     {
578       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
579       return -1;
580     }
581 cp
582   return nfd;
583 }
584
585 /*
586   setup an outgoing meta (tcp) socket
587 */
588 int setup_outgoing_meta_socket(conn_list_t *cl)
589 {
590   int flags;
591   struct sockaddr_in a;
592   config_t const *cfg;
593 cp
594   if(debug_lvl >= DEBUG_CONNECTIONS)
595     syslog(LOG_INFO, _("Trying to connect to %s"), cl->hostname);
596
597   if((cfg = get_config_val(cl->config, config_port)) == NULL)
598     cl->port = 655;
599   else
600     cl->port = cfg->data.val;
601
602   cl->meta_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
603   if(cl->meta_socket == -1)
604     {
605       syslog(LOG_ERR, _("Creating socket for %s port %d failed: %m"),
606              cl->hostname, cl->port);
607       return -1;
608     }
609
610   a.sin_family = AF_INET;
611   a.sin_port = htons(cl->port);
612   a.sin_addr.s_addr = htonl(cl->address);
613
614   if(connect(cl->meta_socket, (struct sockaddr *)&a, sizeof(a)) == -1)
615     {
616       syslog(LOG_ERR, _("%s port %hd: %m"), cl->hostname, cl->port);
617       return -1;
618     }
619
620   flags = fcntl(cl->meta_socket, F_GETFL);
621   if(fcntl(cl->meta_socket, F_SETFL, flags | O_NONBLOCK) < 0)
622     {
623       syslog(LOG_ERR, _("fcntl for %s port %d: %m"),
624              cl->hostname, cl->port);
625       return -1;
626     }
627
628   if(debug_lvl >= DEBUG_CONNECTIONS)
629     syslog(LOG_INFO, _("Connected to %s port %hd"),
630          cl->hostname, cl->port);
631
632   cl->status.meta = 1;
633 cp
634   return 0;
635 }
636
637 /*
638   setup an outgoing connection. It's not
639   necessary to also open an udp socket as
640   well, because the other host will initiate
641   an authentication sequence during which
642   we will do just that.
643 */
644 int setup_outgoing_connection(char *name)
645 {
646   conn_list_t *ncn;
647   struct hostent *h;
648   config_t const *cfg;
649 cp
650   if(check_id(name))
651     {
652       syslog(LOG_ERR, _("Invalid name for outgoing connection"));
653       return -1;
654     }
655
656   ncn = new_conn_list();
657   asprintf(&ncn->name, "%s", name);
658     
659   if(read_host_config(ncn))
660     {
661       syslog(LOG_ERR, _("Error reading host configuration file for %s"));
662       free_conn_list(ncn);
663       return -1;
664     }
665     
666   if(!(cfg = get_config_val(ncn->config, config_address)))
667     {
668       syslog(LOG_ERR, _("No address specified for %s"));
669       free_conn_list(ncn);
670       return -1;
671     }
672     
673   if(!(h = gethostbyname(cfg->data.ptr)))
674     {
675       syslog(LOG_ERR, _("Error looking up `%s': %m"), cfg->data.ptr);
676       free_conn_list(ncn);
677       return -1;
678     }
679
680   ncn->address = ntohl(*((ip_t*)(h->h_addr_list[0])));
681   ncn->hostname = hostlookup(htonl(ncn->address));
682   
683   if(setup_outgoing_meta_socket(ncn) < 0)
684     {
685       syslog(LOG_ERR, _("Could not set up a meta connection to %s"),
686              ncn->hostname);
687       free_conn_list(ncn);
688       return -1;
689     }
690
691   ncn->status.outgoing = 1;
692   ncn->buffer = xmalloc(MAXBUFSIZE);
693   ncn->buflen = 0;
694   ncn->last_ping_time = time(NULL);
695
696   conn_list_add(ncn);
697
698   send_id(ncn);
699 cp
700   return 0;
701 }
702
703 /*
704   Configure conn_list_t myself and set up the local sockets (listen only)
705 */
706 int setup_myself(void)
707 {
708   config_t const *cfg;
709   config_t *next;
710   subnet_t *net;
711 cp
712   myself = new_conn_list();
713
714   asprintf(&myself->hostname, "MYSELF"); /* FIXME? Do hostlookup on ourselves? */
715   myself->flags = 0;
716   myself->protocol_version = PROT_CURRENT;
717
718   if(!(cfg = get_config_val(config, config_name))) /* Not acceptable */
719     {
720       syslog(LOG_ERR, _("Name for tinc daemon required!"));
721       return -1;
722     }
723   else
724     asprintf(&myself->name, "%s", (char*)cfg->data.val);
725
726   if(check_id(myself->name))
727     {
728       syslog(LOG_ERR, _("Invalid name for myself!"));
729       return -1;
730     }
731 cp
732   if(!(cfg = get_config_val(config, config_privatekey)))
733     {
734       syslog(LOG_ERR, _("Private key for tinc daemon required!"));
735       return -1;
736     }
737   else
738     {
739       myself->rsa_key = RSA_new();
740       BN_hex2bn(&myself->rsa_key->d, cfg->data.ptr);
741       BN_hex2bn(&myself->rsa_key->e, "FFFF");
742     }
743
744   if(read_host_config(myself))
745     {
746       syslog(LOG_ERR, _("Cannot open host configuration file for myself!"));
747       return -1;
748     }
749 cp  
750   if(!(cfg = get_config_val(myself->config, config_publickey)))
751     {
752       syslog(LOG_ERR, _("Public key for tinc daemon required!"));
753       return -1;
754     }
755   else
756     {
757       BN_hex2bn(&myself->rsa_key->n, cfg->data.ptr);
758     }
759 /*
760   if(RSA_check_key(myself->rsa_key) != 1)
761     {
762       syslog(LOG_ERR, _("Invalid public/private keypair!"));
763       return -1;
764     }
765 */
766   if(!(cfg = get_config_val(myself->config, config_port)))
767     myself->port = 655;
768   else
769     myself->port = cfg->data.val;
770
771   if((cfg = get_config_val(myself->config, config_indirectdata)))
772     if(cfg->data.val == stupid_true)
773       myself->flags |= EXPORTINDIRECTDATA;
774
775   if((cfg = get_config_val(myself->config, config_tcponly)))
776     if(cfg->data.val == stupid_true)
777       myself->flags |= TCPONLY;
778
779 /* Read in all the subnets specified in the host configuration file */
780
781   for(next = myself->config; (cfg = get_config_val(next, config_subnet)); next = cfg->next)
782     {
783       net = new_subnet();
784       net->type = SUBNET_IPV4;
785       net->net.ipv4.address = cfg->data.ip->address;
786       net->net.ipv4.mask = cfg->data.ip->mask;
787       
788       /* Teach newbies what subnets are... */
789       
790       if((net->net.ipv4.address & net->net.ipv4.mask) != net->net.ipv4.address)
791         {
792           syslog(LOG_ERR, _("Network address and subnet mask do not match!"));
793           return -1;
794         }        
795       
796       subnet_add(myself, net);
797     }
798     
799   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
800     {
801       syslog(LOG_ERR, _("Unable to set up a listening socket!"));
802       return -1;
803     }
804
805   /* Generate packet encryption key */
806
807   myself->cipher_pkttype = EVP_bf_cfb();
808
809   myself->cipher_pktkeylength = myself->cipher_pkttype->key_len + myself->cipher_pkttype->iv_len;
810
811   myself->cipher_pktkey = (char *)xmalloc(myself->cipher_pktkeylength);
812   RAND_bytes(myself->cipher_pktkey, myself->cipher_pktkeylength);
813
814   if(!(cfg = get_config_val(config, config_keyexpire)))
815     keylifetime = 3600;
816   else
817     keylifetime = cfg->data.val;
818     
819   keyexpires = time(NULL) + keylifetime;
820
821   /* Activate ourselves */
822   
823   myself->status.active = 1;
824
825   syslog(LOG_NOTICE, _("Ready: listening on port %hd"), myself->port);
826 cp
827   return 0;
828 }
829
830 RETSIGTYPE
831 sigalrm_handler(int a)
832 {
833   config_t const *cfg;
834 cp
835   cfg = get_config_val(upstreamcfg, config_connectto);
836
837   if(!cfg && upstreamcfg == config)
838     /* No upstream IP given, we're listen only. */
839     return;
840
841   while(cfg)
842     {
843       upstreamcfg = cfg->next;
844       if(!setup_outgoing_connection(cfg->data.ptr))   /* function returns 0 when there are no problems */
845         {
846           signal(SIGALRM, SIG_IGN);
847           return;
848         }
849       cfg = get_config_val(upstreamcfg, config_connectto); /* Or else we try the next ConnectTo line */
850     }
851
852   signal(SIGALRM, sigalrm_handler);
853   upstreamcfg = config;
854   seconds_till_retry += 5;
855   if(seconds_till_retry > MAXTIMEOUT)    /* Don't wait more than MAXTIMEOUT seconds. */
856     seconds_till_retry = MAXTIMEOUT;
857   syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
858          seconds_till_retry);
859   alarm(seconds_till_retry);
860 cp
861 }
862
863 /*
864   setup all initial network connections
865 */
866 int setup_network_connections(void)
867 {
868   config_t const *cfg;
869 cp
870   if((cfg = get_config_val(config, config_pingtimeout)) == NULL)
871     timeout = 60;
872   else
873     {
874       timeout = cfg->data.val;
875       if(timeout < 1)
876         {
877           timeout = 86400;
878         }
879      }
880
881   if(setup_tap_fd() < 0)
882     return -1;
883
884   if(setup_myself() < 0)
885     return -1;
886
887   /* Run tinc-up script to further initialize the tap interface */
888   execute_script("tinc-up");
889   
890   if(!(cfg = get_config_val(config, config_connectto)))
891     /* No upstream IP given, we're listen only. */
892     return 0;
893
894   while(cfg)
895     {
896       upstreamcfg = cfg->next;
897       if(!setup_outgoing_connection(cfg->data.ptr))   /* function returns 0 when there are no problems */
898         return 0;
899       cfg = get_config_val(upstreamcfg, config_connectto); /* Or else we try the next ConnectTo line */
900     }
901     
902   signal(SIGALRM, sigalrm_handler);
903   upstreamcfg = config;
904   seconds_till_retry = MAXTIMEOUT;
905   syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in %d seconds"), seconds_till_retry);
906   alarm(seconds_till_retry);
907 cp
908   return 0;
909 }
910
911 /*
912   close all open network connections
913 */
914 void close_network_connections(void)
915 {
916   conn_list_t *p;
917 cp
918   for(p = conn_list; p != NULL; p = p->next)
919     {
920       p->status.active = 0;
921       terminate_connection(p);
922     }
923
924   if(myself)
925     if(myself->status.active)
926       {
927         close(myself->meta_socket);
928         free_conn_list(myself);
929         myself = NULL;
930       }
931
932   close(tap_fd);
933
934   /* Execute tinc-down script right after shutting down the interface */
935   execute_script("tinc-down");
936
937   destroy_conn_list();
938
939   syslog(LOG_NOTICE, _("Terminating"));
940 cp
941   return;
942 }
943
944 /*
945   create a data (udp) socket
946 */
947 int setup_vpn_connection(conn_list_t *cl)
948 {
949   int nfd, flags;
950   struct sockaddr_in a;
951   const int one = 1;
952 cp
953   if(debug_lvl >= DEBUG_TRAFFIC)
954     syslog(LOG_DEBUG, _("Opening UDP socket to %s"), cl->hostname);
955
956   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
957   if(nfd == -1)
958     {
959       syslog(LOG_ERR, _("Creating UDP socket failed: %m"));
960       return -1;
961     }
962
963   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
964     {
965       syslog(LOG_ERR, _("System call `%s' failed: %m"),
966              "setsockopt");
967       return -1;
968     }
969
970   flags = fcntl(nfd, F_GETFL);
971   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
972     {
973       syslog(LOG_ERR, _("System call `%s' failed: %m"),
974              "fcntl");
975       return -1;
976     }
977
978   memset(&a, 0, sizeof(a));
979   a.sin_family = AF_INET;
980   a.sin_port = htons(myself->port);
981   a.sin_addr.s_addr = htonl(INADDR_ANY);
982
983   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
984     {
985       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), myself->port);
986       return -1;
987     }
988
989   a.sin_family = AF_INET;
990   a.sin_port = htons(cl->port);
991   a.sin_addr.s_addr = htonl(cl->address);
992
993   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
994     {
995       syslog(LOG_ERR, _("Connecting to %s port %d failed: %m"),
996              cl->hostname, cl->port);
997       return -1;
998     }
999
1000   flags = fcntl(nfd, F_GETFL);
1001   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
1002     {
1003       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m %s (%s)"), __FILE__, __LINE__, nfd,
1004              cl->name, cl->hostname);
1005       return -1;
1006     }
1007
1008   cl->socket = nfd;
1009   cl->status.dataopen = 1;
1010 cp
1011   return 0;
1012 }
1013
1014 /*
1015   handle an incoming tcp connect call and open
1016   a connection to it.
1017 */
1018 conn_list_t *create_new_connection(int sfd)
1019 {
1020   conn_list_t *p;
1021   struct sockaddr_in ci;
1022   int len = sizeof(ci);
1023 cp
1024   p = new_conn_list();
1025
1026   if(getpeername(sfd, &ci, &len) < 0)
1027     {
1028       syslog(LOG_ERR, _("System call `%s' failed: %m"),
1029              "getpeername");
1030       return NULL;
1031     }
1032
1033   p->name = unknown;
1034   p->address = ntohl(ci.sin_addr.s_addr);
1035   p->hostname = hostlookup(ci.sin_addr.s_addr);
1036   p->meta_socket = sfd;
1037   p->status.meta = 1;
1038   p->buffer = xmalloc(MAXBUFSIZE);
1039   p->buflen = 0;
1040   p->last_ping_time = time(NULL);
1041   
1042   if(debug_lvl >= DEBUG_CONNECTIONS)
1043     syslog(LOG_NOTICE, _("Connection from %s port %d"),
1044          p->hostname, htons(ci.sin_port));
1045
1046   p->allow_request = ID;
1047 cp
1048   return p;
1049 }
1050
1051 /*
1052   put all file descriptors in an fd_set array
1053 */
1054 void build_fdset(fd_set *fs)
1055 {
1056   conn_list_t *p;
1057 cp
1058   FD_ZERO(fs);
1059
1060   for(p = conn_list; p != NULL; p = p->next)
1061     {
1062       if(p->status.meta)
1063         FD_SET(p->meta_socket, fs);
1064       if(p->status.dataopen)
1065         FD_SET(p->socket, fs);
1066     }
1067
1068   FD_SET(myself->meta_socket, fs);
1069   FD_SET(tap_fd, fs);
1070 cp
1071 }
1072
1073 /*
1074   receive incoming data from the listening
1075   udp socket and write it to the ethertap
1076   device after being decrypted
1077 */
1078 int handle_incoming_vpn_data(conn_list_t *cl)
1079 {
1080   vpn_packet_t pkt;
1081   int x, l = sizeof(x);
1082   int lenin;
1083 cp
1084   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1085     {
1086       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"),
1087              __FILE__, __LINE__, cl->socket);
1088       return -1;
1089     }
1090   if(x)
1091     {
1092       syslog(LOG_ERR, _("Incoming data socket error: %s"), strerror(x));
1093       return -1;
1094     }
1095
1096   if((lenin = recv(cl->socket, (char *) &(pkt.len), MTU, 0)) <= 0)
1097     {
1098       syslog(LOG_ERR, _("Receiving packet failed: %m"));
1099       return -1;
1100     }
1101
1102   if(debug_lvl >= DEBUG_TRAFFIC)
1103     {
1104       syslog(LOG_DEBUG, _("Received packet of %d bytes from %s (%s)"), lenin,
1105              cl->name, cl->hostname);
1106     }
1107
1108 cp
1109   return xrecv(cl, &pkt);
1110 }
1111
1112 /*
1113   terminate a connection and notify the other
1114   end before closing the sockets
1115 */
1116 void terminate_connection(conn_list_t *cl)
1117 {
1118   conn_list_t *p;
1119   subnet_t *s;
1120 cp
1121   if(cl->status.remove)
1122     return;
1123
1124   cl->status.remove = 1;
1125
1126   if(debug_lvl >= DEBUG_CONNECTIONS)
1127     syslog(LOG_NOTICE, _("Closing connection with %s (%s)"),
1128            cl->name, cl->hostname);
1129  
1130   if(cl->socket)
1131     close(cl->socket);
1132   if(cl->status.meta)
1133     close(cl->meta_socket);
1134
1135 cp
1136   /* Find all connections that were lost because they were behind cl
1137      (the connection that was dropped). */
1138
1139   if(cl->status.meta)
1140     for(p = conn_list; p != NULL; p = p->next)
1141       if((p->nexthop == cl) && (p != cl))
1142         terminate_connection(p);        /* Sounds like recursion, but p does not have a meta connection :) */
1143
1144   /* Inform others of termination if it was still active */
1145
1146   if(cl->status.active)
1147     for(p = conn_list; p != NULL; p = p->next)
1148       if(p->status.meta && p->status.active && p!=cl)
1149         send_del_host(p, cl);
1150
1151   /* Remove the associated subnets */
1152
1153   for(s = cl->subnets; s; s = s->next)
1154     subnet_del(s);
1155
1156   /* Check if this was our outgoing connection */
1157     
1158   if(cl->status.outgoing && cl->status.active)
1159     {
1160       signal(SIGALRM, sigalrm_handler);
1161       seconds_till_retry = 5;
1162       alarm(seconds_till_retry);
1163       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
1164     }
1165
1166   /* Inactivate */
1167
1168   cl->status.active = 0;
1169 cp
1170 }
1171
1172 /*
1173   Check if the other end is active.
1174   If we have sent packets, but didn't receive any,
1175   then possibly the other end is dead. We send a
1176   PING request over the meta connection. If the other
1177   end does not reply in time, we consider them dead
1178   and close the connection.
1179 */
1180 int check_dead_connections(void)
1181 {
1182   conn_list_t *p;
1183   time_t now;
1184 cp
1185   now = time(NULL);
1186   for(p = conn_list; p != NULL; p = p->next)
1187     {
1188       if(p->status.active && p->status.meta)
1189         {
1190           if(p->last_ping_time + timeout < now)
1191             {
1192               if(p->status.pinged)
1193                 {
1194                   if(debug_lvl >= DEBUG_PROTOCOL)
1195                     syslog(LOG_INFO, _("%s (%s) didn't respond to PING"),
1196                            p->name, p->hostname);
1197                   p->status.timeout = 1;
1198                   terminate_connection(p);
1199                 }
1200               else
1201                 {
1202                   send_ping(p);
1203                 }
1204             }
1205         }
1206     }
1207 cp
1208   return 0;
1209 }
1210
1211 /*
1212   accept a new tcp connect and create a
1213   new connection
1214 */
1215 int handle_new_meta_connection()
1216 {
1217   conn_list_t *ncn;
1218   struct sockaddr client;
1219   int nfd, len = sizeof(client);
1220 cp
1221   if((nfd = accept(myself->meta_socket, &client, &len)) < 0)
1222     {
1223       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1224       return -1;
1225     }
1226
1227   if(!(ncn = create_new_connection(nfd)))
1228     {
1229       shutdown(nfd, 2);
1230       close(nfd);
1231       syslog(LOG_NOTICE, _("Closed attempted connection"));
1232       return 0;
1233     }
1234
1235   conn_list_add(ncn);
1236 cp
1237   return 0;
1238 }
1239
1240 /*
1241   check all connections to see if anything
1242   happened on their sockets
1243 */
1244 void check_network_activity(fd_set *f)
1245 {
1246   conn_list_t *p;
1247 cp
1248   for(p = conn_list; p != NULL; p = p->next)
1249     {
1250       if(p->status.remove)
1251         continue;
1252
1253       if(p->status.dataopen)
1254         if(FD_ISSET(p->socket, f))
1255           {
1256             handle_incoming_vpn_data(p);
1257
1258             /* Old error stuff (FIXME: copy this to handle_incoming_vpn_data()
1259             
1260             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1261             syslog(LOG_ERR, _("Outgoing data socket error for %s (%s): %s"),
1262                    p->name, p->hostname, strerror(x));
1263             terminate_connection(p);
1264             */
1265             return;
1266           }  
1267
1268       if(p->status.meta)
1269         if(FD_ISSET(p->meta_socket, f))
1270           if(receive_meta(p) < 0)
1271             {
1272               terminate_connection(p);
1273               return;
1274             } 
1275     }
1276   
1277   if(FD_ISSET(myself->meta_socket, f))
1278     handle_new_meta_connection();
1279 cp
1280 }
1281
1282 /*
1283   read, encrypt and send data that is
1284   available through the ethertap device
1285 */
1286 void handle_tap_input(void)
1287 {
1288   vpn_packet_t vp;
1289   int lenin;
1290 cp  
1291   if(taptype == TAP_TYPE_TUNTAP)
1292     {
1293       if((lenin = read(tap_fd, vp.data, MTU)) <= 0)
1294         {
1295           syslog(LOG_ERR, _("Error while reading from tun/tap device: %m"));
1296           return;
1297         }
1298       vp.len = lenin;
1299     }
1300   else                  /* ethertap */
1301     {
1302       if((lenin = read(tap_fd, vp.data - 2, MTU)) <= 0)
1303         {
1304           syslog(LOG_ERR, _("Error while reading from ethertap device: %m"));
1305           return;
1306         }
1307       vp.len = lenin - 2;
1308     }
1309
1310   total_tap_in += lenin;
1311
1312   if(lenin < 32)
1313     {
1314       if(debug_lvl >= DEBUG_TRAFFIC)
1315         syslog(LOG_WARNING, _("Received short packet from tap device"));
1316       return;
1317     }
1318
1319   if(debug_lvl >= DEBUG_TRAFFIC)
1320     {
1321       syslog(LOG_DEBUG, _("Read packet of length %d from tap device"), vp.len);
1322     }
1323
1324   send_packet(ntohl(*((unsigned long*)(&vp.data[30]))), &vp);
1325 cp
1326 }
1327
1328 /*
1329   this is where it all happens...
1330 */
1331 void main_loop(void)
1332 {
1333   fd_set fset;
1334   struct timeval tv;
1335   int r;
1336   time_t last_ping_check;
1337   int t;
1338 cp
1339   last_ping_check = time(NULL);
1340
1341   for(;;)
1342     {
1343       tv.tv_sec = timeout;
1344       tv.tv_usec = 0;
1345
1346       prune_conn_list();
1347       build_fdset(&fset);
1348
1349       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1350         {
1351           if(errno != EINTR) /* because of alarm */
1352             {
1353               syslog(LOG_ERR, _("Error while waiting for input: %m"));
1354               return;
1355             }
1356         }
1357
1358       if(sighup)
1359         {
1360           syslog(LOG_INFO, _("Rereading configuration file and restarting in 5 seconds"));
1361           sighup = 0;
1362           close_network_connections();
1363           clear_config(&config);
1364
1365           if(read_server_config())
1366             {
1367               syslog(LOG_ERR, _("Unable to reread configuration file, exiting"));
1368               exit(0);
1369             }
1370
1371           sleep(5);
1372           
1373           if(setup_network_connections())
1374             return;
1375             
1376           continue;
1377         }
1378
1379       t = time(NULL);
1380
1381       /* Let's check if everybody is still alive */
1382
1383       if(last_ping_check + timeout < t)
1384         {
1385           check_dead_connections();
1386           last_ping_check = time(NULL);
1387
1388           /* Should we regenerate our key? */
1389
1390           if(keyexpires < t)
1391             {
1392               if(debug_lvl >= DEBUG_STATUS)
1393                 syslog(LOG_INFO, _("Regenerating symmetric key"));
1394                 
1395               RAND_bytes(myself->cipher_pktkey, myself->cipher_pktkeylength);
1396               send_key_changed(myself, NULL);
1397               keyexpires = time(NULL) + keylifetime;
1398             }
1399         }
1400
1401       if(r > 0)
1402         {
1403           check_network_activity(&fset);
1404
1405           /* local tap data */
1406           if(FD_ISSET(tap_fd, &fset))
1407             handle_tap_input();
1408         }
1409     }
1410 cp
1411 }