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         vpn_packet_t pkt1, pkt2;
 444         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 445         vpn_packet_t *inpkt = origpkt;
 446         int nextpkt = 0;
 447         vpn_packet_t *outpkt;
 448         int origlen = origpkt->len;
 449         size_t outlen;
 450
 451         if(!n->status.reachable) {
 452                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 453                 return;
 454         }
 455
 456         return send_sptps_packet(mesh, n, origpkt);
 457 }
 458
 459 bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
 460         node_t *to = handle;
 461         meshlink_handle_t *mesh = to->mesh;
 462
 463         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 464
 465         if(type >= SPTPS_HANDSHAKE || ((mesh->self->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
 466                 char buf[len * 4 / 3 + 5];
 467                 b64encode(data, buf, len);
 468                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
 469                    to ensure we get to learn the reflexive UDP address. */
 470                 if(!to->status.validkey) {
 471                         to->incompression = mesh->self->incompression;
 472                         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);
 473                 } else {
 474                         return send_request(mesh, to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
 475                 }
 476         }
 477
 478         /* Otherwise, send the packet via UDP */
 479
 480         const sockaddr_t *sa;
 481         int sock;
 482
 483         if(to->status.broadcast)
 484                 choose_broadcast_address(mesh, to, &sa, &sock);
 485         else
 486                 choose_udp_address(mesh, to, &sa, &sock);
 487
 488         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 489                 if(sockmsgsize(sockerrno)) {
 490                         if(to->maxmtu >= len)
 491                                 to->maxmtu = len - 1;
 492                         if(to->mtu >= len)
 493                                 to->mtu = len - 1;
 494                 } else {
 495                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", to->name, to->hostname, sockstrerror(sockerrno));
 496                         return false;
 497                 }
 498         }
 499
 500         return true;
 501 }
 502
 503 bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t len) {
 504         node_t *from = handle;
 505         meshlink_handle_t *mesh = from->mesh;
 506
 507         if(type == SPTPS_HANDSHAKE) {
 508                 if(!from->status.validkey) {
 509                         from->status.validkey = true;
 510                         from->status.waitingforkey = false;
 511                         logger(DEBUG_META, LOG_INFO, "SPTPS key exchange with %s (%s) succesful", from->name, from->hostname);
 512                 }
 513                 return true;
 514         }
 515
 516         if(len > MTU) {
 517                 logger(DEBUG_ALWAYS, LOG_ERR, "Packet from %s (%s) larger than maximum supported size (%d > %d)", from->name, from->hostname, len, MTU);
 518                 return false;
 519         }
 520
 521         vpn_packet_t inpkt;
 522
 523         if(type == PKT_PROBE) {
 524                 inpkt.len = len;
 525                 inpkt.probe = true;
 526                 memcpy(inpkt.data, data, len);
 527                 mtu_probe_h(mesh, from, &inpkt, len);
 528                 return true;
 529         } else {
 530                 inpkt.probe = false;
 531         }
 532
 533         if(type & ~(PKT_COMPRESSED)) {
 534                 logger(DEBUG_ALWAYS, LOG_ERR, "Unexpected SPTPS record type %d len %d from %s (%s)", type, len, from->name, from->hostname);
 535                 return false;
 536         }
 537
 538         if(type & PKT_COMPRESSED) {
 539                 uint16_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
 540                 if(ulen < 0) {
 541                         return false;
 542                 } else {
 543                         inpkt.len = ulen;
 544                 }
 545                 if(inpkt.len > MAXSIZE)
 546                         abort();
 547         } else {
 548                 memcpy(inpkt.data, data, len);
 549                 inpkt.len = len;
 550         }
 551
 552         receive_packet(mesh, from, &inpkt);
 553         return true;
 554 }
 555
 556 /*
 557   send a packet to the given vpn ip.
 558 */
 559 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 560         node_t *via;
 561
 562         if(n == mesh->self) {
 563                 n->out_packets++;
 564                 n->out_bytes += packet->len;
 565                 // TODO: send to application
 566                 return;
 567         }
 568
 569         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
 570                            packet->len, n->name, n->hostname);
 571
 572         if(!n->status.reachable) {
 573                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
 574                                    n->name, n->hostname);
 575                 return;
 576         }
 577
 578         n->out_packets++;
 579         n->out_bytes += packet->len;
 580
 581         send_sptps_packet(mesh, n, packet);
 582         return;
 583 }
 584
 585 /* Broadcast a packet using the minimum spanning tree */
 586
 587 void broadcast_packet(meshlink_handle_t *mesh, const node_t *from, vpn_packet_t *packet) {
 588         // Always give ourself a copy of the packet.
 589         if(from != mesh->self)
 590                 send_packet(mesh, mesh->self, packet);
 591
 592         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
 593                            packet->len, from->name, from->hostname);
 594
 595         for list_each(connection_t, c, mesh->connections)
 596                 if(c->status.active && c->status.mst && c != from->nexthop->connection)
 597                         send_packet(mesh, c->node, packet);
 598 }
 599
 600 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
 601         node_t *n = NULL;
 602         bool hard = false;
 603         static time_t last_hard_try = 0;
 604
 605         for splay_each(edge_t, e, mesh->edges) {
 606                 if(!e->to->status.reachable || e->to == mesh->self)
 607                         continue;
 608
 609                 if(sockaddrcmp_noport(from, &e->address)) {
 610                         if(last_hard_try == mesh->loop.now.tv_sec)
 611                                 continue;
 612                         hard = true;
 613                 }
 614
 615                 if(!try_mac(mesh, e->to, pkt))
 616                         continue;
 617
 618                 n = e->to;
 619                 break;
 620         }
 621
 622         if(hard)
 623                 last_hard_try = mesh->loop.now.tv_sec;
 624
 625         last_hard_try = mesh->loop.now.tv_sec;
 626         return n;
 627 }
 628
 629 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
 630         meshlink_handle_t *mesh = loop->data;
 631         listen_socket_t *ls = data;
 632         vpn_packet_t pkt;
 633         char *hostname;
 634         sockaddr_t from = {{0}};
 635         socklen_t fromlen = sizeof from;
 636         node_t *n;
 637         int len;
 638
 639         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
 640
 641         if(len <= 0 || len > MAXSIZE) {
 642                 if(!sockwouldblock(sockerrno))
 643                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
 644                 return;
 645         }
 646
 647         pkt.len = len;
 648
 649         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
 650
 651         n = lookup_node_udp(mesh, &from);
 652
 653         if(!n) {
 654                 n = try_harder(mesh, &from, &pkt);
 655                 if(n)
 656                         update_node_udp(mesh, n, &from);
 657                 else if(mesh->debug_level >= DEBUG_PROTOCOL) {
 658                         hostname = sockaddr2hostname(&from);
 659                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
 660                         free(hostname);
 661                         return;
 662                 }
 663                 else
 664                         return;
 665         }
 666
 667         n->sock = ls - mesh->listen_socket;
 668
 669         receive_udppacket(mesh, n, &pkt);
 670 }