2 protocol_misc.c -- handle the meta-protocol, miscellaneous functions
3 Copyright (C) 1999-2005 Ivo Timmermans,
4 2000-2013 Guus Sliepen <guus@tinc-vpn.org>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include "connection.h"
34 #define MIN(x, y) (((x)<(y))?(x):(y))
37 int maxoutbufsize = 0;
38 int mtu_info_interval = 5;
39 int udp_info_interval = 5;
41 bool send_termreq(connection_t *c) {
42 return send_request(c, "%d", TERMREQ);
45 bool termreq_h(connection_t *c, const char *request) {
49 bool send_ping(connection_t *c) {
50 c->status.pinged = true;
51 c->last_ping_time = now.tv_sec;
53 return send_request(c, "%d", PING);
56 bool ping_h(connection_t *c, const char *request) {
60 bool send_pong(connection_t *c) {
61 return send_request(c, "%d", PONG);
64 bool pong_h(connection_t *c, const char *request) {
65 c->status.pinged = false;
67 /* Successful connection, reset timeout if this is an outgoing connection. */
70 c->outgoing->timeout = 0;
71 c->outgoing->cfg = NULL;
74 freeaddrinfo(c->outgoing->ai);
77 c->outgoing->ai = NULL;
78 c->outgoing->aip = NULL;
84 /* Sending and receiving packets via TCP */
86 bool send_tcppacket(connection_t *c, const vpn_packet_t *packet) {
87 /* If there already is a lot of data in the outbuf buffer, discard this packet.
88 We use a very simple Random Early Drop algorithm. */
90 if(2.0 * c->outbuf.len / (float)maxoutbufsize - 1 > (float)rand() / (float)RAND_MAX) {
94 if(!send_request(c, "%d %d", PACKET, packet->len)) {
98 return send_meta(c, (char *)DATA(packet), packet->len);
101 bool tcppacket_h(connection_t *c, const char *request) {
104 if(sscanf(request, "%*d %hd", &len) != 1) {
105 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "PACKET", c->name,
110 /* Set reqlen to len, this will tell receive_meta() that a tcppacket is coming. */
117 bool send_sptps_tcppacket(connection_t *c, const char *packet, int len) {
118 /* If there already is a lot of data in the outbuf buffer, discard this packet.
119 We use a very simple Random Early Drop algorithm. */
121 if(2.0 * c->outbuf.len / (float)maxoutbufsize - 1 > (float)rand() / (float)RAND_MAX) {
125 if(!send_request(c, "%d %d", SPTPS_PACKET, len)) {
129 send_meta_raw(c, packet, len);
133 bool sptps_tcppacket_h(connection_t *c, const char *request) {
136 if(sscanf(request, "%*d %hd", &len) != 1) {
137 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "SPTPS_PACKET", c->name,
142 /* Set sptpslen to len, this will tell receive_meta() that a SPTPS packet is coming. */
149 /* Transmitting UDP information */
151 bool send_udp_info(node_t *from, node_t *to) {
152 /* If there's a static relay in the path, there's no point in sending the message
153 farther than the static relay. */
154 to = (to->via == myself) ? to->nexthop : to->via;
157 logger(DEBUG_ALWAYS, LOG_ERR, "Something went wrong when selecting relay - possible fake UDP_INFO");
161 /* Skip cases where sending UDP info messages doesn't make sense.
162 This is done here in order to avoid repeating the same logic in multiple callsites. */
168 if(!to->status.reachable) {
177 struct timeval elapsed;
179 timersub(&now, &to->udp_info_sent, &elapsed);
181 if(elapsed.tv_sec < udp_info_interval) {
186 if((myself->options | from->options | to->options) & OPTION_TCPONLY) {
190 if((to->nexthop->options >> 24) < 5) {
194 char *from_address, *from_port;
195 /* If we're the originator, the address we use is irrelevant
196 because the first intermediate node will ignore it.
197 We use our local address as it somewhat makes sense
198 and it's simpler than introducing an encoding for "null" addresses anyway. */
199 sockaddr2str((from != myself) ? &from->address : &to->nexthop->connection->edge->local_address, &from_address, &from_port);
201 bool x = send_request(to->nexthop->connection, "%d %s %s %s %s", UDP_INFO, from->name, to->name, from_address, from_port);
207 to->udp_info_sent = now;
213 bool udp_info_h(connection_t *c, const char *request) {
214 char from_name[MAX_STRING_SIZE];
215 char to_name[MAX_STRING_SIZE];
216 char from_address[MAX_STRING_SIZE];
217 char from_port[MAX_STRING_SIZE];
219 if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING" "MAX_STRING, from_name, to_name, from_address, from_port) != 4) {
220 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "UDP_INFO", c->name, c->hostname);
224 if(!check_id(from_name) || !check_id(to_name)) {
225 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "UDP_INFO", c->name, c->hostname, "invalid name");
229 node_t *from = lookup_node(from_name);
232 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist in our connection list", "UDP_INFO", c->name, c->hostname, from_name);
236 if(from != from->via) {
237 /* Not supposed to happen, as it means the message wandered past a static relay */
238 logger(DEBUG_PROTOCOL, LOG_WARNING, "Got UDP info message from %s (%s) which we can't reach directly", from->name, from->hostname);
242 /* If we have a direct edge to "from", we are in a better position
243 to guess its address than it is itself. */
244 if(!from->connection && !from->status.udp_confirmed) {
245 sockaddr_t from_addr = str2sockaddr(from_address, from_port);
247 if(sockaddrcmp(&from_addr, &from->address)) {
248 update_node_udp(from, &from_addr);
252 node_t *to = lookup_node(to_name);
255 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) destination %s which does not exist in our connection list", "UDP_INFO", c->name, c->hostname, to_name);
259 /* Send our own data (which could be what we just received) up the chain. */
261 return send_udp_info(from, to);
264 /* Transmitting MTU information */
266 bool send_mtu_info(node_t *from, node_t *to, int mtu) {
267 /* Skip cases where sending MTU info messages doesn't make sense.
268 This is done here in order to avoid repeating the same logic in multiple callsites. */
274 if(!to->status.reachable) {
283 struct timeval elapsed;
285 timersub(&now, &to->mtu_info_sent, &elapsed);
287 if(elapsed.tv_sec < mtu_info_interval) {
292 if((to->nexthop->options >> 24) < 6) {
296 /* We will send the passed-in MTU value, unless we believe ours is better. */
298 node_t *via = (from->via == myself) ? from->nexthop : from->via;
300 if(from->minmtu == from->maxmtu && from->via == myself) {
301 /* We have a direct measurement. Override the value entirely.
302 Note that we only do that if we are sitting as a static relay in the path;
303 otherwise, we can't guarantee packets will flow through us, and increasing
304 MTU could therefore end up being too optimistic. */
306 } else if(via->minmtu == via->maxmtu) {
307 /* Static relay. Ensure packets will make it through the entire relay path. */
308 mtu = MIN(mtu, via->minmtu);
309 } else if(via->nexthop->minmtu == via->nexthop->maxmtu) {
310 /* Dynamic relay. Ensure packets will make it through the entire relay path. */
311 mtu = MIN(mtu, via->nexthop->minmtu);
315 to->mtu_info_sent = now;
318 /* If none of the conditions above match in the steady state, it means we're using TCP,
319 so the MTU is irrelevant. That said, it is still important to honor the MTU that was passed in,
320 because other parts of the relay path might be able to use UDP, which means they care about the MTU. */
322 return send_request(to->nexthop->connection, "%d %s %s %d", MTU_INFO, from->name, to->name, mtu);
325 bool mtu_info_h(connection_t *c, const char *request) {
326 char from_name[MAX_STRING_SIZE];
327 char to_name[MAX_STRING_SIZE];
330 if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" %d", from_name, to_name, &mtu) != 3) {
331 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "MTU_INFO", c->name, c->hostname);
336 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid MTU");
342 if(!check_id(from_name) || !check_id(to_name)) {
343 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid name");
347 node_t *from = lookup_node(from_name);
350 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist in our connection list", "MTU_INFO", c->name, c->hostname, from_name);
354 /* If we don't know the current MTU for that node, use the one we received.
355 Even if we're about to make our own measurements, the value we got from downstream nodes should be pretty close
356 so it's a good idea to use it in the mean time. */
357 if(from->mtu != mtu && from->minmtu != from->maxmtu) {
358 logger(DEBUG_TRAFFIC, LOG_INFO, "Using provisional MTU %d for node %s (%s)", mtu, from->name, from->hostname);
362 node_t *to = lookup_node(to_name);
365 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) destination %s which does not exist in our connection list", "MTU_INFO", c->name, c->hostname, to_name);
369 /* Continue passing the MTU value (or a better one if we have it) up the chain. */
371 return send_mtu_info(from, to, mtu);