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 && n->nexthop && n->nexthop->connection) {
 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
 192                         if(n->nexthop && n->nexthop->connection) {
 193                                 send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
 194                         } else {
 195                                 logger(mesh, MESHLINK_WARNING, "Cannot send reflexive address to %s via %s", n->name, n->nexthop ? n->nexthop->name : n->name);
 196                         }
 197
 198                         free(address);
 199                         free(port);
 200                         n->status.udp_confirmed = true;
 201                 }
 202
 203                 /* If we haven't established the PMTU yet, restart the discovery process. */
 204
 205                 if(n->mtuprobes > 30) {
 206                         if(len == n->maxmtu + 8) {
 207                                 logger(mesh, MESHLINK_INFO, "Increase in PMTU to %s detected, restarting PMTU discovery", n->name);
 208                                 n->maxmtu = MTU;
 209                                 n->mtuprobes = 10;
 210                                 return;
 211                         }
 212
 213                         if(n->minmtu) {
 214                                 n->mtuprobes = 30;
 215                         } else {
 216                                 n->mtuprobes = 1;
 217                         }
 218                 }
 219
 220                 /* If applicable, raise the minimum supported MTU */
 221
 222                 if(len > n->maxmtu) {
 223                         len = n->maxmtu;
 224                 }
 225
 226                 if(n->minmtu < len) {
 227                         n->minmtu = len;
 228                         update_node_pmtu(mesh, n);
 229                 }
 230         }
 231 }
 232
 233 /* VPN packet I/O */
 234
 235 static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 236         logger(mesh, MESHLINK_DEBUG, "Received packet of %d bytes from %s", packet->len, n->name);
 237
 238         if(n->status.blacklisted) {
 239                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
 240         } else {
 241                 n->in_packets++;
 242                 n->in_bytes += packet->len;
 243
 244                 route(mesh, n, packet);
 245         }
 246 }
 247
 248 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
 249         (void)mesh;
 250         return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
 251 }
 252
 253 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
 254         if(!n->status.reachable) {
 255                 logger(mesh, MESHLINK_ERROR, "Got SPTPS data from unreachable node %s", n->name);
 256                 return;
 257         }
 258
 259         if(!n->sptps.state) {
 260                 if(!n->status.waitingforkey) {
 261                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but we haven't exchanged keys yet", n->name);
 262                         send_req_key(mesh, n);
 263                 } else {
 264                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but he hasn't got our key yet", n->name);
 265                 }
 266
 267                 return;
 268         }
 269
 270         if(!sptps_receive_data(&n->sptps, inpkt->data, inpkt->len)) {
 271                 logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", n->name, strerror(errno));
 272         }
 273 }
 274
 275 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 276         if(!n->status.reachable) {
 277                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", n->name);
 278                 return;
 279         }
 280
 281         if(!n->status.validkey) {
 282                 if(n->connection && (n->connection->flags & PROTOCOL_TINY) & n->connection->status.active) {
 283                         send_raw_packet(mesh, n->connection, origpkt);
 284                         return;
 285                 }
 286
 287                 logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
 288
 289                 if(!n->status.waitingforkey) {
 290                         send_req_key(mesh, n);
 291                 } else if(n->last_req_key + 10 < mesh->loop.now.tv_sec) {
 292                         logger(mesh, MESHLINK_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
 293                         sptps_stop(&n->sptps);
 294                         n->status.waitingforkey = false;
 295                         send_req_key(mesh, n);
 296                 }
 297
 298                 return;
 299         }
 300
 301         uint8_t type = 0;
 302
 303         // If it's a probe, send it immediately without trying to compress it.
 304         if(origpkt->probe) {
 305                 sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
 306                 return;
 307         }
 308
 309         sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
 310         return;
 311 }
 312
 313 static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock, sockaddr_t *sa_buf) {
 314         /* Latest guess */
 315         *sa = &n->address;
 316         *sock = n->sock;
 317
 318         /* If the UDP address is confirmed, use it. */
 319         if(n->status.udp_confirmed) {
 320                 return;
 321         }
 322
 323         /* Send every third packet to n->address; that could be set
 324            to the node's reflexive UDP address discovered during key
 325            exchange. */
 326
 327         if(++mesh->udp_choice >= 3) {
 328                 mesh->udp_choice = 0;
 329                 return;
 330         }
 331
 332         /* If we have learned an address via Catta, try this once every batch */
 333         if(mesh->udp_choice == 1 && n->catta_address.sa.sa_family != AF_UNSPEC) {
 334                 *sa = &n->catta_address;
 335                 goto check_socket;
 336         }
 337
 338         /* Else, if we have a canonical address, try this once every batch */
 339         if(mesh->udp_choice == 1 && n->canonical_address) {
 340                 char *host = xstrdup(n->canonical_address);
 341                 char *port = strchr(host, ' ');
 342
 343                 if(port) {
 344                         *port++ = 0;
 345                         *sa_buf = str2sockaddr_random(mesh, host, port);
 346                         *sa = sa_buf;
 347
 348                         if(sa_buf->sa.sa_family != AF_UNKNOWN) {
 349                                 free(host);
 350                                 goto check_socket;
 351                         }
 352                 }
 353
 354                 free(host);
 355         }
 356
 357         /* Otherwise, address are found in edges to this node.
 358            So we pick a random edge and a random socket. */
 359
 360         edge_t *candidate = NULL;
 361
 362         {
 363                 int i = 0;
 364                 int j = prng(mesh, n->edge_tree->count);
 365
 366                 for splay_each(edge_t, e, n->edge_tree) {
 367                         if(i++ == j) {
 368                                 candidate = e->reverse;
 369                                 break;
 370                         }
 371                 }
 372         }
 373
 374         if(candidate) {
 375                 *sa = &candidate->address;
 376                 *sock = prng(mesh, mesh->listen_sockets);
 377         }
 378
 379 check_socket:
 380
 381         /* Make sure we have a suitable socket for the chosen address */
 382         if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
 383                 for(int i = 0; i < mesh->listen_sockets; i++) {
 384                         if(mesh->listen_socket[i].sa.sa.sa_family == (*sa)->sa.sa_family) {
 385                                 *sock = i;
 386                                 break;
 387                         }
 388                 }
 389         }
 390 }
 391
 392 static void choose_broadcast_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
 393         *sock = prng(mesh, mesh->listen_sockets);
 394         sockaddr_t *broadcast_sa = &mesh->listen_socket[*sock].broadcast_sa;
 395
 396         if(broadcast_sa->sa.sa_family == AF_INET6) {
 397                 broadcast_sa->in6.sin6_port = n->prevedge->address.in.sin_port;
 398         } else {
 399                 broadcast_sa->in.sin_port = n->prevedge->address.in.sin_port;
 400         }
 401
 402         *sa = broadcast_sa;
 403 }
 404
 405 static void send_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 406         if(!n->status.reachable) {
 407                 logger(mesh, MESHLINK_INFO, "Trying to send UDP packet to unreachable node %s", n->name);
 408                 return;
 409         }
 410
 411         send_sptps_packet(mesh, n, origpkt);
 412 }
 413
 414 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
 415         assert(handle);
 416         assert(data);
 417         assert(len);
 418
 419         node_t *to = handle;
 420         meshlink_handle_t *mesh = to->mesh;
 421
 422         if(!to->status.reachable) {
 423                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", to->name);
 424                 return false;
 425         }
 426
 427         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 428
 429         if(type >= SPTPS_HANDSHAKE || (type != PKT_PROBE && (len - 21) > to->minmtu)) {
 430                 char buf[len * 4 / 3 + 5];
 431                 b64encode(data, buf, len);
 432
 433                 if(!to->nexthop || !to->nexthop->connection) {
 434                         logger(mesh, MESHLINK_WARNING, "Unable to forward SPTPS packet to %s via %s", to->name, to->nexthop ? to->nexthop->name : to->name);
 435                         return false;
 436                 }
 437
 438                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
 439                    to ensure we get to learn the reflexive UDP address. */
 440                 if(!to->status.validkey) {
 441                         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);
 442                 } else {
 443                         return send_request(mesh, to->nexthop->connection, NULL, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
 444                 }
 445         }
 446
 447         /* Otherwise, send the packet via UDP */
 448
 449         sockaddr_t sa_buf;
 450         const sockaddr_t *sa;
 451         int sock;
 452
 453         if(to->status.broadcast) {
 454                 choose_broadcast_address(mesh, to, &sa, &sock);
 455         } else {
 456                 choose_udp_address(mesh, to, &sa, &sock, &sa_buf);
 457         }
 458
 459         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
 460                 if(sockmsgsize(sockerrno)) {
 461                         if(to->maxmtu >= len) {
 462                                 to->maxmtu = len - 1;
 463                         }
 464
 465                         if(to->mtu >= len) {
 466                                 to->mtu = len - 1;
 467                         }
 468                 } else {
 469                         logger(mesh, MESHLINK_WARNING, "Error sending UDP SPTPS packet to %s: %s", to->name, sockstrerror(sockerrno));
 470                         return false;
 471                 }
 472         }
 473
 474         return true;
 475 }
 476
 477 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
 478         assert(handle);
 479         assert(!data || len);
 480
 481         node_t *from = handle;
 482         meshlink_handle_t *mesh = from->mesh;
 483
 484         if(type == SPTPS_HANDSHAKE) {
 485                 if(!from->status.validkey) {
 486                         logger(mesh, MESHLINK_INFO, "SPTPS key exchange with %s successful", from->name);
 487                         from->status.validkey = true;
 488                         from->status.waitingforkey = false;
 489
 490                         if(from->utcp) {
 491                                 utcp_reset_timers(from->utcp);
 492                         }
 493                 }
 494
 495                 return true;
 496         }
 497
 498         if(len > MAXSIZE) {
 499                 logger(mesh, MESHLINK_ERROR, "Packet from %s larger than maximum supported size (%d > %d)", from->name, len, MAXSIZE);
 500                 return false;
 501         }
 502
 503         vpn_packet_t inpkt;
 504
 505         if(type == PKT_PROBE) {
 506                 inpkt.len = len;
 507                 inpkt.probe = true;
 508                 memcpy(inpkt.data, data, len);
 509                 mtu_probe_h(mesh, from, &inpkt, len);
 510                 return true;
 511         } else {
 512                 inpkt.probe = false;
 513         }
 514
 515         if(type & ~(PKT_COMPRESSED)) {
 516                 logger(mesh, MESHLINK_ERROR, "Unexpected SPTPS record type %d len %d from %s", type, len, from->name);
 517                 return false;
 518         }
 519
 520         if(type & PKT_COMPRESSED) {
 521                 logger(mesh, MESHLINK_ERROR, "Error while decompressing packet from %s", from->name);
 522                 return false;
 523         }
 524
 525         memcpy(inpkt.data, data, len); // TODO: get rid of memcpy
 526         inpkt.len = len;
 527
 528         receive_packet(mesh, from, &inpkt);
 529         return true;
 530 }
 531
 532 /*
 533   send a packet to the given vpn ip.
 534 */
 535 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
 536         if(n == mesh->self) {
 537                 n->out_packets++;
 538                 n->out_bytes += packet->len;
 539                 // TODO: send to application
 540                 return;
 541         }
 542
 543         logger(mesh, MESHLINK_DEBUG, "Sending packet of %d bytes to %s", packet->len, n->name);
 544
 545         if(!n->status.reachable) {
 546                 logger(mesh, MESHLINK_WARNING, "Node %s is not reachable", n->name);
 547                 return;
 548         }
 549
 550         n->out_packets++;
 551         n->out_bytes += packet->len;
 552         n->status.want_udp = true;
 553
 554         send_sptps_packet(mesh, n, packet);
 555         return;
 556 }
 557
 558 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
 559         node_t *n = NULL;
 560         bool hard = false;
 561
 562         for splay_each(edge_t, e, mesh->edges) {
 563                 if(!e->to->status.reachable || e->to == mesh->self) {
 564                         continue;
 565                 }
 566
 567                 if(sockaddrcmp_noport(from, &e->address)) {
 568                         if(mesh->last_hard_try == mesh->loop.now.tv_sec) {
 569                                 continue;
 570                         }
 571
 572                         hard = true;
 573                 }
 574
 575                 if(!try_mac(mesh, e->to, pkt)) {
 576                         continue;
 577                 }
 578
 579                 n = e->to;
 580                 break;
 581         }
 582
 583         if(hard) {
 584                 mesh->last_hard_try = mesh->loop.now.tv_sec;
 585         }
 586
 587         return n;
 588 }
 589
 590 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
 591         (void)flags;
 592         meshlink_handle_t *mesh = loop->data;
 593         listen_socket_t *ls = data;
 594         vpn_packet_t pkt;
 595         char *hostname;
 596         sockaddr_t from;
 597         socklen_t fromlen = sizeof(from);
 598         node_t *n;
 599         int len;
 600
 601         memset(&from, 0, sizeof(from));
 602
 603         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
 604
 605         if(len <= 0 || len > MAXSIZE) {
 606                 if(!sockwouldblock(sockerrno)) {
 607                         logger(mesh, MESHLINK_ERROR, "Receiving packet failed: %s", sockstrerror(sockerrno));
 608                 }
 609
 610                 return;
 611         }
 612
 613         pkt.len = len;
 614
 615         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
 616
 617         n = lookup_node_udp(mesh, &from);
 618
 619         if(!n) {
 620                 n = try_harder(mesh, &from, &pkt);
 621
 622                 if(n) {
 623                         update_node_udp(mesh, n, &from);
 624                 } else if(mesh->log_level <= MESHLINK_WARNING) {
 625                         hostname = sockaddr2hostname(&from);
 626                         logger(mesh, MESHLINK_WARNING, "Received UDP packet from unknown source %s", hostname);
 627                         free(hostname);
 628                         return;
 629                 } else {
 630                         return;
 631                 }
 632         }
 633
 634         if(n->status.blacklisted) {
 635                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
 636                 return;
 637         }
 638
 639         n->sock = ls - mesh->listen_socket;
 640
 641         receive_udppacket(mesh, n, &pkt);
 642 }