Rewrite the test suite for better compat and stability

[tinc] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 25d3efb..8a5460c 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -1085,14 +1085,14 @@ static void try_sptps(node_t *n) {
 
 static void send_udp_probe_packet(node_t *n, int len) {
        vpn_packet_t packet;
-       packet.offset = DEFAULT_PACKET_OFFSET;
-       memset(DATA(&packet), 0, 14);
 
        if(len > sizeof(packet.data)) {
                logger(DEBUG_TRAFFIC, LOG_INFO, "Truncating probe length %d to %s (%s)", len, n->name, n->hostname);
                len = sizeof(packet.data);
        }
 
+       packet.offset = DEFAULT_PACKET_OFFSET;
+       memset(DATA(&packet), 0, 14);
        randomize(DATA(&packet) + 14, len - 14);
        packet.len = len;
        packet.priority = 0;
@@ -1333,14 +1333,19 @@ static void try_mtu(node_t *n) {
                        const length_t minmtu = MAX(n->minmtu, 512);
                        const float interval = n->maxmtu - minmtu;
 
-                       /* The core of the discovery algorithm is this exponential.
-                          It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
-                          This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
-                          are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
-                          on the precise MTU as we are approaching it.
-                          The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
-                          reply per cycle so that we can make progress. */
-                       const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
+                       length_t offset = 0;
+
+                       /* powf can be underflowed if n->maxmtu is less than 512 due to the minmtu MAX bound */
+                       if(interval > 0) {
+                               /* The core of the discovery algorithm is this exponential.
+                                       It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
+                                       This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
+                                       are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
+                                       on the precise MTU as we are approaching it.
+                                       The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
+                                       reply per cycle so that we can make progress. */
+                               offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
+                       }
 
                        length_t maxmtu = n->maxmtu;
                        send_udp_probe_packet(n, minmtu + offset);