1fee46b80cdc3b3fee6cdfa1165bb17a3b883ad3
[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.3 2000/06/25 15:16:11 guus Exp $
21 */
22
23 #include "config.h"
24
25 #include <arpa/inet.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <netdb.h>
29 #include <netinet/in.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/signal.h>
34 #include <sys/socket.h>
35 #include <sys/time.h>
36 #include <sys/types.h>
37 #include <syslog.h>
38 #include <unistd.h>
39
40 #include <cipher.h>
41 #include <utils.h>
42 #include <xalloc.h>
43
44 #include "conf.h"
45 #include "encr.h"
46 #include "net.h"
47 #include "netutl.h"
48 #include "protocol.h"
49
50 #include "system.h"
51
52 int tap_fd = -1;
53
54 int total_tap_in = 0;
55 int total_tap_out = 0;
56 int total_socket_in = 0;
57 int total_socket_out = 0;
58
59 static int seconds_till_retry;
60
61 /* The global list of existing connections */
62 conn_list_t *conn_list = NULL;
63 conn_list_t *myself = NULL;
64
65 /*
66   strip off the MAC adresses of an ethernet frame
67 */
68 void strip_mac_addresses(vpn_packet_t *p)
69 {
70   unsigned char tmp[MAXSIZE];
71 cp
72   memcpy(tmp, p->data, p->len);
73   p->len -= 12;
74   memcpy(p->data, &tmp[12], p->len);
75 cp
76 }
77
78 /*
79   reassemble MAC addresses
80 */
81 void add_mac_addresses(vpn_packet_t *p)
82 {
83   unsigned char tmp[MAXSIZE];
84 cp
85   memcpy(&tmp[12], p->data, p->len);
86   p->len += 12;
87   tmp[0] = tmp[6] = 0xfe;
88   tmp[1] = tmp[7] = 0xfd;
89   *((ip_t*)(&tmp[2])) = (ip_t)(htonl(myself->vpn_ip));
90   *((ip_t*)(&tmp[8])) = *((ip_t*)(&tmp[26]));
91   memcpy(p->data, &tmp[0], p->len);
92 cp
93 }
94
95 int xsend(conn_list_t *cl, void *packet)
96 {
97   int r;
98   real_packet_t rp;
99 cp
100   do_encrypt((vpn_packet_t*)packet, &rp, cl->key);
101   rp.from = htonl(myself->vpn_ip);
102   rp.data.len = htons(rp.data.len);
103   rp.len = htons(rp.len);
104
105   if(debug_lvl > 3)
106     syslog(LOG_ERR, _("Sent %d bytes to %lx"), ntohs(rp.len), cl->vpn_ip);
107
108   if((r = send(cl->socket, (char*)&rp, ntohs(rp.len), 0)) < 0)
109     {
110       syslog(LOG_ERR, _("Error sending data: %m"));
111       return -1;
112     }
113
114   total_socket_out += r;
115
116   cl->want_ping = 1;
117 cp
118   return 0;
119 }
120
121 int xrecv(conn_list_t *cl, void *packet)
122 {
123   vpn_packet_t vp;
124   int lenin;
125 cp
126   do_decrypt((real_packet_t*)packet, &vp, cl->key);
127   add_mac_addresses(&vp);
128
129   if((lenin = write(tap_fd, &vp, vp.len + sizeof(vp.len))) < 0)
130     syslog(LOG_ERR, _("Can't write to tap device: %m"));
131   else
132     total_tap_out += lenin;
133
134   cl->want_ping = 0;
135   cl->last_ping_time = time(NULL);
136 cp
137   return 0;
138 }
139
140 /*
141   add the given packet of size s to the
142   queue q, be it the send or receive queue
143 */
144 void add_queue(packet_queue_t **q, void *packet, size_t s)
145 {
146   queue_element_t *e;
147 cp
148   if(debug_lvl > 3)
149     syslog(LOG_DEBUG, _("packet to queue: %d"), s);
150
151   e = xmalloc(sizeof(*e));
152   e->packet = xmalloc(s);
153   memcpy(e->packet, packet, s);
154
155   if(!*q)
156     {
157       *q = xmalloc(sizeof(**q));
158       (*q)->head = (*q)->tail = NULL;
159     }
160
161   e->next = NULL;                       /* We insert at the tail */
162
163   if((*q)->tail)                        /* Do we have a tail? */
164     {
165       (*q)->tail->next = e;
166       e->prev = (*q)->tail;
167     }
168   else                                  /* No tail -> no head too */
169     {
170       (*q)->head = e;
171       e->prev = NULL;
172     }
173
174   (*q)->tail = e;
175 cp
176 }
177
178 /* Remove a queue element */
179 void del_queue(packet_queue_t **q, queue_element_t *e)
180 {
181 cp
182   free(e->packet);
183
184   if(e->next)                           /* There is a successor, so we are not tail */
185     {
186       if(e->prev)                       /* There is a predecessor, so we are not head */
187         {
188           e->next->prev = e->prev;
189           e->prev->next = e->next;
190         }
191       else                              /* We are head */
192         {
193           e->next->prev = NULL;
194           (*q)->head = e->next;
195         }
196     }
197   else                                  /* We are tail (or all alone!) */
198     {          
199       if(e->prev)                       /* We are not alone :) */
200         {
201           e->prev->next = NULL;
202           (*q)->tail = e->prev;
203         }
204       else                              /* Adieu */
205         {
206           free(*q);
207           *q = NULL;
208         }
209     }
210     
211   free(e);
212 cp
213 }
214
215 /*
216   flush a queue by calling function for
217   each packet, and removing it when that
218   returned a zero exit code
219 */
220 void flush_queue(conn_list_t *cl, packet_queue_t **pq,
221                  int (*function)(conn_list_t*,void*))
222 {
223   queue_element_t *p, *next = NULL;
224 cp
225   for(p = (*pq)->head; p != NULL; )
226     {
227       next = p->next;
228
229       if(!function(cl, p->packet))
230         del_queue(pq, p);
231         
232       p = next;
233     }
234
235   if(debug_lvl > 3)
236     syslog(LOG_DEBUG, _("queue flushed"));
237 cp
238 }
239
240 /*
241   flush the send&recv queues
242   void because nothing goes wrong here, packets
243   remain in the queue if something goes wrong
244 */
245 void flush_queues(conn_list_t *cl)
246 {
247 cp
248   if(cl->sq)
249     {
250       if(debug_lvl > 3)
251         syslog(LOG_DEBUG, _("Flushing send queue for " IP_ADDR_S),
252                IP_ADDR_V(cl->vpn_ip));
253       flush_queue(cl, &(cl->sq), xsend);
254     }
255
256   if(cl->rq)
257     {
258       if(debug_lvl > 3)
259         syslog(LOG_DEBUG, _("Flushing receive queue for " IP_ADDR_S),
260                IP_ADDR_V(cl->vpn_ip));
261       flush_queue(cl, &(cl->rq), xrecv);
262     }
263 cp
264 }
265
266 /*
267   send a packet to the given vpn ip.
268 */
269 int send_packet(ip_t to, vpn_packet_t *packet)
270 {
271   conn_list_t *cl;
272 cp
273   if((cl = lookup_conn(to)) == NULL)
274     {
275       if(debug_lvl > 3)
276         {
277           syslog(LOG_NOTICE, _("Trying to look up " IP_ADDR_S " in connection list failed!"),
278                  IP_ADDR_V(to));
279         }
280         
281       /* Is this really necessary? If we can't find "to", then neither should any uplink. (GS) */
282       
283       return -1;
284         
285       for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
286       if(!cl)
287         { /* No open outgoing connection has been found. */
288           if(debug_lvl > 3)
289             syslog(LOG_NOTICE, _("There is no remote host I can send this packet to!"));
290           return -1;
291         }
292     }
293
294   /* If we ourselves have indirectdata flag set, we should send only to our uplink! */
295   
296   if(myself->flags & EXPORTINDIRECTDATA)
297     {
298       for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
299       if(!cl)
300         { /* No open outgoing connection has been found. */
301           if(debug_lvl > 3)
302             syslog(LOG_NOTICE, _("There is no remote host I can send this packet to!"));
303           return -1;
304         }
305     }
306   else
307
308   /* If indirectdata flag is set for the destination we just looked up,
309    * then real_ip is actually the vpn_ip of the gateway tincd
310    * it is behind.
311    */
312    
313   if(cl->flags & INDIRECTDATA)
314     {
315       if((cl = lookup_conn(cl->vpn_ip)) == NULL)
316         {
317           if(debug_lvl > 3)
318             {
319               syslog(LOG_NOTICE, _("Indirect look up " IP_ADDR_S " in connection list failed!"),
320                      IP_ADDR_V(to));
321             }
322             
323           /* Gateway tincd dead? Should we kill it? (GS) */
324
325           return -1;
326         }
327       if(cl->flags & INDIRECTDATA)  /* This should not happen */
328         if(debug_lvl > 3)
329           {
330             syslog(LOG_NOTICE, _("double indirection for " IP_ADDR_S),
331                    IP_ADDR_V(to));
332           }
333         return -1;        
334     }            
335
336   if(my_key_expiry <= time(NULL))
337     regenerate_keys();
338
339   if(!cl->status.dataopen)
340     if(setup_vpn_connection(cl) < 0)
341       return -1;
342
343   if(!cl->status.validkey)
344     {
345       add_queue(&(cl->sq), packet, packet->len + 2);
346       if(!cl->status.waitingforkey)
347         send_key_request(cl->vpn_ip);                   /* Keys should be sent to the host running the tincd */
348       return 0;
349     }
350
351   if(!cl->status.active)
352     {
353       add_queue(&(cl->sq), packet, packet->len + 2);
354       if(debug_lvl > 3)
355         syslog(LOG_INFO, _(IP_ADDR_S " is not ready, queueing packet"), IP_ADDR_V(cl->vpn_ip));
356       return 0; /* We don't want to mess up, do we? */
357     }
358
359   /* can we send it? can we? can we? huh? */
360 cp
361   return xsend(cl, packet);
362 }
363
364 /*
365   open the local ethertap device
366 */
367 int setup_tap_fd(void)
368 {
369   int nfd;
370   const char *tapfname;
371   config_t const *cfg;
372 cp  
373   if((cfg = get_config_val(tapdevice)) == NULL)
374     tapfname = "/dev/tap0";
375   else
376     tapfname = cfg->data.ptr;
377
378   if((nfd = open(tapfname, O_RDWR | O_NONBLOCK)) < 0)
379     {
380       syslog(LOG_ERR, _("Could not open %s: %m"), tapfname);
381       return -1;
382     }
383
384   tap_fd = nfd;
385 cp
386   return 0;
387 }
388
389 /*
390   set up the socket that we listen on for incoming
391   (tcp) connections
392 */
393 int setup_listen_meta_socket(int port)
394 {
395   int nfd, flags;
396   struct sockaddr_in a;
397   const int one = 1;
398 cp
399   if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
400     {
401       syslog(LOG_ERR, _("Creating metasocket failed: %m"));
402       return -1;
403     }
404
405   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
406     {
407       syslog(LOG_ERR, _("setsockopt: %m"));
408       return -1;
409     }
410
411   flags = fcntl(nfd, F_GETFL);
412   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
413     {
414       syslog(LOG_ERR, _("fcntl: %m"));
415       return -1;
416     }
417
418   memset(&a, 0, sizeof(a));
419   a.sin_family = AF_INET;
420   a.sin_port = htons(port);
421   a.sin_addr.s_addr = htonl(INADDR_ANY);
422
423   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
424     {
425       syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
426       return -1;
427     }
428
429   if(listen(nfd, 3))
430     {
431       syslog(LOG_ERR, _("listen: %m"));
432       return -1;
433     }
434 cp
435   return nfd;
436 }
437
438 /*
439   setup the socket for incoming encrypted
440   data (the udp part)
441 */
442 int setup_vpn_in_socket(int port)
443 {
444   int nfd, flags;
445   struct sockaddr_in a;
446   const int one = 1;
447 cp
448   if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
449     {
450       syslog(LOG_ERR, _("Creating socket failed: %m"));
451       return -1;
452     }
453
454   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
455     {
456       syslog(LOG_ERR, _("setsockopt: %m"));
457       return -1;
458     }
459
460   flags = fcntl(nfd, F_GETFL);
461   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
462     {
463       syslog(LOG_ERR, _("fcntl: %m"));
464       return -1;
465     }
466
467   memset(&a, 0, sizeof(a));
468   a.sin_family = AF_INET;
469   a.sin_port = htons(port);
470   a.sin_addr.s_addr = htonl(INADDR_ANY);
471
472   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
473     {
474       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
475       return -1;
476     }
477 cp
478   return nfd;
479 }
480
481 /*
482   setup an outgoing meta (tcp) socket
483 */
484 int setup_outgoing_meta_socket(conn_list_t *cl)
485 {
486   int flags;
487   struct sockaddr_in a;
488   config_t const *cfg;
489 cp
490   if((cfg = get_config_val(upstreamport)) == NULL)
491     cl->port = 655;
492   else
493     cl->port = cfg->data.val;
494
495   cl->meta_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
496   if(cl->meta_socket == -1)
497     {
498       syslog(LOG_ERR, _("Creating socket failed: %m"));
499       return -1;
500     }
501
502   a.sin_family = AF_INET;
503   a.sin_port = htons(cl->port);
504   a.sin_addr.s_addr = htonl(cl->real_ip);
505
506   if(connect(cl->meta_socket, (struct sockaddr *)&a, sizeof(a)) == -1)
507     {
508       syslog(LOG_ERR, _(IP_ADDR_S ":%d: %m"), IP_ADDR_V(cl->real_ip), cl->port);
509       return -1;
510     }
511
512   flags = fcntl(cl->meta_socket, F_GETFL);
513   if(fcntl(cl->meta_socket, F_SETFL, flags | O_NONBLOCK) < 0)
514     {
515       syslog(LOG_ERR, _("fcntl: %m"));
516       return -1;
517     }
518
519   syslog(LOG_INFO, _("Connected to " IP_ADDR_S ":%hd"),
520          IP_ADDR_V(cl->real_ip), cl->port);
521 cp
522   return 0;
523 }
524
525 /*
526   setup an outgoing connection. It's not
527   necessary to also open an udp socket as
528   well, because the other host will initiate
529   an authentication sequence during which
530   we will do just that.
531 */
532 int setup_outgoing_connection(ip_t ip)
533 {
534   conn_list_t *ncn;
535 cp
536   ncn = new_conn_list();
537   ncn->real_ip = ip;
538
539   if(setup_outgoing_meta_socket(ncn) < 0)
540     {
541       syslog(LOG_ERR, _("Could not set up a meta connection!"));
542       free_conn_element(ncn);
543       return -1;
544     }
545
546   ncn->status.meta = 1;
547   ncn->status.outgoing = 1;
548   ncn->next = conn_list;
549   conn_list = ncn;
550 cp
551   return 0;
552 }
553
554 /*
555   set up the local sockets (listen only)
556 */
557 int setup_myself(void)
558 {
559   config_t const *cfg;
560 cp
561   myself = new_conn_list();
562
563   if(!(cfg = get_config_val(myvpnip)))
564     {
565       syslog(LOG_ERR, _("No value for my VPN IP given"));
566       return -1;
567     }
568
569   myself->vpn_ip = cfg->data.ip->ip;
570   myself->vpn_mask = cfg->data.ip->mask;
571   myself->flags = 0;
572
573   if(!(cfg = get_config_val(listenport)))
574     myself->port = 655;
575   else
576     myself->port = cfg->data.val;
577
578   if(cfg = get_config_val(indirectdata))
579     if(cfg->data.val)
580       myself->flags |= EXPORTINDIRECTDATA;
581
582   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
583     {
584       syslog(LOG_ERR, _("Unable to set up a listening socket"));
585       return -1;
586     }
587
588   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
589     {
590       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
591       close(myself->meta_socket);
592       return -1;
593     }
594
595   myself->status.active = 1;
596
597   syslog(LOG_NOTICE, _("Ready: listening on port %d"), myself->port);
598 cp
599   return 0;
600 }
601
602 RETSIGTYPE
603 sigalrm_handler(int a)
604 {
605   config_t const *cfg;
606 cp
607   cfg = get_config_val(upstreamip);
608
609   if(!setup_outgoing_connection(cfg->data.ip->ip))
610     {
611       signal(SIGALRM, SIG_IGN);
612     }
613   else
614     {
615       signal(SIGALRM, sigalrm_handler);
616       seconds_till_retry += 5;
617       if(seconds_till_retry>300)    /* Don't wait more than 5 minutes. */
618         seconds_till_retry = 300;
619       alarm(seconds_till_retry);
620       syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
621              seconds_till_retry);
622     }
623 cp
624 }
625
626 /*
627   setup all initial network connections
628 */
629 int setup_network_connections(void)
630 {
631   config_t const *cfg;
632 cp
633   if((cfg = get_config_val(pingtimeout)) == NULL)
634     timeout = 5;
635   else
636     timeout = cfg->data.val;
637
638   if(setup_tap_fd() < 0)
639     return -1;
640
641   if(setup_myself() < 0)
642     return -1;
643
644   if((cfg = get_config_val(upstreamip)) == NULL)
645     /* No upstream IP given, we're listen only. */
646     return 0;
647
648   if(setup_outgoing_connection(cfg->data.ip->ip))
649     {
650       signal(SIGALRM, sigalrm_handler);
651       seconds_till_retry = 300;
652       alarm(seconds_till_retry);
653       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 minutes"));
654     }
655 cp
656   return 0;
657 }
658
659 /*
660   close all open network connections
661 */
662 void close_network_connections(void)
663 {
664   conn_list_t *p;
665 cp
666   for(p = conn_list; p != NULL; p = p->next)
667     {
668       if(p->status.dataopen)
669         {
670           shutdown(p->socket, 0); /* No more receptions */
671           close(p->socket);
672         }
673       if(p->status.meta)
674         {
675           send_termreq(p);
676           shutdown(p->meta_socket, 0); /* No more receptions */
677           close(p->meta_socket);
678         }
679     }
680
681   if(myself)
682     if(myself->status.active)
683       {
684         close(myself->meta_socket);
685         close(myself->socket);
686       }
687
688   close(tap_fd);
689   destroy_conn_list();
690
691   syslog(LOG_NOTICE, _("Terminating"));
692 cp
693   return;
694 }
695
696 /*
697   create a data (udp) socket
698 */
699 int setup_vpn_connection(conn_list_t *cl)
700 {
701   int nfd, flags;
702   struct sockaddr_in a;
703 cp
704   if(debug_lvl > 0)
705     syslog(LOG_DEBUG, _("Opening UDP socket to " IP_ADDR_S), IP_ADDR_V(cl->real_ip));
706
707   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
708   if(nfd == -1)
709     {
710       syslog(LOG_ERR, _("Creating data socket failed: %m"));
711       return -1;
712     }
713
714   a.sin_family = AF_INET;
715   a.sin_port = htons(cl->port);
716   a.sin_addr.s_addr = htonl(cl->real_ip);
717
718   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
719     {
720       syslog(LOG_ERR, _("Connecting to " IP_ADDR_S ":%d failed: %m"),
721              IP_ADDR_V(cl->real_ip), cl->port);
722       return -1;
723     }
724
725   flags = fcntl(nfd, F_GETFL);
726   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
727     {
728       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, nfd);
729       return -1;
730     }
731
732   cl->socket = nfd;
733   cl->status.dataopen = 1;
734 cp
735   return 0;
736 }
737
738 /*
739   handle an incoming tcp connect call and open
740   a connection to it.
741 */
742 conn_list_t *create_new_connection(int sfd)
743 {
744   conn_list_t *p;
745   struct sockaddr_in ci;
746   int len = sizeof(ci);
747 cp
748   p = new_conn_list();
749
750   if(getpeername(sfd, &ci, &len) < 0)
751     {
752       syslog(LOG_ERR, _("Error: getpeername: %m"));
753       return NULL;
754     }
755
756   p->real_ip = ntohl(ci.sin_addr.s_addr);
757   p->meta_socket = sfd;
758   p->status.meta = 1;
759   p->buflen = 0;
760   p->last_ping_time = time(NULL);
761   p->want_ping = 0;
762   
763   syslog(LOG_NOTICE, _("Connection from " IP_ADDR_S ":%d"),
764          IP_ADDR_V(p->real_ip), htons(ci.sin_port));
765
766   if(send_basic_info(p) < 0)
767     {
768       free(p);
769       return NULL;
770     }
771 cp
772   return p;
773 }
774
775 /*
776   put all file descriptors in an fd_set array
777 */
778 void build_fdset(fd_set *fs)
779 {
780   conn_list_t *p;
781 cp
782   FD_ZERO(fs);
783
784   for(p = conn_list; p != NULL; p = p->next)
785     {
786       if(p->status.meta)
787         FD_SET(p->meta_socket, fs);
788       if(p->status.dataopen)
789         FD_SET(p->socket, fs);
790     }
791
792   FD_SET(myself->meta_socket, fs);
793   FD_SET(myself->socket, fs);
794   FD_SET(tap_fd, fs);
795 cp
796 }
797
798 /*
799   receive incoming data from the listening
800   udp socket and write it to the ethertap
801   device after being decrypted
802 */
803 int handle_incoming_vpn_data(conn_list_t *cl)
804 {
805   real_packet_t rp;
806   int lenin;
807   int x, l = sizeof(x);
808   conn_list_t *f;
809 cp
810   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
811     {
812       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
813       return -1;
814     }
815   if(x)
816     {
817       syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
818       return -1;
819     }
820
821   rp.len = -1;
822   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
823   if(lenin <= 0)
824     {
825       syslog(LOG_ERR, _("Receiving data failed: %m"));
826       return -1;
827     }
828   total_socket_in += lenin;
829
830   rp.data.len = ntohs(rp.data.len);
831   rp.len = ntohs(rp.len);
832   rp.from = ntohl(rp.from);
833
834   if(rp.len >= 0)
835     {
836       f = lookup_conn(rp.from);
837       if(debug_lvl > 3)
838         syslog(LOG_DEBUG, _("packet from " IP_ADDR_S " (len %d)"),
839                IP_ADDR_V(rp.from), rp.len);
840       if(!f)
841         {
842           syslog(LOG_ERR, _("Got packet from unknown source " IP_ADDR_S),
843                  IP_ADDR_V(rp.from));
844           return -1;
845         }
846
847       if(f->status.validkey)
848         xrecv(f, &rp);
849       else
850         {
851           add_queue(&(f->rq), &rp, rp.len);
852           if(!cl->status.waitingforkey)
853             send_key_request(rp.from);
854         }
855
856       if(my_key_expiry <= time(NULL))
857         regenerate_keys();
858     }
859 cp
860   return 0;
861 }
862
863 /*
864   terminate a connection and notify the other
865   end before closing the sockets
866 */
867 void terminate_connection(conn_list_t *cl)
868 {
869   conn_list_t *p, *q;
870
871 cp
872   if(cl->status.remove)
873     return;
874
875   if(debug_lvl > 0)
876     syslog(LOG_NOTICE, _("Closing connection with " IP_ADDR_S " (" IP_ADDR_S ")"),
877            IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip));
878
879   if(cl->status.timeout)
880     send_timeout(cl);
881   else if(!cl->status.termreq)
882     send_termreq(cl);
883
884   close(cl->socket);
885   if(cl->status.meta)
886     close(cl->meta_socket);
887
888   if(cl->status.outgoing)
889     {
890       signal(SIGALRM, sigalrm_handler);
891       seconds_till_retry = 5;
892       alarm(seconds_till_retry);
893       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
894     }
895   
896   cl->status.active = 0;
897   cl->status.remove = 1;
898
899 cp
900   /* Find all connections that were lost because they were behind cl
901      (the connection that was dropped). */
902   for(p = conn_list; p != NULL; p = p->next)
903     if(p->nexthop == cl)
904       {
905         p->status.active = 0;
906         p->status.remove = 1;
907       }
908
909 cp 
910   /* Then send a notification about all these connections to all hosts
911      that are still connected to us. */
912   for(p = conn_list; p != NULL; p = p->next)
913     if(!p->status.remove && p->status.meta)
914       for(q = conn_list; q != NULL; q = q->next)
915         if(q->status.remove)
916           send_del_host(p, q);
917
918 cp
919 }
920
921 /*
922   Check if the other end is active.
923   If we have sent packets, but didn't receive any,
924   then possibly the other end is dead. We send a
925   PING request over the meta connection. If the other
926   end does not reply in time, we consider them dead
927   and close the connection.
928 */
929 int check_dead_connections(void)
930 {
931   conn_list_t *p;
932   time_t now;
933 cp
934   now = time(NULL);
935   for(p = conn_list; p != NULL; p = p->next)
936     {
937       if(p->status.remove)
938         continue;
939       if(p->status.active && p->status.meta)
940         {
941           if(p->last_ping_time + timeout < now)
942             {
943               if(p->status.pinged && !p->status.got_pong)
944                 {
945                   if(debug_lvl > 1)
946                     syslog(LOG_INFO, _(IP_ADDR_S " (" IP_ADDR_S ") didn't respond to ping"),
947                            IP_ADDR_V(p->vpn_ip), IP_ADDR_V(p->real_ip));
948                   p->status.timeout = 1;
949                   terminate_connection(p);
950                 }
951               else if(p->want_ping)
952                 {
953                   send_ping(p);
954                   p->last_ping_time = now;
955                   p->status.pinged = 1;
956                   p->status.got_pong = 0;
957                 }
958             }
959         }
960     }
961 cp
962   return 0;
963 }
964
965 /*
966   accept a new tcp connect and create a
967   new connection
968 */
969 int handle_new_meta_connection(conn_list_t *cl)
970 {
971   conn_list_t *ncn;
972   struct sockaddr client;
973   int nfd, len = sizeof(client);
974 cp
975   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
976     {
977       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
978       return -1;
979     }
980
981   if((ncn = create_new_connection(nfd)) == NULL)
982     {
983       shutdown(nfd, 2);
984       close(nfd);
985       syslog(LOG_NOTICE, _("Closed attempted connection"));
986       return 0;
987     }
988
989   ncn->status.meta = 1;
990   ncn->next = conn_list;
991   conn_list = ncn;
992 cp
993   return 0;
994 }
995
996 /*
997   dispatch any incoming meta requests
998 */
999 int handle_incoming_meta_data(conn_list_t *cl)
1000 {
1001   int x, l = sizeof(x);
1002   int request, oldlen, i;
1003   int lenin = 0;
1004 cp
1005   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1006     {
1007       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1008       return -1;
1009     }
1010   if(x)
1011     {
1012       syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1013       return -1;
1014     }
1015
1016   if(cl->buflen >= MAXBUFSIZE)
1017     {
1018       syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1019       return -1;
1020     }
1021
1022   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1023
1024   if(lenin<=0)
1025     {
1026       syslog(LOG_ERR, _("Metadata socket read error: %m"));
1027       return -1;
1028     }
1029
1030   oldlen = cl->buflen;
1031   cl->buflen += lenin;
1032
1033   for(;;)
1034     {
1035       cl->reqlen = 0;
1036
1037       for(i = oldlen; i < cl->buflen; i++)
1038         {
1039           if(cl->buffer[i] == '\n')
1040             {
1041               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1042               cl->reqlen = i + 1;
1043               break;
1044             }
1045         }
1046
1047       if(cl->reqlen)
1048         {
1049           if(debug_lvl > 2)
1050             syslog(LOG_DEBUG, _("Got request from " IP_ADDR_S " (" IP_ADDR_S "): %s"),
1051                          IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip), cl->buffer);
1052           if(sscanf(cl->buffer, "%d", &request) == 1)
1053             {
1054               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1055                 {
1056                   syslog(LOG_ERR, _("Unknown request from " IP_ADDR_S " (" IP_ADDR_S ")"),
1057                          IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip));
1058                   return -1;
1059                 }
1060
1061               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1062                 {
1063                   syslog(LOG_ERR, _("Error while processing request from " IP_ADDR_S " (" IP_ADDR_S ")"),
1064                          IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip));
1065                   return -1;
1066                 }
1067             }
1068           else
1069             {
1070               syslog(LOG_ERR, _("Bogus data received from " IP_ADDR_S " (" IP_ADDR_S ")"),
1071                          IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip));
1072               return -1;
1073             }
1074
1075           cl->buflen -= cl->reqlen;
1076           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1077           oldlen = 0;
1078         }
1079       else
1080         {
1081           break;
1082         }
1083     }
1084
1085   cl->last_ping_time = time(NULL);
1086   cl->want_ping = 0;
1087 cp  
1088   return 0;
1089 }
1090
1091 /*
1092   check all connections to see if anything
1093   happened on their sockets
1094 */
1095 void check_network_activity(fd_set *f)
1096 {
1097   conn_list_t *p;
1098   int x, l = sizeof(x);
1099 cp
1100   for(p = conn_list; p != NULL; p = p->next)
1101     {
1102       if(p->status.remove)
1103         continue;
1104
1105       if(p->status.dataopen)
1106         if(FD_ISSET(p->socket, f))
1107           {
1108             /*
1109               The only thing that can happen to get us here is apparently an
1110               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1111               something that will not trigger an error directly on send()).
1112               I've once got here when it said `No route to host'.
1113             */
1114             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1115             syslog(LOG_ERR, _("Outgoing data socket error: %s"), sys_errlist[x]);
1116             terminate_connection(p);
1117             return;
1118           }  
1119
1120       if(p->status.meta)
1121         if(FD_ISSET(p->meta_socket, f))
1122           if(handle_incoming_meta_data(p) < 0)
1123             {
1124               terminate_connection(p);
1125               return;
1126             } 
1127     }
1128   
1129   if(FD_ISSET(myself->socket, f))
1130     handle_incoming_vpn_data(myself);
1131
1132   if(FD_ISSET(myself->meta_socket, f))
1133     handle_new_meta_connection(myself);
1134 cp
1135 }
1136
1137 /*
1138   read, encrypt and send data that is
1139   available through the ethertap device
1140 */
1141 void handle_tap_input(void)
1142 {
1143   vpn_packet_t vp;
1144   ip_t from, to;
1145   int ether_type, lenin;
1146 cp  
1147   memset(&vp, 0, sizeof(vp));
1148   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1149     {
1150       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1151       return;
1152     }
1153
1154   total_tap_in += lenin;
1155
1156   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1157   if(ether_type != 0x0800)
1158     {
1159       if(debug_lvl > 3)
1160         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1161                ether_type, MAC_ADDR_V(vp.data[6]));
1162       return;
1163     }
1164   
1165   if(lenin < 32)
1166     {
1167       if(debug_lvl > 3)
1168         syslog(LOG_INFO, _("Dropping short packet"));
1169       return;
1170     }
1171
1172   from = ntohl(*((unsigned long*)(&vp.data[26])));
1173   to = ntohl(*((unsigned long*)(&vp.data[30])));
1174
1175   if(debug_lvl > 3)
1176     syslog(LOG_DEBUG, _("An IP packet (%04x) for " IP_ADDR_S " from " IP_ADDR_S),
1177            ether_type, IP_ADDR_V(to), IP_ADDR_V(from));
1178   if(debug_lvl > 3)
1179     syslog(LOG_DEBUG, _(MAC_ADDR_S " to " MAC_ADDR_S),
1180            MAC_ADDR_V(vp.data[0]), MAC_ADDR_V(vp.data[6]));
1181   
1182   vp.len = (length_t)lenin - 2;
1183
1184   strip_mac_addresses(&vp);
1185
1186   send_packet(to, &vp);
1187 cp
1188 }
1189
1190 /*
1191   this is where it all happens...
1192 */
1193 void main_loop(void)
1194 {
1195   fd_set fset;
1196   struct timeval tv;
1197   int r;
1198   time_t last_ping_check;
1199 cp
1200   last_ping_check = time(NULL);
1201
1202   for(;;)
1203     {
1204       tv.tv_sec = timeout;
1205       tv.tv_usec = 0;
1206
1207       prune_conn_list();
1208       build_fdset(&fset);
1209
1210       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1211         {
1212           if(errno == EINTR) /* because of alarm */
1213             continue;
1214           syslog(LOG_ERR, _("Error while waiting for input: %m"));
1215           return;
1216         }
1217
1218       if(last_ping_check + timeout < time(NULL))
1219         /* Let's check if everybody is still alive */
1220         {
1221           check_dead_connections();
1222           last_ping_check = time(NULL);
1223           continue;
1224         }
1225
1226       check_network_activity(&fset);
1227
1228       /* local tap data */
1229       if(FD_ISSET(tap_fd, &fset))
1230         handle_tap_input();
1231     }
1232 cp
1233 }