/*
net_packet.c -- Handles in- and outgoing VPN packets
Copyright (C) 1998-2005 Ivo Timmermans,
- 2000-2018 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>
#ifdef HAVE_ZLIB
#define ZLIB_CONST
#include <zlib.h>
+#include <assert.h>
+
#endif
#ifdef HAVE_LZO
#include LZO1X_H
#endif
+#ifdef LZ4_H
+#include LZ4_H
+#endif
+
#include "address_cache.h"
#include "cipher.h"
#include "conf.h"
static char lzo_wrkmem[LZO1X_999_MEM_COMPRESS > LZO1X_1_MEM_COMPRESS ? LZO1X_999_MEM_COMPRESS : LZO1X_1_MEM_COMPRESS];
#endif
+#ifdef HAVE_LZ4_BUILTIN
+static LZ4_stream_t lz4_stream;
+#else
+static void *lz4_state = NULL;
+#endif /* HAVE_LZ4_BUILTIN */
+
static void send_udppacket(node_t *, vpn_packet_t *);
unsigned replaywin = 32;
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);
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);
}
}
-static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
- if(level == 0) {
- memcpy(dest, source, len);
- return len;
- } else if(level == 10) {
+#ifdef HAVE_LZ4
+static length_t compress_packet_lz4(uint8_t *dest, const uint8_t *source, length_t len) {
+#ifdef HAVE_LZ4_BUILTIN
+ return LZ4_compress_fast_extState(&lz4_stream, (const char *) source, (char *) dest, len, MAXSIZE, 0);
+#else
+
+ /* @FIXME: Put this in a better place, and free() it too. */
+ if(lz4_state == NULL) {
+ lz4_state = malloc(LZ4_sizeofState());
+ }
+
+ if(lz4_state == NULL) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Failed to allocate lz4_state, error: %i", errno);
+ return 0;
+ }
+
+ return LZ4_compress_fast_extState(lz4_state, (const char *) source, (char *) dest, len, MAXSIZE, 0);
+#endif /* HAVE_LZ4_BUILTIN */
+}
+#endif /* HAVE_LZ4 */
+
#ifdef HAVE_LZO
- lzo_uint lzolen = MAXSIZE;
- lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
+static length_t compress_packet_lzo(uint8_t *dest, const uint8_t *source, length_t len, int level) {
+ assert(level == 10 || level == 11);
+
+ lzo_uint lzolen = MAXSIZE;
+ int result;
+
+ if(level == 11) {
+ result = lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
+ } else { // level == 10
+ result = lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
+ }
+
+ if(result == LZO_E_OK) {
return lzolen;
-#else
+ } else {
return 0;
+ }
+}
#endif
- } else if(level < 10) {
-#ifdef HAVE_ZLIB
- unsigned long destlen = MAXSIZE;
- if(compress2(dest, &destlen, source, len, level) == Z_OK) {
- return destlen;
- } else
+static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
+ switch(level) {
+#ifdef HAVE_LZ4
+
+ case 12:
+ return compress_packet_lz4(dest, source, len);
#endif
- return 0;
- } else {
+
#ifdef HAVE_LZO
- lzo_uint lzolen = MAXSIZE;
- lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
- return lzolen;
-#else
- return 0;
+
+ case 11:
+ case 10:
+ return compress_packet_lzo(dest, source, len, level);
#endif
+#ifdef HAVE_ZLIB
+
+ case 9:
+ case 8:
+ case 7:
+ case 6:
+ case 5:
+ case 4:
+ case 3:
+ case 2:
+ case 1: {
+ unsigned long dest_len = MAXSIZE;
+
+ if(compress2(dest, (unsigned long *) &dest_len, source, len, level) == Z_OK) {
+ return dest_len;
+ } else {
+ return 0;
+ }
}
- return 0;
-}
+#endif
-static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
- if(level == 0) {
+ case 0:
memcpy(dest, source, len);
return len;
- } else if(level > 9) {
-#ifdef HAVE_LZO
- lzo_uint lzolen = MAXSIZE;
- if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK) {
- return lzolen;
- } else
+ default:
+ return 0;
+ }
+}
+
+static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
+ switch(level) {
+#ifdef HAVE_LZ4
+
+ case 12:
+ return LZ4_decompress_safe((char *)source, (char *) dest, len, MAXSIZE);
+
#endif
+#ifdef HAVE_LZO
+
+ case 11:
+ case 10: {
+ lzo_uint dst_len = MAXSIZE;
+
+ if(lzo1x_decompress_safe(source, len, dest, (lzo_uint *) &dst_len, NULL) == LZO_E_OK) {
+ return dst_len;
+ } else {
return 0;
+ }
}
+#endif
#ifdef HAVE_ZLIB
- else {
+
+ case 9:
+ case 8:
+ case 7:
+ case 6:
+ case 5:
+ case 4:
+ case 3:
+ case 2:
+ case 1: {
unsigned long destlen = MAXSIZE;
static z_stream stream;
#endif
- return 0;
+ case 0:
+ memcpy(dest, source, len);
+ return len;
+
+ default:
+ return 0;
+ }
}
/* VPN packet I/O */
/* 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;
}
static void send_udp_probe_packet(node_t *n, int len) {
vpn_packet_t packet;
+
+ 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);
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) {
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);
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 {
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;
projects / tinc / blobdiff