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(mesh, MESHLINK_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(mesh, MESHLINK_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(mesh, MESHLINK_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(mesh, MESHLINK_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(mesh, MESHLINK_DEBUG, "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(mesh, MESHLINK_DEBUG, "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(mesh, MESHLINK_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(mesh, MESHLINK_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(mesh, MESHLINK_DEBUG, "Received packet of %d bytes from %s (%s)",
 277                            packet->len, n->name, n->hostname);
 278
 279     if (n->status.blacklisted) {
 280         logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
 281     } else {
 282         n->in_packets++;
 283         n->in_bytes += packet->len;
 284
 285         route(mesh, n, packet);
 286     }
 287 }
 288
 289 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
 290         return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
 291 }
 292
 293 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
 294         if(!n->sptps.state) {
 295                 if(!n->status.waitingforkey) {
 296                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
 297                         send_req_key(mesh, n);
 298                 } else {
 299                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet", n->name, n->hostname);
 300                 }
 301                 return;
 302         }
 303         sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
 304 }
 305
 306 void receive_tcppacket(meshlink_handle_t *mesh, connection_t *c, const char *buffer, int len) {
 307         vpn_packet_t outpkt;
 308
 309         if(len > sizeof outpkt.data)
 310                 return;
 311
 312         outpkt.len = len;
 313         outpkt.tcp = true;
 314         memcpy(outpkt.data, buffer, len);
 315
 316         receive_packet(mesh, c->node, &outpkt);
 317 }
 318
 319 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 320         if(!n->status.validkey) {
 321                 logger(mesh, MESHLINK_INFO, "No valid key known yet for %s (%s)", n->name, n->hostname);
 322                 if(!n->status.waitingforkey)
 323                         send_req_key(mesh, n);
 324                 else if(n->last_req_key + 10 < mesh->loop.now.tv_sec) {
 325                         logger(mesh, MESHLINK_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
 326                         sptps_stop(&n->sptps);
 327                         n->status.waitingforkey = false;
 328                         send_req_key(mesh, n);
 329                 }
 330                 return;
 331         }
 332
 333         uint8_t type = 0;
 334
 335         // If it's a probe, send it immediately without trying to compress it.
 336         if(origpkt->probe) {
 337                 sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
 338                 return;
 339         }
 340
 341         vpn_packet_t outpkt;
 342
 343         if(n->outcompression) {
 344                 int len = compress_packet(outpkt.data, origpkt->data, origpkt->len, n->outcompression);
 345                 if(len < 0) {
 346                         logger(mesh, MESHLINK_ERROR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
 347                 } else if(len < origpkt->len) {
 348                         outpkt.len = len;
 349                         origpkt = &outpkt;
 350                         type |= PKT_COMPRESSED;
 351                 }
 352         }
 353
 354         sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
 355         return;
 356 }
 357
 358 static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
 359         /* Latest guess */
 360         *sa = &n->address;
 361         *sock = n->sock;
 362
 363         /* If the UDP address is confirmed, use it. */
 364         if(n->status.udp_confirmed)
 365                 return;
 366
 367         /* Send every third packet to n->address; that could be set
 368            to the node's reflexive UDP address discovered during key
 369            exchange. */
 370
 371         static int x = 0;
 372         if(++x >= 3) {
 373                 x = 0;
 374                 return;
 375         }
 376
 377         /* Otherwise, address are found in edges to this node.
 378            So we pick a random edge and a random socket. */
 379
 380         int i = 0;
 381         int j = rand() % n->edge_tree->count;
 382         edge_t *candidate = NULL;
 383
 384         for splay_each(edge_t, e, n->edge_tree) {
 385                 if(i++ == j) {
 386                         candidate = e->reverse;
 387                         break;
 388                 }
 389         }
 390
 391         if(candidate) {
 392                 *sa = &candidate->address;
 393                 *sock = rand() % mesh->listen_sockets;
 394         }
 395
 396         /* Make sure we have a suitable socket for the chosen address */
 397         if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
 398                 for(int i = 0; i < mesh->listen_sockets; i++) {
 399                         if(mesh->listen_socket[i].sa.sa.sa_family == (*sa)->sa.sa_family) {
 400                                 *sock = i;
 401                                 break;
 402                         }
 403                 }
 404         }
 405 }
 406
 407 static void choose_broadcast_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
 408         static sockaddr_t broadcast_ipv4 = {
 409                 .in = {
 410                         .sin_family = AF_INET,
 411                         .sin_addr.s_addr = -1,
 412                 }
 413         };
 414
 415         static sockaddr_t broadcast_ipv6 = {
 416                 .in6 = {
 417                         .sin6_family = AF_INET6,
 418                         .sin6_addr.s6_addr[0x0] = 0xff,
 419                         .sin6_addr.s6_addr[0x1] = 0x02,
 420                         .sin6_addr.s6_addr[0xf] = 0x01,
 421                 }
 422         };
 423
 424         *sock = rand() % mesh->listen_sockets;
 425
 426         if(mesh->listen_socket[*sock].sa.sa.sa_family == AF_INET6) {
 427                 if(mesh->localdiscovery_address.sa.sa_family == AF_INET6) {
 428                         mesh->localdiscovery_address.in6.sin6_port = n->prevedge->address.in.sin_port;
 429                         *sa = &mesh->localdiscovery_address;
 430                 } else {
 431                         broadcast_ipv6.in6.sin6_port = n->prevedge->address.in.sin_port;
 432                         broadcast_ipv6.in6.sin6_scope_id = mesh->listen_socket[*sock].sa.in6.sin6_scope_id;
 433                         *sa = &broadcast_ipv6;
 434                 }
 435         } else {
 436                 if(mesh->localdiscovery_address.sa.sa_family == AF_INET) {
 437                         mesh->localdiscovery_address.in.sin_port = n->prevedge->address.in.sin_port;
 438                         *sa = &mesh->localdiscovery_address;
 439                 } else {
 440                         broadcast_ipv4.in.sin_port = n->prevedge->address.in.sin_port;
 441                         *sa = &broadcast_ipv4;
 442                 }
 443         }
 444 }
 445
 446 static void send_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 447         if(!n->status.reachable) {
 448                 logger(mesh, MESHLINK_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 449                 return;
 450         }
 451
 452         return send_sptps_packet(mesh, n, origpkt);
 453 }
 454
 455 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
 456         node_t *to = handle;
 457         meshlink_handle_t *mesh = to->mesh;
 458
 459         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 460
 461         if(type >= SPTPS_HANDSHAKE || ((mesh->self->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
 462                 char buf[len * 4 / 3 + 5];
 463                 b64encode(data, buf, len);
 464                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
 465                    to ensure we get to learn the reflexive UDP address. */
 466                 if(!to->status.validkey) {
 467                         to->incompression = mesh->self->incompression;
 468                         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);
 469                 } else {
 470                         return send_request(mesh, to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
 471                 }
 472         }
 473
 474         /* Otherwise, send the packet via UDP */
 475
 476         const sockaddr_t *sa;
 477         int sock;
 478
 479         if(to->status.broadcast)
 480                 choose_broadcast_address(mesh, to, &sa, &sock);
 481         else
 482                 choose_udp_address(mesh, to, &sa, &sock);
 483
 484         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 485                 if(sockmsgsize(sockerrno)) {
 486                         if(to->maxmtu >= len)
 487                                 to->maxmtu = len - 1;
 488                         if(to->mtu >= len)
 489                                 to->mtu = len - 1;
 490                 } else {
 491                         logger(mesh, MESHLINK_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", to->name, to->hostname, sockstrerror(sockerrno));
 492                         return false;
 493                 }
 494         }
 495
 496         return true;
 497 }
 498
 499 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
 500         node_t *from = handle;
 501         meshlink_handle_t *mesh = from->mesh;
 502
 503         if(type == SPTPS_HANDSHAKE) {
 504                 if(!from->status.validkey) {
 505                         from->status.validkey = true;
 506                         from->status.waitingforkey = false;
 507                         logger(mesh, MESHLINK_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
 508                 }
 509                 return true;
 510         }
 511
 512         if(len > MTU) {
 513                 logger(mesh, MESHLINK_ERROR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
 514                 return false;
 515         }
 516
 517         vpn_packet_t inpkt;
 518
 519         if(type == PKT_PROBE) {
 520                 inpkt.len = len;
 521                 inpkt.probe = true;
 522                 memcpy(inpkt.data, data, len);
 523                 mtu_probe_h(mesh, from, &inpkt, len);
 524                 return true;
 525         } else {
 526                 inpkt.probe = false;
 527         }
 528
 529         if(type & ~(PKT_COMPRESSED)) {
 530                 logger(mesh, MESHLINK_ERROR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
 531                 return false;
 532         }
 533
 534         if(type & PKT_COMPRESSED) {
 535                 uint16_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
 536                 if(ulen < 0) {
 537                         return false;
 538                 } else {
 539                         inpkt.len = ulen;
 540                 }
 541                 if(inpkt.len > MAXSIZE)
 542                         abort();
 543         } else {
 544                 memcpy(inpkt.data, data, len);
 545                 inpkt.len = len;
 546         }
 547
 548         receive_packet(mesh, from, &inpkt);
 549         return true;
 550 }
 551
 552 /*
 553   send a packet to the given vpn ip.
 554 */
 555 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 556         if(n == mesh->self) {
 557                 n->out_packets++;
 558                 n->out_bytes += packet->len;
 559                 // TODO: send to application
 560                 return;
 561         }
 562
 563         logger(mesh, MESHLINK_DEBUG, "Sending packet of %d bytes to %s (%s)",
 564                            packet->len, n->name, n->hostname);
 565
 566         if(!n->status.reachable) {
 567                 logger(mesh, MESHLINK_WARNING, "Node %s (%s) is not reachable",
 568                                    n->name, n->hostname);
 569                 return;
 570         }
 571
 572         n->out_packets++;
 573         n->out_bytes += packet->len;
 574
 575         send_sptps_packet(mesh, n, packet);
 576         return;
 577 }
 578
 579 /* Broadcast a packet using the minimum spanning tree */
 580
 581 void broadcast_packet(meshlink_handle_t *mesh, const node_t *from, vpn_packet_t *packet) {
 582         // Always give ourself a copy of the packet.
 583         if(from != mesh->self)
 584                 send_packet(mesh, mesh->self, packet);
 585
 586         logger(mesh, MESHLINK_INFO, "Broadcasting packet of %d bytes from %s (%s)",
 587                            packet->len, from->name, from->hostname);
 588
 589         for list_each(connection_t, c, mesh->connections)
 590                 if(c->status.active && c->status.mst && c != from->nexthop->connection)
 591                         send_packet(mesh, c->node, packet);
 592 }
 593
 594 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
 595         node_t *n = NULL;
 596         bool hard = false;
 597         static time_t last_hard_try = 0;
 598
 599         for splay_each(edge_t, e, mesh->edges) {
 600                 if(!e->to->status.reachable || e->to == mesh->self)
 601                         continue;
 602
 603                 if(sockaddrcmp_noport(from, &e->address)) {
 604                         if(last_hard_try == mesh->loop.now.tv_sec)
 605                                 continue;
 606                         hard = true;
 607                 }
 608
 609                 if(!try_mac(mesh, e->to, pkt))
 610                         continue;
 611
 612                 n = e->to;
 613                 break;
 614         }
 615
 616         if(hard)
 617                 last_hard_try = mesh->loop.now.tv_sec;
 618
 619         last_hard_try = mesh->loop.now.tv_sec;
 620         return n;
 621 }
 622
 623 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
 624         meshlink_handle_t *mesh = loop->data;
 625         listen_socket_t *ls = data;
 626         vpn_packet_t pkt;
 627         char *hostname;
 628         sockaddr_t from = {{0}};
 629         socklen_t fromlen = sizeof from;
 630         node_t *n;
 631         int len;
 632
 633         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
 634
 635         if(len <= 0 || len > MAXSIZE) {
 636                 if(!sockwouldblock(sockerrno))
 637                         logger(mesh, MESHLINK_ERROR, "Receiving packet failed: %s", sockstrerror(sockerrno));
 638                 return;
 639         }
 640
 641         pkt.len = len;
 642
 643         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
 644
 645         n = lookup_node_udp(mesh, &from);
 646
 647         if(!n) {
 648                 n = try_harder(mesh, &from, &pkt);
 649                 if(n)
 650                         update_node_udp(mesh, n, &from);
 651                 else if(mesh->log_level >= MESHLINK_WARNING) {
 652                         hostname = sockaddr2hostname(&from);
 653                         logger(mesh, MESHLINK_WARNING, "Received UDP packet from unknown source %s", hostname);
 654                         free(hostname);
 655                         return;
 656                 }
 657                 else
 658                         return;
 659         }
 660
 661     if (n->status.blacklisted) {
 662                         logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
 663             return;
 664     }
 665         n->sock = ls - mesh->listen_socket;
 666
 667         receive_udppacket(mesh, n, &pkt);
 668 }