git.meshlink.io Git - meshlink/blob - src/net_packet.c

   1 /*
   2     net_packet.c -- Handles in- and outgoing VPN packets
   3     Copyright (C) 1998-2005 Ivo Timmermans,
   4                   2000-2012 Guus Sliepen <guus@tinc-vpn.org>
   5                   2010      Timothy Redaelli <timothy@redaelli.eu>
   6                   2010      Brandon Black <blblack@gmail.com>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License along
  19     with this program; if not, write to the Free Software Foundation, Inc.,
  20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21 */
  22
  23 #include "system.h"
  24
  25 #include <openssl/rand.h>
  26 #include <openssl/err.h>
  27 #include <openssl/evp.h>
  28 #include <openssl/pem.h>
  29 #include <openssl/hmac.h>
  30
  31 #ifdef HAVE_ZLIB
  32 #include <zlib.h>
  33 #endif
  34
  35 #ifdef HAVE_LZO
  36 #include LZO1X_H
  37 #endif
  38
  39 #include "splay_tree.h"
  40 #include "cipher.h"
  41 #include "conf.h"
  42 #include "connection.h"
  43 #include "crypto.h"
  44 #include "digest.h"
  45 #include "device.h"
  46 #include "ethernet.h"
  47 #include "graph.h"
  48 #include "logger.h"
  49 #include "net.h"
  50 #include "netutl.h"
  51 #include "protocol.h"
  52 #include "process.h"
  53 #include "route.h"
  54 #include "utils.h"
  55 #include "xalloc.h"
  56
  57 int keylifetime = 0;
  58 #ifdef HAVE_LZO
  59 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
  60 #endif
  61
  62 static void send_udppacket(node_t *, vpn_packet_t *);
  63
  64 unsigned replaywin = 16;
  65 bool localdiscovery = false;
  66
  67 #define MAX_SEQNO 1073741824
  68
  69 /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
  70    mtuprobes ==    31: sleep pinginterval seconds
  71    mtuprobes ==    32: send 1 burst, sleep pingtimeout second
  72    mtuprobes ==    33: no response from other side, restart PMTU discovery process
  73
  74    Probes are sent in batches of three, with random sizes between the lower and
  75    upper boundaries for the MTU thus far discovered.
  76
  77    In case local discovery is enabled, a fourth packet is added to each batch,
  78    which will be broadcast to the local network.
  79 */
  80
  81 static void send_mtu_probe_handler(int fd, short events, void *data) {
  82         node_t *n = data;
  83         vpn_packet_t packet;
  84         int len, i;
  85         int timeout = 1;
  86
  87         n->mtuprobes++;
  88
  89         if(!n->status.reachable || !n->status.validkey) {
  90                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname);
  91                 n->mtuprobes = 0;
  92                 return;
  93         }
  94
  95         if(n->mtuprobes > 32) {
  96                 if(!n->minmtu) {
  97                         n->mtuprobes = 31;
  98                         timeout = pinginterval;
  99                         goto end;
 100                 }
 101
 102                 logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
 103                 n->mtuprobes = 1;
 104                 n->minmtu = 0;
 105                 n->maxmtu = MTU;
 106         }
 107
 108         if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
 109                 logger(DEBUG_TRAFFIC, LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname);
 110                 n->mtuprobes = 31;
 111         }
 112
 113         if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
 114                 if(n->minmtu > n->maxmtu)
 115                         n->minmtu = n->maxmtu;
 116                 else
 117                         n->maxmtu = n->minmtu;
 118                 n->mtu = n->minmtu;
 119                 logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
 120                 n->mtuprobes = 31;
 121         }
 122
 123         if(n->mtuprobes == 31) {
 124                 timeout = pinginterval;
 125                 goto end;
 126         } else if(n->mtuprobes == 32) {
 127                 timeout = pingtimeout;
 128         }
 129
 130         for(i = 0; i < 3 + localdiscovery; i++) {
 131                 if(n->maxmtu <= n->minmtu)
 132                         len = n->maxmtu;
 133                 else
 134                         len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
 135
 136                 if(len < 64)
 137                         len = 64;
 138
 139                 memset(packet.data, 0, 14);
 140                 randomize(packet.data + 14, len - 14);
 141                 packet.len = len;
 142                 if(i >= 3 && n->mtuprobes <= 10)
 143                         packet.priority = -1;
 144                 else
 145                         packet.priority = 0;
 146
 147                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
 148
 149                 send_udppacket(n, &packet);
 150         }
 151
 152 end:
 153         event_add(&n->mtuevent, &(struct timeval){timeout, 0});
 154 }
 155
 156 void send_mtu_probe(node_t *n) {
 157         if(!timeout_initialized(&n->mtuevent))
 158                 timeout_set(&n->mtuevent, send_mtu_probe_handler, n);
 159         send_mtu_probe_handler(0, 0, n);
 160 }
 161
 162 static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
 163         logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe length %d from %s (%s)", packet->len, n->name, n->hostname);
 164
 165         if(!packet->data[0]) {
 166                 packet->data[0] = 1;
 167                 send_udppacket(n, packet);
 168         } else {
 169                 if(n->mtuprobes > 30) {
 170                         if(n->minmtu)
 171                                 n->mtuprobes = 30;
 172                         else
 173                                 n->mtuprobes = 1;
 174                 }
 175
 176                 if(len > n->maxmtu)
 177                         len = n->maxmtu;
 178                 if(n->minmtu < len)
 179                         n->minmtu = len;
 180         }
 181 }
 182
 183 static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
 184         if(level == 0) {
 185                 memcpy(dest, source, len);
 186                 return len;
 187         } else if(level == 10) {
 188 #ifdef HAVE_LZO
 189                 lzo_uint lzolen = MAXSIZE;
 190                 lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
 191                 return lzolen;
 192 #else
 193                 return -1;
 194 #endif
 195         } else if(level < 10) {
 196 #ifdef HAVE_ZLIB
 197                 unsigned long destlen = MAXSIZE;
 198                 if(compress2(dest, &destlen, source, len, level) == Z_OK)
 199                         return destlen;
 200                 else
 201 #endif
 202                         return -1;
 203         } else {
 204 #ifdef HAVE_LZO
 205                 lzo_uint lzolen = MAXSIZE;
 206                 lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
 207                 return lzolen;
 208 #else
 209                 return -1;
 210 #endif
 211         }
 212
 213         return -1;
 214 }
 215
 216 static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
 217         if(level == 0) {
 218                 memcpy(dest, source, len);
 219                 return len;
 220         } else if(level > 9) {
 221 #ifdef HAVE_LZO
 222                 lzo_uint lzolen = MAXSIZE;
 223                 if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
 224                         return lzolen;
 225                 else
 226 #endif
 227                         return -1;
 228         }
 229 #ifdef HAVE_ZLIB
 230         else {
 231                 unsigned long destlen = MAXSIZE;
 232                 if(uncompress(dest, &destlen, source, len) == Z_OK)
 233                         return destlen;
 234                 else
 235                         return -1;
 236         }
 237 #endif
 238
 239         return -1;
 240 }
 241
 242 /* VPN packet I/O */
 243
 244 static void receive_packet(node_t *n, vpn_packet_t *packet) {
 245         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Received packet of %d bytes from %s (%s)",
 246                            packet->len, n->name, n->hostname);
 247
 248         n->in_packets++;
 249         n->in_bytes += packet->len;
 250
 251         route(n, packet);
 252 }
 253
 254 static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
 255         if(!digest_active(&n->indigest) || inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest))
 256                 return false;
 257
 258         return digest_verify(&n->indigest, &inpkt->seqno, inpkt->len - n->indigest.maclength, (const char *)&inpkt->seqno + inpkt->len - n->indigest.maclength);
 259 }
 260
 261 static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
 262         vpn_packet_t pkt1, pkt2;
 263         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 264         int nextpkt = 0;
 265         vpn_packet_t *outpkt = pkt[0];
 266         size_t outlen;
 267
 268         if(!cipher_active(&n->incipher)) {
 269                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but he hasn't got our key yet",
 270                                         n->name, n->hostname);
 271                 return;
 272         }
 273
 274         /* Check packet length */
 275
 276         if(inpkt->len < sizeof inpkt->seqno + digest_length(&n->indigest)) {
 277                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
 278                                         n->name, n->hostname);
 279                 return;
 280         }
 281
 282         /* Check the message authentication code */
 283
 284         if(digest_active(&n->indigest)) {
 285                 inpkt->len -= n->indigest.maclength;
 286                 if(!digest_verify(&n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) {
 287                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
 288                         return;
 289                 }
 290         }
 291         /* Decrypt the packet */
 292
 293         if(cipher_active(&n->incipher)) {
 294                 outpkt = pkt[nextpkt++];
 295                 outlen = MAXSIZE;
 296
 297                 if(!cipher_decrypt(&n->incipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
 298                         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
 299                         return;
 300                 }
 301
 302                 outpkt->len = outlen;
 303                 inpkt = outpkt;
 304         }
 305
 306         /* Check the sequence number */
 307
 308         inpkt->len -= sizeof inpkt->seqno;
 309         inpkt->seqno = ntohl(inpkt->seqno);
 310
 311         if(replaywin) {
 312                 if(inpkt->seqno != n->received_seqno + 1) {
 313                         if(inpkt->seqno >= n->received_seqno + replaywin * 8) {
 314                                 if(n->farfuture++ < replaywin >> 2) {
 315                                         logger(DEBUG_ALWAYS, LOG_WARNING, "Packet from %s (%s) is %d seqs in the future, dropped (%u)",
 316                                                 n->name, n->hostname, inpkt->seqno - n->received_seqno - 1, n->farfuture);
 317                                         return;
 318                                 }
 319                                 logger(DEBUG_ALWAYS, LOG_WARNING, "Lost %d packets from %s (%s)",
 320                                                 inpkt->seqno - n->received_seqno - 1, n->name, n->hostname);
 321                                 memset(n->late, 0, replaywin);
 322                         } else if (inpkt->seqno <= n->received_seqno) {
 323                                 if((n->received_seqno >= replaywin * 8 && inpkt->seqno <= n->received_seqno - replaywin * 8) || !(n->late[(inpkt->seqno / 8) % replaywin] & (1 << inpkt->seqno % 8))) {
 324                                         logger(DEBUG_ALWAYS, LOG_WARNING, "Got late or replayed packet from %s (%s), seqno %d, last received %d",
 325                                                 n->name, n->hostname, inpkt->seqno, n->received_seqno);
 326                                         return;
 327                                 }
 328                         } else {
 329                                 for(int i = n->received_seqno + 1; i < inpkt->seqno; i++)
 330                                         n->late[(i / 8) % replaywin] |= 1 << i % 8;
 331                         }
 332                 }
 333
 334                 n->farfuture = 0;
 335                 n->late[(inpkt->seqno / 8) % replaywin] &= ~(1 << inpkt->seqno % 8);
 336         }
 337
 338         if(inpkt->seqno > n->received_seqno)
 339                 n->received_seqno = inpkt->seqno;
 340
 341         if(n->received_seqno > MAX_SEQNO)
 342                 regenerate_key();
 343
 344         /* Decompress the packet */
 345
 346         length_t origlen = inpkt->len;
 347
 348         if(n->incompression) {
 349                 outpkt = pkt[nextpkt++];
 350
 351                 if((outpkt->len = uncompress_packet(outpkt->data, inpkt->data, inpkt->len, n->incompression)) < 0) {
 352                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
 353                                                  n->name, n->hostname);
 354                         return;
 355                 }
 356
 357                 inpkt = outpkt;
 358
 359                 origlen -= MTU/64 + 20;
 360         }
 361
 362         inpkt->priority = 0;
 363
 364         if(!inpkt->data[12] && !inpkt->data[13])
 365                 mtu_probe_h(n, inpkt, origlen);
 366         else
 367                 receive_packet(n, inpkt);
 368 }
 369
 370 void receive_tcppacket(connection_t *c, const char *buffer, int len) {
 371         vpn_packet_t outpkt;
 372
 373         outpkt.len = len;
 374         if(c->options & OPTION_TCPONLY)
 375                 outpkt.priority = 0;
 376         else
 377                 outpkt.priority = -1;
 378         memcpy(outpkt.data, buffer, len);
 379
 380         receive_packet(c->node, &outpkt);
 381 }
 382
 383 static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
 384         vpn_packet_t pkt1, pkt2;
 385         vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
 386         vpn_packet_t *inpkt = origpkt;
 387         int nextpkt = 0;
 388         vpn_packet_t *outpkt;
 389         int origlen = origpkt->len;
 390         size_t outlen;
 391 #if defined(SOL_IP) && defined(IP_TOS)
 392         static int priority = 0;
 393         int origpriority = origpkt->priority;
 394 #endif
 395
 396         if(!n->status.reachable) {
 397                 logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
 398                 return;
 399         }
 400
 401         /* Make sure we have a valid key */
 402
 403         if(!n->status.validkey) {
 404                 time_t now = time(NULL);
 405
 406                 logger(DEBUG_TRAFFIC, LOG_INFO,
 407                                    "No valid key known yet for %s (%s), forwarding via TCP",
 408                                    n->name, n->hostname);
 409
 410                 if(n->last_req_key + 10 <= now) {
 411                         send_req_key(n);
 412                         n->last_req_key = now;
 413                 }
 414
 415                 send_tcppacket(n->nexthop->connection, origpkt);
 416
 417                 return;
 418         }
 419
 420         if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (inpkt->data[12] | inpkt->data[13])) {
 421                 logger(DEBUG_TRAFFIC, LOG_INFO,
 422                                 "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
 423                                 n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
 424
 425                 if(n != n->nexthop)
 426                         send_packet(n->nexthop, origpkt);
 427                 else
 428                         send_tcppacket(n->nexthop->connection, origpkt);
 429
 430                 return;
 431         }
 432
 433         /* Compress the packet */
 434
 435         if(n->outcompression) {
 436                 outpkt = pkt[nextpkt++];
 437
 438                 if((outpkt->len = compress_packet(outpkt->data, inpkt->data, inpkt->len, n->outcompression)) < 0) {
 439                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
 440                                    n->name, n->hostname);
 441                         return;
 442                 }
 443
 444                 inpkt = outpkt;
 445         }
 446
 447         /* Add sequence number */
 448
 449         inpkt->seqno = htonl(++(n->sent_seqno));
 450         inpkt->len += sizeof inpkt->seqno;
 451
 452         /* Encrypt the packet */
 453
 454         if(cipher_active(&n->outcipher)) {
 455                 outpkt = pkt[nextpkt++];
 456                 outlen = MAXSIZE;
 457
 458                 if(!cipher_encrypt(&n->outcipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) {
 459                         logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
 460                         goto end;
 461                 }
 462
 463                 outpkt->len = outlen;
 464                 inpkt = outpkt;
 465         }
 466
 467         /* Add the message authentication code */
 468
 469         if(digest_active(&n->outdigest)) {
 470                 digest_create(&n->outdigest, &inpkt->seqno, inpkt->len, (char *)&inpkt->seqno + inpkt->len);
 471                 inpkt->len += digest_length(&n->outdigest);
 472         }
 473
 474         /* Determine which socket we have to use */
 475
 476         if(n->address.sa.sa_family != listen_socket[n->sock].sa.sa.sa_family) {
 477                 for(int sock = 0; sock < listen_sockets; sock++) {
 478                         if(n->address.sa.sa_family == listen_socket[sock].sa.sa.sa_family) {
 479                                 n->sock = sock;
 480                                 break;
 481                         }
 482                 }
 483         }
 484
 485         /* Send the packet */
 486
 487         struct sockaddr *sa;
 488         socklen_t sl;
 489         int sock;
 490
 491         /* Overloaded use of priority field: -1 means local broadcast */
 492
 493         if(origpriority == -1 && n->prevedge) {
 494                 struct sockaddr_in in;
 495                 in.sin_family = AF_INET;
 496                 in.sin_addr.s_addr = -1;
 497                 in.sin_port = n->prevedge->address.in.sin_port;
 498                 sa = (struct sockaddr *)&in;
 499                 sl = sizeof in;
 500                 sock = 0;
 501         } else {
 502                 if(origpriority == -1)
 503                         origpriority = 0;
 504
 505                 sa = &(n->address.sa);
 506                 sl = SALEN(n->address.sa);
 507                 sock = n->sock;
 508         }
 509
 510 #if defined(SOL_IP) && defined(IP_TOS)
 511         if(priorityinheritance && origpriority != priority
 512            && listen_socket[n->sock].sa.sa.sa_family == AF_INET) {
 513                 priority = origpriority;
 514                 logger(DEBUG_TRAFFIC, LOG_DEBUG, "Setting outgoing packet priority to %d", priority);
 515                 if(setsockopt(listen_socket[n->sock].udp, SOL_IP, IP_TOS, &priority, sizeof(priority))) /* SO_PRIORITY doesn't seem to work */
 516                         logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setsockopt", strerror(errno));
 517         }
 518 #endif
 519
 520         if(sendto(listen_socket[sock].udp, (char *) &inpkt->seqno, inpkt->len, 0, sa, sl) < 0 && !sockwouldblock(sockerrno)) {
 521                 if(sockmsgsize(sockerrno)) {
 522                         if(n->maxmtu >= origlen)
 523                                 n->maxmtu = origlen - 1;
 524                         if(n->mtu >= origlen)
 525                                 n->mtu = origlen - 1;
 526                 } else
 527                         logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
 528         }
 529
 530 end:
 531         origpkt->len = origlen;
 532 }
 533
 534 /*
 535   send a packet to the given vpn ip.
 536 */
 537 void send_packet(node_t *n, vpn_packet_t *packet) {
 538         node_t *via;
 539
 540         if(n == myself) {
 541                 if(overwrite_mac)
 542                          memcpy(packet->data, mymac.x, ETH_ALEN);
 543                 n->out_packets++;
 544                 n->out_bytes += packet->len;
 545                 devops.write(packet);
 546                 return;
 547         }
 548
 549         logger(DEBUG_TRAFFIC, LOG_ERR, "Sending packet of %d bytes to %s (%s)",
 550                            packet->len, n->name, n->hostname);
 551
 552         if(!n->status.reachable) {
 553                 logger(DEBUG_TRAFFIC, LOG_INFO, "Node %s (%s) is not reachable",
 554                                    n->name, n->hostname);
 555                 return;
 556         }
 557
 558         n->out_packets++;
 559         n->out_bytes += packet->len;
 560
 561         via = (packet->priority == -1 || n->via == myself) ? n->nexthop : n->via;
 562
 563         if(via != n)
 564                 logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet to %s via %s (%s)",
 565                            n->name, via->name, n->via->hostname);
 566
 567         if(packet->priority == -1 || ((myself->options | via->options) & OPTION_TCPONLY)) {
 568                 if(!send_tcppacket(via->connection, packet))
 569                         terminate_connection(via->connection, true);
 570         } else
 571                 send_udppacket(via, packet);
 572 }
 573
 574 /* Broadcast a packet using the minimum spanning tree */
 575
 576 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
 577         splay_node_t *node;
 578         connection_t *c;
 579
 580         logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
 581                            packet->len, from->name, from->hostname);
 582
 583         if(from != myself) {
 584                 send_packet(myself, packet);
 585
 586                 // In TunnelServer mode, do not forward broadcast packets.
 587                 // The MST might not be valid and create loops.
 588                 if(tunnelserver)
 589                         return;
 590         }
 591
 592         for(node = connection_tree->head; node; node = node->next) {
 593                 c = node->data;
 594
 595                 if(c->status.active && c->status.mst && c != from->nexthop->connection)
 596                         send_packet(c->node, packet);
 597         }
 598 }
 599
 600 static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
 601         splay_node_t *node;
 602         edge_t *e;
 603         node_t *n = NULL;
 604         bool hard = false;
 605         static time_t last_hard_try = 0;
 606         time_t now = time(NULL);
 607
 608         for(node = edge_weight_tree->head; node; node = node->next) {
 609                 e = node->data;
 610
 611                 if(e->to == myself)
 612                         continue;
 613
 614                 if(sockaddrcmp_noport(from, &e->address)) {
 615                         if(last_hard_try == now)
 616                                 continue;
 617                         hard = true;
 618                 }
 619
 620                 if(!try_mac(e->to, pkt))
 621                         continue;
 622
 623                 n = e->to;
 624                 break;
 625         }
 626
 627         if(hard)
 628                 last_hard_try = now;
 629
 630         last_hard_try = now;
 631         return n;
 632 }
 633
 634 void handle_incoming_vpn_data(int sock, short events, void *data) {
 635         vpn_packet_t pkt;
 636         char *hostname;
 637         sockaddr_t from;
 638         socklen_t fromlen = sizeof from;
 639         node_t *n;
 640         int len;
 641
 642         len = recvfrom(sock, (char *) &pkt.seqno, MAXSIZE, 0, &from.sa, &fromlen);
 643
 644         if(len <= 0 || len > MAXSIZE) {
 645                 if(!sockwouldblock(sockerrno))
 646                         logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
 647                 return;
 648         }
 649
 650         pkt.len = len;
 651
 652         sockaddrunmap(&from);           /* Some braindead IPv6 implementations do stupid things. */
 653
 654         n = lookup_node_udp(&from);
 655
 656         if(!n) {
 657                 n = try_harder(&from, &pkt);
 658                 if(n)
 659                         update_node_udp(n, &from);
 660                 else if(debug_level >= DEBUG_PROTOCOL) {
 661                         hostname = sockaddr2hostname(&from);
 662                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from unknown source %s", hostname);
 663                         free(hostname);
 664                         return;
 665                 }
 666                 else
 667                         return;
 668         }
 669
 670         n->sock = (intptr_t)data;
 671
 672         receive_udppacket(n, &pkt);
 673 }
 674
 675 void handle_device_data(int sock, short events, void *data) {
 676         vpn_packet_t packet;
 677
 678         packet.priority = 0;
 679
 680         if(devops.read(&packet)) {
 681                 myself->in_packets++;
 682                 myself->in_bytes += packet.len;
 683                 route(myself, &packet);
 684         }
 685 }