Use xoshiro256** to generate pseudo-random numbers.
[tinc] / src / node.c
1 /*
2     node.c -- node tree management
3     Copyright (C) 2001-2013 Guus Sliepen <guus@tinc-vpn.org>,
4                   2001-2005 Ivo Timmermans
5
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.
10
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.
15
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.
19 */
20
21 #include "system.h"
22
23 #include "address_cache.h"
24 #include "control_common.h"
25 #include "logger.h"
26 #include "net.h"
27 #include "netutl.h"
28 #include "node.h"
29 #include "splay_tree.h"
30 #include "utils.h"
31 #include "xalloc.h"
32
33 #include "ed25519/sha512.h"
34
35 node_t *myself;
36
37 static int node_compare(const node_t *a, const node_t *b) {
38         return strcmp(a->name, b->name);
39 }
40
41 static int node_id_compare(const node_t *a, const node_t *b) {
42         return memcmp(&a->id, &b->id, sizeof(node_id_t));
43 }
44
45 static int node_udp_compare(const node_t *a, const node_t *b) {
46         int result = sockaddrcmp(&a->address, &b->address);
47
48         if(result) {
49                 return result;
50         }
51
52         return (a->name && b->name) ? strcmp(a->name, b->name) : 0;
53 }
54
55 splay_tree_t node_tree = {
56         .compare = (splay_compare_t) node_compare,
57         .delete = (splay_action_t) free_node,
58 };
59
60 static splay_tree_t node_id_tree = {
61         .compare = (splay_compare_t) node_id_compare,
62 };
63
64 static splay_tree_t node_udp_tree = {
65         .compare = (splay_compare_t) node_udp_compare,
66 };
67
68 void exit_nodes(void) {
69         splay_empty_tree(&node_udp_tree);
70         splay_empty_tree(&node_id_tree);
71         splay_empty_tree(&node_tree);
72 }
73
74 node_t *new_node(void) {
75         node_t *n = xzalloc(sizeof(*n));
76
77         if(replaywin) {
78                 n->late = xzalloc(replaywin);
79         }
80
81         init_subnet_tree(&n->subnet_tree);
82         init_edge_tree(&n->edge_tree);
83
84         n->mtu = MTU;
85         n->maxmtu = MTU;
86         n->udp_ping_rtt = -1;
87
88         return n;
89 }
90
91 void free_node(node_t *n) {
92         splay_empty_tree(&n->subnet_tree);
93         splay_empty_tree(&n->edge_tree);
94
95         sockaddrfree(&n->address);
96
97 #ifndef DISABLE_LEGACY
98         cipher_free(&n->incipher);
99         digest_free(&n->indigest);
100         cipher_free(&n->outcipher);
101         digest_free(&n->outdigest);
102 #endif
103
104         ecdsa_free(n->ecdsa);
105         sptps_stop(&n->sptps);
106
107         timeout_del(&n->udp_ping_timeout);
108
109         free(n->hostname);
110         free(n->name);
111         free(n->late);
112
113         if(n->address_cache) {
114                 close_address_cache(n->address_cache);
115         }
116
117         free(n);
118 }
119
120 void node_add(node_t *n) {
121         unsigned char buf[64];
122         sha512(n->name, strlen(n->name), buf);
123         memcpy(&n->id, buf, sizeof(n->id));
124
125         splay_insert(&node_tree, n);
126         splay_insert(&node_id_tree, n);
127 }
128
129 void node_del(node_t *n) {
130         splay_delete(&node_udp_tree, n);
131
132         for splay_each(subnet_t, s, &n->subnet_tree) {
133                 subnet_del(n, s);
134         }
135
136         for splay_each(edge_t, e, &n->edge_tree) {
137                 edge_del(e);
138         }
139
140         splay_delete(&node_id_tree, n);
141         splay_delete(&node_tree, n);
142 }
143
144 node_t *lookup_node(char *name) {
145         node_t n = {0};
146
147         n.name = name;
148
149         return splay_search(&node_tree, &n);
150 }
151
152 node_t *lookup_node_id(const node_id_t *id) {
153         node_t n = {.id = *id};
154         return splay_search(&node_id_tree, &n);
155 }
156
157 node_t *lookup_node_udp(const sockaddr_t *sa) {
158         node_t tmp = {.address = *sa};
159         return splay_search(&node_udp_tree, &tmp);
160 }
161
162 void update_node_udp(node_t *n, const sockaddr_t *sa) {
163         if(n == myself) {
164                 logger(DEBUG_ALWAYS, LOG_WARNING, "Trying to update UDP address of myself!");
165                 return;
166         }
167
168         splay_delete(&node_udp_tree, n);
169
170         if(sa) {
171                 n->address = *sa;
172                 n->sock = 0;
173
174                 for(int i = 0; i < listen_sockets; i++) {
175                         if(listen_socket[i].sa.sa.sa_family == sa->sa.sa_family) {
176                                 n->sock = i;
177                                 break;
178                         }
179                 }
180
181                 splay_insert(&node_udp_tree, n);
182                 free(n->hostname);
183                 n->hostname = sockaddr2hostname(&n->address);
184                 logger(DEBUG_PROTOCOL, LOG_DEBUG, "UDP address of %s set to %s", n->name, n->hostname);
185         }
186
187         /* invalidate UDP information - note that this is a security feature as well to make sure
188            we can't be tricked into flooding any random address with UDP packets */
189         n->status.udp_confirmed = false;
190         n->maxrecentlen = 0;
191         n->mtuprobes = 0;
192         n->minmtu = 0;
193         n->maxmtu = MTU;
194 }
195
196 bool dump_nodes(connection_t *c) {
197         for splay_each(node_t, n, &node_tree) {
198                 char id[2 * sizeof(n->id) + 1];
199
200                 for(size_t c = 0; c < sizeof(n->id); ++c) {
201                         snprintf(id + 2 * c, 3, "%02x", n->id.x[c]);
202                 }
203
204                 id[sizeof(id) - 1] = 0;
205                 send_request(c, "%d %d %s %s %s %d %d %zu %d %x %x %s %s %d %d %d %d %ld %d %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64, CONTROL, REQ_DUMP_NODES,
206                              n->name, id, n->hostname ? n->hostname : "unknown port unknown",
207 #ifdef DISABLE_LEGACY
208                              0, 0, 0UL,
209 #else
210                              cipher_get_nid(n->outcipher), digest_get_nid(n->outdigest), digest_length(n->outdigest),
211 #endif
212                              n->outcompression, n->options, bitfield_to_int(&n->status, sizeof(n->status)),
213                              n->nexthop ? n->nexthop->name : "-", n->via && n->via->name ? n->via->name : "-", n->distance,
214                              n->mtu, n->minmtu, n->maxmtu, (long)n->last_state_change, n->udp_ping_rtt,
215                              n->in_packets, n->in_bytes, n->out_packets, n->out_bytes);
216         }
217
218         return send_request(c, "%d %d", CONTROL, REQ_DUMP_NODES);
219 }
220
221 bool dump_traffic(connection_t *c) {
222         for splay_each(node_t, n, &node_tree)
223                 send_request(c, "%d %d %s %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64, CONTROL, REQ_DUMP_TRAFFIC,
224                              n->name, n->in_packets, n->in_bytes, n->out_packets, n->out_bytes);
225
226         return send_request(c, "%d %d", CONTROL, REQ_DUMP_TRAFFIC);
227 }