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                         const size_t buflen = len + sizeof(to->id) + sizeof(from->id);
 966                         uint8_t *buf = alloca(buflen);
 967                         uint8_t *buf_ptr = buf;
 968                         memcpy(buf_ptr, &to->id, sizeof(to->id));
 969                         buf_ptr += sizeof(to->id);
 970                         memcpy(buf_ptr, &from->id, sizeof(from->id));
 971                         buf_ptr += sizeof(from->id);
 972                         memcpy(buf_ptr, data, len);
 973                         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);
 974                         return send_sptps_tcppacket(to->nexthop->connection, buf, buflen);
 975                 }
 976
 977                 char *buf = alloca(B64_SIZE(len));
 978                 b64encode_tinc(data, buf, len);
 979
 980                 /* If this is a handshake packet, use ANS_KEY instead of REQ_KEY, for two reasons:
 981                     - We don't want intermediate nodes to switch to UDP to relay these packets;
 982                     - ANS_KEY allows us to learn the reflexive UDP address. */
 983                 if(type == SPTPS_HANDSHAKE) {
 984                         to->incompression = myself->incompression;
 985                         return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
 986                 } else {
 987                         return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, SPTPS_PACKET, buf);
 988                 }
 989         }
 990
 991         size_t overhead = 0;
 992
 993         if(relay_supported) {
 994                 overhead += sizeof(to->id) + sizeof(from->id);
 995         }
 996
 997         char *buf = alloca(len + overhead);
 998         char *buf_ptr = buf;
 999
1000         if(relay_supported) {
1001                 if(direct) {
1002                         /* Inform the recipient that this packet was sent directly. */
1003                         node_id_t nullid = {0};
1004                         memcpy(buf_ptr, &nullid, sizeof(nullid));
1005                         buf_ptr += sizeof(nullid);
1006                 } else {
1007                         memcpy(buf_ptr, &to->id, sizeof(to->id));
1008                         buf_ptr += sizeof(to->id);
1009                 }
1010
1011                 memcpy(buf_ptr, &from->id, sizeof(from->id));
1012                 buf_ptr += sizeof(from->id);
1013
1014         }
1015
1016         /* 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 */
1017         memcpy(buf_ptr, data, len);
1018         buf_ptr += len;
1019
1020         const sockaddr_t *sa = NULL;
1021         size_t sock;
1022
1023         if(relay->status.send_locally) {
1024                 choose_local_address(relay, &sa, &sock);
1025         }
1026
1027         if(!sa) {
1028                 choose_udp_address(relay, &sa, &sock);
1029         }
1030
1031         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);
1032
1033         if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
1034                 if(sockmsgsize(sockerrno)) {
1035                         reduce_mtu(relay, (int)origlen - 1);
1036                 } else {
1037                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
1038                         return false;
1039                 }
1040         }
1041
1042         return true;
1043 }
1044
1045 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
1046         node_t *from = handle;
1047
1048         if(type == SPTPS_HANDSHAKE) {
1049                 if(!from->status.validkey) {
1050                         from->status.validkey = true;
1051                         from->status.waitingforkey = false;
1052                         logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) successful", from->name, from->hostname);
1053                 }
1054
1055                 return true;
1056         }
1057
1058         if(len > MTU) {
1059                 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
1060                 return false;
1061         }
1062
1063         vpn_packet_t inpkt;
1064         inpkt.offset = DEFAULT_PACKET_OFFSET;
1065         inpkt.priority = 0;
1066
1067         if(type == PKT_PROBE) {
1068                 if(!from->status.udppacket) {
1069                         logger(DEBUG_ALWAYS, LOG_ERR, "Got SPTPS PROBE packet from %s (%s) via TCP", from->name, from->hostname);
1070                         return false;
1071                 }
1072
1073                 inpkt.len = len;
1074                 memcpy(DATA(&inpkt), data, len);
1075
1076                 if(inpkt.len > from->maxrecentlen) {
1077                         from->maxrecentlen = inpkt.len;
1078                 }
1079
1080                 udp_probe_h(from, &inpkt, len);
1081                 return true;
1082         }
1083
1084         if(type & ~(PKT_COMPRESSED | PKT_MAC)) {
1085                 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
1086                 return false;
1087         }
1088
1089         /* Check if we have the headers we need */
1090         if(routing_mode != RMODE_ROUTER && !(type & PKT_MAC)) {
1091                 logger(DEBUG_TRAFFIC, LOG_ERR, "Received packet from %s (%s) without MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
1092                 return false;
1093         } else if(routing_mode == RMODE_ROUTER && (type & PKT_MAC)) {
1094                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Received packet from %s (%s) with MAC header (maybe Mode is not set correctly)", from->name, from->hostname);
1095         }
1096
1097         int offset = (type & PKT_MAC) ? 0 : 14;
1098
1099         if(type & PKT_COMPRESSED) {
1100                 length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
1101
1102                 if(!ulen) {
1103                         return false;
1104                 } else {
1105                         inpkt.len = ulen + offset;
1106                 }
1107
1108                 if(inpkt.len > MAXSIZE) {
1109                         abort();
1110                 }
1111         } else {
1112                 memcpy(DATA(&inpkt) + offset, data, len);
1113                 inpkt.len = len + offset;
1114         }
1115
1116         /* Generate the Ethernet packet type if necessary */
1117         if(offset) {
1118                 switch(DATA(&inpkt)[14] >> 4) {
1119                 case 4:
1120                         DATA(&inpkt)[12] = 0x08;
1121                         DATA(&inpkt)[13] = 0x00;
1122                         break;
1123
1124                 case 6:
1125                         DATA(&inpkt)[12] = 0x86;
1126                         DATA(&inpkt)[13] = 0xDD;
1127                         break;
1128
1129                 default:
1130                         logger(DEBUG_TRAFFIC, LOG_ERR,
1131                                "Unknown IP version %d while reading packet from %s (%s)",
1132                                DATA(&inpkt)[14] >> 4, from->name, from->hostname);
1133                         return false;
1134                 }
1135         }
1136
1137         if(from->status.udppacket && inpkt.len > from->maxrecentlen) {
1138                 from->maxrecentlen = inpkt.len;
1139         }
1140
1141         receive_packet(from, &inpkt);
1142         return true;
1143 }
1144
1145 // This function tries to get SPTPS keys, if they aren't already known.
1146 // 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.
1147 static void try_sptps(node_t *n) {
1148         if(n->status.validkey) {
1149                 return;
1150         }
1151
1152         logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
1153
1154         if(!n->status.waitingforkey) {
1155                 send_req_key(n);
1156         } else if(n->last_req_key + 10 < now.tv_sec) {
1157                 logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
1158                 sptps_stop(&n->sptps);
1159                 n->status.waitingforkey = false;
1160                 send_req_key(n);
1161         }
1162
1163         return;
1164 }
1165
1166 static void send_udp_probe_packet(node_t *n, size_t len) {
1167         vpn_packet_t packet;
1168
1169         if(len > sizeof(packet.data)) {
1170                 logger(DEBUG_TRAFFIC, LOG_INFO, "Truncating probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
1171                 len = sizeof(packet.data);
1172         }
1173
1174         packet.offset = DEFAULT_PACKET_OFFSET;
1175         memset(DATA(&packet), 0, 14);
1176         randomize(DATA(&packet) + 14, len - 14);
1177         packet.len = len;
1178         packet.priority = 0;
1179
1180         logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
1181
1182         send_udppacket(n, &packet);
1183 }
1184
1185 // This function tries to establish a UDP tunnel to a node so that packets can be sent.
1186 // If a tunnel is already established, it makes sure it stays up.
1187 // This function makes no guarantees - it is up to the caller to check the node's state to figure out if UDP is usable.
1188 static void try_udp(node_t *n) {
1189         if(!udp_discovery) {
1190                 return;
1191         }
1192
1193         /* Send gratuitous probe replies to 1.1 nodes. */
1194
1195         if((n->options >> 24) >= 3 && n->status.udp_confirmed) {
1196                 struct timeval ping_tx_elapsed;
1197                 timersub(&now, &n->udp_reply_sent, &ping_tx_elapsed);
1198
1199                 if(ping_tx_elapsed.tv_sec >= udp_discovery_keepalive_interval - 1) {
1200                         n->udp_reply_sent = now;
1201
1202                         if(n->maxrecentlen) {
1203                                 vpn_packet_t pkt;
1204                                 pkt.len = n->maxrecentlen;
1205                                 pkt.offset = DEFAULT_PACKET_OFFSET;
1206                                 memset(DATA(&pkt), 0, 14);
1207                                 randomize(DATA(&pkt) + 14, MIN_PROBE_SIZE - 14);
1208                                 send_udp_probe_reply(n, &pkt, pkt.len);
1209                                 n->maxrecentlen = 0;
1210                         }
1211                 }
1212         }
1213
1214         /* Probe request */
1215
1216         struct timeval ping_tx_elapsed;
1217         timersub(&now, &n->udp_ping_sent, &ping_tx_elapsed);
1218
1219         int interval = n->status.udp_confirmed
1220                        ? udp_discovery_keepalive_interval
1221                        : udp_discovery_interval;
1222
1223         if(ping_tx_elapsed.tv_sec >= interval) {
1224                 gettimeofday(&now, NULL);
1225                 n->udp_ping_sent = now; // a probe in flight
1226                 n->status.ping_sent = true;
1227                 send_udp_probe_packet(n, MIN_PROBE_SIZE);
1228
1229                 if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
1230                         n->status.send_locally = true;
1231                         send_udp_probe_packet(n, MIN_PROBE_SIZE);
1232                         n->status.send_locally = false;
1233                 }
1234         }
1235 }
1236
1237 static length_t choose_initial_maxmtu(node_t *n) {
1238 #ifdef IP_MTU
1239
1240         int sock = -1;
1241
1242         const sockaddr_t *sa = NULL;
1243         size_t sockindex;
1244         choose_udp_address(n, &sa, &sockindex);
1245
1246         if(!sa) {
1247                 return MTU;
1248         }
1249
1250         sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
1251
1252         if(sock < 0) {
1253                 logger(DEBUG_TRAFFIC, LOG_ERR, "Creating MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1254                 return MTU;
1255         }
1256
1257         if(connect(sock, &sa->sa, SALEN(sa->sa))) {
1258                 logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1259                 close(sock);
1260                 return MTU;
1261         }
1262
1263         int ip_mtu;
1264         socklen_t ip_mtu_len = sizeof(ip_mtu);
1265
1266         if(getsockopt(sock, IPPROTO_IP, IP_MTU, (void *)&ip_mtu, &ip_mtu_len)) {
1267                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
1268                 close(sock);
1269                 return MTU;
1270         }
1271
1272         close(sock);
1273
1274         if(ip_mtu < MINMTU) {
1275                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
1276                 return MTU;
1277         }
1278
1279         /* getsockopt(IP_MTU) returns the MTU of the physical interface.
1280            We need to remove various overheads to get to the tinc MTU. */
1281         length_t mtu = ip_mtu;
1282         mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
1283         mtu -= 8; /* UDP */
1284
1285         if(n->status.sptps) {
1286                 mtu -= SPTPS_DATAGRAM_OVERHEAD;
1287
1288                 if((n->options >> 24) >= 4) {
1289                         mtu -= sizeof(node_id_t) + sizeof(node_id_t);
1290                 }
1291
1292 #ifndef DISABLE_LEGACY
1293         } else {
1294                 mtu -= digest_length(n->outdigest);
1295
1296                 /* Now it's tricky. We use CBC mode, so the length of the
1297                    encrypted payload must be a multiple of the blocksize. The
1298                    sequence number is also part of the encrypted payload, so we
1299                    must account for it after correcting for the blocksize.
1300                    Furthermore, the padding in the last block must be at least
1301                    1 byte. */
1302
1303                 length_t blocksize = cipher_blocksize(n->outcipher);
1304
1305                 if(blocksize > 1) {
1306                         mtu /= blocksize;
1307                         mtu *= blocksize;
1308                         mtu--;
1309                 }
1310
1311                 mtu -= 4; // seqno
1312 #endif
1313         }
1314
1315         if(mtu > MTU) {
1316                 return MTU;
1317         }
1318
1319         logger(DEBUG_TRAFFIC, LOG_INFO, "Using system-provided maximum tinc MTU for %s (%s): %hd", n->name, n->hostname, mtu);
1320         return mtu;
1321
1322 #else
1323         (void)n;
1324         return MTU;
1325 #endif
1326 }
1327
1328 /* This function tries to determines the MTU of a node.
1329    By calling this function repeatedly, n->minmtu will be progressively
1330    increased, and at some point, n->mtu will be fixed to n->minmtu.  If the MTU
1331    is already fixed, this function checks if it can be increased.
1332 */
1333
1334 static void try_mtu(node_t *n) {
1335         if(!(n->options & OPTION_PMTU_DISCOVERY)) {
1336                 return;
1337         }
1338
1339         if(udp_discovery && !n->status.udp_confirmed) {
1340                 n->maxrecentlen = 0;
1341                 n->mtuprobes = 0;
1342                 n->minmtu = 0;
1343                 n->maxmtu = MTU;
1344                 return;
1345         }
1346
1347         /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++
1348            mtuprobes ==    20: fix MTU, and go to -1
1349            mtuprobes ==    -1: send one maxmtu and one maxmtu+1 probe every pinginterval
1350            mtuprobes ==-2..-3: send one maxmtu probe every second
1351            mtuprobes ==    -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0 */
1352
1353         struct timeval elapsed;
1354         timersub(&now, &n->mtu_ping_sent, &elapsed);
1355
1356         if(n->mtuprobes >= 0) {
1357                 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333) {
1358                         return;
1359                 }
1360         } else {
1361                 if(n->mtuprobes < -1) {
1362                         if(elapsed.tv_sec < 1) {
1363                                 return;
1364                         }
1365                 } else {
1366                         if(elapsed.tv_sec < pinginterval) {
1367                                 return;
1368                         }
1369                 }
1370         }
1371
1372         n->mtu_ping_sent = now;
1373
1374         try_fix_mtu(n);
1375
1376         if(n->mtuprobes < -3) {
1377                 /* We lost three MTU probes, restart discovery */
1378                 logger(DEBUG_TRAFFIC, LOG_INFO, "Decrease in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
1379                 n->mtuprobes = 0;
1380                 n->minmtu = 0;
1381         }
1382
1383         if(n->mtuprobes < 0) {
1384                 /* After the initial discovery, we only send one maxmtu and one
1385                    maxmtu+1 probe to detect PMTU increases. */
1386                 send_udp_probe_packet(n, n->maxmtu);
1387
1388                 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU) {
1389                         send_udp_probe_packet(n, n->maxmtu + 1);
1390                 }
1391
1392                 n->mtuprobes--;
1393         } else {
1394                 /* Before initial discovery begins, set maxmtu to the most likely value.
1395                    If it's underestimated, we will correct it after initial discovery. */
1396                 if(n->mtuprobes == 0) {
1397                         n->maxmtu = choose_initial_maxmtu(n);
1398                 }
1399
1400                 for(;;) {
1401                         /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets,
1402                            but it will typically increase convergence time in the no-loss case. */
1403                         const length_t probes_per_cycle = 8;
1404
1405                         /* This magic value was determined using math simulations.
1406                            It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
1407                            Since 1407 is just below the range of tinc MTUs over typical networks,
1408                            this fine-tuning allows tinc to cover a lot of ground very quickly.
1409                            This fine-tuning is only valid for maxmtu = MTU; if maxmtu is smaller,
1410                            then it's better to use a multiplier of 1. Indeed, this leads to an interesting scenario
1411                            if choose_initial_maxmtu() returns the actual MTU value - it will get confirmed with one single probe. */
1412                         const float multiplier = (n->maxmtu == MTU) ? 0.97f : 1.0f;
1413
1414                         const float cycle_position = (float) probes_per_cycle - (float)(n->mtuprobes % probes_per_cycle) - 1.0f;
1415                         const length_t minmtu = MAX(n->minmtu, MINMTU);
1416                         const float interval = (float)(n->maxmtu - minmtu);
1417
1418                         length_t offset = 0;
1419
1420                         /* powf can be underflowed if n->maxmtu is less than 512 due to the minmtu MAX bound */
1421                         if(interval > 0) {
1422                                 /* The core of the discovery algorithm is this exponential.
1423                                         It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
1424                                         This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
1425                                         are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
1426                                         on the precise MTU as we are approaching it.
1427                                         The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
1428                                         reply per cycle so that we can make progress. */
1429                                 offset = lrintf(powf(interval, multiplier * cycle_position / (float)(probes_per_cycle - 1)));
1430                         }
1431
1432                         length_t maxmtu = n->maxmtu;
1433                         send_udp_probe_packet(n, minmtu + offset);
1434
1435                         /* If maxmtu changed, it means the probe was rejected by the system because it was too large.
1436                            In that case, we recalculate with the new maxmtu and try again. */
1437                         if(n->mtuprobes < 0 || maxmtu == n->maxmtu) {
1438                                 break;
1439                         }
1440                 }
1441
1442                 if(n->mtuprobes >= 0) {
1443                         n->mtuprobes++;
1444                 }
1445         }
1446 }
1447
1448 /* These functions try to establish a tunnel to a node (or its relay) so that
1449    packets can be sent (e.g. exchange keys).
1450    If a tunnel is already established, it tries to improve it (e.g. by trying
1451    to establish a UDP tunnel instead of TCP).  This function makes no
1452    guarantees - it is up to the caller to check the node's state to figure out
1453    if TCP and/or UDP is usable.  By calling this function repeatedly, the
1454    tunnel is gradually improved until we hit the wall imposed by the underlying
1455    network environment.  It is recommended to call this function every time a
1456    packet is sent (or intended to be sent) to a node, so that the tunnel keeps
1457    improving as packets flow, and then gracefully downgrades itself as it goes
1458    idle.
1459 */
1460
1461 static void try_tx_sptps(node_t *n, bool mtu) {
1462         /* If n is a TCP-only neighbor, we'll only use "cleartext" PACKET
1463            messages anyway, so there's no need for SPTPS at all. */
1464
1465         if(n->connection && ((myself->options | n->options) & OPTION_TCPONLY)) {
1466                 return;
1467         }
1468
1469         /* Otherwise, try to do SPTPS authentication with n if necessary. */
1470
1471         try_sptps(n);
1472
1473         /* Do we need to statically relay packets? */
1474
1475         node_t *via = (n->via == myself) ? n->nexthop : n->via;
1476
1477         /* If we do have a static relay, try everything with that one instead, if it supports relaying. */
1478
1479         if(via != n) {
1480                 if((via->options >> 24) < 4) {
1481                         return;
1482                 }
1483
1484                 try_tx(via, mtu);
1485                 return;
1486         }
1487
1488         /* Otherwise, try to establish UDP connectivity. */
1489
1490         try_udp(n);
1491
1492         if(mtu) {
1493                 try_mtu(n);
1494         }
1495
1496         /* If we don't have UDP connectivity (yet), we need to use a dynamic relay (nexthop)
1497            while we try to establish direct connectivity. */
1498
1499         if(!n->status.udp_confirmed && n != n->nexthop && (n->nexthop->options >> 24) >= 4) {
1500                 try_tx(n->nexthop, mtu);
1501         }
1502 }
1503
1504 static void try_tx_legacy(node_t *n, bool mtu) {
1505         /* Does he have our key? If not, send one. */
1506
1507         if(!n->status.validkey_in) {
1508                 send_ans_key(n);
1509         }
1510
1511         /* Check if we already have a key, or request one. */
1512
1513         if(!n->status.validkey) {
1514                 if(n->last_req_key + 10 <= now.tv_sec) {
1515                         send_req_key(n);
1516                         n->last_req_key = now.tv_sec;
1517                 }
1518
1519                 return;
1520         }
1521
1522         try_udp(n);
1523
1524         if(mtu) {
1525                 try_mtu(n);
1526         }
1527 }
1528
1529 void try_tx(node_t *n, bool mtu) {
1530         if(!n->status.reachable) {
1531                 return;
1532         }
1533
1534         if(n->status.sptps) {
1535                 try_tx_sptps(n, mtu);
1536         } else {
1537                 try_tx_legacy(n, mtu);
1538         }
1539 }
1540
1541 void send_packet(node_t *n, vpn_packet_t *packet) {
1542         // If it's for myself, write it to the tun/tap device.
1543
1544         if(n == myself) {
1545                 if(overwrite_mac) {
1546                         memcpy(DATA(packet), mymac.x, ETH_ALEN);
1547                         // Use an arbitrary fake source address.
1548                         memcpy(DATA(packet) + ETH_ALEN, DATA(packet), ETH_ALEN);
1549                         DATA(packet)[ETH_ALEN * 2 - 1] ^= 0xFF;
1550                 }
1551
1552                 n->out_packets++;
1553                 n->out_bytes += packet->len;
1554                 devops.write(packet);
1555                 return;
1556         }
1557
1558         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)", packet->len, n->name, n->hostname);
1559
1560         // If the node is not reachable, drop it.
1561
1562         if(!n->status.reachable) {
1563                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable", n->name, n->hostname);
1564                 return;
1565         }
1566
1567         // Keep track of packet statistics.
1568
1569         n->out_packets++;
1570         n->out_bytes += packet->len;
1571
1572         // Check if it should be sent as an SPTPS packet.
1573
1574         if(n->status.sptps) {
1575                 send_sptps_packet(n, packet);
1576                 try_tx(n, true);
1577                 return;
1578         }
1579
1580         // Determine which node to actually send it to.
1581
1582         node_t *via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
1583
1584         if(via != n) {
1585                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)", n->name, via->name, n->via->hostname);
1586         }
1587
1588         // Try to send via UDP, unless TCP is forced.
1589
1590         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
1591                 if(!send_tcppacket(via->connection, packet)) {
1592                         terminate_connection(via->connection, true);
1593                 }
1594
1595                 return;
1596         }
1597
1598         send_udppacket(via, packet);
1599         try_tx(via, true);
1600 }
1601
1602 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
1603         // Always give ourself a copy of the packet.
1604         if(from != myself) {
1605                 send_packet(myself, packet);
1606         }
1607
1608         // In TunnelServer mode, do not forward broadcast packets.
1609         // The MST might not be valid and create loops.
1610         if(tunnelserver || broadcast_mode == BMODE_NONE) {
1611                 return;
1612         }
1613
1614         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
1615                packet->len, from->name, from->hostname);
1616
1617         switch(broadcast_mode) {
1618         // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
1619         // This guarantees all nodes receive the broadcast packet, and
1620         // usually distributes the sending of broadcast packets over all nodes.
1621         case BMODE_MST:
1622                 for list_each(connection_t, c, &connection_list)
1623                         if(c->edge && c->status.mst && c != from->nexthop->connection) {
1624                                 send_packet(c->node, packet);
1625                         }
1626
1627                 break;
1628
1629         // In direct mode, we send copies to each node we know of.
1630         // However, this only reaches nodes that can be reached in a single hop.
1631         // We don't have enough information to forward broadcast packets in this case.
1632         case BMODE_DIRECT:
1633                 if(from != myself) {
1634                         break;
1635                 }
1636
1637                 for splay_each(node_t, n, &node_tree)
1638                         if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n)) {
1639                                 send_packet(n, packet);
1640                         }
1641
1642                 break;
1643
1644         default:
1645                 break;
1646         }
1647 }
1648
1649 /* We got a packet from some IP address, but we don't know who sent it.  Try to
1650    verify the message authentication code against all active session keys.
1651    Since this is actually an expensive operation, we only do a full check once
1652    a minute, the rest of the time we only check against nodes for which we know
1653    an IP address that matches the one from the packet.  */
1654
1655 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
1656         node_t *match = NULL;
1657         bool hard = false;
1658         static time_t last_hard_try = 0;
1659
1660         for splay_each(node_t, n, &node_tree) {
1661                 if(!n->status.reachable || n == myself) {
1662                         continue;
1663                 }
1664
1665                 if(!n->status.validkey_in && !(n->status.sptps && n->sptps.instate)) {
1666                         continue;
1667                 }
1668
1669                 bool soft = false;
1670
1671                 for splay_each(edge_t, e, &n->edge_tree) {
1672                         if(!e->reverse) {
1673                                 continue;
1674                         }
1675
1676                         if(!sockaddrcmp_noport(from, &e->reverse->address)) {
1677                                 soft = true;
1678                                 break;
1679                         }
1680                 }
1681
1682                 if(!soft) {
1683                         if(last_hard_try == now.tv_sec) {
1684                                 continue;
1685                         }
1686
1687                         hard = true;
1688                 }
1689
1690                 if(!try_mac(n, pkt)) {
1691                         continue;
1692                 }
1693
1694                 match = n;
1695                 break;
1696         }
1697
1698         if(hard) {
1699                 last_hard_try = now.tv_sec;
1700         }
1701
1702         return match;
1703 }
1704
1705 static void handle_incoming_vpn_packet(listen_socket_t *ls, vpn_packet_t *pkt, sockaddr_t *addr) {
1706         char *hostname;
1707         node_id_t nullid = {0};
1708         node_t *from, *to;
1709         bool direct = false;
1710
1711         sockaddrunmap(addr); /* Some braindead IPv6 implementations do stupid things. */
1712
1713         // Try to figure out who sent this packet.
1714
1715         node_t *n = lookup_node_udp(addr);
1716
1717         if(n && !n->status.udp_confirmed) {
1718                 n = NULL;        // Don't believe it if we don't have confirmation yet.
1719         }
1720
1721         if(!n) {
1722                 // It might be from a 1.1 node, which might have a source ID in the packet.
1723                 pkt->offset = 2 * sizeof(node_id_t);
1724                 from = lookup_node_id(SRCID(pkt));
1725
1726                 if(from && from->status.sptps && !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
1727                         if(sptps_verify_datagram(&from->sptps, DATA(pkt), pkt->len - 2 * sizeof(node_id_t))) {
1728                                 n = from;
1729                         } else {
1730                                 goto skip_harder;
1731                         }
1732                 }
1733         }
1734
1735         if(!n) {
1736                 pkt->offset = 0;
1737                 n = try_harder(addr, pkt);
1738         }
1739
1740 skip_harder:
1741
1742         if(!n) {
1743                 if(debug_level >= DEBUG_PROTOCOL) {
1744                         hostname = sockaddr2hostname(addr);
1745                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
1746                         free(hostname);
1747                 }
1748
1749                 return;
1750         }
1751
1752         pkt->offset = 0;
1753
1754         if(n->status.sptps) {
1755                 bool relay_enabled = (n->options >> 24) >= 4;
1756
1757                 if(relay_enabled) {
1758                         pkt->offset = 2 * sizeof(node_id_t);
1759                         pkt->len -= pkt->offset;
1760                 }
1761
1762                 if(!relay_enabled || !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
1763                         direct = true;
1764                         from = n;
1765                         to = myself;
1766                 } else {
1767                         from = lookup_node_id(SRCID(pkt));
1768                         to = lookup_node_id(DSTID(pkt));
1769                 }
1770
1771                 if(!from || !to) {
1772                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
1773                         return;
1774                 }
1775
1776                 if(!to->status.reachable) {
1777                         /* This can happen in the form of a race condition
1778                            if the node just became unreachable. */
1779                         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);
1780                         return;
1781                 }
1782
1783                 /* The packet is supposed to come from the originator or its static relay
1784                    (i.e. with no dynamic relays in between).
1785                    If it did not, "help" the static relay by sending it UDP info.
1786                    Note that we only do this if we're the destination or the static relay;
1787                    otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
1788
1789                 if(n != from->via && to->via == myself) {
1790                         send_udp_info(myself, from);
1791                 }
1792
1793                 /* If we're not the final recipient, relay the packet. */
1794
1795                 if(to != myself) {
1796                         send_sptps_data(to, from, 0, DATA(pkt), pkt->len);
1797                         try_tx(to, true);
1798                         return;
1799                 }
1800         } else {
1801                 direct = true;
1802                 from = n;
1803         }
1804
1805         if(!receive_udppacket(from, pkt)) {
1806                 return;
1807         }
1808
1809         n->sock = ls - listen_socket;
1810
1811         if(direct && sockaddrcmp(addr, &n->address)) {
1812                 update_node_udp(n, addr);
1813         }
1814
1815         /* If the packet went through a relay, help the sender find the appropriate MTU
1816            through the relay path. */
1817
1818         if(!direct) {
1819                 send_mtu_info(myself, n, MTU);
1820         }
1821 }
1822
1823 void handle_incoming_vpn_data(void *data, int flags) {
1824         (void)data;
1825         (void)flags;
1826         listen_socket_t *ls = data;
1827
1828 #ifdef HAVE_RECVMMSG
1829 #define MAX_MSG 64
1830         static ssize_t num = MAX_MSG;
1831         static vpn_packet_t pkt[MAX_MSG];
1832         static sockaddr_t addr[MAX_MSG];
1833         static struct mmsghdr msg[MAX_MSG];
1834         static struct iovec iov[MAX_MSG];
1835
1836         for(int i = 0; i < num; i++) {
1837                 pkt[i].offset = 0;
1838
1839                 iov[i] = (struct iovec) {
1840                         .iov_base = DATA(&pkt[i]),
1841                         .iov_len = MAXSIZE,
1842                 };
1843
1844                 msg[i].msg_hdr = (struct msghdr) {
1845                         .msg_name = &addr[i].sa,
1846                         .msg_namelen = sizeof(addr)[i],
1847                         .msg_iov = &iov[i],
1848                         .msg_iovlen = 1,
1849                 };
1850         }
1851
1852         num = recvmmsg(ls->udp.fd, msg, MAX_MSG, MSG_DONTWAIT, NULL);
1853
1854         if(num < 0) {
1855                 if(!sockwouldblock(sockerrno)) {
1856                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1857                 }
1858
1859                 return;
1860         }
1861
1862         for(int i = 0; i < num; i++) {
1863                 pkt[i].len = msg[i].msg_len;
1864
1865                 if(pkt[i].len <= 0 || pkt[i].len > MAXSIZE) {
1866                         continue;
1867                 }
1868
1869                 handle_incoming_vpn_packet(ls, &pkt[i], &addr[i]);
1870         }
1871
1872 #else
1873         vpn_packet_t pkt;
1874         sockaddr_t addr = {0};
1875         socklen_t addrlen = sizeof(addr);
1876
1877         pkt.offset = 0;
1878         ssize_t len = recvfrom(ls->udp.fd, (void *)DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
1879
1880         if(len <= 0 || (size_t)len > MAXSIZE) {
1881                 if(!sockwouldblock(sockerrno)) {
1882                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
1883                 }
1884
1885                 return;
1886         }
1887
1888         pkt.len = len;
1889
1890         handle_incoming_vpn_packet(ls, &pkt, &addr);
1891 #endif
1892 }
1893
1894 void handle_device_data(void *data, int flags) {
1895         (void)data;
1896         (void)flags;
1897         vpn_packet_t packet;
1898         packet.offset = DEFAULT_PACKET_OFFSET;
1899         packet.priority = 0;
1900         static int errors = 0;
1901
1902         if(devops.read(&packet)) {
1903                 errors = 0;
1904                 myself->in_packets++;
1905                 myself->in_bytes += packet.len;
1906                 route(myself, &packet);
1907         } else {
1908                 sleep_millis(errors * 50);
1909                 errors++;
1910
1911                 if(errors > 10) {
1912                         logger(DEBUG_ALWAYS, LOG_ERR, "Too many errors from %s, exiting!", device);
1913                         event_exit();
1914                 }
1915         }
1916 }