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 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
401 sptps_stop(&n->sptps);
402 n->status.waitingforkey = false;
411 if(!(origpkt->data[12] | origpkt->data[13])) {
412 sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len);
416 if(routing_mode == RMODE_ROUTER)
421 if(origpkt->len < offset)
426 if(n->outcompression) {
427 int len = compress_packet(outpkt.data + offset, origpkt->data + offset, origpkt->len - offset, n->outcompression);
429 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
430 } else if(len < origpkt->len - offset) {
431 outpkt.len = len + offset;
433 type |= PKT_COMPRESSED;
437 sptps_send_record(&n->sptps, type, (char *)origpkt->data + offset, origpkt->len - offset);
441 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
442 vpn_packet_t pkt1, pkt2;
443 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
444 vpn_packet_t *inpkt = origpkt;
446 vpn_packet_t *outpkt;
447 int origlen = origpkt->len;
449 #if defined(SOL_IP) && defined(IP_TOS)
450 static int priority = 0;
452 int origpriority = origpkt->priority;
454 if(!n->status.reachable) {
455 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
460 return send_sptps_packet(n, origpkt);
462 /* Make sure we have a valid key */
464 if(!n->status.validkey) {
465 time_t now = time(NULL);
467 logger(DEBUG_TRAFFIC, LOG_INFO,
468 "No valid key known yet for %s (%s), forwarding via TCP",
469 n->name, n->hostname);
471 if(n->last_req_key + 10 <= now) {
473 n->last_req_key = now;
476 send_tcppacket(n->nexthop->connection, origpkt);
481 if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (inpkt->data[12] | inpkt->data[13])) {
482 logger(DEBUG_TRAFFIC, LOG_INFO,
483 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
484 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
487 send_packet(n->nexthop, origpkt);
489 send_tcppacket(n->nexthop->connection, origpkt);
494 /* Compress the packet */
496 if(n->outcompression) {
497 outpkt = pkt[nextpkt++];
499 if((outpkt->len = compress_packet(outpkt->data, inpkt->data, inpkt->len, n->outcompression)) < 0) {
500 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
501 n->name, n->hostname);
508 /* Add sequence number */
510 inpkt->seqno = htonl(++(n->sent_seqno));
511 inpkt->len += sizeof inpkt->seqno;
513 /* Encrypt the packet */
515 if(cipher_active(&n->outcipher)) {
516 outpkt = pkt[nextpkt++];
519 if(!cipher_encrypt(&n->outcipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
520 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
524 outpkt->len = outlen;
528 /* Add the message authentication code */
530 if(digest_active(&n->outdigest)) {
531 digest_create(&n->outdigest, &inpkt->seqno, inpkt->len, (char *)&inpkt->seqno + inpkt->len);
532 inpkt->len += digest_length(&n->outdigest);
535 /* Send the packet */
540 /* Overloaded use of priority field: -1 means local broadcast */
542 if(origpriority == -1 && n->prevedge) {
543 sockaddr_t broadcast;
544 broadcast.in.sin_family = AF_INET;
545 broadcast.in.sin_addr.s_addr = -1;
546 broadcast.in.sin_port = n->prevedge->address.in.sin_port;
550 if(origpriority == -1)
553 if(n->status.udp_confirmed) {
554 /* Address of this node is confirmed, so use it. */
558 /* Otherwise, go through the list of known addresses of
559 this node. The first address we try is always the
560 one in n->address; that could be set to the node's
561 reflexive UDP address discovered during key
562 exchange. The other known addresses are those found
563 in edges to this node. */
565 static unsigned int i;
567 edge_t *candidate = NULL;
570 for splay_each(edge_t, e, edge_weight_tree) {
574 if(!candidate || j == i)
583 sa = &candidate->address;
584 sock = rand() % listen_sockets;
593 /* Determine which socket we have to use */
595 if(sa->sa.sa_family != listen_socket[sock].sa.sa.sa_family)
596 for(sock = 0; sock < listen_sockets; sock++)
597 if(sa->sa.sa_family == listen_socket[sock].sa.sa.sa_family)
600 if(sock >= listen_sockets)
603 if(!n->status.udp_confirmed)
606 #if defined(SOL_IP) && defined(IP_TOS)
607 if(priorityinheritance && origpriority != priority
608 && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
609 priority = origpriority;
610 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
611 if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
612 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", strerror(errno));
616 socklen_t sl = SALEN(n->address.sa);
618 if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, &sa->sa, sl) < 0 && !sockwouldblock(sockerrno)) {
619 if(sockmsgsize(sockerrno)) {
620 if(n->maxmtu >= origlen)
621 n->maxmtu = origlen - 1;
622 if(n->mtu >= origlen)
623 n->mtu = origlen - 1;
625 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
629 origpkt->len = origlen;
632 bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
635 /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
637 if(type >= SPTPS_HANDSHAKE || ((myself->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
638 char buf[len * 4 / 3 + 5];
639 b64encode(data, buf, len);
640 /* If no valid key is known yet, send the packets using ANS_KEY requests,
641 to ensure we get to learn the reflexive UDP address. */
642 if(!to->status.validkey)
643 return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, myself->incompression);
645 return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_SPTPS, buf);
648 /* Otherwise, send the packet via UDP */
654 sa = &(to->address.sa);
655 sl = SALEN(to->address.sa);
658 if(sendto(listen_socket[sock].udp, data, len, 0, sa, sl) < 0 && !sockwouldblock(sockerrno)) {
659 if(sockmsgsize(sockerrno)) {
660 if(to->maxmtu >= len)
661 to->maxmtu = len - 1;
665 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", to->name, to->hostname, sockstrerror(sockerrno));
673 bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t len) {
674 node_t *from = handle;
676 if(type == SPTPS_HANDSHAKE) {
677 from->status.validkey = true;
678 from->status.waitingforkey = false;
679 logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
684 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
690 if(type == PKT_PROBE) {
692 memcpy(inpkt.data, data, len);
693 mtu_probe_h(from, &inpkt, len);
697 if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
698 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
702 /* Check if we have the headers we need */
703 if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
704 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
706 } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
707 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
710 int offset = (type & PKT_MAC) ? 0 : 14;
711 if(type & PKT_COMPRESSED) {
712 len = uncompress_packet(inpkt.data + offset, (const uint8_t *)data, len, from->incompression);
716 inpkt.len = len + offset;
718 if(inpkt.len > MAXSIZE)
721 memcpy(inpkt.data + offset, data, len);
722 inpkt.len = len + offset;
725 /* Generate the Ethernet packet type if necessary */
727 switch(inpkt.data[14] >> 4) {
729 inpkt.data[12] = 0x08;
730 inpkt.data[13] = 0x00;
733 inpkt.data[12] = 0x86;
734 inpkt.data[13] = 0xDD;
737 logger(DEBUG_TRAFFIC, LOG_ERR,
738 "Unknown IP version %d while reading packet from %s (%s)",
739 inpkt.data[14] >> 4, from->name, from->hostname);
744 receive_packet(from, &inpkt);
749 send a packet to the given vpn ip.
751 void send_packet(node_t *n, vpn_packet_t *packet) {
756 memcpy(packet->data, mymac.x, ETH_ALEN);
758 n->out_bytes += packet->len;
759 devops.write(packet);
763 logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
764 packet->len, n->name, n->hostname);
766 if(!n->status.reachable) {
767 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
768 n->name, n->hostname);
773 n->out_bytes += packet->len;
775 if(n->status.sptps) {
776 send_sptps_packet(n, packet);
780 via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
783 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)",
784 n->name, via->name, n->via->hostname);
786 if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
787 if(!send_tcppacket(via->connection, packet))
788 terminate_connection(via->connection, true);
790 send_udppacket(via, packet);
793 /* Broadcast a packet using the minimum spanning tree */
795 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
796 // Always give ourself a copy of the packet.
798 send_packet(myself, packet);
800 // In TunnelServer mode, do not forward broadcast packets.
801 // The MST might not be valid and create loops.
802 if(tunnelserver || broadcast_mode == BMODE_NONE)
805 logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
806 packet->len, from->name, from->hostname);
808 switch(broadcast_mode) {
809 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
810 // This guarantees all nodes receive the broadcast packet, and
811 // usually distributes the sending of broadcast packets over all nodes.
813 for list_each(connection_t, c, connection_list)
814 if(c->status.active && c->status.mst && c != from->nexthop->connection)
815 send_packet(c->node, packet);
818 // In direct mode, we send copies to each node we know of.
819 // However, this only reaches nodes that can be reached in a single hop.
820 // We don't have enough information to forward broadcast packets in this case.
825 for splay_each(node_t, n, node_tree)
826 if(n->status.reachable && ((n->via == myself && n->nexthop == n) || n->via == n))
827 send_packet(n, packet);
835 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
838 static time_t last_hard_try = 0;
839 time_t now = time(NULL);
841 for splay_each(edge_t, e, edge_weight_tree) {
842 if(!e->to->status.reachable || e->to == myself)
845 if(sockaddrcmp_noport(from, &e->address)) {
846 if(last_hard_try == now)
851 if(!try_mac(e->to, pkt))
865 void handle_incoming_vpn_data(int sock, short events, void *data) {
868 sockaddr_t from = {{0}};
869 socklen_t fromlen = sizeof from;
873 len = recvfrom(sock, (char *) &pkt.seqno, MAXSIZE, 0, &from.sa, &fromlen);
875 if(len <= 0 || len > MAXSIZE) {
876 if(!sockwouldblock(sockerrno))
877 logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
883 sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
885 n = lookup_node_udp(&from);
888 n = try_harder(&from, &pkt);
890 update_node_udp(n, &from);
891 else if(debug_level >= DEBUG_PROTOCOL) {
892 hostname = sockaddr2hostname(&from);
893 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
901 n->sock = (intptr_t)data;
903 receive_udppacket(n, &pkt);
906 void handle_device_data(int sock, short events, void *data) {
911 if(devops.read(&packet)) {
912 myself->in_packets++;
913 myself->in_bytes += packet.len;
914 route(myself, &packet);