zebra/irdp_interface.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  * Copyright (C) 1997, 2000
   5  * Portions:
   6  *   Swedish University of Agricultural Sciences
   7  *   Robert Olsson
   8  *   Kunihiro Ishiguro
   9  *
  10  * Thanks to Jens Laas at Swedish University of Agricultural Sciences
  11  * for reviewing and tests.
  12  */
  13
  14 #include <zebra.h>
  15
  16 #include "if.h"
  17 #include "vty.h"
  18 #include "sockunion.h"
  19 #include "prefix.h"
  20 #include "command.h"
  21 #include "memory.h"
  22 #include "stream.h"
  23 #include "ioctl.h"
  24 #include "connected.h"
  25 #include "log.h"
  26 #include "zclient.h"
  27 #include "frrevent.h"
  28 #include "lib_errors.h"
  29 #include "zebra/interface.h"
  30 #include "zebra/rtadv.h"
  31 #include "zebra/rib.h"
  32 #include "zebra/zebra_router.h"
  33 #include "zebra/redistribute.h"
  34 #include "zebra/irdp.h"
  35 #include "zebra/zebra_errors.h"
  36 #include <netinet/ip_icmp.h>
  37 #include "if.h"
  38 #include "sockunion.h"
  39 #include "log.h"
  40 #include "network.h"
  41
  42 extern int irdp_sock;
  43
  44 DEFINE_MTYPE_STATIC(ZEBRA, IRDP_IF, "IRDP interface data");
  45
  46 #define IRDP_CONFIGED                                                                 \
  47         do {                                                                          \
  48                 if (!irdp) {                                                          \
  49                         vty_out(vty,                                                  \
  50                                 "Please Configure IRDP before using this command\n"); \
  51                         return CMD_WARNING_CONFIG_FAILED;                             \
  52                 }                                                                     \
  53         } while (0)
  54
  55 static struct irdp_interface *irdp_if_get(struct interface *ifp)
  56 {
  57         struct zebra_if *zi = ifp->info;
  58
  59         if (!zi)
  60                 return NULL;
  61
  62         if (!zi->irdp)
  63                 zi->irdp = XCALLOC(MTYPE_IRDP_IF, sizeof(*zi->irdp));
  64
  65         if (!zi->irdp->started)
  66                 return NULL;
  67
  68         return zi->irdp;
  69 }
  70
  71 static int irdp_if_delete(struct interface *ifp)
  72 {
  73         struct zebra_if *zi = ifp->info;
  74         if (!zi)
  75                 return 0;
  76         XFREE(MTYPE_IRDP_IF, zi->irdp);
  77         return 0;
  78 }
  79
  80 static const char *inet_2a(uint32_t a, char *b, size_t b_len)
  81 {
  82         snprintf(b, b_len, "%u.%u.%u.%u", (a)&0xFF, (a >> 8) & 0xFF,
  83                  (a >> 16) & 0xFF, (a >> 24) & 0xFF);
  84         return b;
  85 }
  86
  87
  88 static struct prefix *irdp_get_prefix(struct interface *ifp)
  89 {
  90         struct listnode *node;
  91         struct connected *ifc;
  92
  93         if (ifp->connected)
  94                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc))
  95                         return ifc->address;
  96
  97         return NULL;
  98 }
  99
 100 /* Join to the add/leave multicast group. */
 101 static int if_group(struct interface *ifp, int sock, uint32_t group,
 102                     int add_leave)
 103 {
 104         struct ip_mreq m;
 105         struct prefix *p;
 106         int ret;
 107         char b1[INET_ADDRSTRLEN];
 108
 109         memset(&m, 0, sizeof(m));
 110         m.imr_multiaddr.s_addr = htonl(group);
 111         p = irdp_get_prefix(ifp);
 112
 113         if (!p) {
 114                 flog_warn(EC_ZEBRA_NO_IFACE_ADDR,
 115                           "IRDP: can't get address for %s", ifp->name);
 116                 return 1;
 117         }
 118
 119         m.imr_interface = p->u.prefix4;
 120
 121         ret = setsockopt(sock, IPPROTO_IP, add_leave, (char *)&m,
 122                          sizeof(struct ip_mreq));
 123         if (ret < 0)
 124                 flog_err_sys(EC_LIB_SOCKET, "IRDP: %s can't setsockopt %s: %s",
 125                              add_leave == IP_ADD_MEMBERSHIP ? "join group"
 126                                                             : "leave group",
 127                              inet_2a(group, b1, sizeof(b1)),
 128                              safe_strerror(errno));
 129
 130         return ret;
 131 }
 132
 133 static int if_add_group(struct interface *ifp)
 134 {
 135         struct zebra_if *zi = ifp->info;
 136         struct irdp_interface *irdp = zi->irdp;
 137         int ret;
 138         char b1[INET_ADDRSTRLEN];
 139
 140         if (!irdp)
 141                 return -1;
 142
 143         ret = if_group(ifp, irdp_sock, INADDR_ALLRTRS_GROUP, IP_ADD_MEMBERSHIP);
 144         if (ret < 0) {
 145                 return ret;
 146         }
 147
 148         if (irdp->flags & IF_DEBUG_MISC)
 149                 zlog_debug("IRDP: Adding group %s for %s",
 150                            inet_2a(htonl(INADDR_ALLRTRS_GROUP), b1, sizeof(b1)),
 151                            ifp->name);
 152         return 0;
 153 }
 154
 155 static int if_drop_group(struct interface *ifp)
 156 {
 157         struct zebra_if *zi = ifp->info;
 158         struct irdp_interface *irdp = zi->irdp;
 159         int ret;
 160         char b1[INET_ADDRSTRLEN];
 161
 162         if (!irdp)
 163                 return -1;
 164
 165         ret = if_group(ifp, irdp_sock, INADDR_ALLRTRS_GROUP,
 166                        IP_DROP_MEMBERSHIP);
 167         if (ret < 0)
 168                 return ret;
 169
 170         if (irdp->flags & IF_DEBUG_MISC)
 171                 zlog_debug("IRDP: Leaving group %s for %s",
 172                            inet_2a(htonl(INADDR_ALLRTRS_GROUP), b1, sizeof(b1)),
 173                            ifp->name);
 174         return 0;
 175 }
 176
 177 static void if_set_defaults(struct irdp_interface *irdp)
 178 {
 179         irdp->MaxAdvertInterval = IRDP_MAXADVERTINTERVAL;
 180         irdp->MinAdvertInterval = IRDP_MINADVERTINTERVAL;
 181         irdp->Preference = IRDP_PREFERENCE;
 182         irdp->Lifetime = IRDP_LIFETIME;
 183 }
 184
 185
 186 static struct Adv *Adv_new(void)
 187 {
 188         return XCALLOC(MTYPE_IRDP_IF, sizeof(struct Adv));
 189 }
 190
 191 static void Adv_free(struct Adv *adv)
 192 {
 193         XFREE(MTYPE_IRDP_IF, adv);
 194 }
 195
 196 static void irdp_if_start(struct interface *ifp, int multicast,
 197                           int set_defaults)
 198 {
 199         struct zebra_if *zi = ifp->info;
 200         struct irdp_interface *irdp = zi->irdp;
 201         struct listnode *node;
 202         struct connected *ifc;
 203         uint32_t timer, seed;
 204
 205         assert(irdp);
 206
 207         irdp->started = true;
 208         if (irdp->flags & IF_ACTIVE) {
 209                 zlog_debug("IRDP: Interface is already active %s", ifp->name);
 210                 return;
 211         }
 212         if ((irdp_sock < 0) && ((irdp_sock = irdp_sock_init()) < 0)) {
 213                 flog_warn(EC_ZEBRA_IRDP_CANNOT_ACTIVATE_IFACE,
 214                           "IRDP: Cannot activate interface %s (cannot create IRDP socket)",
 215                           ifp->name);
 216                 return;
 217         }
 218         irdp->flags |= IF_ACTIVE;
 219
 220         if (!multicast)
 221                 irdp->flags |= IF_BROADCAST;
 222
 223         if_add_update(ifp);
 224
 225         if (!(ifp->flags & IFF_UP)) {
 226                 flog_warn(EC_ZEBRA_IRDP_IFACE_DOWN,
 227                           "IRDP: Interface is down %s", ifp->name);
 228         }
 229
 230         /* Shall we cancel if_start if if_add_group fails? */
 231
 232         if (multicast) {
 233                 if_add_group(ifp);
 234
 235                 if (!(ifp->flags & (IFF_MULTICAST | IFF_ALLMULTI))) {
 236                         flog_warn(EC_ZEBRA_IRDP_IFACE_MCAST_DISABLED,
 237                                   "IRDP: Interface not multicast enabled %s",
 238                                   ifp->name);
 239                 }
 240         }
 241
 242         if (set_defaults)
 243                 if_set_defaults(irdp);
 244
 245         irdp->irdp_sent = 0;
 246
 247         /* The spec suggests this for randomness */
 248
 249         seed = 0;
 250         if (ifp->connected)
 251                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 252                         seed = ifc->address->u.prefix4.s_addr;
 253                         break;
 254                 }
 255
 256         srandom(seed);
 257         timer = (frr_weak_random() % IRDP_DEFAULT_INTERVAL) + 1;
 258
 259         irdp->AdvPrefList = list_new();
 260         irdp->AdvPrefList->del = (void (*)(void *))Adv_free; /* Destructor */
 261
 262
 263         /* And this for startup. Speed limit from 1991 :-). But it's OK*/
 264
 265         if (irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS
 266             && timer > MAX_INITIAL_ADVERT_INTERVAL)
 267                 timer = MAX_INITIAL_ADVERT_INTERVAL;
 268
 269
 270         if (irdp->flags & IF_DEBUG_MISC)
 271                 zlog_debug("IRDP: Init timer for %s set to %u", ifp->name,
 272                            timer);
 273
 274         irdp->t_advertise = NULL;
 275         event_add_timer(zrouter.master, irdp_send_thread, ifp, timer,
 276                         &irdp->t_advertise);
 277 }
 278
 279 static void irdp_if_stop(struct interface *ifp)
 280 {
 281         struct zebra_if *zi = ifp->info;
 282         struct irdp_interface *irdp = zi->irdp;
 283
 284         if (irdp == NULL) {
 285                 zlog_debug("Interface %s structure is NULL", ifp->name);
 286                 return;
 287         }
 288
 289         if (!(irdp->flags & IF_ACTIVE)) {
 290                 zlog_debug("Interface is not active %s", ifp->name);
 291                 return;
 292         }
 293
 294         if (!(irdp->flags & IF_BROADCAST))
 295                 if_drop_group(ifp);
 296
 297         irdp_advert_off(ifp);
 298
 299         list_delete(&irdp->AdvPrefList);
 300
 301         irdp->flags = 0;
 302 }
 303
 304
 305 static void irdp_if_shutdown(struct interface *ifp)
 306 {
 307         struct zebra_if *zi = ifp->info;
 308         struct irdp_interface *irdp = zi->irdp;
 309
 310         if (!irdp)
 311                 return;
 312
 313         if (irdp->flags & IF_SHUTDOWN) {
 314                 zlog_debug("IRDP: Interface is already shutdown %s", ifp->name);
 315                 return;
 316         }
 317
 318         irdp->flags |= IF_SHUTDOWN;
 319         irdp->flags &= ~IF_ACTIVE;
 320
 321         if (!(irdp->flags & IF_BROADCAST))
 322                 if_drop_group(ifp);
 323
 324         /* Tell the hosts we are out of service */
 325         irdp_advert_off(ifp);
 326 }
 327
 328 static void irdp_if_no_shutdown(struct interface *ifp)
 329 {
 330         struct irdp_interface *irdp = irdp_if_get(ifp);
 331
 332         if (!irdp)
 333                 return;
 334
 335         if (!(irdp->flags & IF_SHUTDOWN)) {
 336                 zlog_debug("IRDP: Interface is not shutdown %s", ifp->name);
 337                 return;
 338         }
 339
 340         irdp->flags &= ~IF_SHUTDOWN;
 341
 342         irdp_if_start(ifp, irdp->flags & IF_BROADCAST ? false : true, false);
 343 }
 344
 345
 346 /* Write configuration to user */
 347
 348 int irdp_config_write(struct vty *vty, struct interface *ifp)
 349 {
 350         struct zebra_if *zi = ifp->info;
 351         struct irdp_interface *irdp = zi->irdp;
 352         struct Adv *adv;
 353         struct listnode *node;
 354         char b1[INET_ADDRSTRLEN];
 355
 356         if (!irdp)
 357                 return 0;
 358
 359         if (irdp->flags & IF_ACTIVE || irdp->flags & IF_SHUTDOWN) {
 360
 361                 if (irdp->flags & IF_SHUTDOWN)
 362                         vty_out(vty, " ip irdp shutdown \n");
 363
 364                 if (irdp->flags & IF_BROADCAST)
 365                         vty_out(vty, " ip irdp broadcast\n");
 366                 else
 367                         vty_out(vty, " ip irdp multicast\n");
 368
 369                 vty_out(vty, " ip irdp preference %ld\n", irdp->Preference);
 370
 371                 for (ALL_LIST_ELEMENTS_RO(irdp->AdvPrefList, node, adv))
 372                         vty_out(vty, " ip irdp address %s preference %d\n",
 373                                 inet_2a(adv->ip.s_addr, b1, sizeof(b1)),
 374                                 adv->pref);
 375
 376                 vty_out(vty, " ip irdp holdtime %d\n", irdp->Lifetime);
 377
 378                 vty_out(vty, " ip irdp minadvertinterval %ld\n",
 379                         irdp->MinAdvertInterval);
 380
 381                 vty_out(vty, " ip irdp maxadvertinterval %ld\n",
 382                         irdp->MaxAdvertInterval);
 383         }
 384         return 0;
 385 }
 386
 387
 388 DEFUN (ip_irdp_multicast,
 389        ip_irdp_multicast_cmd,
 390        "ip irdp multicast",
 391        IP_STR
 392        "ICMP Router discovery on this interface\n"
 393        "Use multicast mode\n")
 394 {
 395         VTY_DECLVAR_CONTEXT(interface, ifp);
 396         irdp_if_get(ifp);
 397
 398         irdp_if_start(ifp, true, true);
 399         return CMD_SUCCESS;
 400 }
 401
 402 DEFUN (ip_irdp_broadcast,
 403        ip_irdp_broadcast_cmd,
 404        "ip irdp broadcast",
 405        IP_STR
 406        "ICMP Router discovery on this interface\n"
 407        "Use broadcast mode\n")
 408 {
 409         VTY_DECLVAR_CONTEXT(interface, ifp);
 410         irdp_if_get(ifp);
 411
 412         irdp_if_start(ifp, false, true);
 413         return CMD_SUCCESS;
 414 }
 415
 416 DEFUN (no_ip_irdp,
 417        no_ip_irdp_cmd,
 418        "no ip irdp",
 419        NO_STR
 420        IP_STR
 421        "Disable ICMP Router discovery on this interface\n")
 422 {
 423         VTY_DECLVAR_CONTEXT(interface, ifp);
 424
 425         irdp_if_stop(ifp);
 426         return CMD_SUCCESS;
 427 }
 428
 429 DEFUN (ip_irdp_shutdown,
 430        ip_irdp_shutdown_cmd,
 431        "ip irdp shutdown",
 432        IP_STR
 433        "ICMP Router discovery on this interface\n"
 434        "ICMP Router discovery shutdown on this interface\n")
 435 {
 436         VTY_DECLVAR_CONTEXT(interface, ifp);
 437
 438         irdp_if_shutdown(ifp);
 439         return CMD_SUCCESS;
 440 }
 441
 442 DEFUN (no_ip_irdp_shutdown,
 443        no_ip_irdp_shutdown_cmd,
 444        "no ip irdp shutdown",
 445        NO_STR
 446        IP_STR
 447        "ICMP Router discovery on this interface\n"
 448        "ICMP Router discovery no shutdown on this interface\n")
 449 {
 450         VTY_DECLVAR_CONTEXT(interface, ifp);
 451
 452         irdp_if_no_shutdown(ifp);
 453         return CMD_SUCCESS;
 454 }
 455
 456 DEFUN (ip_irdp_holdtime,
 457        ip_irdp_holdtime_cmd,
 458        "ip irdp holdtime (0-9000)",
 459        IP_STR
 460        "ICMP Router discovery on this interface\n"
 461        "Set holdtime value\n"
 462        "Holdtime value in seconds. Default is 1800 seconds\n")
 463 {
 464         int idx_number = 3;
 465         VTY_DECLVAR_CONTEXT(interface, ifp);
 466         struct irdp_interface *irdp = irdp_if_get(ifp);
 467
 468         IRDP_CONFIGED;
 469
 470         irdp->Lifetime = atoi(argv[idx_number]->arg);
 471         return CMD_SUCCESS;
 472 }
 473
 474 DEFUN (ip_irdp_minadvertinterval,
 475        ip_irdp_minadvertinterval_cmd,
 476        "ip irdp minadvertinterval (3-1800)",
 477        IP_STR
 478        "ICMP Router discovery on this interface\n"
 479        "Set minimum time between advertisement\n"
 480        "Minimum advertisement interval in seconds\n")
 481 {
 482         int idx_number = 3;
 483         VTY_DECLVAR_CONTEXT(interface, ifp);
 484         struct irdp_interface *irdp = irdp_if_get(ifp);
 485
 486         IRDP_CONFIGED;
 487
 488         if ((unsigned)atoi(argv[idx_number]->arg) <= irdp->MaxAdvertInterval) {
 489                 irdp->MinAdvertInterval = atoi(argv[idx_number]->arg);
 490                 return CMD_SUCCESS;
 491         } else {
 492                 vty_out(vty,
 493                         "%% MinAdvertInterval must be less than or equal to MaxAdvertInterval\n");
 494                 return CMD_WARNING_CONFIG_FAILED;
 495         }
 496 }
 497
 498 DEFUN (ip_irdp_maxadvertinterval,
 499        ip_irdp_maxadvertinterval_cmd,
 500        "ip irdp maxadvertinterval (4-1800)",
 501        IP_STR
 502        "ICMP Router discovery on this interface\n"
 503        "Set maximum time between advertisement\n"
 504        "Maximum advertisement interval in seconds\n")
 505 {
 506         int idx_number = 3;
 507         VTY_DECLVAR_CONTEXT(interface, ifp);
 508         struct irdp_interface *irdp = irdp_if_get(ifp);
 509
 510         IRDP_CONFIGED;
 511
 512         if (irdp->MinAdvertInterval <= (unsigned)atoi(argv[idx_number]->arg)) {
 513                 irdp->MaxAdvertInterval = atoi(argv[idx_number]->arg);
 514                 return CMD_SUCCESS;
 515         } else {
 516                 vty_out(vty,
 517                         "%% MaxAdvertInterval must be greater than or equal to MinAdvertInterval\n");
 518                 return CMD_WARNING_CONFIG_FAILED;
 519         }
 520 }
 521
 522 /* DEFUN needs to be fixed for negative ranages...
 523  * "ip irdp preference <-2147483648-2147483647>",
 524  * Be positive for now. :-)
 525  */
 526
 527 DEFUN (ip_irdp_preference,
 528        ip_irdp_preference_cmd,
 529        "ip irdp preference (0-2147483647)",
 530        IP_STR
 531        "ICMP Router discovery on this interface\n"
 532        "Set default preference level for this interface\n"
 533        "Preference level\n")
 534 {
 535         int idx_number = 3;
 536         VTY_DECLVAR_CONTEXT(interface, ifp);
 537         struct irdp_interface *irdp = irdp_if_get(ifp);
 538
 539         IRDP_CONFIGED;
 540
 541         irdp->Preference = atoi(argv[idx_number]->arg);
 542         return CMD_SUCCESS;
 543 }
 544
 545 DEFUN (ip_irdp_address_preference,
 546        ip_irdp_address_preference_cmd,
 547        "ip irdp address A.B.C.D preference (0-2147483647)",
 548        IP_STR
 549        "Alter ICMP Router discovery preference on this interface\n"
 550        "Set IRDP address for advertise\n"
 551        "IPv4 address\n"
 552        "Specify IRDP non-default preference to advertise\n"
 553        "Preference level\n")
 554 {
 555         int idx_ipv4 = 3;
 556         int idx_number = 5;
 557         VTY_DECLVAR_CONTEXT(interface, ifp);
 558         struct irdp_interface *irdp = irdp_if_get(ifp);
 559         struct listnode *node;
 560         struct in_addr ip;
 561         int pref;
 562         int ret;
 563         struct Adv *adv;
 564
 565         IRDP_CONFIGED;
 566
 567         ret = inet_aton(argv[idx_ipv4]->arg, &ip);
 568         if (!ret)
 569                 return CMD_WARNING_CONFIG_FAILED;
 570
 571         pref = atoi(argv[idx_number]->arg);
 572
 573         for (ALL_LIST_ELEMENTS_RO(irdp->AdvPrefList, node, adv))
 574                 if (adv->ip.s_addr == ip.s_addr)
 575                         return CMD_SUCCESS;
 576
 577         adv = Adv_new();
 578         adv->ip = ip;
 579         adv->pref = pref;
 580         listnode_add(irdp->AdvPrefList, adv);
 581
 582         return CMD_SUCCESS;
 583 }
 584
 585 DEFUN (no_ip_irdp_address_preference,
 586        no_ip_irdp_address_preference_cmd,
 587        "no ip irdp address A.B.C.D preference (0-2147483647)",
 588        NO_STR
 589        IP_STR
 590        "Alter ICMP Router discovery preference on this interface\n"
 591        "Select IRDP address\n"
 592        "IPv4 address\n"
 593        "Reset ICMP Router discovery preference on this interface\n"
 594        "Old preference level\n")
 595 {
 596         int idx_ipv4 = 4;
 597         VTY_DECLVAR_CONTEXT(interface, ifp);
 598         struct irdp_interface *irdp = irdp_if_get(ifp);
 599         struct listnode *node, *nnode;
 600         struct in_addr ip;
 601         int ret;
 602         struct Adv *adv;
 603
 604         IRDP_CONFIGED;
 605
 606         ret = inet_aton(argv[idx_ipv4]->arg, &ip);
 607         if (!ret)
 608                 return CMD_WARNING_CONFIG_FAILED;
 609
 610         for (ALL_LIST_ELEMENTS(irdp->AdvPrefList, node, nnode, adv)) {
 611                 if (adv->ip.s_addr == ip.s_addr) {
 612                         listnode_delete(irdp->AdvPrefList, adv);
 613                         break;
 614                 }
 615         }
 616
 617         return CMD_SUCCESS;
 618 }
 619
 620 DEFUN (ip_irdp_debug_messages,
 621        ip_irdp_debug_messages_cmd,
 622        "ip irdp debug messages",
 623        IP_STR
 624        "ICMP Router discovery debug Averts. and Solicits (short)\n"
 625        "IRDP debugging options\n"
 626        "Enable debugging for IRDP messages\n")
 627 {
 628         VTY_DECLVAR_CONTEXT(interface, ifp);
 629         struct irdp_interface *irdp = irdp_if_get(ifp);
 630
 631         IRDP_CONFIGED;
 632
 633         irdp->flags |= IF_DEBUG_MESSAGES;
 634
 635         return CMD_SUCCESS;
 636 }
 637
 638 DEFUN (ip_irdp_debug_misc,
 639        ip_irdp_debug_misc_cmd,
 640        "ip irdp debug misc",
 641        IP_STR
 642        "ICMP Router discovery debug Averts. and Solicits (short)\n"
 643        "IRDP debugging options\n"
 644        "Enable debugging for miscellaneous IRDP events\n")
 645 {
 646         VTY_DECLVAR_CONTEXT(interface, ifp);
 647         struct irdp_interface *irdp = irdp_if_get(ifp);
 648
 649         IRDP_CONFIGED;
 650
 651         irdp->flags |= IF_DEBUG_MISC;
 652
 653         return CMD_SUCCESS;
 654 }
 655
 656 DEFUN (ip_irdp_debug_packet,
 657        ip_irdp_debug_packet_cmd,
 658        "ip irdp debug packet",
 659        IP_STR
 660        "ICMP Router discovery debug Averts. and Solicits (short)\n"
 661        "IRDP debugging options\n"
 662        "Enable debugging for IRDP packets\n")
 663 {
 664         VTY_DECLVAR_CONTEXT(interface, ifp);
 665         struct irdp_interface *irdp = irdp_if_get(ifp);
 666
 667         IRDP_CONFIGED;
 668
 669         irdp->flags |= IF_DEBUG_PACKET;
 670
 671         return CMD_SUCCESS;
 672 }
 673
 674
 675 DEFUN (ip_irdp_debug_disable,
 676        ip_irdp_debug_disable_cmd,
 677        "ip irdp debug disable",
 678        IP_STR
 679        "ICMP Router discovery debug Averts. and Solicits (short)\n"
 680        "IRDP debugging options\n"
 681        "Disable debugging for all IRDP events\n")
 682 {
 683         VTY_DECLVAR_CONTEXT(interface, ifp);
 684         struct irdp_interface *irdp = irdp_if_get(ifp);
 685
 686         IRDP_CONFIGED;
 687
 688         irdp->flags &= ~IF_DEBUG_PACKET;
 689         irdp->flags &= ~IF_DEBUG_MESSAGES;
 690         irdp->flags &= ~IF_DEBUG_MISC;
 691
 692         return CMD_SUCCESS;
 693 }
 694
 695 void irdp_if_init(void)
 696 {
 697         hook_register(zebra_if_config_wr, irdp_config_write);
 698         hook_register(if_del, irdp_if_delete);
 699
 700         install_element(INTERFACE_NODE, &ip_irdp_broadcast_cmd);
 701         install_element(INTERFACE_NODE, &ip_irdp_multicast_cmd);
 702         install_element(INTERFACE_NODE, &no_ip_irdp_cmd);
 703         install_element(INTERFACE_NODE, &ip_irdp_shutdown_cmd);
 704         install_element(INTERFACE_NODE, &no_ip_irdp_shutdown_cmd);
 705         install_element(INTERFACE_NODE, &ip_irdp_holdtime_cmd);
 706         install_element(INTERFACE_NODE, &ip_irdp_maxadvertinterval_cmd);
 707         install_element(INTERFACE_NODE, &ip_irdp_minadvertinterval_cmd);
 708         install_element(INTERFACE_NODE, &ip_irdp_preference_cmd);
 709         install_element(INTERFACE_NODE, &ip_irdp_address_preference_cmd);
 710         install_element(INTERFACE_NODE, &no_ip_irdp_address_preference_cmd);
 711
 712         install_element(INTERFACE_NODE, &ip_irdp_debug_messages_cmd);
 713         install_element(INTERFACE_NODE, &ip_irdp_debug_misc_cmd);
 714         install_element(INTERFACE_NODE, &ip_irdp_debug_packet_cmd);
 715         install_element(INTERFACE_NODE, &ip_irdp_debug_disable_cmd);
 716 }