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 #include "northbound_cli.h"
  27
  28 #include "static_vrf.h"
  29 #include "static_routes.h"
  30 #include "static_zebra.h"
  31
  32 DEFINE_MTYPE_STATIC(STATIC, STATIC_RTABLE_INFO, "Static Route Table Info");
  33
  34 static struct static_vrf *static_vrf_alloc(void)
  35 {
  36         struct route_table *table;
  37         struct static_vrf *svrf;
  38         struct stable_info *info;
  39         safi_t safi;
  40         afi_t afi;
  41
  42         svrf = XCALLOC(MTYPE_STATIC_RTABLE_INFO, sizeof(struct static_vrf));
  43
  44         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
  45                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
  46                         if (afi == AFI_IP6)
  47                                 table = srcdest_table_init();
  48                         else
  49                                 table = route_table_init();
  50
  51                         info = XCALLOC(MTYPE_STATIC_RTABLE_INFO,
  52                                        sizeof(struct stable_info));
  53                         info->svrf = svrf;
  54                         info->afi = afi;
  55                         info->safi = safi;
  56                         route_table_set_info(table, info);
  57
  58                         table->cleanup = zebra_stable_node_cleanup;
  59                         svrf->stable[afi][safi] = table;
  60                 }
  61         }
  62         return svrf;
  63 }
  64
  65 static int static_vrf_new(struct vrf *vrf)
  66 {
  67         struct static_vrf *svrf;
  68
  69         svrf = static_vrf_alloc();
  70         vrf->info = svrf;
  71         svrf->vrf = vrf;
  72
  73         return 0;
  74 }
  75
  76 static int static_vrf_enable(struct vrf *vrf)
  77 {
  78         static_zebra_vrf_register(vrf);
  79
  80         static_fixup_vrf_ids(vrf->info);
  81
  82         return 0;
  83 }
  84
  85 static int static_vrf_disable(struct vrf *vrf)
  86 {
  87         static_zebra_vrf_unregister(vrf);
  88         return 0;
  89 }
  90
  91 static int static_vrf_delete(struct vrf *vrf)
  92 {
  93         struct route_table *table;
  94         struct static_vrf *svrf;
  95         safi_t safi;
  96         afi_t afi;
  97         void *info;
  98
  99         svrf = vrf->info;
 100         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 101                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
 102                         table = svrf->stable[afi][safi];
 103                         info = route_table_get_info(table);
 104                         route_table_finish(table);
 105                         XFREE(MTYPE_STATIC_RTABLE_INFO, info);
 106                         svrf->stable[afi][safi] = NULL;
 107                 }
 108         }
 109         XFREE(MTYPE_STATIC_RTABLE_INFO, svrf);
 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_name(const char *name)
 127 {
 128         struct vrf *vrf;
 129
 130         if (!name)
 131                 name = VRF_DEFAULT_NAME;
 132
 133         vrf = vrf_lookup_by_name(name);
 134         if (vrf)
 135                 return ((struct static_vrf *)vrf->info);
 136
 137         return NULL;
 138 }
 139
 140 static int static_vrf_config_write(struct vty *vty)
 141 {
 142         struct lyd_node *dnode;
 143         int written = 0;
 144
 145         dnode = yang_dnode_get(running_config->dnode, "/frr-routing:routing");
 146         if (dnode) {
 147                 nb_cli_show_dnode_cmds(vty, dnode, false);
 148                 written = 1;
 149         }
 150
 151         return written;
 152 }
 153
 154 void static_vrf_init(void)
 155 {
 156         vrf_init(static_vrf_new, static_vrf_enable, static_vrf_disable,
 157                  static_vrf_delete);
 158
 159         vrf_cmd_init(static_vrf_config_write);
 160 }
 161
 162 void static_vrf_terminate(void)
 163 {
 164         vrf_terminate();
 165 }