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