tinc-vpn.org Git - tinc/blob - src/net_packet.c

   1 /*
   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>
   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 #include <zlib.h>
  27 #endif
  28
  29 #ifdef HAVE_LZO
  30 #include LZO1X_H
  31 #endif
  32
  33 #include "cipher.h"
  34 #include "conf.h"
  35 #include "connection.h"
  36 #include "crypto.h"
  37 #include "digest.h"
  38 #include "device.h"
  39 #include "ethernet.h"
  40 #include "ipv4.h"
  41 #include "ipv6.h"
  42 #include "graph.h"
  43 #include "logger.h"
  44 #include "net.h"
  45 #include "netutl.h"
  46 #include "protocol.h"
  47 #include "route.h"
  48 #include "utils.h"
  49 #include "xalloc.h"
  50
  51 #ifndef MAX
  52 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  53 #endif
  54
  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
  59
  60 int keylifetime = 0;
  61 #ifdef HAVE_LZO
  62 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
  63 #endif
  64
  65 static void send_udppacket(node_t *, vpn_packet_t *);
  66
  67 unsigned replaywin = 16;
  68 bool localdiscovery = true;
  69 bool udp_discovery = true;
  70 int udp_discovery_keepalive_interval = 10;
  71 int udp_discovery_interval = 2;
  72 int udp_discovery_timeout = 30;
  73
  74 #define MAX_SEQNO 1073741824
  75
  76 static void try_fix_mtu(node_t *n) {
  77         if(n->mtuprobes < 0)
  78                 return;
  79
  80         if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) {
  81                 if(n->minmtu > n->maxmtu)
  82                         n->minmtu = n->maxmtu;
  83                 else
  84                         n->maxmtu = n->minmtu;
  85                 n->mtu = 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);
  87                 n->mtuprobes = -1;
  88         }
  89 }
  90
  91 static void udp_probe_timeout_handler(void *data) {
  92         node_t *n = data;
  93         if(!n->status.udp_confirmed)
  94                 return;
  95
  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;
  98         n->maxrecentlen = 0;
  99         n->mtuprobes = 0;
 100         n->minmtu = 0;
 101         n->maxmtu = MTU;
 102 }
 103
 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);
 107                 return;
 108         }
 109
 110         /* Type 2 probe replies were introduced in protocol 17.3 */
 111         if ((n->options >> 24) >= 3) {
 112                 DATA(packet)[0] = 2;
 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);
 117
 118         } else {
 119                 /* Legacy protocol: n won't understand type 2 probe replies. */
 120                 DATA(packet)[0] = 1;
 121                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 1 probe reply length %u to %s (%s)", len, n->name, n->hostname);
 122         }
 123
 124         /* Temporarily set udp_confirmed, so that the reply is sent
 125            back exactly the way it came in. */
 126
 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;
 131 }
 132
 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);
 137         }
 138
 139         if (DATA(packet)[0] == 2) {
 140                 // It's a type 2 probe reply, use the length field inside the packet
 141                 uint16_t len16;
 142                 memcpy(&len16, DATA(packet) + 1, 2);
 143                 len = ntohs(len16);
 144         }
 145
 146         logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s)", DATA(packet)[0], len, n->name, n->hostname);
 147
 148         /* It's a valid reply: now we know bidirectional communication
 149            is possible using the address and socket that the reply
 150            packet used. */
 151         n->status.udp_confirmed = true;
 152
 153         // Reset the UDP ping timer.
 154         n->udp_ping_sent = now;
 155
 156         if(udp_discovery) {
 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});
 159         }
 160
 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);
 163                 n->minmtu = len;
 164                 n->maxmtu = MTU;
 165                 /* Set mtuprobes to 1 so that try_mtu() doesn't reset maxmtu */
 166                 n->mtuprobes = 1;
 167                 return;
 168         } else if(n->mtuprobes < 0 && len == n->maxmtu) {
 169                 /* We got a maxmtu sized packet, confirming the PMTU is still valid. */
 170                 n->mtuprobes = -1;
 171                 n->mtu_ping_sent = now;
 172         }
 173
 174         /* If applicable, raise the minimum supported MTU */
 175
 176         if(n->minmtu < len) {
 177                 n->minmtu = len;
 178                 try_fix_mtu(n);
 179         }
 180 }
 181
 182 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
 183         if(level == 0) {
 184                 memcpy(dest, source, len);
 185                 return len;
 186         } else if(level == 10) {
 187 #ifdef HAVE_LZO
 188                 lzo_uint lzolen = MAXSIZE;
 189                 lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
 190                 return lzolen;
 191 #else
 192                 return -1;
 193 #endif
 194         } else if(level < 10) {
 195 #ifdef HAVE_ZLIB
 196                 unsigned long destlen = MAXSIZE;
 197                 if(compress2(dest, &destlen, source, len, level) == Z_OK)
 198                         return destlen;
 199                 else
 200 #endif
 201                         return -1;
 202         } else {
 203 #ifdef HAVE_LZO
 204                 lzo_uint lzolen = MAXSIZE;
 205                 lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
 206                 return lzolen;
 207 #else
 208                 return -1;
 209 #endif
 210         }
 211
 212         return -1;
 213 }
 214
 215 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
 216         if(level == 0) {
 217                 memcpy(dest, source, len);
 218                 return len;
 219         } else if(level > 9) {
 220 #ifdef HAVE_LZO
 221                 lzo_uint lzolen = MAXSIZE;
 222                 if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
 223                         return lzolen;
 224                 else
 225 #endif
 226                         return -1;
 227         }
 228 #ifdef HAVE_ZLIB
 229         else {
 230                 unsigned long destlen = MAXSIZE;
 231                 if(uncompress(dest, &destlen, source, len) == Z_OK)
 232                         return destlen;
 233                 else
 234                         return -1;
 235         }
 236 #endif
 237
 238         return -1;
 239 }
 240
 241 /* VPN packet I/O */
 242
 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);
 246
 247         n->in_packets++;
 248         n->in_bytes += packet->len;
 249
 250         route(n, packet);
 251 }
 252
 253 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
 254         if(n->status.sptps)
 255                 return sptps_verify_datagram(&n->sptps, DATA(inpkt), inpkt->len);
 256
 257 #ifdef DISABLE_LEGACY
 258         return false;
 259 #else
 260         if(!digest_active(n->indigest) || inpkt->len < sizeof(seqno_t) + digest_length(n->indigest))
 261                 return false;
 262
 263         return digest_verify(n->indigest, SEQNO(inpkt), inpkt->len - digest_length(n->indigest), DATA(inpkt) + inpkt->len - digest_length(n->indigest));
 264 #endif
 265 }
 266
 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 };
 270         int nextpkt = 0;
 271         size_t outlen;
 272         pkt1.offset = DEFAULT_PACKET_OFFSET;
 273         pkt2.offset = DEFAULT_PACKET_OFFSET;
 274
 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);
 279                                 send_req_key(n);
 280                         } else {
 281                                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
 282                         }
 283                         return false;
 284                 }
 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;
 289
 290                 if(!result) {
 291                         logger(DEBUG_TRAFFIC, LOG_ERR, "Got bad packet from %s (%s)", n->name, n->hostname);
 292                         return false;
 293                 }
 294                 return true;
 295         }
 296
 297 #ifdef DISABLE_LEGACY
 298         return false;
 299 #else
 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);
 302                 return false;
 303         }
 304
 305         /* Check packet length */
 306
 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);
 310                 return false;
 311         }
 312
 313         /* It's a legacy UDP packet, the data starts after the seqno */
 314
 315         inpkt->offset += sizeof(seqno_t);
 316
 317         /* Check the message authentication code */
 318
 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);
 323                         return false;
 324                 }
 325         }
 326         /* Decrypt the packet */
 327
 328         if(cipher_active(n->incipher)) {
 329                 vpn_packet_t *outpkt = pkt[nextpkt++];
 330                 outlen = MAXSIZE;
 331
 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);
 334                         return false;
 335                 }
 336
 337                 outpkt->len = outlen;
 338                 inpkt = outpkt;
 339         }
 340
 341         /* Check the sequence number */
 342
 343         seqno_t seqno;
 344         memcpy(&seqno, SEQNO(inpkt), sizeof seqno);
 345         seqno = ntohl(seqno);
 346         inpkt->len -= sizeof seqno;
 347
 348         if(replaywin) {
 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);
 354                                         return false;
 355                                 }
 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);
 363                                         return false;
 364                                 }
 365                         } else {
 366                                 for(int i = n->received_seqno + 1; i < seqno; i++)
 367                                         n->late[(i / 8) % replaywin] |= 1 << i % 8;
 368                         }
 369                 }
 370
 371                 n->farfuture = 0;
 372                 n->late[(seqno / 8) % replaywin] &= ~(1 << seqno % 8);
 373         }
 374
 375         if(seqno > n->received_seqno)
 376                 n->received_seqno = seqno;
 377
 378         n->received++;
 379
 380         if(n->received_seqno > MAX_SEQNO)
 381                 regenerate_key();
 382
 383         /* Decompress the packet */
 384
 385         length_t origlen = inpkt->len;
 386
 387         if(n->incompression) {
 388                 vpn_packet_t *outpkt = pkt[nextpkt++];
 389
 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);
 393                         return false;
 394                 }
 395
 396                 inpkt = outpkt;
 397
 398                 origlen -= MTU/64 + 20;
 399         }
 400
 401         if(inpkt->len > n->maxrecentlen)
 402                 n->maxrecentlen = inpkt->len;
 403
 404         inpkt->priority = 0;
 405
 406         if(!DATA(inpkt)[12] && !DATA(inpkt)[13])
 407                 udp_probe_h(n, inpkt, origlen);
 408         else
 409                 receive_packet(n, inpkt);
 410         return true;
 411 #endif
 412 }
 413
 414 void receive_tcppacket(connection_t *c, const char *buffer, int len) {
 415         vpn_packet_t outpkt;
 416         outpkt.offset = DEFAULT_PACKET_OFFSET;
 417
 418         if(len > sizeof outpkt.data - outpkt.offset)
 419                 return;
 420
 421         outpkt.len = len;
 422         if(c->options & OPTION_TCPONLY)
 423                 outpkt.priority = 0;
 424         else
 425                 outpkt.priority = -1;
 426         memcpy(DATA(&outpkt), buffer, len);
 427
 428         receive_packet(c->node, &outpkt);
 429 }
 430
 431 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
 432         if(!n->status.validkey && !n->connection)
 433                 return;
 434
 435         uint8_t type = 0;
 436         int offset = 0;
 437
 438         if(!(DATA(origpkt)[12] | DATA(origpkt)[13])) {
 439                 sptps_send_record(&n->sptps, PKT_PROBE, (char *)DATA(origpkt), origpkt->len);
 440                 return;
 441         }
 442
 443         if(routing_mode == RMODE_ROUTER)
 444                 offset = 14;
 445         else
 446                 type = PKT_MAC;
 447
 448         if(origpkt->len < offset)
 449                 return;
 450
 451         vpn_packet_t outpkt;
 452
 453         if(n->outcompression) {
 454                 outpkt.offset = 0;
 455                 int len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
 456                 if(len < 0) {
 457                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
 458                 } else if(len < origpkt->len - offset) {
 459                         outpkt.len = len + offset;
 460                         origpkt = &outpkt;
 461                         type |= PKT_COMPRESSED;
 462                 }
 463         }
 464
 465         /* If we have a direct metaconnection to n, and we can't use UDP, then
 466            don't bother with SPTPS and just use a "plaintext" PACKET message.
 467            We don't really care about end-to-end security since we're not
 468            sending the message through any intermediate nodes. */
 469         if(n->connection && origpkt->len > n->minmtu)
 470                 send_tcppacket(n->connection, origpkt);
 471         else
 472                 sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
 473         return;
 474 }
 475
 476 static void adapt_socket(const sockaddr_t *sa, int *sock) {
 477         /* Make sure we have a suitable socket for the chosen address */
 478         if(listen_socket[*sock].sa.sa.sa_family != sa->sa.sa_family) {
 479                 for(int i = 0; i < listen_sockets; i++) {
 480                         if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
 481                                 *sock = i;
 482                                 break;
 483                         }
 484                 }
 485         }
 486 }
 487
 488 static void choose_udp_address(const node_t *n, const sockaddr_t **sa, int *sock) {
 489         /* Latest guess */
 490         *sa = &n->address;
 491         *sock = n->sock;
 492
 493         /* If the UDP address is confirmed, use it. */
 494         if(n->status.udp_confirmed)
 495                 return;
 496
 497         /* Send every third packet to n->address; that could be set
 498            to the node's reflexive UDP address discovered during key
 499            exchange. */
 500
 501         static int x = 0;
 502         if(++x >= 3) {
 503                 x = 0;
 504                 return;
 505         }
 506
 507         /* Otherwise, address are found in edges to this node.
 508            So we pick a random edge and a random socket. */
 509
 510         int i = 0;
 511         int j = rand() % n->edge_tree->count;
 512         edge_t *candidate = NULL;
 513
 514         for splay_each(edge_t, e, n->edge_tree) {
 515                 if(i++ == j) {
 516                         candidate = e->reverse;
 517                         break;
 518                 }
 519         }
 520
 521         if(candidate) {
 522                 *sa = &candidate->address;
 523                 *sock = rand() % listen_sockets;
 524         }
 525
 526         adapt_socket(*sa, sock);
 527 }
 528
 529 static void choose_local_address(const node_t *n, const sockaddr_t **sa, int *sock) {
 530         *sa = NULL;
 531
 532         /* Pick one of the edges from this node at random, then use its local address. */
 533
 534         int i = 0;
 535         int j = rand() % n->edge_tree->count;
 536         edge_t *candidate = NULL;
 537
 538         for splay_each(edge_t, e, n->edge_tree) {
 539                 if(i++ == j) {
 540                         candidate = e;
 541                         break;
 542                 }
 543         }
 544
 545         if (candidate && candidate->local_address.sa.sa_family) {
 546                 *sa = &candidate->local_address;
 547                 *sock = rand() % listen_sockets;
 548                 adapt_socket(*sa, sock);
 549         }
 550 }
 551
 552 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
 553         vpn_packet_t pkt1, pkt2;
 554         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 555         vpn_packet_t *inpkt = origpkt;
 556         int nextpkt = 0;
 557         vpn_packet_t *outpkt;
 558         int origlen = origpkt->len;
 559         size_t outlen;
 560 #if defined(SOL_IP) && defined(IP_TOS)
 561         static int priority = 0;
 562         int origpriority = origpkt->priority;
 563 #endif
 564
 565         pkt1.offset = DEFAULT_PACKET_OFFSET;
 566         pkt2.offset = DEFAULT_PACKET_OFFSET;
 567
 568         if(!n->status.reachable) {
 569                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 570                 return;
 571         }
 572
 573         if(n->status.sptps)
 574                 return send_sptps_packet(n, origpkt);
 575
 576 #ifdef DISABLE_LEGACY
 577         return;
 578 #else
 579         /* Make sure we have a valid key */
 580
 581         if(!n->status.validkey) {
 582                 logger(DEBUG_TRAFFIC, LOG_INFO,
 583                                    "No valid key known yet for %s (%s), forwarding via TCP",
 584                                    n->name, n->hostname);
 585                 send_tcppacket(n->nexthop->connection, origpkt);
 586                 return;
 587         }
 588
 589         if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
 590                 logger(DEBUG_TRAFFIC, LOG_INFO,
 591                                 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
 592                                 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
 593
 594                 if(n != n->nexthop)
 595                         send_packet(n->nexthop, origpkt);
 596                 else
 597                         send_tcppacket(n->nexthop->connection, origpkt);
 598
 599                 return;
 600         }
 601
 602         /* Compress the packet */
 603
 604         if(n->outcompression) {
 605                 outpkt = pkt[nextpkt++];
 606
 607                 if((outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression)) < 0) {
 608                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
 609                                    n->name, n->hostname);
 610                         return;
 611                 }
 612
 613                 inpkt = outpkt;
 614         }
 615
 616         /* Add sequence number */
 617
 618         seqno_t seqno = htonl(++(n->sent_seqno));
 619         memcpy(SEQNO(inpkt), &seqno, sizeof seqno);
 620         inpkt->len += sizeof seqno;
 621
 622         /* Encrypt the packet */
 623
 624         if(cipher_active(n->outcipher)) {
 625                 outpkt = pkt[nextpkt++];
 626                 outlen = MAXSIZE;
 627
 628                 if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
 629                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
 630                         goto end;
 631                 }
 632
 633                 outpkt->len = outlen;
 634                 inpkt = outpkt;
 635         }
 636
 637         /* Add the message authentication code */
 638
 639         if(digest_active(n->outdigest)) {
 640                 if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
 641                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
 642                         goto end;
 643                 }
 644
 645                 inpkt->len += digest_length(n->outdigest);
 646         }
 647
 648         /* Send the packet */
 649
 650         const sockaddr_t *sa = NULL;
 651         int sock;
 652
 653         if(n->status.send_locally)
 654                 choose_local_address(n, &sa, &sock);
 655         if(!sa)
 656                 choose_udp_address(n, &sa, &sock);
 657
 658 #if defined(SOL_IP) && defined(IP_TOS)
 659         if(priorityinheritance && origpriority != priority
 660            && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
 661                 priority = origpriority;
 662                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
 663                 if(setsockopt(listen_socket[n->sock].udp.fd, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
 664                         logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
 665         }
 666 #endif
 667
 668         if(sendto(listen_socket[sock].udp.fd, SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 669                 if(sockmsgsize(sockerrno)) {
 670                         if(n->maxmtu >= origlen)
 671                                 n->maxmtu = origlen - 1;
 672                         if(n->mtu >= origlen)
 673                                 n->mtu = origlen - 1;
 674                         try_fix_mtu(n);
 675                 } else
 676                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
 677         }
 678
 679 end:
 680         origpkt->len = origlen;
 681 #endif
 682 }
 683
 684 static bool send_sptps_data_priv(node_t *to, node_t *from, int type, const void *data, size_t len) {
 685         node_t *relay = (to->via != myself && (type == PKT_PROBE || (len - SPTPS_DATAGRAM_OVERHEAD) <= to->via->minmtu)) ? to->via : to->nexthop;
 686         bool direct = from == myself && to == relay;
 687         bool relay_supported = (relay->options >> 24) >= 4;
 688         bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
 689
 690         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, this is a relay packet that the other node cannot understand, or this packet is larger than the MTU.
 691            TODO: When relaying, the original sender does not know the end-to-end PMTU (it only knows the PMTU of the first hop).
 692                  This can lead to scenarios where large packets are sent over UDP to relay, but then relay has no choice but fall back to TCP. */
 693
 694         if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) {
 695                 char buf[len * 4 / 3 + 5];
 696                 b64encode(data, buf, len);
 697                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
 698                    to ensure we get to learn the reflexive UDP address. */
 699                 if(from == myself && !to->status.validkey) {
 700                         to->incompression = myself->incompression;
 701                         return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
 702                 } else {
 703                         return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, REQ_SPTPS, buf);
 704                 }
 705         }
 706
 707         size_t overhead = 0;
 708         if(relay_supported) overhead += sizeof to->id + sizeof from->id;
 709         char buf[len + overhead]; char* buf_ptr = buf;
 710         if(relay_supported) {
 711                 if(direct) {
 712                         /* Inform the recipient that this packet was sent directly. */
 713                         node_id_t nullid = {};
 714                         memcpy(buf_ptr, &nullid, sizeof nullid); buf_ptr += sizeof nullid;
 715                 } else {
 716                         memcpy(buf_ptr, &to->id, sizeof to->id); buf_ptr += sizeof to->id;
 717                 }
 718                 memcpy(buf_ptr, &from->id, sizeof from->id); buf_ptr += sizeof from->id;
 719
 720         }
 721         /* TODO: if this copy turns out to be a performance concern, change sptps_send_record() to add some "pre-padding" to the buffer and use that instead */
 722         memcpy(buf_ptr, data, len); buf_ptr += len;
 723
 724         const sockaddr_t *sa = NULL;
 725         int sock;
 726         if(relay->status.send_locally)
 727                 choose_local_address(relay, &sa, &sock);
 728         if(!sa)
 729                 choose_udp_address(relay, &sa, &sock);
 730         logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet from %s (%s) to %s (%s) via %s (%s)", from->name, from->hostname, to->name, to->hostname, relay->name, relay->hostname);
 731         if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 732                 if(sockmsgsize(sockerrno)) {
 733                         // Compensate for SPTPS overhead
 734                         len -= SPTPS_DATAGRAM_OVERHEAD;
 735                         if(relay->maxmtu >= len)
 736                                 relay->maxmtu = len - 1;
 737                         if(relay->mtu >= len)
 738                                 relay->mtu = len - 1;
 739                         try_fix_mtu(relay);
 740                 } else {
 741                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
 742                         return false;
 743                 }
 744         }
 745
 746         return true;
 747 }
 748
 749 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
 750         return send_sptps_data_priv(handle, myself, type, data, len);
 751 }
 752
 753 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
 754         node_t *from = handle;
 755
 756         if(type == SPTPS_HANDSHAKE) {
 757                 if(!from->status.validkey) {
 758                         from->status.validkey = true;
 759                         from->status.waitingforkey = false;
 760                         logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
 761                 }
 762                 return true;
 763         }
 764
 765         if(len > MTU) {
 766                 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
 767                 return false;
 768         }
 769
 770         vpn_packet_t inpkt;
 771         inpkt.offset = DEFAULT_PACKET_OFFSET;
 772
 773         if(type == PKT_PROBE) {
 774                 if(!from->status.udppacket) {
 775                         logger(DEBUG_ALWAYS, LOG_ERR, "Got SPTPS PROBE packet from %s (%s) via TCP", from->name, from->hostname);
 776                         return false;
 777                 }
 778                 inpkt.len = len;
 779                 memcpy(DATA(&inpkt), data, len);
 780                 if(inpkt.len > from->maxrecentlen)
 781                         from->maxrecentlen = inpkt.len;
 782                 udp_probe_h(from, &inpkt, len);
 783                 return true;
 784         }
 785
 786         if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
 787                 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
 788                 return false;
 789         }
 790
 791         /* Check if we have the headers we need */
 792         if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
 793                 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
 794                 return false;
 795         } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
 796                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
 797         }
 798
 799         int offset = (type & PKT_MAC) ? 0 : 14;
 800         if(type & PKT_COMPRESSED) {
 801                 length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
 802                 if(ulen < 0) {
 803                         return false;
 804                 } else {
 805                         inpkt.len = ulen + offset;
 806                 }
 807                 if(inpkt.len > MAXSIZE)
 808                         abort();
 809         } else {
 810                 memcpy(DATA(&inpkt) + offset, data, len);
 811                 inpkt.len = len + offset;
 812         }
 813
 814         /* Generate the Ethernet packet type if necessary */
 815         if(offset) {
 816                 switch(DATA(&inpkt)[14] >> 4) {
 817                         case 4:
 818                                 DATA(&inpkt)[12] = 0x08;
 819                                 DATA(&inpkt)[13] = 0x00;
 820                                 break;
 821                         case 6:
 822                                 DATA(&inpkt)[12] = 0x86;
 823                                 DATA(&inpkt)[13] = 0xDD;
 824                                 break;
 825                         default:
 826                                 logger(DEBUG_TRAFFIC, LOG_ERR,
 827                                                    "Unknown IP version %d while reading packet from %s (%s)",
 828                                                    DATA(&inpkt)[14] >> 4, from->name, from->hostname);
 829                                 return false;
 830                 }
 831         }
 832
 833         if(from->status.udppacket && inpkt.len > from->maxrecentlen)
 834                 from->maxrecentlen = inpkt.len;
 835
 836         receive_packet(from, &inpkt);
 837         return true;
 838 }
 839
 840 // This function tries to get SPTPS keys, if they aren't already known.
 841 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if the keys are available.
 842 static void try_sptps(node_t *n) {
 843         if(n->status.validkey)
 844                 return;
 845
 846         logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
 847
 848         if(!n->status.waitingforkey)
 849                 send_req_key(n);
 850         else if(n->last_req_key + 10 < now.tv_sec) {
 851                 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
 852                 sptps_stop(&n->sptps);
 853                 n->status.waitingforkey = false;
 854                 send_req_key(n);
 855         }
 856
 857         return;
 858 }
 859
 860 static void send_udp_probe_packet(node_t *n, int len) {
 861         vpn_packet_t packet;
 862         packet.offset = DEFAULT_PACKET_OFFSET;
 863         memset(DATA(&packet), 0, 14);
 864         randomize(DATA(&packet) + 14, len - 14);
 865         packet.len = len;
 866         packet.priority = 0;
 867
 868         logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %d to %s (%s)", len, n->name, n->hostname);
 869
 870         send_udppacket(n, &packet);
 871 }
 872
 873 // This function tries to establish a UDP tunnel to a node so that packets can be sent.
 874 // If a tunnel is already established, it makes sure it stays up.
 875 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if UDP is usable.
 876 static void try_udp(node_t* n) {
 877         if(!udp_discovery)
 878                 return;
 879
 880         /* Send gratuitous probe replies to 1.1 nodes. */
 881
 882         if((n->options >> 24) >= 3 && n->status.udp_confirmed) {
 883                 struct timeval ping_tx_elapsed;
 884                 timersub(&now, &n->udp_reply_sent, &ping_tx_elapsed);
 885
 886                 if(ping_tx_elapsed.tv_sec >= udp_discovery_keepalive_interval - 1) {
 887                         n->udp_reply_sent = now;
 888                         if(n->maxrecentlen) {
 889                                 vpn_packet_t pkt;
 890                                 pkt.len = n->maxrecentlen;
 891                                 pkt.offset = DEFAULT_PACKET_OFFSET;
 892                                 memset(DATA(&pkt), 0, 14);
 893                                 randomize(DATA(&pkt) + 14, MIN_PROBE_SIZE - 14);
 894                                 send_udp_probe_reply(n, &pkt, pkt.len);
 895                                 n->maxrecentlen = 0;
 896                         }
 897                 }
 898         }
 899
 900         /* Probe request */
 901
 902         struct timeval ping_tx_elapsed;
 903         timersub(&now, &n->udp_ping_sent, &ping_tx_elapsed);
 904
 905         int interval = n->status.udp_confirmed ? udp_discovery_keepalive_interval : udp_discovery_interval;
 906
 907         if(ping_tx_elapsed.tv_sec >= interval) {
 908                 send_udp_probe_packet(n, MIN_PROBE_SIZE);
 909                 n->udp_ping_sent = now;
 910
 911                 if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
 912                         n->status.send_locally = true;
 913                         send_udp_probe_packet(n, MIN_PROBE_SIZE);
 914                         n->status.send_locally = false;
 915                 }
 916         }
 917 }
 918
 919 static length_t choose_initial_maxmtu(node_t *n) {
 920 #ifdef IP_MTU
 921
 922         int sock = -1;
 923
 924         const sockaddr_t *sa = NULL;
 925         int sockindex;
 926         choose_udp_address(n, &sa, &sockindex);
 927         if(!sa)
 928                 return MTU;
 929
 930         sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
 931         if(sock < 0) {
 932                 logger(DEBUG_TRAFFIC, LOG_ERR, "Creating MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
 933                 return MTU;
 934         }
 935
 936         if(connect(sock, &sa->sa, SALEN(sa->sa))) {
 937                 logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
 938                 close(sock);
 939                 return MTU;
 940         }
 941
 942         int ip_mtu;
 943         socklen_t ip_mtu_len = sizeof ip_mtu;
 944         if(getsockopt(sock, IPPROTO_IP, IP_MTU, &ip_mtu, &ip_mtu_len)) {
 945                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
 946                 close(sock);
 947                 return MTU;
 948         }
 949
 950         close(sock);
 951
 952         /* getsockopt(IP_MTU) returns the MTU of the physical interface.
 953            We need to remove various overheads to get to the tinc MTU. */
 954         length_t mtu = ip_mtu;
 955         mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
 956         mtu -= 8; /* UDP */
 957         if(n->status.sptps) {
 958                 mtu -= SPTPS_DATAGRAM_OVERHEAD;
 959                 if((n->options >> 24) >= 4)
 960                         mtu -= sizeof(node_id_t) + sizeof(node_id_t);
 961         } else {
 962                 mtu -= digest_length(n->outdigest);
 963
 964                 /* Now it's tricky. We use CBC mode, so the length of the
 965                    encrypted payload must be a multiple of the blocksize. The
 966                    sequence number is also part of the encrypted payload, so we
 967                    must account for it after correcting for the blocksize.
 968                    Furthermore, the padding in the last block must be at least
 969                    1 byte. */
 970
 971                 length_t blocksize = cipher_blocksize(n->outcipher);
 972
 973                 if(blocksize > 1) {
 974                         mtu /= blocksize;
 975                         mtu *= blocksize;
 976                         mtu--;
 977                 }
 978
 979                 mtu -= 4; // seqno
 980         }
 981
 982         if (mtu < 512) {
 983                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
 984                 return MTU;
 985         }
 986         if (mtu > MTU)
 987                 return MTU;
 988
 989         logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
 990         return mtu;
 991
 992 #else
 993
 994         return MTU;
 995
 996 #endif
 997 }
 998
 999 /* This function tries to determines the MTU of a node.
1000    By calling this function repeatedly, n->minmtu will be progressively
1001    increased, and at some point, n->mtu will be fixed to n->minmtu.  If the MTU
1002    is already fixed, this function checks if it can be increased.
1003 */
1004
1005 static void try_mtu(node_t *n) {
1006         if(!(n->options & OPTION_PMTU_DISCOVERY))
1007                 return;
1008
1009         if(udp_discovery && !n->status.udp_confirmed) {
1010                 n->maxrecentlen = 0;
1011                 n->mtuprobes = 0;
1012                 n->minmtu = 0;
1013                 n->maxmtu = MTU;
1014                 return;
1015         }
1016
1017         /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1018            mtuprobes ==    20: fix MTU, and go to -1
1019            mtuprobes ==    -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1020            mtuprobes ==-2..-3: send one maxmtu probe every second
1021            mtuprobes ==    -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1022
1023         struct timeval elapsed;
1024         timersub(&now, &n->mtu_ping_sent, &elapsed);
1025         if(n->mtuprobes >= 0) {
1026                 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333)
1027                         return;
1028         } else {
1029                 if(n->mtuprobes < -1) {
1030                         if(elapsed.tv_sec < 1)
1031                                 return;
1032                 } else {
1033                         if(elapsed.tv_sec < pinginterval)
1034                                 return;
1035                 }
1036         }
1037
1038         n->mtu_ping_sent = now;
1039
1040         try_fix_mtu(n);
1041
1042         if(n->mtuprobes < -3) {
1043                 /* We lost three MTU probes, restart discovery */
1044                 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1045                 n->mtuprobes = 0;
1046                 n->minmtu = 0;
1047         }
1048
1049         if(n->mtuprobes < 0) {
1050                 /* After the initial discovery, we only send one maxmtu and one
1051                    maxmtu+1 probe to detect PMTU increases. */
1052                 send_udp_probe_packet(n, n->maxmtu);
1053                 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU)
1054                         send_udp_probe_packet(n, n->maxmtu + 1);
1055                 n->mtuprobes--;
1056         } else {
1057                 /* Before initial discovery begins, set maxmtu to the most likely value.
1058                    If it's underestimated, we will correct it after initial discovery. */
1059                 if(n->mtuprobes == 0)
1060                         n->maxmtu = choose_initial_maxmtu(n);
1061
1062                 for (;;) {
1063                         /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1064                            but it will typically increase convergence time in the no-loss case. */
1065                         const length_t probes_per_cycle = 8;
1066
1067                         /* This magic value was determined using math simulations.
1068                            It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1069                            Since 1407 is just below the range of tinc MTUs over typical networks,
1070                            this fine-tuning allows tinc to cover a lot of ground very quickly.
1071                            This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1072                            then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1073                            if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1074                         const float multiplier = (n->maxmtu == MTU) ? 0.97 : 1;
1075
1076                         const float cycle_position = probes_per_cycle - (n->mtuprobes % probes_per_cycle) - 1;
1077                         const length_t minmtu = MAX(n->minmtu, 512);
1078                         const float interval = n->maxmtu - minmtu;
1079
1080                         /* The core of the discovery algorithm is this exponential.
1081                            It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1082                            This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1083                            are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1084                            on the precise MTU as we are approaching it.
1085                            The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1086                            reply per cycle so that we can make progress. */
1087                         const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
1088
1089                         length_t maxmtu = n->maxmtu;
1090                         send_udp_probe_packet(n, minmtu + offset);
1091                         /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1092                            In that case, we recalculate with the new maxmtu and try again. */
1093                         if(n->mtuprobes < 0 || maxmtu == n->maxmtu)
1094                                 break;
1095                 }
1096
1097                 if(n->mtuprobes >= 0)
1098                         n->mtuprobes++;
1099         }
1100 }
1101
1102 /* These functions try to establish a tunnel to a node (or its relay) so that
1103    packets can be sent (e.g. exchange keys).
1104    If a tunnel is already established, it tries to improve it (e.g. by trying
1105    to establish a UDP tunnel instead of TCP).  This function makes no
1106    guarantees - it is up to the caller to check the node's state to figure out
1107    if TCP and/or UDP is usable.  By calling this function repeatedly, the
1108    tunnel is gradually improved until we hit the wall imposed by the underlying
1109    network environment.  It is recommended to call this function every time a
1110    packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1111    improving as packets flow, and then gracefully downgrades itself as it goes
1112    idle.
1113 */
1114
1115 static void try_tx_sptps(node_t *n, bool mtu) {
1116         /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1117            messages anyway, so there's no need for SPTPS at all. */
1118
1119         if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY))
1120                 return;
1121
1122         /* Otherwise, try to do SPTPS authentication with n if necessary. */
1123
1124         try_sptps(n);
1125
1126         /* Do we need to relay packets? */
1127
1128         node_t *via = (n->via == myself) ? n->nexthop : n->via;
1129
1130         /* If the relay doesn't support SPTPS, everything goes via TCP anyway. */
1131
1132         if((via->options >> 24) < 4)
1133                 return;
1134
1135         /* If we do have a relay, try everything with that one instead. */
1136
1137         if(via != n)
1138                 return try_tx_sptps(via, mtu);
1139
1140         try_udp(n);
1141         if(mtu)
1142                 try_mtu(n);
1143 }
1144
1145 static void try_tx_legacy(node_t *n, bool mtu) {
1146         /* Does he have our key? If not, send one. */
1147
1148         if(!n->status.validkey_in)
1149                 send_ans_key(n);
1150
1151         /* Check if we already have a key, or request one. */
1152
1153         if(!n->status.validkey) {
1154                 if(n->last_req_key + 10 <= now.tv_sec) {
1155                         send_req_key(n);
1156                         n->last_req_key = now.tv_sec;
1157                 }
1158                 return;
1159         }
1160
1161         try_udp(n);
1162         if(mtu)
1163                 try_mtu(n);
1164 }
1165
1166 void try_tx(node_t *n, bool mtu) {
1167         if(n->status.sptps)
1168                 try_tx_sptps(n, mtu);
1169         else
1170                 try_tx_legacy(n, mtu);
1171 }
1172
1173 void send_packet(node_t *n, vpn_packet_t *packet) {
1174         // If it's for myself, write it to the tun/tap device.
1175
1176         if(n == myself) {
1177                 if(overwrite_mac)
1178                          memcpy(DATA(packet), mymac.x, ETH_ALEN);
1179                 n->out_packets++;
1180                 n->out_bytes += packet->len;
1181                 devops.write(packet);
1182                 return;
1183         }
1184
1185         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1186
1187         // If the node is not reachable, drop it.
1188
1189         if(!n->status.reachable) {
1190                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1191                 return;
1192         }
1193
1194         // Keep track of packet statistics.
1195
1196         n->out_packets++;
1197         n->out_bytes += packet->len;
1198
1199         // Check if it should be sent as an SPTPS packet.
1200
1201         if(n->status.sptps) {
1202                 send_sptps_packet(n, packet);
1203                 try_tx_sptps(n, true);
1204                 return;
1205         }
1206
1207         // Determine which node to actually send it to.
1208
1209         node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1210
1211         if(via != n)
1212                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1213
1214         // Try to send via UDP, unless TCP is forced.
1215
1216         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1217                 if(!send_tcppacket(via->connection, packet))
1218                         terminate_connection(via->connection, true);
1219                 return;
1220         }
1221
1222         send_udppacket(via, packet);
1223         try_tx_legacy(via, true);
1224 }
1225
1226 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1227         // Always give ourself a copy of the packet.
1228         if(from != myself)
1229                 send_packet(myself, packet);
1230
1231         // In TunnelServer mode, do not forward broadcast packets.
1232         // The MST might not be valid and create loops.
1233         if(tunnelserver || broadcast_mode == BMODE_NONE)
1234                 return;
1235
1236         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1237                            packet->len, from->name, from->hostname);
1238
1239         switch(broadcast_mode) {
1240                 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1241                 // This guarantees all nodes receive the broadcast packet, and
1242                 // usually distributes the sending of broadcast packets over all nodes.
1243                 case BMODE_MST:
1244                         for list_each(connection_t, c, connection_list)
1245                                 if(c->edge && c->status.mst && c != from->nexthop->connection)
1246                                         send_packet(c->node, packet);
1247                         break;
1248
1249                 // In direct mode, we send copies to each node we know of.
1250                 // However, this only reaches nodes that can be reached in a single hop.
1251                 // We don't have enough information to forward broadcast packets in this case.
1252                 case BMODE_DIRECT:
1253                         if(from != myself)
1254                                 break;
1255
1256                         for splay_each(node_t, n, node_tree)
1257                                 if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
1258                                         send_packet(n, packet);
1259                         break;
1260
1261                 default:
1262                         break;
1263         }
1264 }
1265
1266 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1267         node_t *n = NULL;
1268         bool hard = false;
1269         static time_t last_hard_try = 0;
1270
1271         for splay_each(edge_t, e, edge_weight_tree) {
1272                 if(!e->to->status.reachable || e->to == myself)
1273                         continue;
1274
1275                 if(sockaddrcmp_noport(from, &e->address)) {
1276                         if(last_hard_try == now.tv_sec)
1277                                 continue;
1278                         hard = true;
1279                 }
1280
1281                 if(!try_mac(e->to, pkt))
1282                         continue;
1283
1284                 n = e->to;
1285                 break;
1286         }
1287
1288         if(hard)
1289                 last_hard_try = now.tv_sec;
1290
1291         last_hard_try = now.tv_sec;
1292         return n;
1293 }
1294
1295 void handle_incoming_vpn_data(void *data, int flags) {
1296         listen_socket_t *ls = data;
1297         vpn_packet_t pkt;
1298         char *hostname;
1299         node_id_t nullid = {};
1300         sockaddr_t addr = {};
1301         socklen_t addrlen = sizeof addr;
1302         node_t *from, *to;
1303         bool direct = false;
1304
1305         pkt.offset = 0;
1306         int len = recvfrom(ls->udp.fd, DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1307
1308         if(len <= 0 || len > MAXSIZE) {
1309                 if(!sockwouldblock(sockerrno))
1310                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1311                 return;
1312         }
1313
1314         pkt.len = len;
1315
1316         sockaddrunmap(&addr); /* Some braindead IPv6 implementations do stupid things. */
1317
1318         // Try to figure out who sent this packet.
1319
1320         node_t *n = lookup_node_udp(&addr);
1321
1322         if(!n) {
1323                 // It might be from a 1.1 node, which might have a source ID in the packet.
1324                 pkt.offset = 2 * sizeof(node_id_t);
1325                 from = lookup_node_id(SRCID(&pkt));
1326                 if(from && !memcmp(DSTID(&pkt), &nullid, sizeof nullid) && from->status.sptps) {
1327                         if(sptps_verify_datagram(&from->sptps, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t)))
1328                                 n = from;
1329                         else
1330                                 goto skip_harder;
1331                 }
1332         }
1333
1334         if(!n) {
1335                 pkt.offset = 0;
1336                 n = try_harder(&addr, &pkt);
1337         }
1338
1339 skip_harder:
1340         if(!n) {
1341                 if(debug_level >= DEBUG_PROTOCOL) {
1342                         hostname = sockaddr2hostname(&addr);
1343                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1344                         free(hostname);
1345                 }
1346                 return;
1347         }
1348
1349         if(n->status.sptps) {
1350                 pkt.offset = 2 * sizeof(node_id_t);
1351
1352                 if(!memcmp(DSTID(&pkt), &nullid, sizeof nullid)) {
1353                         direct = true;
1354                         from = n;
1355                         to = myself;
1356                 } else {
1357                         from = lookup_node_id(SRCID(&pkt));
1358                         to = lookup_node_id(DSTID(&pkt));
1359                 }
1360                 if(!from || !to) {
1361                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1362                         return;
1363                 }
1364
1365                 if(to != myself) {
1366                         send_sptps_data_priv(to, n, 0, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t));
1367                         return;
1368                 }
1369         } else {
1370                 direct = true;
1371                 from = n;
1372         }
1373
1374         pkt.offset = 0;
1375         if(!receive_udppacket(from, &pkt))
1376                 return;
1377
1378         n->sock = ls - listen_socket;
1379         if(direct && sockaddrcmp(&addr, &n->address))
1380                 update_node_udp(n, &addr);
1381 }
1382
1383 void handle_device_data(void *data, int flags) {
1384         vpn_packet_t packet;
1385         packet.offset = DEFAULT_PACKET_OFFSET;
1386         packet.priority = 0;
1387
1388         if(devops.read(&packet)) {
1389                 myself->in_packets++;
1390                 myself->in_bytes += packet.len;
1391                 route(myself, &packet);
1392         }
1393 }