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(!n->status.validkey_in || !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 #ifndef DISABLE_LEGACY
 962         } else {
 963                 mtu -= digest_length(n->outdigest);
 964
 965                 /* Now it's tricky. We use CBC mode, so the length of the
 966                    encrypted payload must be a multiple of the blocksize. The
 967                    sequence number is also part of the encrypted payload, so we
 968                    must account for it after correcting for the blocksize.
 969                    Furthermore, the padding in the last block must be at least
 970                    1 byte. */
 971
 972                 length_t blocksize = cipher_blocksize(n->outcipher);
 973
 974                 if(blocksize > 1) {
 975                         mtu /= blocksize;
 976                         mtu *= blocksize;
 977                         mtu--;
 978                 }
 979
 980                 mtu -= 4; // seqno
 981 #endif
 982         }
 983
 984         if (mtu < 512) {
 985                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
 986                 return MTU;
 987         }
 988         if (mtu > MTU)
 989                 return MTU;
 990
 991         logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
 992         return mtu;
 993
 994 #else
 995
 996         return MTU;
 997
 998 #endif
 999 }
1000
1001 /* This function tries to determines the MTU of a node.
1002    By calling this function repeatedly, n->minmtu will be progressively
1003    increased, and at some point, n->mtu will be fixed to n->minmtu.  If the MTU
1004    is already fixed, this function checks if it can be increased.
1005 */
1006
1007 static void try_mtu(node_t *n) {
1008         if(!(n->options & OPTION_PMTU_DISCOVERY))
1009                 return;
1010
1011         if(udp_discovery && !n->status.udp_confirmed) {
1012                 n->maxrecentlen = 0;
1013                 n->mtuprobes = 0;
1014                 n->minmtu = 0;
1015                 n->maxmtu = MTU;
1016                 return;
1017         }
1018
1019         /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1020            mtuprobes ==    20: fix MTU, and go to -1
1021            mtuprobes ==    -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1022            mtuprobes ==-2..-3: send one maxmtu probe every second
1023            mtuprobes ==    -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1024
1025         struct timeval elapsed;
1026         timersub(&now, &n->mtu_ping_sent, &elapsed);
1027         if(n->mtuprobes >= 0) {
1028                 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333)
1029                         return;
1030         } else {
1031                 if(n->mtuprobes < -1) {
1032                         if(elapsed.tv_sec < 1)
1033                                 return;
1034                 } else {
1035                         if(elapsed.tv_sec < pinginterval)
1036                                 return;
1037                 }
1038         }
1039
1040         n->mtu_ping_sent = now;
1041
1042         try_fix_mtu(n);
1043
1044         if(n->mtuprobes < -3) {
1045                 /* We lost three MTU probes, restart discovery */
1046                 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1047                 n->mtuprobes = 0;
1048                 n->minmtu = 0;
1049         }
1050
1051         if(n->mtuprobes < 0) {
1052                 /* After the initial discovery, we only send one maxmtu and one
1053                    maxmtu+1 probe to detect PMTU increases. */
1054                 send_udp_probe_packet(n, n->maxmtu);
1055                 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU)
1056                         send_udp_probe_packet(n, n->maxmtu + 1);
1057                 n->mtuprobes--;
1058         } else {
1059                 /* Before initial discovery begins, set maxmtu to the most likely value.
1060                    If it's underestimated, we will correct it after initial discovery. */
1061                 if(n->mtuprobes == 0)
1062                         n->maxmtu = choose_initial_maxmtu(n);
1063
1064                 for (;;) {
1065                         /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1066                            but it will typically increase convergence time in the no-loss case. */
1067                         const length_t probes_per_cycle = 8;
1068
1069                         /* This magic value was determined using math simulations.
1070                            It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1071                            Since 1407 is just below the range of tinc MTUs over typical networks,
1072                            this fine-tuning allows tinc to cover a lot of ground very quickly.
1073                            This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1074                            then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1075                            if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1076                         const float multiplier = (n->maxmtu == MTU) ? 0.97 : 1;
1077
1078                         const float cycle_position = probes_per_cycle - (n->mtuprobes % probes_per_cycle) - 1;
1079                         const length_t minmtu = MAX(n->minmtu, 512);
1080                         const float interval = n->maxmtu - minmtu;
1081
1082                         /* The core of the discovery algorithm is this exponential.
1083                            It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1084                            This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1085                            are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1086                            on the precise MTU as we are approaching it.
1087                            The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1088                            reply per cycle so that we can make progress. */
1089                         const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
1090
1091                         length_t maxmtu = n->maxmtu;
1092                         send_udp_probe_packet(n, minmtu + offset);
1093                         /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1094                            In that case, we recalculate with the new maxmtu and try again. */
1095                         if(n->mtuprobes < 0 || maxmtu == n->maxmtu)
1096                                 break;
1097                 }
1098
1099                 if(n->mtuprobes >= 0)
1100                         n->mtuprobes++;
1101         }
1102 }
1103
1104 /* These functions try to establish a tunnel to a node (or its relay) so that
1105    packets can be sent (e.g. exchange keys).
1106    If a tunnel is already established, it tries to improve it (e.g. by trying
1107    to establish a UDP tunnel instead of TCP).  This function makes no
1108    guarantees - it is up to the caller to check the node's state to figure out
1109    if TCP and/or UDP is usable.  By calling this function repeatedly, the
1110    tunnel is gradually improved until we hit the wall imposed by the underlying
1111    network environment.  It is recommended to call this function every time a
1112    packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1113    improving as packets flow, and then gracefully downgrades itself as it goes
1114    idle.
1115 */
1116
1117 static void try_tx_sptps(node_t *n, bool mtu) {
1118         /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1119            messages anyway, so there's no need for SPTPS at all. */
1120
1121         if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY))
1122                 return;
1123
1124         /* Otherwise, try to do SPTPS authentication with n if necessary. */
1125
1126         try_sptps(n);
1127
1128         /* Do we need to statically relay packets? */
1129
1130         node_t *via = (n->via == myself) ? n->nexthop : n->via;
1131
1132         /* If the static relay doesn't support SPTPS, everything goes via TCP anyway. */
1133
1134         if((via->options >> 24) < 4)
1135                 return;
1136
1137         /* If we do have a static relay, try everything with that one instead. */
1138
1139         if(via != n)
1140                 try_tx_sptps(via, mtu);
1141
1142         /* Otherwise, try to establish UDP connectivity. */
1143
1144         try_udp(n);
1145         if(mtu)
1146                 try_mtu(n);
1147
1148         /* If we don't have UDP connectivity (yet), we need to use a dynamic relay (nexthop)
1149            while we try to establish direct connectivity. */
1150
1151         if(!n->status.udp_confirmed && n != n->nexthop && (n->nexthop->options >> 24) >= 4)
1152                 try_tx_sptps(n->nexthop, mtu);
1153 }
1154
1155 static void try_tx_legacy(node_t *n, bool mtu) {
1156         /* Does he have our key? If not, send one. */
1157
1158         if(!n->status.validkey_in)
1159                 send_ans_key(n);
1160
1161         /* Check if we already have a key, or request one. */
1162
1163         if(!n->status.validkey) {
1164                 if(n->last_req_key + 10 <= now.tv_sec) {
1165                         send_req_key(n);
1166                         n->last_req_key = now.tv_sec;
1167                 }
1168                 return;
1169         }
1170
1171         try_udp(n);
1172         if(mtu)
1173                 try_mtu(n);
1174 }
1175
1176 void try_tx(node_t *n, bool mtu) {
1177         if(n->status.sptps)
1178                 try_tx_sptps(n, mtu);
1179         else
1180                 try_tx_legacy(n, mtu);
1181 }
1182
1183 void send_packet(node_t *n, vpn_packet_t *packet) {
1184         // If it's for myself, write it to the tun/tap device.
1185
1186         if(n == myself) {
1187                 if(overwrite_mac)
1188                          memcpy(DATA(packet), mymac.x, ETH_ALEN);
1189                 n->out_packets++;
1190                 n->out_bytes += packet->len;
1191                 devops.write(packet);
1192                 return;
1193         }
1194
1195         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1196
1197         // If the node is not reachable, drop it.
1198
1199         if(!n->status.reachable) {
1200                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1201                 return;
1202         }
1203
1204         // Keep track of packet statistics.
1205
1206         n->out_packets++;
1207         n->out_bytes += packet->len;
1208
1209         // Check if it should be sent as an SPTPS packet.
1210
1211         if(n->status.sptps) {
1212                 send_sptps_packet(n, packet);
1213                 try_tx_sptps(n, true);
1214                 return;
1215         }
1216
1217         // Determine which node to actually send it to.
1218
1219         node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1220
1221         if(via != n)
1222                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1223
1224         // Try to send via UDP, unless TCP is forced.
1225
1226         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1227                 if(!send_tcppacket(via->connection, packet))
1228                         terminate_connection(via->connection, true);
1229                 return;
1230         }
1231
1232         send_udppacket(via, packet);
1233         try_tx_legacy(via, true);
1234 }
1235
1236 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1237         // Always give ourself a copy of the packet.
1238         if(from != myself)
1239                 send_packet(myself, packet);
1240
1241         // In TunnelServer mode, do not forward broadcast packets.
1242         // The MST might not be valid and create loops.
1243         if(tunnelserver || broadcast_mode == BMODE_NONE)
1244                 return;
1245
1246         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1247                            packet->len, from->name, from->hostname);
1248
1249         switch(broadcast_mode) {
1250                 // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1251                 // This guarantees all nodes receive the broadcast packet, and
1252                 // usually distributes the sending of broadcast packets over all nodes.
1253                 case BMODE_MST:
1254                         for list_each(connection_t, c, connection_list)
1255                                 if(c->edge && c->status.mst && c != from->nexthop->connection)
1256                                         send_packet(c->node, packet);
1257                         break;
1258
1259                 // In direct mode, we send copies to each node we know of.
1260                 // However, this only reaches nodes that can be reached in a single hop.
1261                 // We don't have enough information to forward broadcast packets in this case.
1262                 case BMODE_DIRECT:
1263                         if(from != myself)
1264                                 break;
1265
1266                         for splay_each(node_t, n, node_tree)
1267                                 if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
1268                                         send_packet(n, packet);
1269                         break;
1270
1271                 default:
1272                         break;
1273         }
1274 }
1275
1276 /* We got a packet from some IP address, but we don't know who sent it.  Try to
1277    verify the message authentication code against all active session keys.
1278    Since this is actually an expensive operation, we only do a full check once
1279    a minute, the rest of the time we only check against nodes for which we know
1280    an IP address that matches the one from the packet.  */
1281
1282 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1283         node_t *match = NULL;
1284         bool hard = false;
1285         static time_t last_hard_try = 0;
1286
1287         for splay_each(node_t, n, node_tree) {
1288                 if(!n->status.reachable || n == myself)
1289                         continue;
1290
1291                 if((n->status.sptps && !n->sptps.instate) || !n->status.validkey_in)
1292                         continue;
1293
1294                 bool soft = false;
1295
1296                 for splay_each(edge_t, e, n->edge_tree) {
1297                         if(!e->reverse)
1298                                 continue;
1299                         if(!sockaddrcmp_noport(from, &e->reverse->address)) {
1300                                 soft = true;
1301                                 break;
1302                         }
1303                 }
1304
1305                 if(!soft) {
1306                         if(last_hard_try == now.tv_sec)
1307                                 continue;
1308                         hard = true;
1309                 }
1310
1311                 if(!try_mac(n, pkt))
1312                         continue;
1313
1314                 match = n;
1315                 break;
1316         }
1317
1318         if(hard)
1319                 last_hard_try = now.tv_sec;
1320
1321         return match;
1322 }
1323
1324 void handle_incoming_vpn_data(void *data, int flags) {
1325         listen_socket_t *ls = data;
1326         vpn_packet_t pkt;
1327         char *hostname;
1328         node_id_t nullid = {};
1329         sockaddr_t addr = {};
1330         socklen_t addrlen = sizeof addr;
1331         node_t *from, *to;
1332         bool direct = false;
1333
1334         pkt.offset = 0;
1335         int len = recvfrom(ls->udp.fd, DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1336
1337         if(len <= 0 || len > MAXSIZE) {
1338                 if(!sockwouldblock(sockerrno))
1339                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1340                 return;
1341         }
1342
1343         pkt.len = len;
1344
1345         sockaddrunmap(&addr); /* Some braindead IPv6 implementations do stupid things. */
1346
1347         // Try to figure out who sent this packet.
1348
1349         node_t *n = lookup_node_udp(&addr);
1350
1351         if(n && !n->status.udp_confirmed)
1352                 n = NULL; // Don't believe it if we don't have confirmation yet.
1353
1354         if(!n) {
1355                 // It might be from a 1.1 node, which might have a source ID in the packet.
1356                 pkt.offset = 2 * sizeof(node_id_t);
1357                 from = lookup_node_id(SRCID(&pkt));
1358                 if(from && !memcmp(DSTID(&pkt), &nullid, sizeof nullid) && from->status.sptps) {
1359                         if(sptps_verify_datagram(&from->sptps, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t)))
1360                                 n = from;
1361                         else
1362                                 goto skip_harder;
1363                 }
1364         }
1365
1366         if(!n) {
1367                 pkt.offset = 0;
1368                 n = try_harder(&addr, &pkt);
1369         }
1370
1371 skip_harder:
1372         if(!n) {
1373                 if(debug_level >= DEBUG_PROTOCOL) {
1374                         hostname = sockaddr2hostname(&addr);
1375                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1376                         free(hostname);
1377                 }
1378                 return;
1379         }
1380
1381         if(n->status.sptps) {
1382                 pkt.offset = 2 * sizeof(node_id_t);
1383
1384                 if(!memcmp(DSTID(&pkt), &nullid, sizeof nullid)) {
1385                         direct = true;
1386                         from = n;
1387                         to = myself;
1388                 } else {
1389                         from = lookup_node_id(SRCID(&pkt));
1390                         to = lookup_node_id(DSTID(&pkt));
1391                 }
1392                 if(!from || !to) {
1393                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1394                         return;
1395                 }
1396
1397                 if(to != myself) {
1398                         send_sptps_data_priv(to, n, 0, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t));
1399                         try_tx_sptps(n, true);
1400                         return;
1401                 }
1402         } else {
1403                 direct = true;
1404                 from = n;
1405         }
1406
1407         pkt.offset = 0;
1408         if(!receive_udppacket(from, &pkt))
1409                 return;
1410
1411         n->sock = ls - listen_socket;
1412         if(direct && sockaddrcmp(&addr, &n->address))
1413                 update_node_udp(n, &addr);
1414 }
1415
1416 void handle_device_data(void *data, int flags) {
1417         vpn_packet_t packet;
1418         packet.offset = DEFAULT_PACKET_OFFSET;
1419         packet.priority = 0;
1420
1421         if(devops.read(&packet)) {
1422                 myself->in_packets++;
1423                 myself->in_bytes += packet.len;
1424                 route(myself, &packet);
1425         }
1426 }