zebra/irdp_interface.c

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