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