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"
33 int maxoutbufsize = 0;
34 int udp_info_interval = 5;
36 /* Status and error notification routines */
38 bool send_status(connection_t *c, int statusno, const char *statusstring) {
40 statusstring = "Status";
42 return send_request(c, "%d %d %s", STATUS, statusno, statusstring);
45 bool status_h(connection_t *c, const char *request) {
47 char statusstring[MAX_STRING_SIZE];
49 if(sscanf(request, "%*d %d " MAX_STRING, &statusno, statusstring) != 2) {
50 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "STATUS",
51 c->name, c->hostname);
55 logger(DEBUG_STATUS, LOG_NOTICE, "Status message from %s (%s): %d: %s",
56 c->name, c->hostname, statusno, statusstring);
61 bool send_error(connection_t *c, int err, const char *errstring) {
65 return send_request(c, "%d %d %s", ERROR, err, errstring);
68 bool error_h(connection_t *c, const char *request) {
70 char errorstring[MAX_STRING_SIZE];
72 if(sscanf(request, "%*d %d " MAX_STRING, &err, errorstring) != 2) {
73 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "ERROR",
74 c->name, c->hostname);
78 logger(DEBUG_ERROR, LOG_NOTICE, "Error message from %s (%s): %d: %s",
79 c->name, c->hostname, err, errorstring);
84 bool send_termreq(connection_t *c) {
85 return send_request(c, "%d", TERMREQ);
88 bool termreq_h(connection_t *c, const char *request) {
92 bool send_ping(connection_t *c) {
93 c->status.pinged = true;
94 c->last_ping_time = now.tv_sec;
96 return send_request(c, "%d", PING);
99 bool ping_h(connection_t *c, const char *request) {
103 bool send_pong(connection_t *c) {
104 return send_request(c, "%d", PONG);
107 bool pong_h(connection_t *c, const char *request) {
108 c->status.pinged = false;
110 /* Succesful connection, reset timeout if this is an outgoing connection. */
113 c->outgoing->timeout = 0;
114 c->outgoing->cfg = NULL;
116 freeaddrinfo(c->outgoing->ai);
117 c->outgoing->ai = NULL;
118 c->outgoing->aip = NULL;
124 /* Sending and receiving packets via TCP */
126 bool send_tcppacket(connection_t *c, const vpn_packet_t *packet) {
127 /* If there already is a lot of data in the outbuf buffer, discard this packet.
128 We use a very simple Random Early Drop algorithm. */
130 if(2.0 * c->outbuf.len / (float)maxoutbufsize - 1 > (float)rand()/(float)RAND_MAX)
133 if(!send_request(c, "%d %hd", PACKET, packet->len))
136 return send_meta(c, (char *)DATA(packet), packet->len);
139 bool tcppacket_h(connection_t *c, const char *request) {
142 if(sscanf(request, "%*d %hd", &len) != 1) {
143 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "PACKET", c->name,
148 /* Set reqlen to len, this will tell receive_meta() that a tcppacket is coming. */
155 /* Transmitting UDP information */
157 bool send_udp_info(node_t *from, node_t *to) {
158 /* If there's a static relay in the path, there's no point in sending the message
159 farther than the static relay. */
160 to = (to->via == myself) ? to->nexthop : to->via;
162 /* Skip cases where sending UDP info messages doesn't make sense.
163 This is done here in order to avoid repeating the same logic in multiple callsites. */
168 if(!to->status.reachable)
175 struct timeval elapsed;
176 timersub(&now, &to->udp_info_sent, &elapsed);
177 if(elapsed.tv_sec < udp_info_interval)
181 if((myself->options | from->options | to->options) & OPTION_TCPONLY)
184 if((to->nexthop->options >> 24) < 5)
187 char *from_address, *from_port;
188 /* If we're the originator, the address we use is irrelevant
189 because the first intermediate node will ignore it.
190 We use our local address as it somewhat makes sense
191 and it's simpler than introducing an encoding for "null" addresses anyway. */
192 sockaddr2str((from != myself) ? &from->address : &to->nexthop->connection->edge->local_address, &from_address, &from_port);
194 bool x = send_request(to->nexthop->connection, "%d %s %s %s %s", UDP_INFO, from->name, to->name, from_address, from_port);
200 to->udp_info_sent = now;
205 bool udp_info_h(connection_t *c, const char* request) {
206 char from_name[MAX_STRING_SIZE];
207 char to_name[MAX_STRING_SIZE];
208 char from_address[MAX_STRING_SIZE];
209 char from_port[MAX_STRING_SIZE];
211 if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING" "MAX_STRING, from_name, to_name, from_address, from_port) != 4) {
212 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "UDP_INFO", c->name, c->hostname);
216 if(!check_id(from_name) || !check_id(to_name)) {
217 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "UDP_INFO", c->name, c->hostname, "invalid name");
221 node_t *from = lookup_node(from_name);
223 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);
227 if(from != from->via) {
228 /* Not supposed to happen, as it means the message wandered past a static relay */
229 logger(DEBUG_PROTOCOL, LOG_WARNING, "Got UDP info message from %s (%s) which we can't reach directly", from->name, from->hostname);
233 /* If we have a direct edge to "from", we are in a better position
234 to guess its address than it is itself. */
235 if(!from->connection && !from->status.udp_confirmed) {
236 sockaddr_t from_addr = str2sockaddr(from_address, from_port);
237 if(sockaddrcmp(&from_addr, &from->address))
238 update_node_udp(from, &from_addr);
241 node_t *to = lookup_node(to_name);
243 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);
247 /* Send our own data (which could be what we just received) up the chain. */
249 return send_udp_info(from, to);
252 /* Transmitting MTU information */
254 bool send_mtu_info(node_t *from, node_t *to, int mtu) {
255 /* Skip cases where sending MTU info messages doesn't make sense.
256 This is done here in order to avoid repeating the same logic in multiple callsites. */
261 if(!to->status.reachable)
264 if(from == myself && to->connection)
267 if((to->nexthop->options >> 24) < 6)
270 /* We will send the passed-in MTU value, unless we believe ours is better. */
272 node_t *via = (from->via == myself) ? from->nexthop : from->via;
273 if(from->minmtu == from->maxmtu && from->via == myself) {
274 /* We have a direct measurement. Override the value entirely.
275 Note that we only do that if we are sitting as a static relay in the path;
276 otherwise, we can't guarantee packets will flow through us, and increasing
277 MTU could therefore end up being too optimistic. */
279 } else if(via->minmtu == via->maxmtu) {
280 /* Static relay. Ensure packets will make it through the entire relay path. */
281 mtu = MIN(mtu, via->minmtu);
282 } else if(via->nexthop->minmtu == via->nexthop->maxmtu) {
283 /* Dynamic relay. Ensure packets will make it through the entire relay path. */
284 mtu = MIN(mtu, via->nexthop->minmtu);
287 /* If none of the conditions above match in the steady state, it means we're using TCP,
288 so the MTU is irrelevant. That said, it is still important to honor the MTU that was passed in,
289 because other parts of the relay path might be able to use UDP, which means they care about the MTU. */
291 return send_request(to->nexthop->connection, "%d %s %s %d", MTU_INFO, from->name, to->name, mtu);
294 bool mtu_info_h(connection_t *c, const char* request) {
295 char from_name[MAX_STRING_SIZE];
296 char to_name[MAX_STRING_SIZE];
299 if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" %d", from_name, to_name, &mtu) != 3) {
300 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "MTU_INFO", c->name, c->hostname);
305 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid MTU");
311 if(!check_id(from_name) || !check_id(to_name)) {
312 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid name");
316 node_t *from = lookup_node(from_name);
318 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);
322 /* If we don't know the current MTU for that node, use the one we received.
323 Even if we're about to make our own measurements, the value we got from downstream nodes should be pretty close
324 so it's a good idea to use it in the mean time. */
325 if(from->mtu != mtu && from->minmtu != from->maxmtu) {
326 logger(DEBUG_TRAFFIC, LOG_INFO, "Using provisional MTU %d for node %s (%s)", mtu, from->name, from->hostname);
330 node_t *to = lookup_node(to_name);
332 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);
336 /* Continue passing the MTU value (or a better one if we have it) up the chain. */
338 return send_mtu_info(from, to, mtu);