GitHub CI: update list of container images

[tinc] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 8917267..0b95a93 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -1,7 +1,7 @@
 /*
     net_packet.c -- Handles in- and outgoing VPN packets
     Copyright (C) 1998-2005 Ivo Timmermans,
-                  2000-2021 Guus Sliepen <guus@tinc-vpn.org>
+                  2000-2022 Guus Sliepen <guus@tinc-vpn.org>
                   2010      Timothy Redaelli <timothy@redaelli.eu>
                   2010      Brandon Black <blblack@gmail.com>
 
@@ -25,7 +25,6 @@
 #ifdef HAVE_ZLIB
 #define ZLIB_CONST
 #include <zlib.h>
-#include <assert.h>
 
 #endif
 
@@ -33,8 +32,8 @@
 #include LZO1X_H
 #endif
 
-#ifdef LZ4_H
-#include LZ4_H
+#ifdef HAVE_LZ4
+#include <lz4.h>
 #endif
 
 #include "address_cache.h"
@@ -54,6 +53,7 @@
 #include "protocol.h"
 #include "route.h"
 #include "utils.h"
+#include "random.h"
 
 /* The minimum size of a probe is 14 bytes, but since we normally use CBC mode
    encryption, we can add a few extra random bytes without increasing the
@@ -65,11 +65,15 @@ int keylifetime = 0;
 static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
 #endif
 
+#ifdef HAVE_LZ4
+
 #ifdef HAVE_LZ4_BUILTIN
 static LZ4_stream_t lz4_stream;
 #else
 static void *lz4_state = NULL;
-#endif /* HAVE_LZ4_BUILTIN */
+#endif // HAVE_LZ4_BUILTIN
+
+#endif // HAVE_LZ4
 
 static void send_udppacket(node_t *, vpn_packet_t *);
 
@@ -196,7 +200,10 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                        n->address_cache = open_address_cache(n);
                }
 
-               reset_address_cache(n->address_cache, &n->address);
+               if(n->connection && n->connection->edge) {
+                       reset_address_cache(n->address_cache);
+                       add_recent_address(n->address_cache, &n->connection->edge->address);
+               }
        }
 
        // Reset the UDP ping timer.
@@ -252,8 +259,6 @@ static length_t compress_packet_lz4(uint8_t *dest, const uint8_t *source, length
 
 #ifdef HAVE_LZO
 static length_t compress_packet_lzo(uint8_t *dest, const uint8_t *source, length_t len, compression_level_t level) {
-       assert(level == COMPRESS_LZO_LO || level == COMPRESS_LZO_HI);
-
        lzo_uint lzolen = MAXSIZE;
        int result;
 
@@ -961,7 +966,8 @@ bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_
 
        if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && origlen > relay->minmtu)) {
                if(type != SPTPS_HANDSHAKE && (to->nexthop->connection->options >> 24) >= 7) {
-                       uint8_t buf[len + sizeof(to->id) + sizeof(from->id)];
+                       const size_t buflen = len + sizeof(to->id) + sizeof(from->id);
+                       uint8_t *buf = alloca(buflen);
                        uint8_t *buf_ptr = buf;
                        memcpy(buf_ptr, &to->id, sizeof(to->id));
                        buf_ptr += sizeof(to->id);
@@ -969,10 +975,10 @@ bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_
                        buf_ptr += sizeof(from->id);
                        memcpy(buf_ptr, data, len);
                        logger(DEBUG_TRAFFIC, LOG_INFO, "Sending packet from %s (%s) to %s (%s) via %s (%s) (TCP)", from->name, from->hostname, to->name, to->hostname, to->nexthop->name, to->nexthop->hostname);
-                       return send_sptps_tcppacket(to->nexthop->connection, buf, sizeof(buf));
+                       return send_sptps_tcppacket(to->nexthop->connection, buf, buflen);
                }
 
-               char buf[B64_SIZE(len)];
+               char *buf = alloca(B64_SIZE(len));
                b64encode_tinc(data, buf, len);
 
                /* If this is a handshake packet, use ANS_KEY instead of REQ_KEY, for two reasons:
@@ -992,8 +998,8 @@ bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_
                overhead += sizeof(to->id) + sizeof(from->id);
        }
 
-       uint8_t buf[len + overhead];
-       uint8_t *buf_ptr = buf;
+       char *buf = alloca(len + overhead);
+       char *buf_ptr = buf;
 
        if(relay_supported) {
                if(direct) {
@@ -1165,17 +1171,18 @@ static void send_udp_probe_packet(node_t *n, size_t len) {
        vpn_packet_t packet;
 
        if(len > sizeof(packet.data)) {
-               logger(DEBUG_TRAFFIC, LOG_INFO, "Truncating probe length %zu to %s (%s)", len, n->name, n->hostname);
+               logger(DEBUG_TRAFFIC, LOG_INFO, "Truncating probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
                len = sizeof(packet.data);
        }
 
+       len = MAX(len, MIN_PROBE_SIZE);
        packet.offset = DEFAULT_PACKET_OFFSET;
        memset(DATA(&packet), 0, 14);
        randomize(DATA(&packet) + 14, len - 14);
        packet.len = len;
        packet.priority = 0;
 
-       logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %zu to %s (%s)", len, n->name, n->hostname);
+       logger(DEBUG_TRAFFIC, LOG_INFO, "Sending UDP probe length %lu to %s (%s)", (unsigned long)len, n->name, n->hostname);
 
        send_udppacket(n, &packet);
 }
@@ -1254,20 +1261,20 @@ static length_t choose_initial_maxmtu(node_t *n) {
 
        if(connect(sock, &sa->sa, SALEN(sa->sa))) {
                logger(DEBUG_TRAFFIC, LOG_ERR, "Connecting MTU assessment socket for %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
-               close(sock);
+               closesocket(sock);
                return MTU;
        }
 
        int ip_mtu;
        socklen_t ip_mtu_len = sizeof(ip_mtu);
 
-       if(getsockopt(sock, IPPROTO_IP, IP_MTU, &ip_mtu, &ip_mtu_len)) {
+       if(getsockopt(sock, IPPROTO_IP, IP_MTU, (void *)&ip_mtu, &ip_mtu_len)) {
                logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) failed: %s", n->name, n->hostname, sockstrerror(sockerrno));
-               close(sock);
+               closesocket(sock);
                return MTU;
        }
 
-       close(sock);
+       closesocket(sock);
 
        if(ip_mtu < MINMTU) {
                logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu);
@@ -1424,7 +1431,7 @@ static void try_mtu(node_t *n) {
                                        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 = (length_t) powf(interval, multiplier * cycle_position / ((float) probes_per_cycle - 1.0f));
+                               offset = lrintf(powf(interval, multiplier * cycle_position / (float)(probes_per_cycle - 1)));
                        }
 
                        length_t maxmtu = n->maxmtu;
@@ -1639,6 +1646,7 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
 
                break;
 
+       case BMODE_NONE:
        default:
                break;
        }
@@ -1903,7 +1911,7 @@ void handle_device_data(void *data, int flags) {
                myself->in_bytes += packet.len;
                route(myself, &packet);
        } else {
-               usleep(errors * 50000);
+               sleep_millis(errors * 50);
                errors++;
 
                if(errors > 10) {