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