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
  19  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  20  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  21  * 02111-1307, USA.
  22  */
  23
  24 /*
  25  * This work includes work with the following copywrite:
  26  *
  27  * Copyright (C) 1997, 2000 Kunihiro Ishiguro
  28  *
  29  */
  30
  31 /*
  32  * Thanks to Jens Låås at Swedish University of Agricultural Sciences
  33  * for reviewing and tests.
  34  */
  35
  36
  37 #include <zebra.h>
  38
  39 #ifdef HAVE_IRDP
  40
  41 #include "if.h"
  42 #include "vty.h"
  43 #include "sockunion.h"
  44 #include "prefix.h"
  45 #include "command.h"
  46 #include "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
  65 /* Master of threads. */
  66 extern struct zebra_t zebrad;
  67
  68 int in_cksum (void *ptr, int nbytes);
  69 extern int irdp_sock;
  70 int irdp_send_thread(struct thread *t_advert);
  71 char *inet_2a(u_int32_t a, char *b);
  72 void irdp_advert_off(struct interface *ifp);
  73
  74
  75 char b1[16], b2[16], b3[16], b4[16];  /* For inet_2a */
  76
  77 static struct prefix *
  78 irdp_get_prefix(struct interface *ifp)
  79 {
  80   struct listnode *node;
  81   struct connected *ifc;
  82
  83   if (ifp->connected)
  84     for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
  85       return ifc->address;
  86
  87   return NULL;
  88 }
  89
  90 /* Join to the add/leave multicast group. */
  91 static int
  92 if_group (struct interface *ifp,
  93           int sock,
  94           u_int32_t group,
  95           int add_leave)
  96 {
  97   struct zebra_if *zi;
  98   struct ip_mreq m;
  99   struct prefix *p;
 100   int ret;
 101
 102   zi = ifp->info;
 103
 104   bzero (&m, sizeof (m));
 105   m.imr_multiaddr.s_addr = htonl (group);
 106   p = irdp_get_prefix(ifp);
 107
 108   if(!p) {
 109         zlog_warn ("IRDP: can't get address for %s", ifp->name);
 110         return 1;
 111   }
 112
 113   m.imr_interface = p->u.prefix4;
 114
 115   ret = setsockopt (sock, IPPROTO_IP, add_leave,
 116                     (char *) &m, sizeof (struct ip_mreq));
 117   if (ret < 0)
 118     zlog_warn ("IRDP: %s can't setsockopt %s: %s",
 119                add_leave == IP_ADD_MEMBERSHIP? "join group":"leave group",
 120                inet_2a(group, b1),
 121                safe_strerror (errno));
 122
 123   return ret;
 124 }
 125
 126 static int
 127 if_add_group (struct interface *ifp)
 128 {
 129   struct zebra_if *zi= ifp->info;
 130   struct irdp_interface *irdp = &zi->irdp;
 131   int ret;
 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
 152   ret = if_group (ifp, irdp_sock, INADDR_ALLRTRS_GROUP, IP_DROP_MEMBERSHIP);
 153   if (ret < 0)
 154     return ret;
 155
 156   if(irdp->flags & IF_DEBUG_MISC)
 157     zlog_debug("IRDP: Leaving group %s for %s",
 158                inet_2a(htonl(INADDR_ALLRTRS_GROUP), b1),
 159                ifp->name);
 160   return 0;
 161 }
 162
 163 static void
 164 if_set_defaults(struct interface *ifp)
 165 {
 166   struct zebra_if *zi=ifp->info;
 167   struct irdp_interface *irdp=&zi->irdp;
 168
 169   irdp->MaxAdvertInterval = IRDP_MAXADVERTINTERVAL;
 170   irdp->MinAdvertInterval = IRDP_MINADVERTINTERVAL;
 171   irdp->Preference = IRDP_PREFERENCE;
 172   irdp->Lifetime = IRDP_LIFETIME;
 173 }
 174
 175
 176 struct Adv *Adv_new (void)
 177 {
 178   struct Adv *new;
 179   new = XMALLOC (MTYPE_TMP, sizeof (struct Adv));
 180   memset (new, 0, sizeof (struct Adv));
 181   return new;
 182 }
 183
 184 static void
 185 Adv_free (struct Adv *adv)
 186 {
 187   XFREE (MTYPE_TMP, adv);
 188 }
 189
 190 static void
 191 irdp_if_start(struct interface *ifp, int multicast, int set_defaults)
 192 {
 193   struct zebra_if *zi= ifp->info;
 194   struct irdp_interface *irdp = &zi->irdp;
 195   struct listnode *node;
 196   struct connected *ifc;
 197   u_int32_t timer, seed;
 198
 199   if (irdp->flags & IF_ACTIVE ) {
 200     zlog_warn("IRDP: Interface is already active %s", ifp->name);
 201     return;
 202   }
 203   if ((irdp_sock < 0) && ((irdp_sock = irdp_sock_init()) < 0)) {
 204     zlog_warn("IRDP: Cannot activate interface %s (cannot create "
 205               "IRDP socket)", ifp->name);
 206     return;
 207   }
 208   irdp->flags |= IF_ACTIVE;
 209
 210   if(!multicast)
 211     irdp->flags |= IF_BROADCAST;
 212
 213   if_add_update(ifp);
 214
 215   if (! (ifp->flags & IFF_UP)) {
 216     zlog_warn("IRDP: Interface is down %s", ifp->name);
 217   }
 218
 219   /* Shall we cancel if_start if if_add_group fails? */
 220
 221   if( multicast) {
 222     if_add_group(ifp);
 223
 224     if (! (ifp->flags & (IFF_MULTICAST|IFF_ALLMULTI))) {
 225       zlog_warn("IRDP: Interface not multicast enabled %s", ifp->name);
 226     }
 227   }
 228
 229   if(set_defaults)
 230     if_set_defaults(ifp);
 231
 232   irdp->irdp_sent = 0;
 233
 234   /* The spec suggests this for randomness */
 235
 236   seed = 0;
 237   if( ifp->connected)
 238     for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
 239       {
 240         seed = ifc->address->u.prefix4.s_addr;
 241         break;
 242       }
 243
 244   srandom(seed);
 245   timer =  (random () % IRDP_DEFAULT_INTERVAL) + 1;
 246
 247   irdp->AdvPrefList = list_new();
 248   irdp->AdvPrefList->del =  (void (*)(void *)) Adv_free; /* Destructor */
 249
 250
 251   /* And this for startup. Speed limit from 1991 :-). But it's OK*/
 252
 253   if(irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS &&
 254      timer > MAX_INITIAL_ADVERT_INTERVAL )
 255           timer= MAX_INITIAL_ADVERT_INTERVAL;
 256
 257
 258   if(irdp->flags & IF_DEBUG_MISC)
 259     zlog_debug("IRDP: Init timer for %s set to %u",
 260                ifp->name,
 261                timer);
 262
 263   irdp->t_advertise = thread_add_timer(zebrad.master,
 264                                        irdp_send_thread,
 265                                        ifp,
 266                                        timer);
 267 }
 268
 269 static void
 270 irdp_if_stop(struct interface *ifp)
 271 {
 272   struct zebra_if *zi=ifp->info;
 273   struct irdp_interface *irdp=&zi->irdp;
 274
 275   if (irdp == NULL) {
 276     zlog_warn ("Interface %s structure is NULL", ifp->name);
 277     return;
 278   }
 279
 280   if (! (irdp->flags & IF_ACTIVE )) {
 281     zlog_warn("Interface is not active %s", ifp->name);
 282     return;
 283   }
 284
 285   if(! (irdp->flags & IF_BROADCAST))
 286     if_drop_group(ifp);
 287
 288   irdp_advert_off(ifp);
 289
 290   list_delete(irdp->AdvPrefList);
 291   irdp->AdvPrefList=NULL;
 292
 293   irdp->flags = 0;
 294 }
 295
 296
 297 static void
 298 irdp_if_shutdown(struct interface *ifp)
 299 {
 300   struct zebra_if *zi= ifp->info;
 301   struct irdp_interface *irdp = &zi->irdp;
 302
 303   if (irdp->flags & IF_SHUTDOWN ) {
 304     zlog_warn("IRDP: Interface is already shutdown %s", ifp->name);
 305     return;
 306   }
 307
 308   irdp->flags |= IF_SHUTDOWN;
 309   irdp->flags &= ~IF_ACTIVE;
 310
 311   if(! (irdp->flags & IF_BROADCAST))
 312     if_drop_group(ifp);
 313
 314   /* Tell the hosts we are out of service */
 315   irdp_advert_off(ifp);
 316 }
 317
 318 static void
 319 irdp_if_no_shutdown(struct interface *ifp)
 320 {
 321   struct zebra_if *zi= ifp->info;
 322   struct irdp_interface *irdp = &zi->irdp;
 323
 324   if (! (irdp->flags & IF_SHUTDOWN )) {
 325     zlog_warn("IRDP: Interface is not shutdown %s", ifp->name);
 326     return;
 327   }
 328
 329   irdp->flags &= ~IF_SHUTDOWN;
 330
 331   irdp_if_start(ifp, irdp->flags & IF_BROADCAST? FALSE : TRUE, FALSE);
 332
 333 }
 334
 335
 336 /* Write configuration to user */
 337
 338 void irdp_config_write (struct vty *vty, struct interface *ifp)
 339 {
 340   struct zebra_if *zi=ifp->info;
 341   struct irdp_interface *irdp=&zi->irdp;
 342   struct Adv *adv;
 343   struct listnode *node;
 344
 345   if(irdp->flags & IF_ACTIVE || irdp->flags & IF_SHUTDOWN) {
 346
 347     if( irdp->flags & IF_SHUTDOWN)
 348       vty_out (vty, " ip irdp shutdown %s",  VTY_NEWLINE);
 349
 350     if( irdp->flags & IF_BROADCAST)
 351       vty_out (vty, " ip irdp broadcast%s",  VTY_NEWLINE);
 352     else
 353       vty_out (vty, " ip irdp multicast%s",  VTY_NEWLINE);
 354
 355     vty_out (vty, " ip irdp preference %ld%s",
 356              irdp->Preference, VTY_NEWLINE);
 357
 358     for (ALL_LIST_ELEMENTS_RO (irdp->AdvPrefList, node, adv))
 359       vty_out (vty, " ip irdp address %s preference %d%s",
 360                     inet_2a(adv->ip.s_addr, b1),
 361                     adv->pref,
 362                     VTY_NEWLINE);
 363
 364     vty_out (vty, " ip irdp holdtime %d%s",
 365              irdp->Lifetime, VTY_NEWLINE);
 366
 367     vty_out (vty, " ip irdp minadvertinterval %ld%s",
 368              irdp->MinAdvertInterval, VTY_NEWLINE);
 369
 370     vty_out (vty, " ip irdp maxadvertinterval %ld%s",
 371              irdp->MaxAdvertInterval, VTY_NEWLINE);
 372
 373   }
 374 }
 375
 376
 377 DEFUN (ip_irdp_multicast,
 378        ip_irdp_multicast_cmd,
 379        "ip irdp multicast",
 380        IP_STR
 381        "ICMP Router discovery on this interface using multicast\n")
 382 {
 383   struct interface *ifp;
 384
 385   ifp = (struct interface *) vty->index;
 386   if(!ifp) {
 387           return CMD_WARNING;
 388   }
 389
 390   irdp_if_start(ifp, TRUE, TRUE);
 391   return CMD_SUCCESS;
 392 }
 393
 394 DEFUN (ip_irdp_broadcast,
 395        ip_irdp_broadcast_cmd,
 396        "ip irdp broadcast",
 397        IP_STR
 398        "ICMP Router discovery on this interface using broadcast\n")
 399 {
 400   struct interface *ifp;
 401
 402   ifp = (struct interface *) vty->index;
 403   if(!ifp) {
 404           return CMD_WARNING;
 405   }
 406
 407   irdp_if_start(ifp, FALSE, TRUE);
 408   return CMD_SUCCESS;
 409 }
 410
 411 DEFUN (no_ip_irdp,
 412        no_ip_irdp_cmd,
 413        "no ip irdp",
 414        NO_STR
 415        IP_STR
 416        "Disable ICMP Router discovery on this interface\n")
 417 {
 418   struct interface *ifp;
 419
 420   ifp = (struct interface *) vty->index;
 421   if(!ifp) {
 422           return CMD_WARNING;
 423   }
 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 shutdown on this interface\n")
 434 {
 435   struct interface *ifp;
 436
 437   ifp = (struct interface *) vty->index;
 438   if(!ifp) {
 439           return CMD_WARNING;
 440   }
 441
 442   irdp_if_shutdown(ifp);
 443   return CMD_SUCCESS;
 444 }
 445
 446 DEFUN (no_ip_irdp_shutdown,
 447        no_ip_irdp_shutdown_cmd,
 448        "no ip irdp shutdown",
 449        NO_STR
 450        IP_STR
 451        "ICMP Router discovery no shutdown on this interface\n")
 452 {
 453   struct interface *ifp;
 454
 455   ifp = (struct interface *) vty->index;
 456   if(!ifp) {
 457           return CMD_WARNING;
 458   }
 459
 460   irdp_if_no_shutdown(ifp);
 461   return CMD_SUCCESS;
 462 }
 463
 464 DEFUN (ip_irdp_holdtime,
 465        ip_irdp_holdtime_cmd,
 466        "ip irdp holdtime <0-9000>",
 467        IP_STR
 468        "ICMP Router discovery on this interface\n"
 469        "Set holdtime value\n"
 470        "Holdtime value in seconds. Default is 1800 seconds\n")
 471 {
 472   struct interface *ifp;
 473   struct zebra_if *zi;
 474   struct irdp_interface *irdp;
 475   ifp = (struct interface *) vty->index;
 476   if(!ifp) {
 477           return CMD_WARNING;
 478   }
 479
 480   zi=ifp->info;
 481   irdp=&zi->irdp;
 482
 483   irdp->Lifetime = atoi(argv[0]);
 484   return CMD_SUCCESS;
 485 }
 486
 487 DEFUN (ip_irdp_minadvertinterval,
 488        ip_irdp_minadvertinterval_cmd,
 489        "ip irdp minadvertinterval <3-1800>",
 490        IP_STR
 491        "ICMP Router discovery on this interface\n"
 492        "Set minimum time between advertisement\n"
 493        "Minimum advertisement interval in seconds\n")
 494 {
 495   struct interface *ifp;
 496   struct zebra_if *zi;
 497   struct irdp_interface *irdp;
 498   ifp = (struct interface *) vty->index;
 499   if(!ifp) {
 500           return CMD_WARNING;
 501   }
 502
 503   zi=ifp->info;
 504   irdp=&zi->irdp;
 505
 506   if( (unsigned) atoi(argv[0]) <= irdp->MaxAdvertInterval) {
 507       irdp->MinAdvertInterval = atoi(argv[0]);
 508
 509       return CMD_SUCCESS;
 510   }
 511
 512   vty_out (vty, "ICMP warning maxadvertinterval is greater or equal than minadvertinterval%s",
 513              VTY_NEWLINE);
 514
 515   vty_out (vty, "Please correct!%s",
 516              VTY_NEWLINE);
 517   return CMD_WARNING;
 518 }
 519
 520 DEFUN (ip_irdp_maxadvertinterval,
 521        ip_irdp_maxadvertinterval_cmd,
 522        "ip irdp maxadvertinterval <4-1800>",
 523        IP_STR
 524        "ICMP Router discovery on this interface\n"
 525        "Set maximum time between advertisement\n"
 526        "Maximum advertisement interval in seconds\n")
 527 {
 528   struct interface *ifp;
 529   struct zebra_if *zi;
 530   struct irdp_interface *irdp;
 531   ifp = (struct interface *) vty->index;
 532   if(!ifp) {
 533           return CMD_WARNING;
 534   }
 535
 536   zi=ifp->info;
 537   irdp=&zi->irdp;
 538
 539
 540   if( irdp->MinAdvertInterval <= (unsigned) atoi(argv[0]) ) {
 541     irdp->MaxAdvertInterval = atoi(argv[0]);
 542
 543       return CMD_SUCCESS;
 544   }
 545
 546   vty_out (vty, "ICMP warning maxadvertinterval is greater or equal than minadvertinterval%s",
 547              VTY_NEWLINE);
 548
 549   vty_out (vty, "Please correct!%s",
 550              VTY_NEWLINE);
 551   return CMD_WARNING;
 552 }
 553
 554 /* DEFUN needs to be fixed for negative ranages...
 555  * "ip irdp preference <-2147483648-2147483647>",
 556  * Be positive for now. :-)
 557  */
 558
 559 DEFUN (ip_irdp_preference,
 560        ip_irdp_preference_cmd,
 561        "ip irdp preference <0-2147483647>",
 562        IP_STR
 563        "ICMP Router discovery on this interface\n"
 564        "Set default preference level for this interface\n"
 565        "Preference level\n")
 566 {
 567   struct interface *ifp;
 568   struct zebra_if *zi;
 569   struct irdp_interface *irdp;
 570   ifp = (struct interface *) vty->index;
 571   if(!ifp) {
 572           return CMD_WARNING;
 573   }
 574
 575   zi=ifp->info;
 576   irdp=&zi->irdp;
 577
 578   irdp->Preference = atoi(argv[0]);
 579   return CMD_SUCCESS;
 580 }
 581
 582 DEFUN (ip_irdp_address_preference,
 583        ip_irdp_address_preference_cmd,
 584        "ip irdp address A.B.C.D preference <0-2147483647>",
 585        IP_STR
 586        "Alter ICMP Router discovery preference this interface\n"
 587        "Specify IRDP non-default preference to advertise\n"
 588        "Set IRDP address for advertise\n"
 589        "Preference level\n")
 590 {
 591   struct listnode *node;
 592   struct in_addr ip;
 593   int pref;
 594   int ret;
 595   struct interface *ifp;
 596   struct zebra_if *zi;
 597   struct irdp_interface *irdp;
 598   struct Adv *adv;
 599
 600   ifp = (struct interface *) vty->index;
 601   if(!ifp) {
 602           return CMD_WARNING;
 603   }
 604
 605   zi=ifp->info;
 606   irdp=&zi->irdp;
 607
 608   ret = inet_aton(argv[0], &ip);
 609   if(!ret) return CMD_WARNING;
 610
 611   pref = atoi(argv[1]);
 612
 613   for (ALL_LIST_ELEMENTS_RO (irdp->AdvPrefList, node, adv))
 614     if(adv->ip.s_addr == ip.s_addr)
 615       return CMD_SUCCESS;
 616
 617   adv = Adv_new();
 618   adv->ip = ip;
 619   adv->pref = pref;
 620   listnode_add(irdp->AdvPrefList, adv);
 621
 622   return CMD_SUCCESS;
 623
 624 }
 625
 626 DEFUN (no_ip_irdp_address_preference,
 627        no_ip_irdp_address_preference_cmd,
 628        "no ip irdp address A.B.C.D preference <0-2147483647>",
 629        NO_STR
 630        IP_STR
 631        "Alter ICMP Router discovery preference this interface\n"
 632        "Removes IRDP non-default preference\n"
 633        "Select IRDP address\n"
 634        "Old preference level\n")
 635 {
 636   struct listnode *node, *nnode;
 637   struct in_addr ip;
 638   int pref;
 639   int ret;
 640   struct interface *ifp;
 641   struct zebra_if *zi;
 642   struct irdp_interface *irdp;
 643   struct Adv *adv;
 644
 645   ifp = (struct interface *) vty->index;
 646   if(!ifp) {
 647           return CMD_WARNING;
 648   }
 649
 650   zi=ifp->info;
 651   irdp=&zi->irdp;
 652
 653   ret = inet_aton(argv[0], &ip);
 654   if (!ret)
 655     return CMD_WARNING;
 656
 657   pref = atoi(argv[1]);
 658
 659   for (ALL_LIST_ELEMENTS (irdp->AdvPrefList, node, nnode, adv))
 660     {
 661       if(adv->ip.s_addr == ip.s_addr )
 662         {
 663           listnode_delete(irdp->AdvPrefList, adv);
 664           break;
 665         }
 666     }
 667
 668   return CMD_SUCCESS;
 669 }
 670
 671 DEFUN (ip_irdp_debug_messages,
 672        ip_irdp_debug_messages_cmd,
 673        "ip irdp debug messages",
 674        IP_STR
 675        "ICMP Router discovery debug Averts. and Solicits (short)\n")
 676 {
 677   struct interface *ifp;
 678   struct zebra_if *zi;
 679   struct irdp_interface *irdp;
 680   ifp = (struct interface *) vty->index;
 681   if(!ifp) {
 682           return CMD_WARNING;
 683   }
 684
 685   zi=ifp->info;
 686   irdp=&zi->irdp;
 687
 688   irdp->flags |= IF_DEBUG_MESSAGES;
 689
 690   return CMD_SUCCESS;
 691 }
 692
 693 DEFUN (ip_irdp_debug_misc,
 694        ip_irdp_debug_misc_cmd,
 695        "ip irdp debug misc",
 696        IP_STR
 697        "ICMP Router discovery debug Averts. and Solicits (short)\n")
 698 {
 699   struct interface *ifp;
 700   struct zebra_if *zi;
 701   struct irdp_interface *irdp;
 702   ifp = (struct interface *) vty->index;
 703   if(!ifp) {
 704           return CMD_WARNING;
 705   }
 706
 707   zi=ifp->info;
 708   irdp=&zi->irdp;
 709
 710   irdp->flags |= IF_DEBUG_MISC;
 711
 712   return CMD_SUCCESS;
 713 }
 714
 715 DEFUN (ip_irdp_debug_packet,
 716        ip_irdp_debug_packet_cmd,
 717        "ip irdp debug packet",
 718        IP_STR
 719        "ICMP Router discovery debug Averts. and Solicits (short)\n")
 720 {
 721   struct interface *ifp;
 722   struct zebra_if *zi;
 723   struct irdp_interface *irdp;
 724   ifp = (struct interface *) vty->index;
 725   if(!ifp) {
 726           return CMD_WARNING;
 727   }
 728
 729   zi=ifp->info;
 730   irdp=&zi->irdp;
 731
 732   irdp->flags |= IF_DEBUG_PACKET;
 733
 734   return CMD_SUCCESS;
 735 }
 736
 737
 738 DEFUN (ip_irdp_debug_disable,
 739        ip_irdp_debug_disable_cmd,
 740        "ip irdp debug disable",
 741        IP_STR
 742        "ICMP Router discovery debug Averts. and Solicits (short)\n")
 743 {
 744   struct interface *ifp;
 745   struct zebra_if *zi;
 746   struct irdp_interface *irdp;
 747   ifp = (struct interface *) vty->index;
 748   if(!ifp) {
 749           return CMD_WARNING;
 750   }
 751
 752   zi=ifp->info;
 753   irdp=&zi->irdp;
 754
 755   irdp->flags &= ~IF_DEBUG_PACKET;
 756   irdp->flags &= ~IF_DEBUG_MESSAGES;
 757   irdp->flags &= ~IF_DEBUG_MISC;
 758
 759   return CMD_SUCCESS;
 760 }
 761
 762 void
 763 irdp_init ()
 764 {
 765   install_element (INTERFACE_NODE, &ip_irdp_broadcast_cmd);
 766   install_element (INTERFACE_NODE, &ip_irdp_multicast_cmd);
 767   install_element (INTERFACE_NODE, &no_ip_irdp_cmd);
 768   install_element (INTERFACE_NODE, &ip_irdp_shutdown_cmd);
 769   install_element (INTERFACE_NODE, &no_ip_irdp_shutdown_cmd);
 770   install_element (INTERFACE_NODE, &ip_irdp_holdtime_cmd);
 771   install_element (INTERFACE_NODE, &ip_irdp_maxadvertinterval_cmd);
 772   install_element (INTERFACE_NODE, &ip_irdp_minadvertinterval_cmd);
 773   install_element (INTERFACE_NODE, &ip_irdp_preference_cmd);
 774   install_element (INTERFACE_NODE, &ip_irdp_address_preference_cmd);
 775   install_element (INTERFACE_NODE, &no_ip_irdp_address_preference_cmd);
 776
 777   install_element (INTERFACE_NODE, &ip_irdp_debug_messages_cmd);
 778   install_element (INTERFACE_NODE, &ip_irdp_debug_misc_cmd);
 779   install_element (INTERFACE_NODE, &ip_irdp_debug_packet_cmd);
 780   install_element (INTERFACE_NODE, &ip_irdp_debug_disable_cmd);
 781 }
 782
 783 #endif /* HAVE_IRDP */