pimd/pim_instance.c

   1 /*
   2  * PIM for FRR - PIM Instance
   3  * Copyright (C) 2017 Cumulus Networks, Inc.
   4  * Donald Sharp
   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, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * 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; see the file COPYING; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  19  * MA 02110-1301 USA
  20  */
  21 #include <zebra.h>
  22
  23 #include "hash.h"
  24 #include "vrf.h"
  25
  26 #include "pimd.h"
  27 #include "pim_ssm.h"
  28 #include "pim_rpf.h"
  29 #include "pim_rp.h"
  30 #include "pim_mroute.h"
  31 #include "pim_oil.h"
  32 #include "pim_static.h"
  33 #include "pim_ssmpingd.h"
  34 #include "pim_vty.h"
  35
  36 static void pim_instance_terminate(struct pim_instance *pim)
  37 {
  38         /* Traverse and cleanup rpf_hash */
  39         if (pim->rpf_hash) {
  40                 hash_clean(pim->rpf_hash, (void *)pim_rp_list_hash_clean);
  41                 hash_free(pim->rpf_hash);
  42                 pim->rpf_hash = NULL;
  43         }
  44
  45         if (pim->ssm_info) {
  46                 pim_ssm_terminate(pim->ssm_info);
  47                 pim->ssm_info = NULL;
  48         }
  49
  50         if (pim->static_routes)
  51                 list_delete_and_null(&pim->static_routes);
  52
  53         pim_rp_free(pim);
  54
  55         pim_upstream_terminate(pim);
  56
  57         pim_oil_terminate(pim);
  58
  59         pim_if_terminate(pim);
  60
  61         pim_msdp_exit(pim);
  62
  63         XFREE(MTYPE_PIM_PIM_INSTANCE, pim);
  64 }
  65
  66 static struct pim_instance *pim_instance_init(struct vrf *vrf)
  67 {
  68         struct pim_instance *pim;
  69         char hash_name[64];
  70
  71         pim = XCALLOC(MTYPE_PIM_PIM_INSTANCE, sizeof(struct pim_instance));
  72         if (!pim)
  73                 return NULL;
  74
  75         pim_if_init(pim);
  76
  77         pim->keep_alive_time = PIM_KEEPALIVE_PERIOD;
  78         pim->rp_keep_alive_time = PIM_RP_KEEPALIVE_PERIOD;
  79
  80
  81         pim->vrf_id = vrf->vrf_id;
  82         pim->vrf = vrf;
  83
  84         pim->spt.switchover = PIM_SPT_IMMEDIATE;
  85         pim->spt.plist = NULL;
  86
  87         pim_msdp_init(pim, master);
  88
  89         snprintf(hash_name, 64, "PIM %s RPF Hash", vrf->name);
  90         pim->rpf_hash = hash_create_size(256, pim_rpf_hash_key, pim_rpf_equal,
  91                                          hash_name);
  92
  93         if (PIM_DEBUG_ZEBRA)
  94                 zlog_debug("%s: NHT rpf hash init ", __PRETTY_FUNCTION__);
  95
  96         pim->ssm_info = pim_ssm_init();
  97         if (!pim->ssm_info) {
  98                 pim_instance_terminate(pim);
  99                 return NULL;
 100         }
 101
 102         pim->static_routes = list_new();
 103         if (!pim->static_routes) {
 104                 zlog_err("%s %s: failure: static_routes=list_new()", __FILE__,
 105                          __PRETTY_FUNCTION__);
 106                 pim_instance_terminate(pim);
 107                 return NULL;
 108         }
 109         pim->static_routes->del = (void (*)(void *))pim_static_route_free;
 110
 111         pim->send_v6_secondary = 1;
 112
 113         if (vrf->vrf_id == VRF_DEFAULT)
 114                 pimg = pim;
 115
 116         pim_rp_init(pim);
 117
 118         pim_oil_init(pim);
 119
 120         pim_upstream_init(pim);
 121
 122         pim->last_route_change_time = -1;
 123         return pim;
 124 }
 125
 126 struct pim_instance *pim_get_pim_instance(vrf_id_t vrf_id)
 127 {
 128         struct vrf *vrf = vrf_lookup_by_id(vrf_id);
 129
 130         if (vrf)
 131                 return vrf->info;
 132
 133         return NULL;
 134 }
 135
 136 static int pim_vrf_new(struct vrf *vrf)
 137 {
 138         struct pim_instance *pim = pim_instance_init(vrf);
 139
 140         zlog_debug("VRF Created: %s(%u)", vrf->name, vrf->vrf_id);
 141         if (pim == NULL) {
 142                 zlog_err("%s %s: pim class init failure ", __FILE__,
 143                          __PRETTY_FUNCTION__);
 144                 /*
 145                  * We will crash and burn otherwise
 146                  */
 147                 exit(1);
 148         }
 149
 150         vrf->info = (void *)pim;
 151
 152         if (vrf->vrf_id == VRF_DEFAULT)
 153                 pimg = pim;
 154
 155         pim_ssmpingd_init(pim);
 156         return 0;
 157 }
 158
 159 static int pim_vrf_delete(struct vrf *vrf)
 160 {
 161         struct pim_instance *pim = vrf->info;
 162
 163         zlog_debug("VRF Deletion: %s(%u)", vrf->name, vrf->vrf_id);
 164
 165         pim_ssmpingd_destroy(pim);
 166         pim_instance_terminate(pim);
 167         return 0;
 168 }
 169
 170 /*
 171  * Code to turn on the pim instance that
 172  * we have created with new
 173  */
 174 static int pim_vrf_enable(struct vrf *vrf)
 175 {
 176         struct pim_instance *pim = (struct pim_instance *)vrf->info;
 177
 178         zlog_debug("%s: for %s", __PRETTY_FUNCTION__, vrf->name);
 179
 180         pim_mroute_socket_enable(pim);
 181
 182         return 0;
 183 }
 184
 185 static int pim_vrf_disable(struct vrf *vrf)
 186 {
 187         /* Note: This is a callback, the VRF will be deleted by the caller. */
 188         return 0;
 189 }
 190
 191 static int pim_vrf_config_write(struct vty *vty)
 192 {
 193         struct vrf *vrf;
 194         struct pim_instance *pim;
 195
 196         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 197                 pim = vrf->info;
 198
 199                 if (!pim)
 200                         continue;
 201
 202                 if (vrf->vrf_id != VRF_DEFAULT)
 203                         vty_frame(vty, "vrf %s\n", vrf->name);
 204
 205                 pim_global_config_write_worker(pim, vty);
 206
 207                 if (vrf->vrf_id != VRF_DEFAULT)
 208                         vty_endframe(vty, "!\n");
 209         }
 210
 211         return 0;
 212 }
 213
 214 void pim_vrf_init(void)
 215 {
 216         vrf_init(pim_vrf_new, pim_vrf_enable, pim_vrf_disable, pim_vrf_delete);
 217
 218         vrf_cmd_init(pim_vrf_config_write, &pimd_privs);
 219 }
 220
 221 void pim_vrf_terminate(void)
 222 {
 223         vrf_terminate();
 224 }