]> git.meshlink.io Git - meshlink/blob - src/net_packet.c
Stop fast UDP probes after 30 seconds if the peer does not respond.
[meshlink] / src / net_packet.c
1 /*
2     net_packet.c -- Handles in- and outgoing VPN packets
3     Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License along
16     with this program; if not, write to the Free Software Foundation, Inc.,
17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "system.h"
21
22 #include "conf.h"
23 #include "connection.h"
24 #include "crypto.h"
25 #include "graph.h"
26 #include "logger.h"
27 #include "meshlink_internal.h"
28 #include "net.h"
29 #include "netutl.h"
30 #include "pmtu.h"
31 #include "protocol.h"
32 #include "route.h"
33 #include "sptps.h"
34 #include "utils.h"
35 #include "xalloc.h"
36
37 /* Packet I/O */
38
39 static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
40         logger(mesh, MESHLINK_DEBUG, "Received packet of %d bytes from %s", packet->len, n->name);
41
42         if(n->status.blacklisted) {
43                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
44         } else {
45                 route(mesh, n, packet);
46         }
47 }
48
49 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
50         (void)mesh;
51         return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
52 }
53
54 static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *inpkt) {
55         if(!n->status.reachable) {
56                 logger(mesh, MESHLINK_ERROR, "Got SPTPS data from unreachable node %s", n->name);
57                 return;
58         }
59
60         if(!n->sptps.state) {
61                 if(!n->status.waitingforkey) {
62                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but we haven't exchanged keys yet", n->name);
63                         send_req_key(mesh, n);
64                 } else {
65                         logger(mesh, MESHLINK_DEBUG, "Got packet from %s but he hasn't got our key yet", n->name);
66                 }
67
68                 return;
69         }
70
71         if(!sptps_receive_data(&n->sptps, inpkt->data, inpkt->len)) {
72                 logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", n->name, strerror(errno));
73         }
74 }
75
76 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
77         if(!n->status.reachable) {
78                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", n->name);
79                 return;
80         }
81
82         if(!n->status.validkey) {
83                 if(n->connection && (n->connection->flags & PROTOCOL_TINY) & n->connection->status.active) {
84                         send_raw_packet(mesh, n->connection, origpkt);
85                         return;
86                 }
87
88                 logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
89
90                 if(!n->status.waitingforkey) {
91                         send_req_key(mesh, n);
92                 } else if(n->last_req_key + 10 < mesh->loop.now.tv_sec) {
93                         logger(mesh, MESHLINK_DEBUG, "No key from %s after 10 seconds, restarting SPTPS", n->name);
94                         sptps_stop(&n->sptps);
95                         n->status.waitingforkey = false;
96                         send_req_key(mesh, n);
97                 }
98
99                 return;
100         }
101
102         uint8_t type = 0;
103
104         // If it's a probe, send it immediately without trying to compress it.
105         if(origpkt->probe) {
106                 sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
107                 return;
108         }
109
110         sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
111         return;
112 }
113
114 void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock, sockaddr_t *sa_buf) {
115         /* Latest guess */
116         *sa = &n->address;
117         *sock = n->sock;
118
119         /* If the UDP address is confirmed, use it. */
120         if(n->status.udp_confirmed) {
121                 return;
122         }
123
124         /* Send every third packet to n->address; that could be set
125            to the node's reflexive UDP address discovered during key
126            exchange. */
127
128         if(++mesh->udp_choice >= 3) {
129                 mesh->udp_choice = 0;
130                 return;
131         }
132
133         /* If we have learned an address via Catta, try this once every batch */
134         if(mesh->udp_choice == 1 && n->catta_address.sa.sa_family != AF_UNSPEC) {
135                 *sa = &n->catta_address;
136                 goto check_socket;
137         }
138
139         /* Else, if we have a canonical address, try this once every batch */
140         if(mesh->udp_choice == 1 && n->canonical_address) {
141                 char *host = xstrdup(n->canonical_address);
142                 char *port = strchr(host, ' ');
143
144                 if(port) {
145                         *port++ = 0;
146                         *sa_buf = str2sockaddr_random(mesh, host, port);
147                         *sa = sa_buf;
148
149                         if(sa_buf->sa.sa_family != AF_UNKNOWN) {
150                                 free(host);
151                                 goto check_socket;
152                         }
153                 }
154
155                 free(host);
156         }
157
158         /* Otherwise, address are found in edges to this node.
159            So we pick a random edge and a random socket. */
160
161         edge_t *candidate = NULL;
162
163         {
164                 int i = 0;
165                 int j = prng(mesh, n->edge_tree->count);
166
167                 for splay_each(edge_t, e, n->edge_tree) {
168                         if(i++ == j) {
169                                 candidate = e->reverse;
170                                 break;
171                         }
172                 }
173         }
174
175         if(candidate) {
176                 *sa = &candidate->address;
177                 *sock = prng(mesh, mesh->listen_sockets);
178         }
179
180 check_socket:
181
182         /* Make sure we have a suitable socket for the chosen address */
183         if(mesh->listen_socket[*sock].sa.sa.sa_family != (*sa)->sa.sa_family) {
184                 for(int i = 0; i < mesh->listen_sockets; i++) {
185                         if(mesh->listen_socket[i].sa.sa.sa_family == (*sa)->sa.sa_family) {
186                                 *sock = i;
187                                 break;
188                         }
189                 }
190         }
191 }
192
193 static void choose_broadcast_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
194         *sock = prng(mesh, mesh->listen_sockets);
195         sockaddr_t *broadcast_sa = &mesh->listen_socket[*sock].broadcast_sa;
196
197         if(broadcast_sa->sa.sa_family == AF_INET6) {
198                 broadcast_sa->in6.sin6_port = n->prevedge->address.in.sin_port;
199         } else {
200                 broadcast_sa->in.sin_port = n->prevedge->address.in.sin_port;
201         }
202
203         *sa = broadcast_sa;
204 }
205
206 void send_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
207         if(!n->status.reachable) {
208                 logger(mesh, MESHLINK_INFO, "Trying to send UDP packet to unreachable node %s", n->name);
209                 return;
210         }
211
212         send_sptps_packet(mesh, n, origpkt);
213 }
214
215 bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
216         assert(handle);
217         assert(data);
218         assert(len);
219
220         node_t *to = handle;
221         meshlink_handle_t *mesh = to->mesh;
222
223         if(!to->status.reachable) {
224                 logger(mesh, MESHLINK_ERROR, "Trying to send SPTPS data to unreachable node %s", to->name);
225                 return false;
226         }
227
228         /* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
229
230         if(type >= SPTPS_HANDSHAKE || (type != PKT_PROBE && (len - 21) > to->minmtu)) {
231                 char buf[len * 4 / 3 + 5];
232                 b64encode(data, buf, len);
233
234                 if(!to->nexthop || !to->nexthop->connection) {
235                         logger(mesh, MESHLINK_WARNING, "Unable to forward SPTPS packet to %s via %s", to->name, to->nexthop ? to->nexthop->name : to->name);
236                         return false;
237                 }
238
239                 /* If no valid key is known yet, send the packets using ANS_KEY requests,
240                    to ensure we get to learn the reflexive UDP address. */
241                 if(!to->status.validkey) {
242                         return send_request(mesh, to->nexthop->connection, NULL, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, mesh->self->name, to->name, buf, 0);
243                 } else {
244                         return send_request(mesh, to->nexthop->connection, NULL, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
245                 }
246         }
247
248         /* Otherwise, send the packet via UDP */
249
250         sockaddr_t sa_buf;
251         const sockaddr_t *sa;
252         int sock;
253
254         if(to->status.broadcast) {
255                 choose_broadcast_address(mesh, to, &sa, &sock);
256         } else {
257                 choose_udp_address(mesh, to, &sa, &sock, &sa_buf);
258         }
259
260         if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
261                 if(sockmsgsize(sockerrno) && len > 21) {
262                         if(to->maxmtu >= len - 21) {
263                                 to->maxmtu = len - 22;
264                         }
265
266                         if(to->mtu >= len - 21) {
267                                 to->mtu = len - 22;
268                         }
269                 } else {
270                         logger(mesh, MESHLINK_WARNING, "Error sending UDP SPTPS packet to %s: %s", to->name, sockstrerror(sockerrno));
271                         return false;
272                 }
273         }
274
275         return true;
276 }
277
278 bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
279         assert(handle);
280         assert(!data || len);
281
282         node_t *from = handle;
283         meshlink_handle_t *mesh = from->mesh;
284
285         if(type == SPTPS_HANDSHAKE) {
286                 if(!from->status.validkey) {
287                         logger(mesh, MESHLINK_INFO, "SPTPS key exchange with %s successful", from->name);
288                         from->status.validkey = true;
289                         from->status.waitingforkey = false;
290
291                         if(from->utcp) {
292                                 utcp_reset_timers(from->utcp);
293                         }
294                 }
295
296                 return true;
297         }
298
299         if(len > MAXSIZE) {
300                 logger(mesh, MESHLINK_ERROR, "Packet from %s larger than maximum supported size (%d > %d)", from->name, len, MAXSIZE);
301                 return false;
302         }
303
304         vpn_packet_t inpkt;
305
306         if(type == PKT_PROBE) {
307                 inpkt.len = len;
308                 inpkt.probe = true;
309                 memcpy(inpkt.data, data, len);
310                 udp_probe_h(mesh, from, &inpkt, len);
311                 return true;
312         } else {
313                 inpkt.probe = false;
314         }
315
316         if(type & ~(PKT_COMPRESSED)) {
317                 logger(mesh, MESHLINK_ERROR, "Unexpected SPTPS record type %d len %d from %s", type, len, from->name);
318                 return false;
319         }
320
321         if(type & PKT_COMPRESSED) {
322                 logger(mesh, MESHLINK_ERROR, "Error while decompressing packet from %s", from->name);
323                 return false;
324         }
325
326         memcpy(inpkt.data, data, len); // TODO: get rid of memcpy
327         inpkt.len = len;
328
329         receive_packet(mesh, from, &inpkt);
330         return true;
331 }
332
333 /*
334   send a packet to the given vpn ip.
335 */
336 void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
337         if(n == mesh->self) {
338                 // TODO: send to application
339                 return;
340         }
341
342         logger(mesh, MESHLINK_DEBUG, "Sending packet of %d bytes to %s", packet->len, n->name);
343
344         if(!n->status.reachable) {
345                 logger(mesh, MESHLINK_WARNING, "Node %s is not reachable", n->name);
346                 return;
347         }
348
349         n->status.want_udp = true;
350
351         send_sptps_packet(mesh, n, packet);
352         keepalive(mesh, n, true);
353         return;
354 }
355
356 static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const vpn_packet_t *pkt) {
357         node_t *n = NULL;
358         bool hard = false;
359
360         for splay_each(edge_t, e, mesh->edges) {
361                 if(!e->to->status.reachable || e->to == mesh->self) {
362                         continue;
363                 }
364
365                 if(sockaddrcmp_noport(from, &e->address)) {
366                         if(mesh->last_hard_try == mesh->loop.now.tv_sec) {
367                                 continue;
368                         }
369
370                         hard = true;
371                 }
372
373                 if(!try_mac(mesh, e->to, pkt)) {
374                         continue;
375                 }
376
377                 n = e->to;
378                 break;
379         }
380
381         if(hard) {
382                 mesh->last_hard_try = mesh->loop.now.tv_sec;
383         }
384
385         return n;
386 }
387
388 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
389         (void)flags;
390         meshlink_handle_t *mesh = loop->data;
391         listen_socket_t *ls = data;
392         vpn_packet_t pkt;
393         char *hostname;
394         sockaddr_t from;
395         socklen_t fromlen = sizeof(from);
396         node_t *n;
397         int len;
398
399         memset(&from, 0, sizeof(from));
400
401         len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
402
403         if(len <= 0 || len > MAXSIZE) {
404                 if(!sockwouldblock(sockerrno)) {
405                         logger(mesh, MESHLINK_ERROR, "Receiving packet failed: %s", sockstrerror(sockerrno));
406                 }
407
408                 return;
409         }
410
411         pkt.len = len;
412
413         sockaddrunmap(&from); /* Some braindead IPv6 implementations do stupid things. */
414
415         n = lookup_node_udp(mesh, &from);
416
417         if(!n) {
418                 n = try_harder(mesh, &from, &pkt);
419
420                 if(n) {
421                         update_node_udp(mesh, n, &from);
422                 } else if(mesh->log_level <= MESHLINK_WARNING) {
423                         hostname = sockaddr2hostname(&from);
424                         logger(mesh, MESHLINK_WARNING, "Received UDP packet from unknown source %s", hostname);
425                         free(hostname);
426                         return;
427                 } else {
428                         return;
429                 }
430         }
431
432         if(n->status.blacklisted) {
433                 logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
434                 return;
435         }
436
437         n->sock = ls - mesh->listen_socket;
438
439         receive_udppacket(mesh, n, &pkt);
440 }