Check interval bounds for UDP probe size.
[tinc] / src / net_packet.c
index d589228..ac70d6b 100644 (file)
@@ -1,7 +1,7 @@
 /*
     net_packet.c -- Handles in- and outgoing VPN packets
     Copyright (C) 1998-2005 Ivo Timmermans,
-                  2000-2017 Guus Sliepen <guus@tinc-vpn.org>
+                  2000-2021 Guus Sliepen <guus@tinc-vpn.org>
                   2010      Timothy Redaelli <timothy@redaelli.eu>
                   2010      Brandon Black <blblack@gmail.com>
 
@@ -152,11 +152,12 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                len = ntohs(len16);
        }
 
-       if(n->udp_ping_sent.tv_sec != 0) {  // a probe in flight
+       if(n->status.ping_sent) {  // a probe in flight
                gettimeofday(&now, NULL);
                struct timeval rtt;
                timersub(&now, &n->udp_ping_sent, &rtt);
                n->udp_ping_rtt = rtt.tv_sec * 1000000 + rtt.tv_usec;
+               n->status.ping_sent = false;
                logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s) rtt=%d.%03d", DATA(packet)[0], len, n->name, n->hostname, n->udp_ping_rtt / 1000, n->udp_ping_rtt % 1000);
        } else {
                logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d UDP probe reply %d from %s (%s)", DATA(packet)[0], len, n->name, n->hostname);
@@ -175,8 +176,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                reset_address_cache(n->address_cache, &n->address);
        }
 
-       // Reset the UDP ping timer. (no probe in flight)
-       n->udp_ping_sent.tv_sec = 0;
+       // Reset the UDP ping timer.
 
        if(udp_discovery) {
                timeout_del(&n->udp_ping_timeout);
@@ -545,7 +545,10 @@ bool receive_tcppacket_sptps(connection_t *c, const char *data, size_t len) {
        /* If we're not the final recipient, relay the packet. */
 
        if(to != myself) {
-               send_sptps_data(to, from, 0, data, len);
+               if(to->status.validkey) {
+                       send_sptps_data(to, from, 0, data, len);
+               }
+
                try_tx(to, true);
                return true;
        }
@@ -1084,6 +1087,12 @@ 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);
+       }
+
        randomize(DATA(&packet) + 14, len - 14);
        packet.len = len;
        packet.priority = 0;
@@ -1132,6 +1141,7 @@ static void try_udp(node_t *n) {
        if(ping_tx_elapsed.tv_sec >= interval) {
                gettimeofday(&now, NULL);
                n->udp_ping_sent = now; // a probe in flight
+               n->status.ping_sent = true;
                send_udp_probe_packet(n, MIN_PROBE_SIZE);
 
                if(localdiscovery && !n->status.udp_confirmed && n->prevedge) {
@@ -1228,9 +1238,8 @@ static length_t choose_initial_maxmtu(node_t *n) {
        return mtu;
 
 #else
-
+       (void)n;
        return MTU;
-
 #endif
 }
 
@@ -1324,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);
@@ -1627,7 +1641,7 @@ static void handle_incoming_vpn_packet(listen_socket_t *ls, vpn_packet_t *pkt, s
                pkt->offset = 2 * sizeof(node_id_t);
                from = lookup_node_id(SRCID(pkt));
 
-               if(from && !memcmp(DSTID(pkt), &nullid, sizeof(nullid)) && from->status.sptps) {
+               if(from && from->status.sptps && !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
                        if(sptps_verify_datagram(&from->sptps, DATA(pkt), pkt->len - 2 * sizeof(node_id_t))) {
                                n = from;
                        } else {
@@ -1663,7 +1677,7 @@ skip_harder:
                        pkt->len -= pkt->offset;
                }
 
-               if(!memcmp(DSTID(pkt), &nullid, sizeof(nullid)) || !relay_enabled) {
+               if(!relay_enabled || !memcmp(DSTID(pkt), &nullid, sizeof(nullid))) {
                        direct = true;
                        from = n;
                        to = myself;
@@ -1775,13 +1789,13 @@ void handle_incoming_vpn_data(void *data, int flags) {
 
 #else
        vpn_packet_t pkt;
-       sockaddr_t addr = {};
+       sockaddr_t addr = {0};
        socklen_t addrlen = sizeof(addr);
 
        pkt.offset = 0;
        int len = recvfrom(ls->udp.fd, (void *)DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
 
-       if(len <= 0 || len > MAXSIZE) {
+       if(len <= 0 || (size_t)len > MAXSIZE) {
                if(!sockwouldblock(sockerrno)) {
                        logger(DEBUG_ALWAYS, LOG_ERR, "Receiving packet failed: %s", sockstrerror(sockerrno));
                }