gcrypt: initialize secure memory on startup
[tinc] / src / net_packet.c
1 /*
2     net_packet.c -- Handles in- and outgoing VPN packets
3     Copyright (C) 1998-2005 Ivo Timmermans,
4                   2000-2022 Guus Sliepen <guus@tinc-vpn.org>
5                   2010      Timothy Redaelli <timothy@redaelli.eu>
6                   2010      Brandon Black <blblack@gmail.com>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17
18     You should have received a copy of the GNU General Public License along
19     with this program; if not, write to the Free Software Foundation, Inc.,
20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include "system.h"
24
25 #ifdef HAVE_ZLIB
26 #define ZLIB_CONST
27 #include <zlib.h>
28
29 #endif
30
31 #ifdef HAVE_LZO
32 #include LZO1X_H
33 #endif
34
35 #ifdef HAVE_LZ4
36 #include <lz4.h>
37 #endif
38
39 #include "address_cache.h"
40 #include "cipher.h"
41 #include "conf.h"
42 #include "connection.h"
43 #include "compression.h"
44 #include "crypto.h"
45 #include "digest.h"
46 #include "device.h"
47 #include "ethernet.h"
48 #include "ipv4.h"
49 #include "ipv6.h"
50 #include "logger.h"
51 #include "net.h"
52 #include "netutl.h"
53 #include "protocol.h"
54 #include "route.h"
55 #include "utils.h"
56 #include "random.h"
57
58 /* The minimum size of a probe is 14 bytes, but since we normally use CBC mode
59    encryption, we can add a few extra random bytes without increasing the
60    resulting packet size. */
61 #define MIN_PROBE_SIZE 18
62
63 int keylifetime = 0;
64 #ifdef HAVE_LZO
65 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
66 #endif
67
68 #ifdef HAVE_LZ4
69
70 #ifdef HAVE_LZ4_BUILTIN
71 static LZ4_stream_t lz4_stream;
72 #else
73 static void *lz4_state = NULL;
74 #endif // HAVE_LZ4_BUILTIN
75
76 #endif // HAVE_LZ4
77
78 static void send_udppacket(node_t *, vpn_packet_t *);
79
80 unsigned replaywin = 32;
81 bool localdiscovery = true;
82 bool udp_discovery = true;
83 int udp_discovery_keepalive_interval = 10;
84 int udp_discovery_interval = 2;
85 int udp_discovery_timeout = 30;
86
87 #define MAX_SEQNO 1073741824
88
89 static void try_fix_mtu(node_t *n) {
90         if(n->mtuprobes < 0) {
91                 return;
92         }
93
94         if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) {
95                 if(n->minmtu > n->maxmtu) {
96                         n->minmtu = n->maxmtu;
97                 } else {
98                         n->maxmtu = n->minmtu;
99                 }
100
101                 n->mtu = n->minmtu;
102                 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
103                 n->mtuprobes = -1;
104         }
105 }
106
107 static void reduce_mtu(node_t *n, int mtu) {
108         if(mtu < MINMTU) {
109                 mtu = MINMTU;
110         }
111
112         if(n->maxmtu > mtu) {
113                 n->maxmtu = mtu;
114         }
115
116         if(n->mtu > mtu) {
117                 n->mtu = mtu;
118         }
119
120         try_fix_mtu(n);
121 }
122
123 static void udp_probe_timeout_handler(void *data) {
124         node_t *n = data;
125
126         if(!n->status.udp_confirmed) {
127                 return;
128         }
129
130         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);
131         n->status.udp_confirmed = false;
132         n->udp_ping_rtt = -1;
133         n->maxrecentlen = 0;
134         n->mtuprobes = 0;
135         n->minmtu = 0;
136         n->maxmtu = MTU;
137 }
138
139 static void send_udp_probe_reply(node_t *n, vpn_packet_t *packet, length_t len) {
140         if(!n->status.sptps && !n->status.validkey) {
141                 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);
142                 return;
143         }
144
145         /* Type 2 probe replies were introduced in protocol 17.3 */
146         if((n->options >> 24) >= 3) {
147                 DATA(packet)[0] = 2;
148                 uint16_t len16 = htons(len);
149                 memcpy(DATA(packet) + 1, &len16, 2);
150                 packet->len = MIN_PROBE_SIZE;
151                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 2 probe reply length %u to %s (%s)", len, n->name, n->hostname);
152
153         } else {
154                 /* Legacy protocol: n won't understand type 2 probe replies. */
155                 DATA(packet)[0] = 1;
156                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 1 probe reply length %u to %s (%s)", len, n->name, n->hostname);
157         }
158
159         /* Temporarily set udp_confirmed, so that the reply is sent
160            back exactly the way it came in. */
161
162         bool udp_confirmed = n->status.udp_confirmed;
163         n->status.udp_confirmed = true;
164         send_udppacket(n, packet);
165         n->status.udp_confirmed = udp_confirmed;
166 }
167
168 static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
169         if(!DATA(packet)[0]) {
170                 logger(DEBUG_TRAFFIC, LOG_INFO, "Got UDP probe request %d from %s (%s)", packet->len, n->name, n->hostname);
171                 send_udp_probe_reply(n, packet, len);
172                 return;
173         }
174
175         if(DATA(packet)[0] == 2) {
176                 // It's a type 2 probe reply, use the length field inside the packet
177                 uint16_t len16;
178                 memcpy(&len16, DATA(packet) + 1, 2);
179                 len = ntohs(len16);
180         }
181
182         if(n->status.ping_sent) {  // a probe in flight
183                 gettimeofday(&now, NULL);
184                 struct timeval rtt;
185                 timersub(&now, &n->udp_ping_sent, &rtt);
186                 n->udp_ping_rtt = (int)(rtt.tv_sec * 1000000 + rtt.tv_usec);
187                 n->status.ping_sent = false;
188                 logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s) rtt=%d.%03d", DATA(packet)[0], len, n->name, n->hostname, n->udp_ping_rtt / 1000, n->udp_ping_rtt % 1000);
189         } else {
190                 logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s)", DATA(packet)[0], len, n->name, n->hostname);
191         }
192
193         /* It's a valid reply: now we know bidirectional communication
194            is possible using the address and socket that the reply
195            packet used. */
196         if(!n->status.udp_confirmed) {
197                 n->status.udp_confirmed = true;
198
199                 if(!n->address_cache) {
200                         n->address_cache = open_address_cache(n);
201                 }
202
203                 reset_address_cache(n->address_cache, &n->address);
204         }
205
206         // Reset the UDP ping timer.
207
208         if(udp_discovery) {
209                 timeout_del(&n->udp_ping_timeout);
210                 timeout_add(&n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timeval) {
211                         udp_discovery_timeout, 0
212                 });
213         }
214
215         if(len > n->maxmtu) {
216                 logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
217                 n->minmtu = len;
218                 n->maxmtu = MTU;
219                 /* Set mtuprobes to 1 so that try_mtu() doesn't reset maxmtu */
220                 n->mtuprobes = 1;
221                 return;
222         } else if(n->mtuprobes < 0 && len == n->maxmtu) {
223                 /* We got a maxmtu sized packet, confirming the PMTU is still valid. */
224                 n->mtuprobes = -1;
225                 n->mtu_ping_sent = now;
226         }
227
228         /* If applicable, raise the minimum supported MTU */
229
230         if(n->minmtu < len) {
231                 n->minmtu = len;
232                 try_fix_mtu(n);
233         }
234 }
235
236 #ifdef HAVE_LZ4
237 static length_t compress_packet_lz4(uint8_t *dest, const uint8_t *source, length_t len) {
238 #ifdef HAVE_LZ4_BUILTIN
239         return LZ4_compress_fast_extState(&lz4_stream, (const char *) source, (char *) dest, len, MAXSIZE, 0);
240 #else
241
242         /* @FIXME: Put this in a better place, and free() it too. */
243         if(lz4_state == NULL) {
244                 lz4_state = malloc(LZ4_sizeofState());
245         }
246
247         if(lz4_state == NULL) {
248                 logger(DEBUG_ALWAYS, LOG_ERR, "Failed to allocate lz4_state, error: %i", errno);
249                 return 0;
250         }
251
252         return LZ4_compress_fast_extState(lz4_state, (const char *) source, (char *) dest, len, MAXSIZE, 0);
253 #endif /* HAVE_LZ4_BUILTIN */
254 }
255 #endif /* HAVE_LZ4 */
256
257 #ifdef HAVE_LZO
258 static length_t compress_packet_lzo(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
259         lzo_uint lzolen = MAXSIZE;
260         int result;
261
262         if(level == COMPRESS_LZO_HI) {
263                 result = lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
264         } else { // level == COMPRESS_LZO_LO
265                 result = lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
266         }
267
268         if(result == LZO_E_OK) {
269                 return lzolen;
270         } else {
271                 return 0;
272         }
273 }
274 #endif
275
276 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
277         switch(level) {
278 #ifdef HAVE_LZ4
279
280         case COMPRESS_LZ4:
281                 return compress_packet_lz4(dest, source, len);
282 #endif
283
284 #ifdef HAVE_LZO
285
286         case COMPRESS_LZO_HI:
287         case COMPRESS_LZO_LO:
288                 return compress_packet_lzo(dest, source, len, level);
289 #endif
290 #ifdef HAVE_ZLIB
291
292         case COMPRESS_ZLIB_9:
293         case COMPRESS_ZLIB_8:
294         case COMPRESS_ZLIB_7:
295         case COMPRESS_ZLIB_6:
296         case COMPRESS_ZLIB_5:
297         case COMPRESS_ZLIB_4:
298         case COMPRESS_ZLIB_3:
299         case COMPRESS_ZLIB_2:
300         case COMPRESS_ZLIB_1: {
301                 unsigned long dest_len = MAXSIZE;
302
303                 if(compress2(dest, &dest_len, source, len, level) == Z_OK) {
304                         return dest_len;
305                 } else {
306                         return 0;
307                 }
308         }
309
310 #endif
311
312         case COMPRESS_NONE:
313                 memcpy(dest, source, len);
314                 return len;
315
316         default:
317                 return 0;
318         }
319 }
320
321 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
322         switch(level) {
323 #ifdef HAVE_LZ4
324
325         case COMPRESS_LZ4:
326                 return LZ4_decompress_safe((char *)source, (char *) dest, len, MAXSIZE);
327
328 #endif
329 #ifdef HAVE_LZO
330
331         case COMPRESS_LZO_HI:
332         case COMPRESS_LZO_LO: {
333                 lzo_uint dst_len = MAXSIZE;
334
335                 if(lzo1x_decompress_safe(source, len, dest, &dst_len, NULL) == LZO_E_OK) {
336                         return dst_len;
337                 } else {
338                         return 0;
339                 }
340         }
341
342 #endif
343 #ifdef HAVE_ZLIB
344
345         case COMPRESS_ZLIB_9:
346         case COMPRESS_ZLIB_8:
347         case COMPRESS_ZLIB_7:
348         case COMPRESS_ZLIB_6:
349         case COMPRESS_ZLIB_5:
350         case COMPRESS_ZLIB_4:
351         case COMPRESS_ZLIB_3:
352         case COMPRESS_ZLIB_2:
353         case COMPRESS_ZLIB_1: {
354                 unsigned long destlen = MAXSIZE;
355                 static z_stream stream;
356
357                 if(stream.next_in) {
358                         inflateReset(&stream);
359                 } else {
360                         inflateInit(&stream);
361                 }
362
363                 stream.next_in = source;
364                 stream.avail_in = len;
365                 stream.next_out = dest;
366                 stream.avail_out = destlen;
367                 stream.total_out = 0;
368
369                 if(inflate(&stream, Z_FINISH) == Z_STREAM_END) {
370                         return stream.total_out;
371                 } else {
372                         return 0;
373                 }
374         }
375
376 #endif
377
378         case COMPRESS_NONE:
379                 memcpy(dest, source, len);
380                 return len;
381
382         default:
383                 return 0;
384         }
385 }
386
387 /* VPN packet I/O */
388
389 static void receive_packet(node_t *n, vpn_packet_t *packet) {
390         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
391                packet->len, n->name, n->hostname);
392
393         n->in_packets++;
394         n->in_bytes += packet->len;
395
396         route(n, packet);
397 }
398
399 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
400         if(n->status.sptps) {
401                 return sptps_verify_datagram(&n->sptps, DATA(inpkt), inpkt->len);
402         }
403
404 #ifdef DISABLE_LEGACY
405         return false;
406 #else
407
408         if(!n->status.validkey_in || !digest_active(n->indigest) || (size_t)inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
409                 return false;
410         }
411
412         return digest_verify(n->indigest, inpkt->data, inpkt->len - digest_length(n->indigest), inpkt->data + inpkt->len - digest_length(n->indigest));
413 #endif
414 }
415
416 static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
417         if(n->status.sptps) {
418                 if(!n->sptps.state) {
419                         if(!n->status.waitingforkey) {
420                                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
421                                 send_req_key(n);
422                         } else {
423                                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
424                         }
425
426                         return false;
427                 }
428
429                 n->status.udppacket = true;
430                 bool result = sptps_receive_data(&n->sptps, DATA(inpkt), inpkt->len);
431                 n->status.udppacket = false;
432
433                 if(!result) {
434                         /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
435                            so let's restart SPTPS in case that helps. But don't do that too often
436                            to prevent storms, and because that would make life a little too easy
437                            for external attackers trying to DoS us. */
438                         if(n->last_req_key < now.tv_sec - 10) {
439                                 logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode raw TCP packet from %s (%s), restarting SPTPS", n->name, n->hostname);
440                                 send_req_key(n);
441                         }
442
443                         return false;
444                 }
445
446                 return true;
447         }
448
449 #ifdef DISABLE_LEGACY
450         return false;
451 #else
452         vpn_packet_t pkt1, pkt2;
453         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
454         int nextpkt = 0;
455         size_t outlen;
456         pkt1.offset = DEFAULT_PACKET_OFFSET;
457         pkt2.offset = DEFAULT_PACKET_OFFSET;
458
459         if(!n->status.validkey_in) {
460                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
461                 return false;
462         }
463
464         /* Check packet length */
465
466         if((size_t)inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
467                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
468                        n->name, n->hostname);
469                 return false;
470         }
471
472         /* It's a legacy UDP packet, the data starts after the seqno */
473
474         inpkt->offset += sizeof(seqno_t);
475
476         /* Check the message authentication code */
477
478         if(digest_active(n->indigest)) {
479                 inpkt->len -= digest_length(n->indigest);
480
481                 if(!digest_verify(n->indigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
482                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
483                         return false;
484                 }
485         }
486
487         /* Decrypt the packet */
488
489         if(cipher_active(n->incipher)) {
490                 vpn_packet_t *outpkt = pkt[nextpkt++];
491                 outlen = MAXSIZE;
492
493                 if(!cipher_decrypt(n->incipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
494                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
495                         return false;
496                 }
497
498                 outpkt->len = outlen;
499                 inpkt = outpkt;
500         }
501
502         /* Check the sequence number */
503
504         seqno_t seqno;
505         memcpy(&seqno, SEQNO(inpkt), sizeof(seqno));
506         seqno = ntohl(seqno);
507         inpkt->len -= sizeof(seqno);
508
509         if(replaywin) {
510                 if(seqno != n->received_seqno + 1) {
511                         if(seqno >= n->received_seqno + replaywin * 8) {
512                                 if(n->farfuture++ < replaywin >> 2) {
513                                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
514                                                n->name, n->hostname, seqno - n->received_seqno - 1, n->farfuture);
515                                         return false;
516                                 }
517
518                                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Lost %d packets from %s (%s)",
519                                        seqno - n->received_seqno - 1, n->name, n->hostname);
520                                 memset(n->late, 0, replaywin);
521                         } else if(seqno <= n->received_seqno) {
522                                 if((n->received_seqno >= replaywin * 8 && seqno <= n->received_seqno - replaywin * 8) || !(n->late[(seqno / 8) % replaywin] & (1 << seqno % 8))) {
523                                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
524                                                n->name, n->hostname, seqno, n->received_seqno);
525                                         return false;
526                                 }
527                         } else {
528                                 for(seqno_t i = n->received_seqno + 1; i < seqno; i++) {
529                                         n->late[(i / 8) % replaywin] |= 1 << i % 8;
530                                 }
531                         }
532                 }
533
534                 n->farfuture = 0;
535                 n->late[(seqno / 8) % replaywin] &= ~(1 << seqno % 8);
536         }
537
538         if(seqno > n->received_seqno) {
539                 n->received_seqno = seqno;
540         }
541
542         n->received++;
543
544         if(n->received_seqno > MAX_SEQNO) {
545                 regenerate_key();
546         }
547
548         /* Decompress the packet */
549
550         length_t origlen = inpkt->len;
551
552         if(n->incompression != COMPRESS_NONE) {
553                 vpn_packet_t *outpkt = pkt[nextpkt++];
554
555                 if(!(outpkt->len = uncompress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->incompression))) {
556                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
557                                n->name, n->hostname);
558                         return false;
559                 }
560
561                 inpkt = outpkt;
562
563                 if(origlen > MTU / 64 + 20) {
564                         origlen -= MTU / 64 + 20;
565                 } else {
566                         origlen = 0;
567                 }
568         }
569
570         if(inpkt->len > n->maxrecentlen) {
571                 n->maxrecentlen = inpkt->len;
572         }
573
574         inpkt->priority = 0;
575
576         if(!DATA(inpkt)[12] && !DATA(inpkt)[13]) {
577                 udp_probe_h(n, inpkt, origlen);
578         } else {
579                 receive_packet(n, inpkt);
580         }
581
582         return true;
583 #endif
584 }
585
586 void receive_tcppacket(connection_t *c, const char *buffer, size_t len) {
587         vpn_packet_t outpkt;
588         outpkt.offset = DEFAULT_PACKET_OFFSET;
589
590         if(len > sizeof(outpkt.data) - outpkt.offset) {
591                 return;
592         }
593
594         outpkt.len = len;
595
596         if(c->options & OPTION_TCPONLY) {
597                 outpkt.priority = 0;
598         } else {
599                 outpkt.priority = -1;
600         }
601
602         memcpy(DATA(&outpkt), buffer, len);
603
604         receive_packet(c->node, &outpkt);
605 }
606
607 bool receive_tcppacket_sptps(connection_t *c, const char *data, size_t len) {
608         if(len < sizeof(node_id_t) + sizeof(node_id_t)) {
609                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got too short TCP SPTPS packet from %s (%s)", c->name, c->hostname);
610                 return false;
611         }
612
613         node_t *to = lookup_node_id((node_id_t *)data);
614         data += sizeof(node_id_t);
615         len -= sizeof(node_id_t);
616
617         if(!to) {
618                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown destination ID", c->name, c->hostname);
619                 return true;
620         }
621
622         node_t *from = lookup_node_id((node_id_t *)data);
623         data += sizeof(node_id_t);
624         len -= sizeof(node_id_t);
625
626         if(!from) {
627                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown source ID", c->name, c->hostname);
628                 return true;
629         }
630
631         if(!to->status.reachable) {
632                 /* This can happen in the form of a race condition
633                    if the node just became unreachable. */
634                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Cannot relay TCP packet from %s (%s) because the destination, %s (%s), is unreachable", from->name, from->hostname, to->name, to->hostname);
635                 return true;
636         }
637
638         /* Help the sender reach us over UDP.
639            Note that we only do this if we're the destination or the static relay;
640            otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
641         if(to->via == myself) {
642                 send_udp_info(myself, from);
643         }
644
645         /* If we're not the final recipient, relay the packet. */
646
647         if(to != myself) {
648                 if(to->status.validkey) {
649                         send_sptps_data(to, from, 0, data, len);
650                 }
651
652                 try_tx(to, true);
653                 return true;
654         }
655
656         /* The packet is for us */
657
658         if(!sptps_receive_data(&from->sptps, data, len)) {
659                 /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
660                    so let's restart SPTPS in case that helps. But don't do that too often
661                    to prevent storms. */
662                 if(from->last_req_key < now.tv_sec - 10) {
663                         logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode raw TCP packet from %s (%s), restarting SPTPS", from->name, from->hostname);
664                         send_req_key(from);
665                 }
666
667                 return true;
668         }
669
670         send_mtu_info(myself, from, MTU);
671         return true;
672 }
673
674 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
675         if(!n->status.validkey && !n->connection) {
676                 return;
677         }
678
679         uint8_t type = 0;
680         int offset = 0;
681
682         if((!(DATA(origpkt)[12] | DATA(origpkt)[13])) && (n->sptps.outstate))  {
683                 sptps_send_record(&n->sptps, PKT_PROBE, DATA(origpkt), origpkt->len);
684                 return;
685         }
686
687         if(routing_mode == RMODE_ROUTER) {
688                 offset = 14;
689         } else {
690                 type = PKT_MAC;
691         }
692
693         if(origpkt->len < offset) {
694                 return;
695         }
696
697         vpn_packet_t outpkt;
698
699         if(n->outcompression != COMPRESS_NONE) {
700                 outpkt.offset = 0;
701                 length_t len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
702
703                 if(!len) {
704                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
705                 } else if(len < origpkt->len - offset) {
706                         outpkt.len = len + offset;
707                         origpkt = &outpkt;
708                         type |= PKT_COMPRESSED;
709                 }
710         }
711
712         /* If we have a direct metaconnection to n, and we can't use UDP, then
713            don't bother with SPTPS and just use a "plaintext" PACKET message.
714            We don't really care about end-to-end security since we're not
715            sending the message through any intermediate nodes. */
716         if(n->connection && origpkt->len > n->minmtu) {
717                 send_tcppacket(n->connection, origpkt);
718         } else {
719                 sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
720         }
721 }
722
723 static void adapt_socket(const sockaddr_t *sa, size_t *sock) {
724         /* Make sure we have a suitable socket for the chosen address */
725         if(listen_socket[*sock].sa.sa.sa_family != sa->sa.sa_family) {
726                 for(int i = 0; i < listen_sockets; i++) {
727                         if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
728                                 *sock = i;
729                                 break;
730                         }
731                 }
732         }
733 }
734
735 static void choose_udp_address(const node_t *n, const sockaddr_t **sa, size_t *sock) {
736         /* Latest guess */
737         *sa = &n->address;
738         *sock = n->sock;
739
740         /* If the UDP address is confirmed, use it. */
741         if(n->status.udp_confirmed) {
742                 return;
743         }
744
745         /* Send every third packet to n->address; that could be set
746            to the node's reflexive UDP address discovered during key
747            exchange. */
748
749         static int x = 0;
750
751         if(++x >= 3) {
752                 x = 0;
753                 return;
754         }
755
756         /* Otherwise, address are found in edges to this node.
757            So we pick a random edge and a random socket. */
758
759         unsigned int i = 0;
760         unsigned int j = prng(n->edge_tree.count);
761         edge_t *candidate = NULL;
762
763         for splay_each(edge_t, e, &n->edge_tree) {
764                 if(i++ == j) {
765                         candidate = e->reverse;
766                         break;
767                 }
768         }
769
770         if(candidate) {
771                 *sa = &candidate->address;
772                 *sock = prng(listen_sockets);
773         }
774
775         adapt_socket(*sa, sock);
776 }
777
778 static void choose_local_address(const node_t *n, const sockaddr_t **sa, size_t *sock) {
779         *sa = NULL;
780
781         /* Pick one of the edges from this node at random, then use its local address. */
782
783         unsigned int i = 0;
784         unsigned int j = prng(n->edge_tree.count);
785         edge_t *candidate = NULL;
786
787         for splay_each(edge_t, e, &n->edge_tree) {
788                 if(i++ == j) {
789                         candidate = e;
790                         break;
791                 }
792         }
793
794         if(candidate && candidate->local_address.sa.sa_family) {
795                 *sa = &candidate->local_address;
796                 *sock = prng(listen_sockets);
797                 adapt_socket(*sa, sock);
798         }
799 }
800
801 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
802         if(!n->status.reachable) {
803                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
804                 return;
805         }
806
807         if(n->status.sptps) {
808                 send_sptps_packet(n, origpkt);
809                 return;
810         }
811
812 #ifdef DISABLE_LEGACY
813         return;
814 #else
815         vpn_packet_t pkt1, pkt2;
816         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
817         vpn_packet_t *inpkt = origpkt;
818         int nextpkt = 0;
819         vpn_packet_t *outpkt;
820         int origlen = origpkt->len;
821         size_t outlen;
822         int origpriority = origpkt->priority;
823
824         pkt1.offset = DEFAULT_PACKET_OFFSET;
825         pkt2.offset = DEFAULT_PACKET_OFFSET;
826
827         /* Make sure we have a valid key */
828
829         if(!n->status.validkey) {
830                 logger(DEBUG_TRAFFIC, LOG_INFO,
831                        "No valid key known yet for %s (%s), forwarding via TCP",
832                        n->name, n->hostname);
833                 send_tcppacket(n->nexthop->connection, origpkt);
834                 return;
835         }
836
837         if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
838                 logger(DEBUG_TRAFFIC, LOG_INFO,
839                        "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
840                        n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
841
842                 if(n != n->nexthop) {
843                         send_packet(n->nexthop, origpkt);
844                 } else {
845                         send_tcppacket(n->nexthop->connection, origpkt);
846                 }
847
848                 return;
849         }
850
851         /* Compress the packet */
852
853         if(n->outcompression != COMPRESS_NONE) {
854                 outpkt = pkt[nextpkt++];
855
856                 if(!(outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression))) {
857                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
858                                n->name, n->hostname);
859                         return;
860                 }
861
862                 inpkt = outpkt;
863         }
864
865         /* Add sequence number */
866
867         seqno_t seqno = htonl(++(n->sent_seqno));
868         memcpy(SEQNO(inpkt), &seqno, sizeof(seqno));
869         inpkt->len += sizeof(seqno);
870
871         /* Encrypt the packet */
872
873         if(cipher_active(n->outcipher)) {
874                 outpkt = pkt[nextpkt++];
875                 outlen = MAXSIZE;
876
877                 if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
878                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
879                         goto end;
880                 }
881
882                 outpkt->len = outlen;
883                 inpkt = outpkt;
884         }
885
886         /* Add the message authentication code */
887
888         if(digest_active(n->outdigest)) {
889                 if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
890                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
891                         goto end;
892                 }
893
894                 inpkt->len += digest_length(n->outdigest);
895         }
896
897         /* Send the packet */
898
899         const sockaddr_t *sa = NULL;
900         size_t sock;
901
902         if(n->status.send_locally) {
903                 choose_local_address(n, &sa, &sock);
904         }
905
906         if(!sa) {
907                 choose_udp_address(n, &sa, &sock);
908         }
909
910         if(priorityinheritance && origpriority != listen_socket[sock].priority) {
911                 listen_socket[sock].priority = origpriority;
912
913                 switch(sa->sa.sa_family) {
914 #if defined(IP_TOS)
915
916                 case AF_INET:
917                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting IPv4 outgoing packet priority to %d", origpriority);
918
919                         if(setsockopt(listen_socket[sock].udp.fd, IPPROTO_IP, IP_TOS, (void *)&origpriority, sizeof(origpriority))) { /* SO_PRIORITY doesn't seem to work */
920                                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
921                         }
922
923                         break;
924 #endif
925 #if defined(IPV6_TCLASS)
926
927                 case AF_INET6:
928                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting IPv6 outgoing packet priority to %d", origpriority);
929
930                         if(setsockopt(listen_socket[sock].udp.fd, IPPROTO_IPV6, IPV6_TCLASS, (void *)&origpriority, sizeof(origpriority))) { /* SO_PRIORITY doesn't seem to work */
931                                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
932                         }
933
934                         break;
935 #endif
936
937                 default:
938                         break;
939                 }
940         }
941
942         if(sendto(listen_socket[sock].udp.fd, (void *)SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
943                 if(sockmsgsize(sockerrno)) {
944                         reduce_mtu(n, origlen - 1);
945                 } else {
946                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
947                 }
948         }
949
950 end:
951         origpkt->len = origlen;
952 #endif
953 }
954
955 bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_t len) {
956         size_t origlen = len - SPTPS_DATAGRAM_OVERHEAD;
957         node_t *relay = (to->via != myself && (type == PKT_PROBE || origlen <= to->via->minmtu)) ? to->via : to->nexthop;
958         bool direct = from == myself && to == relay;
959         bool relay_supported = (relay->options >> 24) >= 4;
960         bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
961
962         /* 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. */
963
964         if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && origlen > relay->minmtu)) {
965                 if(type != SPTPS_HANDSHAKE && (to->nexthop->connection->options >> 24) >= 7) {
966                         const size_t buflen = len + sizeof(to->id) + sizeof(from->id);
967                         uint8_t *buf = alloca(buflen);
968                         uint8_t *buf_ptr = buf;
969                         memcpy(buf_ptr, &to->id, sizeof(to->id));
970                         buf_ptr += sizeof(to->id);
971                         memcpy(buf_ptr, &from->id, sizeof(from->id));
972                         buf_ptr += sizeof(from->id);
973                         memcpy(buf_ptr, data, len);
974                         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);
975                         return send_sptps_tcppacket(to->nexthop->connection, buf, buflen);
976                 }
977
978                 char *buf = alloca(B64_SIZE(len));
979                 b64encode_tinc(data, buf, len);
980
981                 /* If this is a handshake packet, use ANS_KEY instead of REQ_KEY, for two reasons:
982                     - We don't want intermediate nodes to switch to UDP to relay these packets;
983                     - ANS_KEY allows us to learn the reflexive UDP address. */
984                 if(type == SPTPS_HANDSHAKE) {
985                         to->incompression = myself->incompression;
986                         return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
987                 } else {
988                         return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, SPTPS_PACKET, buf);
989                 }
990         }
991
992         size_t overhead = 0;
993
994         if(relay_supported) {
995                 overhead += sizeof(to->id) + sizeof(from->id);
996         }
997
998         char *buf = alloca(len + overhead);
999         char *buf_ptr = buf;
1000
1001         if(relay_supported) {
1002                 if(direct) {
1003                         /* Inform the recipient that this packet was sent directly. */
1004                         node_id_t nullid = {0};
1005                         memcpy(buf_ptr, &nullid, sizeof(nullid));
1006                         buf_ptr += sizeof(nullid);
1007                 } else {
1008                         memcpy(buf_ptr, &to->id, sizeof(to->id));
1009                         buf_ptr += sizeof(to->id);
1010                 }
1011
1012                 memcpy(buf_ptr, &from->id, sizeof(from->id));
1013                 buf_ptr += sizeof(from->id);
1014
1015         }
1016
1017         /* 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 */
1018         memcpy(buf_ptr, data, len);
1019         buf_ptr += len;
1020
1021         const sockaddr_t *sa = NULL;
1022         size_t sock;
1023
1024         if(relay->status.send_locally) {
1025                 choose_local_address(relay, &sa, &sock);
1026         }
1027
1028         if(!sa) {
1029                 choose_udp_address(relay, &sa, &sock);
1030         }
1031
1032         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);
1033
1034         if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
1035                 if(sockmsgsize(sockerrno)) {
1036                         reduce_mtu(relay, (int)origlen - 1);
1037                 } else {
1038                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
1039                         return false;
1040                 }
1041         }
1042
1043         return true;
1044 }
1045
1046 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
1047         node_t *from = handle;
1048
1049         if(type == SPTPS_HANDSHAKE) {
1050                 if(!from->status.validkey) {
1051                         from->status.validkey = true;
1052                         from->status.waitingforkey = false;
1053                         logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) successful", from->name, from->hostname);
1054                 }
1055
1056                 return true;
1057         }
1058
1059         if(len > MTU) {
1060                 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
1061                 return false;
1062         }
1063
1064         vpn_packet_t inpkt;
1065         inpkt.offset = DEFAULT_PACKET_OFFSET;
1066         inpkt.priority = 0;
1067
1068         if(type == PKT_PROBE) {
1069                 if(!from->status.udppacket) {
1070                         logger(DEBUG_ALWAYS, LOG_ERR, "Got SPTPS PROBE packet from %s (%s) via TCP", from->name, from->hostname);
1071                         return false;
1072                 }
1073
1074                 inpkt.len = len;
1075                 memcpy(DATA(&inpkt), data, len);
1076
1077                 if(inpkt.len > from->maxrecentlen) {
1078                         from->maxrecentlen = inpkt.len;
1079                 }
1080
1081                 udp_probe_h(from, &inpkt, len);
1082                 return true;
1083         }
1084
1085         if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
1086                 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
1087                 return false;
1088         }
1089
1090         /* Check if we have the headers we need */
1091         if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
1092                 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
1093                 return false;
1094         } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
1095                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
1096         }
1097
1098         int offset = (type & PKT_MAC) ? 0 : 14;
1099
1100         if(type & PKT_COMPRESSED) {
1101                 length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
1102
1103                 if(!ulen) {
1104                         return false;
1105                 } else {
1106                         inpkt.len = ulen + offset;
1107                 }
1108
1109                 if(inpkt.len > MAXSIZE) {
1110                         abort();
1111                 }
1112         } else {
1113                 memcpy(DATA(&inpkt) + offset, data, len);
1114                 inpkt.len = len + offset;
1115         }
1116
1117         /* Generate the Ethernet packet type if necessary */
1118         if(offset) {
1119                 switch(DATA(&inpkt)[14] >> 4) {
1120                 case 4:
1121                         DATA(&inpkt)[12] = 0x08;
1122                         DATA(&inpkt)[13] = 0x00;
1123                         break;
1124
1125                 case 6:
1126                         DATA(&inpkt)[12] = 0x86;
1127                         DATA(&inpkt)[13] = 0xDD;
1128                         break;
1129
1130                 default:
1131                         logger(DEBUG_TRAFFIC, LOG_ERR,
1132                                "Unknown IP version %d while reading packet from %s (%s)",
1133                                DATA(&inpkt)[14] >> 4, from->name, from->hostname);
1134                         return false;
1135                 }
1136         }
1137
1138         if(from->status.udppacket && inpkt.len > from->maxrecentlen) {
1139                 from->maxrecentlen = inpkt.len;
1140         }
1141
1142         receive_packet(from, &inpkt);
1143         return true;
1144 }
1145
1146 // This function tries to get SPTPS keys, if they aren't already known.
1147 // 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.
1148 static void try_sptps(node_t *n) {
1149         if(n->status.validkey) {
1150                 return;
1151         }
1152
1153         logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
1154
1155         if(!n->status.waitingforkey) {
1156                 send_req_key(n);
1157         } else if(n->last_req_key + 10 < now.tv_sec) {
1158                 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
1159                 sptps_stop(&n->sptps);
1160                 n->status.waitingforkey = false;
1161                 send_req_key(n);
1162         }
1163
1164         return;
1165 }
1166
1167 static void send_udp_probe_packet(node_t *n, size_t len) {
1168         vpn_packet_t packet;
1169
1170         if(len > sizeof(packet.data)) {
1171                 logger(DEBUG_TRAFFIC, LOG_INFO, "Truncating probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
1172                 len = sizeof(packet.data);
1173         }
1174
1175         len = MAX(len, MIN_PROBE_SIZE);
1176         packet.offset = DEFAULT_PACKET_OFFSET;
1177         memset(DATA(&packet), 0, 14);
1178         randomize(DATA(&packet) + 14, len - 14);
1179         packet.len = len;
1180         packet.priority = 0;
1181
1182         logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
1183
1184         send_udppacket(n, &packet);
1185 }
1186
1187 // This function tries to establish a UDP tunnel to a node so that packets can be sent.
1188 // If a tunnel is already established, it makes sure it stays up.
1189 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if UDP is usable.
1190 static void try_udp(node_t *n) {
1191         if(!udp_discovery) {
1192                 return;
1193         }
1194
1195         /* Send gratuitous probe replies to 1.1 nodes. */
1196
1197         if((n->options >> 24) >= 3 && n->status.udp_confirmed) {
1198                 struct timeval ping_tx_elapsed;
1199                 timersub(&now, &n->udp_reply_sent, &ping_tx_elapsed);
1200
1201                 if(ping_tx_elapsed.tv_sec >= udp_discovery_keepalive_interval - 1) {
1202                         n->udp_reply_sent = now;
1203
1204                         if(n->maxrecentlen) {
1205                                 vpn_packet_t pkt;
1206                                 pkt.len = n->maxrecentlen;
1207                                 pkt.offset = DEFAULT_PACKET_OFFSET;
1208                                 memset(DATA(&pkt), 0, 14);
1209                                 randomize(DATA(&pkt) + 14, MIN_PROBE_SIZE - 14);
1210                                 send_udp_probe_reply(n, &pkt, pkt.len);
1211                                 n->maxrecentlen = 0;
1212                         }
1213                 }
1214         }
1215
1216         /* Probe request */
1217
1218         struct timeval ping_tx_elapsed;
1219         timersub(&now, &n->udp_ping_sent, &ping_tx_elapsed);
1220
1221         int interval = n->status.udp_confirmed
1222                        ? udp_discovery_keepalive_interval
1223                        : udp_discovery_interval;
1224
1225         if(ping_tx_elapsed.tv_sec >= interval) {
1226                 gettimeofday(&now, NULL);
1227                 n->udp_ping_sent = now; // a probe in flight
1228                 n->status.ping_sent = true;
1229                 send_udp_probe_packet(n, MIN_PROBE_SIZE);
1230
1231                 if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
1232                         n->status.send_locally = true;
1233                         send_udp_probe_packet(n, MIN_PROBE_SIZE);
1234                         n->status.send_locally = false;
1235                 }
1236         }
1237 }
1238
1239 static length_t choose_initial_maxmtu(node_t *n) {
1240 #ifdef IP_MTU
1241
1242         int sock = -1;
1243
1244         const sockaddr_t *sa = NULL;
1245         size_t sockindex;
1246         choose_udp_address(n, &sa, &sockindex);
1247
1248         if(!sa) {
1249                 return MTU;
1250         }
1251
1252         sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
1253
1254         if(sock < 0) {
1255                 logger(DEBUG_TRAFFIC, LOG_ERR, "Creating MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1256                 return MTU;
1257         }
1258
1259         if(connect(sock, &sa->sa, SALEN(sa->sa))) {
1260                 logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1261                 closesocket(sock);
1262                 return MTU;
1263         }
1264
1265         int ip_mtu;
1266         socklen_t ip_mtu_len = sizeof(ip_mtu);
1267
1268         if(getsockopt(sock, IPPROTO_IP, IP_MTU, (void *)&ip_mtu, &ip_mtu_len)) {
1269                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1270                 closesocket(sock);
1271                 return MTU;
1272         }
1273
1274         closesocket(sock);
1275
1276         if(ip_mtu < MINMTU) {
1277                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
1278                 return MTU;
1279         }
1280
1281         /* getsockopt(IP_MTU) returns the MTU of the physical interface.
1282            We need to remove various overheads to get to the tinc MTU. */
1283         length_t mtu = ip_mtu;
1284         mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
1285         mtu -= 8; /* UDP */
1286
1287         if(n->status.sptps) {
1288                 mtu -= SPTPS_DATAGRAM_OVERHEAD;
1289
1290                 if((n->options >> 24) >= 4) {
1291                         mtu -= sizeof(node_id_t) + sizeof(node_id_t);
1292                 }
1293
1294 #ifndef DISABLE_LEGACY
1295         } else {
1296                 mtu -= digest_length(n->outdigest);
1297
1298                 /* Now it's tricky. We use CBC mode, so the length of the
1299                    encrypted payload must be a multiple of the blocksize. The
1300                    sequence number is also part of the encrypted payload, so we
1301                    must account for it after correcting for the blocksize.
1302                    Furthermore, the padding in the last block must be at least
1303                    1 byte. */
1304
1305                 length_t blocksize = cipher_blocksize(n->outcipher);
1306
1307                 if(blocksize > 1) {
1308                         mtu /= blocksize;
1309                         mtu *= blocksize;
1310                         mtu--;
1311                 }
1312
1313                 mtu -= 4; // seqno
1314 #endif
1315         }
1316
1317         if(mtu > MTU) {
1318                 return MTU;
1319         }
1320
1321         logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
1322         return mtu;
1323
1324 #else
1325         (void)n;
1326         return MTU;
1327 #endif
1328 }
1329
1330 /* This function tries to determines the MTU of a node.
1331    By calling this function repeatedly, n->minmtu will be progressively
1332    increased, and at some point, n->mtu will be fixed to n->minmtu.  If the MTU
1333    is already fixed, this function checks if it can be increased.
1334 */
1335
1336 static void try_mtu(node_t *n) {
1337         if(!(n->options & OPTION_PMTU_DISCOVERY)) {
1338                 return;
1339         }
1340
1341         if(udp_discovery && !n->status.udp_confirmed) {
1342                 n->maxrecentlen = 0;
1343                 n->mtuprobes = 0;
1344                 n->minmtu = 0;
1345                 n->maxmtu = MTU;
1346                 return;
1347         }
1348
1349         /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1350            mtuprobes ==    20: fix MTU, and go to -1
1351            mtuprobes ==    -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1352            mtuprobes ==-2..-3: send one maxmtu probe every second
1353            mtuprobes ==    -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1354
1355         struct timeval elapsed;
1356         timersub(&now, &n->mtu_ping_sent, &elapsed);
1357
1358         if(n->mtuprobes >= 0) {
1359                 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333) {
1360                         return;
1361                 }
1362         } else {
1363                 if(n->mtuprobes < -1) {
1364                         if(elapsed.tv_sec < 1) {
1365                                 return;
1366                         }
1367                 } else {
1368                         if(elapsed.tv_sec < pinginterval) {
1369                                 return;
1370                         }
1371                 }
1372         }
1373
1374         n->mtu_ping_sent = now;
1375
1376         try_fix_mtu(n);
1377
1378         if(n->mtuprobes < -3) {
1379                 /* We lost three MTU probes, restart discovery */
1380                 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1381                 n->mtuprobes = 0;
1382                 n->minmtu = 0;
1383         }
1384
1385         if(n->mtuprobes < 0) {
1386                 /* After the initial discovery, we only send one maxmtu and one
1387                    maxmtu+1 probe to detect PMTU increases. */
1388                 send_udp_probe_packet(n, n->maxmtu);
1389
1390                 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU) {
1391                         send_udp_probe_packet(n, n->maxmtu + 1);
1392                 }
1393
1394                 n->mtuprobes--;
1395         } else {
1396                 /* Before initial discovery begins, set maxmtu to the most likely value.
1397                    If it's underestimated, we will correct it after initial discovery. */
1398                 if(n->mtuprobes == 0) {
1399                         n->maxmtu = choose_initial_maxmtu(n);
1400                 }
1401
1402                 for(;;) {
1403                         /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1404                            but it will typically increase convergence time in the no-loss case. */
1405                         const length_t probes_per_cycle = 8;
1406
1407                         /* This magic value was determined using math simulations.
1408                            It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1409                            Since 1407 is just below the range of tinc MTUs over typical networks,
1410                            this fine-tuning allows tinc to cover a lot of ground very quickly.
1411                            This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1412                            then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1413                            if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1414                         const float multiplier = (n->maxmtu == MTU) ? 0.97f : 1.0f;
1415
1416                         const float cycle_position = (float) probes_per_cycle - (float)(n->mtuprobes % probes_per_cycle) - 1.0f;
1417                         const length_t minmtu = MAX(n->minmtu, MINMTU);
1418                         const float interval = (float)(n->maxmtu - minmtu);
1419
1420                         length_t offset = 0;
1421
1422                         /* powf can be underflowed if n->maxmtu is less than 512 due to the minmtu MAX bound */
1423                         if(interval > 0) {
1424                                 /* The core of the discovery algorithm is this exponential.
1425                                         It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1426                                         This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1427                                         are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1428                                         on the precise MTU as we are approaching it.
1429                                         The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1430                                         reply per cycle so that we can make progress. */
1431                                 offset = lrintf(powf(interval, multiplier * cycle_position / (float)(probes_per_cycle - 1)));
1432                         }
1433
1434                         length_t maxmtu = n->maxmtu;
1435                         send_udp_probe_packet(n, minmtu + offset);
1436
1437                         /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1438                            In that case, we recalculate with the new maxmtu and try again. */
1439                         if(n->mtuprobes < 0 || maxmtu == n->maxmtu) {
1440                                 break;
1441                         }
1442                 }
1443
1444                 if(n->mtuprobes >= 0) {
1445                         n->mtuprobes++;
1446                 }
1447         }
1448 }
1449
1450 /* These functions try to establish a tunnel to a node (or its relay) so that
1451    packets can be sent (e.g. exchange keys).
1452    If a tunnel is already established, it tries to improve it (e.g. by trying
1453    to establish a UDP tunnel instead of TCP).  This function makes no
1454    guarantees - it is up to the caller to check the node's state to figure out
1455    if TCP and/or UDP is usable.  By calling this function repeatedly, the
1456    tunnel is gradually improved until we hit the wall imposed by the underlying
1457    network environment.  It is recommended to call this function every time a
1458    packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1459    improving as packets flow, and then gracefully downgrades itself as it goes
1460    idle.
1461 */
1462
1463 static void try_tx_sptps(node_t *n, bool mtu) {
1464         /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1465            messages anyway, so there's no need for SPTPS at all. */
1466
1467         if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY)) {
1468                 return;
1469         }
1470
1471         /* Otherwise, try to do SPTPS authentication with n if necessary. */
1472
1473         try_sptps(n);
1474
1475         /* Do we need to statically relay packets? */
1476
1477         node_t *via = (n->via == myself) ? n->nexthop : n->via;
1478
1479         /* If we do have a static relay, try everything with that one instead, if it supports relaying. */
1480
1481         if(via != n) {
1482                 if((via->options >> 24) < 4) {
1483                         return;
1484                 }
1485
1486                 try_tx(via, mtu);
1487                 return;
1488         }
1489
1490         /* Otherwise, try to establish UDP connectivity. */
1491
1492         try_udp(n);
1493
1494         if(mtu) {
1495                 try_mtu(n);
1496         }
1497
1498         /* If we don't have UDP connectivity (yet), we need to use a dynamic relay (nexthop)
1499            while we try to establish direct connectivity. */
1500
1501         if(!n->status.udp_confirmed && n != n->nexthop && (n->nexthop->options >> 24) >= 4) {
1502                 try_tx(n->nexthop, mtu);
1503         }
1504 }
1505
1506 static void try_tx_legacy(node_t *n, bool mtu) {
1507         /* Does he have our key? If not, send one. */
1508
1509         if(!n->status.validkey_in) {
1510                 send_ans_key(n);
1511         }
1512
1513         /* Check if we already have a key, or request one. */
1514
1515         if(!n->status.validkey) {
1516                 if(n->last_req_key + 10 <= now.tv_sec) {
1517                         send_req_key(n);
1518                         n->last_req_key = now.tv_sec;
1519                 }
1520
1521                 return;
1522         }
1523
1524         try_udp(n);
1525
1526         if(mtu) {
1527                 try_mtu(n);
1528         }
1529 }
1530
1531 void try_tx(node_t *n, bool mtu) {
1532         if(!n->status.reachable) {
1533                 return;
1534         }
1535
1536         if(n->status.sptps) {
1537                 try_tx_sptps(n, mtu);
1538         } else {
1539                 try_tx_legacy(n, mtu);
1540         }
1541 }
1542
1543 void send_packet(node_t *n, vpn_packet_t *packet) {
1544         // If it's for myself, write it to the tun/tap device.
1545
1546         if(n == myself) {
1547                 if(overwrite_mac) {
1548                         memcpy(DATA(packet), mymac.x, ETH_ALEN);
1549                         // Use an arbitrary fake source address.
1550                         memcpy(DATA(packet) + ETH_ALEN, DATA(packet), ETH_ALEN);
1551                         DATA(packet)[ETH_ALEN * 2 - 1] ^= 0xFF;
1552                 }
1553
1554                 n->out_packets++;
1555                 n->out_bytes += packet->len;
1556                 devops.write(packet);
1557                 return;
1558         }
1559
1560         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1561
1562         // If the node is not reachable, drop it.
1563
1564         if(!n->status.reachable) {
1565                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1566                 return;
1567         }
1568
1569         // Keep track of packet statistics.
1570
1571         n->out_packets++;
1572         n->out_bytes += packet->len;
1573
1574         // Check if it should be sent as an SPTPS packet.
1575
1576         if(n->status.sptps) {
1577                 send_sptps_packet(n, packet);
1578                 try_tx(n, true);
1579                 return;
1580         }
1581
1582         // Determine which node to actually send it to.
1583
1584         node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1585
1586         if(via != n) {
1587                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1588         }
1589
1590         // Try to send via UDP, unless TCP is forced.
1591
1592         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1593                 if(!send_tcppacket(via->connection, packet)) {
1594                         terminate_connection(via->connection, true);
1595                 }
1596
1597                 return;
1598         }
1599
1600         send_udppacket(via, packet);
1601         try_tx(via, true);
1602 }
1603
1604 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1605         // Always give ourself a copy of the packet.
1606         if(from != myself) {
1607                 send_packet(myself, packet);
1608         }
1609
1610         // In TunnelServer mode, do not forward broadcast packets.
1611         // The MST might not be valid and create loops.
1612         if(tunnelserver || broadcast_mode == BMODE_NONE) {
1613                 return;
1614         }
1615
1616         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1617                packet->len, from->name, from->hostname);
1618
1619         switch(broadcast_mode) {
1620         // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1621         // This guarantees all nodes receive the broadcast packet, and
1622         // usually distributes the sending of broadcast packets over all nodes.
1623         case BMODE_MST:
1624                 for list_each(connection_t, c, &connection_list)
1625                         if(c->edge && c->status.mst && c != from->nexthop->connection) {
1626                                 send_packet(c->node, packet);
1627                         }
1628
1629                 break;
1630
1631         // In direct mode, we send copies to each node we know of.
1632         // However, this only reaches nodes that can be reached in a single hop.
1633         // We don't have enough information to forward broadcast packets in this case.
1634         case BMODE_DIRECT:
1635                 if(from != myself) {
1636                         break;
1637                 }
1638
1639                 for splay_each(node_t, n, &node_tree)
1640                         if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n)) {
1641                                 send_packet(n, packet);
1642                         }
1643
1644                 break;
1645
1646         case BMODE_NONE:
1647         default:
1648                 break;
1649         }
1650 }
1651
1652 /* We got a packet from some IP address, but we don't know who sent it.  Try to
1653    verify the message authentication code against all active session keys.
1654    Since this is actually an expensive operation, we only do a full check once
1655    a minute, the rest of the time we only check against nodes for which we know
1656    an IP address that matches the one from the packet.  */
1657
1658 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1659         node_t *match = NULL;
1660         bool hard = false;
1661         static time_t last_hard_try = 0;
1662
1663         for splay_each(node_t, n, &node_tree) {
1664                 if(!n->status.reachable || n == myself) {
1665                         continue;
1666                 }
1667
1668                 if(!n->status.validkey_in && !(n->status.sptps && n->sptps.instate)) {
1669                         continue;
1670                 }
1671
1672                 bool soft = false;
1673
1674                 for splay_each(edge_t, e, &n->edge_tree) {
1675                         if(!e->reverse) {
1676                                 continue;
1677                         }
1678
1679                         if(!sockaddrcmp_noport(from, &e->reverse->address)) {
1680                                 soft = true;
1681                                 break;
1682                         }
1683                 }
1684
1685                 if(!soft) {
1686                         if(last_hard_try == now.tv_sec) {
1687                                 continue;
1688                         }
1689
1690                         hard = true;
1691                 }
1692
1693                 if(!try_mac(n, pkt)) {
1694                         continue;
1695                 }
1696
1697                 match = n;
1698                 break;
1699         }
1700
1701         if(hard) {
1702                 last_hard_try = now.tv_sec;
1703         }
1704
1705         return match;
1706 }
1707
1708 static void handle_incoming_vpn_packet(listen_socket_t *ls, vpn_packet_t *pkt, sockaddr_t *addr) {
1709         char *hostname;
1710         node_id_t nullid = {0};
1711         node_t *from, *to;
1712         bool direct = false;
1713
1714         sockaddrunmap(addr); /* Some braindead IPv6 implementations do stupid things. */
1715
1716         // Try to figure out who sent this packet.
1717
1718         node_t *n = lookup_node_udp(addr);
1719
1720         if(n && !n->status.udp_confirmed) {
1721                 n = NULL;        // Don't believe it if we don't have confirmation yet.
1722         }
1723
1724         if(!n) {
1725                 // It might be from a 1.1 node, which might have a source ID in the packet.
1726                 pkt->offset = 2 * sizeof(node_id_t);
1727                 from = lookup_node_id(SRCID(pkt));
1728
1729                 if(from && from->status.sptps && !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
1730                         if(sptps_verify_datagram(&from->sptps, DATA(pkt), pkt->len - 2 * sizeof(node_id_t))) {
1731                                 n = from;
1732                         } else {
1733                                 goto skip_harder;
1734                         }
1735                 }
1736         }
1737
1738         if(!n) {
1739                 pkt->offset = 0;
1740                 n = try_harder(addr, pkt);
1741         }
1742
1743 skip_harder:
1744
1745         if(!n) {
1746                 if(debug_level >= DEBUG_PROTOCOL) {
1747                         hostname = sockaddr2hostname(addr);
1748                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1749                         free(hostname);
1750                 }
1751
1752                 return;
1753         }
1754
1755         pkt->offset = 0;
1756
1757         if(n->status.sptps) {
1758                 bool relay_enabled = (n->options >> 24) >= 4;
1759
1760                 if(relay_enabled) {
1761                         pkt->offset = 2 * sizeof(node_id_t);
1762                         pkt->len -= pkt->offset;
1763                 }
1764
1765                 if(!relay_enabled || !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
1766                         direct = true;
1767                         from = n;
1768                         to = myself;
1769                 } else {
1770                         from = lookup_node_id(SRCID(pkt));
1771                         to = lookup_node_id(DSTID(pkt));
1772                 }
1773
1774                 if(!from || !to) {
1775                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1776                         return;
1777                 }
1778
1779                 if(!to->status.reachable) {
1780                         /* This can happen in the form of a race condition
1781                            if the node just became unreachable. */
1782                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Cannot relay packet from %s (%s) because the destination, %s (%s), is unreachable", from->name, from->hostname, to->name, to->hostname);
1783                         return;
1784                 }
1785
1786                 /* The packet is supposed to come from the originator or its static relay
1787                    (i.e. with no dynamic relays in between).
1788                    If it did not, "help" the static relay by sending it UDP info.
1789                    Note that we only do this if we're the destination or the static relay;
1790                    otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
1791
1792                 if(n != from->via && to->via == myself) {
1793                         send_udp_info(myself, from);
1794                 }
1795
1796                 /* If we're not the final recipient, relay the packet. */
1797
1798                 if(to != myself) {
1799                         send_sptps_data(to, from, 0, DATA(pkt), pkt->len);
1800                         try_tx(to, true);
1801                         return;
1802                 }
1803         } else {
1804                 direct = true;
1805                 from = n;
1806         }
1807
1808         if(!receive_udppacket(from, pkt)) {
1809                 return;
1810         }
1811
1812         n->sock = ls - listen_socket;
1813
1814         if(direct && sockaddrcmp(addr, &n->address)) {
1815                 update_node_udp(n, addr);
1816         }
1817
1818         /* If the packet went through a relay, help the sender find the appropriate MTU
1819            through the relay path. */
1820
1821         if(!direct) {
1822                 send_mtu_info(myself, n, MTU);
1823         }
1824 }
1825
1826 void handle_incoming_vpn_data(void *data, int flags) {
1827         (void)data;
1828         (void)flags;
1829         listen_socket_t *ls = data;
1830
1831 #ifdef HAVE_RECVMMSG
1832 #define MAX_MSG 64
1833         static ssize_t num = MAX_MSG;
1834         static vpn_packet_t pkt[MAX_MSG];
1835         static sockaddr_t addr[MAX_MSG];
1836         static struct mmsghdr msg[MAX_MSG];
1837         static struct iovec iov[MAX_MSG];
1838
1839         for(int i = 0; i < num; i++) {
1840                 pkt[i].offset = 0;
1841
1842                 iov[i] = (struct iovec) {
1843                         .iov_base = DATA(&pkt[i]),
1844                         .iov_len = MAXSIZE,
1845                 };
1846
1847                 msg[i].msg_hdr = (struct msghdr) {
1848                         .msg_name = &addr[i].sa,
1849                         .msg_namelen = sizeof(addr)[i],
1850                         .msg_iov = &iov[i],
1851                         .msg_iovlen = 1,
1852                 };
1853         }
1854
1855         num = recvmmsg(ls->udp.fd, msg, MAX_MSG, MSG_DONTWAIT, NULL);
1856
1857         if(num < 0) {
1858                 if(!sockwouldblock(sockerrno)) {
1859                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1860                 }
1861
1862                 return;
1863         }
1864
1865         for(int i = 0; i < num; i++) {
1866                 pkt[i].len = msg[i].msg_len;
1867
1868                 if(pkt[i].len <= 0 || pkt[i].len > MAXSIZE) {
1869                         continue;
1870                 }
1871
1872                 handle_incoming_vpn_packet(ls, &pkt[i], &addr[i]);
1873         }
1874
1875 #else
1876         vpn_packet_t pkt;
1877         sockaddr_t addr = {0};
1878         socklen_t addrlen = sizeof(addr);
1879
1880         pkt.offset = 0;
1881         ssize_t len = recvfrom(ls->udp.fd, (void *)DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1882
1883         if(len <= 0 || (size_t)len > MAXSIZE) {
1884                 if(!sockwouldblock(sockerrno)) {
1885                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1886                 }
1887
1888                 return;
1889         }
1890
1891         pkt.len = len;
1892
1893         handle_incoming_vpn_packet(ls, &pkt, &addr);
1894 #endif
1895 }
1896
1897 void handle_device_data(void *data, int flags) {
1898         (void)data;
1899         (void)flags;
1900         vpn_packet_t packet;
1901         packet.offset = DEFAULT_PACKET_OFFSET;
1902         packet.priority = 0;
1903         static int errors = 0;
1904
1905         if(devops.read(&packet)) {
1906                 errors = 0;
1907                 myself->in_packets++;
1908                 myself->in_bytes += packet.len;
1909                 route(myself, &packet);
1910         } else {
1911                 sleep_millis(errors * 50);
1912                 errors++;
1913
1914                 if(errors > 10) {
1915                         logger(DEBUG_ALWAYS, LOG_ERR, "Too many errors from %s, exiting!", device);
1916                         event_exit();
1917                 }
1918         }
1919 }