/*
net_packet.c -- Handles in- and outgoing VPN packets
Copyright (C) 1998-2005 Ivo Timmermans,
- 2000-2011 Guus Sliepen <guus@tinc-vpn.org>
+ 2000-2013 Guus Sliepen <guus@tinc-vpn.org>
2010 Timothy Redaelli <timothy@redaelli.eu>
2010 Brandon Black <blblack@gmail.com>
mtuprobes == 32: send 1 burst, sleep pingtimeout second
mtuprobes == 33: no response from other side, restart PMTU discovery process
- Probes are sent in batches of three, with random sizes between the lower and
- upper boundaries for the MTU thus far discovered.
+ Probes are sent in batches of at least three, with random sizes between the
+ lower and upper boundaries for the MTU thus far discovered.
- In case local discovery is enabled, a fourth packet is added to each batch,
+ 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.
+
+ In case local discovery is enabled, another packet is added to each batch,
which will be broadcast to the local network.
+
*/
void send_mtu_probe(node_t *n) {
timeout = pingtimeout;
}
- for(i = 0; i < 3 + localdiscovery; i++) {
- if(n->maxmtu <= n->minmtu)
+ for(i = 0; i < 4 + localdiscovery; i++) {
+ if(i == 0) {
+ if(n->mtuprobes < 30 || n->maxmtu + 8 >= MTU)
+ continue;
+ len = n->maxmtu + 8;
+ } else if(n->maxmtu <= n->minmtu) {
len = n->maxmtu;
- else
+ } else {
len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
+ }
if(len < 64)
len = 64;
memset(packet.data, 0, 14);
RAND_pseudo_bytes(packet.data + 14, len - 14);
packet.len = len;
- if(i >= 3 && n->mtuprobes <= 10)
+ if(i >= 4 && n->mtuprobes <= 10)
packet.priority = -1;
else
packet.priority = 0;
send_udppacket(n, packet);
} else {
if(n->mtuprobes > 30) {
+ if (len == n->maxmtu + 8) {
+ ifdebug(TRAFFIC) logger(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
void receive_tcppacket(connection_t *c, const char *buffer, int len) {
vpn_packet_t outpkt;
+ if(len > sizeof outpkt.data)
+ return;
+
outpkt.len = len;
if(c->options & OPTION_TCPONLY)
outpkt.priority = 0;
struct sockaddr *sa;
socklen_t sl;
int sock;
+ sockaddr_t broadcast;
/* Overloaded use of priority field: -1 means local broadcast */
if(origpriority == -1 && n->prevedge) {
- struct sockaddr_in in;
- in.sin_family = AF_INET;
- in.sin_addr.s_addr = -1;
- in.sin_port = n->prevedge->address.in.sin_port;
- sa = (struct sockaddr *)∈
- sl = sizeof in;
- sock = 0;
+ sock = rand() % listen_sockets;
+ memset(&broadcast, 0, sizeof broadcast);
+ if(listen_socket[sock].sa.sa.sa_family == AF_INET6) {
+ broadcast.in6.sin6_family = AF_INET6;
+ broadcast.in6.sin6_addr.s6_addr[0x0] = 0xff;
+ broadcast.in6.sin6_addr.s6_addr[0x1] = 0x02;
+ broadcast.in6.sin6_addr.s6_addr[0xf] = 0x01;
+ broadcast.in6.sin6_port = n->prevedge->address.in.sin_port;
+ broadcast.in6.sin6_scope_id = listen_socket[sock].sa.in6.sin6_scope_id;
+ } else {
+ broadcast.in.sin_family = AF_INET;
+ broadcast.in.sin_addr.s_addr = -1;
+ broadcast.in.sin_port = n->prevedge->address.in.sin_port;
+ }
+ sa = &broadcast.sa;
+ sl = SALEN(broadcast.sa);
} else {
if(origpriority == -1)
origpriority = 0;
if(n->mtu >= origlen)
n->mtu = origlen - 1;
} else
- logger(LOG_ERR, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
+ ifdebug(TRAFFIC) logger(LOG_WARNING, "Error sending packet to %s (%s): %s", n->name, n->hostname, sockstrerror(sockerrno));
}
end:
void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
avl_node_t *node;
connection_t *c;
+ node_t *n;
+
+ // Always give ourself a copy of the packet.
+ if(from != myself)
+ send_packet(myself, packet);
+
+ // In TunnelServer mode, do not forward broadcast packets.
+ // The MST might not be valid and create loops.
+ if(tunnelserver || broadcast_mode == BMODE_NONE)
+ return;
ifdebug(TRAFFIC) logger(LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
packet->len, from->name, from->hostname);
- if(from != myself) {
- send_packet(myself, packet);
+ switch(broadcast_mode) {
+ // In MST mode, broadcast packets travel via the Minimum Spanning Tree.
+ // This guarantees all nodes receive the broadcast packet, and
+ // usually distributes the sending of broadcast packets over all nodes.
+ case BMODE_MST:
+ for(node = connection_tree->head; node; node = node->next) {
+ c = node->data;
- // In TunnelServer mode, do not forward broadcast packets.
- // The MST might not be valid and create loops.
- if(tunnelserver)
- return;
- }
+ if(c->status.active && c->status.mst && c != from->nexthop->connection)
+ send_packet(c->node, packet);
+ }
+ break;
+
+ // In direct mode, we send copies to each node we know of.
+ // However, this only reaches nodes that can be reached in a single hop.
+ // We don't have enough information to forward broadcast packets in this case.
+ case BMODE_DIRECT:
+ if(from != myself)
+ break;
- for(node = connection_tree->head; node; node = node->next) {
- c = node->data;
+ for(node = node_udp_tree->head; node; node = node->next) {
+ n = node->data;
+
+ if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
+ send_packet(n, packet);
+ }
+ break;
- if(c->status.active && c->status.mst && c != from->nexthop->connection)
- send_packet(c->node, packet);
+ default:
+ break;
}
}