git.meshlink.io Git - meshlink/blob - src/net_packet.c

   1 /*
   2     net_packet.c -- Handles in- and outgoing VPN packets
   3     Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #ifdef HAVE_ZLIB
  23 #include <zlib.h>
  24 #endif
  25
  26 #include "conf.h"
  27 #include "connection.h"
  28 #include "crypto.h"
  29 #include "graph.h"
  30 #include "logger.h"
  31 #include "meshlink_internal.h"
  32 #include "net.h"
  33 #include "netutl.h"
  34 #include "protocol.h"
  35 #include "route.h"
  36 #include "utils.h"
  37 #include "xalloc.h"
  38
  39 int keylifetime = 0;
  40
  41 static void send_udppacket(meshlink_handle_t *mesh, node_t *, vpn_packet_t *);
  42
  43 unsigned replaywin = 16;
  44
  45 #define MAX_SEQNO 1073741824
  46
  47 /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
  48    mtuprobes ==    31: sleep pinginterval seconds
  49    mtuprobes ==    32: send 1 burst, sleep pingtimeout second
  50    mtuprobes ==    33: no response from other side, restart PMTU discovery process
  51
  52    Probes are sent in batches of at least three, with random sizes between the
  53    lower and upper boundaries for the MTU thus far discovered.
  54
  55    After the initial discovery, a fourth packet is added to each batch with a
  56    size larger than the currently known PMTU, to test if the PMTU has increased.
  57
  58    In case local discovery is enabled, another packet is added to each batch,
  59    which will be broadcast to the local network.
  60
  61 */
  62
  63 static void send_mtu_probe_handler(event_loop_t *loop, void *data) {
  64         meshlink_handle_t *mesh = loop->data;
  65         node_t *n = data;
  66         int timeout = 1;
  67
  68         n->mtuprobes++;
  69
  70         if(!n->status.reachable || !n->status.validkey) {
  71                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname);
  72                 n->mtuprobes = 0;
  73                 return;
  74         }
  75
  76         if(n->mtuprobes > 32) {
  77                 if(!n->minmtu) {
  78                         n->mtuprobes = 31;
  79                         timeout = mesh->pinginterval;
  80                         goto end;
  81                 }
  82
  83                 logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
  84                 n->status.udp_confirmed = false;
  85                 n->mtuprobes = 1;
  86                 n->minmtu = 0;
  87                 n->maxmtu = MTU;
  88         }
  89
  90         if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
  91                 logger(DEBUG_TRAFFIC, LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname);
  92                 n->mtuprobes = 31;
  93         }
  94
  95         if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
  96                 if(n->minmtu > n->maxmtu)
  97                         n->minmtu = n->maxmtu;
  98                 else
  99                         n->maxmtu = n->minmtu;
 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 = 31;
 103         }
 104
 105         if(n->mtuprobes == 31) {
 106                 timeout = mesh->pinginterval;
 107                 goto end;
 108         } else if(n->mtuprobes == 32) {
 109                 timeout = mesh->pingtimeout;
 110         }
 111
 112         for(int i = 0; i < 4 + mesh->localdiscovery; i++) {
 113                 int len;
 114
 115                 if(i == 0) {
 116                         if(n->mtuprobes < 30 || n->maxmtu + 8 >= MTU)
 117                                 continue;
 118                         len = n->maxmtu + 8;
 119                 } else if(n->maxmtu <= n->minmtu) {
 120                         len = n->maxmtu;
 121                 } else {
 122                         len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
 123                 }
 124
 125                 if(len < 64)
 126                         len = 64;
 127
 128                 vpn_packet_t packet;
 129                 packet.probe = true;
 130                 memset(packet.data, 0, 14);
 131                 randomize(packet.data + 14, len - 14);
 132                 packet.len = len;
 133                 n->status.broadcast = i >= 4 && n->mtuprobes <= 10 && n->prevedge;
 134
 135                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
 136
 137                 send_udppacket(mesh, n, &packet);
 138         }
 139
 140         n->status.broadcast = false;
 141         n->probe_counter = 0;
 142         gettimeofday(&n->probe_time, NULL);
 143
 144         /* Calculate the packet loss of incoming traffic by comparing the rate of
 145            packets received to the rate with which the sequence number has increased.
 146          */
 147
 148         if(n->received > n->prev_received)
 149                 n->packetloss = 1.0 - (n->received - n->prev_received) / (float)(n->received_seqno - n->prev_received_seqno);
 150         else
 151                 n->packetloss = n->received_seqno <= n->prev_received_seqno;
 152
 153         n->prev_received_seqno = n->received_seqno;
 154         n->prev_received = n->received;
 155
 156 end:
 157         timeout_set(&mesh->loop, &n->mtutimeout, &(struct timeval){timeout, rand() % 100000});
 158 }
 159
 160 void send_mtu_probe(meshlink_handle_t *mesh, node_t *n) {
 161         timeout_add(&mesh->loop, &n->mtutimeout, send_mtu_probe_handler, n, &(struct timeval){1, 0});
 162         send_mtu_probe_handler(&mesh->loop, n);
 163 }
 164
 165 static void mtu_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet, uint16_t len) {
 166         logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe length %d from %s (%s)", packet->len, n->name, n->hostname);
 167
 168         if(!packet->data[0]) {
 169                 /* It's a probe request, send back a reply */
 170
 171                 packet->data[0] = 1;
 172
 173                 /* Temporarily set udp_confirmed, so that the reply is sent
 174                    back exactly the way it came in. */
 175
 176                 bool udp_confirmed = n->status.udp_confirmed;
 177                 n->status.udp_confirmed = true;
 178                 send_udppacket(mesh, n, packet);
 179                 n->status.udp_confirmed = udp_confirmed;
 180         } else {
 181                 /* It's a valid reply: now we know bidirectional communication
 182                    is possible using the address and socket that the reply
 183                    packet used. */
 184
 185                 n->status.udp_confirmed = true;
 186
 187                 /* If we haven't established the PMTU yet, restart the discovery process. */
 188
 189                 if(n->mtuprobes > 30) {
 190                         if (len == n->maxmtu + 8) {
 191                                 logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
 192                                 n->maxmtu = MTU;
 193                                 n->mtuprobes = 10;
 194                                 return;
 195                         }
 196
 197                         if(n->minmtu)
 198                                 n->mtuprobes = 30;
 199                         else
 200                                 n->mtuprobes = 1;
 201                 }
 202
 203                 /* If applicable, raise the minimum supported MTU */
 204
 205                 if(len > n->maxmtu)
 206                         len = n->maxmtu;
 207                 if(n->minmtu < len)
 208                         n->minmtu = len;
 209
 210                 /* Calculate RTT and bandwidth.
 211                    The RTT is the time between the MTU probe burst was sent and the first
 212                    reply is received. The bandwidth is measured using the time between the
 213                    arrival of the first and third probe reply.
 214                  */
 215
 216                 struct timeval now, diff;
 217                 gettimeofday(&now, NULL);
 218                 timersub(&now, &n->probe_time, &diff);
 219
 220                 n->probe_counter++;
 221
 222                 if(n->probe_counter == 1) {
 223                         n->rtt = diff.tv_sec + diff.tv_usec * 1e-6;
 224                         n->probe_time = now;
 225                 } else if(n->probe_counter == 3) {
 226                         n->bandwidth = 2.0 * len / (diff.tv_sec + diff.tv_usec * 1e-6);
 227                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, burst bandwidth %.3f Mbit/s, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->bandwidth * 8e-6, n->packetloss * 1e2);
 228                 }
 229         }
 230 }
 231
 232 static uint16_t compress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
 233         if(level == 0) {
 234                 memcpy(dest, source, len);
 235                 return len;
 236         } else if(level == 10) {
 237                 return -1;
 238         } else if(level < 10) {
 239 #ifdef HAVE_ZLIB
 240                 unsigned long destlen = MAXSIZE;
 241                 if(compress2(dest, &destlen, source, len, level) == Z_OK)
 242                         return destlen;
 243                 else
 244 #endif
 245                         return -1;
 246         } else {
 247                 return -1;
 248         }
 249
 250         return -1;
 251 }
 252
 253 static uint16_t uncompress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
 254         if(level == 0) {
 255                 memcpy(dest, source, len);
 256                 return len;
 257         } else if(level > 9) {
 258                         return -1;
 259         }
 260 #ifdef HAVE_ZLIB
 261         else {
 262                 unsigned long destlen = MAXSIZE;
 263                 if(uncompress(dest, &destlen, source, len) == Z_OK)
 264                         return destlen;
 265                 else
 266                         return -1;
 267         }
 268 #endif
 269
 270         return -1;
 271 }
 272
 273 /* VPN packet I/O */
 274
 275 static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 276         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
 277                            packet->len, n->name, n->hostname);
 278
 279         n->in_packets++;
 280         n->in_bytes += packet->len;
 281
 282         route(mesh, n, packet);
 283 }
 284
 285 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
 286         return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
 287 }
 288
 289 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
 290         if(!n->sptps.state) {
 291                 if(!n->status.waitingforkey) {
 292                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
 293                         send_req_key(mesh, n);
 294                 } else {
 295                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
 296                 }
 297                 return;
 298         }
 299         sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
 300 }
 301
 302 void receive_tcppacket(meshlink_handle_t *mesh, connection_t *c, const char *buffer, int len) {
 303         vpn_packet_t outpkt;
 304
 305         if(len > sizeof outpkt.data)
 306                 return;
 307
 308         outpkt.len = len;
 309         outpkt.tcp = true;
 310         memcpy(outpkt.data, buffer, len);
 311
 312         receive_packet(mesh, c->node, &outpkt);
 313 }
 314
 315 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 316         if(!n->status.validkey) {
 317                 logger(DEBUG_TRAFFIC, LOG_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
 318                 if(!n->status.waitingforkey)
 319                         send_req_key(mesh, n);
 320                 else if(n->last_req_key + 10 < mesh->loop.now.tv_sec) {
 321                         logger(DEBUG_ALWAYS, LOG_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
 322                         sptps_stop(&n->sptps);
 323                         n->status.waitingforkey = false;
 324                         send_req_key(mesh, n);
 325                 }
 326                 return;
 327         }
 328
 329         uint8_t type = 0;
 330
 331         // If it's a probe, send it immediately without trying to compress it.
 332         if(origpkt->probe) {
 333                 sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
 334                 return;
 335         }
 336
 337         vpn_packet_t outpkt;
 338
 339         if(n->outcompression) {
 340                 int len = compress_packet(outpkt.data, origpkt->data, origpkt->len, n->outcompression);
 341                 if(len < 0) {
 342                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
 343                 } else if(len < origpkt->len) {
 344                         outpkt.len = len;
 345                         origpkt = &outpkt;
 346                         type |= PKT_COMPRESSED;
 347                 }
 348         }
 349
 350         sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
 351         return;
 352 }
 353
 354 static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
 355         /* Latest guess */
 356         *sa = &n->address;
 357         *sock = n->sock;
 358
 359         /* If the UDP address is confirmed, use it. */
 360         if(n->status.udp_confirmed)
 361                 return;
 362
 363         /* Send every third packet to n->address; that could be set
 364            to the node's reflexive UDP address discovered during key
 365            exchange. */
 366
 367         static int x = 0;
 368         if(++x >= 3) {
 369                 x = 0;
 370                 return;
 371         }
 372
 373         /* Otherwise, address are found in edges to this node.
 374            So we pick a random edge and a random socket. */
 375
 376         int i = 0;
 377         int j = rand() % n->edge_tree->count;
 378         edge_t *candidate = NULL;
 379
 380         for splay_each(edge_t, e, n->edge_tree) {
 381                 if(i++ == j) {
 382                         candidate = e->reverse;
 383                         break;
 384                 }
 385         }
 386
 387         if(candidate) {
 388                 *sa = &candidate->address;
 389                 *sock = rand() % mesh->listen_sockets;
 390         }
 391
 392         /* Make sure we have a suitable socket for the chosen address */
 393         if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
 394                 for(int i = 0; i < mesh->listen_sockets; i++) {
 395                         if(mesh->listen_socket[i].sa.sa.sa_family == (*sa)->sa.sa_family) {
 396                                 *sock = i;
 397                                 break;
 398                         }
 399                 }
 400         }
 401 }
 402
 403 static void choose_broadcast_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
 404         static sockaddr_t broadcast_ipv4 = {
 405                 .in = {
 406                         .sin_family = AF_INET,
 407                         .sin_addr.s_addr = -1,
 408                 }
 409         };
 410
 411         static sockaddr_t broadcast_ipv6 = {
 412                 .in6 = {
 413                         .sin6_family = AF_INET6,
 414                         .sin6_addr.s6_addr[0x0] = 0xff,
 415                         .sin6_addr.s6_addr[0x1] = 0x02,
 416                         .sin6_addr.s6_addr[0xf] = 0x01,
 417                 }
 418         };
 419
 420         *sock = rand() % mesh->listen_sockets;
 421
 422         if(mesh->listen_socket[*sock].sa.sa.sa_family == AF_INET6) {
 423                 if(mesh->localdiscovery_address.sa.sa_family == AF_INET6) {
 424                         mesh->localdiscovery_address.in6.sin6_port = n->prevedge->address.in.sin_port;
 425                         *sa = &mesh->localdiscovery_address;
 426                 } else {
 427                         broadcast_ipv6.in6.sin6_port = n->prevedge->address.in.sin_port;
 428                         broadcast_ipv6.in6.sin6_scope_id = mesh->listen_socket[*sock].sa.in6.sin6_scope_id;
 429                         *sa = &broadcast_ipv6;
 430                 }
 431         } else {
 432                 if(mesh->localdiscovery_address.sa.sa_family == AF_INET) {
 433                         mesh->localdiscovery_address.in.sin_port = n->prevedge->address.in.sin_port;
 434                         *sa = &mesh->localdiscovery_address;
 435                 } else {
 436                         broadcast_ipv4.in.sin_port = n->prevedge->address.in.sin_port;
 437                         *sa = &broadcast_ipv4;
 438                 }
 439         }
 440 }
 441
 442 static void send_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 443         if(!n->status.reachable) {
 444                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 445                 return;
 446         }
 447
 448         return send_sptps_packet(mesh, n, origpkt);
 449 }
 450
 451 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
 452         node_t *to = handle;
 453         meshlink_handle_t *mesh = to->mesh;
 454
 455         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 456
 457         if(type >= SPTPS_HANDSHAKE || ((mesh->self->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
 458                 char buf[len * 4 / 3 + 5];
 459                 b64encode(data, buf, len);
 460                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
 461                    to ensure we get to learn the reflexive UDP address. */
 462                 if(!to->status.validkey) {
 463                         to->incompression = mesh->self->incompression;
 464                         return send_request(mesh, to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, mesh->self->name, to->name, buf, to->incompression);
 465                 } else {
 466                         return send_request(mesh, to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
 467                 }
 468         }
 469
 470         /* Otherwise, send the packet via UDP */
 471
 472         const sockaddr_t *sa;
 473         int sock;
 474
 475         if(to->status.broadcast)
 476                 choose_broadcast_address(mesh, to, &sa, &sock);
 477         else
 478                 choose_udp_address(mesh, to, &sa, &sock);
 479
 480         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 481                 if(sockmsgsize(sockerrno)) {
 482                         if(to->maxmtu >= len)
 483                                 to->maxmtu = len - 1;
 484                         if(to->mtu >= len)
 485                                 to->mtu = len - 1;
 486                 } else {
 487                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", to->name, to->hostname, sockstrerror(sockerrno));
 488                         return false;
 489                 }
 490         }
 491
 492         return true;
 493 }
 494
 495 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
 496         node_t *from = handle;
 497         meshlink_handle_t *mesh = from->mesh;
 498
 499         if(type == SPTPS_HANDSHAKE) {
 500                 if(!from->status.validkey) {
 501                         from->status.validkey = true;
 502                         from->status.waitingforkey = false;
 503                         logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
 504                 }
 505                 return true;
 506         }
 507
 508         if(len > MTU) {
 509                 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
 510                 return false;
 511         }
 512
 513         vpn_packet_t inpkt;
 514
 515         if(type == PKT_PROBE) {
 516                 inpkt.len = len;
 517                 inpkt.probe = true;
 518                 memcpy(inpkt.data, data, len);
 519                 mtu_probe_h(mesh, from, &inpkt, len);
 520                 return true;
 521         } else {
 522                 inpkt.probe = false;
 523         }
 524
 525         if(type & ~(PKT_COMPRESSED)) {
 526                 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
 527                 return false;
 528         }
 529
 530         if(type & PKT_COMPRESSED) {
 531                 uint16_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
 532                 if(ulen < 0) {
 533                         return false;
 534                 } else {
 535                         inpkt.len = ulen;
 536                 }
 537                 if(inpkt.len > MAXSIZE)
 538                         abort();
 539         } else {
 540                 memcpy(inpkt.data, data, len);
 541                 inpkt.len = len;
 542         }
 543
 544         receive_packet(mesh, from, &inpkt);
 545         return true;
 546 }
 547
 548 /*
 549   send a packet to the given vpn ip.
 550 */
 551 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 552         if(n == mesh->self) {
 553                 n->out_packets++;
 554                 n->out_bytes += packet->len;
 555                 // TODO: send to application
 556                 return;
 557         }
 558
 559         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
 560                            packet->len, n->name, n->hostname);
 561
 562         if(!n->status.reachable) {
 563                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
 564                                    n->name, n->hostname);
 565                 return;
 566         }
 567
 568         n->out_packets++;
 569         n->out_bytes += packet->len;
 570
 571         send_sptps_packet(mesh, n, packet);
 572         return;
 573 }
 574
 575 /* Broadcast a packet using the minimum spanning tree */
 576
 577 void broadcast_packet(meshlink_handle_t *mesh, const node_t *from, vpn_packet_t *packet) {
 578         // Always give ourself a copy of the packet.
 579         if(from != mesh->self)
 580                 send_packet(mesh, mesh->self, packet);
 581
 582         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
 583                            packet->len, from->name, from->hostname);
 584
 585         for list_each(connection_t, c, mesh->connections)
 586                 if(c->status.active && c->status.mst && c != from->nexthop->connection)
 587                         send_packet(mesh, c->node, packet);
 588 }
 589
 590 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
 591         node_t *n = NULL;
 592         bool hard = false;
 593         static time_t last_hard_try = 0;
 594
 595         for splay_each(edge_t, e, mesh->edges) {
 596                 if(!e->to->status.reachable || e->to == mesh->self)
 597                         continue;
 598
 599                 if(sockaddrcmp_noport(from, &e->address)) {
 600                         if(last_hard_try == mesh->loop.now.tv_sec)
 601                                 continue;
 602                         hard = true;
 603                 }
 604
 605                 if(!try_mac(mesh, e->to, pkt))
 606                         continue;
 607
 608                 n = e->to;
 609                 break;
 610         }
 611
 612         if(hard)
 613                 last_hard_try = mesh->loop.now.tv_sec;
 614
 615         last_hard_try = mesh->loop.now.tv_sec;
 616         return n;
 617 }
 618
 619 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
 620         meshlink_handle_t *mesh = loop->data;
 621         listen_socket_t *ls = data;
 622         vpn_packet_t pkt;
 623         char *hostname;
 624         sockaddr_t from = {{0}};
 625         socklen_t fromlen = sizeof from;
 626         node_t *n;
 627         int len;
 628
 629         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
 630
 631         if(len <= 0 || len > MAXSIZE) {
 632                 if(!sockwouldblock(sockerrno))
 633                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
 634                 return;
 635         }
 636
 637         pkt.len = len;
 638
 639         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
 640
 641         n = lookup_node_udp(mesh, &from);
 642
 643         if(!n) {
 644                 n = try_harder(mesh, &from, &pkt);
 645                 if(n)
 646                         update_node_udp(mesh, n, &from);
 647                 else if(mesh->debug_level >= DEBUG_PROTOCOL) {
 648                         hostname = sockaddr2hostname(&from);
 649                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
 650                         free(hostname);
 651                         return;
 652                 }
 653                 else
 654                         return;
 655         }
 656
 657         n->sock = ls - mesh->listen_socket;
 658
 659         receive_udppacket(mesh, n, &pkt);
 660 }