2 net_packet.c -- Handles in- and outgoing VPN packets
3 Copyright (C) 1998-2005 Ivo Timmermans,
4 2000-2014 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.
35 #include "connection.h"
52 #define MAX(a, b) ((a) > (b) ? (a) : (b))
55 /* The minimum size of a probe is 14 bytes, but since we normally use CBC mode
56 encryption, we can add a few extra random bytes without increasing the
57 resulting packet size. */
58 #define MIN_PROBE_SIZE 18
62 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
65 static void send_udppacket(node_t *, vpn_packet_t *);
67 unsigned replaywin = 16;
68 bool localdiscovery = true;
69 bool udp_discovery = true;
70 int udp_discovery_keepalive_interval = 10;
71 int udp_discovery_interval = 2;
72 int udp_discovery_timeout = 30;
74 #define MAX_SEQNO 1073741824
76 static void try_fix_mtu(node_t *n) {
80 if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) {
81 if(n->minmtu > n->maxmtu)
82 n->minmtu = n->maxmtu;
84 n->maxmtu = n->minmtu;
86 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
91 static void udp_probe_timeout_handler(void *data) {
93 if(!n->status.udp_confirmed)
96 logger(DEBUG_TRAFFIC, LOG_INFO, "Too much time has elapsed since last UDP ping response from %s (%s), stopping UDP communication", n->name, n->hostname);
97 n->status.udp_confirmed = false;
104 static void send_udp_probe_reply(node_t *n, vpn_packet_t *packet, length_t len) {
105 if(!n->status.sptps && !n->status.validkey) {
106 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP probe reply to %s (%s) but we don't have his key yet", n->name, n->hostname);
110 /* Type 2 probe replies were introduced in protocol 17.3 */
111 if ((n->options >> 24) >= 3) {
113 uint16_t len16 = htons(len);
114 memcpy(DATA(packet) + 1, &len16, 2);
115 packet->len = MIN_PROBE_SIZE;
116 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 2 probe reply length %u to %s (%s)", len, n->name, n->hostname);
119 /* Legacy protocol: n won't understand type 2 probe replies. */
121 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 1 probe reply length %u to %s (%s)", len, n->name, n->hostname);
124 /* Temporarily set udp_confirmed, so that the reply is sent
125 back exactly the way it came in. */
127 bool udp_confirmed = n->status.udp_confirmed;
128 n->status.udp_confirmed = true;
129 send_udppacket(n, packet);
130 n->status.udp_confirmed = udp_confirmed;
133 static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
134 if(!DATA(packet)[0]) {
135 logger(DEBUG_TRAFFIC, LOG_INFO, "Got UDP probe request %d from %s (%s)", packet->len, n->name, n->hostname);
136 return send_udp_probe_reply(n, packet, len);
139 if (DATA(packet)[0] == 2) {
140 // It's a type 2 probe reply, use the length field inside the packet
142 memcpy(&len16, DATA(packet) + 1, 2);
146 logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s)", DATA(packet)[0], len, n->name, n->hostname);
148 /* It's a valid reply: now we know bidirectional communication
149 is possible using the address and socket that the reply
151 n->status.udp_confirmed = true;
153 // Reset the UDP ping timer.
154 n->udp_ping_sent = now;
157 timeout_del(&n->udp_ping_timeout);
158 timeout_add(&n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timeval){udp_discovery_timeout, 0});
161 if(len > n->maxmtu) {
162 logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
165 /* Set mtuprobes to 1 so that try_mtu() doesn't reset maxmtu */
168 } else if(n->mtuprobes < 0 && len == n->maxmtu) {
169 /* We got a maxmtu sized packet, confirming the PMTU is still valid. */
171 n->mtu_ping_sent = now;
174 /* If applicable, raise the minimum supported MTU */
176 if(n->minmtu < len) {
182 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
184 memcpy(dest, source, len);
186 } else if(level == 10) {
188 lzo_uint lzolen = MAXSIZE;
189 lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
194 } else if(level < 10) {
196 unsigned long destlen = MAXSIZE;
197 if(compress2(dest, &destlen, source, len, level) == Z_OK)
204 lzo_uint lzolen = MAXSIZE;
205 lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
215 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
217 memcpy(dest, source, len);
219 } else if(level > 9) {
221 lzo_uint lzolen = MAXSIZE;
222 if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
230 unsigned long destlen = MAXSIZE;
231 if(uncompress(dest, &destlen, source, len) == Z_OK)
243 static void receive_packet(node_t *n, vpn_packet_t *packet) {
244 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
245 packet->len, n->name, n->hostname);
248 n->in_bytes += packet->len;
253 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
255 return sptps_verify_datagram(&n->sptps, DATA(inpkt), inpkt->len);
257 #ifdef DISABLE_LEGACY
260 if(!n->status.validkey_in || !digest_active(n->indigest) || inpkt->len < sizeof(seqno_t) + digest_length(n->indigest))
263 return digest_verify(n->indigest, SEQNO(inpkt), inpkt->len - digest_length(n->indigest), DATA(inpkt) + inpkt->len - digest_length(n->indigest));
267 static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
268 vpn_packet_t pkt1, pkt2;
269 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
272 pkt1.offset = DEFAULT_PACKET_OFFSET;
273 pkt2.offset = DEFAULT_PACKET_OFFSET;
275 if(n->status.sptps) {
276 if(!n->sptps.state) {
277 if(!n->status.waitingforkey) {
278 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
281 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
285 inpkt->offset += 2 * sizeof(node_id_t);
286 n->status.udppacket = true;
287 bool result = sptps_receive_data(&n->sptps, DATA(inpkt), inpkt->len - 2 * sizeof(node_id_t));
288 n->status.udppacket = false;
291 logger(DEBUG_TRAFFIC, LOG_ERR, "Got bad packet from %s (%s)", n->name, n->hostname);
297 #ifdef DISABLE_LEGACY
300 if(!n->status.validkey_in) {
301 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
305 /* Check packet length */
307 if(inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
308 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
309 n->name, n->hostname);
313 /* It's a legacy UDP packet, the data starts after the seqno */
315 inpkt->offset += sizeof(seqno_t);
317 /* Check the message authentication code */
319 if(digest_active(n->indigest)) {
320 inpkt->len -= digest_length(n->indigest);
321 if(!digest_verify(n->indigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
322 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
326 /* Decrypt the packet */
328 if(cipher_active(n->incipher)) {
329 vpn_packet_t *outpkt = pkt[nextpkt++];
332 if(!cipher_decrypt(n->incipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
333 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
337 outpkt->len = outlen;
341 /* Check the sequence number */
344 memcpy(&seqno, SEQNO(inpkt), sizeof seqno);
345 seqno = ntohl(seqno);
346 inpkt->len -= sizeof seqno;
349 if(seqno != n->received_seqno + 1) {
350 if(seqno >= n->received_seqno + replaywin * 8) {
351 if(n->farfuture++ < replaywin >> 2) {
352 logger(DEBUG_ALWAYS, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
353 n->name, n->hostname, seqno - n->received_seqno - 1, n->farfuture);
356 logger(DEBUG_ALWAYS, LOG_WARNING, "Lost %d packets from %s (%s)",
357 seqno - n->received_seqno - 1, n->name, n->hostname);
358 memset(n->late, 0, replaywin);
359 } else if (seqno <= n->received_seqno) {
360 if((n->received_seqno >= replaywin * 8 && seqno <= n->received_seqno - replaywin * 8) || !(n->late[(seqno / 8) % replaywin] & (1 << seqno % 8))) {
361 logger(DEBUG_ALWAYS, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
362 n->name, n->hostname, seqno, n->received_seqno);
366 for(int i = n->received_seqno + 1; i < seqno; i++)
367 n->late[(i / 8) % replaywin] |= 1 << i % 8;
372 n->late[(seqno / 8) % replaywin] &= ~(1 << seqno % 8);
375 if(seqno > n->received_seqno)
376 n->received_seqno = seqno;
380 if(n->received_seqno > MAX_SEQNO)
383 /* Decompress the packet */
385 length_t origlen = inpkt->len;
387 if(n->incompression) {
388 vpn_packet_t *outpkt = pkt[nextpkt++];
390 if((outpkt->len = uncompress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->incompression)) < 0) {
391 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
392 n->name, n->hostname);
398 origlen -= MTU/64 + 20;
401 if(inpkt->len > n->maxrecentlen)
402 n->maxrecentlen = inpkt->len;
406 if(!DATA(inpkt)[12] && !DATA(inpkt)[13])
407 udp_probe_h(n, inpkt, origlen);
409 receive_packet(n, inpkt);
414 void receive_tcppacket(connection_t *c, const char *buffer, int len) {
416 outpkt.offset = DEFAULT_PACKET_OFFSET;
418 if(len > sizeof outpkt.data - outpkt.offset)
422 if(c->options & OPTION_TCPONLY)
425 outpkt.priority = -1;
426 memcpy(DATA(&outpkt), buffer, len);
428 receive_packet(c->node, &outpkt);
431 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
432 if(!n->status.validkey && !n->connection)
438 if(!(DATA(origpkt)[12] | DATA(origpkt)[13])) {
439 sptps_send_record(&n->sptps, PKT_PROBE, (char *)DATA(origpkt), origpkt->len);
443 if(routing_mode == RMODE_ROUTER)
448 if(origpkt->len < offset)
453 if(n->outcompression) {
455 int len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
457 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
458 } else if(len < origpkt->len - offset) {
459 outpkt.len = len + offset;
461 type |= PKT_COMPRESSED;
465 /* If we have a direct metaconnection to n, and we can't use UDP, then
466 don't bother with SPTPS and just use a "plaintext" PACKET message.
467 We don't really care about end-to-end security since we're not
468 sending the message through any intermediate nodes. */
469 if(n->connection && origpkt->len > n->minmtu)
470 send_tcppacket(n->connection, origpkt);
472 sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
476 static void adapt_socket(const sockaddr_t *sa, int *sock) {
477 /* Make sure we have a suitable socket for the chosen address */
478 if(listen_socket[*sock].sa.sa.sa_family != sa->sa.sa_family) {
479 for(int i = 0; i < listen_sockets; i++) {
480 if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
488 static void choose_udp_address(const node_t *n, const sockaddr_t **sa, int *sock) {
493 /* If the UDP address is confirmed, use it. */
494 if(n->status.udp_confirmed)
497 /* Send every third packet to n->address; that could be set
498 to the node's reflexive UDP address discovered during key
507 /* Otherwise, address are found in edges to this node.
508 So we pick a random edge and a random socket. */
511 int j = rand() % n->edge_tree->count;
512 edge_t *candidate = NULL;
514 for splay_each(edge_t, e, n->edge_tree) {
516 candidate = e->reverse;
522 *sa = &candidate->address;
523 *sock = rand() % listen_sockets;
526 adapt_socket(*sa, sock);
529 static void choose_local_address(const node_t *n, const sockaddr_t **sa, int *sock) {
532 /* Pick one of the edges from this node at random, then use its local address. */
535 int j = rand() % n->edge_tree->count;
536 edge_t *candidate = NULL;
538 for splay_each(edge_t, e, n->edge_tree) {
545 if (candidate && candidate->local_address.sa.sa_family) {
546 *sa = &candidate->local_address;
547 *sock = rand() % listen_sockets;
548 adapt_socket(*sa, sock);
552 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
553 vpn_packet_t pkt1, pkt2;
554 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
555 vpn_packet_t *inpkt = origpkt;
557 vpn_packet_t *outpkt;
558 int origlen = origpkt->len;
560 #if defined(SOL_IP) && defined(IP_TOS)
561 static int priority = 0;
562 int origpriority = origpkt->priority;
565 pkt1.offset = DEFAULT_PACKET_OFFSET;
566 pkt2.offset = DEFAULT_PACKET_OFFSET;
568 if(!n->status.reachable) {
569 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
574 return send_sptps_packet(n, origpkt);
576 #ifdef DISABLE_LEGACY
579 /* Make sure we have a valid key */
581 if(!n->status.validkey) {
582 logger(DEBUG_TRAFFIC, LOG_INFO,
583 "No valid key known yet for %s (%s), forwarding via TCP",
584 n->name, n->hostname);
585 send_tcppacket(n->nexthop->connection, origpkt);
589 if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
590 logger(DEBUG_TRAFFIC, LOG_INFO,
591 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
592 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
595 send_packet(n->nexthop, origpkt);
597 send_tcppacket(n->nexthop->connection, origpkt);
602 /* Compress the packet */
604 if(n->outcompression) {
605 outpkt = pkt[nextpkt++];
607 if((outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression)) < 0) {
608 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
609 n->name, n->hostname);
616 /* Add sequence number */
618 seqno_t seqno = htonl(++(n->sent_seqno));
619 memcpy(SEQNO(inpkt), &seqno, sizeof seqno);
620 inpkt->len += sizeof seqno;
622 /* Encrypt the packet */
624 if(cipher_active(n->outcipher)) {
625 outpkt = pkt[nextpkt++];
628 if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
629 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
633 outpkt->len = outlen;
637 /* Add the message authentication code */
639 if(digest_active(n->outdigest)) {
640 if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
641 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
645 inpkt->len += digest_length(n->outdigest);
648 /* Send the packet */
650 const sockaddr_t *sa = NULL;
653 if(n->status.send_locally)
654 choose_local_address(n, &sa, &sock);
656 choose_udp_address(n, &sa, &sock);
658 #if defined(SOL_IP) && defined(IP_TOS)
659 if(priorityinheritance && origpriority != priority
660 && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
661 priority = origpriority;
662 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
663 if(setsockopt(listen_socket[n->sock].udp.fd, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
664 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
668 if(sendto(listen_socket[sock].udp.fd, SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
669 if(sockmsgsize(sockerrno)) {
670 if(n->maxmtu >= origlen)
671 n->maxmtu = origlen - 1;
672 if(n->mtu >= origlen)
673 n->mtu = origlen - 1;
676 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
680 origpkt->len = origlen;
684 static bool send_sptps_data_priv(node_t *to, node_t *from, int type, const void *data, size_t len) {
685 node_t *relay = (to->via != myself && (type == PKT_PROBE || (len - SPTPS_DATAGRAM_OVERHEAD) <= to->via->minmtu)) ? to->via : to->nexthop;
686 bool direct = from == myself && to == relay;
687 bool relay_supported = (relay->options >> 24) >= 4;
688 bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
690 /* Send it via TCP if it is a handshake packet, TCPOnly is in use, this is a relay packet that the other node cannot understand, or this packet is larger than the MTU.
691 TODO: When relaying, the original sender does not know the end-to-end PMTU (it only knows the PMTU of the first hop).
692 This can lead to scenarios where large packets are sent over UDP to relay, but then relay has no choice but fall back to TCP. */
694 if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) {
695 char buf[len * 4 / 3 + 5];
696 b64encode(data, buf, len);
697 /* If no valid key is known yet, send the packets using ANS_KEY requests,
698 to ensure we get to learn the reflexive UDP address. */
699 if(from == myself && !to->status.validkey) {
700 to->incompression = myself->incompression;
701 return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
703 return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, REQ_SPTPS, buf);
708 if(relay_supported) overhead += sizeof to->id + sizeof from->id;
709 char buf[len + overhead]; char* buf_ptr = buf;
710 if(relay_supported) {
712 /* Inform the recipient that this packet was sent directly. */
713 node_id_t nullid = {};
714 memcpy(buf_ptr, &nullid, sizeof nullid); buf_ptr += sizeof nullid;
716 memcpy(buf_ptr, &to->id, sizeof to->id); buf_ptr += sizeof to->id;
718 memcpy(buf_ptr, &from->id, sizeof from->id); buf_ptr += sizeof from->id;
721 /* TODO: if this copy turns out to be a performance concern, change sptps_send_record() to add some "pre-padding" to the buffer and use that instead */
722 memcpy(buf_ptr, data, len); buf_ptr += len;
724 const sockaddr_t *sa = NULL;
726 if(relay->status.send_locally)
727 choose_local_address(relay, &sa, &sock);
729 choose_udp_address(relay, &sa, &sock);
730 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet from %s (%s) to %s (%s) via %s (%s)", from->name, from->hostname, to->name, to->hostname, relay->name, relay->hostname);
731 if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
732 if(sockmsgsize(sockerrno)) {
733 // Compensate for SPTPS overhead
734 len -= SPTPS_DATAGRAM_OVERHEAD;
735 if(relay->maxmtu >= len)
736 relay->maxmtu = len - 1;
737 if(relay->mtu >= len)
738 relay->mtu = len - 1;
741 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
749 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
750 return send_sptps_data_priv(handle, myself, type, data, len);
753 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
754 node_t *from = handle;
756 if(type == SPTPS_HANDSHAKE) {
757 if(!from->status.validkey) {
758 from->status.validkey = true;
759 from->status.waitingforkey = false;
760 logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
766 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
771 inpkt.offset = DEFAULT_PACKET_OFFSET;
773 if(type == PKT_PROBE) {
774 if(!from->status.udppacket) {
775 logger(DEBUG_ALWAYS, LOG_ERR, "Got SPTPS PROBE packet from %s (%s) via TCP", from->name, from->hostname);
779 memcpy(DATA(&inpkt), data, len);
780 if(inpkt.len > from->maxrecentlen)
781 from->maxrecentlen = inpkt.len;
782 udp_probe_h(from, &inpkt, len);
786 if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
787 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
791 /* Check if we have the headers we need */
792 if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
793 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
795 } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
796 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
799 int offset = (type & PKT_MAC) ? 0 : 14;
800 if(type & PKT_COMPRESSED) {
801 length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
805 inpkt.len = ulen + offset;
807 if(inpkt.len > MAXSIZE)
810 memcpy(DATA(&inpkt) + offset, data, len);
811 inpkt.len = len + offset;
814 /* Generate the Ethernet packet type if necessary */
816 switch(DATA(&inpkt)[14] >> 4) {
818 DATA(&inpkt)[12] = 0x08;
819 DATA(&inpkt)[13] = 0x00;
822 DATA(&inpkt)[12] = 0x86;
823 DATA(&inpkt)[13] = 0xDD;
826 logger(DEBUG_TRAFFIC, LOG_ERR,
827 "Unknown IP version %d while reading packet from %s (%s)",
828 DATA(&inpkt)[14] >> 4, from->name, from->hostname);
833 if(from->status.udppacket && inpkt.len > from->maxrecentlen)
834 from->maxrecentlen = inpkt.len;
836 receive_packet(from, &inpkt);
840 // This function tries to get SPTPS keys, if they aren't already known.
841 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if the keys are available.
842 static void try_sptps(node_t *n) {
843 if(n->status.validkey)
846 logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
848 if(!n->status.waitingforkey)
850 else if(n->last_req_key + 10 < now.tv_sec) {
851 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
852 sptps_stop(&n->sptps);
853 n->status.waitingforkey = false;
860 static void send_udp_probe_packet(node_t *n, int len) {
862 packet.offset = DEFAULT_PACKET_OFFSET;
863 memset(DATA(&packet), 0, 14);
864 randomize(DATA(&packet) + 14, len - 14);
868 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %d to %s (%s)", len, n->name, n->hostname);
870 send_udppacket(n, &packet);
873 // This function tries to establish a UDP tunnel to a node so that packets can be sent.
874 // If a tunnel is already established, it makes sure it stays up.
875 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if UDP is usable.
876 static void try_udp(node_t* n) {
880 /* Send gratuitous probe replies to 1.1 nodes. */
882 if((n->options >> 24) >= 3 && n->status.udp_confirmed) {
883 struct timeval ping_tx_elapsed;
884 timersub(&now, &n->udp_reply_sent, &ping_tx_elapsed);
886 if(ping_tx_elapsed.tv_sec >= udp_discovery_keepalive_interval - 1) {
887 n->udp_reply_sent = now;
888 if(n->maxrecentlen) {
890 pkt.len = n->maxrecentlen;
891 pkt.offset = DEFAULT_PACKET_OFFSET;
892 memset(DATA(&pkt), 0, 14);
893 randomize(DATA(&pkt) + 14, MIN_PROBE_SIZE - 14);
894 send_udp_probe_reply(n, &pkt, pkt.len);
902 struct timeval ping_tx_elapsed;
903 timersub(&now, &n->udp_ping_sent, &ping_tx_elapsed);
905 int interval = n->status.udp_confirmed ? udp_discovery_keepalive_interval : udp_discovery_interval;
907 if(ping_tx_elapsed.tv_sec >= interval) {
908 send_udp_probe_packet(n, MIN_PROBE_SIZE);
909 n->udp_ping_sent = now;
911 if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
912 n->status.send_locally = true;
913 send_udp_probe_packet(n, MIN_PROBE_SIZE);
914 n->status.send_locally = false;
919 static length_t choose_initial_maxmtu(node_t *n) {
924 const sockaddr_t *sa = NULL;
926 choose_udp_address(n, &sa, &sockindex);
930 sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
932 logger(DEBUG_TRAFFIC, LOG_ERR, "Creating MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
936 if(connect(sock, &sa->sa, SALEN(sa->sa))) {
937 logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
943 socklen_t ip_mtu_len = sizeof ip_mtu;
944 if(getsockopt(sock, IPPROTO_IP, IP_MTU, &ip_mtu, &ip_mtu_len)) {
945 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
952 /* getsockopt(IP_MTU) returns the MTU of the physical interface.
953 We need to remove various overheads to get to the tinc MTU. */
954 length_t mtu = ip_mtu;
955 mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
957 if(n->status.sptps) {
958 mtu -= SPTPS_DATAGRAM_OVERHEAD;
959 if((n->options >> 24) >= 4)
960 mtu -= sizeof(node_id_t) + sizeof(node_id_t);
961 #ifndef DISABLE_LEGACY
963 mtu -= digest_length(n->outdigest);
965 /* Now it's tricky. We use CBC mode, so the length of the
966 encrypted payload must be a multiple of the blocksize. The
967 sequence number is also part of the encrypted payload, so we
968 must account for it after correcting for the blocksize.
969 Furthermore, the padding in the last block must be at least
972 length_t blocksize = cipher_blocksize(n->outcipher);
985 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
991 logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
1001 /* This function tries to determines the MTU of a node.
1002 By calling this function repeatedly, n->minmtu will be progressively
1003 increased, and at some point, n->mtu will be fixed to n->minmtu. If the MTU
1004 is already fixed, this function checks if it can be increased.
1007 static void try_mtu(node_t *n) {
1008 if(!(n->options & OPTION_PMTU_DISCOVERY))
1011 if(udp_discovery && !n->status.udp_confirmed) {
1012 n->maxrecentlen = 0;
1019 /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1020 mtuprobes == 20: fix MTU, and go to -1
1021 mtuprobes == -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1022 mtuprobes ==-2..-3: send one maxmtu probe every second
1023 mtuprobes == -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1025 struct timeval elapsed;
1026 timersub(&now, &n->mtu_ping_sent, &elapsed);
1027 if(n->mtuprobes >= 0) {
1028 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333)
1031 if(n->mtuprobes < -1) {
1032 if(elapsed.tv_sec < 1)
1035 if(elapsed.tv_sec < pinginterval)
1040 n->mtu_ping_sent = now;
1044 if(n->mtuprobes < -3) {
1045 /* We lost three MTU probes, restart discovery */
1046 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1051 if(n->mtuprobes < 0) {
1052 /* After the initial discovery, we only send one maxmtu and one
1053 maxmtu+1 probe to detect PMTU increases. */
1054 send_udp_probe_packet(n, n->maxmtu);
1055 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU)
1056 send_udp_probe_packet(n, n->maxmtu + 1);
1059 /* Before initial discovery begins, set maxmtu to the most likely value.
1060 If it's underestimated, we will correct it after initial discovery. */
1061 if(n->mtuprobes == 0)
1062 n->maxmtu = choose_initial_maxmtu(n);
1065 /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1066 but it will typically increase convergence time in the no-loss case. */
1067 const length_t probes_per_cycle = 8;
1069 /* This magic value was determined using math simulations.
1070 It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1071 Since 1407 is just below the range of tinc MTUs over typical networks,
1072 this fine-tuning allows tinc to cover a lot of ground very quickly.
1073 This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1074 then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1075 if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1076 const float multiplier = (n->maxmtu == MTU) ? 0.97 : 1;
1078 const float cycle_position = probes_per_cycle - (n->mtuprobes % probes_per_cycle) - 1;
1079 const length_t minmtu = MAX(n->minmtu, 512);
1080 const float interval = n->maxmtu - minmtu;
1082 /* The core of the discovery algorithm is this exponential.
1083 It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1084 This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1085 are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1086 on the precise MTU as we are approaching it.
1087 The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1088 reply per cycle so that we can make progress. */
1089 const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
1091 length_t maxmtu = n->maxmtu;
1092 send_udp_probe_packet(n, minmtu + offset);
1093 /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1094 In that case, we recalculate with the new maxmtu and try again. */
1095 if(n->mtuprobes < 0 || maxmtu == n->maxmtu)
1099 if(n->mtuprobes >= 0)
1104 /* These functions try to establish a tunnel to a node (or its relay) so that
1105 packets can be sent (e.g. exchange keys).
1106 If a tunnel is already established, it tries to improve it (e.g. by trying
1107 to establish a UDP tunnel instead of TCP). This function makes no
1108 guarantees - it is up to the caller to check the node's state to figure out
1109 if TCP and/or UDP is usable. By calling this function repeatedly, the
1110 tunnel is gradually improved until we hit the wall imposed by the underlying
1111 network environment. It is recommended to call this function every time a
1112 packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1113 improving as packets flow, and then gracefully downgrades itself as it goes
1117 static void try_tx_sptps(node_t *n, bool mtu) {
1118 /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1119 messages anyway, so there's no need for SPTPS at all. */
1121 if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY))
1124 /* Otherwise, try to do SPTPS authentication with n if necessary. */
1128 /* Do we need to statically relay packets? */
1130 node_t *via = (n->via == myself) ? n->nexthop : n->via;
1132 /* If the static relay doesn't support SPTPS, everything goes via TCP anyway. */
1134 if((via->options >> 24) < 4)
1137 /* If we do have a static relay, try everything with that one instead. */
1140 try_tx_sptps(via, mtu);
1142 /* Otherwise, try to establish UDP connectivity. */
1148 /* If we don't have UDP connectivity (yet), we need to use a dynamic relay (nexthop)
1149 while we try to establish direct connectivity. */
1151 if(!n->status.udp_confirmed && n != n->nexthop && (n->nexthop->options >> 24) >= 4)
1152 try_tx_sptps(n->nexthop, mtu);
1155 static void try_tx_legacy(node_t *n, bool mtu) {
1156 /* Does he have our key? If not, send one. */
1158 if(!n->status.validkey_in)
1161 /* Check if we already have a key, or request one. */
1163 if(!n->status.validkey) {
1164 if(n->last_req_key + 10 <= now.tv_sec) {
1166 n->last_req_key = now.tv_sec;
1176 void try_tx(node_t *n, bool mtu) {
1178 try_tx_sptps(n, mtu);
1180 try_tx_legacy(n, mtu);
1183 void send_packet(node_t *n, vpn_packet_t *packet) {
1184 // If it's for myself, write it to the tun/tap device.
1188 memcpy(DATA(packet), mymac.x, ETH_ALEN);
1190 n->out_bytes += packet->len;
1191 devops.write(packet);
1195 logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1197 // If the node is not reachable, drop it.
1199 if(!n->status.reachable) {
1200 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1204 // Keep track of packet statistics.
1207 n->out_bytes += packet->len;
1209 // Check if it should be sent as an SPTPS packet.
1211 if(n->status.sptps) {
1212 send_sptps_packet(n, packet);
1213 try_tx_sptps(n, true);
1217 // Determine which node to actually send it to.
1219 node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1222 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1224 // Try to send via UDP, unless TCP is forced.
1226 if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1227 if(!send_tcppacket(via->connection, packet))
1228 terminate_connection(via->connection, true);
1232 send_udppacket(via, packet);
1233 try_tx_legacy(via, true);
1236 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1237 // Always give ourself a copy of the packet.
1239 send_packet(myself, packet);
1241 // In TunnelServer mode, do not forward broadcast packets.
1242 // The MST might not be valid and create loops.
1243 if(tunnelserver || broadcast_mode == BMODE_NONE)
1246 logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1247 packet->len, from->name, from->hostname);
1249 switch(broadcast_mode) {
1250 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1251 // This guarantees all nodes receive the broadcast packet, and
1252 // usually distributes the sending of broadcast packets over all nodes.
1254 for list_each(connection_t, c, connection_list)
1255 if(c->edge && c->status.mst && c != from->nexthop->connection)
1256 send_packet(c->node, packet);
1259 // In direct mode, we send copies to each node we know of.
1260 // However, this only reaches nodes that can be reached in a single hop.
1261 // We don't have enough information to forward broadcast packets in this case.
1266 for splay_each(node_t, n, node_tree)
1267 if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
1268 send_packet(n, packet);
1276 /* We got a packet from some IP address, but we don't know who sent it. Try to
1277 verify the message authentication code against all active session keys.
1278 Since this is actually an expensive operation, we only do a full check once
1279 a minute, the rest of the time we only check against nodes for which we know
1280 an IP address that matches the one from the packet. */
1282 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1283 node_t *match = NULL;
1285 static time_t last_hard_try = 0;
1287 for splay_each(node_t, n, node_tree) {
1288 if(!n->status.reachable || n == myself)
1291 if((n->status.sptps && !n->sptps.instate) || !n->status.validkey_in)
1296 for splay_each(edge_t, e, n->edge_tree) {
1299 if(!sockaddrcmp_noport(from, &e->reverse->address)) {
1306 if(last_hard_try == now.tv_sec)
1311 if(!try_mac(n, pkt))
1319 last_hard_try = now.tv_sec;
1324 void handle_incoming_vpn_data(void *data, int flags) {
1325 listen_socket_t *ls = data;
1328 node_id_t nullid = {};
1329 sockaddr_t addr = {};
1330 socklen_t addrlen = sizeof addr;
1332 bool direct = false;
1335 int len = recvfrom(ls->udp.fd, DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1337 if(len <= 0 || len > MAXSIZE) {
1338 if(!sockwouldblock(sockerrno))
1339 logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1345 sockaddrunmap(&addr); /* Some braindead IPv6 implementations do stupid things. */
1347 // Try to figure out who sent this packet.
1349 node_t *n = lookup_node_udp(&addr);
1351 if(n && !n->status.udp_confirmed)
1352 n = NULL; // Don't believe it if we don't have confirmation yet.
1355 // It might be from a 1.1 node, which might have a source ID in the packet.
1356 pkt.offset = 2 * sizeof(node_id_t);
1357 from = lookup_node_id(SRCID(&pkt));
1358 if(from && !memcmp(DSTID(&pkt), &nullid, sizeof nullid) && from->status.sptps) {
1359 if(sptps_verify_datagram(&from->sptps, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t)))
1368 n = try_harder(&addr, &pkt);
1373 if(debug_level >= DEBUG_PROTOCOL) {
1374 hostname = sockaddr2hostname(&addr);
1375 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1381 if(n->status.sptps) {
1382 pkt.offset = 2 * sizeof(node_id_t);
1384 if(!memcmp(DSTID(&pkt), &nullid, sizeof nullid)) {
1389 from = lookup_node_id(SRCID(&pkt));
1390 to = lookup_node_id(DSTID(&pkt));
1393 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1398 send_sptps_data_priv(to, n, 0, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t));
1399 try_tx_sptps(n, true);
1408 if(!receive_udppacket(from, &pkt))
1411 n->sock = ls - listen_socket;
1412 if(direct && sockaddrcmp(&addr, &n->address))
1413 update_node_udp(n, &addr);
1416 void handle_device_data(void *data, int flags) {
1417 vpn_packet_t packet;
1418 packet.offset = DEFAULT_PACKET_OFFSET;
1419 packet.priority = 0;
1421 if(devops.read(&packet)) {
1422 myself->in_packets++;
1423 myself->in_bytes += packet.len;
1424 route(myself, &packet);