Only read our public key if it wasn't already in the private key file.
[tinc] / src / protocol_subnet.c
1 /*
2     protocol_subnet.c -- handle the meta-protocol, subnets
3     Copyright (C) 1999-2003 Ivo Timmermans <ivo@o2w.nl>,
4                   2000-2003 Guus Sliepen <guus@sliepen.eu.org>
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
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: protocol_subnet.c,v 1.1.4.18 2003/12/12 19:52:25 guus Exp $
21 */
22
23 #include "system.h"
24
25 #include "conf.h"
26 #include "connection.h"
27 #include "logger.h"
28 #include "net.h"
29 #include "netutl.h"
30 #include "node.h"
31 #include "protocol.h"
32 #include "subnet.h"
33 #include "utils.h"
34 #include "xalloc.h"
35
36 bool send_add_subnet(connection_t *c, const subnet_t *subnet)
37 {
38         char netstr[MAXNETSTR];
39
40         cp();
41
42         if(!net2str(netstr, sizeof netstr, subnet))
43                 return false;
44
45         return send_request(c, "%d %lx %s %s", ADD_SUBNET, random(), subnet->owner->name, netstr);
46 }
47
48 bool add_subnet_h(connection_t *c)
49 {
50         char subnetstr[MAX_STRING_SIZE];
51         char name[MAX_STRING_SIZE];
52         node_t *owner;
53         subnet_t s = {0}, *new;
54
55         cp();
56
57         if(sscanf(c->buffer, "%*d %*x " MAX_STRING " " MAX_STRING, name, subnetstr) != 2) {
58                 logger(LOG_ERR, _("Got bad %s from %s (%s)"), "ADD_SUBNET", c->name,
59                            c->hostname);
60                 return false;
61         }
62
63         /* Check if owner name is a valid */
64
65         if(!check_id(name)) {
66                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "ADD_SUBNET", c->name,
67                            c->hostname, _("invalid name"));
68                 return false;
69         }
70
71         /* Check if subnet string is valid */
72
73         if(!str2net(&s, subnetstr)) {
74                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "ADD_SUBNET", c->name,
75                            c->hostname, _("invalid subnet string"));
76                 return false;
77         }
78
79         if(seen_request(c->buffer))
80                 return true;
81
82         /* Check if the owner of the new subnet is in the connection list */
83
84         owner = lookup_node(name);
85
86         if(!owner) {
87                 owner = new_node();
88                 owner->name = xstrdup(name);
89                 node_add(owner);
90         }
91
92         if(tunnelserver && owner != myself && owner != c->node)
93                 return false;
94
95         /* Check if we already know this subnet */
96
97         if(lookup_subnet(owner, &s))
98                 return true;
99
100         /* If we don't know this subnet, but we are the owner, retaliate with a DEL_SUBNET */
101
102         if(owner == myself) {
103                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for ourself"),
104                                    "ADD_SUBNET", c->name, c->hostname);
105                 s.owner = myself;
106                 send_del_subnet(c, &s);
107                 return true;
108         }
109
110         /* In tunnel server mode, check if the subnet matches one in the config file of this node */
111
112         if(tunnelserver) {
113                 config_t *cfg;
114                 subnet_t *allowed;
115
116                 for(cfg = lookup_config(c->config_tree, "Subnet"); cfg; cfg = lookup_config_next(c->config_tree, cfg)) {
117                         if(!get_config_subnet(cfg, &allowed))
118                                 return false;
119
120                         if(!subnet_compare(&s, allowed))
121                                 break;
122
123                         free_subnet(allowed);
124                 }
125
126                 if(!cfg)
127                         return false;
128
129                 free_subnet(allowed);
130         }
131
132         /* If everything is correct, add the subnet to the list of the owner */
133
134         *(new = new_subnet()) = s;
135         subnet_add(owner, new);
136
137         /* Tell the rest */
138
139         if(!tunnelserver)
140                 forward_request(c);
141
142         return true;
143 }
144
145 bool send_del_subnet(connection_t *c, const subnet_t *s)
146 {
147         char netstr[MAXNETSTR];
148
149         cp();
150
151         if(!net2str(netstr, sizeof netstr, s))
152                 return false;
153
154         return send_request(c, "%d %lx %s %s", DEL_SUBNET, random(), s->owner->name, netstr);
155 }
156
157 bool del_subnet_h(connection_t *c)
158 {
159         char subnetstr[MAX_STRING_SIZE];
160         char name[MAX_STRING_SIZE];
161         node_t *owner;
162         subnet_t s = {0}, *find;
163
164         cp();
165
166         if(sscanf(c->buffer, "%*d %*x " MAX_STRING " " MAX_STRING, name, subnetstr) != 2) {
167                 logger(LOG_ERR, _("Got bad %s from %s (%s)"), "DEL_SUBNET", c->name,
168                            c->hostname);
169                 return false;
170         }
171
172         /* Check if owner name is a valid */
173
174         if(!check_id(name)) {
175                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "DEL_SUBNET", c->name,
176                            c->hostname, _("invalid name"));
177                 return false;
178         }
179
180         /* Check if the owner of the new subnet is in the connection list */
181
182         owner = lookup_node(name);
183
184         if(!owner) {
185                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for %s which is not in our node tree"),
186                                    "DEL_SUBNET", c->name, c->hostname, name);
187                 return true;
188         }
189
190         if(tunnelserver && owner != myself && owner != c->node)
191                 return false;
192
193         /* Check if subnet string is valid */
194
195         if(!str2net(&s, subnetstr)) {
196                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "DEL_SUBNET", c->name,
197                            c->hostname, _("invalid subnet string"));
198                 return false;
199         }
200
201         if(seen_request(c->buffer))
202                 return true;
203
204         /* If everything is correct, delete the subnet from the list of the owner */
205
206         s.owner = owner;
207
208         find = lookup_subnet(owner, &s);
209
210         if(!find) {
211                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for %s which does not appear in his subnet tree"),
212                                    "DEL_SUBNET", c->name, c->hostname, name);
213                 return true;
214         }
215
216         /* If we are the owner of this subnet, retaliate with an ADD_SUBNET */
217
218         if(owner == myself) {
219                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for ourself"),
220                                    "DEL_SUBNET", c->name, c->hostname);
221                 send_add_subnet(c, find);
222                 return true;
223         }
224
225         /* Tell the rest */
226
227         if(!tunnelserver)
228                 forward_request(c);
229
230         /* Finally, delete it. */
231
232         subnet_del(owner, find);
233
234         return true;
235 }