ripngd/ripng_interface.c

   1 /*
   2  * Interface related function for RIPng.
   3  * Copyright (C) 1998 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20  * 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "linklist.h"
  26 #include "if.h"
  27 #include "prefix.h"
  28 #include "memory.h"
  29 #include "network.h"
  30 #include "filter.h"
  31 #include "log.h"
  32 #include "stream.h"
  33 #include "zclient.h"
  34 #include "command.h"
  35 #include "table.h"
  36 #include "thread.h"
  37 #include "privs.h"
  38
  39 #include "ripngd/ripngd.h"
  40 #include "ripngd/ripng_debug.h"
  41 \f
  42 /* If RFC2133 definition is used. */
  43 #ifndef IPV6_JOIN_GROUP
  44 #define IPV6_JOIN_GROUP  IPV6_ADD_MEMBERSHIP
  45 #endif
  46 #ifndef IPV6_LEAVE_GROUP
  47 #define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP
  48 #endif
  49
  50 extern struct zebra_privs_t ripngd_privs;
  51
  52 /* Static utility function. */
  53 static void ripng_enable_apply (struct interface *);
  54 static void ripng_passive_interface_apply (struct interface *);
  55 int ripng_enable_if_lookup (const char *ifname);
  56 int ripng_enable_network_lookup2 (struct connected *connected);
  57 void ripng_enable_apply_all ();
  58
  59 /* Join to the all rip routers multicast group. */
  60 int
  61 ripng_multicast_join (struct interface *ifp)
  62 {
  63   int ret;
  64   struct ipv6_mreq mreq;
  65   int save_errno;
  66
  67   if (if_is_up (ifp) && if_is_multicast (ifp)) {
  68     memset (&mreq, 0, sizeof (mreq));
  69     inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
  70     mreq.ipv6mr_interface = ifp->ifindex;
  71
  72     /*
  73      * NetBSD 1.6.2 requires root to join groups on gif(4).
  74      * While this is bogus, privs are available and easy to use
  75      * for this call as a workaround.
  76      */
  77     if (ripngd_privs.change (ZPRIVS_RAISE))
  78       zlog_err ("ripng_multicast_join: could not raise privs");
  79
  80     ret = setsockopt (ripng->sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
  81                       (char *) &mreq, sizeof (mreq));
  82     save_errno = errno;
  83
  84     if (ripngd_privs.change (ZPRIVS_LOWER))
  85       zlog_err ("ripng_multicast_join: could not lower privs");
  86
  87     if (ret < 0 && save_errno == EADDRINUSE)
  88       {
  89         /*
  90          * Group is already joined.  This occurs due to sloppy group
  91          * management, in particular declining to leave the group on
  92          * an interface that has just gone down.
  93          */
  94         zlog_warn ("ripng join on %s EADDRINUSE (ignoring)\n", ifp->name);
  95         return 0;               /* not an error */
  96       }
  97
  98     if (ret < 0)
  99       zlog_warn ("can't setsockopt IPV6_JOIN_GROUP: %s",
 100                  safe_strerror (save_errno));
 101
 102     if (IS_RIPNG_DEBUG_EVENT)
 103       zlog_debug ("RIPng %s join to all-rip-routers multicast group", ifp->name);
 104
 105     if (ret < 0)
 106       return -1;
 107   }
 108   return 0;
 109 }
 110
 111 /* Leave from the all rip routers multicast group. */
 112 int
 113 ripng_multicast_leave (struct interface *ifp)
 114 {
 115   int ret;
 116   struct ipv6_mreq mreq;
 117
 118   if (if_is_up (ifp) && if_is_multicast (ifp)) {
 119     memset (&mreq, 0, sizeof (mreq));
 120     inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
 121     mreq.ipv6mr_interface = ifp->ifindex;
 122
 123     ret = setsockopt (ripng->sock, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
 124                       (char *) &mreq, sizeof (mreq));
 125     if (ret < 0)
 126       zlog_warn ("can't setsockopt IPV6_LEAVE_GROUP: %s\n", safe_strerror (errno));
 127
 128     if (IS_RIPNG_DEBUG_EVENT)
 129       zlog_debug ("RIPng %s leave from all-rip-routers multicast group",
 130                  ifp->name);
 131
 132     if (ret < 0)
 133       return -1;
 134   }
 135
 136   return 0;
 137 }
 138
 139 /* How many link local IPv6 address could be used on the interface ? */
 140 int
 141 ripng_if_ipv6_lladdress_check (struct interface *ifp)
 142 {
 143   struct listnode *nn;
 144   struct connected *connected;
 145   int count = 0;
 146
 147   for (ALL_LIST_ELEMENTS_RO (ifp->connected, nn, connected))
 148     {
 149       struct prefix *p;
 150       p = connected->address;
 151
 152       if ((p->family == AF_INET6) &&
 153           IN6_IS_ADDR_LINKLOCAL (&p->u.prefix6))
 154         count++;
 155     }
 156
 157   return count;
 158 }
 159
 160 /* Check max mtu size. */
 161 unsigned int
 162 ripng_check_max_mtu ()
 163 {
 164   struct listnode *node;
 165   struct interface *ifp;
 166   unsigned int mtu;
 167
 168   mtu = 0;
 169   for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
 170     if (mtu < ifp->mtu6)
 171       mtu = ifp->mtu6;
 172
 173   return mtu;
 174 }
 175
 176 int
 177 ripng_if_down (struct interface *ifp)
 178 {
 179   struct route_node *rp;
 180   struct ripng_info *rinfo;
 181   struct ripng_interface *ri;
 182
 183   if (ripng)
 184     {
 185       for (rp = route_top (ripng->table); rp; rp = route_next (rp))
 186         if ((rinfo = rp->info) != NULL)
 187           {
 188             /* Routes got through this interface. */
 189             if (rinfo->ifindex == ifp->ifindex
 190                 && rinfo->type == ZEBRA_ROUTE_RIPNG
 191                 && rinfo->sub_type == RIPNG_ROUTE_RTE)
 192               {
 193                 ripng_zebra_ipv6_delete ((struct prefix_ipv6 *) &rp->p,
 194                                          &rinfo->nexthop,
 195                                          rinfo->ifindex);
 196
 197                 ripng_redistribute_delete (rinfo->type, rinfo->sub_type,
 198                                            (struct prefix_ipv6 *)&rp->p,
 199                                            rinfo->ifindex);
 200               }
 201             else
 202               {
 203                 /* All redistributed routes got through this interface,
 204                  * but the static and system ones are kept. */
 205                 if ((rinfo->ifindex == ifp->ifindex) &&
 206                     (rinfo->type != ZEBRA_ROUTE_STATIC) &&
 207                     (rinfo->type != ZEBRA_ROUTE_SYSTEM))
 208                   ripng_redistribute_delete (rinfo->type, rinfo->sub_type,
 209                                              (struct prefix_ipv6 *) &rp->p,
 210                                              rinfo->ifindex);
 211               }
 212           }
 213     }
 214
 215   ri = ifp->info;
 216
 217   if (ri->running)
 218    {
 219      if (IS_RIPNG_DEBUG_EVENT)
 220        zlog_debug ("turn off %s", ifp->name);
 221
 222      /* Leave from multicast group. */
 223      ripng_multicast_leave (ifp);
 224
 225      ri->running = 0;
 226    }
 227
 228   return 0;
 229 }
 230
 231 /* Inteface link up message processing. */
 232 int
 233 ripng_interface_up (int command, struct zclient *zclient, zebra_size_t length)
 234 {
 235   struct stream *s;
 236   struct interface *ifp;
 237
 238   /* zebra_interface_state_read() updates interface structure in iflist. */
 239   s = zclient->ibuf;
 240   ifp = zebra_interface_state_read (s);
 241
 242   if (ifp == NULL)
 243     return 0;
 244
 245   if (IS_RIPNG_DEBUG_ZEBRA)
 246     zlog_debug ("interface up %s index %d flags %ld metric %d mtu %d",
 247                ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu6);
 248
 249   /* Check if this interface is RIPng enabled or not. */
 250   ripng_enable_apply (ifp);
 251
 252   /* Check for a passive interface. */
 253   ripng_passive_interface_apply (ifp);
 254
 255   /* Apply distribute list to the all interface. */
 256   ripng_distribute_update_interface (ifp);
 257
 258   return 0;
 259 }
 260
 261 /* Inteface link down message processing. */
 262 int
 263 ripng_interface_down (int command, struct zclient *zclient,
 264                       zebra_size_t length)
 265 {
 266   struct stream *s;
 267   struct interface *ifp;
 268
 269   /* zebra_interface_state_read() updates interface structure in iflist. */
 270   s = zclient->ibuf;
 271   ifp = zebra_interface_state_read (s);
 272
 273   if (ifp == NULL)
 274     return 0;
 275
 276   ripng_if_down (ifp);
 277
 278   if (IS_RIPNG_DEBUG_ZEBRA)
 279     zlog_debug ("interface down %s index %d flags %ld metric %d mtu %d",
 280                ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu6);
 281
 282   return 0;
 283 }
 284
 285 /* Inteface addition message from zebra. */
 286 int
 287 ripng_interface_add (int command, struct zclient *zclient, zebra_size_t length)
 288 {
 289   struct interface *ifp;
 290
 291   ifp = zebra_interface_add_read (zclient->ibuf);
 292
 293   if (IS_RIPNG_DEBUG_ZEBRA)
 294     zlog_debug ("RIPng interface add %s index %d flags %ld metric %d mtu %d",
 295                ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu6);
 296
 297   /* Check is this interface is RIP enabled or not.*/
 298   ripng_enable_apply (ifp);
 299
 300   /* Apply distribute list to the interface. */
 301   ripng_distribute_update_interface (ifp);
 302
 303   /* Check interface routemap. */
 304   ripng_if_rmap_update_interface (ifp);
 305
 306   return 0;
 307 }
 308
 309 int
 310 ripng_interface_delete (int command, struct zclient *zclient,
 311                         zebra_size_t length)
 312 {
 313   struct interface *ifp;
 314   struct stream *s;
 315
 316   s = zclient->ibuf;
 317   /*  zebra_interface_state_read() updates interface structure in iflist */
 318   ifp = zebra_interface_state_read(s);
 319
 320   if (ifp == NULL)
 321     return 0;
 322
 323   if (if_is_up (ifp)) {
 324     ripng_if_down(ifp);
 325   }
 326
 327   zlog_info("interface delete %s index %d flags %ld metric %d mtu %d",
 328             ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu6);
 329
 330   /* To support pseudo interface do not free interface structure.  */
 331   /* if_delete(ifp); */
 332   ifp->ifindex = IFINDEX_INTERNAL;
 333
 334   return 0;
 335 }
 336
 337 void
 338 ripng_interface_clean ()
 339 {
 340   struct listnode *node, *nnode;
 341   struct interface *ifp;
 342   struct ripng_interface *ri;
 343
 344   for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
 345     {
 346       ri = ifp->info;
 347
 348       ri->enable_network = 0;
 349       ri->enable_interface = 0;
 350       ri->running = 0;
 351
 352       if (ri->t_wakeup)
 353         {
 354           thread_cancel (ri->t_wakeup);
 355           ri->t_wakeup = NULL;
 356         }
 357     }
 358 }
 359
 360 void
 361 ripng_interface_reset () {
 362   struct listnode *node;
 363   struct interface *ifp;
 364   struct ripng_interface *ri;
 365
 366   for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
 367     {
 368       ri = ifp->info;
 369
 370       ri->enable_network = 0;
 371       ri->enable_interface = 0;
 372       ri->running = 0;
 373
 374       ri->split_horizon = RIPNG_NO_SPLIT_HORIZON;
 375       ri->split_horizon_default = RIPNG_NO_SPLIT_HORIZON;
 376
 377       ri->list[RIPNG_FILTER_IN] = NULL;
 378       ri->list[RIPNG_FILTER_OUT] = NULL;
 379
 380       ri->prefix[RIPNG_FILTER_IN] = NULL;
 381       ri->prefix[RIPNG_FILTER_OUT] = NULL;
 382
 383       if (ri->t_wakeup)
 384         {
 385           thread_cancel (ri->t_wakeup);
 386           ri->t_wakeup = NULL;
 387         }
 388
 389       ri->passive = 0;
 390     }
 391 }
 392
 393 static void
 394 ripng_apply_address_add (struct connected *ifc) {
 395   struct prefix_ipv6 address;
 396   struct prefix *p;
 397
 398   if (!ripng)
 399     return;
 400
 401   if (! if_is_up(ifc->ifp))
 402     return;
 403
 404   p = ifc->address;
 405
 406   memset (&address, 0, sizeof (address));
 407   address.family = p->family;
 408   address.prefix = p->u.prefix6;
 409   address.prefixlen = p->prefixlen;
 410   apply_mask_ipv6(&address);
 411
 412   /* Check if this interface is RIP enabled or not
 413      or  Check if this address's prefix is RIP enabled */
 414   if ((ripng_enable_if_lookup(ifc->ifp->name) >= 0) ||
 415       (ripng_enable_network_lookup2(ifc) >= 0))
 416     ripng_redistribute_add(ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
 417                            &address, ifc->ifp->ifindex, NULL);
 418
 419 }
 420
 421 int
 422 ripng_interface_address_add (int command, struct zclient *zclient,
 423                              zebra_size_t length)
 424 {
 425   struct connected *c;
 426   struct prefix *p;
 427
 428   c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
 429                                     zclient->ibuf);
 430
 431   if (c == NULL)
 432     return 0;
 433
 434   p = c->address;
 435
 436   if (p->family == AF_INET6)
 437     {
 438       struct ripng_interface *ri = c->ifp->info;
 439
 440       if (IS_RIPNG_DEBUG_ZEBRA)
 441         zlog_debug ("RIPng connected address %s/%d add",
 442                    inet6_ntoa(p->u.prefix6),
 443                    p->prefixlen);
 444
 445       /* Check is this prefix needs to be redistributed. */
 446       ripng_apply_address_add(c);
 447
 448       /* Let's try once again whether the interface could be activated */
 449       if (!ri->running) {
 450         /* Check if this interface is RIP enabled or not.*/
 451         ripng_enable_apply (c->ifp);
 452
 453         /* Apply distribute list to the interface. */
 454         ripng_distribute_update_interface (c->ifp);
 455
 456         /* Check interface routemap. */
 457         ripng_if_rmap_update_interface (c->ifp);
 458       }
 459
 460     }
 461
 462   return 0;
 463 }
 464
 465 static void
 466 ripng_apply_address_del (struct connected *ifc) {
 467   struct prefix_ipv6 address;
 468   struct prefix *p;
 469
 470   if (!ripng)
 471     return;
 472
 473   if (! if_is_up(ifc->ifp))
 474     return;
 475
 476   p = ifc->address;
 477
 478   memset (&address, 0, sizeof (address));
 479   address.family = p->family;
 480   address.prefix = p->u.prefix6;
 481   address.prefixlen = p->prefixlen;
 482   apply_mask_ipv6(&address);
 483
 484   ripng_redistribute_delete(ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
 485                             &address, ifc->ifp->ifindex);
 486 }
 487
 488 int
 489 ripng_interface_address_delete (int command, struct zclient *zclient,
 490                                 zebra_size_t length)
 491 {
 492   struct connected *ifc;
 493   struct prefix *p;
 494   char buf[INET6_ADDRSTRLEN];
 495
 496   ifc = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
 497                                       zclient->ibuf);
 498
 499   if (ifc)
 500     {
 501       p = ifc->address;
 502
 503       if (p->family == AF_INET6)
 504         {
 505           if (IS_RIPNG_DEBUG_ZEBRA)
 506             zlog_debug ("RIPng connected address %s/%d delete",
 507                        inet_ntop (AF_INET6, &p->u.prefix6, buf,
 508                                   INET6_ADDRSTRLEN),
 509                        p->prefixlen);
 510
 511           /* Check wether this prefix needs to be removed. */
 512           ripng_apply_address_del(ifc);
 513         }
 514       connected_free (ifc);
 515     }
 516
 517   return 0;
 518 }
 519 \f
 520 /* RIPng enable interface vector. */
 521 vector ripng_enable_if;
 522
 523 /* RIPng enable network table. */
 524 struct route_table *ripng_enable_network;
 525
 526 /* Lookup RIPng enable network. */
 527 /* Check wether the interface has at least a connected prefix that
 528  * is within the ripng_enable_network table. */
 529 int
 530 ripng_enable_network_lookup_if (struct interface *ifp)
 531 {
 532   struct listnode *node;
 533   struct connected *connected;
 534   struct prefix_ipv6 address;
 535
 536   for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, connected))
 537     {
 538       struct prefix *p;
 539       struct route_node *node;
 540
 541       p = connected->address;
 542
 543       if (p->family == AF_INET6)
 544         {
 545           address.family = AF_INET6;
 546           address.prefix = p->u.prefix6;
 547           address.prefixlen = IPV6_MAX_BITLEN;
 548
 549           node = route_node_match (ripng_enable_network,
 550                                    (struct prefix *)&address);
 551           if (node)
 552             {
 553               route_unlock_node (node);
 554               return 1;
 555             }
 556         }
 557     }
 558   return -1;
 559 }
 560
 561 /* Check wether connected is within the ripng_enable_network table. */
 562 int
 563 ripng_enable_network_lookup2 (struct connected *connected)
 564 {
 565   struct prefix_ipv6 address;
 566   struct prefix *p;
 567
 568   p = connected->address;
 569
 570   if (p->family == AF_INET6) {
 571     struct route_node *node;
 572
 573     address.family = p->family;
 574     address.prefix = p->u.prefix6;
 575     address.prefixlen = IPV6_MAX_BITLEN;
 576
 577     /* LPM on p->family, p->u.prefix6/IPV6_MAX_BITLEN within ripng_enable_network */
 578     node = route_node_match (ripng_enable_network,
 579                              (struct prefix *)&address);
 580
 581     if (node) {
 582       route_unlock_node (node);
 583       return 1;
 584     }
 585   }
 586
 587   return -1;
 588 }
 589
 590 /* Add RIPng enable network. */
 591 int
 592 ripng_enable_network_add (struct prefix *p)
 593 {
 594   struct route_node *node;
 595
 596   node = route_node_get (ripng_enable_network, p);
 597
 598   if (node->info)
 599     {
 600       route_unlock_node (node);
 601       return -1;
 602     }
 603   else
 604     node->info = (char *) "enabled";
 605
 606   /* XXX: One should find a better solution than a generic one */
 607   ripng_enable_apply_all();
 608
 609   return 1;
 610 }
 611
 612 /* Delete RIPng enable network. */
 613 int
 614 ripng_enable_network_delete (struct prefix *p)
 615 {
 616   struct route_node *node;
 617
 618   node = route_node_lookup (ripng_enable_network, p);
 619   if (node)
 620     {
 621       node->info = NULL;
 622
 623       /* Unlock info lock. */
 624       route_unlock_node (node);
 625
 626       /* Unlock lookup lock. */
 627       route_unlock_node (node);
 628
 629       return 1;
 630     }
 631   return -1;
 632 }
 633
 634 /* Lookup function. */
 635 int
 636 ripng_enable_if_lookup (const char *ifname)
 637 {
 638   unsigned int i;
 639   char *str;
 640
 641   for (i = 0; i < vector_active (ripng_enable_if); i++)
 642     if ((str = vector_slot (ripng_enable_if, i)) != NULL)
 643       if (strcmp (str, ifname) == 0)
 644         return i;
 645   return -1;
 646 }
 647
 648 /* Add interface to ripng_enable_if. */
 649 int
 650 ripng_enable_if_add (const char *ifname)
 651 {
 652   int ret;
 653
 654   ret = ripng_enable_if_lookup (ifname);
 655   if (ret >= 0)
 656     return -1;
 657
 658   vector_set (ripng_enable_if, strdup (ifname));
 659
 660   ripng_enable_apply_all();
 661
 662   return 1;
 663 }
 664
 665 /* Delete interface from ripng_enable_if. */
 666 int
 667 ripng_enable_if_delete (const char *ifname)
 668 {
 669   int index;
 670   char *str;
 671
 672   index = ripng_enable_if_lookup (ifname);
 673   if (index < 0)
 674     return -1;
 675
 676   str = vector_slot (ripng_enable_if, index);
 677   free (str);
 678   vector_unset (ripng_enable_if, index);
 679
 680   ripng_enable_apply_all();
 681
 682   return 1;
 683 }
 684
 685 /* Wake up interface. */
 686 int
 687 ripng_interface_wakeup (struct thread *t)
 688 {
 689   struct interface *ifp;
 690   struct ripng_interface *ri;
 691
 692   /* Get interface. */
 693   ifp = THREAD_ARG (t);
 694
 695   ri = ifp->info;
 696   ri->t_wakeup = NULL;
 697
 698   /* Join to multicast group. */
 699   if (ripng_multicast_join (ifp) < 0) {
 700     zlog_err ("multicast join failed, interface %s not running", ifp->name);
 701     return 0;
 702   }
 703
 704   /* Set running flag. */
 705   ri->running = 1;
 706
 707   /* Send RIP request to the interface. */
 708   ripng_request (ifp);
 709
 710   return 0;
 711 }
 712
 713 int ripng_redistribute_check (int);
 714
 715 void
 716 ripng_connect_set (struct interface *ifp, int set)
 717 {
 718   struct listnode *node, *nnode;
 719   struct connected *connected;
 720   struct prefix_ipv6 address;
 721
 722   for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, connected))
 723     {
 724       struct prefix *p;
 725       p = connected->address;
 726
 727       if (p->family != AF_INET6)
 728         continue;
 729
 730       address.family = AF_INET6;
 731       address.prefix = p->u.prefix6;
 732       address.prefixlen = p->prefixlen;
 733       apply_mask_ipv6 (&address);
 734
 735       if (set) {
 736         /* Check once more wether this prefix is within a "network IF_OR_PREF" one */
 737         if ((ripng_enable_if_lookup(connected->ifp->name) >= 0) ||
 738             (ripng_enable_network_lookup2(connected) >= 0))
 739           ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
 740                                   &address, connected->ifp->ifindex, NULL);
 741       } else {
 742         ripng_redistribute_delete (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
 743                                    &address, connected->ifp->ifindex);
 744         if (ripng_redistribute_check (ZEBRA_ROUTE_CONNECT))
 745           ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_REDISTRIBUTE,
 746                                   &address, connected->ifp->ifindex, NULL);
 747       }
 748     }
 749 }
 750
 751 /* Check RIPng is enabed on this interface. */
 752 void
 753 ripng_enable_apply (struct interface *ifp)
 754 {
 755   int ret;
 756   struct ripng_interface *ri = NULL;
 757
 758   /* Check interface. */
 759   if (! if_is_up (ifp))
 760     return;
 761
 762   ri = ifp->info;
 763
 764   /* Is this interface a candidate for RIPng ? */
 765   ret = ripng_enable_network_lookup_if (ifp);
 766
 767   /* If the interface is matched. */
 768   if (ret > 0)
 769     ri->enable_network = 1;
 770   else
 771     ri->enable_network = 0;
 772
 773   /* Check interface name configuration. */
 774   ret = ripng_enable_if_lookup (ifp->name);
 775   if (ret >= 0)
 776     ri->enable_interface = 1;
 777   else
 778     ri->enable_interface = 0;
 779
 780   /* any candidate interface MUST have a link-local IPv6 address */
 781   if ((! ripng_if_ipv6_lladdress_check (ifp)) &&
 782       (ri->enable_network || ri->enable_interface)) {
 783     ri->enable_network = 0;
 784     ri->enable_interface = 0;
 785     zlog_warn("Interface %s does not have any link-local address",
 786               ifp->name);
 787   }
 788
 789   /* Update running status of the interface. */
 790   if (ri->enable_network || ri->enable_interface)
 791     {
 792         {
 793           if (IS_RIPNG_DEBUG_EVENT)
 794             zlog_debug ("RIPng turn on %s", ifp->name);
 795
 796           /* Add interface wake up thread. */
 797           if (! ri->t_wakeup)
 798             ri->t_wakeup = thread_add_timer (master, ripng_interface_wakeup,
 799                                              ifp, 1);
 800
 801           ripng_connect_set (ifp, 1);
 802         }
 803     }
 804   else
 805     {
 806       if (ri->running)
 807         {
 808           /* Might as well clean up the route table as well
 809            * ripng_if_down sets to 0 ri->running, and displays "turn off %s"
 810            **/
 811           ripng_if_down(ifp);
 812
 813           ripng_connect_set (ifp, 0);
 814         }
 815     }
 816 }
 817
 818 /* Set distribute list to all interfaces. */
 819 void
 820 ripng_enable_apply_all ()
 821 {
 822   struct interface *ifp;
 823   struct listnode *node;
 824
 825   for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
 826     ripng_enable_apply (ifp);
 827 }
 828 \f
 829 /* Clear all network and neighbor configuration */
 830 void
 831 ripng_clean_network ()
 832 {
 833   unsigned int i;
 834   char *str;
 835   struct route_node *rn;
 836
 837   /* ripng_enable_network */
 838   for (rn = route_top (ripng_enable_network); rn; rn = route_next (rn))
 839     if (rn->info) {
 840       rn->info = NULL;
 841       route_unlock_node(rn);
 842     }
 843
 844   /* ripng_enable_if */
 845   for (i = 0; i < vector_active (ripng_enable_if); i++)
 846     if ((str = vector_slot (ripng_enable_if, i)) != NULL) {
 847       free (str);
 848       vector_slot (ripng_enable_if, i) = NULL;
 849     }
 850 }
 851 \f
 852 /* Vector to store passive-interface name. */
 853 vector Vripng_passive_interface;
 854
 855 /* Utility function for looking up passive interface settings. */
 856 int
 857 ripng_passive_interface_lookup (const char *ifname)
 858 {
 859   unsigned int i;
 860   char *str;
 861
 862   for (i = 0; i < vector_active (Vripng_passive_interface); i++)
 863     if ((str = vector_slot (Vripng_passive_interface, i)) != NULL)
 864       if (strcmp (str, ifname) == 0)
 865         return i;
 866   return -1;
 867 }
 868
 869 void
 870 ripng_passive_interface_apply (struct interface *ifp)
 871 {
 872   int ret;
 873   struct ripng_interface *ri;
 874
 875   ri = ifp->info;
 876
 877   ret = ripng_passive_interface_lookup (ifp->name);
 878   if (ret < 0)
 879     ri->passive = 0;
 880   else
 881     ri->passive = 1;
 882 }
 883
 884 void
 885 ripng_passive_interface_apply_all (void)
 886 {
 887   struct interface *ifp;
 888   struct listnode *node;
 889
 890   for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
 891     ripng_passive_interface_apply (ifp);
 892 }
 893
 894 /* Passive interface. */
 895 int
 896 ripng_passive_interface_set (struct vty *vty, const char *ifname)
 897 {
 898   if (ripng_passive_interface_lookup (ifname) >= 0)
 899     return CMD_WARNING;
 900
 901   vector_set (Vripng_passive_interface, strdup (ifname));
 902
 903   ripng_passive_interface_apply_all ();
 904
 905   return CMD_SUCCESS;
 906 }
 907
 908 int
 909 ripng_passive_interface_unset (struct vty *vty, const char *ifname)
 910 {
 911   int i;
 912   char *str;
 913
 914   i = ripng_passive_interface_lookup (ifname);
 915   if (i < 0)
 916     return CMD_WARNING;
 917
 918   str = vector_slot (Vripng_passive_interface, i);
 919   free (str);
 920   vector_unset (Vripng_passive_interface, i);
 921
 922   ripng_passive_interface_apply_all ();
 923
 924   return CMD_SUCCESS;
 925 }
 926
 927 /* Free all configured RIP passive-interface settings. */
 928 void
 929 ripng_passive_interface_clean (void)
 930 {
 931   unsigned int i;
 932   char *str;
 933
 934   for (i = 0; i < vector_active (Vripng_passive_interface); i++)
 935     if ((str = vector_slot (Vripng_passive_interface, i)) != NULL)
 936       {
 937         free (str);
 938         vector_slot (Vripng_passive_interface, i) = NULL;
 939       }
 940   ripng_passive_interface_apply_all ();
 941 }
 942
 943 /* Write RIPng enable network and interface to the vty. */
 944 int
 945 ripng_network_write (struct vty *vty, int config_mode)
 946 {
 947   unsigned int i;
 948   const char *ifname;
 949   struct route_node *node;
 950   char buf[BUFSIZ];
 951
 952   /* Write enable network. */
 953   for (node = route_top (ripng_enable_network); node; node = route_next (node))
 954     if (node->info)
 955       {
 956         struct prefix *p = &node->p;
 957         vty_out (vty, "%s%s/%d%s",
 958                  config_mode ? " network " : "    ",
 959                  inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
 960                  p->prefixlen,
 961                  VTY_NEWLINE);
 962
 963       }
 964
 965   /* Write enable interface. */
 966   for (i = 0; i < vector_active (ripng_enable_if); i++)
 967     if ((ifname = vector_slot (ripng_enable_if, i)) != NULL)
 968       vty_out (vty, "%s%s%s",
 969                config_mode ? " network " : "    ",
 970                ifname,
 971                VTY_NEWLINE);
 972
 973   /* Write passive interface. */
 974   if (config_mode)
 975     for (i = 0; i < vector_active (Vripng_passive_interface); i++)
 976       if ((ifname = vector_slot (Vripng_passive_interface, i)) != NULL)
 977         vty_out (vty, " passive-interface %s%s", ifname, VTY_NEWLINE);
 978
 979   return 0;
 980 }
 981
 982 /* RIPng enable on specified interface or matched network. */
 983 DEFUN (ripng_network,
 984        ripng_network_cmd,
 985        "network IF_OR_ADDR",
 986        "RIPng enable on specified interface or network.\n"
 987        "Interface or address")
 988 {
 989   int ret;
 990   struct prefix p;
 991
 992   ret = str2prefix (argv[0], &p);
 993
 994   /* Given string is IPv6 network or interface name. */
 995   if (ret)
 996     ret = ripng_enable_network_add (&p);
 997   else
 998     ret = ripng_enable_if_add (argv[0]);
 999
1000   if (ret < 0)
1001     {
1002       vty_out (vty, "There is same network configuration %s%s", argv[0],
1003                VTY_NEWLINE);
1004       return CMD_WARNING;
1005     }
1006
1007   return CMD_SUCCESS;
1008 }
1009
1010 /* RIPng enable on specified interface or matched network. */
1011 DEFUN (no_ripng_network,
1012        no_ripng_network_cmd,
1013        "no network IF_OR_ADDR",
1014        NO_STR
1015        "RIPng enable on specified interface or network.\n"
1016        "Interface or address")
1017 {
1018   int ret;
1019   struct prefix p;
1020
1021   ret = str2prefix (argv[0], &p);
1022
1023   /* Given string is interface name. */
1024   if (ret)
1025     ret = ripng_enable_network_delete (&p);
1026   else
1027     ret = ripng_enable_if_delete (argv[0]);
1028
1029   if (ret < 0)
1030     {
1031       vty_out (vty, "can't find network %s%s", argv[0],
1032                VTY_NEWLINE);
1033       return CMD_WARNING;
1034     }
1035
1036   return CMD_SUCCESS;
1037 }
1038
1039 DEFUN (ipv6_ripng_split_horizon,
1040        ipv6_ripng_split_horizon_cmd,
1041        "ipv6 ripng split-horizon",
1042        IPV6_STR
1043        "Routing Information Protocol\n"
1044        "Perform split horizon\n")
1045 {
1046   struct interface *ifp;
1047   struct ripng_interface *ri;
1048
1049   ifp = vty->index;
1050   ri = ifp->info;
1051
1052   ri->split_horizon = RIPNG_SPLIT_HORIZON;
1053   return CMD_SUCCESS;
1054 }
1055
1056 DEFUN (ipv6_ripng_split_horizon_poisoned_reverse,
1057        ipv6_ripng_split_horizon_poisoned_reverse_cmd,
1058        "ipv6 ripng split-horizon poisoned-reverse",
1059        IPV6_STR
1060        "Routing Information Protocol\n"
1061        "Perform split horizon\n"
1062        "With poisoned-reverse\n")
1063 {
1064   struct interface *ifp;
1065   struct ripng_interface *ri;
1066
1067   ifp = vty->index;
1068   ri = ifp->info;
1069
1070   ri->split_horizon = RIPNG_SPLIT_HORIZON_POISONED_REVERSE;
1071   return CMD_SUCCESS;
1072 }
1073
1074 DEFUN (no_ipv6_ripng_split_horizon,
1075        no_ipv6_ripng_split_horizon_cmd,
1076        "no ipv6 ripng split-horizon",
1077        NO_STR
1078        IPV6_STR
1079        "Routing Information Protocol\n"
1080        "Perform split horizon\n")
1081 {
1082   struct interface *ifp;
1083   struct ripng_interface *ri;
1084
1085   ifp = vty->index;
1086   ri = ifp->info;
1087
1088   ri->split_horizon = RIPNG_NO_SPLIT_HORIZON;
1089   return CMD_SUCCESS;
1090 }
1091
1092 ALIAS (no_ipv6_ripng_split_horizon,
1093        no_ipv6_ripng_split_horizon_poisoned_reverse_cmd,
1094        "no ipv6 ripng split-horizon poisoned-reverse",
1095        NO_STR
1096        IPV6_STR
1097        "Routing Information Protocol\n"
1098        "Perform split horizon\n"
1099        "With poisoned-reverse\n")
1100
1101 DEFUN (ripng_passive_interface,
1102        ripng_passive_interface_cmd,
1103        "passive-interface IFNAME",
1104        "Suppress routing updates on an interface\n"
1105        "Interface name\n")
1106 {
1107   return ripng_passive_interface_set (vty, argv[0]);
1108 }
1109
1110 DEFUN (no_ripng_passive_interface,
1111        no_ripng_passive_interface_cmd,
1112        "no passive-interface IFNAME",
1113        NO_STR
1114        "Suppress routing updates on an interface\n"
1115        "Interface name\n")
1116 {
1117   return ripng_passive_interface_unset (vty, argv[0]);
1118 }
1119 \f
1120 struct ripng_interface *
1121 ri_new ()
1122 {
1123   struct ripng_interface *ri;
1124   ri = XCALLOC (MTYPE_IF, sizeof (struct ripng_interface));
1125
1126   /* Set default split-horizon behavior.  If the interface is Frame
1127      Relay or SMDS is enabled, the default value for split-horizon is
1128      off.  But currently Zebra does detect Frame Relay or SMDS
1129      interface.  So all interface is set to split horizon.  */
1130   ri->split_horizon_default = RIPNG_SPLIT_HORIZON;
1131   ri->split_horizon = ri->split_horizon_default;
1132
1133   return ri;
1134 }
1135
1136 int
1137 ripng_if_new_hook (struct interface *ifp)
1138 {
1139   ifp->info = ri_new ();
1140   return 0;
1141 }
1142
1143 /* Called when interface structure deleted. */
1144 int
1145 ripng_if_delete_hook (struct interface *ifp)
1146 {
1147   XFREE (MTYPE_IF, ifp->info);
1148   ifp->info = NULL;
1149   return 0;
1150 }
1151
1152 /* Configuration write function for ripngd. */
1153 int
1154 interface_config_write (struct vty *vty)
1155 {
1156   struct listnode *node;
1157   struct interface *ifp;
1158   struct ripng_interface *ri;
1159   int write = 0;
1160
1161   for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
1162     {
1163       ri = ifp->info;
1164
1165       /* Do not display the interface if there is no
1166        * configuration about it.
1167        **/
1168       if ((!ifp->desc) &&
1169           (ri->split_horizon == ri->split_horizon_default))
1170         continue;
1171
1172       vty_out (vty, "interface %s%s", ifp->name,
1173                VTY_NEWLINE);
1174       if (ifp->desc)
1175         vty_out (vty, " description %s%s", ifp->desc,
1176                  VTY_NEWLINE);
1177
1178       /* Split horizon. */
1179       if (ri->split_horizon != ri->split_horizon_default)
1180         {
1181           switch (ri->split_horizon) {
1182           case RIPNG_SPLIT_HORIZON:
1183             vty_out (vty, " ipv6 ripng split-horizon%s", VTY_NEWLINE);
1184             break;
1185           case RIPNG_SPLIT_HORIZON_POISONED_REVERSE:
1186             vty_out (vty, " ipv6 ripng split-horizon poisoned-reverse%s",
1187                           VTY_NEWLINE);
1188             break;
1189           case RIPNG_NO_SPLIT_HORIZON:
1190           default:
1191             vty_out (vty, " no ipv6 ripng split-horizon%s", VTY_NEWLINE);
1192             break;
1193           }
1194         }
1195
1196       vty_out (vty, "!%s", VTY_NEWLINE);
1197
1198       write++;
1199     }
1200   return write;
1201 }
1202
1203 /* ripngd's interface node. */
1204 struct cmd_node interface_node =
1205 {
1206   INTERFACE_NODE,
1207   "%s(config-if)# ",
1208   1 /* VTYSH */
1209 };
1210
1211 /* Initialization of interface. */
1212 void
1213 ripng_if_init ()
1214 {
1215   /* Interface initialize. */
1216   iflist = list_new ();
1217   if_add_hook (IF_NEW_HOOK, ripng_if_new_hook);
1218   if_add_hook (IF_DELETE_HOOK, ripng_if_delete_hook);
1219
1220   /* RIPng enable network init. */
1221   ripng_enable_network = route_table_init ();
1222
1223   /* RIPng enable interface init. */
1224   ripng_enable_if = vector_init (1);
1225
1226   /* RIPng passive interface. */
1227   Vripng_passive_interface = vector_init (1);
1228
1229   /* Install interface node. */
1230   install_node (&interface_node, interface_config_write);
1231
1232   /* Install commands. */
1233   install_element (CONFIG_NODE, &interface_cmd);
1234   install_element (CONFIG_NODE, &no_interface_cmd);
1235   install_default (INTERFACE_NODE);
1236   install_element (INTERFACE_NODE, &interface_desc_cmd);
1237   install_element (INTERFACE_NODE, &no_interface_desc_cmd);
1238
1239   install_element (RIPNG_NODE, &ripng_network_cmd);
1240   install_element (RIPNG_NODE, &no_ripng_network_cmd);
1241   install_element (RIPNG_NODE, &ripng_passive_interface_cmd);
1242   install_element (RIPNG_NODE, &no_ripng_passive_interface_cmd);
1243
1244   install_element (INTERFACE_NODE, &ipv6_ripng_split_horizon_cmd);
1245   install_element (INTERFACE_NODE, &ipv6_ripng_split_horizon_poisoned_reverse_cmd);
1246   install_element (INTERFACE_NODE, &no_ipv6_ripng_split_horizon_cmd);
1247   install_element (INTERFACE_NODE, &no_ipv6_ripng_split_horizon_poisoned_reverse_cmd);
1248 }