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 "ioctl.h"
  33 #include "connected.h"
  34 #include "network.h"
  35 #include "log.h"
  36 #include "table.h"
  37 #include "rib.h"
  38 #include "vrf.h"
  39
  40 #include "zebra/zebra_router.h"
  41 #include "zebra/zapi_msg.h"
  42 #include "zebra/zebra_vrf.h"
  43 #include "zebra/router-id.h"
  44 #include "zebra/redistribute.h"
  45
  46 static struct connected *router_id_find_node(struct list *l,
  47                                              struct connected *ifc)
  48 {
  49         struct listnode *node;
  50         struct connected *c;
  51
  52         for (ALL_LIST_ELEMENTS_RO(l, node, c))
  53                 if (prefix_same(ifc->address, c->address))
  54                         return c;
  55
  56         return NULL;
  57 }
  58
  59 static int router_id_bad_address(struct connected *ifc)
  60 {
  61         /* non-redistributable addresses shouldn't be used for RIDs either */
  62         if (!zebra_check_addr(ifc->address))
  63                 return 1;
  64
  65         return 0;
  66 }
  67
  68 static bool router_id_v6_is_any(struct prefix *p)
  69 {
  70         return memcmp(&p->u.prefix6, &in6addr_any, sizeof(struct in6_addr))
  71                == 0;
  72 }
  73
  74 int router_id_get(afi_t afi, struct prefix *p, struct zebra_vrf *zvrf)
  75 {
  76         struct listnode *node;
  77         struct connected *c;
  78         struct in6_addr *addr = NULL;
  79
  80         switch (afi) {
  81         case AFI_IP:
  82                 p->u.prefix4.s_addr = INADDR_ANY;
  83                 p->family = AF_INET;
  84                 p->prefixlen = IPV4_MAX_BITLEN;
  85                 if (zvrf->rid_user_assigned.u.prefix4.s_addr != INADDR_ANY)
  86                         p->u.prefix4.s_addr =
  87                                 zvrf->rid_user_assigned.u.prefix4.s_addr;
  88                 else if (!list_isempty(zvrf->rid_lo_sorted_list)) {
  89                         node = listtail(zvrf->rid_lo_sorted_list);
  90                         c = listgetdata(node);
  91                         p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
  92                 } else if (!list_isempty(zvrf->rid_all_sorted_list)) {
  93                         node = listtail(zvrf->rid_all_sorted_list);
  94                         c = listgetdata(node);
  95                         p->u.prefix4.s_addr = c->address->u.prefix4.s_addr;
  96                 }
  97                 return 0;
  98         case AFI_IP6:
  99                 p->u.prefix6 = in6addr_any;
 100                 p->family = AF_INET6;
 101                 p->prefixlen = IPV6_MAX_BITLEN;
 102                 if (!router_id_v6_is_any(&zvrf->rid6_user_assigned))
 103                         addr = &zvrf->rid6_user_assigned.u.prefix6;
 104                 else if (!list_isempty(zvrf->rid6_lo_sorted_list)) {
 105                         node = listtail(zvrf->rid6_lo_sorted_list);
 106                         c = listgetdata(node);
 107                         addr = &c->address->u.prefix6;
 108                 } else if (!list_isempty(zvrf->rid6_all_sorted_list)) {
 109                         node = listtail(zvrf->rid6_all_sorted_list);
 110                         c = listgetdata(node);
 111                         addr = &c->address->u.prefix6;
 112                 }
 113                 if (addr)
 114                         memcpy(&p->u.prefix6, addr, sizeof(struct in6_addr));
 115                 return 0;
 116         default:
 117                 return -1;
 118         }
 119 }
 120
 121 static int router_id_set(afi_t afi, struct prefix *p, struct zebra_vrf *zvrf)
 122 {
 123         struct prefix after, before;
 124         struct listnode *node;
 125         struct zserv *client;
 126
 127         router_id_get(afi, &before, zvrf);
 128
 129         switch (afi) {
 130         case AFI_IP:
 131                 zvrf->rid_user_assigned.u.prefix4.s_addr = p->u.prefix4.s_addr;
 132                 break;
 133         case AFI_IP6:
 134                 zvrf->rid6_user_assigned.u.prefix6 = p->u.prefix6;
 135                 break;
 136         default:
 137                 return -1;
 138         }
 139
 140         router_id_get(afi, &after, zvrf);
 141
 142         /*
 143          * If we've been told that the router-id is exactly the same
 144          * do we need to really do anything here?
 145          */
 146         if (prefix_same(&before, &after))
 147                 return 0;
 148
 149         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 150                 zsend_router_id_update(client, afi, &after, zvrf->vrf->vrf_id);
 151
 152         return 0;
 153 }
 154
 155 void router_id_add_address(struct connected *ifc)
 156 {
 157         struct list *l = NULL;
 158         struct listnode *node;
 159         struct prefix before;
 160         struct prefix after;
 161         struct zserv *client;
 162         struct zebra_vrf *zvrf = vrf_info_get(ifc->ifp->vrf_id);
 163         afi_t afi;
 164         struct list *rid_lo;
 165         struct list *rid_all;
 166
 167         if (router_id_bad_address(ifc))
 168                 return;
 169
 170         switch (ifc->address->family) {
 171         case AF_INET:
 172                 afi = AFI_IP;
 173                 rid_lo = zvrf->rid_lo_sorted_list;
 174                 rid_all = zvrf->rid_all_sorted_list;
 175                 break;
 176         case AF_INET6:
 177                 afi = AFI_IP6;
 178                 rid_lo = zvrf->rid6_lo_sorted_list;
 179                 rid_all = zvrf->rid6_all_sorted_list;
 180                 break;
 181         default:
 182                 return;
 183         }
 184
 185         router_id_get(afi, &before, zvrf);
 186
 187         l = if_is_loopback(ifc->ifp) ? rid_lo : rid_all;
 188
 189         if (!router_id_find_node(l, ifc))
 190                 listnode_add_sort(l, ifc);
 191
 192         router_id_get(afi, &after, zvrf);
 193
 194         if (prefix_same(&before, &after))
 195                 return;
 196
 197         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 198                 zsend_router_id_update(client, afi, &after, zvrf_id(zvrf));
 199 }
 200
 201 void router_id_del_address(struct connected *ifc)
 202 {
 203         struct connected *c;
 204         struct list *l;
 205         struct prefix after;
 206         struct prefix before;
 207         struct listnode *node;
 208         struct zserv *client;
 209         struct zebra_vrf *zvrf = vrf_info_get(ifc->ifp->vrf_id);
 210         afi_t afi;
 211         struct list *rid_lo;
 212         struct list *rid_all;
 213
 214         if (router_id_bad_address(ifc))
 215                 return;
 216
 217         switch (ifc->address->family) {
 218         case AF_INET:
 219                 afi = AFI_IP;
 220                 rid_lo = zvrf->rid_lo_sorted_list;
 221                 rid_all = zvrf->rid_all_sorted_list;
 222                 break;
 223         case AF_INET6:
 224                 afi = AFI_IP6;
 225                 rid_lo = zvrf->rid6_lo_sorted_list;
 226                 rid_all = zvrf->rid6_all_sorted_list;
 227                 break;
 228         default:
 229                 return;
 230         }
 231
 232         router_id_get(afi, &before, zvrf);
 233
 234         if (if_is_loopback(ifc->ifp))
 235                 l = rid_lo;
 236         else
 237                 l = rid_all;
 238
 239         if ((c = router_id_find_node(l, ifc)))
 240                 listnode_delete(l, c);
 241
 242         router_id_get(afi, &after, zvrf);
 243
 244         if (prefix_same(&before, &after))
 245                 return;
 246
 247         for (ALL_LIST_ELEMENTS_RO(zrouter.client_list, node, client))
 248                 zsend_router_id_update(client, afi, &after, zvrf_id(zvrf));
 249 }
 250
 251 void router_id_write(struct vty *vty, struct zebra_vrf *zvrf)
 252 {
 253         char space[2];
 254
 255         memset(space, 0, sizeof(space));
 256
 257         if (zvrf_id(zvrf) != VRF_DEFAULT)
 258                 snprintf(space, sizeof(space), "%s", " ");
 259
 260         if (zvrf->rid_user_assigned.u.prefix4.s_addr != INADDR_ANY) {
 261                 vty_out(vty, "%sip router-id %pI4\n", space,
 262                         &zvrf->rid_user_assigned.u.prefix4);
 263         }
 264         if (!router_id_v6_is_any(&zvrf->rid6_user_assigned)) {
 265                 vty_out(vty, "%sipv6 router-id %pI6\n", space,
 266                         &zvrf->rid_user_assigned.u.prefix6);
 267         }
 268 }
 269
 270 DEFUN (ip_router_id,
 271        ip_router_id_cmd,
 272        "ip router-id A.B.C.D vrf NAME",
 273        IP_STR
 274        "Manually set the router-id\n"
 275        "IP address to use for router-id\n"
 276        VRF_CMD_HELP_STR)
 277 {
 278         int idx = 0;
 279         struct prefix rid;
 280         vrf_id_t vrf_id;
 281         struct zebra_vrf *zvrf;
 282
 283         argv_find(argv, argc, "A.B.C.D", &idx);
 284
 285         if (!inet_pton(AF_INET, argv[idx]->arg, &rid.u.prefix4))
 286                 return CMD_WARNING_CONFIG_FAILED;
 287
 288         rid.prefixlen = IPV4_MAX_BITLEN;
 289         rid.family = AF_INET;
 290
 291         argv_find(argv, argc, "NAME", &idx);
 292         VRF_GET_ID(vrf_id, argv[idx]->arg, false);
 293
 294         zvrf = vrf_info_lookup(vrf_id);
 295         router_id_set(AFI_IP, &rid, zvrf);
 296
 297         return CMD_SUCCESS;
 298 }
 299
 300 ALIAS (ip_router_id,
 301        router_id_cmd,
 302        "router-id A.B.C.D vrf NAME",
 303        "Manually set the router-id\n"
 304        "IP address to use for router-id\n"
 305        VRF_CMD_HELP_STR);
 306
 307 DEFUN (ipv6_router_id,
 308        ipv6_router_id_cmd,
 309        "ipv6 router-id X:X::X:X vrf NAME",
 310        IPV6_STR
 311        "Manually set the router-id\n"
 312        "IPv6 address to use for router-id\n"
 313        VRF_CMD_HELP_STR)
 314 {
 315         int idx = 0;
 316         struct prefix rid;
 317         vrf_id_t vrf_id;
 318         struct zebra_vrf *zvrf;
 319
 320         argv_find(argv, argc, "X:X::X:X", &idx);
 321
 322         if (!inet_pton(AF_INET6, argv[idx]->arg, &rid.u.prefix6))
 323                 return CMD_WARNING_CONFIG_FAILED;
 324
 325         rid.prefixlen = IPV6_MAX_BITLEN;
 326         rid.family = AF_INET6;
 327
 328         argv_find(argv, argc, "NAME", &idx);
 329         VRF_GET_ID(vrf_id, argv[idx]->arg, false);
 330
 331         zvrf = vrf_info_lookup(vrf_id);
 332         router_id_set(AFI_IP6, &rid, zvrf);
 333
 334         return CMD_SUCCESS;
 335 }
 336
 337
 338 DEFUN (ip_router_id_in_vrf,
 339        ip_router_id_in_vrf_cmd,
 340        "ip router-id A.B.C.D",
 341        IP_STR
 342        "Manually set the router-id\n"
 343        "IP address to use for router-id\n")
 344 {
 345         ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
 346         int idx = 0;
 347         struct prefix rid;
 348
 349         argv_find(argv, argc, "A.B.C.D", &idx);
 350
 351         if (!inet_pton(AF_INET, argv[idx]->arg, &rid.u.prefix4))
 352                 return CMD_WARNING_CONFIG_FAILED;
 353
 354         rid.prefixlen = IPV4_MAX_BITLEN;
 355         rid.family = AF_INET;
 356
 357         router_id_set(AFI_IP, &rid, zvrf);
 358
 359         return CMD_SUCCESS;
 360 }
 361
 362 ALIAS (ip_router_id_in_vrf,
 363        router_id_in_vrf_cmd,
 364        "router-id A.B.C.D",
 365        "Manually set the router-id\n"
 366        "IP address to use for router-id\n");
 367
 368 DEFUN (ipv6_router_id_in_vrf,
 369        ipv6_router_id_in_vrf_cmd,
 370        "ipv6 router-id X:X::X:X",
 371        IP6_STR
 372        "Manually set the IPv6 router-id\n"
 373        "IPV6 address to use for router-id\n")
 374 {
 375         ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
 376         int idx = 0;
 377         struct prefix rid;
 378
 379         argv_find(argv, argc, "X:X::X:X", &idx);
 380
 381         if (!inet_pton(AF_INET6, argv[idx]->arg, &rid.u.prefix6))
 382                 return CMD_WARNING_CONFIG_FAILED;
 383
 384         rid.prefixlen = IPV6_MAX_BITLEN;
 385         rid.family = AF_INET6;
 386
 387         router_id_set(AFI_IP6, &rid, zvrf);
 388
 389         return CMD_SUCCESS;
 390 }
 391
 392 DEFUN (no_ip_router_id,
 393        no_ip_router_id_cmd,
 394        "no ip router-id [A.B.C.D vrf NAME]",
 395        NO_STR
 396        IP_STR
 397        "Remove the manually configured router-id\n"
 398        "IP address to use for router-id\n"
 399        VRF_CMD_HELP_STR)
 400 {
 401         int idx = 0;
 402         struct prefix rid;
 403         vrf_id_t vrf_id = VRF_DEFAULT;
 404         struct zebra_vrf *zvrf;
 405
 406         rid.u.prefix4.s_addr = 0;
 407         rid.prefixlen = 0;
 408         rid.family = AF_INET;
 409
 410         if (argv_find(argv, argc, "NAME", &idx))
 411                 VRF_GET_ID(vrf_id, argv[idx]->arg, false);
 412
 413         zvrf = vrf_info_lookup(vrf_id);
 414         router_id_set(AFI_IP, &rid, zvrf);
 415
 416         return CMD_SUCCESS;
 417 }
 418
 419 ALIAS (no_ip_router_id,
 420        no_router_id_cmd,
 421        "no router-id [A.B.C.D vrf NAME]",
 422        NO_STR
 423        "Remove the manually configured router-id\n"
 424        "IP address to use for router-id\n"
 425        VRF_CMD_HELP_STR);
 426
 427 DEFUN (no_ipv6_router_id,
 428        no_ipv6_router_id_cmd,
 429        "no ipv6 router-id [X:X::X:X vrf NAME]",
 430        NO_STR
 431        IPV6_STR
 432        "Remove the manually configured IPv6 router-id\n"
 433        "IPv6 address to use for router-id\n"
 434        VRF_CMD_HELP_STR)
 435 {
 436         int idx = 0;
 437         struct prefix rid;
 438         vrf_id_t vrf_id = VRF_DEFAULT;
 439         struct zebra_vrf *zvrf;
 440
 441         memset(&rid, 0, sizeof(rid));
 442         rid.family = AF_INET;
 443
 444         if (argv_find(argv, argc, "NAME", &idx))
 445                 VRF_GET_ID(vrf_id, argv[idx]->arg, false);
 446
 447         zvrf = vrf_info_lookup(vrf_id);
 448         router_id_set(AFI_IP6, &rid, zvrf);
 449
 450         return CMD_SUCCESS;
 451 }
 452
 453 DEFUN (no_ip_router_id_in_vrf,
 454        no_ip_router_id_in_vrf_cmd,
 455        "no ip router-id [A.B.C.D]",
 456        NO_STR
 457        IP_STR
 458        "Remove the manually configured router-id\n"
 459        "IP address to use for router-id\n")
 460 {
 461         ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
 462
 463         struct prefix rid;
 464
 465         rid.u.prefix4.s_addr = 0;
 466         rid.prefixlen = 0;
 467         rid.family = AF_INET;
 468
 469         router_id_set(AFI_IP, &rid, zvrf);
 470
 471         return CMD_SUCCESS;
 472 }
 473
 474 ALIAS (no_ip_router_id_in_vrf,
 475        no_router_id_in_vrf_cmd,
 476        "no router-id [A.B.C.D]",
 477        NO_STR
 478        "Remove the manually configured router-id\n"
 479        "IP address to use for router-id\n");
 480
 481 DEFUN (no_ipv6_router_id_in_vrf,
 482        no_ipv6_router_id_in_vrf_cmd,
 483        "no ipv6 router-id [X:X::X:X]",
 484        NO_STR
 485        IP6_STR
 486        "Remove the manually configured IPv6 router-id\n"
 487        "IPv6 address to use for router-id\n")
 488 {
 489         ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
 490
 491         struct prefix rid;
 492
 493         memset(&rid, 0, sizeof(rid));
 494         rid.family = AF_INET;
 495
 496         router_id_set(AFI_IP6, &rid, zvrf);
 497
 498         return CMD_SUCCESS;
 499 }
 500
 501 DEFUN (show_ip_router_id,
 502        show_ip_router_id_cmd,
 503        "show [ip|ipv6] router-id [vrf NAME]",
 504        SHOW_STR
 505        IP_STR
 506        IPV6_STR
 507        "Show the configured router-id\n"
 508        VRF_CMD_HELP_STR)
 509 {
 510         int idx = 0;
 511         vrf_id_t vrf_id = VRF_DEFAULT;
 512         struct zebra_vrf *zvrf;
 513         const char *vrf_name = "default";
 514         char addr_name[INET6_ADDRSTRLEN];
 515         int is_ipv6 = 0;
 516
 517         is_ipv6 = argv_find(argv, argc, "ipv6", &idx);
 518
 519         if (argv_find(argv, argc, "NAME", &idx)) {
 520                 VRF_GET_ID(vrf_id, argv[idx]->arg, false);
 521                 vrf_name = argv[idx]->arg;
 522         }
 523
 524         zvrf = vrf_info_get(vrf_id);
 525
 526         if (zvrf != NULL) {
 527                 if (is_ipv6) {
 528                         if (router_id_v6_is_any(&zvrf->rid6_user_assigned))
 529                                 return CMD_SUCCESS;
 530                         inet_ntop(AF_INET6, &zvrf->rid6_user_assigned.u.prefix6,
 531                                   addr_name, sizeof(addr_name));
 532                 } else {
 533                         if (zvrf->rid_user_assigned.u.prefix4.s_addr
 534                             == INADDR_ANY)
 535                                 return CMD_SUCCESS;
 536                         inet_ntop(AF_INET, &zvrf->rid_user_assigned.u.prefix4,
 537                                   addr_name, sizeof(addr_name));
 538                 }
 539
 540                 vty_out(vty, "zebra:\n");
 541                 vty_out(vty, "     router-id %s vrf %s\n", addr_name, vrf_name);
 542         }
 543
 544         return CMD_SUCCESS;
 545 }
 546
 547 static int router_id_cmp(void *a, void *b)
 548 {
 549         const struct connected *ifa = (const struct connected *)a;
 550         const struct connected *ifb = (const struct connected *)b;
 551
 552         return IPV4_ADDR_CMP(&ifa->address->u.prefix4.s_addr,
 553                              &ifb->address->u.prefix4.s_addr);
 554 }
 555
 556 static int router_id_v6_cmp(void *a, void *b)
 557 {
 558         const struct connected *ifa = (const struct connected *)a;
 559         const struct connected *ifb = (const struct connected *)b;
 560
 561         return IPV6_ADDR_CMP(&ifa->address->u.prefix6,
 562                              &ifb->address->u.prefix6);
 563 }
 564
 565 void router_id_cmd_init(void)
 566 {
 567         install_element(CONFIG_NODE, &ip_router_id_cmd);
 568         install_element(CONFIG_NODE, &router_id_cmd);
 569         install_element(CONFIG_NODE, &ipv6_router_id_cmd);
 570         install_element(CONFIG_NODE, &no_ip_router_id_cmd);
 571         install_element(CONFIG_NODE, &no_router_id_cmd);
 572         install_element(CONFIG_NODE, &ip_router_id_in_vrf_cmd);
 573         install_element(VRF_NODE, &ip_router_id_in_vrf_cmd);
 574         install_element(CONFIG_NODE, &router_id_in_vrf_cmd);
 575         install_element(VRF_NODE, &router_id_in_vrf_cmd);
 576         install_element(CONFIG_NODE, &ipv6_router_id_in_vrf_cmd);
 577         install_element(VRF_NODE, &ipv6_router_id_in_vrf_cmd);
 578         install_element(CONFIG_NODE, &no_ipv6_router_id_cmd);
 579         install_element(CONFIG_NODE, &no_ip_router_id_in_vrf_cmd);
 580         install_element(VRF_NODE, &no_ip_router_id_in_vrf_cmd);
 581         install_element(CONFIG_NODE, &no_router_id_in_vrf_cmd);
 582         install_element(VRF_NODE, &no_router_id_in_vrf_cmd);
 583         install_element(CONFIG_NODE, &no_ipv6_router_id_in_vrf_cmd);
 584         install_element(VRF_NODE, &no_ipv6_router_id_in_vrf_cmd);
 585         install_element(VIEW_NODE, &show_ip_router_id_cmd);
 586 }
 587
 588 void router_id_init(struct zebra_vrf *zvrf)
 589 {
 590         zvrf->rid_all_sorted_list = &zvrf->_rid_all_sorted_list;
 591         zvrf->rid_lo_sorted_list = &zvrf->_rid_lo_sorted_list;
 592         zvrf->rid6_all_sorted_list = &zvrf->_rid6_all_sorted_list;
 593         zvrf->rid6_lo_sorted_list = &zvrf->_rid6_lo_sorted_list;
 594
 595         memset(zvrf->rid_all_sorted_list, 0,
 596                sizeof(zvrf->_rid_all_sorted_list));
 597         memset(zvrf->rid_lo_sorted_list, 0, sizeof(zvrf->_rid_lo_sorted_list));
 598         memset(&zvrf->rid_user_assigned, 0, sizeof(zvrf->rid_user_assigned));
 599         memset(zvrf->rid6_all_sorted_list, 0,
 600                sizeof(zvrf->_rid6_all_sorted_list));
 601         memset(zvrf->rid6_lo_sorted_list, 0,
 602                sizeof(zvrf->_rid6_lo_sorted_list));
 603         memset(&zvrf->rid6_user_assigned, 0, sizeof(zvrf->rid6_user_assigned));
 604
 605         zvrf->rid_all_sorted_list->cmp = router_id_cmp;
 606         zvrf->rid_lo_sorted_list->cmp = router_id_cmp;
 607         zvrf->rid6_all_sorted_list->cmp = router_id_v6_cmp;
 608         zvrf->rid6_lo_sorted_list->cmp = router_id_v6_cmp;
 609
 610         zvrf->rid_user_assigned.family = AF_INET;
 611         zvrf->rid_user_assigned.prefixlen = IPV4_MAX_BITLEN;
 612         zvrf->rid6_user_assigned.family = AF_INET6;
 613         zvrf->rid6_user_assigned.prefixlen = IPV6_MAX_BITLEN;
 614 }