staticd/static_vrf.c

   1 /*
   2  * STATICd - vrf code
   3  * Copyright (C) 2018 Cumulus Networks, Inc.
   4  *               Donald Sharp
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 #include <zebra.h>
  21
  22 #include "vrf.h"
  23 #include "nexthop.h"
  24 #include "table.h"
  25 #include "srcdest_table.h"
  26
  27 #include "static_memory.h"
  28 #include "static_vrf.h"
  29 #include "static_routes.h"
  30 #include "static_vty.h"
  31
  32 static void zebra_stable_node_cleanup(struct route_table *table,
  33                                       struct route_node *node)
  34 {
  35         struct static_route *si, *next;
  36
  37         if (node->info)
  38                 for (si = node->info; si; si = next) {
  39                         next = si->next;
  40                         XFREE(MTYPE_STATIC_ROUTE, si);
  41                 }
  42 }
  43
  44 static struct static_vrf *static_vrf_alloc(void)
  45 {
  46         struct route_table *table;
  47         struct static_vrf *svrf;
  48         safi_t safi;
  49         afi_t afi;
  50
  51         svrf = XCALLOC(MTYPE_TMP, sizeof(struct static_vrf));
  52
  53         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
  54                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
  55                         if (afi == AFI_IP6)
  56                                 table = srcdest_table_init();
  57                         else
  58                                 table = route_table_init();
  59                         table->cleanup = zebra_stable_node_cleanup;
  60                         svrf->stable[afi][safi] = table;
  61                 }
  62         }
  63         return svrf;
  64 }
  65
  66 static int static_vrf_new(struct vrf *vrf)
  67 {
  68         struct static_vrf *svrf;
  69
  70         svrf = static_vrf_alloc();
  71         vrf->info = svrf;
  72         svrf->vrf = vrf;
  73
  74         return 0;
  75 }
  76
  77 static int static_vrf_enable(struct vrf *vrf)
  78 {
  79         static_fixup_vrf_ids(vrf->info);
  80
  81         /*
  82          * We may have static routes that are now possible to
  83          * insert into the appropriate tables
  84          */
  85         static_config_install_delayed_routes(vrf->info);
  86
  87         return 0;
  88 }
  89
  90 static int static_vrf_disable(struct vrf *vrf)
  91 {
  92         return 0;
  93 }
  94
  95 static int static_vrf_delete(struct vrf *vrf)
  96 {
  97         struct route_table *table;
  98         struct static_vrf *svrf;
  99         safi_t safi;
 100         afi_t afi;
 101
 102         svrf = vrf->info;
 103         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 104                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
 105                         table = svrf->stable[afi][safi];
 106                         route_table_finish(table);
 107                         svrf->stable[afi][safi] = NULL;
 108                 }
 109         }
 110         return 0;
 111 }
 112
 113 /* Lookup the static routing table in a VRF. */
 114 struct route_table *static_vrf_static_table(afi_t afi, safi_t safi,
 115                                             struct static_vrf *svrf)
 116 {
 117         if (!svrf)
 118                 return NULL;
 119
 120         if (afi >= AFI_MAX || safi >= SAFI_MAX)
 121                 return NULL;
 122
 123         return svrf->stable[afi][safi];
 124 }
 125
 126 struct static_vrf *static_vrf_lookup_by_id(vrf_id_t vrf_id)
 127 {
 128         struct vrf *vrf;
 129
 130         vrf = vrf_lookup_by_id(vrf_id);
 131         if (vrf)
 132                 return ((struct static_vrf *)vrf->info);
 133
 134         return NULL;
 135 }
 136
 137 struct static_vrf *static_vrf_lookup_by_name(const char *name)
 138 {
 139         struct vrf *vrf;
 140
 141         if (!name)
 142                 name = VRF_DEFAULT_NAME;
 143
 144         vrf = vrf_lookup_by_name(name);
 145         if (vrf)
 146                 return ((struct static_vrf *)vrf->info);
 147
 148         return NULL;
 149 }
 150
 151 static int static_vrf_config_write(struct vty *vty)
 152 {
 153         struct vrf *vrf;
 154
 155         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 156                 if (vrf->vrf_id != VRF_DEFAULT)
 157                         vty_frame(vty, "vrf %s\n", vrf->name);
 158
 159                 static_config(vty, vrf->info, AFI_IP,
 160                               SAFI_UNICAST, "ip route");
 161                 static_config(vty, vrf->info, AFI_IP,
 162                               SAFI_MULTICAST, "ip mroute");
 163                 static_config(vty, vrf->info, AFI_IP6,
 164                               SAFI_UNICAST, "ipv6 route");
 165
 166                 if (vrf->vrf_id != VRF_DEFAULT)
 167                         vty_endframe(vty, " exit-vrf\n!\n");
 168         }
 169
 170         return 0;
 171 }
 172
 173 int static_vrf_has_config(struct static_vrf *svrf)
 174 {
 175         struct route_table *table;
 176         safi_t safi;
 177         afi_t afi;
 178
 179         /*
 180          * NOTE: This is a don't care for the default VRF, but we go through
 181          * the motions to keep things consistent.
 182          */
 183         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 184                 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
 185                         table = svrf->stable[afi][safi];
 186                         if (!table)
 187                                 continue;
 188                         if (route_table_count(table))
 189                                 return 1;
 190                 }
 191         }
 192
 193         return 0;
 194 }
 195
 196 void static_vrf_init(void)
 197 {
 198         vrf_init(static_vrf_new, static_vrf_enable,
 199                  static_vrf_disable, static_vrf_delete, NULL);
 200
 201         vrf_cmd_init(static_vrf_config_write, &static_privs);
 202 }