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