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