zebra/router-id.c

   1 /*
   2  * Router ID for zebra daemon.
   3  *
   4  * Copyright (C) 2004 James R. Leu
   5  *
   6  * This file is part of Quagga routing suite.
   7  *
   8  * Quagga is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * Quagga is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "if.h"
  26 #include "vty.h"
  27 #include "sockunion.h"
  28 #include "prefix.h"
  29 #include "stream.h"
  30 #include "command.h"
  31 #include "memory.h"
  32 #include "zebra_memory.h"
  33 #include "ioctl.h"
  34 #include "connected.h"
  35 #include "network.h"
  36 #include "log.h"
  37 #include "table.h"
  38 #include "rib.h"
  39 #include "vrf.h"
  40
  41 #include "zebra/zebra_router.h"
  42 #include "zebra/zapi_msg.h"
  43 #include "zebra/zebra_vrf.h"
  44 #include "zebra/router-id.h"
  45 #include "zebra/redistribute.h"
  46
  47 static struct connected *router_id_find_node(struct list *l,
  48                                              struct connected *ifc)
  49 {
  50         struct listnode *node;
  51         struct connected *c;
  52
  53         for (ALL_LIST_ELEMENTS_RO(l, node, c))
  54                 if (prefix_same(ifc->address, c->address))
  55                         return c;
  56
  57         return NULL;
  58 }
  59
  60 static int router_id_bad_address(struct connected *ifc)
  61 {
  62         if (ifc->address->family != AF_INET)
  63                 return 1;
  64
  65         /* non-redistributable addresses shouldn't be used for RIDs either */
  66         if (!zebra_check_addr(ifc->address))
  67                 return 1;
  68
  69         return 0;
  70 }
  71
  72 void router_id_get(struct prefix *p, vrf_id_t vrf_id)
  73 {
  74         struct listnode *node;
  75         struct connected *c;
  76         struct zebra_vrf *zvrf = vrf_info_get(vrf_id);
  77
  78         p->u.prefix4.s_addr = INADDR_ANY;
  79         p->family = AF_INET;
  80         p->prefixlen = 32;
  81
  82         if (zvrf->rid_user_assigned.u.prefix4.s_addr != INADDR_ANY)
  83                 p->u.prefix4.s_addr = zvrf->rid_user_assigned.u.prefix4.s_addr;
  84         else if (!list_isempty(zvrf->rid_lo_sorted_list)) {
  85                 node = listtail(zvrf->rid_lo_sorted_list);
  86                 c = listgetdata(node);
  87                 p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
  88         } else if (!list_isempty(zvrf->rid_all_sorted_list)) {
  89                 node = listtail(zvrf->rid_all_sorted_list);
  90                 c = listgetdata(node);
  91                 p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
  92         }
  93 }
  94
  95 static void router_id_set(struct prefix *p, vrf_id_t vrf_id)
  96 {
  97         struct prefix p2;
  98         struct listnode *node;
  99         struct zserv *client;
 100         struct zebra_vrf *zvrf;
 101
 102         if (p->u.prefix4.s_addr == 0) /* unset */
 103         {
 104                 zvrf = vrf_info_lookup(vrf_id);
 105                 if (!zvrf)
 106                         return;
 107         } else /* set */
 108                 zvrf = vrf_info_get(vrf_id);
 109
 110         zvrf->rid_user_assigned.u.prefix4.s_addr = p->u.prefix4.s_addr;
 111
 112         router_id_get(&p2, vrf_id);
 113
 114         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 115                 zsend_router_id_update(client, &p2, vrf_id);
 116 }
 117
 118 void router_id_add_address(struct connected *ifc)
 119 {
 120         struct list *l = NULL;
 121         struct listnode *node;
 122         struct prefix before;
 123         struct prefix after;
 124         struct zserv *client;
 125         struct zebra_vrf *zvrf = vrf_info_get(ifc->ifp->vrf_id);
 126
 127         if (router_id_bad_address(ifc))
 128                 return;
 129
 130         router_id_get(&before, zvrf_id(zvrf));
 131
 132         if (if_is_loopback(ifc->ifp))
 133                 l = zvrf->rid_lo_sorted_list;
 134         else
 135                 l = zvrf->rid_all_sorted_list;
 136
 137         if (!router_id_find_node(l, ifc))
 138                 listnode_add_sort(l, ifc);
 139
 140         router_id_get(&after, zvrf_id(zvrf));
 141
 142         if (prefix_same(&before, &after))
 143                 return;
 144
 145         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 146                 zsend_router_id_update(client, &after, zvrf_id(zvrf));
 147 }
 148
 149 void router_id_del_address(struct connected *ifc)
 150 {
 151         struct connected *c;
 152         struct list *l;
 153         struct prefix after;
 154         struct prefix before;
 155         struct listnode *node;
 156         struct zserv *client;
 157         struct zebra_vrf *zvrf = vrf_info_get(ifc->ifp->vrf_id);
 158
 159         if (router_id_bad_address(ifc))
 160                 return;
 161
 162         router_id_get(&before, zvrf_id(zvrf));
 163
 164         if (if_is_loopback(ifc->ifp))
 165                 l = zvrf->rid_lo_sorted_list;
 166         else
 167                 l = zvrf->rid_all_sorted_list;
 168
 169         if ((c = router_id_find_node(l, ifc)))
 170                 listnode_delete(l, c);
 171
 172         router_id_get(&after, zvrf_id(zvrf));
 173
 174         if (prefix_same(&before, &after))
 175                 return;
 176
 177         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 178                 zsend_router_id_update(client, &after, zvrf_id(zvrf));
 179 }
 180
 181 void router_id_write(struct vty *vty)
 182 {
 183         struct vrf *vrf;
 184         struct zebra_vrf *zvrf;
 185
 186         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
 187                 if ((zvrf = vrf->info) != NULL)
 188                         if (zvrf->rid_user_assigned.u.prefix4.s_addr
 189                             != INADDR_ANY) {
 190                                 if (zvrf_id(zvrf) == VRF_DEFAULT)
 191                                         vty_out(vty, "router-id %s\n",
 192                                                 inet_ntoa(
 193                                                         zvrf->rid_user_assigned
 194                                                                 .u.prefix4));
 195                                 else
 196                                         vty_out(vty, "router-id %s vrf %s\n",
 197                                                 inet_ntoa(
 198                                                         zvrf->rid_user_assigned
 199                                                                 .u.prefix4),
 200                                                 zvrf_name(zvrf));
 201                         }
 202 }
 203
 204 DEFUN (router_id,
 205        router_id_cmd,
 206        "router-id A.B.C.D [vrf NAME]",
 207        "Manually set the router-id\n"
 208        "IP address to use for router-id\n"
 209        VRF_CMD_HELP_STR)
 210 {
 211         int idx_ipv4 = 1;
 212         int idx_name = 3;
 213
 214         struct prefix rid;
 215         vrf_id_t vrf_id = VRF_DEFAULT;
 216
 217         rid.u.prefix4.s_addr = inet_addr(argv[idx_ipv4]->arg);
 218         if (!rid.u.prefix4.s_addr)
 219                 return CMD_WARNING_CONFIG_FAILED;
 220
 221         rid.prefixlen = 32;
 222         rid.family = AF_INET;
 223
 224         if (argc > 2)
 225                 VRF_GET_ID(vrf_id, argv[idx_name]->arg, false);
 226
 227         router_id_set(&rid, vrf_id);
 228
 229         return CMD_SUCCESS;
 230 }
 231
 232 DEFUN (no_router_id,
 233        no_router_id_cmd,
 234        "no router-id [A.B.C.D [vrf NAME]]",
 235        NO_STR
 236        "Remove the manually configured router-id\n"
 237        "IP address to use for router-id\n"
 238        VRF_CMD_HELP_STR)
 239 {
 240         int idx_name = 4;
 241
 242         struct prefix rid;
 243         vrf_id_t vrf_id = VRF_DEFAULT;
 244
 245         rid.u.prefix4.s_addr = 0;
 246         rid.prefixlen = 0;
 247         rid.family = AF_INET;
 248
 249         if (argc > 3)
 250                 VRF_GET_ID(vrf_id, argv[idx_name]->arg, false);
 251
 252         router_id_set(&rid, vrf_id);
 253
 254         return CMD_SUCCESS;
 255 }
 256
 257 DEFUN (show_router_id,
 258        show_router_id_cmd,
 259        "show router-id [vrf NAME]",
 260        SHOW_STR
 261        "Show the configured router-id\n"
 262        VRF_CMD_HELP_STR)
 263 {
 264         int idx_name = 3;
 265
 266         vrf_id_t vrf_id = VRF_DEFAULT;
 267         struct zebra_vrf *zvrf;
 268
 269         if (argc > 2)
 270                 VRF_GET_ID(vrf_id, argv[idx_name]->arg, false);
 271
 272         zvrf = vrf_info_get(vrf_id);
 273
 274         if ((zvrf != NULL) && (zvrf->rid_user_assigned.u.prefix4.s_addr)) {
 275                 vty_out(vty, "zebra:\n");
 276                 if (vrf_id == VRF_DEFAULT)
 277                         vty_out(vty, "     router-id %s vrf default\n",
 278                                 inet_ntoa(zvrf->rid_user_assigned.u.prefix4));
 279                 else
 280                         vty_out(vty, "     router-id %s vrf %s\n",
 281                                 inet_ntoa(zvrf->rid_user_assigned.u.prefix4),
 282                                 argv[idx_name]->arg);
 283         }
 284
 285         return CMD_SUCCESS;
 286 }
 287
 288 static int router_id_cmp(void *a, void *b)
 289 {
 290         const struct connected *ifa = (const struct connected *)a;
 291         const struct connected *ifb = (const struct connected *)b;
 292
 293         return IPV4_ADDR_CMP(&ifa->address->u.prefix4.s_addr,
 294                              &ifb->address->u.prefix4.s_addr);
 295 }
 296
 297 void router_id_cmd_init(void)
 298 {
 299         install_element(CONFIG_NODE, &router_id_cmd);
 300         install_element(CONFIG_NODE, &no_router_id_cmd);
 301         install_element(VIEW_NODE, &show_router_id_cmd);
 302 }
 303
 304 void router_id_init(struct zebra_vrf *zvrf)
 305 {
 306         zvrf->rid_all_sorted_list = &zvrf->_rid_all_sorted_list;
 307         zvrf->rid_lo_sorted_list = &zvrf->_rid_lo_sorted_list;
 308
 309         memset(zvrf->rid_all_sorted_list, 0,
 310                sizeof(zvrf->_rid_all_sorted_list));
 311         memset(zvrf->rid_lo_sorted_list, 0, sizeof(zvrf->_rid_lo_sorted_list));
 312         memset(&zvrf->rid_user_assigned, 0, sizeof(zvrf->rid_user_assigned));
 313
 314         zvrf->rid_all_sorted_list->cmp = router_id_cmp;
 315         zvrf->rid_lo_sorted_list->cmp = router_id_cmp;
 316
 317         zvrf->rid_user_assigned.family = AF_INET;
 318         zvrf->rid_user_assigned.prefixlen = 32;
 319 }