]> git.meshlink.io Git - meshlink/blob - src/net_packet.c
Move timespec functions to utils.h.
[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 "sptps.h"
33 #include "utils.h"
34 #include "xalloc.h"
35
36 int keylifetime = 0;
37
38 static void send_udppacket(meshlink_handle_t *mesh, node_t *, vpn_packet_t *);
39
40 #define MAX_SEQNO 1073741824
41 #define PROBE_OVERHEAD (SPTPS_DATAGRAM_OVERHEAD + 40)
42
43 /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
44    mtuprobes ==    31: sleep pinginterval seconds
45    mtuprobes ==    32: send 1 burst, sleep pingtimeout second
46    mtuprobes ==    33: no response from other side, restart PMTU discovery process
47
48    Probes are sent in batches of at least three, with random sizes between the
49    lower and upper boundaries for the MTU thus far discovered.
50
51    After the initial discovery, a fourth packet is added to each batch with a
52    size larger than the currently known PMTU, to test if the PMTU has increased.
53
54    In case local discovery is enabled, another packet is added to each batch,
55    which will be broadcast to the local network.
56
57 */
58
59 static void send_mtu_probe_handler(event_loop_t *loop, void *data) {
60         meshlink_handle_t *mesh = loop->data;
61         node_t *n = data;
62         int timeout = 1;
63
64         n->mtuprobes++;
65
66         if(!n->status.reachable || !n->status.validkey) {
67                 logger(mesh, MESHLINK_INFO, "Trying to send MTU probe to unreachable or rekeying node %s", n->name);
68                 n->mtuprobes = 0;
69                 return;
70         }
71
72         if(n->mtuprobes > 32) {
73                 if(!n->minmtu) {
74                         n->mtuprobes = 31;
75                         timeout = mesh->dev_class_traits[n->devclass].pinginterval;
76                         goto end;
77                 }
78
79                 logger(mesh, MESHLINK_INFO, "%s did not respond to UDP ping, restarting PMTU discovery", n->name);
80                 n->status.udp_confirmed = false;
81                 n->mtuprobes = 1;
82                 n->minmtu = 0;
83                 n->maxmtu = MTU;
84
85                 update_node_pmtu(mesh, n);
86         }
87
88         if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
89                 logger(mesh, MESHLINK_INFO, "No response to MTU probes from %s", n->name);
90                 n->mtuprobes = 31;
91         }
92
93         if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
94                 if(n->minmtu > n->maxmtu) {
95                         n->minmtu = n->maxmtu;
96                         update_node_pmtu(mesh, n);
97                 } else {
98                         n->maxmtu = n->minmtu;
99                 }
100
101                 n->mtu = n->minmtu;
102                 logger(mesh, MESHLINK_INFO, "Fixing MTU of %s to %d after %d probes", n->name, n->mtu, n->mtuprobes);
103                 n->mtuprobes = 31;
104         }
105
106         if(n->mtuprobes == 31) {
107                 if(!n->minmtu && n->status.want_udp && n->nexthop && n->nexthop->connection) {
108                         /* Send a dummy ANS_KEY to try to update the reflexive UDP address */
109                         send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0", ANS_KEY, mesh->self->name, n->name);
110                         n->status.want_udp = false;
111                 }
112
113                 timeout = mesh->dev_class_traits[n->devclass].pinginterval;
114                 goto end;
115         } else if(n->mtuprobes == 32) {
116                 timeout = mesh->dev_class_traits[n->devclass].pingtimeout;
117         }
118
119         for(int i = 0; i < 5; i++) {
120                 int len;
121
122                 if(i == 0) {
123                         if(n->mtuprobes < 30 || n->maxmtu + 8 >= MTU) {
124                                 continue;
125                         }
126
127                         len = n->maxmtu + 8;
128                 } else if(n->maxmtu <= n->minmtu) {
129                         len = n->maxmtu;
130                 } else {
131                         len = n->minmtu + 1 + prng(mesh, n->maxmtu - n->minmtu);
132                 }
133
134                 if(len < 64) {
135                         len = 64;
136                 }
137
138                 vpn_packet_t packet;
139                 packet.probe = true;
140                 memset(packet.data, 0, 14);
141                 randomize(packet.data + 14, len - 14);
142                 packet.len = len;
143                 n->status.broadcast = i >= 4 && n->mtuprobes <= 10 && n->prevedge;
144
145                 logger(mesh, MESHLINK_DEBUG, "Sending MTU probe length %d to %s", len, n->name);
146
147                 n->out_meta += packet.len + PROBE_OVERHEAD;
148                 send_udppacket(mesh, n, &packet);
149         }
150
151         n->status.broadcast = false;
152
153 end:
154         timeout_set(&mesh->loop, &n->mtutimeout, &(struct timespec) {
155                 timeout, prng(mesh, TIMER_FUDGE)
156         });
157 }
158
159 void send_mtu_probe(meshlink_handle_t *mesh, node_t *n) {
160         timeout_add(&mesh->loop, &n->mtutimeout, send_mtu_probe_handler, n, &(struct timespec) {
161                 1, 0
162         });
163         send_mtu_probe_handler(&mesh->loop, n);
164 }
165
166 static void mtu_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet, uint16_t len) {
167         n->in_meta += len + PROBE_OVERHEAD;
168
169         if(len < 64) {
170                 logger(mesh, MESHLINK_WARNING, "Got too short MTU probe length %d from %s", packet->len, n->name);
171                 return;
172         }
173
174         logger(mesh, MESHLINK_DEBUG, "Got MTU probe length %d from %s", packet->len, n->name);
175
176         if(!packet->data[0]) {
177                 /* It's a probe request, send back a reply */
178
179                 packet->data[0] = 1;
180
181                 /* Temporarily set udp_confirmed, so that the reply is sent
182                    back exactly the way it came in. */
183
184                 bool udp_confirmed = n->status.udp_confirmed;
185                 n->status.udp_confirmed = true;
186                 logger(mesh, MESHLINK_DEBUG, "Sending MTU probe reply %d to %s", packet->len, n->name);
187                 n->out_meta += packet->len + PROBE_OVERHEAD;
188                 send_udppacket(mesh, n, packet);
189                 n->status.udp_confirmed = udp_confirmed;
190         } else {
191                 /* It's a valid reply: now we know bidirectional communication
192                    is possible using the address and socket that the reply
193                    packet used. */
194
195                 if(!n->status.udp_confirmed) {
196                         char *address, *port;
197                         sockaddr2str(&n->address, &address, &port);
198
199                         if(n->nexthop && n->nexthop->connection) {
200                                 send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
201                         } else {
202                                 logger(mesh, MESHLINK_WARNING, "Cannot send reflexive address to %s via %s", n->name, n->nexthop ? n->nexthop->name : n->name);
203                         }
204
205                         free(address);
206                         free(port);
207                         n->status.udp_confirmed = true;
208                 }
209
210                 /* If we haven't established the PMTU yet, restart the discovery process. */
211
212                 if(n->mtuprobes > 30) {
213                         if(len == n->maxmtu + 8) {
214                                 logger(mesh, MESHLINK_INFO, "Increase in PMTU to %s detected, restarting PMTU discovery", n->name);
215                                 n->maxmtu = MTU;
216                                 n->mtuprobes = 10;
217                                 return;
218                         }
219
220                         if(n->minmtu) {
221                                 n->mtuprobes = 30;
222                         } else {
223                                 n->mtuprobes = 1;
224                         }
225                 }
226
227                 /* If applicable, raise the minimum supported MTU */
228
229                 if(len > n->maxmtu) {
230                         len = n->maxmtu;
231                 }
232
233                 if(n->minmtu < len) {
234                         n->minmtu = len;
235                         update_node_pmtu(mesh, n);
236                 }
237         }
238 }
239
240 /* VPN packet I/O */
241
242 static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
243         logger(mesh, MESHLINK_DEBUG, "Received packet of %d bytes from %s", packet->len, n->name);
244
245         if(n->status.blacklisted) {
246                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
247         } else {
248                 route(mesh, n, packet);
249         }
250 }
251
252 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
253         (void)mesh;
254         return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
255 }
256
257 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
258         if(!n->status.reachable) {
259                 logger(mesh, MESHLINK_ERROR, "Got SPTPS data from unreachable node %s", n->name);
260                 return;
261         }
262
263         if(!n->sptps.state) {
264                 if(!n->status.waitingforkey) {
265                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but we haven't exchanged keys yet", n->name);
266                         send_req_key(mesh, n);
267                 } else {
268                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but he hasn't got our key yet", n->name);
269                 }
270
271                 return;
272         }
273
274         if(!sptps_receive_data(&n->sptps, inpkt->data, inpkt->len)) {
275                 logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", n->name, strerror(errno));
276         }
277 }
278
279 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
280         if(!n->status.reachable) {
281                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", n->name);
282                 return;
283         }
284
285         if(!n->status.validkey) {
286                 if(n->connection && (n->connection->flags & PROTOCOL_TINY) & n->connection->status.active) {
287                         send_raw_packet(mesh, n->connection, origpkt);
288                         return;
289                 }
290
291                 logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
292
293                 if(!n->status.waitingforkey) {
294                         send_req_key(mesh, n);
295                 } else if(n->last_req_key + 10 < mesh->loop.now.tv_sec) {
296                         logger(mesh, MESHLINK_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
297                         sptps_stop(&n->sptps);
298                         n->status.waitingforkey = false;
299                         send_req_key(mesh, n);
300                 }
301
302                 return;
303         }
304
305         uint8_t type = 0;
306
307         // If it's a probe, send it immediately without trying to compress it.
308         if(origpkt->probe) {
309                 sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
310                 return;
311         }
312
313         sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
314         return;
315 }
316
317 static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock, sockaddr_t *sa_buf) {
318         /* Latest guess */
319         *sa = &n->address;
320         *sock = n->sock;
321
322         /* If the UDP address is confirmed, use it. */
323         if(n->status.udp_confirmed) {
324                 return;
325         }
326
327         /* Send every third packet to n->address; that could be set
328            to the node's reflexive UDP address discovered during key
329            exchange. */
330
331         if(++mesh->udp_choice >= 3) {
332                 mesh->udp_choice = 0;
333                 return;
334         }
335
336         /* If we have learned an address via Catta, try this once every batch */
337         if(mesh->udp_choice == 1 && n->catta_address.sa.sa_family != AF_UNSPEC) {
338                 *sa = &n->catta_address;
339                 goto check_socket;
340         }
341
342         /* Else, if we have a canonical address, try this once every batch */
343         if(mesh->udp_choice == 1 && n->canonical_address) {
344                 char *host = xstrdup(n->canonical_address);
345                 char *port = strchr(host, ' ');
346
347                 if(port) {
348                         *port++ = 0;
349                         *sa_buf = str2sockaddr_random(mesh, host, port);
350                         *sa = sa_buf;
351
352                         if(sa_buf->sa.sa_family != AF_UNKNOWN) {
353                                 free(host);
354                                 goto check_socket;
355                         }
356                 }
357
358                 free(host);
359         }
360
361         /* Otherwise, address are found in edges to this node.
362            So we pick a random edge and a random socket. */
363
364         edge_t *candidate = NULL;
365
366         {
367                 int i = 0;
368                 int j = prng(mesh, n->edge_tree->count);
369
370                 for splay_each(edge_t, e, n->edge_tree) {
371                         if(i++ == j) {
372                                 candidate = e->reverse;
373                                 break;
374                         }
375                 }
376         }
377
378         if(candidate) {
379                 *sa = &candidate->address;
380                 *sock = prng(mesh, mesh->listen_sockets);
381         }
382
383 check_socket:
384
385         /* Make sure we have a suitable socket for the chosen address */
386         if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
387                 for(int i = 0; i < mesh->listen_sockets; i++) {
388                         if(mesh->listen_socket[i].sa.sa.sa_family == (*sa)->sa.sa_family) {
389                                 *sock = i;
390                                 break;
391                         }
392                 }
393         }
394 }
395
396 static void choose_broadcast_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
397         *sock = prng(mesh, mesh->listen_sockets);
398         sockaddr_t *broadcast_sa = &mesh->listen_socket[*sock].broadcast_sa;
399
400         if(broadcast_sa->sa.sa_family == AF_INET6) {
401                 broadcast_sa->in6.sin6_port = n->prevedge->address.in.sin_port;
402         } else {
403                 broadcast_sa->in.sin_port = n->prevedge->address.in.sin_port;
404         }
405
406         *sa = broadcast_sa;
407 }
408
409 static void send_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
410         if(!n->status.reachable) {
411                 logger(mesh, MESHLINK_INFO, "Trying to send UDP packet to unreachable node %s", n->name);
412                 return;
413         }
414
415         send_sptps_packet(mesh, n, origpkt);
416 }
417
418 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
419         assert(handle);
420         assert(data);
421         assert(len);
422
423         node_t *to = handle;
424         meshlink_handle_t *mesh = to->mesh;
425
426         if(!to->status.reachable) {
427                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", to->name);
428                 return false;
429         }
430
431         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
432
433         if(type >= SPTPS_HANDSHAKE || (type != PKT_PROBE && (len - 21) > to->minmtu)) {
434                 char buf[len * 4 / 3 + 5];
435                 b64encode(data, buf, len);
436
437                 if(!to->nexthop || !to->nexthop->connection) {
438                         logger(mesh, MESHLINK_WARNING, "Unable to forward SPTPS packet to %s via %s", to->name, to->nexthop ? to->nexthop->name : to->name);
439                         return false;
440                 }
441
442                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
443                    to ensure we get to learn the reflexive UDP address. */
444                 if(!to->status.validkey) {
445                         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);
446                 } else {
447                         return send_request(mesh, to->nexthop->connection, NULL, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
448                 }
449         }
450
451         /* Otherwise, send the packet via UDP */
452
453         sockaddr_t sa_buf;
454         const sockaddr_t *sa;
455         int sock;
456
457         if(to->status.broadcast) {
458                 choose_broadcast_address(mesh, to, &sa, &sock);
459         } else {
460                 choose_udp_address(mesh, to, &sa, &sock, &sa_buf);
461         }
462
463         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
464                 if(sockmsgsize(sockerrno)) {
465                         if(to->maxmtu >= len) {
466                                 to->maxmtu = len - 1;
467                         }
468
469                         if(to->mtu >= len) {
470                                 to->mtu = len - 1;
471                         }
472                 } else {
473                         logger(mesh, MESHLINK_WARNING, "Error sending UDP SPTPS packet to %s: %s", to->name, sockstrerror(sockerrno));
474                         return false;
475                 }
476         }
477
478         return true;
479 }
480
481 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
482         assert(handle);
483         assert(!data || len);
484
485         node_t *from = handle;
486         meshlink_handle_t *mesh = from->mesh;
487
488         if(type == SPTPS_HANDSHAKE) {
489                 if(!from->status.validkey) {
490                         logger(mesh, MESHLINK_INFO, "SPTPS key exchange with %s successful", from->name);
491                         from->status.validkey = true;
492                         from->status.waitingforkey = false;
493
494                         if(from->utcp) {
495                                 utcp_reset_timers(from->utcp);
496                         }
497                 }
498
499                 return true;
500         }
501
502         if(len > MAXSIZE) {
503                 logger(mesh, MESHLINK_ERROR, "Packet from %s larger than maximum supported size (%d > %d)", from->name, len, MAXSIZE);
504                 return false;
505         }
506
507         vpn_packet_t inpkt;
508
509         if(type == PKT_PROBE) {
510                 inpkt.len = len;
511                 inpkt.probe = true;
512                 memcpy(inpkt.data, data, len);
513                 mtu_probe_h(mesh, from, &inpkt, len);
514                 return true;
515         } else {
516                 inpkt.probe = false;
517         }
518
519         if(type & ~(PKT_COMPRESSED)) {
520                 logger(mesh, MESHLINK_ERROR, "Unexpected SPTPS record type %d len %d from %s", type, len, from->name);
521                 return false;
522         }
523
524         if(type & PKT_COMPRESSED) {
525                 logger(mesh, MESHLINK_ERROR, "Error while decompressing packet from %s", from->name);
526                 return false;
527         }
528
529         memcpy(inpkt.data, data, len); // TODO: get rid of memcpy
530         inpkt.len = len;
531
532         receive_packet(mesh, from, &inpkt);
533         return true;
534 }
535
536 /*
537   send a packet to the given vpn ip.
538 */
539 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
540         if(n == mesh->self) {
541                 // TODO: send to application
542                 return;
543         }
544
545         logger(mesh, MESHLINK_DEBUG, "Sending packet of %d bytes to %s", packet->len, n->name);
546
547         if(!n->status.reachable) {
548                 logger(mesh, MESHLINK_WARNING, "Node %s is not reachable", n->name);
549                 return;
550         }
551
552         n->status.want_udp = true;
553
554         send_sptps_packet(mesh, n, packet);
555         return;
556 }
557
558 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
559         node_t *n = NULL;
560         bool hard = false;
561
562         for splay_each(edge_t, e, mesh->edges) {
563                 if(!e->to->status.reachable || e->to == mesh->self) {
564                         continue;
565                 }
566
567                 if(sockaddrcmp_noport(from, &e->address)) {
568                         if(mesh->last_hard_try == mesh->loop.now.tv_sec) {
569                                 continue;
570                         }
571
572                         hard = true;
573                 }
574
575                 if(!try_mac(mesh, e->to, pkt)) {
576                         continue;
577                 }
578
579                 n = e->to;
580                 break;
581         }
582
583         if(hard) {
584                 mesh->last_hard_try = mesh->loop.now.tv_sec;
585         }
586
587         return n;
588 }
589
590 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
591         (void)flags;
592         meshlink_handle_t *mesh = loop->data;
593         listen_socket_t *ls = data;
594         vpn_packet_t pkt;
595         char *hostname;
596         sockaddr_t from;
597         socklen_t fromlen = sizeof(from);
598         node_t *n;
599         int len;
600
601         memset(&from, 0, sizeof(from));
602
603         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
604
605         if(len <= 0 || len > MAXSIZE) {
606                 if(!sockwouldblock(sockerrno)) {
607                         logger(mesh, MESHLINK_ERROR, "Receiving packet failed: %s", sockstrerror(sockerrno));
608                 }
609
610                 return;
611         }
612
613         pkt.len = len;
614
615         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
616
617         n = lookup_node_udp(mesh, &from);
618
619         if(!n) {
620                 n = try_harder(mesh, &from, &pkt);
621
622                 if(n) {
623                         update_node_udp(mesh, n, &from);
624                 } else if(mesh->log_level <= MESHLINK_WARNING) {
625                         hostname = sockaddr2hostname(&from);
626                         logger(mesh, MESHLINK_WARNING, "Received UDP packet from unknown source %s", hostname);
627                         free(hostname);
628                         return;
629                 } else {
630                         return;
631                 }
632         }
633
634         if(n->status.blacklisted) {
635                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
636                 return;
637         }
638
639         n->sock = ls - mesh->listen_socket;
640
641         receive_udppacket(mesh, n, &pkt);
642 }