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