2 net_packet.c -- Handles in- and outgoing VPN packets
3 Copyright (C) 1998-2005 Ivo Timmermans,
4 2000-2012 Guus Sliepen <guus@tinc-vpn.org>
5 2010 Timothy Redaelli <timothy@redaelli.eu>
6 2010 Brandon Black <blblack@gmail.com>
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.
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.
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.
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>
41 #include "connection.h"
58 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
61 static void send_udppacket(node_t *, vpn_packet_t *);
63 unsigned replaywin = 16;
64 bool localdiscovery = false;
66 #define MAX_SEQNO 1073741824
68 /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
69 mtuprobes == 31: sleep pinginterval seconds
70 mtuprobes == 32: send 1 burst, sleep pingtimeout second
71 mtuprobes == 33: no response from other side, restart PMTU discovery process
73 Probes are sent in batches of three, with random sizes between the lower and
74 upper boundaries for the MTU thus far discovered.
76 In case local discovery is enabled, a fourth packet is added to each batch,
77 which will be broadcast to the local network.
80 static void send_mtu_probe_handler(int fd, short events, void *data) {
86 if(!n->status.reachable || !n->status.validkey) {
87 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname);
92 if(n->mtuprobes > 32) {
95 timeout = pinginterval;
99 logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
100 n->status.udp_confirmed = false;
106 if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
107 logger(DEBUG_TRAFFIC, LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname);
111 if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
112 if(n->minmtu > n->maxmtu)
113 n->minmtu = n->maxmtu;
115 n->maxmtu = n->minmtu;
117 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
121 if(n->mtuprobes == 31) {
122 timeout = pinginterval;
124 } else if(n->mtuprobes == 32) {
125 timeout = pingtimeout;
128 for(int i = 0; i < 3 + localdiscovery; i++) {
131 if(n->maxmtu <= n->minmtu)
134 len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
140 memset(packet.data, 0, 14);
141 randomize(packet.data + 14, len - 14);
143 if(i >= 3 && n->mtuprobes <= 10)
144 packet.priority = -1;
148 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
150 send_udppacket(n, &packet);
154 event_add(&n->mtuevent, &(struct timeval){timeout, 0});
157 void send_mtu_probe(node_t *n) {
158 if(!timeout_initialized(&n->mtuevent))
159 timeout_set(&n->mtuevent, send_mtu_probe_handler, n);
160 send_mtu_probe_handler(0, 0, n);
163 static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
164 logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe length %d from %s (%s)", packet->len, n->name, n->hostname);
166 if(!packet->data[0]) {
168 send_udppacket(n, packet);
170 n->status.udp_confirmed = true;
172 if(n->mtuprobes > 30) {
186 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
188 memcpy(dest, source, len);
190 } else if(level == 10) {
192 lzo_uint lzolen = MAXSIZE;
193 lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
198 } else if(level < 10) {
200 unsigned long destlen = MAXSIZE;
201 if(compress2(dest, &destlen, source, len, level) == Z_OK)
208 lzo_uint lzolen = MAXSIZE;
209 lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
219 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
221 memcpy(dest, source, len);
223 } else if(level > 9) {
225 lzo_uint lzolen = MAXSIZE;
226 if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
234 unsigned long destlen = MAXSIZE;
235 if(uncompress(dest, &destlen, source, len) == Z_OK)
247 static void receive_packet(node_t *n, vpn_packet_t *packet) {
248 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
249 packet->len, n->name, n->hostname);
252 n->in_bytes += packet->len;
257 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
259 return sptps_verify_datagram(&n->sptps, (char *)&inpkt->seqno, inpkt->len);
261 if(!digest_active(&n->indigest) || inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest))
264 return digest_verify(&n->indigest, &inpkt->seqno, inpkt->len - n->indigest.maclength, (const char *)&inpkt->seqno + inpkt->len - n->indigest.maclength);
267 static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
268 vpn_packet_t pkt1, pkt2;
269 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
271 vpn_packet_t *outpkt = pkt[0];
274 if(n->status.sptps) {
275 sptps_receive_data(&n->sptps, (char *)&inpkt->seqno, inpkt->len);
279 if(!cipher_active(&n->incipher)) {
280 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet",
281 n->name, n->hostname);
285 /* Check packet length */
287 if(inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest)) {
288 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
289 n->name, n->hostname);
293 /* Check the message authentication code */
295 if(digest_active(&n->indigest)) {
296 inpkt->len -= n->indigest.maclength;
297 if(!digest_verify(&n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) {
298 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
302 /* Decrypt the packet */
304 if(cipher_active(&n->incipher)) {
305 outpkt = pkt[nextpkt++];
308 if(!cipher_decrypt(&n->incipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
309 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
313 outpkt->len = outlen;
317 /* Check the sequence number */
319 inpkt->len -= sizeof inpkt->seqno;
320 inpkt->seqno = ntohl(inpkt->seqno);
323 if(inpkt->seqno != n->received_seqno + 1) {
324 if(inpkt->seqno >= n->received_seqno + replaywin * 8) {
325 if(n->farfuture++ < replaywin >> 2) {
326 logger(DEBUG_ALWAYS, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
327 n->name, n->hostname, inpkt->seqno - n->received_seqno - 1, n->farfuture);
330 logger(DEBUG_ALWAYS, LOG_WARNING, "Lost %d packets from %s (%s)",
331 inpkt->seqno - n->received_seqno - 1, n->name, n->hostname);
332 memset(n->late, 0, replaywin);
333 } else if (inpkt->seqno <= n->received_seqno) {
334 if((n->received_seqno >= replaywin * 8 && inpkt->seqno <= n->received_seqno - replaywin * 8) || !(n->late[(inpkt->seqno / 8) % replaywin] & (1 << inpkt->seqno % 8))) {
335 logger(DEBUG_ALWAYS, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
336 n->name, n->hostname, inpkt->seqno, n->received_seqno);
340 for(int i = n->received_seqno + 1; i < inpkt->seqno; i++)
341 n->late[(i / 8) % replaywin] |= 1 << i % 8;
346 n->late[(inpkt->seqno / 8) % replaywin] &= ~(1 << inpkt->seqno % 8);
349 if(inpkt->seqno > n->received_seqno)
350 n->received_seqno = inpkt->seqno;
352 if(n->received_seqno > MAX_SEQNO)
355 /* Decompress the packet */
357 length_t origlen = inpkt->len;
359 if(n->incompression) {
360 outpkt = pkt[nextpkt++];
362 if((outpkt->len = uncompress_packet(outpkt->data, inpkt->data, inpkt->len, n->incompression)) < 0) {
363 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
364 n->name, n->hostname);
370 origlen -= MTU/64 + 20;
375 if(!inpkt->data[12] && !inpkt->data[13])
376 mtu_probe_h(n, inpkt, origlen);
378 receive_packet(n, inpkt);
381 void receive_tcppacket(connection_t *c, const char *buffer, int len) {
385 if(c->options & OPTION_TCPONLY)
388 outpkt.priority = -1;
389 memcpy(outpkt.data, buffer, len);
391 receive_packet(c->node, &outpkt);
394 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
395 if(!n->status.validkey) {
396 logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
397 if(!n->status.waitingforkey)
399 else if(n->last_req_key + 10 < time(NULL)) {
400 sptps_stop(&n->sptps);
401 n->status.waitingforkey = false;
410 if(!(origpkt->data[12] | origpkt->data[13])) {
411 sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len);
415 if(routing_mode == RMODE_ROUTER)
420 if(origpkt->len < offset)
425 if(n->outcompression) {
426 int len = compress_packet(outpkt.data + offset, origpkt->data + offset, origpkt->len - offset, n->outcompression);
428 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
429 } else if(len < origpkt->len - offset) {
430 outpkt.len = len + offset;
432 type |= PKT_COMPRESSED;
436 sptps_send_record(&n->sptps, type, (char *)origpkt->data + offset, origpkt->len - offset);
440 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
441 vpn_packet_t pkt1, pkt2;
442 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
443 vpn_packet_t *inpkt = origpkt;
445 vpn_packet_t *outpkt;
446 int origlen = origpkt->len;
448 #if defined(SOL_IP) && defined(IP_TOS)
449 static int priority = 0;
451 int origpriority = origpkt->priority;
453 if(!n->status.reachable) {
454 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
459 return send_sptps_packet(n, origpkt);
461 /* Make sure we have a valid key */
463 if(!n->status.validkey) {
464 time_t now = time(NULL);
466 logger(DEBUG_TRAFFIC, LOG_INFO,
467 "No valid key known yet for %s (%s), forwarding via TCP",
468 n->name, n->hostname);
470 if(n->last_req_key + 10 <= now) {
472 n->last_req_key = now;
475 send_tcppacket(n->nexthop->connection, origpkt);
480 if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (inpkt->data[12] | inpkt->data[13])) {
481 logger(DEBUG_TRAFFIC, LOG_INFO,
482 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
483 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
486 send_packet(n->nexthop, origpkt);
488 send_tcppacket(n->nexthop->connection, origpkt);
493 /* Compress the packet */
495 if(n->outcompression) {
496 outpkt = pkt[nextpkt++];
498 if((outpkt->len = compress_packet(outpkt->data, inpkt->data, inpkt->len, n->outcompression)) < 0) {
499 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
500 n->name, n->hostname);
507 /* Add sequence number */
509 inpkt->seqno = htonl(++(n->sent_seqno));
510 inpkt->len += sizeof inpkt->seqno;
512 /* Encrypt the packet */
514 if(cipher_active(&n->outcipher)) {
515 outpkt = pkt[nextpkt++];
518 if(!cipher_encrypt(&n->outcipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
519 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
523 outpkt->len = outlen;
527 /* Add the message authentication code */
529 if(digest_active(&n->outdigest)) {
530 digest_create(&n->outdigest, &inpkt->seqno, inpkt->len, (char *)&inpkt->seqno + inpkt->len);
531 inpkt->len += digest_length(&n->outdigest);
534 /* Send the packet */
539 /* Overloaded use of priority field: -1 means local broadcast */
541 if(origpriority == -1 && n->prevedge) {
542 sockaddr_t broadcast;
543 broadcast.in.sin_family = AF_INET;
544 broadcast.in.sin_addr.s_addr = -1;
545 broadcast.in.sin_port = n->prevedge->address.in.sin_port;
549 if(origpriority == -1)
552 if(n->status.udp_confirmed) {
553 /* Address of this node is confirmed, so use it. */
557 /* Otherwise, go through the list of known addresses of
558 this node. The first address we try is always the
559 one in n->address; that could be set to the node's
560 reflexive UDP address discovered during key
561 exchange. The other known addresses are those found
562 in edges to this node. */
564 static unsigned int i;
566 edge_t *candidate = NULL;
569 for splay_each(edge_t, e, edge_weight_tree) {
573 if(!candidate || j == i)
582 sa = &candidate->address;
583 sock = rand() % listen_sockets;
592 /* Determine which socket we have to use */
594 if(sa->sa.sa_family != listen_socket[sock].sa.sa.sa_family)
595 for(sock = 0; sock < listen_sockets; sock++)
596 if(sa->sa.sa_family == listen_socket[sock].sa.sa.sa_family)
599 if(sock >= listen_sockets)
602 if(!n->status.udp_confirmed)
605 #if defined(SOL_IP) && defined(IP_TOS)
606 if(priorityinheritance && origpriority != priority
607 && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
608 priority = origpriority;
609 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
610 if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
611 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", strerror(errno));
615 socklen_t sl = SALEN(n->address.sa);
617 if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, &sa->sa, sl) < 0 && !sockwouldblock(sockerrno)) {
618 if(sockmsgsize(sockerrno)) {
619 if(n->maxmtu >= origlen)
620 n->maxmtu = origlen - 1;
621 if(n->mtu >= origlen)
622 n->mtu = origlen - 1;
624 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
628 origpkt->len = origlen;
631 bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
634 if(type >= SPTPS_HANDSHAKE
635 || ((myself->options | to->options) & OPTION_TCPONLY)
636 || (type != PKT_PROBE && len > to->minmtu)) {
637 char buf[len * 4 / 3 + 5];
638 b64encode(data, buf, len);
639 if(!to->status.validkey)
640 return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, myself->incompression);
642 return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, type >= SPTPS_HANDSHAKE ? REQ_SPTPS : REQ_PACKET, buf);
645 /* Send the packet */
651 sa = &(to->address.sa);
652 sl = SALEN(to->address.sa);
655 if(sendto(listen_socket[sock].udp, data, len, 0, sa, sl) < 0 && !sockwouldblock(sockerrno)) {
656 if(sockmsgsize(sockerrno)) {
657 if(to->maxmtu >= len)
658 to->maxmtu = len - 1;
662 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", to->name, to->hostname, sockstrerror(sockerrno));
670 bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t len) {
671 node_t *from = handle;
673 if(type == SPTPS_HANDSHAKE) {
674 from->status.validkey = true;
675 from->status.waitingforkey = false;
676 logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
681 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
687 if(type == PKT_PROBE) {
689 memcpy(inpkt.data, data, len);
690 mtu_probe_h(from, &inpkt, len);
694 if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
695 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
699 /* Check if we have the headers we need */
700 if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
701 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
703 } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
704 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
707 int offset = (type & PKT_MAC) ? 0 : 14;
708 if(type & PKT_COMPRESSED) {
709 len = uncompress_packet(inpkt.data + offset, (const uint8_t *)data, len, from->incompression);
713 inpkt.len = len + offset;
715 if(inpkt.len > MAXSIZE)
718 memcpy(inpkt.data + offset, data, len);
719 inpkt.len = len + offset;
722 /* Generate the Ethernet packet type if necessary */
724 switch(inpkt.data[14] >> 4) {
726 inpkt.data[12] = 0x08;
727 inpkt.data[13] = 0x00;
730 inpkt.data[12] = 0x86;
731 inpkt.data[13] = 0xDD;
734 logger(DEBUG_TRAFFIC, LOG_ERR,
735 "Unknown IP version %d while reading packet from %s (%s)",
736 inpkt.data[14] >> 4, from->name, from->hostname);
741 receive_packet(from, &inpkt);
746 send a packet to the given vpn ip.
748 void send_packet(node_t *n, vpn_packet_t *packet) {
753 memcpy(packet->data, mymac.x, ETH_ALEN);
755 n->out_bytes += packet->len;
756 devops.write(packet);
760 logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
761 packet->len, n->name, n->hostname);
763 if(!n->status.reachable) {
764 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
765 n->name, n->hostname);
770 n->out_bytes += packet->len;
772 if(n->status.sptps) {
773 send_sptps_packet(n, packet);
777 via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
780 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)",
781 n->name, via->name, n->via->hostname);
783 if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
784 if(!send_tcppacket(via->connection, packet))
785 terminate_connection(via->connection, true);
787 send_udppacket(via, packet);
790 /* Broadcast a packet using the minimum spanning tree */
792 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
793 // Always give ourself a copy of the packet.
795 send_packet(myself, packet);
797 // In TunnelServer mode, do not forward broadcast packets.
798 // The MST might not be valid and create loops.
799 if(tunnelserver || broadcast_mode == BMODE_NONE)
802 logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
803 packet->len, from->name, from->hostname);
805 switch(broadcast_mode) {
806 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
807 // This guarantees all nodes receive the broadcast packet, and
808 // usually distributes the sending of broadcast packets over all nodes.
810 for list_each(connection_t, c, connection_list)
811 if(c->status.active && c->status.mst && c != from->nexthop->connection)
812 send_packet(c->node, packet);
815 // In direct mode, we send copies to each node we know of.
816 // However, this only reaches nodes that can be reached in a single hop.
817 // We don't have enough information to forward broadcast packets in this case.
822 for splay_each(node_t, n, node_tree)
823 if(n->status.reachable && ((n->via == myself && n->nexthop == n) || n->via == n))
824 send_packet(n, packet);
832 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
835 static time_t last_hard_try = 0;
836 time_t now = time(NULL);
838 for splay_each(edge_t, e, edge_weight_tree) {
839 if(!e->to->status.reachable || e->to == myself)
842 if(sockaddrcmp_noport(from, &e->address)) {
843 if(last_hard_try == now)
848 if(!try_mac(e->to, pkt))
862 void handle_incoming_vpn_data(int sock, short events, void *data) {
865 sockaddr_t from = {{0}};
866 socklen_t fromlen = sizeof from;
870 len = recvfrom(sock, (char *) &pkt.seqno, MAXSIZE, 0, &from.sa, &fromlen);
872 if(len <= 0 || len > MAXSIZE) {
873 if(!sockwouldblock(sockerrno))
874 logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
880 sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
882 n = lookup_node_udp(&from);
885 n = try_harder(&from, &pkt);
887 update_node_udp(n, &from);
888 else if(debug_level >= DEBUG_PROTOCOL) {
889 hostname = sockaddr2hostname(&from);
890 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
898 n->sock = (intptr_t)data;
900 receive_udppacket(n, &pkt);
903 void handle_device_data(int sock, short events, void *data) {
908 if(devops.read(&packet)) {
909 myself->in_packets++;
910 myself->in_bytes += packet.len;
911 route(myself, &packet);