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