]> git.meshlink.io Git - meshlink/blob - src/net_packet.c
Allow log messages to be captured by tincctl.
[meshlink] / src / net_packet.c
1 /*
2     net_packet.c -- Handles in- and outgoing VPN packets
3     Copyright (C) 1998-2005 Ivo Timmermans,
4                   2000-2011 Guus Sliepen <guus@tinc-vpn.org>
5                   2010      Timothy Redaelli <timothy@redaelli.eu>
6                   2010      Brandon Black <blblack@gmail.com>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17
18     You should have received a copy of the GNU General Public License along
19     with this program; if not, write to the Free Software Foundation, Inc.,
20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include "system.h"
24
25 #include <openssl/rand.h>
26 #include <openssl/err.h>
27 #include <openssl/evp.h>
28 #include <openssl/pem.h>
29 #include <openssl/hmac.h>
30
31 #ifdef HAVE_ZLIB
32 #include <zlib.h>
33 #endif
34
35 #ifdef HAVE_LZO
36 #include LZO1X_H
37 #endif
38
39 #include "splay_tree.h"
40 #include "cipher.h"
41 #include "conf.h"
42 #include "connection.h"
43 #include "crypto.h"
44 #include "digest.h"
45 #include "device.h"
46 #include "ethernet.h"
47 #include "graph.h"
48 #include "logger.h"
49 #include "net.h"
50 #include "netutl.h"
51 #include "protocol.h"
52 #include "process.h"
53 #include "route.h"
54 #include "utils.h"
55 #include "xalloc.h"
56
57 int keylifetime = 0;
58 #ifdef HAVE_LZO
59 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
60 #endif
61
62 static void send_udppacket(node_t *, vpn_packet_t *);
63
64 unsigned replaywin = 16;
65 bool localdiscovery = false;
66
67 #define MAX_SEQNO 1073741824
68
69 /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
70    mtuprobes ==    31: sleep pinginterval seconds
71    mtuprobes ==    32: send 1 burst, sleep pingtimeout second
72    mtuprobes ==    33: no response from other side, restart PMTU discovery process
73
74    Probes are sent in batches of three, with random sizes between the lower and
75    upper boundaries for the MTU thus far discovered.
76
77    In case local discovery is enabled, a fourth packet is added to each batch,
78    which will be broadcast to the local network.
79 */
80
81 static void send_mtu_probe_handler(int fd, short events, void *data) {
82         node_t *n = data;
83         vpn_packet_t packet;
84         int len, i;
85         int timeout = 1;
86         
87         n->mtuprobes++;
88
89         if(!n->status.reachable || !n->status.validkey) {
90                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname);
91                 n->mtuprobes = 0;
92                 return;
93         }
94
95         if(n->mtuprobes > 32) {
96                 if(!n->minmtu) {
97                         n->mtuprobes = 31;
98                         timeout = pinginterval;
99                         goto end;
100                 }
101
102                 logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
103                 n->mtuprobes = 1;
104                 n->minmtu = 0;
105                 n->maxmtu = MTU;
106         }
107
108         if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
109                 logger(DEBUG_TRAFFIC, LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname);
110                 n->mtuprobes = 31;
111         }
112
113         if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
114                 if(n->minmtu > n->maxmtu)
115                         n->minmtu = n->maxmtu;
116                 else
117                         n->maxmtu = n->minmtu;
118                 n->mtu = n->minmtu;
119                 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
120                 n->mtuprobes = 31;
121         }
122
123         if(n->mtuprobes == 31) {
124                 timeout = pinginterval;
125                 goto end;
126         } else if(n->mtuprobes == 32) {
127                 timeout = pingtimeout;
128         }
129
130         for(i = 0; i < 3 + localdiscovery; i++) {
131                 if(n->maxmtu <= n->minmtu)
132                         len = n->maxmtu;
133                 else
134                         len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
135
136                 if(len < 64)
137                         len = 64;
138                 
139                 memset(packet.data, 0, 14);
140                 randomize(packet.data + 14, len - 14);
141                 packet.len = len;
142                 if(i >= 3 && n->mtuprobes <= 10)
143                         packet.priority = -1;
144                 else
145                         packet.priority = 0;
146
147                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
148
149                 send_udppacket(n, &packet);
150         }
151
152 end:
153         event_add(&n->mtuevent, &(struct timeval){timeout, 0});
154 }
155
156 void send_mtu_probe(node_t *n) {
157         if(!timeout_initialized(&n->mtuevent))
158                 timeout_set(&n->mtuevent, send_mtu_probe_handler, n);
159         send_mtu_probe_handler(0, 0, n);
160 }
161
162 static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
163         logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe length %d from %s (%s)", packet->len, n->name, n->hostname);
164
165         if(!packet->data[0]) {
166                 packet->data[0] = 1;
167                 send_udppacket(n, packet);
168         } else {
169                 if(n->mtuprobes > 30) {
170                         if(n->minmtu)
171                                 n->mtuprobes = 30;
172                         else
173                                 n->mtuprobes = 1;
174                 }
175
176                 if(len > n->maxmtu)
177                         len = n->maxmtu;
178                 if(n->minmtu < len)
179                         n->minmtu = len;
180         }
181 }
182
183 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
184         if(level == 0) {
185                 memcpy(dest, source, len);
186                 return len;
187         } else if(level == 10) {
188 #ifdef HAVE_LZO
189                 lzo_uint lzolen = MAXSIZE;
190                 lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
191                 return lzolen;
192 #else
193                 return -1;
194 #endif
195         } else if(level < 10) {
196 #ifdef HAVE_ZLIB
197                 unsigned long destlen = MAXSIZE;
198                 if(compress2(dest, &destlen, source, len, level) == Z_OK)
199                         return destlen;
200                 else
201 #endif
202                         return -1;
203         } else {
204 #ifdef HAVE_LZO
205                 lzo_uint lzolen = MAXSIZE;
206                 lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
207                 return lzolen;
208 #else
209                 return -1;
210 #endif
211         }
212         
213         return -1;
214 }
215
216 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
217         if(level == 0) {
218                 memcpy(dest, source, len);
219                 return len;
220         } else if(level > 9) {
221 #ifdef HAVE_LZO
222                 lzo_uint lzolen = MAXSIZE;
223                 if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
224                         return lzolen;
225                 else
226 #endif
227                         return -1;
228         }
229 #ifdef HAVE_ZLIB
230         else {
231                 unsigned long destlen = MAXSIZE;
232                 if(uncompress(dest, &destlen, source, len) == Z_OK)
233                         return destlen;
234                 else
235                         return -1;
236         }
237 #endif
238
239         return -1;
240 }
241
242 /* VPN packet I/O */
243
244 static void receive_packet(node_t *n, vpn_packet_t *packet) {
245         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
246                            packet->len, n->name, n->hostname);
247
248         n->in_packets++;
249         n->in_bytes += packet->len;
250
251         route(n, packet);
252 }
253
254 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
255         if(!digest_active(&n->indigest) || inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest))
256                 return false;
257
258         return digest_verify(&n->indigest, &inpkt->seqno, inpkt->len - n->indigest.maclength, (const char *)&inpkt->seqno + inpkt->len - n->indigest.maclength);
259 }
260
261 static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
262         vpn_packet_t pkt1, pkt2;
263         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
264         int nextpkt = 0;
265         vpn_packet_t *outpkt = pkt[0];
266         size_t outlen;
267
268         if(!cipher_active(&n->incipher)) {
269                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet",
270                                         n->name, n->hostname);
271                 return;
272         }
273
274         /* Check packet length */
275
276         if(inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest)) {
277                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
278                                         n->name, n->hostname);
279                 return;
280         }
281
282         /* Check the message authentication code */
283
284         if(digest_active(&n->indigest)) {
285                 inpkt->len -= n->indigest.maclength;
286                 if(!digest_verify(&n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) {
287                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
288                         return;
289                 }
290         }
291         /* Decrypt the packet */
292
293         if(cipher_active(&n->incipher)) {
294                 outpkt = pkt[nextpkt++];
295                 outlen = MAXSIZE;
296
297                 if(!cipher_decrypt(&n->incipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
298                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
299                         return;
300                 }
301                 
302                 outpkt->len = outlen;
303                 inpkt = outpkt;
304         }
305
306         /* Check the sequence number */
307
308         inpkt->len -= sizeof inpkt->seqno;
309         inpkt->seqno = ntohl(inpkt->seqno);
310
311         if(replaywin) {
312                 if(inpkt->seqno != n->received_seqno + 1) {
313                         if(inpkt->seqno >= n->received_seqno + replaywin * 8) {
314                                 if(n->farfuture++ < replaywin >> 2) {
315                                         logger(DEBUG_ALWAYS, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
316                                                 n->name, n->hostname, inpkt->seqno - n->received_seqno - 1, n->farfuture);
317                                         return;
318                                 }
319                                 logger(DEBUG_ALWAYS, LOG_WARNING, "Lost %d packets from %s (%s)",
320                                                 inpkt->seqno - n->received_seqno - 1, n->name, n->hostname);
321                                 memset(n->late, 0, replaywin);
322                         } else if (inpkt->seqno <= n->received_seqno) {
323                                 if((n->received_seqno >= replaywin * 8 && inpkt->seqno <= n->received_seqno - replaywin * 8) || !(n->late[(inpkt->seqno / 8) % replaywin] & (1 << inpkt->seqno % 8))) {
324                                         logger(DEBUG_ALWAYS, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
325                                                 n->name, n->hostname, inpkt->seqno, n->received_seqno);
326                                         return;
327                                 }
328                         } else {
329                                 for(int i = n->received_seqno + 1; i < inpkt->seqno; i++)
330                                         n->late[(i / 8) % replaywin] |= 1 << i % 8;
331                         }
332                 }
333
334                 n->farfuture = 0;
335                 n->late[(inpkt->seqno / 8) % replaywin] &= ~(1 << inpkt->seqno % 8);
336         }
337
338         if(inpkt->seqno > n->received_seqno)
339                 n->received_seqno = inpkt->seqno;
340                         
341         if(n->received_seqno > MAX_SEQNO)
342                 regenerate_key();
343
344         /* Decompress the packet */
345
346         length_t origlen = inpkt->len;
347
348         if(n->incompression) {
349                 outpkt = pkt[nextpkt++];
350
351                 if((outpkt->len = uncompress_packet(outpkt->data, inpkt->data, inpkt->len, n->incompression)) < 0) {
352                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
353                                                  n->name, n->hostname);
354                         return;
355                 }
356
357                 inpkt = outpkt;
358
359                 origlen -= MTU/64 + 20;
360         }
361
362         inpkt->priority = 0;
363
364         if(!inpkt->data[12] && !inpkt->data[13])
365                 mtu_probe_h(n, inpkt, origlen);
366         else
367                 receive_packet(n, inpkt);
368 }
369
370 void receive_tcppacket(connection_t *c, const char *buffer, int len) {
371         vpn_packet_t outpkt;
372
373         outpkt.len = len;
374         if(c->options & OPTION_TCPONLY)
375                 outpkt.priority = 0;
376         else
377                 outpkt.priority = -1;
378         memcpy(outpkt.data, buffer, len);
379
380         receive_packet(c->node, &outpkt);
381 }
382
383 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
384         vpn_packet_t pkt1, pkt2;
385         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
386         vpn_packet_t *inpkt = origpkt;
387         int nextpkt = 0;
388         vpn_packet_t *outpkt;
389         int origlen = origpkt->len;
390         size_t outlen;
391 #if defined(SOL_IP) && defined(IP_TOS)
392         static int priority = 0;
393         int origpriority = origpkt->priority;
394 #endif
395
396         if(!n->status.reachable) {
397                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
398                 return;
399         }
400
401         /* Make sure we have a valid key */
402
403         if(!n->status.validkey) {
404                 time_t now = time(NULL);
405
406                 logger(DEBUG_TRAFFIC, LOG_INFO,
407                                    "No valid key known yet for %s (%s), forwarding via TCP",
408                                    n->name, n->hostname);
409
410                 if(n->last_req_key + 10 <= now) {
411                         send_req_key(n);
412                         n->last_req_key = now;
413                 }
414
415                 send_tcppacket(n->nexthop->connection, origpkt);
416
417                 return;
418         }
419
420         if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (inpkt->data[12] | inpkt->data[13])) {
421                 logger(DEBUG_TRAFFIC, LOG_INFO,
422                                 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
423                                 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
424
425                 if(n != n->nexthop)
426                         send_packet(n->nexthop, origpkt);
427                 else
428                         send_tcppacket(n->nexthop->connection, origpkt);
429
430                 return;
431         }
432
433         /* Compress the packet */
434
435         if(n->outcompression) {
436                 outpkt = pkt[nextpkt++];
437
438                 if((outpkt->len = compress_packet(outpkt->data, inpkt->data, inpkt->len, n->outcompression)) < 0) {
439                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
440                                    n->name, n->hostname);
441                         return;
442                 }
443
444                 inpkt = outpkt;
445         }
446
447         /* Add sequence number */
448
449         inpkt->seqno = htonl(++(n->sent_seqno));
450         inpkt->len += sizeof inpkt->seqno;
451
452         /* Encrypt the packet */
453
454         if(cipher_active(&n->outcipher)) {
455                 outpkt = pkt[nextpkt++];
456                 outlen = MAXSIZE;
457
458                 if(!cipher_encrypt(&n->outcipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
459                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
460                         goto end;
461                 }
462
463                 outpkt->len = outlen;
464                 inpkt = outpkt;
465         }
466
467         /* Add the message authentication code */
468
469         if(digest_active(&n->outdigest)) {
470                 digest_create(&n->outdigest, &inpkt->seqno, inpkt->len, (char *)&inpkt->seqno + inpkt->len);
471                 inpkt->len += digest_length(&n->outdigest);
472         }
473
474         /* Determine which socket we have to use */
475
476         if(n->address.sa.sa_family != listen_socket[n->sock].sa.sa.sa_family) {
477                 for(int sock = 0; sock < listen_sockets; sock++) {
478                         if(n->address.sa.sa_family == listen_socket[sock].sa.sa.sa_family) {
479                                 n->sock = sock;
480                                 break;
481                         }
482                 }
483         }
484
485         /* Send the packet */
486
487         struct sockaddr *sa;
488         socklen_t sl;
489         int sock;
490
491         /* Overloaded use of priority field: -1 means local broadcast */
492
493         if(origpriority == -1 && n->prevedge) {
494                 struct sockaddr_in in;
495                 in.sin_family = AF_INET;
496                 in.sin_addr.s_addr = -1;
497                 in.sin_port = n->prevedge->address.in.sin_port;
498                 sa = (struct sockaddr *)&in;
499                 sl = sizeof in;
500                 sock = 0;
501         } else {
502                 if(origpriority == -1)
503                         origpriority = 0;
504
505                 sa = &(n->address.sa);
506                 sl = SALEN(n->address.sa);
507                 sock = n->sock;
508         }
509
510 #if defined(SOL_IP) && defined(IP_TOS)
511         if(priorityinheritance && origpriority != priority
512            && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
513                 priority = origpriority;
514                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
515                 if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
516                         logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", strerror(errno));
517         }
518 #endif
519
520         if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, sa, sl) < 0 && !sockwouldblock(sockerrno)) {
521                 if(sockmsgsize(sockerrno)) {
522                         if(n->maxmtu >= origlen)
523                                 n->maxmtu = origlen - 1;
524                         if(n->mtu >= origlen)
525                                 n->mtu = origlen - 1;
526                 } else
527                         logger(DEBUG_ALWAYS, LOG_ERR, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
528         }
529
530 end:
531         origpkt->len = origlen;
532 }
533
534 /*
535   send a packet to the given vpn ip.
536 */
537 void send_packet(node_t *n, vpn_packet_t *packet) {
538         node_t *via;
539
540         if(n == myself) {
541                 if(overwrite_mac)
542                          memcpy(packet->data, mymac.x, ETH_ALEN);
543                 n->out_packets++;
544                 n->out_bytes += packet->len;
545                 devops.write(packet);
546                 return;
547         }
548
549         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
550                            packet->len, n->name, n->hostname);
551
552         if(!n->status.reachable) {
553                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
554                                    n->name, n->hostname);
555                 return;
556         }
557
558         n->out_packets++;
559         n->out_bytes += packet->len;
560
561         via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
562
563         if(via != n)
564                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)",
565                            n->name, via->name, n->via->hostname);
566
567         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
568                 if(!send_tcppacket(via->connection, packet))
569                         terminate_connection(via->connection, true);
570         } else
571                 send_udppacket(via, packet);
572 }
573
574 /* Broadcast a packet using the minimum spanning tree */
575
576 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
577         splay_node_t *node;
578         connection_t *c;
579
580         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
581                            packet->len, from->name, from->hostname);
582
583         if(from != myself) {
584                 send_packet(myself, packet);
585
586                 // In TunnelServer mode, do not forward broadcast packets.
587                 // The MST might not be valid and create loops.
588                 if(tunnelserver)
589                         return;
590         }
591
592         for(node = connection_tree->head; node; node = node->next) {
593                 c = node->data;
594
595                 if(c->status.active && c->status.mst && c != from->nexthop->connection)
596                         send_packet(c->node, packet);
597         }
598 }
599
600 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
601         splay_node_t *node;
602         edge_t *e;
603         node_t *n = NULL;
604         bool hard = false;
605         static time_t last_hard_try = 0;
606         time_t now = time(NULL);
607
608         for(node = edge_weight_tree->head; node; node = node->next) {
609                 e = node->data;
610
611                 if(e->to == myself)
612                         continue;
613
614                 if(sockaddrcmp_noport(from, &e->address)) {
615                         if(last_hard_try == now)
616                                 continue;
617                         hard = true;
618                 }
619
620                 if(!try_mac(e->to, pkt))
621                         continue;
622
623                 n = e->to;
624                 break;
625         }
626
627         if(hard)
628                 last_hard_try = now;
629
630         last_hard_try = now;
631         return n;
632 }
633
634 void handle_incoming_vpn_data(int sock, short events, void *data) {
635         vpn_packet_t pkt;
636         char *hostname;
637         sockaddr_t from;
638         socklen_t fromlen = sizeof from;
639         node_t *n;
640         int len;
641
642         len = recvfrom(sock, (char *) &pkt.seqno, MAXSIZE, 0, &from.sa, &fromlen);
643
644         if(len <= 0 || len > MAXSIZE) {
645                 if(!sockwouldblock(sockerrno))
646                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
647                 return;
648         }
649
650         pkt.len = len;
651
652         sockaddrunmap(&from);           /* Some braindead IPv6 implementations do stupid things. */
653
654         n = lookup_node_udp(&from);
655
656         if(!n) {
657                 n = try_harder(&from, &pkt);
658                 if(n)
659                         update_node_udp(n, &from);
660                 else if(debug_level >= DEBUG_PROTOCOL) {
661                         hostname = sockaddr2hostname(&from);
662                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
663                         free(hostname);
664                         return;
665                 }
666                 else
667                         return;
668         }
669
670         n->sock = (intptr_t)data;
671
672         receive_udppacket(n, &pkt);
673 }
674
675 void handle_device_data(int sock, short events, void *data) {
676         vpn_packet_t packet;
677
678         packet.priority = 0;
679
680         if(devops.read(&packet)) {
681                 myself->in_packets++;
682                 myself->in_bytes += packet.len;
683                 route(myself, &packet);
684         }
685 }