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.17 2003/11/17 15:30:18 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         bool x;
  39         char *netstr;
  40
  41         cp();
  42
  43         x = send_request(c, "%d %lx %s %s", ADD_SUBNET, random(),
  44                                          subnet->owner->name, netstr = net2str(subnet));
  45
  46         free(netstr);
  47
  48         return x;
  49 }
  50
  51 bool add_subnet_h(connection_t *c)
  52 {
  53         char subnetstr[MAX_STRING_SIZE];
  54         char name[MAX_STRING_SIZE];
  55         node_t *owner;
  56         subnet_t *s;
  57
  58         cp();
  59
  60         if(sscanf(c->buffer, "%*d %*x " MAX_STRING " " MAX_STRING, name, subnetstr) != 2) {
  61                 logger(LOG_ERR, _("Got bad %s from %s (%s)"), "ADD_SUBNET", c->name,
  62                            c->hostname);
  63                 return false;
  64         }
  65
  66         /* Check if owner name is a valid */
  67
  68         if(!check_id(name)) {
  69                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "ADD_SUBNET", c->name,
  70                            c->hostname, _("invalid name"));
  71                 return false;
  72         }
  73
  74         /* Check if subnet string is valid */
  75
  76         s = str2net(subnetstr);
  77
  78         if(!s) {
  79                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "ADD_SUBNET", c->name,
  80                            c->hostname, _("invalid subnet string"));
  81                 return false;
  82         }
  83
  84         if(seen_request(c->buffer))
  85                 return true;
  86
  87         /* Check if the owner of the new subnet is in the connection list */
  88
  89         owner = lookup_node(name);
  90
  91         if(!owner) {
  92                 owner = new_node();
  93                 owner->name = xstrdup(name);
  94                 node_add(owner);
  95         }
  96
  97         if(tunnelserver && owner != myself && owner != c->node)
  98                 return false;
  99
 100         /* Check if we already know this subnet */
 101
 102         if(lookup_subnet(owner, s)) {
 103                 free_subnet(s);
 104                 return true;
 105         }
 106
 107         /* If we don't know this subnet, but we are the owner, retaliate with a DEL_SUBNET */
 108
 109         if(owner == myself) {
 110                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for ourself"),
 111                                    "ADD_SUBNET", c->name, c->hostname);
 112                 s->owner = myself;
 113                 send_del_subnet(c, s);
 114                 return true;
 115         }
 116
 117         /* In tunnel server mode, check if the subnet matches one in the config file of this node */
 118
 119         if(tunnelserver) {
 120                 config_t *cfg;
 121                 subnet_t *allowed;
 122
 123                 for(cfg = lookup_config(c->config_tree, "Subnet"); cfg; cfg = lookup_config_next(c->config_tree, cfg)) {
 124                         if(!get_config_subnet(cfg, &allowed))
 125                                 return false;
 126
 127                         if(!subnet_compare(s, allowed))
 128                                 break;
 129
 130                         free_subnet(allowed);
 131                 }
 132
 133                 if(!cfg)
 134                         return false;
 135
 136                 free_subnet(allowed);
 137         }
 138
 139         /* If everything is correct, add the subnet to the list of the owner */
 140
 141         subnet_add(owner, s);
 142
 143         /* Tell the rest */
 144
 145         if(!tunnelserver)
 146                 forward_request(c);
 147
 148         return true;
 149 }
 150
 151 bool send_del_subnet(connection_t *c, const subnet_t *s)
 152 {
 153         bool x;
 154         char *netstr;
 155
 156         cp();
 157
 158         netstr = net2str(s);
 159
 160         x = send_request(c, "%d %lx %s %s", DEL_SUBNET, random(), s->owner->name, netstr);
 161
 162         free(netstr);
 163
 164         return x;
 165 }
 166
 167 bool del_subnet_h(connection_t *c)
 168 {
 169         char subnetstr[MAX_STRING_SIZE];
 170         char name[MAX_STRING_SIZE];
 171         node_t *owner;
 172         subnet_t *s, *find;
 173
 174         cp();
 175
 176         if(sscanf(c->buffer, "%*d %*x " MAX_STRING " " MAX_STRING, name, subnetstr) != 2) {
 177                 logger(LOG_ERR, _("Got bad %s from %s (%s)"), "DEL_SUBNET", c->name,
 178                            c->hostname);
 179                 return false;
 180         }
 181
 182         /* Check if owner name is a valid */
 183
 184         if(!check_id(name)) {
 185                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "DEL_SUBNET", c->name,
 186                            c->hostname, _("invalid name"));
 187                 return false;
 188         }
 189
 190         /* Check if the owner of the new subnet is in the connection list */
 191
 192         owner = lookup_node(name);
 193
 194         if(!owner) {
 195                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for %s which is not in our node tree"),
 196                                    "DEL_SUBNET", c->name, c->hostname, name);
 197                 return true;
 198         }
 199
 200         if(tunnelserver && owner != myself && owner != c->node)
 201                 return false;
 202
 203         /* Check if subnet string is valid */
 204
 205         s = str2net(subnetstr);
 206
 207         if(!s) {
 208                 logger(LOG_ERR, _("Got bad %s from %s (%s): %s"), "DEL_SUBNET", c->name,
 209                            c->hostname, _("invalid subnet string"));
 210                 return false;
 211         }
 212
 213         if(seen_request(c->buffer))
 214                 return true;
 215
 216         /* If everything is correct, delete the subnet from the list of the owner */
 217
 218         s->owner = owner;
 219
 220         find = lookup_subnet(owner, s);
 221
 222         free_subnet(s);
 223
 224         if(!find) {
 225                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for %s which does not appear in his subnet tree"),
 226                                    "DEL_SUBNET", c->name, c->hostname, name);
 227                 return true;
 228         }
 229
 230         /* If we are the owner of this subnet, retaliate with an ADD_SUBNET */
 231
 232         if(owner == myself) {
 233                 ifdebug(PROTOCOL) logger(LOG_WARNING, _("Got %s from %s (%s) for ourself"),
 234                                    "DEL_SUBNET", c->name, c->hostname);
 235                 send_add_subnet(c, find);
 236                 return true;
 237         }
 238
 239         /* Tell the rest */
 240
 241         if(!tunnelserver)
 242                 forward_request(c);
 243
 244         /* Finally, delete it. */
 245
 246         subnet_del(owner, find);
 247
 248         return true;
 249 }