X-Git-Url: http://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fnet_packet.c;h=90fda375b3686ea3e440783a2c80434f327e5362;hb=98716a227ee39fdcdfafa7309adb73499311a2ce;hp=131f52ec3b4b1680193bcb8d08462ab50cd26e1a;hpb=7939ee12836bf2ef772f2a6a1e805ee0d64a8e70;p=tinc diff --git a/src/net_packet.c b/src/net_packet.c index 131f52ec..90fda375 100644 --- a/src/net_packet.c +++ b/src/net_packet.c @@ -78,40 +78,34 @@ static void send_udp_probe_packet(node_t *n, int len) { send_udppacket(n, &packet); } -static void send_mtu_probe_handler(void *data) { - node_t *n = data; - - if(!n->status.reachable || !n->status.validkey) { - logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname); - n->mtuprobes = 0; +// This function tries to determines the MTU of a node. +// By calling this function repeatedly, n->minmtu will be progressively increased, and at some point, n->mtu will be fixed to n->minmtu. +// If the MTU is already fixed, this function checks if it can be increased. +static void try_mtu(node_t *n) { + if(!(n->options & OPTION_PMTU_DISCOVERY)) return; - } - - /* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval - mtuprobes == 31: sleep pinginterval seconds - mtuprobes == 32: send 1 burst, sleep pingtimeout second - mtuprobes == 33: no response from other side, restart PMTU discovery process */ - n->mtuprobes++; - int timeout = 1; - - if(n->mtuprobes > 32) { - if(!n->minmtu) { - n->mtuprobes = 31; - timeout = pinginterval; - goto end; - } - - logger(DEBUG_TRAFFIC, LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname); - n->status.udp_confirmed = false; - n->mtuprobes = 1; + if(udp_discovery && !n->status.udp_confirmed) { + n->mtuprobes = 0; n->minmtu = 0; n->maxmtu = MTU; + return; } - if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) { - logger(DEBUG_TRAFFIC, LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname); - n->mtuprobes = 31; + /* mtuprobes == 0..29: initial discovery, send bursts with 1 second interval, mtuprobes++ + mtuprobes == 30: fix MTU, and go to 31 + mtuprobes == 31: send one >maxmtu probe every pingtimeout */ + + struct timeval now; + gettimeofday(&now, NULL); + struct timeval elapsed; + timersub(&now, &n->probe_sent_time, &elapsed); + if(n->mtuprobes < 31) { + if(n->mtuprobes != 0 && elapsed.tv_sec < 1) + return; + } else { + if(elapsed.tv_sec < pingtimeout) + return; } if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) { @@ -124,41 +118,32 @@ static void send_mtu_probe_handler(void *data) { n->mtuprobes = 31; } + int timeout; if(n->mtuprobes == 31) { - timeout = pinginterval; - goto end; - } else if(n->mtuprobes == 32) { - timeout = pingtimeout; - } - - /* After the initial discovery, a fourth packet is added to each batch with a - size larger than the currently known PMTU, to test if the PMTU has increased. */ - if (n->mtuprobes >= 30 && n->maxmtu + 8 < MTU) - send_udp_probe_packet(n, n->maxmtu + 8); - - /* Probes are sent in batches of three, with random sizes between the - lower and upper boundaries for the MTU thus far discovered. */ - for (int i = 0; i < 3; i++) { - int len = n->maxmtu; - if(n->minmtu < n->maxmtu) - len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu); - - send_udp_probe_packet(n, MAX(len, 64)); - } - - /* In case local discovery is enabled, another packet is added to each batch, - which will be broadcast to the local network. */ - if(localdiscovery && n->mtuprobes <= 10 && n->prevedge) { - n->status.send_locally = true; - send_udp_probe_packet(n, 16); - n->status.send_locally = false; + /* After the initial discovery, we only send one >maxmtu probe + to detect PMTU increases. */ + if(n->maxmtu + 8 < MTU) + send_udp_probe_packet(n, n->maxmtu + 8); + } else { + /* Probes are sent in batches of three, with random sizes between the + lower and upper boundaries for the MTU thus far discovered. */ + for (int i = 0; i < 3; i++) { + int len = n->maxmtu; + if(n->minmtu < n->maxmtu) + len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu); + + send_udp_probe_packet(n, MAX(len, 64)); + } + n->mtuprobes++; } n->probe_counter = 0; - gettimeofday(&n->probe_time, NULL); + n->probe_sent_time = now; + n->probe_time = now; /* Calculate the packet loss of incoming traffic by comparing the rate of packets received to the rate with which the sequence number has increased. + TODO: this is unrelated to PMTU discovery - it should be moved elsewhere. */ if(n->received > n->prev_received) @@ -168,14 +153,6 @@ static void send_mtu_probe_handler(void *data) { n->prev_received_seqno = n->received_seqno; n->prev_received = n->received; - -end: - timeout_set(&n->mtutimeout, &(struct timeval){timeout, rand() % 100000}); -} - -void send_mtu_probe(node_t *n) { - timeout_add(&n->mtutimeout, send_mtu_probe_handler, n, &(struct timeval){1, 0}); - send_mtu_probe_handler(n); } static void udp_probe_timeout_handler(void *data) { @@ -185,7 +162,7 @@ static void udp_probe_timeout_handler(void *data) { logger(DEBUG_TRAFFIC, LOG_INFO, "Too much time has elapsed since last UDP ping response from %s (%s), stopping UDP communication", n->name, n->hostname); n->status.udp_confirmed = false; - n->mtuprobes = 1; + n->mtuprobes = 0; n->minmtu = 0; n->maxmtu = MTU; } @@ -239,20 +216,11 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) { timeout_add(&n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timeval){udp_discovery_timeout, 0}); } - /* If we haven't established the PMTU yet, restart the discovery process. */ - - if(n->mtuprobes > 30) { - if (probelen == n->maxmtu + 8) { - logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname); - n->maxmtu = MTU; - n->mtuprobes = 10; - return; - } - - if(n->minmtu) - n->mtuprobes = 30; - else - n->mtuprobes = 1; + if(probelen >= n->maxmtu + 8) { + logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname); + n->maxmtu = MTU; + n->mtuprobes = 10; + return; } /* If applicable, raise the minimum supported MTU */ @@ -286,6 +254,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) { n->rtt = diff.tv_sec + diff.tv_usec * 1e-6; n->probe_time = probe_timestamp; } else if(n->probe_counter == 3) { + /* TODO: this will never fire after initial MTU discovery. */ struct timeval probe_timestamp_diff; timersub(&probe_timestamp, &n->probe_time, &probe_timestamp_diff); n->bandwidth = 2.0 * probelen / (probe_timestamp_diff.tv_sec + probe_timestamp_diff.tv_usec * 1e-6); @@ -969,6 +938,12 @@ static void try_udp(node_t* n) { if(ping_tx_elapsed.tv_sec >= udp_discovery_interval) { send_udp_probe_packet(n, MAX(n->minmtu, 16)); n->udp_ping_sent = now; + + if(localdiscovery && !n->status.udp_confirmed && n->prevedge) { + n->status.send_locally = true; + send_udp_probe_packet(n, 16); + n->status.send_locally = false; + } } } @@ -995,8 +970,10 @@ static void try_tx(node_t *n) { if(!n->status.sptps && !via->status.validkey && via->last_req_key + 10 <= now.tv_sec) { send_req_key(via); via->last_req_key = now.tv_sec; - } else if(via == n || !n->status.sptps || (via->options >> 24) >= 4) + } else if(via == n || !n->status.sptps || (via->options >> 24) >= 4) { try_udp(via); + try_mtu(via); + } /* If we don't know how to reach "via" yet, then try to reach it through a relay. */ if(n->status.sptps && !via->status.udp_confirmed && via->nexthop != via && (via->nexthop->options >> 24) >= 4)