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 = 32;
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, inpkt->data, inpkt->len - digest_length(n->indigest), inpkt->data + 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 bool receive_tcppacket_sptps(connection_t *c, const char *data, int len) {
432 if (len < sizeof(node_id_t) + sizeof(node_id_t)) {
433 logger(DEBUG_ALWAYS, LOG_ERR, "Got too short TCP SPTPS packet from %s (%s)", c->name, c->hostname);
437 node_t *to = lookup_node_id((node_id_t *)data);
438 data += sizeof(node_id_t); len -= sizeof(node_id_t);
440 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown destination ID", c->name, c->hostname);
444 node_t *from = lookup_node_id((node_id_t *)data);
445 data += sizeof(node_id_t); len -= sizeof(node_id_t);
447 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown source ID", c->name, c->hostname);
451 /* Help the sender reach us over UDP.
452 Note that we only do this if we're the destination or the static relay;
453 otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
454 if(to->via == myself)
455 send_udp_info(myself, from);
457 /* If we're not the final recipient, relay the packet. */
460 send_sptps_data(to, from, 0, data, len);
465 /* The packet is for us */
467 if(!from->status.validkey) {
468 logger(DEBUG_PROTOCOL, LOG_ERR, "Got SPTPS packet from %s (%s) but we don't have a valid key yet", from->name, from->hostname);
471 sptps_receive_data(&from->sptps, data, len);
472 send_mtu_info(myself, from, MTU);
476 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
477 if(!n->status.validkey && !n->connection)
483 if(!(DATA(origpkt)[12] | DATA(origpkt)[13])) {
484 sptps_send_record(&n->sptps, PKT_PROBE, (char *)DATA(origpkt), origpkt->len);
488 if(routing_mode == RMODE_ROUTER)
493 if(origpkt->len < offset)
498 if(n->outcompression) {
500 int len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
502 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
503 } else if(len < origpkt->len - offset) {
504 outpkt.len = len + offset;
506 type |= PKT_COMPRESSED;
510 /* If we have a direct metaconnection to n, and we can't use UDP, then
511 don't bother with SPTPS and just use a "plaintext" PACKET message.
512 We don't really care about end-to-end security since we're not
513 sending the message through any intermediate nodes. */
514 if(n->connection && origpkt->len > n->minmtu)
515 send_tcppacket(n->connection, origpkt);
517 sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
521 static void adapt_socket(const sockaddr_t *sa, int *sock) {
522 /* Make sure we have a suitable socket for the chosen address */
523 if(listen_socket[*sock].sa.sa.sa_family != sa->sa.sa_family) {
524 for(int i = 0; i < listen_sockets; i++) {
525 if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
533 static void choose_udp_address(const node_t *n, const sockaddr_t **sa, int *sock) {
538 /* If the UDP address is confirmed, use it. */
539 if(n->status.udp_confirmed)
542 /* Send every third packet to n->address; that could be set
543 to the node's reflexive UDP address discovered during key
552 /* Otherwise, address are found in edges to this node.
553 So we pick a random edge and a random socket. */
556 int j = rand() % n->edge_tree->count;
557 edge_t *candidate = NULL;
559 for splay_each(edge_t, e, n->edge_tree) {
561 candidate = e->reverse;
567 *sa = &candidate->address;
568 *sock = rand() % listen_sockets;
571 adapt_socket(*sa, sock);
574 static void choose_local_address(const node_t *n, const sockaddr_t **sa, int *sock) {
577 /* Pick one of the edges from this node at random, then use its local address. */
580 int j = rand() % n->edge_tree->count;
581 edge_t *candidate = NULL;
583 for splay_each(edge_t, e, n->edge_tree) {
590 if (candidate && candidate->local_address.sa.sa_family) {
591 *sa = &candidate->local_address;
592 *sock = rand() % listen_sockets;
593 adapt_socket(*sa, sock);
597 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
598 vpn_packet_t pkt1, pkt2;
599 vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
600 vpn_packet_t *inpkt = origpkt;
602 vpn_packet_t *outpkt;
603 int origlen = origpkt->len;
605 #if defined(SOL_IP) && defined(IP_TOS)
606 static int priority = 0;
607 int origpriority = origpkt->priority;
610 pkt1.offset = DEFAULT_PACKET_OFFSET;
611 pkt2.offset = DEFAULT_PACKET_OFFSET;
613 if(!n->status.reachable) {
614 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
619 return send_sptps_packet(n, origpkt);
621 #ifdef DISABLE_LEGACY
624 /* Make sure we have a valid key */
626 if(!n->status.validkey) {
627 logger(DEBUG_TRAFFIC, LOG_INFO,
628 "No valid key known yet for %s (%s), forwarding via TCP",
629 n->name, n->hostname);
630 send_tcppacket(n->nexthop->connection, origpkt);
634 if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
635 logger(DEBUG_TRAFFIC, LOG_INFO,
636 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
637 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
640 send_packet(n->nexthop, origpkt);
642 send_tcppacket(n->nexthop->connection, origpkt);
647 /* Compress the packet */
649 if(n->outcompression) {
650 outpkt = pkt[nextpkt++];
652 if((outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression)) < 0) {
653 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
654 n->name, n->hostname);
661 /* Add sequence number */
663 seqno_t seqno = htonl(++(n->sent_seqno));
664 memcpy(SEQNO(inpkt), &seqno, sizeof seqno);
665 inpkt->len += sizeof seqno;
667 /* Encrypt the packet */
669 if(cipher_active(n->outcipher)) {
670 outpkt = pkt[nextpkt++];
673 if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
674 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
678 outpkt->len = outlen;
682 /* Add the message authentication code */
684 if(digest_active(n->outdigest)) {
685 if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
686 logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
690 inpkt->len += digest_length(n->outdigest);
693 /* Send the packet */
695 const sockaddr_t *sa = NULL;
698 if(n->status.send_locally)
699 choose_local_address(n, &sa, &sock);
701 choose_udp_address(n, &sa, &sock);
703 #if defined(SOL_IP) && defined(IP_TOS)
704 if(priorityinheritance && origpriority != priority
705 && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
706 priority = origpriority;
707 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
708 if(setsockopt(listen_socket[n->sock].udp.fd, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
709 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
713 if(sendto(listen_socket[sock].udp.fd, SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
714 if(sockmsgsize(sockerrno)) {
715 if(n->maxmtu >= origlen)
716 n->maxmtu = origlen - 1;
717 if(n->mtu >= origlen)
718 n->mtu = origlen - 1;
721 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
725 origpkt->len = origlen;
729 bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_t len) {
730 node_t *relay = (to->via != myself && (type == PKT_PROBE || (len - SPTPS_DATAGRAM_OVERHEAD) <= to->via->minmtu)) ? to->via : to->nexthop;
731 bool direct = from == myself && to == relay;
732 bool relay_supported = (relay->options >> 24) >= 4;
733 bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
735 /* 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. */
737 if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) {
738 if(type != SPTPS_HANDSHAKE && (to->nexthop->connection->options >> 24) >= 7) {
739 char buf[len + sizeof to->id + sizeof from->id]; char* buf_ptr = buf;
740 memcpy(buf_ptr, &to->id, sizeof to->id); buf_ptr += sizeof to->id;
741 memcpy(buf_ptr, &from->id, sizeof from->id); buf_ptr += sizeof from->id;
742 memcpy(buf_ptr, data, len); buf_ptr += len;
743 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet from %s (%s) to %s (%s) via %s (%s) (TCP)", from->name, from->hostname, to->name, to->hostname, to->nexthop->name, to->nexthop->hostname);
744 return send_sptps_tcppacket(to->nexthop->connection, buf, sizeof buf);
747 char buf[len * 4 / 3 + 5];
748 b64encode(data, buf, len);
749 /* If this is a handshake packet, use ANS_KEY instead of REQ_KEY, for two reasons:
750 - We don't want intermediate nodes to switch to UDP to relay these packets;
751 - ANS_KEY allows us to learn the reflexive UDP address. */
752 if(type == SPTPS_HANDSHAKE) {
753 to->incompression = myself->incompression;
754 return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
756 return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, SPTPS_PACKET, buf);
761 if(relay_supported) overhead += sizeof to->id + sizeof from->id;
762 char buf[len + overhead]; char* buf_ptr = buf;
763 if(relay_supported) {
765 /* Inform the recipient that this packet was sent directly. */
766 node_id_t nullid = {};
767 memcpy(buf_ptr, &nullid, sizeof nullid); buf_ptr += sizeof nullid;
769 memcpy(buf_ptr, &to->id, sizeof to->id); buf_ptr += sizeof to->id;
771 memcpy(buf_ptr, &from->id, sizeof from->id); buf_ptr += sizeof from->id;
774 /* 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 */
775 memcpy(buf_ptr, data, len); buf_ptr += len;
777 const sockaddr_t *sa = NULL;
779 if(relay->status.send_locally)
780 choose_local_address(relay, &sa, &sock);
782 choose_udp_address(relay, &sa, &sock);
783 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet from %s (%s) to %s (%s) via %s (%s) (UDP)", from->name, from->hostname, to->name, to->hostname, relay->name, relay->hostname);
784 if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
785 if(sockmsgsize(sockerrno)) {
786 // Compensate for SPTPS overhead
787 len -= SPTPS_DATAGRAM_OVERHEAD;
788 if(relay->maxmtu >= len)
789 relay->maxmtu = len - 1;
790 if(relay->mtu >= len)
791 relay->mtu = len - 1;
794 logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
802 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
803 node_t *from = handle;
805 if(type == SPTPS_HANDSHAKE) {
806 if(!from->status.validkey) {
807 from->status.validkey = true;
808 from->status.waitingforkey = false;
809 logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
815 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
820 inpkt.offset = DEFAULT_PACKET_OFFSET;
822 if(type == PKT_PROBE) {
823 if(!from->status.udppacket) {
824 logger(DEBUG_ALWAYS, LOG_ERR, "Got SPTPS PROBE packet from %s (%s) via TCP", from->name, from->hostname);
828 memcpy(DATA(&inpkt), data, len);
829 if(inpkt.len > from->maxrecentlen)
830 from->maxrecentlen = inpkt.len;
831 udp_probe_h(from, &inpkt, len);
835 if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
836 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
840 /* Check if we have the headers we need */
841 if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
842 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
844 } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
845 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
848 int offset = (type & PKT_MAC) ? 0 : 14;
849 if(type & PKT_COMPRESSED) {
850 length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
854 inpkt.len = ulen + offset;
856 if(inpkt.len > MAXSIZE)
859 memcpy(DATA(&inpkt) + offset, data, len);
860 inpkt.len = len + offset;
863 /* Generate the Ethernet packet type if necessary */
865 switch(DATA(&inpkt)[14] >> 4) {
867 DATA(&inpkt)[12] = 0x08;
868 DATA(&inpkt)[13] = 0x00;
871 DATA(&inpkt)[12] = 0x86;
872 DATA(&inpkt)[13] = 0xDD;
875 logger(DEBUG_TRAFFIC, LOG_ERR,
876 "Unknown IP version %d while reading packet from %s (%s)",
877 DATA(&inpkt)[14] >> 4, from->name, from->hostname);
882 if(from->status.udppacket && inpkt.len > from->maxrecentlen)
883 from->maxrecentlen = inpkt.len;
885 receive_packet(from, &inpkt);
889 // This function tries to get SPTPS keys, if they aren't already known.
890 // 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.
891 static void try_sptps(node_t *n) {
892 if(n->status.validkey)
895 logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
897 if(!n->status.waitingforkey)
899 else if(n->last_req_key + 10 < now.tv_sec) {
900 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
901 sptps_stop(&n->sptps);
902 n->status.waitingforkey = false;
909 static void send_udp_probe_packet(node_t *n, int len) {
911 packet.offset = DEFAULT_PACKET_OFFSET;
912 memset(DATA(&packet), 0, 14);
913 randomize(DATA(&packet) + 14, len - 14);
917 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %d to %s (%s)", len, n->name, n->hostname);
919 send_udppacket(n, &packet);
922 // This function tries to establish a UDP tunnel to a node so that packets can be sent.
923 // If a tunnel is already established, it makes sure it stays up.
924 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if UDP is usable.
925 static void try_udp(node_t* n) {
929 /* Send gratuitous probe replies to 1.1 nodes. */
931 if((n->options >> 24) >= 3 && n->status.udp_confirmed) {
932 struct timeval ping_tx_elapsed;
933 timersub(&now, &n->udp_reply_sent, &ping_tx_elapsed);
935 if(ping_tx_elapsed.tv_sec >= udp_discovery_keepalive_interval - 1) {
936 n->udp_reply_sent = now;
937 if(n->maxrecentlen) {
939 pkt.len = n->maxrecentlen;
940 pkt.offset = DEFAULT_PACKET_OFFSET;
941 memset(DATA(&pkt), 0, 14);
942 randomize(DATA(&pkt) + 14, MIN_PROBE_SIZE - 14);
943 send_udp_probe_reply(n, &pkt, pkt.len);
951 struct timeval ping_tx_elapsed;
952 timersub(&now, &n->udp_ping_sent, &ping_tx_elapsed);
954 int interval = n->status.udp_confirmed ? udp_discovery_keepalive_interval : udp_discovery_interval;
956 if(ping_tx_elapsed.tv_sec >= interval) {
957 send_udp_probe_packet(n, MIN_PROBE_SIZE);
958 n->udp_ping_sent = now;
960 if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
961 n->status.send_locally = true;
962 send_udp_probe_packet(n, MIN_PROBE_SIZE);
963 n->status.send_locally = false;
968 static length_t choose_initial_maxmtu(node_t *n) {
973 const sockaddr_t *sa = NULL;
975 choose_udp_address(n, &sa, &sockindex);
979 sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
981 logger(DEBUG_TRAFFIC, LOG_ERR, "Creating MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
985 if(connect(sock, &sa->sa, SALEN(sa->sa))) {
986 logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
992 socklen_t ip_mtu_len = sizeof ip_mtu;
993 if(getsockopt(sock, IPPROTO_IP, IP_MTU, &ip_mtu, &ip_mtu_len)) {
994 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1001 /* getsockopt(IP_MTU) returns the MTU of the physical interface.
1002 We need to remove various overheads to get to the tinc MTU. */
1003 length_t mtu = ip_mtu;
1004 mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
1006 if(n->status.sptps) {
1007 mtu -= SPTPS_DATAGRAM_OVERHEAD;
1008 if((n->options >> 24) >= 4)
1009 mtu -= sizeof(node_id_t) + sizeof(node_id_t);
1010 #ifndef DISABLE_LEGACY
1012 mtu -= digest_length(n->outdigest);
1014 /* Now it's tricky. We use CBC mode, so the length of the
1015 encrypted payload must be a multiple of the blocksize. The
1016 sequence number is also part of the encrypted payload, so we
1017 must account for it after correcting for the blocksize.
1018 Furthermore, the padding in the last block must be at least
1021 length_t blocksize = cipher_blocksize(n->outcipher);
1034 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
1040 logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
1050 /* This function tries to determines the MTU of a node.
1051 By calling this function repeatedly, n->minmtu will be progressively
1052 increased, and at some point, n->mtu will be fixed to n->minmtu. If the MTU
1053 is already fixed, this function checks if it can be increased.
1056 static void try_mtu(node_t *n) {
1057 if(!(n->options & OPTION_PMTU_DISCOVERY))
1060 if(udp_discovery && !n->status.udp_confirmed) {
1061 n->maxrecentlen = 0;
1068 /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1069 mtuprobes == 20: fix MTU, and go to -1
1070 mtuprobes == -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1071 mtuprobes ==-2..-3: send one maxmtu probe every second
1072 mtuprobes == -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1074 struct timeval elapsed;
1075 timersub(&now, &n->mtu_ping_sent, &elapsed);
1076 if(n->mtuprobes >= 0) {
1077 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333)
1080 if(n->mtuprobes < -1) {
1081 if(elapsed.tv_sec < 1)
1084 if(elapsed.tv_sec < pinginterval)
1089 n->mtu_ping_sent = now;
1093 if(n->mtuprobes < -3) {
1094 /* We lost three MTU probes, restart discovery */
1095 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1100 if(n->mtuprobes < 0) {
1101 /* After the initial discovery, we only send one maxmtu and one
1102 maxmtu+1 probe to detect PMTU increases. */
1103 send_udp_probe_packet(n, n->maxmtu);
1104 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU)
1105 send_udp_probe_packet(n, n->maxmtu + 1);
1108 /* Before initial discovery begins, set maxmtu to the most likely value.
1109 If it's underestimated, we will correct it after initial discovery. */
1110 if(n->mtuprobes == 0)
1111 n->maxmtu = choose_initial_maxmtu(n);
1114 /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1115 but it will typically increase convergence time in the no-loss case. */
1116 const length_t probes_per_cycle = 8;
1118 /* This magic value was determined using math simulations.
1119 It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1120 Since 1407 is just below the range of tinc MTUs over typical networks,
1121 this fine-tuning allows tinc to cover a lot of ground very quickly.
1122 This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1123 then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1124 if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1125 const float multiplier = (n->maxmtu == MTU) ? 0.97 : 1;
1127 const float cycle_position = probes_per_cycle - (n->mtuprobes % probes_per_cycle) - 1;
1128 const length_t minmtu = MAX(n->minmtu, 512);
1129 const float interval = n->maxmtu - minmtu;
1131 /* The core of the discovery algorithm is this exponential.
1132 It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1133 This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1134 are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1135 on the precise MTU as we are approaching it.
1136 The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1137 reply per cycle so that we can make progress. */
1138 const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
1140 length_t maxmtu = n->maxmtu;
1141 send_udp_probe_packet(n, minmtu + offset);
1142 /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1143 In that case, we recalculate with the new maxmtu and try again. */
1144 if(n->mtuprobes < 0 || maxmtu == n->maxmtu)
1148 if(n->mtuprobes >= 0)
1153 /* These functions try to establish a tunnel to a node (or its relay) so that
1154 packets can be sent (e.g. exchange keys).
1155 If a tunnel is already established, it tries to improve it (e.g. by trying
1156 to establish a UDP tunnel instead of TCP). This function makes no
1157 guarantees - it is up to the caller to check the node's state to figure out
1158 if TCP and/or UDP is usable. By calling this function repeatedly, the
1159 tunnel is gradually improved until we hit the wall imposed by the underlying
1160 network environment. It is recommended to call this function every time a
1161 packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1162 improving as packets flow, and then gracefully downgrades itself as it goes
1166 static void try_tx_sptps(node_t *n, bool mtu) {
1167 /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1168 messages anyway, so there's no need for SPTPS at all. */
1170 if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY))
1173 /* Otherwise, try to do SPTPS authentication with n if necessary. */
1177 /* Do we need to statically relay packets? */
1179 node_t *via = (n->via == myself) ? n->nexthop : n->via;
1181 /* If the static relay doesn't support SPTPS, everything goes via TCP anyway. */
1183 if((via->options >> 24) < 4)
1186 /* If we do have a static relay, try everything with that one instead. */
1189 return try_tx_sptps(via, mtu);
1191 /* Otherwise, try to establish UDP connectivity. */
1197 /* If we don't have UDP connectivity (yet), we need to use a dynamic relay (nexthop)
1198 while we try to establish direct connectivity. */
1200 if(!n->status.udp_confirmed && n != n->nexthop && (n->nexthop->options >> 24) >= 4)
1201 try_tx_sptps(n->nexthop, mtu);
1204 static void try_tx_legacy(node_t *n, bool mtu) {
1205 /* Does he have our key? If not, send one. */
1207 if(!n->status.validkey_in)
1210 /* Check if we already have a key, or request one. */
1212 if(!n->status.validkey) {
1213 if(n->last_req_key + 10 <= now.tv_sec) {
1215 n->last_req_key = now.tv_sec;
1225 void try_tx(node_t *n, bool mtu) {
1227 try_tx_sptps(n, mtu);
1229 try_tx_legacy(n, mtu);
1232 void send_packet(node_t *n, vpn_packet_t *packet) {
1233 // If it's for myself, write it to the tun/tap device.
1237 memcpy(DATA(packet), mymac.x, ETH_ALEN);
1239 n->out_bytes += packet->len;
1240 devops.write(packet);
1244 logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1246 // If the node is not reachable, drop it.
1248 if(!n->status.reachable) {
1249 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1253 // Keep track of packet statistics.
1256 n->out_bytes += packet->len;
1258 // Check if it should be sent as an SPTPS packet.
1260 if(n->status.sptps) {
1261 send_sptps_packet(n, packet);
1262 try_tx_sptps(n, true);
1266 // Determine which node to actually send it to.
1268 node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1271 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1273 // Try to send via UDP, unless TCP is forced.
1275 if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1276 if(!send_tcppacket(via->connection, packet))
1277 terminate_connection(via->connection, true);
1281 send_udppacket(via, packet);
1282 try_tx_legacy(via, true);
1285 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1286 // Always give ourself a copy of the packet.
1288 send_packet(myself, packet);
1290 // In TunnelServer mode, do not forward broadcast packets.
1291 // The MST might not be valid and create loops.
1292 if(tunnelserver || broadcast_mode == BMODE_NONE)
1295 logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1296 packet->len, from->name, from->hostname);
1298 switch(broadcast_mode) {
1299 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1300 // This guarantees all nodes receive the broadcast packet, and
1301 // usually distributes the sending of broadcast packets over all nodes.
1303 for list_each(connection_t, c, connection_list)
1304 if(c->edge && c->status.mst && c != from->nexthop->connection)
1305 send_packet(c->node, packet);
1308 // In direct mode, we send copies to each node we know of.
1309 // However, this only reaches nodes that can be reached in a single hop.
1310 // We don't have enough information to forward broadcast packets in this case.
1315 for splay_each(node_t, n, node_tree)
1316 if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
1317 send_packet(n, packet);
1325 /* We got a packet from some IP address, but we don't know who sent it. Try to
1326 verify the message authentication code against all active session keys.
1327 Since this is actually an expensive operation, we only do a full check once
1328 a minute, the rest of the time we only check against nodes for which we know
1329 an IP address that matches the one from the packet. */
1331 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1332 node_t *match = NULL;
1334 static time_t last_hard_try = 0;
1336 for splay_each(node_t, n, node_tree) {
1337 if(!n->status.reachable || n == myself)
1340 if((n->status.sptps && !n->sptps.instate) || !n->status.validkey_in)
1345 for splay_each(edge_t, e, n->edge_tree) {
1348 if(!sockaddrcmp_noport(from, &e->reverse->address)) {
1355 if(last_hard_try == now.tv_sec)
1360 if(!try_mac(n, pkt))
1368 last_hard_try = now.tv_sec;
1373 void handle_incoming_vpn_data(void *data, int flags) {
1374 listen_socket_t *ls = data;
1377 node_id_t nullid = {};
1378 sockaddr_t addr = {};
1379 socklen_t addrlen = sizeof addr;
1381 bool direct = false;
1384 int len = recvfrom(ls->udp.fd, DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1386 if(len <= 0 || len > MAXSIZE) {
1387 if(!sockwouldblock(sockerrno))
1388 logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1394 sockaddrunmap(&addr); /* Some braindead IPv6 implementations do stupid things. */
1396 // Try to figure out who sent this packet.
1398 node_t *n = lookup_node_udp(&addr);
1400 if(n && !n->status.udp_confirmed)
1401 n = NULL; // Don't believe it if we don't have confirmation yet.
1404 // It might be from a 1.1 node, which might have a source ID in the packet.
1405 pkt.offset = 2 * sizeof(node_id_t);
1406 from = lookup_node_id(SRCID(&pkt));
1407 if(from && !memcmp(DSTID(&pkt), &nullid, sizeof nullid) && from->status.sptps) {
1408 if(sptps_verify_datagram(&from->sptps, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t)))
1417 n = try_harder(&addr, &pkt);
1422 if(debug_level >= DEBUG_PROTOCOL) {
1423 hostname = sockaddr2hostname(&addr);
1424 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1430 if(n->status.sptps) {
1431 pkt.offset = 2 * sizeof(node_id_t);
1433 if(!memcmp(DSTID(&pkt), &nullid, sizeof nullid)) {
1438 from = lookup_node_id(SRCID(&pkt));
1439 to = lookup_node_id(DSTID(&pkt));
1442 logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1446 /* The packet is supposed to come from the originator or its static relay
1447 (i.e. with no dynamic relays in between).
1448 If it did not, "help" the static relay by sending it UDP info.
1449 Note that we only do this if we're the destination or the static relay;
1450 otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
1452 if(n != from->via && to->via == myself)
1453 send_udp_info(myself, from);
1455 /* If we're not the final recipient, relay the packet. */
1458 send_sptps_data(to, from, 0, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t));
1459 try_tx_sptps(to, true);
1468 if(!receive_udppacket(from, &pkt))
1471 n->sock = ls - listen_socket;
1472 if(direct && sockaddrcmp(&addr, &n->address))
1473 update_node_udp(n, &addr);
1475 /* If the packet went through a relay, help the sender find the appropriate MTU
1476 through the relay path. */
1479 send_mtu_info(myself, n, MTU);
1482 void handle_device_data(void *data, int flags) {
1483 vpn_packet_t packet;
1484 packet.offset = DEFAULT_PACKET_OFFSET;
1485 packet.priority = 0;
1487 if(devops.read(&packet)) {
1488 myself->in_packets++;
1489 myself->in_bytes += packet.len;
1490 route(myself, &packet);