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>
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.
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.
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.
20 $Id: net.c,v 1.35.4.6 2000/06/26 17:20:58 guus Exp $
25 #include <arpa/inet.h>
29 #include <netinet/in.h>
33 #include <sys/signal.h>
34 #include <sys/socket.h>
36 #include <sys/types.h>
55 int total_tap_out = 0;
56 int total_socket_in = 0;
57 int total_socket_out = 0;
59 static int seconds_till_retry;
61 /* The global list of existing connections */
62 conn_list_t *conn_list = NULL;
63 conn_list_t *myself = NULL;
66 strip off the MAC adresses of an ethernet frame
68 void strip_mac_addresses(vpn_packet_t *p)
70 unsigned char tmp[MAXSIZE];
72 memcpy(tmp, p->data, p->len);
74 memcpy(p->data, &tmp[12], p->len);
79 reassemble MAC addresses
81 void add_mac_addresses(vpn_packet_t *p)
83 unsigned char tmp[MAXSIZE];
85 memcpy(&tmp[12], p->data, p->len);
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);
95 int xsend(conn_list_t *cl, void *packet)
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);
106 syslog(LOG_ERR, _("Sent %d bytes to %lx"), ntohs(rp.len), cl->vpn_ip);
108 if((r = send(cl->socket, (char*)&rp, ntohs(rp.len), 0)) < 0)
110 syslog(LOG_ERR, _("Error sending data: %m"));
114 total_socket_out += r;
121 int xrecv(conn_list_t *cl, void *packet)
126 do_decrypt((real_packet_t*)packet, &vp, cl->key);
127 add_mac_addresses(&vp);
129 if((lenin = write(tap_fd, &vp, vp.len + sizeof(vp.len))) < 0)
130 syslog(LOG_ERR, _("Can't write to tap device: %m"));
132 total_tap_out += lenin;
135 cl->last_ping_time = time(NULL);
141 add the given packet of size s to the
142 queue q, be it the send or receive queue
144 void add_queue(packet_queue_t **q, void *packet, size_t s)
149 syslog(LOG_DEBUG, _("packet to queue: %d"), s);
151 e = xmalloc(sizeof(*e));
152 e->packet = xmalloc(s);
153 memcpy(e->packet, packet, s);
157 *q = xmalloc(sizeof(**q));
158 (*q)->head = (*q)->tail = NULL;
161 e->next = NULL; /* We insert at the tail */
163 if((*q)->tail) /* Do we have a tail? */
165 (*q)->tail->next = e;
166 e->prev = (*q)->tail;
168 else /* No tail -> no head too */
178 /* Remove a queue element */
179 void del_queue(packet_queue_t **q, queue_element_t *e)
184 if(e->next) /* There is a successor, so we are not tail */
186 if(e->prev) /* There is a predecessor, so we are not head */
188 e->next->prev = e->prev;
189 e->prev->next = e->next;
191 else /* We are head */
193 e->next->prev = NULL;
194 (*q)->head = e->next;
197 else /* We are tail (or all alone!) */
199 if(e->prev) /* We are not alone :) */
201 e->prev->next = NULL;
202 (*q)->tail = e->prev;
216 flush a queue by calling function for
217 each packet, and removing it when that
218 returned a zero exit code
220 void flush_queue(conn_list_t *cl, packet_queue_t **pq,
221 int (*function)(conn_list_t*,void*))
223 queue_element_t *p, *next = NULL;
225 for(p = (*pq)->head; p != NULL; )
229 if(!function(cl, p->packet))
236 syslog(LOG_DEBUG, _("queue flushed"));
241 flush the send&recv queues
242 void because nothing goes wrong here, packets
243 remain in the queue if something goes wrong
245 void flush_queues(conn_list_t *cl)
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);
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);
267 send a packet to the given vpn ip.
269 int send_packet(ip_t to, vpn_packet_t *packet)
273 if((cl = lookup_conn(to)) == NULL)
277 syslog(LOG_NOTICE, _("Trying to look up " IP_ADDR_S " in connection list failed!"),
281 /* Is this really necessary? If we can't find "to", then neither should any uplink. (GS) */
285 for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
287 { /* No open outgoing connection has been found. */
289 syslog(LOG_NOTICE, _("There is no remote host I can send this packet to!"));
294 /* If we ourselves have indirectdata flag set, we should send only to our uplink! */
296 if(myself->flags & EXPORTINDIRECTDATA)
298 for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
300 { /* No open outgoing connection has been found. */
302 syslog(LOG_NOTICE, _("There is no remote host I can send this packet to!"));
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
313 if(cl->flags & INDIRECTDATA)
315 if((cl = lookup_conn(cl->vpn_ip)) == NULL)
319 syslog(LOG_NOTICE, _("Indirect look up " IP_ADDR_S " in connection list failed!"),
323 /* Gateway tincd dead? Should we kill it? (GS) */
327 if(cl->flags & INDIRECTDATA) /* This should not happen */
330 syslog(LOG_NOTICE, _("double indirection for " IP_ADDR_S),
336 if(my_key_expiry <= time(NULL))
339 if(!cl->status.dataopen)
340 if(setup_vpn_connection(cl) < 0)
343 if(!cl->status.validkey)
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 */
351 if(!cl->status.active)
353 add_queue(&(cl->sq), packet, packet->len + 2);
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? */
359 /* can we send it? can we? can we? huh? */
361 return xsend(cl, packet);
365 open the local ethertap device
367 int setup_tap_fd(void)
370 const char *tapfname;
373 if((cfg = get_config_val(tapdevice)) == NULL)
374 tapfname = "/dev/tap0";
376 tapfname = cfg->data.ptr;
378 if((nfd = open(tapfname, O_RDWR | O_NONBLOCK)) < 0)
380 syslog(LOG_ERR, _("Could not open %s: %m"), tapfname);
390 set up the socket that we listen on for incoming
393 int setup_listen_meta_socket(int port)
396 struct sockaddr_in a;
399 if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
401 syslog(LOG_ERR, _("Creating metasocket failed: %m"));
405 if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
407 syslog(LOG_ERR, _("setsockopt: %m"));
411 flags = fcntl(nfd, F_GETFL);
412 if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
414 syslog(LOG_ERR, _("fcntl: %m"));
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);
423 if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
425 syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
431 syslog(LOG_ERR, _("listen: %m"));
439 setup the socket for incoming encrypted
442 int setup_vpn_in_socket(int port)
445 struct sockaddr_in a;
448 if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
450 syslog(LOG_ERR, _("Creating socket failed: %m"));
454 if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
456 syslog(LOG_ERR, _("setsockopt: %m"));
460 flags = fcntl(nfd, F_GETFL);
461 if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
463 syslog(LOG_ERR, _("fcntl: %m"));
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);
472 if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
474 syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
482 setup an outgoing meta (tcp) socket
484 int setup_outgoing_meta_socket(conn_list_t *cl)
487 struct sockaddr_in a;
490 if((cfg = get_config_val(upstreamport)) == NULL)
493 cl->port = cfg->data.val;
495 cl->meta_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
496 if(cl->meta_socket == -1)
498 syslog(LOG_ERR, _("Creating socket failed: %m"));
502 a.sin_family = AF_INET;
503 a.sin_port = htons(cl->port);
504 a.sin_addr.s_addr = htonl(cl->real_ip);
506 if(connect(cl->meta_socket, (struct sockaddr *)&a, sizeof(a)) == -1)
508 syslog(LOG_ERR, _(IP_ADDR_S ":%d: %m"), IP_ADDR_V(cl->real_ip), cl->port);
512 flags = fcntl(cl->meta_socket, F_GETFL);
513 if(fcntl(cl->meta_socket, F_SETFL, flags | O_NONBLOCK) < 0)
515 syslog(LOG_ERR, _("fcntl: %m"));
519 syslog(LOG_INFO, _("Connected to " IP_ADDR_S ":%hd"),
520 IP_ADDR_V(cl->real_ip), cl->port);
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.
532 int setup_outgoing_connection(ip_t ip)
536 ncn = new_conn_list();
538 ncn->hostname = hostlookup(htonl(ip));
540 if(setup_outgoing_meta_socket(ncn) < 0)
542 syslog(LOG_ERR, _("Could not set up a meta connection!"));
543 free_conn_element(ncn);
547 ncn->status.meta = 1;
548 ncn->status.outgoing = 1;
549 ncn->next = conn_list;
556 set up the local sockets (listen only)
558 int setup_myself(void)
562 myself = new_conn_list();
564 if(!(cfg = get_config_val(myvpnip)))
566 syslog(LOG_ERR, _("No value for my VPN IP given"));
570 myself->vpn_ip = cfg->data.ip->ip;
571 myself->hostname = hostlookup(htonl(myself->vpn_ip));
572 myself->vpn_mask = cfg->data.ip->mask;
575 if(!(cfg = get_config_val(listenport)))
578 myself->port = cfg->data.val;
580 if(cfg = get_config_val(indirectdata))
582 myself->flags |= EXPORTINDIRECTDATA;
584 if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
586 syslog(LOG_ERR, _("Unable to set up a listening socket"));
590 if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
592 syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
593 close(myself->meta_socket);
597 myself->status.active = 1;
599 syslog(LOG_NOTICE, _("Ready: listening on port %d"), myself->port);
605 sigalrm_handler(int a)
609 cfg = get_config_val(upstreamip);
611 if(!setup_outgoing_connection(cfg->data.ip->ip))
613 signal(SIGALRM, SIG_IGN);
617 signal(SIGALRM, sigalrm_handler);
618 seconds_till_retry += 5;
619 if(seconds_till_retry>300) /* Don't wait more than 5 minutes. */
620 seconds_till_retry = 300;
621 alarm(seconds_till_retry);
622 syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
629 setup all initial network connections
631 int setup_network_connections(void)
635 if((cfg = get_config_val(pingtimeout)) == NULL)
638 timeout = cfg->data.val;
640 if(setup_tap_fd() < 0)
643 if(setup_myself() < 0)
646 if((cfg = get_config_val(upstreamip)) == NULL)
647 /* No upstream IP given, we're listen only. */
650 if(setup_outgoing_connection(cfg->data.ip->ip))
652 signal(SIGALRM, sigalrm_handler);
653 seconds_till_retry = 300;
654 alarm(seconds_till_retry);
655 syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 minutes"));
662 close all open network connections
664 void close_network_connections(void)
668 for(p = conn_list; p != NULL; p = p->next)
670 if(p->status.dataopen)
672 shutdown(p->socket, 0); /* No more receptions */
678 shutdown(p->meta_socket, 0); /* No more receptions */
679 close(p->meta_socket);
684 if(myself->status.active)
686 close(myself->meta_socket);
687 close(myself->socket);
693 syslog(LOG_NOTICE, _("Terminating"));
699 create a data (udp) socket
701 int setup_vpn_connection(conn_list_t *cl)
704 struct sockaddr_in a;
707 syslog(LOG_DEBUG, _("Opening UDP socket to " IP_ADDR_S), IP_ADDR_V(cl->real_ip));
709 nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
712 syslog(LOG_ERR, _("Creating data socket failed: %m"));
716 a.sin_family = AF_INET;
717 a.sin_port = htons(cl->port);
718 a.sin_addr.s_addr = htonl(cl->real_ip);
720 if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
722 syslog(LOG_ERR, _("Connecting to " IP_ADDR_S ":%d failed: %m"),
723 IP_ADDR_V(cl->real_ip), cl->port);
727 flags = fcntl(nfd, F_GETFL);
728 if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
730 syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, nfd);
735 cl->status.dataopen = 1;
741 handle an incoming tcp connect call and open
744 conn_list_t *create_new_connection(int sfd)
747 struct sockaddr_in ci;
748 int len = sizeof(ci);
752 if(getpeername(sfd, &ci, &len) < 0)
754 syslog(LOG_ERR, _("Error: getpeername: %m"));
758 p->real_ip = ntohl(ci.sin_addr.s_addr);
759 p->hostname = hostlookup(ci.sin_addr.s_addr);
760 p->meta_socket = sfd;
763 p->last_ping_time = time(NULL);
766 syslog(LOG_NOTICE, _("Connection from %s port %d"),
767 p->hostname, htons(ci.sin_port));
769 if(send_basic_info(p) < 0)
779 put all file descriptors in an fd_set array
781 void build_fdset(fd_set *fs)
787 for(p = conn_list; p != NULL; p = p->next)
790 FD_SET(p->meta_socket, fs);
791 if(p->status.dataopen)
792 FD_SET(p->socket, fs);
795 FD_SET(myself->meta_socket, fs);
796 FD_SET(myself->socket, fs);
802 receive incoming data from the listening
803 udp socket and write it to the ethertap
804 device after being decrypted
806 int handle_incoming_vpn_data(conn_list_t *cl)
810 int x, l = sizeof(x);
813 if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
815 syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
820 syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
825 lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
828 syslog(LOG_ERR, _("Receiving data failed: %m"));
831 total_socket_in += lenin;
833 rp.data.len = ntohs(rp.data.len);
834 rp.len = ntohs(rp.len);
835 rp.from = ntohl(rp.from);
839 f = lookup_conn(rp.from);
841 syslog(LOG_DEBUG, _("packet from " IP_ADDR_S " (len %d)"),
842 IP_ADDR_V(rp.from), rp.len);
845 syslog(LOG_ERR, _("Got packet from unknown source " IP_ADDR_S),
850 if(f->status.validkey)
854 add_queue(&(f->rq), &rp, rp.len);
855 if(!cl->status.waitingforkey)
856 send_key_request(rp.from);
859 if(my_key_expiry <= time(NULL))
867 terminate a connection and notify the other
868 end before closing the sockets
870 void terminate_connection(conn_list_t *cl)
875 if(cl->status.remove)
879 syslog(LOG_NOTICE, _("Closing connection with " IP_ADDR_S " (%s)"),
880 IP_ADDR_V(cl->vpn_ip), cl->hostname);
882 if(cl->status.timeout)
884 else if(!cl->status.termreq)
889 close(cl->meta_socket);
891 if(cl->status.outgoing)
893 signal(SIGALRM, sigalrm_handler);
894 seconds_till_retry = 5;
895 alarm(seconds_till_retry);
896 syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
899 cl->status.active = 0;
900 cl->status.remove = 1;
903 /* Find all connections that were lost because they were behind cl
904 (the connection that was dropped). */
905 for(p = conn_list; p != NULL; p = p->next)
908 p->status.active = 0;
909 p->status.remove = 1;
913 /* Then send a notification about all these connections to all hosts
914 that are still connected to us. */
915 for(p = conn_list; p != NULL; p = p->next)
916 if(!p->status.remove && p->status.meta)
917 for(q = conn_list; q != NULL; q = q->next)
925 Check if the other end is active.
926 If we have sent packets, but didn't receive any,
927 then possibly the other end is dead. We send a
928 PING request over the meta connection. If the other
929 end does not reply in time, we consider them dead
930 and close the connection.
932 int check_dead_connections(void)
938 for(p = conn_list; p != NULL; p = p->next)
942 if(p->status.active && p->status.meta)
944 if(p->last_ping_time + timeout < now)
946 if(p->status.pinged && !p->status.got_pong)
949 syslog(LOG_INFO, _(IP_ADDR_S " (%s) didn't respond to ping"),
950 IP_ADDR_V(p->vpn_ip), p->hostname);
951 p->status.timeout = 1;
952 terminate_connection(p);
954 else if(p->want_ping)
957 p->last_ping_time = now;
958 p->status.pinged = 1;
959 p->status.got_pong = 0;
969 accept a new tcp connect and create a
972 int handle_new_meta_connection(conn_list_t *cl)
975 struct sockaddr client;
976 int nfd, len = sizeof(client);
978 if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
980 syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
984 if((ncn = create_new_connection(nfd)) == NULL)
988 syslog(LOG_NOTICE, _("Closed attempted connection"));
992 ncn->status.meta = 1;
993 ncn->next = conn_list;
1000 dispatch any incoming meta requests
1002 int handle_incoming_meta_data(conn_list_t *cl)
1004 int x, l = sizeof(x);
1005 int request, oldlen, i;
1008 if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1010 syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1015 syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1019 if(cl->buflen >= MAXBUFSIZE)
1021 syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1025 lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1029 syslog(LOG_ERR, _("Metadata socket read error: %m"));
1033 oldlen = cl->buflen;
1034 cl->buflen += lenin;
1040 for(i = oldlen; i < cl->buflen; i++)
1042 if(cl->buffer[i] == '\n')
1044 cl->buffer[i] = 0; /* replace end-of-line by end-of-string so we can use sscanf */
1053 syslog(LOG_DEBUG, _("Got request from " IP_ADDR_S " (%s): %s"),
1054 IP_ADDR_V(cl->vpn_ip), cl->hostname, cl->buffer);
1055 if(sscanf(cl->buffer, "%d", &request) == 1)
1057 if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1059 syslog(LOG_ERR, _("Unknown request from " IP_ADDR_S " (%s)"),
1060 IP_ADDR_V(cl->vpn_ip), cl->hostname);
1064 if(request_handlers[request](cl)) /* Something went wrong. Probably scriptkiddies. Terminate. */
1066 syslog(LOG_ERR, _("Error while processing request from " IP_ADDR_S " (%s)"),
1067 IP_ADDR_V(cl->vpn_ip), cl->hostname);
1073 syslog(LOG_ERR, _("Bogus data received from " IP_ADDR_S " (%s)"),
1074 IP_ADDR_V(cl->vpn_ip), cl->hostname);
1078 cl->buflen -= cl->reqlen;
1079 memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1088 cl->last_ping_time = time(NULL);
1095 check all connections to see if anything
1096 happened on their sockets
1098 void check_network_activity(fd_set *f)
1101 int x, l = sizeof(x);
1103 for(p = conn_list; p != NULL; p = p->next)
1105 if(p->status.remove)
1108 if(p->status.dataopen)
1109 if(FD_ISSET(p->socket, f))
1112 The only thing that can happen to get us here is apparently an
1113 error on this outgoing(!) UDP socket that isn't immediate (i.e.
1114 something that will not trigger an error directly on send()).
1115 I've once got here when it said `No route to host'.
1117 getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1118 syslog(LOG_ERR, _("Outgoing data socket error: %s"), sys_errlist[x]);
1119 terminate_connection(p);
1124 if(FD_ISSET(p->meta_socket, f))
1125 if(handle_incoming_meta_data(p) < 0)
1127 terminate_connection(p);
1132 if(FD_ISSET(myself->socket, f))
1133 handle_incoming_vpn_data(myself);
1135 if(FD_ISSET(myself->meta_socket, f))
1136 handle_new_meta_connection(myself);
1141 read, encrypt and send data that is
1142 available through the ethertap device
1144 void handle_tap_input(void)
1148 int ether_type, lenin;
1150 memset(&vp, 0, sizeof(vp));
1151 if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1153 syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1157 total_tap_in += lenin;
1159 ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1160 if(ether_type != 0x0800)
1163 syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1164 ether_type, MAC_ADDR_V(vp.data[6]));
1171 syslog(LOG_INFO, _("Dropping short packet"));
1175 from = ntohl(*((unsigned long*)(&vp.data[26])));
1176 to = ntohl(*((unsigned long*)(&vp.data[30])));
1179 syslog(LOG_DEBUG, _("An IP packet (%04x) for " IP_ADDR_S " from " IP_ADDR_S),
1180 ether_type, IP_ADDR_V(to), IP_ADDR_V(from));
1182 syslog(LOG_DEBUG, _(MAC_ADDR_S " to " MAC_ADDR_S),
1183 MAC_ADDR_V(vp.data[0]), MAC_ADDR_V(vp.data[6]));
1185 vp.len = (length_t)lenin - 2;
1187 strip_mac_addresses(&vp);
1189 send_packet(to, &vp);
1194 this is where it all happens...
1196 void main_loop(void)
1201 time_t last_ping_check;
1203 last_ping_check = time(NULL);
1207 tv.tv_sec = timeout;
1213 if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1215 if(errno == EINTR) /* because of alarm */
1217 syslog(LOG_ERR, _("Error while waiting for input: %m"));
1221 if(last_ping_check + timeout < time(NULL))
1222 /* Let's check if everybody is still alive */
1224 check_dead_connections();
1225 last_ping_check = time(NULL);
1229 check_network_activity(&fset);
1231 /* local tap data */
1232 if(FD_ISSET(tap_fd, &fset))