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