Don't try to renew SPTPS keys for unreachable nodes.

[meshlink] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 0510b54be8def584f8b9f33d78329b4d852baaa7..38200e5a1d9a31f05bfe6b63ef86634eb9079374 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -148,13 +148,13 @@ static void send_mtu_probe_handler(event_loop_t *loop, void *data) {
        n->status.broadcast = false;
 
 end:
-       timeout_set(&mesh->loop, &n->mtutimeout, &(struct timeval) {
+       timeout_set(&mesh->loop, &n->mtutimeout, &(struct timespec) {
                timeout, prng(mesh, TIMER_FUDGE)
        });
 }
 
 void send_mtu_probe(meshlink_handle_t *mesh, node_t *n) {
-       timeout_add(&mesh->loop, &n->mtutimeout, send_mtu_probe_handler, n, &(struct timeval) {
+       timeout_add(&mesh->loop, &n->mtutimeout, send_mtu_probe_handler, n, &(struct timespec) {
                1, 0
        });
        send_mtu_probe_handler(&mesh->loop, n);
@@ -185,7 +185,14 @@ static void mtu_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet
                   is possible using the address and socket that the reply
                   packet used. */
 
-               n->status.udp_confirmed = true;
+               if(!n->status.udp_confirmed) {
+                       char *address, *port;
+                       sockaddr2str(&n->address, &address, &port);
+                       send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
+                       free(address);
+                       free(port);
+                       n->status.udp_confirmed = true;
+               }
 
                /* If we haven't established the PMTU yet, restart the discovery process. */
 
@@ -238,6 +245,11 @@ static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpk
 }
 
 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
+       if(!n->status.reachable) {
+               logger(mesh, MESHLINK_ERROR, "Got SPTPS data from unreachable node %s", n->name);
+               return;
+       }
+
        if(!n->sptps.state) {
                if(!n->status.waitingforkey) {
                        logger(mesh, MESHLINK_DEBUG, "Got packet from %s but we haven't exchanged keys yet", n->name);
@@ -249,10 +261,17 @@ static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *
                return;
        }
 
-       sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
+       if(!sptps_receive_data(&n->sptps, inpkt->data, inpkt->len)) {
+               logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", n->name, strerror(errno));
+       }
 }
 
 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
+       if(!n->status.reachable) {
+               logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", n->name);
+               return;
+       }
+
        if(!n->status.validkey) {
                logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
 
@@ -299,17 +318,26 @@ static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const s
                return;
        }
 
+       /* If we have learned an address via Catta, try this once every batch */
+       if(mesh->udp_choice == 1 && n->catta_address.sa.sa_family != AF_UNSPEC) {
+               *sa = &n->catta_address;
+               goto check_socket;
+       }
+
        /* Otherwise, address are found in edges to this node.
           So we pick a random edge and a random socket. */
 
-       int i = 0;
-       int j = prng(mesh, n->edge_tree->count);
        edge_t *candidate = NULL;
 
-       for splay_each(edge_t, e, n->edge_tree) {
-               if(i++ == j) {
-                       candidate = e->reverse;
-                       break;
+       {
+               int i = 0;
+               int j = prng(mesh, n->edge_tree->count);
+
+               for splay_each(edge_t, e, n->edge_tree) {
+                       if(i++ == j) {
+                               candidate = e->reverse;
+                               break;
+                       }
                }
        }
 
@@ -318,6 +346,8 @@ static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const s
                *sock = prng(mesh, mesh->listen_sockets);
        }
 
+check_socket:
+
        /* Make sure we have a suitable socket for the chosen address */
        if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
                for(int i = 0; i < mesh->listen_sockets; i++) {
@@ -359,9 +389,14 @@ bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
        node_t *to = handle;
        meshlink_handle_t *mesh = to->mesh;
 
+       if(!to->status.reachable) {
+               logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", to->name);
+               return false;
+       }
+
        /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 
-       if(type >= SPTPS_HANDSHAKE || (type != PKT_PROBE && len > to->minmtu)) {
+       if(type >= SPTPS_HANDSHAKE || (type != PKT_PROBE && (len - 21) > to->minmtu)) {
                char buf[len * 4 / 3 + 5];
                b64encode(data, buf, len);
 
@@ -424,8 +459,8 @@ bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t
                return true;
        }
 
-       if(len > MTU) {
-               logger(mesh, MESHLINK_ERROR, "Packet from %s larger than maximum supported size (%d > %d)", from->name, len, MTU);
+       if(len > MAXSIZE) {
+               logger(mesh, MESHLINK_ERROR, "Packet from %s larger than maximum supported size (%d > %d)", from->name, len, MAXSIZE);
                return false;
        }
 
@@ -550,7 +585,7 @@ void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
 
                if(n) {
                        update_node_udp(mesh, n, &from);
-               } else if(mesh->log_level >= MESHLINK_WARNING) {
+               } else if(mesh->log_level <= MESHLINK_WARNING) {
                        hostname = sockaddr2hostname(&from);
                        logger(mesh, MESHLINK_WARNING, "Received UDP packet from unknown source %s", hostname);
                        free(hostname);