X-Git-Url: https://www.tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fnet_packet.c;h=0b95a939bb84fdc874f115f1a4437d7d84806e3f;hb=c6a15e27d934e90a1f3a26438dddb395bdc9de19;hp=dab74e5d305a313fa43991b64835c790b2a273be;hpb=2c6b2d70e6640f39563ad7bb0aa0ba87f883848c;p=tinc diff --git a/src/net_packet.c b/src/net_packet.c index dab74e5d..0b95a939 100644 --- 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 + 2000-2022 Guus Sliepen 2010 Timothy Redaelli 2010 Brandon Black @@ -25,7 +25,6 @@ #ifdef HAVE_ZLIB #define ZLIB_CONST #include -#include #endif @@ -33,8 +32,8 @@ #include LZO1X_H #endif -#ifdef LZ4_H -#include LZ4_H +#ifdef HAVE_LZ4 +#include #endif #include "address_cache.h" @@ -54,10 +53,7 @@ #include "protocol.h" #include "route.h" #include "utils.h" - -#ifndef MAX -#define MAX(a, b) ((a) > (b) ? (a) : (b)) -#endif +#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 @@ -69,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 *); @@ -104,6 +104,22 @@ static void try_fix_mtu(node_t *n) { } } +static void reduce_mtu(node_t *n, int mtu) { + if(mtu < MINMTU) { + mtu = MINMTU; + } + + if(n->maxmtu > mtu) { + n->maxmtu = mtu; + } + + if(n->mtu > mtu) { + n->mtu = mtu; + } + + try_fix_mtu(n); +} + static void udp_probe_timeout_handler(void *data) { node_t *n = data; @@ -184,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. @@ -240,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; @@ -743,10 +760,10 @@ static void choose_udp_address(const node_t *n, const sockaddr_t **sa, size_t *s So we pick a random edge and a random socket. */ unsigned int i = 0; - unsigned int j = rand() % n->edge_tree->count; + unsigned int j = prng(n->edge_tree.count); edge_t *candidate = NULL; - for splay_each(edge_t, e, n->edge_tree) { + for splay_each(edge_t, e, &n->edge_tree) { if(i++ == j) { candidate = e->reverse; break; @@ -755,7 +772,7 @@ static void choose_udp_address(const node_t *n, const sockaddr_t **sa, size_t *s if(candidate) { *sa = &candidate->address; - *sock = rand() % listen_sockets; + *sock = prng(listen_sockets); } adapt_socket(*sa, sock); @@ -767,10 +784,10 @@ static void choose_local_address(const node_t *n, const sockaddr_t **sa, size_t /* Pick one of the edges from this node at random, then use its local address. */ unsigned int i = 0; - unsigned int j = rand() % n->edge_tree->count; + unsigned int j = prng(n->edge_tree.count); edge_t *candidate = NULL; - for splay_each(edge_t, e, n->edge_tree) { + for splay_each(edge_t, e, &n->edge_tree) { if(i++ == j) { candidate = e; break; @@ -779,7 +796,7 @@ static void choose_local_address(const node_t *n, const sockaddr_t **sa, size_t if(candidate && candidate->local_address.sa.sa_family) { *sa = &candidate->local_address; - *sock = rand() % listen_sockets; + *sock = prng(listen_sockets); adapt_socket(*sa, sock); } } @@ -927,15 +944,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) { if(sendto(listen_socket[sock].udp.fd, (void *)SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) { if(sockmsgsize(sockerrno)) { - if(n->maxmtu >= origlen) { - n->maxmtu = origlen - 1; - } - - if(n->mtu >= origlen) { - n->mtu = origlen - 1; - } - - try_fix_mtu(n); + reduce_mtu(n, origlen - 1); } else { logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno)); } @@ -947,16 +956,18 @@ end: } bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_t len) { - node_t *relay = (to->via != myself && (type == PKT_PROBE || (len - SPTPS_DATAGRAM_OVERHEAD) <= to->via->minmtu)) ? to->via : to->nexthop; + size_t origlen = len - SPTPS_DATAGRAM_OVERHEAD; + node_t *relay = (to->via != myself && (type == PKT_PROBE || origlen <= to->via->minmtu)) ? to->via : to->nexthop; bool direct = from == myself && to == relay; bool relay_supported = (relay->options >> 24) >= 4; bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY; /* Send it via TCP if it is a handshake packet, TCPOnly is in use, this is a relay packet that the other node cannot understand, or this packet is larger than the MTU. */ - if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) { + 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); @@ -964,11 +975,11 @@ 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[len * 4 / 3 + 5]; - b64encode(data, buf, 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: - We don't want intermediate nodes to switch to UDP to relay these packets; @@ -987,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) { @@ -1025,18 +1036,7 @@ bool send_sptps_data(node_t *to, node_t *from, int type, const void *data, size_ if(sendto(listen_socket[sock].udp.fd, buf, buf_ptr - buf, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) { if(sockmsgsize(sockerrno)) { - // Compensate for SPTPS overhead - len -= SPTPS_DATAGRAM_OVERHEAD; - - if(relay->maxmtu >= len) { - relay->maxmtu = len - 1; - } - - if(relay->mtu >= len) { - relay->mtu = len - 1; - } - - try_fix_mtu(relay); + reduce_mtu(relay, (int)origlen - 1); } else { logger(DEBUG_TRAFFIC, LOG_WARNING, "Error sending UDP SPTPS packet to %s (%s): %s", relay->name, relay->hostname, sockstrerror(sockerrno)); return false; @@ -1171,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); } @@ -1260,20 +1261,25 @@ 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); + return MTU; + } /* getsockopt(IP_MTU) returns the MTU of the physical interface. We need to remove various overheads to get to the tinc MTU. */ @@ -1311,11 +1317,6 @@ static length_t choose_initial_maxmtu(node_t *n) { #endif } - if(mtu < 512) { - logger(DEBUG_TRAFFIC, LOG_ERR, "getsockopt(IP_MTU) on %s (%s) returned absurdly small value: %d", n->name, n->hostname, ip_mtu); - return MTU; - } - if(mtu > MTU) { return MTU; } @@ -1416,7 +1417,7 @@ static void try_mtu(node_t *n) { const float multiplier = (n->maxmtu == MTU) ? 0.97f : 1.0f; const float cycle_position = (float) probes_per_cycle - (float)(n->mtuprobes % probes_per_cycle) - 1.0f; - const length_t minmtu = MAX(n->minmtu, 512); + const length_t minmtu = MAX(n->minmtu, MINMTU); const float interval = (float)(n->maxmtu - minmtu); length_t offset = 0; @@ -1430,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; @@ -1623,7 +1624,7 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) { // This guarantees all nodes receive the broadcast packet, and // usually distributes the sending of broadcast packets over all nodes. case BMODE_MST: - for list_each(connection_t, c, connection_list) + for list_each(connection_t, c, &connection_list) if(c->edge && c->status.mst && c != from->nexthop->connection) { send_packet(c->node, packet); } @@ -1638,13 +1639,14 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) { break; } - for splay_each(node_t, n, node_tree) + for splay_each(node_t, n, &node_tree) if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n)) { send_packet(n, packet); } break; + case BMODE_NONE: default: break; } @@ -1661,7 +1663,7 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) { bool hard = false; static time_t last_hard_try = 0; - for splay_each(node_t, n, node_tree) { + for splay_each(node_t, n, &node_tree) { if(!n->status.reachable || n == myself) { continue; } @@ -1672,7 +1674,7 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) { bool soft = false; - for splay_each(edge_t, e, n->edge_tree) { + for splay_each(edge_t, e, &n->edge_tree) { if(!e->reverse) { continue; } @@ -1909,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) {