Send one MTU probe at a time.

[tinc] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 5976fc2..9bebca4 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -65,6 +65,21 @@ int udp_discovery_timeout = 30;
 
 #define MAX_SEQNO 1073741824
 
+static void try_fix_mtu(node_t *n) {
+       if(n->mtuprobes < 0)
+               return;
+
+       if(n->mtuprobes == 90 || n->minmtu >= n->maxmtu) {
+               if(n->minmtu > n->maxmtu)
+                       n->minmtu = n->maxmtu;
+               else
+                       n->maxmtu = n->minmtu;
+               n->mtu = n->minmtu;
+               logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
+               n->mtuprobes = -1;
+       }
+}
+
 static void udp_probe_timeout_handler(void *data) {
        node_t *n = data;
        if(!n->status.udp_confirmed)
@@ -129,7 +144,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                if(probelen >= n->maxmtu + 8) {
                        logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname);
                        n->maxmtu = MTU;
-                       n->mtuprobes = 10;
+                       n->mtuprobes = 30;
                        return;
                }
 
@@ -137,8 +152,10 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
 
                if(probelen > n->maxmtu)
                        probelen = n->maxmtu;
-               if(n->minmtu < probelen)
+               if(n->minmtu < probelen) {
                        n->minmtu = probelen;
+                       try_fix_mtu(n);
+               }
 
                /* Calculate RTT and bandwidth.
                   The RTT is the time between the MTU probe burst was sent and the first
@@ -164,7 +181,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                        n->rtt = diff.tv_sec + diff.tv_usec * 1e-6;
                        n->probe_time = probe_timestamp;
                } else if(n->probe_counter == 3) {
-                       /* TODO: this will never fire after initial MTU discovery. */
+                       /* TODO: this will never fire - we're not sending batches of three anymore. */
                        struct timeval probe_timestamp_diff;
                        timersub(&probe_timestamp, &n->probe_time, &probe_timestamp_diff);
                        n->bandwidth = 2.0 * probelen / (probe_timestamp_diff.tv_sec + probe_timestamp_diff.tv_usec * 1e-6);
@@ -658,6 +675,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
                                n->maxmtu = origlen - 1;
                        if(n->mtu >= origlen)
                                n->mtu = origlen - 1;
+                       try_fix_mtu(n);
                } else
                        logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
        }
@@ -722,6 +740,7 @@ static bool send_sptps_data_priv(node_t *to, node_t *from, int type, const void
                                relay->maxmtu = len - 1;
                        if(relay->mtu >= len)
                                relay->mtu = len - 1;
+                       try_fix_mtu(relay);
                } else {
                        logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno));
                        return false;
@@ -884,49 +903,40 @@ static void try_mtu(node_t *n) {
                return;
        }
 
-       /* mtuprobes == 0..29: initial discovery, send bursts with 1 second interval, mtuprobes++
-          mtuprobes ==    30: fix MTU, and go to 31
-          mtuprobes ==    31: send one >maxmtu probe every pingtimeout */
+       /* mtuprobes == 0..89: initial discovery, send bursts with 1 second interval, mtuprobes++
+          mtuprobes ==    90: fix MTU, and go to -1
+          mtuprobes ==    -1: send one >maxmtu probe every pingtimeout */
 
        struct timeval now;
        gettimeofday(&now, NULL);
        struct timeval elapsed;
        timersub(&now, &n->probe_sent_time, &elapsed);
-       if(n->mtuprobes < 31) {
-               if(n->mtuprobes != 0 && elapsed.tv_sec < 1)
+       if(n->mtuprobes >= 0) {
+               if(n->mtuprobes != 0 && elapsed.tv_sec == 0 && elapsed.tv_usec < 333333)
                        return;
        } else {
                if(elapsed.tv_sec < pingtimeout)
                        return;
        }
 
-       if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
-               if(n->minmtu > n->maxmtu)
-                       n->minmtu = n->maxmtu;
-               else
-                       n->maxmtu = n->minmtu;
-               n->mtu = n->minmtu;
-               logger(DEBUG_TRAFFIC, LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
-               n->mtuprobes = 31;
-       }
+       try_fix_mtu(n);
 
        int timeout;
-       if(n->mtuprobes == 31) {
+       if(n->mtuprobes < 0) {
                /* After the initial discovery, we only send one >maxmtu probe
                   to detect PMTU increases. */
                if(n->maxmtu + 8 < MTU)
                        send_udp_probe_packet(n, n->maxmtu + 8);
        } else {
-               /* Probes are sent in batches of three, with random sizes between the
+               /* Probes are sent with random sizes between the
                   lower and upper boundaries for the MTU thus far discovered. */
-               for (int i = 0; i < 3; i++) {
-                       int len = n->maxmtu;
-                       if(n->minmtu < n->maxmtu)
-                               len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
+               int len = n->maxmtu;
+               if(n->minmtu < n->maxmtu)
+                       len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
+               send_udp_probe_packet(n, MAX(len, 64));
 
-                       send_udp_probe_packet(n, MAX(len, 64));
-               }
-               n->mtuprobes++;
+               if(n->mtuprobes >= 0)
+                       n->mtuprobes++;
        }
 
        n->probe_counter = 0;