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