]> git.meshlink.io Git - meshlink/blob - src/pmtu.c
7d238e2515efc41ae4bd69132655ca35f75a13b5
[meshlink] / src / pmtu.c
1 /*
2     pmtu.c -- PMTU probing
3     Copyright (C) 2020 Guus Sliepen <guus@tinc-vpn.org>
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 "crypto.h"
23 #include "logger.h"
24 #include "net.h"
25 #include "netutl.h"
26 #include "node.h"
27 #include "pmtu.h"
28 #include "protocol.h"
29 #include "utils.h"
30
31 /* PMTU probing serves two purposes:
32  *
33  * - establishing a working UDP connection between two peers
34  * - determining the path MTU (PMTU) between two peers
35  *
36  * Establishing a working UDP connection requires NAT hole punching and regular
37  * packets to keep the NAT mappings alive.  For this, we can use very small UDP
38  * packets, and send them rather frequently (once every 10 seconds).  This also
39  * allows us to detect connection loss rather quickly.
40  *
41  * For PMTU discovery, we need to send packets of various size, and determine
42  * which ones are received by the other end.  Once the PMTU is established, we
43  * want to keep monitoring that the discovered PMTU value is still valid.
44  * However, we assume PMTU changes are unlikely, so they do not have to be done
45  * very often.
46  *
47  * To keep track of how far we are in the PMTU probing process, the variable
48  * mtuprobes is used. The meaning of its value is:
49  *
50  * - mtuprobes ==    -4: maxmtu no longer valid, reset minmtu and maxmtu and go to 0
51  * - mtuprobes ==-2..-3: send one maxmtu probe every second
52  * - mtuprobes ==    -1: send one maxmtu and one maxmtu + 1 probe every pinginterval
53  * - mtuprobes == 0..19: initial discovery, send three packets per second, mtuprobes++
54  * - mtuprobes ==    20: fix PMTU, and go to -1
55  *
56  * The first probe is always the maximum MTU supported by the interface,
57  * then a binary search is done until the minimum and maximum converge,
58  * or until 20 packets have been sent.
59  *
60  * After the initial discovery, PMTU probing only sends two packets; one with
61  * the same size as the discovered PMTU, and one which has a size slightly
62  * larger than the currently known PMTU, to test if the PMTU has increased.
63  */
64
65 static void try_fix_mtu(meshlink_handle_t *mesh, node_t *n) {
66         if(n->mtuprobes < 0) {
67                 return;
68         }
69
70         if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) {
71                 if(n->minmtu > n->maxmtu) {
72                         n->minmtu = n->maxmtu;
73                 } else {
74                         n->maxmtu = n->minmtu;
75                 }
76
77                 n->mtu = n->minmtu;
78                 logger(mesh, MESHLINK_INFO, "Fixing PMTU of %s to %d after %d probes", n->name, n->mtu, n->mtuprobes);
79                 n->mtuprobes = -1;
80         }
81 }
82
83 static void udp_probe_timeout_handler(event_loop_t *loop, void *data) {
84         node_t *n = data;
85         meshlink_handle_t *mesh = loop->data;
86
87         if(!n->status.udp_confirmed) {
88                 return;
89         }
90
91         logger(mesh, MESHLINK_INFO, "Too much time has elapsed since last UDP ping response from %s, stopping UDP communication", n->name);
92         n->status.udp_confirmed = false;
93         n->mtuprobes = 0;
94         n->udpprobes = 0;
95         n->minmtu = 0;
96         n->maxmtu = MTU;
97
98         // If we also have a meta-connection to this node, send a PING on it as well
99         connection_t *c = n->connection;
100
101         if(c && !c->status.pinged) {
102                 send_ping(mesh, c);
103         }
104 }
105
106 static void send_udp_probe_reply(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet, uint16_t len) {
107         if(!n->status.validkey) {
108                 logger(mesh, MESHLINK_INFO, "Trying to send UDP probe reply to %s but we don't have his key yet", n->name);
109                 return;
110         }
111
112         packet->data[0] = 1;
113
114         if(packet->data[1]) {
115                 packet->data[1] = 1;
116                 memcpy(packet->data + 2, &len, 2);
117                 len = MIN_PROBE_SIZE;
118         }
119
120         /* Temporarily set udp_confirmed, so that the reply is sent
121            back exactly the way it came in. */
122
123         bool udp_confirmed = n->status.udp_confirmed;
124         n->status.udp_confirmed = true;
125         logger(mesh, MESHLINK_DEBUG, "Sending UDP reply length %d to %s", packet->len, n->name);
126         n->out_meta += packet->len + SPTPS_DATAGRAM_OVERHEAD;
127         send_udppacket(mesh, n, packet);
128         n->status.udp_confirmed = udp_confirmed;
129 }
130
131 void udp_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet, uint16_t len) {
132         if(len < MIN_PROBE_SIZE) {
133                 logger(mesh, MESHLINK_WARNING, "Got too short PMTU probe length %d from %s", packet->len, n->name);
134                 return;
135         }
136
137         n->in_meta += packet->len + SPTPS_DATAGRAM_OVERHEAD;
138
139         if(!packet->data[0]) {
140                 /* It's a probe request, send back a reply */
141                 logger(mesh, MESHLINK_DEBUG, "Got PMTU probe length %d from %s", packet->len, n->name);
142                 send_udp_probe_reply(mesh, n, packet, len);
143                 return;
144         }
145
146         if(packet->data[1]) {
147                 memcpy(&len, packet->data + 2, 2);
148         }
149
150         logger(mesh, MESHLINK_DEBUG, "Got PMTU reply length %d from %s", len, n->name);
151
152         /* It's a valid reply: now we know bidirectional communication
153            is possible using the address and socket that the reply
154            packet used. */
155         if(!n->status.udp_confirmed) {
156                 char *address, *port;
157                 sockaddr2str(&n->address, &address, &port);
158                 send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
159
160                 free(address);
161                 free(port);
162                 n->status.udp_confirmed = true;
163         }
164
165         n->udpprobes = 0;
166
167         // Reset the UDP ping timer.
168
169         timeout_del(&mesh->loop, &n->udp_ping_timeout);
170         timeout_add(&mesh->loop, &n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timespec) {
171                 30, 0
172         });
173
174         if(len > n->maxmtu) {
175                 logger(mesh, MESHLINK_INFO, "Increase in PMTU to %s detected, restarting PMTU discovery", n->name);
176                 n->minmtu = len;
177                 n->maxmtu = MTU;
178                 /* Set mtuprobes to 1 so that try_pmtu() doesn't reset maxmtu */
179                 n->mtuprobes = 1;
180                 return;
181         } else if(n->mtuprobes < 0 && len == n->maxmtu) {
182                 /* We got a maxmtu sized packet, confirming the PMTU is still valid. */
183                 n->mtuprobes = -1;
184                 n->last_mtu_probe_sent = mesh->loop.now;
185         }
186
187         /* If applicable, raise the minimum supported PMTU */
188
189         if(n->minmtu < len) {
190                 n->minmtu = len;
191                 update_node_pmtu(mesh, n);
192         }
193
194         try_fix_mtu(mesh, n);
195 }
196
197 static void send_udp_probe_packet(meshlink_handle_t *mesh, node_t *n, int len) {
198         if(len < MIN_PROBE_SIZE) {
199                 len = MIN_PROBE_SIZE;
200         }
201
202         vpn_packet_t packet;
203         memset(packet.data, 0, 4);
204         packet.probe = true;
205         packet.data[0] = 0;
206         packet.data[1] = 1;
207         packet.data[2] = 0;
208         packet.data[3] = 0;
209
210         if(len > 4) {
211                 randomize(packet.data + 4, len - 4);
212         }
213
214         packet.len = len;
215
216         logger(mesh, MESHLINK_DEBUG, "Sending UDP probe length %d to %s", len, n->name);
217
218         n->out_meta += packet.len + SPTPS_DATAGRAM_OVERHEAD;
219         send_udppacket(mesh, n, &packet);
220 }
221
222 static void try_udp(meshlink_handle_t *mesh, node_t *n) {
223         /* Probe request */
224
225         if(n->udpprobes < -3) {
226                 /* We lost three UDP probes, UDP status is no longer unconfirmed */
227                 udp_probe_timeout_handler(&mesh->loop, n);
228         }
229
230         struct timespec elapsed;
231
232         timespec_sub(&mesh->loop.now, &n->last_udp_probe_sent, &elapsed);
233
234         int interval = (n->status.udp_confirmed && n->udpprobes >= 0) ? 10 : 2;
235
236         if(elapsed.tv_sec >= interval) {
237                 n->last_udp_probe_sent = mesh->loop.now;
238                 send_udp_probe_packet(mesh, n, MIN_PROBE_SIZE);
239
240                 if(n->status.udp_confirmed) {
241                         n->udpprobes--;
242                 }
243
244                 if(!n->status.udp_confirmed && n->prevedge) {
245                         n->status.broadcast = true;
246                         send_udp_probe_packet(mesh, n, MIN_PROBE_SIZE);
247                         n->status.broadcast = false;
248                 }
249         }
250 }
251
252 static uint16_t choose_initial_maxmtu(meshlink_handle_t *mesh, node_t *n) {
253 #ifdef IP_MTU
254
255         int sock = -1;
256
257         sockaddr_t sa_buf;
258         const sockaddr_t *sa;
259         int sockindex;
260         choose_udp_address(mesh, n, &sa, &sockindex, &sa_buf);
261
262         if(!sa) {
263                 return MTU;
264         }
265
266         sock = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
267
268         if(sock < 0) {
269                 logger(mesh, MESHLINK_ERROR, "Creating MTU assessment socket for %s failed: %s", n->name, sockstrerror(sockerrno));
270                 return MTU;
271         }
272
273         if(connect(sock, &sa->sa, SALEN(sa->sa))) {
274                 logger(mesh, MESHLINK_ERROR, "Connecting MTU assessment socket for %s failed: %s", n->name, sockstrerror(sockerrno));
275                 close(sock);
276                 return MTU;
277         }
278
279         int ip_mtu;
280         socklen_t ip_mtu_len = sizeof(ip_mtu);
281
282         if(getsockopt(sock, IPPROTO_IP, IP_MTU, &ip_mtu, &ip_mtu_len)) {
283                 logger(mesh, MESHLINK_ERROR, "getsockopt(IP_MTU) on %s failed: %s", n->name, sockstrerror(sockerrno));
284                 close(sock);
285                 return MTU;
286         }
287
288         close(sock);
289
290         /* Calculate the maximum SPTPS payload based on the interface MTU */
291         uint16_t mtu = ip_mtu;
292         mtu -= (sa->sa.sa_family == AF_INET6) ? 40 : 20; /* IPv6 or IPv4 */
293         mtu -= 8; /* UDP */
294         mtu -= 21; /* SPTPS */
295
296         if(mtu < 512) {
297                 logger(mesh, MESHLINK_ERROR, "getsockopt(IP_MTU) on %s returned absurdly small value: %d", n->name, ip_mtu);
298                 return MTU;
299         }
300
301         if(mtu > MTU) {
302                 return MTU;
303         }
304
305         logger(mesh, MESHLINK_INFO, "Using system-provided maximum MTU for %s: %hd", n->name, mtu);
306         return mtu;
307
308 #else
309         (void)mesh;
310         (void)n;
311         return MTU;
312 #endif
313 }
314
315 /* This function tries to determines the PMTU of a node.
316    By calling this function repeatedly, n->minmtu will be progressively
317    increased, and at some point, n->mtu will be fixed to n->minmtu.  If the PMTU
318    is already fixed, this function checks if it can be increased.
319 */
320
321 static void try_pmtu(meshlink_handle_t *mesh, node_t *n) {
322         if(!n->status.udp_confirmed) {
323                 n->mtuprobes = 0;
324                 n->minmtu = 0;
325                 n->maxmtu = MTU;
326                 return;
327         }
328
329         struct timespec elapsed;
330
331         timespec_sub(&mesh->loop.now, &n->last_mtu_probe_sent, &elapsed);
332
333         if(n->mtuprobes >= 0) {
334                 /* Fast probing, send three packets per second */
335                 if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_nsec < 333333333) {
336                         return;
337                 }
338         } else {
339                 if(n->mtuprobes < -1) {
340                         /* We didn't get an answer to the last probe, try again once every second */
341                         if(elapsed.tv_sec < 1) {
342                                 return;
343                         }
344                 } else {
345                         /* Slow probing, send one packet every pinginterval */
346                         int pinginterval = mesh->dev_class_traits[n->devclass].pinginterval;
347
348                         if(elapsed.tv_sec < pinginterval) {
349                                 return;
350                         }
351                 }
352         }
353
354         n->last_mtu_probe_sent = mesh->loop.now;
355
356         if(n->mtuprobes < -3) {
357                 /* We lost three PMTU probes, restart discovery */
358                 logger(mesh, MESHLINK_INFO, "Decrease in PMTU to %s detected, restarting PMTU discovery", n->name);
359                 n->mtuprobes = 0;
360                 n->minmtu = 0;
361         }
362
363         if(n->mtuprobes < 0) {
364                 /* After the initial discovery, we only send one maxmtu and one
365                    maxmtu + 1 probe to detect PMTU increases. */
366                 send_udp_probe_packet(mesh, n, n->maxmtu);
367
368                 if(n->mtuprobes == -1 && n->maxmtu + 1 < MTU) {
369                         send_udp_probe_packet(mesh, n, n->maxmtu + 1);
370                 }
371
372                 n->mtuprobes--;
373         } else {
374                 /* Starting parameters. */
375                 uint16_t len;
376
377                 if(n->mtuprobes == 0) {
378                         /* First packet is always the maximum MTU size */
379                         n->maxmtu = choose_initial_maxmtu(mesh, n);
380                         len = n->maxmtu;
381                 } else {
382                         if(n->last_mtu_len == n->minmtu) {
383                                 /* The previous probe was succesful, increase the size */
384                                 len = n->minmtu + (n->maxmtu - n->minmtu + 1) / 2;
385                         } else {
386                                 /* The previous probe was unsuccesful, decrease the size */
387                                 len = n->minmtu + (n->last_mtu_len - n->minmtu) / 2;
388                         }
389                 }
390
391                 n->last_mtu_len = len;
392                 send_udp_probe_packet(mesh, n, len);
393                 n->mtuprobes++;
394         }
395
396         try_fix_mtu(mesh, n);
397 }
398
399 /* Keep the connection to the given node alive.
400  * Ensure we have a valid key, and check whether UDP is working.
401  */
402
403 void keepalive(meshlink_handle_t *mesh, node_t *n, bool traffic) {
404         if(!n->status.reachable || !n->status.validkey) {
405                 return;
406         }
407
408         try_udp(mesh, n);
409
410         if(traffic) {
411                 try_pmtu(mesh, n);
412         }
413
414         /* If we want to send traffic but we don't have a working UDP
415          * connection, we are going to forward the traffic to the nexthop, so
416          * try to keep that one alive as well. */
417
418         if(traffic && !n->status.udp_confirmed && n != n->nexthop) {
419                 keepalive(mesh, n->nexthop, traffic);
420         }
421 }
422