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-2021 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 #include <assert.h>
  29
  30 #endif
  31
  32 #ifdef HAVE_LZO
  33 #include LZO1X_H
  34 #endif
  35
  36 #ifdef LZ4_H
  37 #include LZ4_H
  38 #endif
  39
  40 #include "address_cache.h"
  41 #include "cipher.h"
  42 #include "conf.h"
  43 #include "connection.h"
  44 #include "compression.h"
  45 #include "crypto.h"
  46 #include "digest.h"
  47 #include "device.h"
  48 #include "ethernet.h"
  49 #include "ipv4.h"
  50 #include "ipv6.h"
  51 #include "logger.h"
  52 #include "net.h"
  53 #include "netutl.h"
  54 #include "protocol.h"
  55 #include "route.h"
  56 #include "utils.h"
  57
  58 /* The minimum size of a probe is 14 bytes, but since we normally use CBC mode
  59    encryption, we can add a few extra random bytes without increasing the
  60    resulting packet size. */
  61 #define MIN_PROBE_SIZE 18
  62
  63 int keylifetime = 0;
  64 #ifdef HAVE_LZO
  65 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
  66 #endif
  67
  68 #ifdef HAVE_LZ4_BUILTIN
  69 static LZ4_stream_t lz4_stream;
  70 #else
  71 static void *lz4_state = NULL;
  72 #endif /* HAVE_LZ4_BUILTIN */
  73
  74 static void send_udppacket(node_t *, vpn_packet_t *);
  75
  76 unsigned replaywin = 32;
  77 bool localdiscovery = true;
  78 bool udp_discovery = true;
  79 int udp_discovery_keepalive_interval = 10;
  80 int udp_discovery_interval = 2;
  81 int udp_discovery_timeout = 30;
  82
  83 #define MAX_SEQNO 1073741824
  84
  85 static void try_fix_mtu(node_t *n) {
  86         if(n->mtuprobes < 0) {
  87                 return;
  88         }
  89
  90         if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) {
  91                 if(n->minmtu > n->maxmtu) {
  92                         n->minmtu = n->maxmtu;
  93                 } else {
  94                         n->maxmtu = n->minmtu;
  95                 }
  96
  97                 n->mtu = n->minmtu;
  98                 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
  99                 n->mtuprobes = -1;
 100         }
 101 }
 102
 103 static void udp_probe_timeout_handler(void *data) {
 104         node_t *n = data;
 105
 106         if(!n->status.udp_confirmed) {
 107                 return;
 108         }
 109
 110         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);
 111         n->status.udp_confirmed = false;
 112         n->udp_ping_rtt = -1;
 113         n->maxrecentlen = 0;
 114         n->mtuprobes = 0;
 115         n->minmtu = 0;
 116         n->maxmtu = MTU;
 117 }
 118
 119 static void send_udp_probe_reply(node_t *n, vpn_packet_t *packet, length_t len) {
 120         if(!n->status.sptps && !n->status.validkey) {
 121                 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);
 122                 return;
 123         }
 124
 125         /* Type 2 probe replies were introduced in protocol 17.3 */
 126         if((n->options >> 24) >= 3) {
 127                 DATA(packet)[0] = 2;
 128                 uint16_t len16 = htons(len);
 129                 memcpy(DATA(packet) + 1, &len16, 2);
 130                 packet->len = MIN_PROBE_SIZE;
 131                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 2 probe reply length %u to %s (%s)", len, n->name, n->hostname);
 132
 133         } else {
 134                 /* Legacy protocol: n won't understand type 2 probe replies. */
 135                 DATA(packet)[0] = 1;
 136                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending type 1 probe reply length %u to %s (%s)", len, n->name, n->hostname);
 137         }
 138
 139         /* Temporarily set udp_confirmed, so that the reply is sent
 140            back exactly the way it came in. */
 141
 142         bool udp_confirmed = n->status.udp_confirmed;
 143         n->status.udp_confirmed = true;
 144         send_udppacket(n, packet);
 145         n->status.udp_confirmed = udp_confirmed;
 146 }
 147
 148 static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
 149         if(!DATA(packet)[0]) {
 150                 logger(DEBUG_TRAFFIC, LOG_INFO, "Got UDP probe request %d from %s (%s)", packet->len, n->name, n->hostname);
 151                 send_udp_probe_reply(n, packet, len);
 152                 return;
 153         }
 154
 155         if(DATA(packet)[0] == 2) {
 156                 // It's a type 2 probe reply, use the length field inside the packet
 157                 uint16_t len16;
 158                 memcpy(&len16, DATA(packet) + 1, 2);
 159                 len = ntohs(len16);
 160         }
 161
 162         if(n->status.ping_sent) {  // a probe in flight
 163                 gettimeofday(&now, NULL);
 164                 struct timeval rtt;
 165                 timersub(&now, &n->udp_ping_sent, &rtt);
 166                 n->udp_ping_rtt = (int)(rtt.tv_sec * 1000000 + rtt.tv_usec);
 167                 n->status.ping_sent = false;
 168                 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);
 169         } else {
 170                 logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s)", DATA(packet)[0], len, n->name, n->hostname);
 171         }
 172
 173         /* It's a valid reply: now we know bidirectional communication
 174            is possible using the address and socket that the reply
 175            packet used. */
 176         if(!n->status.udp_confirmed) {
 177                 n->status.udp_confirmed = true;
 178
 179                 if(!n->address_cache) {
 180                         n->address_cache = open_address_cache(n);
 181                 }
 182
 183                 reset_address_cache(n->address_cache, &n->address);
 184         }
 185
 186         // Reset the UDP ping timer.
 187
 188         if(udp_discovery) {
 189                 timeout_del(&n->udp_ping_timeout);
 190                 timeout_add(&n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timeval) {
 191                         udp_discovery_timeout, 0
 192                 });
 193         }
 194
 195         if(len > n->maxmtu) {
 196                 logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
 197                 n->minmtu = len;
 198                 n->maxmtu = MTU;
 199                 /* Set mtuprobes to 1 so that try_mtu() doesn't reset maxmtu */
 200                 n->mtuprobes = 1;
 201                 return;
 202         } else if(n->mtuprobes < 0 && len == n->maxmtu) {
 203                 /* We got a maxmtu sized packet, confirming the PMTU is still valid. */
 204                 n->mtuprobes = -1;
 205                 n->mtu_ping_sent = now;
 206         }
 207
 208         /* If applicable, raise the minimum supported MTU */
 209
 210         if(n->minmtu < len) {
 211                 n->minmtu = len;
 212                 try_fix_mtu(n);
 213         }
 214 }
 215
 216 #ifdef HAVE_LZ4
 217 static length_t compress_packet_lz4(uint8_t *dest, const uint8_t *source, length_t len) {
 218 #ifdef HAVE_LZ4_BUILTIN
 219         return LZ4_compress_fast_extState(&lz4_stream, (const char *) source, (char *) dest, len, MAXSIZE, 0);
 220 #else
 221
 222         /* @FIXME: Put this in a better place, and free() it too. */
 223         if(lz4_state == NULL) {
 224                 lz4_state = malloc(LZ4_sizeofState());
 225         }
 226
 227         if(lz4_state == NULL) {
 228                 logger(DEBUG_ALWAYS, LOG_ERR, "Failed to allocate lz4_state, error: %i", errno);
 229                 return 0;
 230         }
 231
 232         return LZ4_compress_fast_extState(lz4_state, (const char *) source, (char *) dest, len, MAXSIZE, 0);
 233 #endif /* HAVE_LZ4_BUILTIN */
 234 }
 235 #endif /* HAVE_LZ4 */
 236
 237 #ifdef HAVE_LZO
 238 static length_t compress_packet_lzo(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
 239         assert(level == COMPRESS_LZO_LO || level == COMPRESS_LZO_HI);
 240
 241         lzo_uint lzolen = MAXSIZE;
 242         int result;
 243
 244         if(level == COMPRESS_LZO_HI) {
 245                 result = lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
 246         } else { // level == COMPRESS_LZO_LO
 247                 result = lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
 248         }
 249
 250         if(result == LZO_E_OK) {
 251                 return lzolen;
 252         } else {
 253                 return 0;
 254         }
 255 }
 256 #endif
 257
 258 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
 259         switch(level) {
 260 #ifdef HAVE_LZ4
 261
 262         case COMPRESS_LZ4:
 263                 return compress_packet_lz4(dest, source, len);
 264 #endif
 265
 266 #ifdef HAVE_LZO
 267
 268         case COMPRESS_LZO_HI:
 269         case COMPRESS_LZO_LO:
 270                 return compress_packet_lzo(dest, source, len, level);
 271 #endif
 272 #ifdef HAVE_ZLIB
 273
 274         case COMPRESS_ZLIB_9:
 275         case COMPRESS_ZLIB_8:
 276         case COMPRESS_ZLIB_7:
 277         case COMPRESS_ZLIB_6:
 278         case COMPRESS_ZLIB_5:
 279         case COMPRESS_ZLIB_4:
 280         case COMPRESS_ZLIB_3:
 281         case COMPRESS_ZLIB_2:
 282         case COMPRESS_ZLIB_1: {
 283                 unsigned long dest_len = MAXSIZE;
 284
 285                 if(compress2(dest, &dest_len, source, len, level) == Z_OK) {
 286                         return dest_len;
 287                 } else {
 288                         return 0;
 289                 }
 290         }
 291
 292 #endif
 293
 294         case COMPRESS_NONE:
 295                 memcpy(dest, source, len);
 296                 return len;
 297
 298         default:
 299                 return 0;
 300         }
 301 }
 302
 303 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
 304         switch(level) {
 305 #ifdef HAVE_LZ4
 306
 307         case COMPRESS_LZ4:
 308                 return LZ4_decompress_safe((char *)source, (char *) dest, len, MAXSIZE);
 309
 310 #endif
 311 #ifdef HAVE_LZO
 312
 313         case COMPRESS_LZO_HI:
 314         case COMPRESS_LZO_LO: {
 315                 lzo_uint dst_len = MAXSIZE;
 316
 317                 if(lzo1x_decompress_safe(source, len, dest, &dst_len, NULL) == LZO_E_OK) {
 318                         return dst_len;
 319                 } else {
 320                         return 0;
 321                 }
 322         }
 323
 324 #endif
 325 #ifdef HAVE_ZLIB
 326
 327         case COMPRESS_ZLIB_9:
 328         case COMPRESS_ZLIB_8:
 329         case COMPRESS_ZLIB_7:
 330         case COMPRESS_ZLIB_6:
 331         case COMPRESS_ZLIB_5:
 332         case COMPRESS_ZLIB_4:
 333         case COMPRESS_ZLIB_3:
 334         case COMPRESS_ZLIB_2:
 335         case COMPRESS_ZLIB_1: {
 336                 unsigned long destlen = MAXSIZE;
 337                 static z_stream stream;
 338
 339                 if(stream.next_in) {
 340                         inflateReset(&stream);
 341                 } else {
 342                         inflateInit(&stream);
 343                 }
 344
 345                 stream.next_in = source;
 346                 stream.avail_in = len;
 347                 stream.next_out = dest;
 348                 stream.avail_out = destlen;
 349                 stream.total_out = 0;
 350
 351                 if(inflate(&stream, Z_FINISH) == Z_STREAM_END) {
 352                         return stream.total_out;
 353                 } else {
 354                         return 0;
 355                 }
 356         }
 357
 358 #endif
 359
 360         case COMPRESS_NONE:
 361                 memcpy(dest, source, len);
 362                 return len;
 363
 364         default:
 365                 return 0;
 366         }
 367 }
 368
 369 /* VPN packet I/O */
 370
 371 static void receive_packet(node_t *n, vpn_packet_t *packet) {
 372         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
 373                packet->len, n->name, n->hostname);
 374
 375         n->in_packets++;
 376         n->in_bytes += packet->len;
 377
 378         route(n, packet);
 379 }
 380
 381 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
 382         if(n->status.sptps) {
 383                 return sptps_verify_datagram(&n->sptps, DATA(inpkt), inpkt->len);
 384         }
 385
 386 #ifdef DISABLE_LEGACY
 387         return false;
 388 #else
 389
 390         if(!n->status.validkey_in || !digest_active(n->indigest) || (size_t)inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
 391                 return false;
 392         }
 393
 394         return digest_verify(n->indigest, inpkt->data, inpkt->len - digest_length(n->indigest), inpkt->data + inpkt->len - digest_length(n->indigest));
 395 #endif
 396 }
 397
 398 static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 399         if(n->status.sptps) {
 400                 if(!n->sptps.state) {
 401                         if(!n->status.waitingforkey) {
 402                                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
 403                                 send_req_key(n);
 404                         } else {
 405                                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
 406                         }
 407
 408                         return false;
 409                 }
 410
 411                 n->status.udppacket = true;
 412                 bool result = sptps_receive_data(&n->sptps, DATA(inpkt), inpkt->len);
 413                 n->status.udppacket = false;
 414
 415                 if(!result) {
 416                         /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
 417                            so let's restart SPTPS in case that helps. But don't do that too often
 418                            to prevent storms, and because that would make life a little too easy
 419                            for external attackers trying to DoS us. */
 420                         if(n->last_req_key < now.tv_sec - 10) {
 421                                 logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode raw TCP packet from %s (%s), restarting SPTPS", n->name, n->hostname);
 422                                 send_req_key(n);
 423                         }
 424
 425                         return false;
 426                 }
 427
 428                 return true;
 429         }
 430
 431 #ifdef DISABLE_LEGACY
 432         return false;
 433 #else
 434         vpn_packet_t pkt1, pkt2;
 435         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 436         int nextpkt = 0;
 437         size_t outlen;
 438         pkt1.offset = DEFAULT_PACKET_OFFSET;
 439         pkt2.offset = DEFAULT_PACKET_OFFSET;
 440
 441         if(!n->status.validkey_in) {
 442                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
 443                 return false;
 444         }
 445
 446         /* Check packet length */
 447
 448         if((size_t)inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
 449                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
 450                        n->name, n->hostname);
 451                 return false;
 452         }
 453
 454         /* It's a legacy UDP packet, the data starts after the seqno */
 455
 456         inpkt->offset += sizeof(seqno_t);
 457
 458         /* Check the message authentication code */
 459
 460         if(digest_active(n->indigest)) {
 461                 inpkt->len -= digest_length(n->indigest);
 462
 463                 if(!digest_verify(n->indigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
 464                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
 465                         return false;
 466                 }
 467         }
 468
 469         /* Decrypt the packet */
 470
 471         if(cipher_active(n->incipher)) {
 472                 vpn_packet_t *outpkt = pkt[nextpkt++];
 473                 outlen = MAXSIZE;
 474
 475                 if(!cipher_decrypt(n->incipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
 476                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
 477                         return false;
 478                 }
 479
 480                 outpkt->len = outlen;
 481                 inpkt = outpkt;
 482         }
 483
 484         /* Check the sequence number */
 485
 486         seqno_t seqno;
 487         memcpy(&seqno, SEQNO(inpkt), sizeof(seqno));
 488         seqno = ntohl(seqno);
 489         inpkt->len -= sizeof(seqno);
 490
 491         if(replaywin) {
 492                 if(seqno != n->received_seqno + 1) {
 493                         if(seqno >= n->received_seqno + replaywin * 8) {
 494                                 if(n->farfuture++ < replaywin >> 2) {
 495                                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
 496                                                n->name, n->hostname, seqno - n->received_seqno - 1, n->farfuture);
 497                                         return false;
 498                                 }
 499
 500                                 logger(DEBUG_TRAFFIC, LOG_WARNING, "Lost %d packets from %s (%s)",
 501                                        seqno - n->received_seqno - 1, n->name, n->hostname);
 502                                 memset(n->late, 0, replaywin);
 503                         } else if(seqno <= n->received_seqno) {
 504                                 if((n->received_seqno >= replaywin * 8 && seqno <= n->received_seqno - replaywin * 8) || !(n->late[(seqno / 8) % replaywin] & (1 << seqno % 8))) {
 505                                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
 506                                                n->name, n->hostname, seqno, n->received_seqno);
 507                                         return false;
 508                                 }
 509                         } else {
 510                                 for(seqno_t i = n->received_seqno + 1; i < seqno; i++) {
 511                                         n->late[(i / 8) % replaywin] |= 1 << i % 8;
 512                                 }
 513                         }
 514                 }
 515
 516                 n->farfuture = 0;
 517                 n->late[(seqno / 8) % replaywin] &= ~(1 << seqno % 8);
 518         }
 519
 520         if(seqno > n->received_seqno) {
 521                 n->received_seqno = seqno;
 522         }
 523
 524         n->received++;
 525
 526         if(n->received_seqno > MAX_SEQNO) {
 527                 regenerate_key();
 528         }
 529
 530         /* Decompress the packet */
 531
 532         length_t origlen = inpkt->len;
 533
 534         if(n->incompression != COMPRESS_NONE) {
 535                 vpn_packet_t *outpkt = pkt[nextpkt++];
 536
 537                 if(!(outpkt->len = uncompress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->incompression))) {
 538                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
 539                                n->name, n->hostname);
 540                         return false;
 541                 }
 542
 543                 inpkt = outpkt;
 544
 545                 if(origlen > MTU / 64 + 20) {
 546                         origlen -= MTU / 64 + 20;
 547                 } else {
 548                         origlen = 0;
 549                 }
 550         }
 551
 552         if(inpkt->len > n->maxrecentlen) {
 553                 n->maxrecentlen = inpkt->len;
 554         }
 555
 556         inpkt->priority = 0;
 557
 558         if(!DATA(inpkt)[12] && !DATA(inpkt)[13]) {
 559                 udp_probe_h(n, inpkt, origlen);
 560         } else {
 561                 receive_packet(n, inpkt);
 562         }
 563
 564         return true;
 565 #endif
 566 }
 567
 568 void receive_tcppacket(connection_t *c, const char *buffer, size_t len) {
 569         vpn_packet_t outpkt;
 570         outpkt.offset = DEFAULT_PACKET_OFFSET;
 571
 572         if(len > sizeof(outpkt.data) - outpkt.offset) {
 573                 return;
 574         }
 575
 576         outpkt.len = len;
 577
 578         if(c->options & OPTION_TCPONLY) {
 579                 outpkt.priority = 0;
 580         } else {
 581                 outpkt.priority = -1;
 582         }
 583
 584         memcpy(DATA(&outpkt), buffer, len);
 585
 586         receive_packet(c->node, &outpkt);
 587 }
 588
 589 bool receive_tcppacket_sptps(connection_t *c, const char *data, size_t len) {
 590         if(len < sizeof(node_id_t) + sizeof(node_id_t)) {
 591                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got too short TCP SPTPS packet from %s (%s)", c->name, c->hostname);
 592                 return false;
 593         }
 594
 595         node_t *to = lookup_node_id((node_id_t *)data);
 596         data += sizeof(node_id_t);
 597         len -= sizeof(node_id_t);
 598
 599         if(!to) {
 600                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown destination ID", c->name, c->hostname);
 601                 return true;
 602         }
 603
 604         node_t *from = lookup_node_id((node_id_t *)data);
 605         data += sizeof(node_id_t);
 606         len -= sizeof(node_id_t);
 607
 608         if(!from) {
 609                 logger(DEBUG_PROTOCOL, LOG_ERR, "Got TCP SPTPS packet from %s (%s) with unknown source ID", c->name, c->hostname);
 610                 return true;
 611         }
 612
 613         if(!to->status.reachable) {
 614                 /* This can happen in the form of a race condition
 615                    if the node just became unreachable. */
 616                 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);
 617                 return true;
 618         }
 619
 620         /* Help the sender reach us over UDP.
 621            Note that we only do this if we're the destination or the static relay;
 622            otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
 623         if(to->via == myself) {
 624                 send_udp_info(myself, from);
 625         }
 626
 627         /* If we're not the final recipient, relay the packet. */
 628
 629         if(to != myself) {
 630                 if(to->status.validkey) {
 631                         send_sptps_data(to, from, 0, data, len);
 632                 }
 633
 634                 try_tx(to, true);
 635                 return true;
 636         }
 637
 638         /* The packet is for us */
 639
 640         if(!sptps_receive_data(&from->sptps, data, len)) {
 641                 /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
 642                    so let's restart SPTPS in case that helps. But don't do that too often
 643                    to prevent storms. */
 644                 if(from->last_req_key < now.tv_sec - 10) {
 645                         logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode raw TCP packet from %s (%s), restarting SPTPS", from->name, from->hostname);
 646                         send_req_key(from);
 647                 }
 648
 649                 return true;
 650         }
 651
 652         send_mtu_info(myself, from, MTU);
 653         return true;
 654 }
 655
 656 static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
 657         if(!n->status.validkey && !n->connection) {
 658                 return;
 659         }
 660
 661         uint8_t type = 0;
 662         int offset = 0;
 663
 664         if((!(DATA(origpkt)[12] | DATA(origpkt)[13])) && (n->sptps.outstate))  {
 665                 sptps_send_record(&n->sptps, PKT_PROBE, DATA(origpkt), origpkt->len);
 666                 return;
 667         }
 668
 669         if(routing_mode == RMODE_ROUTER) {
 670                 offset = 14;
 671         } else {
 672                 type = PKT_MAC;
 673         }
 674
 675         if(origpkt->len < offset) {
 676                 return;
 677         }
 678
 679         vpn_packet_t outpkt;
 680
 681         if(n->outcompression != COMPRESS_NONE) {
 682                 outpkt.offset = 0;
 683                 length_t len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
 684
 685                 if(!len) {
 686                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
 687                 } else if(len < origpkt->len - offset) {
 688                         outpkt.len = len + offset;
 689                         origpkt = &outpkt;
 690                         type |= PKT_COMPRESSED;
 691                 }
 692         }
 693
 694         /* If we have a direct metaconnection to n, and we can't use UDP, then
 695            don't bother with SPTPS and just use a "plaintext" PACKET message.
 696            We don't really care about end-to-end security since we're not
 697            sending the message through any intermediate nodes. */
 698         if(n->connection && origpkt->len > n->minmtu) {
 699                 send_tcppacket(n->connection, origpkt);
 700         } else {
 701                 sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
 702         }
 703 }
 704
 705 static void adapt_socket(const sockaddr_t *sa, size_t *sock) {
 706         /* Make sure we have a suitable socket for the chosen address */
 707         if(listen_socket[*sock].sa.sa.sa_family != sa->sa.sa_family) {
 708                 for(int i = 0; i < listen_sockets; i++) {
 709                         if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
 710                                 *sock = i;
 711                                 break;
 712                         }
 713                 }
 714         }
 715 }
 716
 717 static void choose_udp_address(const node_t *n, const sockaddr_t **sa, size_t *sock) {
 718         /* Latest guess */
 719         *sa = &n->address;
 720         *sock = n->sock;
 721
 722         /* If the UDP address is confirmed, use it. */
 723         if(n->status.udp_confirmed) {
 724                 return;
 725         }
 726
 727         /* Send every third packet to n->address; that could be set
 728            to the node's reflexive UDP address discovered during key
 729            exchange. */
 730
 731         static int x = 0;
 732
 733         if(++x >= 3) {
 734                 x = 0;
 735                 return;
 736         }
 737
 738         /* Otherwise, address are found in edges to this node.
 739            So we pick a random edge and a random socket. */
 740
 741         unsigned int i = 0;
 742         unsigned int j = rand() % n->edge_tree.count;
 743         edge_t *candidate = NULL;
 744
 745         for splay_each(edge_t, e, &n->edge_tree) {
 746                 if(i++ == j) {
 747                         candidate = e->reverse;
 748                         break;
 749                 }
 750         }
 751
 752         if(candidate) {
 753                 *sa = &candidate->address;
 754                 *sock = rand() % listen_sockets;
 755         }
 756
 757         adapt_socket(*sa, sock);
 758 }
 759
 760 static void choose_local_address(const node_t *n, const sockaddr_t **sa, size_t *sock) {
 761         *sa = NULL;
 762
 763         /* Pick one of the edges from this node at random, then use its local address. */
 764
 765         unsigned int i = 0;
 766         unsigned int j = rand() % n->edge_tree.count;
 767         edge_t *candidate = NULL;
 768
 769         for splay_each(edge_t, e, &n->edge_tree) {
 770                 if(i++ == j) {
 771                         candidate = e;
 772                         break;
 773                 }
 774         }
 775
 776         if(candidate && candidate->local_address.sa.sa_family) {
 777                 *sa = &candidate->local_address;
 778                 *sock = rand() % listen_sockets;
 779                 adapt_socket(*sa, sock);
 780         }
 781 }
 782
 783 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
 784         if(!n->status.reachable) {
 785                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 786                 return;
 787         }
 788
 789         if(n->status.sptps) {
 790                 send_sptps_packet(n, origpkt);
 791                 return;
 792         }
 793
 794 #ifdef DISABLE_LEGACY
 795         return;
 796 #else
 797         vpn_packet_t pkt1, pkt2;
 798         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 799         vpn_packet_t *inpkt = origpkt;
 800         int nextpkt = 0;
 801         vpn_packet_t *outpkt;
 802         int origlen = origpkt->len;
 803         size_t outlen;
 804         int origpriority = origpkt->priority;
 805
 806         pkt1.offset = DEFAULT_PACKET_OFFSET;
 807         pkt2.offset = DEFAULT_PACKET_OFFSET;
 808
 809         /* Make sure we have a valid key */
 810
 811         if(!n->status.validkey) {
 812                 logger(DEBUG_TRAFFIC, LOG_INFO,
 813                        "No valid key known yet for %s (%s), forwarding via TCP",
 814                        n->name, n->hostname);
 815                 send_tcppacket(n->nexthop->connection, origpkt);
 816                 return;
 817         }
 818
 819         if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
 820                 logger(DEBUG_TRAFFIC, LOG_INFO,
 821                        "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
 822                        n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
 823
 824                 if(n != n->nexthop) {
 825                         send_packet(n->nexthop, origpkt);
 826                 } else {
 827                         send_tcppacket(n->nexthop->connection, origpkt);
 828                 }
 829
 830                 return;
 831         }
 832
 833         /* Compress the packet */
 834
 835         if(n->outcompression != COMPRESS_NONE) {
 836                 outpkt = pkt[nextpkt++];
 837
 838                 if(!(outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression))) {
 839                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
 840                                n->name, n->hostname);
 841                         return;
 842                 }
 843
 844                 inpkt = outpkt;
 845         }
 846
 847         /* Add sequence number */
 848
 849         seqno_t seqno = htonl(++(n->sent_seqno));
 850         memcpy(SEQNO(inpkt), &seqno, sizeof(seqno));
 851         inpkt->len += sizeof(seqno);
 852
 853         /* Encrypt the packet */
 854
 855         if(cipher_active(n->outcipher)) {
 856                 outpkt = pkt[nextpkt++];
 857                 outlen = MAXSIZE;
 858
 859                 if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
 860                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
 861                         goto end;
 862                 }
 863
 864                 outpkt->len = outlen;
 865                 inpkt = outpkt;
 866         }
 867
 868         /* Add the message authentication code */
 869
 870         if(digest_active(n->outdigest)) {
 871                 if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
 872                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
 873                         goto end;
 874                 }
 875
 876                 inpkt->len += digest_length(n->outdigest);
 877         }
 878
 879         /* Send the packet */
 880
 881         const sockaddr_t *sa = NULL;
 882         size_t sock;
 883
 884         if(n->status.send_locally) {
 885                 choose_local_address(n, &sa, &sock);
 886         }
 887
 888         if(!sa) {
 889                 choose_udp_address(n, &sa, &sock);
 890         }
 891
 892         if(priorityinheritance && origpriority != listen_socket[sock].priority) {
 893                 listen_socket[sock].priority = origpriority;
 894
 895                 switch(sa->sa.sa_family) {
 896 #if defined(IP_TOS)
 897
 898                 case AF_INET:
 899                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting IPv4 outgoing packet priority to %d", origpriority);
 900
 901                         if(setsockopt(listen_socket[sock].udp.fd, IPPROTO_IP, IP_TOS, (void *)&origpriority, sizeof(origpriority))) { /* SO_PRIORITY doesn't seem to work */
 902                                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
 903                         }
 904
 905                         break;
 906 #endif
 907 #if defined(IPV6_TCLASS)
 908
 909                 case AF_INET6:
 910                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting IPv6 outgoing packet priority to %d", origpriority);
 911
 912                         if(setsockopt(listen_socket[sock].udp.fd, IPPROTO_IPV6, IPV6_TCLASS, (void *)&origpriority, sizeof(origpriority))) { /* SO_PRIORITY doesn't seem to work */
 913                                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", sockstrerror(sockerrno));
 914                         }
 915
 916                         break;
 917 #endif
 918
 919                 default:
 920                         break;
 921                 }
 922         }
 923
 924         if(sendto(listen_socket[sock].udp.fd, (void *)SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 925                 if(sockmsgsize(sockerrno)) {
 926                         if(n->maxmtu >= origlen) {
 927                                 n->maxmtu = origlen - 1;
 928                         }
 929
 930                         if(n->mtu >= origlen) {
 931                                 n->mtu = origlen - 1;
 932                         }
 933
 934                         try_fix_mtu(n);
 935                 } else {
 936                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
 937                 }
 938         }
 939
 940 end:
 941         origpkt->len = origlen;
 942 #endif
 943 }
 944
 945 bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_t len) {
 946         node_t *relay = (to->via != myself && (type == PKT_PROBE || (len - SPTPS_DATAGRAM_OVERHEAD) <= to->via->minmtu)) ? to->via : to->nexthop;
 947         bool direct = from == myself && to == relay;
 948         bool relay_supported = (relay->options >> 24) >= 4;
 949         bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
 950
 951         /* 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. */
 952
 953         if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) {
 954                 if(type != SPTPS_HANDSHAKE && (to->nexthop->connection->options >> 24) >= 7) {
 955                         uint8_t buf[len + sizeof(to->id) + sizeof(from->id)];
 956                         uint8_t *buf_ptr = buf;
 957                         memcpy(buf_ptr, &to->id, sizeof(to->id));
 958                         buf_ptr += sizeof(to->id);
 959                         memcpy(buf_ptr, &from->id, sizeof(from->id));
 960                         buf_ptr += sizeof(from->id);
 961                         memcpy(buf_ptr, data, len);
 962                         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);
 963                         return send_sptps_tcppacket(to->nexthop->connection, buf, sizeof(buf));
 964                 }
 965
 966                 char buf[B64_SIZE(len)];
 967                 b64encode_tinc(data, buf, len);
 968
 969                 /* If this is a handshake packet, use ANS_KEY instead of REQ_KEY, for two reasons:
 970                     - We don't want intermediate nodes to switch to UDP to relay these packets;
 971                     - ANS_KEY allows us to learn the reflexive UDP address. */
 972                 if(type == SPTPS_HANDSHAKE) {
 973                         to->incompression = myself->incompression;
 974                         return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, from->name, to->name, buf, to->incompression);
 975                 } else {
 976                         return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, from->name, to->name, SPTPS_PACKET, buf);
 977                 }
 978         }
 979
 980         size_t overhead = 0;
 981
 982         if(relay_supported) {
 983                 overhead += sizeof(to->id) + sizeof(from->id);
 984         }
 985
 986         uint8_t buf[len + overhead];
 987         uint8_t *buf_ptr = buf;
 988
 989         if(relay_supported) {
 990                 if(direct) {
 991                         /* Inform the recipient that this packet was sent directly. */
 992                         node_id_t nullid = {0};
 993                         memcpy(buf_ptr, &nullid, sizeof(nullid));
 994                         buf_ptr += sizeof(nullid);
 995                 } else {
 996                         memcpy(buf_ptr, &to->id, sizeof(to->id));
 997                         buf_ptr += sizeof(to->id);
 998                 }
 999
1000                 memcpy(buf_ptr, &from->id, sizeof(from->id));
1001                 buf_ptr += sizeof(from->id);
1002
1003         }
1004
1005         /* 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 */
1006         memcpy(buf_ptr, data, len);
1007         buf_ptr += len;
1008
1009         const sockaddr_t *sa = NULL;
1010         size_t sock;
1011
1012         if(relay->status.send_locally) {
1013                 choose_local_address(relay, &sa, &sock);
1014         }
1015
1016         if(!sa) {
1017                 choose_udp_address(relay, &sa, &sock);
1018         }
1019
1020         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);
1021
1022         if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
1023                 if(sockmsgsize(sockerrno)) {
1024                         // Compensate for SPTPS overhead
1025                         len -= SPTPS_DATAGRAM_OVERHEAD;
1026
1027                         if(relay->maxmtu >= len) {
1028                                 relay->maxmtu = len - 1;
1029                         }
1030
1031                         if(relay->mtu >= len) {
1032                                 relay->mtu = len - 1;
1033                         }
1034
1035                         try_fix_mtu(relay);
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 %zu to %s (%s)", 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 %zu to %s (%s)", 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, &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         /* getsockopt(IP_MTU) returns the MTU of the physical interface.
1275            We need to remove various overheads to get to the tinc MTU. */
1276         length_t mtu = ip_mtu;
1277         mtu -= (sa->sa.sa_family == AF_INET6) ? sizeof(struct ip6_hdr) : sizeof(struct ip);
1278         mtu -= 8; /* UDP */
1279
1280         if(n->status.sptps) {
1281                 mtu -= SPTPS_DATAGRAM_OVERHEAD;
1282
1283                 if((n->options >> 24) >= 4) {
1284                         mtu -= sizeof(node_id_t) + sizeof(node_id_t);
1285                 }
1286
1287 #ifndef DISABLE_LEGACY
1288         } else {
1289                 mtu -= digest_length(n->outdigest);
1290
1291                 /* Now it's tricky. We use CBC mode, so the length of the
1292                    encrypted payload must be a multiple of the blocksize. The
1293                    sequence number is also part of the encrypted payload, so we
1294                    must account for it after correcting for the blocksize.
1295                    Furthermore, the padding in the last block must be at least
1296                    1 byte. */
1297
1298                 length_t blocksize = cipher_blocksize(n->outcipher);
1299
1300                 if(blocksize > 1) {
1301                         mtu /= blocksize;
1302                         mtu *= blocksize;
1303                         mtu--;
1304                 }
1305
1306                 mtu -= 4; // seqno
1307 #endif
1308         }
1309
1310         if(mtu < 512) {
1311                 logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
1312                 return MTU;
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, 512);
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 = (length_t) powf(interval, multiplier * cycle_position / ((float) probes_per_cycle - 1.0f));
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                 usleep(errors * 50000);
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 }