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