Remove bandwidth estimation code.

[tinc] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 5976fc2..828e193 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
 
 
 #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)
 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;
                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;
                }
 
                        return;
                }
 


@@ -137,13 +152,14 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
 
                if(probelen > n->maxmtu)
                        probelen = n->maxmtu;
 
                if(probelen > n->maxmtu)
                        probelen = n->maxmtu;

-               if(n->minmtu < probelen)
+               if(n->minmtu < probelen) {

                        n->minmtu = probelen;
                        n->minmtu = probelen;

+                       try_fix_mtu(n);
+               }

 
 

-               /* Calculate RTT and bandwidth.
+               /* Calculate RTT.

                   The RTT is the time between the MTU probe burst was sent and the first
                   The RTT is the time between the MTU probe burst was sent and the first

-                  reply is received. The bandwidth is measured using the time between the
-                  arrival of the first and third probe reply (or type 2 probe requests).
+                  reply is received.

                 */
 
                struct timeval now, diff;
                 */
 
                struct timeval now, diff;


@@ -163,12 +179,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                if(n->probe_counter == 1) {
                        n->rtt = diff.tv_sec + diff.tv_usec * 1e-6;
                        n->probe_time = probe_timestamp;
                if(n->probe_counter == 1) {
                        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. */
-                       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);
-                       logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, burst bandwidth %.3f Mbit/s, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->bandwidth * 8e-6, n->packetloss * 1e2);
+                       logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->packetloss * 1e2);

                }
        }
 }
                }
        }
 }


@@ -658,6 +669,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
                                n->maxmtu = origlen - 1;
                        if(n->mtu >= origlen)
                                n->mtu = origlen - 1;
                                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));
        }
                } else
                        logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
        }


@@ -722,6 +734,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;
                                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;
                } 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 +897,40 @@ static void try_mtu(node_t *n) {
                return;
        }
 
                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);
 
        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;
        }
 
                        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;
 
        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 {
                /* 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. */
                   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;
        }
 
        n->probe_counter = 0;