zebra/irdp_interface.c

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