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