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 along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "linklist.h"
  25 #include "if.h"
  26 #include "prefix.h"
  27 #include "memory.h"
  28 #include "network.h"
  29 #include "filter.h"
  30 #include "log.h"
  31 #include "stream.h"
  32 #include "zclient.h"
  33 #include "command.h"
  34 #include "agg_table.h"
  35 #include "thread.h"
  36 #include "privs.h"
  37 #include "vrf.h"
  38 #include "lib_errors.h"
  39 #include "northbound_cli.h"
  40
  41 #include "ripngd/ripngd.h"
  42 #include "ripngd/ripng_debug.h"
  43
  44 /* If RFC2133 definition is used. */
  45 #ifndef IPV6_JOIN_GROUP
  46 #define IPV6_JOIN_GROUP  IPV6_ADD_MEMBERSHIP
  47 #endif
  48 #ifndef IPV6_LEAVE_GROUP
  49 #define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP
  50 #endif
  51
  52 DEFINE_MTYPE_STATIC(RIPNGD, RIPNG_IF, "ripng interface");
  53
  54 /* Static utility function. */
  55 static void ripng_enable_apply(struct interface *);
  56 static void ripng_passive_interface_apply(struct interface *);
  57 static int ripng_enable_if_lookup(struct ripng *ripng, const char *ifname);
  58 static int ripng_enable_network_lookup2(struct connected *);
  59 static void ripng_enable_apply_all(struct ripng *ripng);
  60
  61 /* Join to the all rip routers multicast group. */
  62 static int ripng_multicast_join(struct interface *ifp, int sock)
  63 {
  64         int ret;
  65         struct ipv6_mreq mreq;
  66         int save_errno;
  67
  68         if (if_is_multicast(ifp)) {
  69                 memset(&mreq, 0, sizeof(mreq));
  70                 inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
  71                 mreq.ipv6mr_interface = ifp->ifindex;
  72
  73                 /*
  74                  * NetBSD 1.6.2 requires root to join groups on gif(4).
  75                  * While this is bogus, privs are available and easy to use
  76                  * for this call as a workaround.
  77                  */
  78                 frr_with_privs(&ripngd_privs) {
  79
  80                         ret = setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
  81                                          (char *)&mreq, sizeof(mreq));
  82                         save_errno = errno;
  83
  84                 }
  85
  86                 if (ret < 0 && save_errno == EADDRINUSE) {
  87                         /*
  88                          * Group is already joined.  This occurs due to sloppy
  89                          * group
  90                          * management, in particular declining to leave the
  91                          * group on
  92                          * an interface that has just gone down.
  93                          */
  94                         zlog_warn("ripng join on %s EADDRINUSE (ignoring)",
  95                                   ifp->name);
  96                         return 0; /* not an error */
  97                 }
  98
  99                 if (ret < 0)
 100                         zlog_warn("can't setsockopt IPV6_JOIN_GROUP: %s",
 101                                   safe_strerror(save_errno));
 102
 103                 if (IS_RIPNG_DEBUG_EVENT)
 104                         zlog_debug(
 105                                 "RIPng %s join to all-rip-routers multicast group",
 106                                 ifp->name);
 107
 108                 if (ret < 0)
 109                         return -1;
 110         }
 111         return 0;
 112 }
 113
 114 /* Leave from the all rip routers multicast group. */
 115 static int ripng_multicast_leave(struct interface *ifp, int sock)
 116 {
 117         int ret;
 118         struct ipv6_mreq mreq;
 119
 120         if (if_is_multicast(ifp)) {
 121                 memset(&mreq, 0, sizeof(mreq));
 122                 inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
 123                 mreq.ipv6mr_interface = ifp->ifindex;
 124
 125                 ret = setsockopt(sock, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
 126                                  (char *)&mreq, sizeof(mreq));
 127                 if (ret < 0)
 128                         zlog_warn("can't setsockopt IPV6_LEAVE_GROUP: %s",
 129                                   safe_strerror(errno));
 130
 131                 if (IS_RIPNG_DEBUG_EVENT)
 132                         zlog_debug(
 133                                 "RIPng %s leave from all-rip-routers multicast group",
 134                                 ifp->name);
 135
 136                 if (ret < 0)
 137                         return -1;
 138         }
 139
 140         return 0;
 141 }
 142
 143 /* How many link local IPv6 address could be used on the interface ? */
 144 static int ripng_if_ipv6_lladdress_check(struct interface *ifp)
 145 {
 146         struct listnode *nn;
 147         struct connected *connected;
 148         int count = 0;
 149
 150         for (ALL_LIST_ELEMENTS_RO(ifp->connected, nn, connected)) {
 151                 struct prefix *p;
 152                 p = connected->address;
 153
 154                 if ((p->family == AF_INET6)
 155                     && IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
 156                         count++;
 157         }
 158
 159         return count;
 160 }
 161
 162 static int ripng_if_down(struct interface *ifp)
 163 {
 164         struct agg_node *rp;
 165         struct ripng_info *rinfo;
 166         struct ripng_interface *ri;
 167         struct ripng *ripng;
 168         struct list *list = NULL;
 169         struct listnode *listnode = NULL, *nextnode = NULL;
 170
 171         ri = ifp->info;
 172
 173         THREAD_OFF(ri->t_wakeup);
 174
 175         ripng = ri->ripng;
 176
 177         if (ripng)
 178                 for (rp = agg_route_top(ripng->table); rp;
 179                      rp = agg_route_next(rp))
 180                         if ((list = rp->info) != NULL)
 181                                 for (ALL_LIST_ELEMENTS(list, listnode, nextnode,
 182                                                        rinfo))
 183                                         if (rinfo->ifindex == ifp->ifindex)
 184                                                 ripng_ecmp_delete(ripng, rinfo);
 185
 186
 187         if (ri->running) {
 188                 if (IS_RIPNG_DEBUG_EVENT)
 189                         zlog_debug("turn off %s", ifp->name);
 190
 191                 /* Leave from multicast group. */
 192                 if (ripng)
 193                         ripng_multicast_leave(ifp, ripng->sock);
 194
 195                 ri->running = 0;
 196         }
 197
 198         return 0;
 199 }
 200
 201 /* Interface link up message processing. */
 202 static int ripng_ifp_up(struct interface *ifp)
 203 {
 204         if (IS_RIPNG_DEBUG_ZEBRA)
 205                 zlog_debug(
 206                         "interface up %s vrf %s(%u) index %d flags %llx metric %d mtu %d",
 207                         ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
 208                         ifp->ifindex, (unsigned long long)ifp->flags,
 209                         ifp->metric, ifp->mtu6);
 210
 211         ripng_interface_sync(ifp);
 212
 213         /* Check if this interface is RIPng enabled or not. */
 214         ripng_enable_apply(ifp);
 215
 216         /* Check for a passive interface. */
 217         ripng_passive_interface_apply(ifp);
 218
 219         /* Apply distribute list to the all interface. */
 220         ripng_distribute_update_interface(ifp);
 221
 222         return 0;
 223 }
 224
 225 /* Interface link down message processing. */
 226 static int ripng_ifp_down(struct interface *ifp)
 227 {
 228         ripng_interface_sync(ifp);
 229         ripng_if_down(ifp);
 230
 231         if (IS_RIPNG_DEBUG_ZEBRA)
 232                 zlog_debug(
 233                         "interface down %s vrf %s(%u) index %d flags %#llx metric %d mtu %d",
 234                         ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
 235                         ifp->ifindex, (unsigned long long)ifp->flags,
 236                         ifp->metric, ifp->mtu6);
 237
 238         return 0;
 239 }
 240
 241 /* Interface addition message from zebra. */
 242 static int ripng_ifp_create(struct interface *ifp)
 243 {
 244         ripng_interface_sync(ifp);
 245
 246         if (IS_RIPNG_DEBUG_ZEBRA)
 247                 zlog_debug(
 248                         "RIPng interface add %s vrf %s(%u) index %d flags %#llx metric %d mtu %d",
 249                         ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
 250                         ifp->ifindex, (unsigned long long)ifp->flags,
 251                         ifp->metric, ifp->mtu6);
 252
 253         /* Check is this interface is RIP enabled or not.*/
 254         ripng_enable_apply(ifp);
 255
 256         /* Apply distribute list to the interface. */
 257         ripng_distribute_update_interface(ifp);
 258
 259         /* Check interface routemap. */
 260         ripng_if_rmap_update_interface(ifp);
 261
 262         return 0;
 263 }
 264
 265 static int ripng_ifp_destroy(struct interface *ifp)
 266 {
 267         ripng_interface_sync(ifp);
 268         if (if_is_up(ifp)) {
 269                 ripng_if_down(ifp);
 270         }
 271
 272         if (IS_RIPNG_DEBUG_ZEBRA)
 273                 zlog_debug(
 274                         "interface delete %s vrf %s(%u) index %d flags %#llx metric %d mtu %d",
 275                         ifp->name, ifp->vrf->name, ifp->vrf->vrf_id,
 276                         ifp->ifindex, (unsigned long long)ifp->flags,
 277                         ifp->metric, ifp->mtu6);
 278
 279         return 0;
 280 }
 281
 282 /* VRF update for an interface. */
 283 int ripng_interface_vrf_update(ZAPI_CALLBACK_ARGS)
 284 {
 285         struct interface *ifp;
 286         vrf_id_t new_vrf_id;
 287
 288         ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
 289                                               &new_vrf_id);
 290         if (!ifp)
 291                 return 0;
 292
 293         if (IS_RIPNG_DEBUG_ZEBRA) {
 294                 struct vrf *nvrf = vrf_lookup_by_id(new_vrf_id);
 295
 296                 zlog_debug("interface %s VRF change vrf %s(%u) new vrf %s(%u)",
 297                            ifp->name, ifp->vrf->name, vrf_id, VRF_LOGNAME(nvrf),
 298                            new_vrf_id);
 299         }
 300
 301         if_update_to_new_vrf(ifp, new_vrf_id);
 302         ripng_interface_sync(ifp);
 303
 304         return 0;
 305 }
 306
 307 void ripng_interface_clean(struct ripng *ripng)
 308 {
 309         struct interface *ifp;
 310         struct ripng_interface *ri;
 311
 312         FOR_ALL_INTERFACES (ripng->vrf, ifp) {
 313                 ri = ifp->info;
 314
 315                 ri->enable_network = 0;
 316                 ri->enable_interface = 0;
 317                 ri->running = 0;
 318
 319                 THREAD_OFF(ri->t_wakeup);
 320         }
 321 }
 322
 323 static void ripng_apply_address_add(struct connected *ifc)
 324 {
 325         struct ripng_interface *ri = ifc->ifp->info;
 326         struct ripng *ripng = ri->ripng;
 327         struct prefix_ipv6 address;
 328         struct prefix *p;
 329
 330         if (!ripng)
 331                 return;
 332
 333         if (!if_is_up(ifc->ifp))
 334                 return;
 335
 336         p = ifc->address;
 337
 338         memset(&address, 0, sizeof(address));
 339         address.family = p->family;
 340         address.prefix = p->u.prefix6;
 341         address.prefixlen = p->prefixlen;
 342         apply_mask_ipv6(&address);
 343
 344         /* Check if this interface is RIP enabled or not
 345            or  Check if this address's prefix is RIP enabled */
 346         if ((ripng_enable_if_lookup(ripng, ifc->ifp->name) >= 0)
 347             || (ripng_enable_network_lookup2(ifc) >= 0))
 348                 ripng_redistribute_add(ripng, ZEBRA_ROUTE_CONNECT,
 349                                        RIPNG_ROUTE_INTERFACE, &address,
 350                                        ifc->ifp->ifindex, NULL, 0);
 351 }
 352
 353 int ripng_interface_address_add(ZAPI_CALLBACK_ARGS)
 354 {
 355         struct connected *c;
 356         struct prefix *p;
 357
 358         c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
 359                                          zclient->ibuf, vrf_id);
 360
 361         if (c == NULL)
 362                 return 0;
 363
 364         p = c->address;
 365
 366         if (p->family == AF_INET6) {
 367                 struct ripng_interface *ri = c->ifp->info;
 368
 369                 if (IS_RIPNG_DEBUG_ZEBRA)
 370                         zlog_debug("RIPng connected address %pFX add", p);
 371
 372                 /* Check is this prefix needs to be redistributed. */
 373                 ripng_apply_address_add(c);
 374
 375                 /* Let's try once again whether the interface could be activated
 376                  */
 377                 if (!ri->running) {
 378                         /* Check if this interface is RIP enabled or not.*/
 379                         ripng_enable_apply(c->ifp);
 380
 381                         /* Apply distribute list to the interface. */
 382                         ripng_distribute_update_interface(c->ifp);
 383
 384                         /* Check interface routemap. */
 385                         ripng_if_rmap_update_interface(c->ifp);
 386                 }
 387         }
 388
 389         return 0;
 390 }
 391
 392 static void ripng_apply_address_del(struct connected *ifc)
 393 {
 394         struct ripng_interface *ri = ifc->ifp->info;
 395         struct ripng *ripng = ri->ripng;
 396         struct prefix_ipv6 address;
 397         struct prefix *p;
 398
 399         if (!ripng)
 400                 return;
 401
 402         if (!if_is_up(ifc->ifp))
 403                 return;
 404
 405         p = ifc->address;
 406
 407         memset(&address, 0, sizeof(address));
 408         address.family = p->family;
 409         address.prefix = p->u.prefix6;
 410         address.prefixlen = p->prefixlen;
 411         apply_mask_ipv6(&address);
 412
 413         ripng_redistribute_delete(ripng, ZEBRA_ROUTE_CONNECT,
 414                                   RIPNG_ROUTE_INTERFACE, &address,
 415                                   ifc->ifp->ifindex);
 416 }
 417
 418 int ripng_interface_address_delete(ZAPI_CALLBACK_ARGS)
 419 {
 420         struct connected *ifc;
 421         struct prefix *p;
 422
 423         ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
 424                                            zclient->ibuf, vrf_id);
 425
 426         if (ifc) {
 427                 p = ifc->address;
 428
 429                 if (p->family == AF_INET6) {
 430                         if (IS_RIPNG_DEBUG_ZEBRA)
 431                                 zlog_debug(
 432                                         "RIPng connected address %pFX delete",
 433                                         p);
 434
 435                         /* Check whether this prefix needs to be removed. */
 436                         ripng_apply_address_del(ifc);
 437                 }
 438                 connected_free(&ifc);
 439         }
 440
 441         return 0;
 442 }
 443
 444 /* Lookup RIPng enable network. */
 445 /* Check whether the interface has at least a connected prefix that
 446  * is within the ripng->enable_network table. */
 447 static int ripng_enable_network_lookup_if(struct interface *ifp)
 448 {
 449         struct ripng_interface *ri = ifp->info;
 450         struct ripng *ripng = ri->ripng;
 451         struct listnode *node;
 452         struct connected *connected;
 453         struct prefix_ipv6 address;
 454
 455         if (!ripng)
 456                 return -1;
 457
 458         for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, connected)) {
 459                 struct prefix *p;
 460                 struct agg_node *n;
 461
 462                 p = connected->address;
 463
 464                 if (p->family == AF_INET6) {
 465                         address.family = AF_INET6;
 466                         address.prefix = p->u.prefix6;
 467                         address.prefixlen = IPV6_MAX_BITLEN;
 468
 469                         n = agg_node_match(ripng->enable_network,
 470                                            (struct prefix *)&address);
 471                         if (n) {
 472                                 agg_unlock_node(n);
 473                                 return 1;
 474                         }
 475                 }
 476         }
 477         return -1;
 478 }
 479
 480 /* Check whether connected is within the ripng->enable_network table. */
 481 static int ripng_enable_network_lookup2(struct connected *connected)
 482 {
 483         struct ripng_interface *ri = connected->ifp->info;
 484         struct ripng *ripng = ri->ripng;
 485         struct prefix_ipv6 address;
 486         struct prefix *p;
 487
 488         if (!ripng)
 489                 return -1;
 490
 491         p = connected->address;
 492
 493         if (p->family == AF_INET6) {
 494                 struct agg_node *node;
 495
 496                 address.family = p->family;
 497                 address.prefix = p->u.prefix6;
 498                 address.prefixlen = IPV6_MAX_BITLEN;
 499
 500                 /* LPM on p->family, p->u.prefix6/IPV6_MAX_BITLEN within
 501                  * ripng->enable_network */
 502                 node = agg_node_match(ripng->enable_network,
 503                                       (struct prefix *)&address);
 504
 505                 if (node) {
 506                         agg_unlock_node(node);
 507                         return 1;
 508                 }
 509         }
 510
 511         return -1;
 512 }
 513
 514 /* Add RIPng enable network. */
 515 int ripng_enable_network_add(struct ripng *ripng, struct prefix *p)
 516 {
 517         struct agg_node *node;
 518
 519         node = agg_node_get(ripng->enable_network, p);
 520
 521         if (node->info) {
 522                 agg_unlock_node(node);
 523                 return NB_ERR_INCONSISTENCY;
 524         } else
 525                 node->info = (void *)1;
 526
 527         /* XXX: One should find a better solution than a generic one */
 528         ripng_enable_apply_all(ripng);
 529
 530         return NB_OK;
 531 }
 532
 533 /* Delete RIPng enable network. */
 534 int ripng_enable_network_delete(struct ripng *ripng, struct prefix *p)
 535 {
 536         struct agg_node *node;
 537
 538         node = agg_node_lookup(ripng->enable_network, p);
 539         if (node) {
 540                 node->info = NULL;
 541
 542                 /* Unlock info lock. */
 543                 agg_unlock_node(node);
 544
 545                 /* Unlock lookup lock. */
 546                 agg_unlock_node(node);
 547
 548                 return NB_OK;
 549         }
 550
 551         return NB_ERR_INCONSISTENCY;
 552 }
 553
 554 /* Lookup function. */
 555 static int ripng_enable_if_lookup(struct ripng *ripng, const char *ifname)
 556 {
 557         unsigned int i;
 558         char *str;
 559
 560         if (!ripng)
 561                 return -1;
 562
 563         for (i = 0; i < vector_active(ripng->enable_if); i++)
 564                 if ((str = vector_slot(ripng->enable_if, i)) != NULL)
 565                         if (strcmp(str, ifname) == 0)
 566                                 return i;
 567         return -1;
 568 }
 569
 570 int ripng_enable_if_add(struct ripng *ripng, const char *ifname)
 571 {
 572         int ret;
 573
 574         ret = ripng_enable_if_lookup(ripng, ifname);
 575         if (ret >= 0)
 576                 return NB_ERR_INCONSISTENCY;
 577
 578         vector_set(ripng->enable_if, strdup(ifname));
 579
 580         ripng_enable_apply_all(ripng);
 581
 582         return NB_OK;
 583 }
 584
 585 int ripng_enable_if_delete(struct ripng *ripng, const char *ifname)
 586 {
 587         int index;
 588         char *str;
 589
 590         index = ripng_enable_if_lookup(ripng, ifname);
 591         if (index < 0)
 592                 return NB_ERR_INCONSISTENCY;
 593
 594         str = vector_slot(ripng->enable_if, index);
 595         free(str);
 596         vector_unset(ripng->enable_if, index);
 597
 598         ripng_enable_apply_all(ripng);
 599
 600         return NB_OK;
 601 }
 602
 603 /* Wake up interface. */
 604 static void ripng_interface_wakeup(struct thread *t)
 605 {
 606         struct interface *ifp;
 607         struct ripng_interface *ri;
 608
 609         /* Get interface. */
 610         ifp = THREAD_ARG(t);
 611
 612         ri = ifp->info;
 613
 614         /* Join to multicast group. */
 615         if (ripng_multicast_join(ifp, ri->ripng->sock) < 0) {
 616                 flog_err_sys(EC_LIB_SOCKET,
 617                              "multicast join failed, interface %s not running",
 618                              ifp->name);
 619                 return;
 620         }
 621
 622         /* Set running flag. */
 623         ri->running = 1;
 624
 625         /* Send RIP request to the interface. */
 626         ripng_request(ifp);
 627 }
 628
 629 static void ripng_connect_set(struct interface *ifp, int set)
 630 {
 631         struct ripng_interface *ri = ifp->info;
 632         struct ripng *ripng = ri->ripng;
 633         struct listnode *node, *nnode;
 634         struct connected *connected;
 635         struct prefix_ipv6 address;
 636
 637         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
 638                 struct prefix *p;
 639                 p = connected->address;
 640
 641                 if (p->family != AF_INET6)
 642                         continue;
 643
 644                 address.family = AF_INET6;
 645                 address.prefix = p->u.prefix6;
 646                 address.prefixlen = p->prefixlen;
 647                 apply_mask_ipv6(&address);
 648
 649                 if (set) {
 650                         /* Check once more whether this prefix is within a
 651                          * "network IF_OR_PREF" one */
 652                         if ((ripng_enable_if_lookup(ripng, connected->ifp->name)
 653                              >= 0)
 654                             || (ripng_enable_network_lookup2(connected) >= 0))
 655                                 ripng_redistribute_add(
 656                                         ripng, ZEBRA_ROUTE_CONNECT,
 657                                         RIPNG_ROUTE_INTERFACE, &address,
 658                                         connected->ifp->ifindex, NULL, 0);
 659                 } else {
 660                         ripng_redistribute_delete(ripng, ZEBRA_ROUTE_CONNECT,
 661                                                   RIPNG_ROUTE_INTERFACE,
 662                                                   &address,
 663                                                   connected->ifp->ifindex);
 664                         if (ripng_redistribute_check(ripng,
 665                                                      ZEBRA_ROUTE_CONNECT))
 666                                 ripng_redistribute_add(
 667                                         ripng, ZEBRA_ROUTE_CONNECT,
 668                                         RIPNG_ROUTE_REDISTRIBUTE, &address,
 669                                         connected->ifp->ifindex, NULL, 0);
 670                 }
 671         }
 672 }
 673
 674 /* Check RIPng is enabed on this interface. */
 675 void ripng_enable_apply(struct interface *ifp)
 676 {
 677         int ret;
 678         struct ripng_interface *ri = NULL;
 679
 680         /* Check interface. */
 681         if (!if_is_up(ifp))
 682                 return;
 683
 684         ri = ifp->info;
 685
 686         /* Is this interface a candidate for RIPng ? */
 687         ret = ripng_enable_network_lookup_if(ifp);
 688
 689         /* If the interface is matched. */
 690         if (ret > 0)
 691                 ri->enable_network = 1;
 692         else
 693                 ri->enable_network = 0;
 694
 695         /* Check interface name configuration. */
 696         ret = ripng_enable_if_lookup(ri->ripng, ifp->name);
 697         if (ret >= 0)
 698                 ri->enable_interface = 1;
 699         else
 700                 ri->enable_interface = 0;
 701
 702         /* any candidate interface MUST have a link-local IPv6 address */
 703         if ((!ripng_if_ipv6_lladdress_check(ifp))
 704             && (ri->enable_network || ri->enable_interface)) {
 705                 ri->enable_network = 0;
 706                 ri->enable_interface = 0;
 707                 zlog_warn("Interface %s does not have any link-local address",
 708                           ifp->name);
 709         }
 710
 711         /* Update running status of the interface. */
 712         if (ri->enable_network || ri->enable_interface) {
 713                 zlog_info("RIPng INTERFACE ON %s", ifp->name);
 714
 715                 /* Add interface wake up thread. */
 716                 thread_add_timer(master, ripng_interface_wakeup, ifp, 1,
 717                                  &ri->t_wakeup);
 718
 719                 ripng_connect_set(ifp, 1);
 720         } else {
 721                 if (ri->running) {
 722                         /* Might as well clean up the route table as well
 723                          * ripng_if_down sets to 0 ri->running, and displays
 724                          *"turn off %s"
 725                          **/
 726                         ripng_if_down(ifp);
 727
 728                         ripng_connect_set(ifp, 0);
 729                 }
 730         }
 731 }
 732
 733 /* Set distribute list to all interfaces. */
 734 static void ripng_enable_apply_all(struct ripng *ripng)
 735 {
 736         struct interface *ifp;
 737
 738         FOR_ALL_INTERFACES (ripng->vrf, ifp)
 739                 ripng_enable_apply(ifp);
 740 }
 741
 742 /* Clear all network and neighbor configuration */
 743 void ripng_clean_network(struct ripng *ripng)
 744 {
 745         unsigned int i;
 746         char *str;
 747         struct agg_node *rn;
 748
 749         /* ripng->enable_network */
 750         for (rn = agg_route_top(ripng->enable_network); rn;
 751              rn = agg_route_next(rn))
 752                 if (rn->info) {
 753                         rn->info = NULL;
 754                         agg_unlock_node(rn);
 755                 }
 756
 757         /* ripng->enable_if */
 758         for (i = 0; i < vector_active(ripng->enable_if); i++)
 759                 if ((str = vector_slot(ripng->enable_if, i)) != NULL) {
 760                         free(str);
 761                         vector_slot(ripng->enable_if, i) = NULL;
 762                 }
 763 }
 764
 765 /* Utility function for looking up passive interface settings. */
 766 static int ripng_passive_interface_lookup(struct ripng *ripng,
 767                                           const char *ifname)
 768 {
 769         unsigned int i;
 770         char *str;
 771
 772         for (i = 0; i < vector_active(ripng->passive_interface); i++)
 773                 if ((str = vector_slot(ripng->passive_interface, i)) != NULL)
 774                         if (strcmp(str, ifname) == 0)
 775                                 return i;
 776         return -1;
 777 }
 778
 779 void ripng_passive_interface_apply(struct interface *ifp)
 780 {
 781         int ret;
 782         struct ripng_interface *ri;
 783         struct ripng *ripng;
 784
 785         ri = ifp->info;
 786         ripng = ri->ripng;
 787         if (!ripng)
 788                 return;
 789
 790         ret = ripng_passive_interface_lookup(ripng, ifp->name);
 791         if (ret < 0)
 792                 ri->passive = 0;
 793         else
 794                 ri->passive = 1;
 795 }
 796
 797 static void ripng_passive_interface_apply_all(struct ripng *ripng)
 798 {
 799         struct interface *ifp;
 800
 801         FOR_ALL_INTERFACES (ripng->vrf, ifp)
 802                 ripng_passive_interface_apply(ifp);
 803 }
 804
 805 /* Passive interface. */
 806 int ripng_passive_interface_set(struct ripng *ripng, const char *ifname)
 807 {
 808         if (ripng_passive_interface_lookup(ripng, ifname) >= 0)
 809                 return NB_ERR_INCONSISTENCY;
 810
 811         vector_set(ripng->passive_interface, strdup(ifname));
 812
 813         ripng_passive_interface_apply_all(ripng);
 814
 815         return NB_OK;
 816 }
 817
 818 int ripng_passive_interface_unset(struct ripng *ripng, const char *ifname)
 819 {
 820         int i;
 821         char *str;
 822
 823         i = ripng_passive_interface_lookup(ripng, ifname);
 824         if (i < 0)
 825                 return NB_ERR_INCONSISTENCY;
 826
 827         str = vector_slot(ripng->passive_interface, i);
 828         free(str);
 829         vector_unset(ripng->passive_interface, i);
 830
 831         ripng_passive_interface_apply_all(ripng);
 832
 833         return NB_OK;
 834 }
 835
 836 /* Free all configured RIP passive-interface settings. */
 837 void ripng_passive_interface_clean(struct ripng *ripng)
 838 {
 839         unsigned int i;
 840         char *str;
 841
 842         for (i = 0; i < vector_active(ripng->passive_interface); i++)
 843                 if ((str = vector_slot(ripng->passive_interface, i)) != NULL) {
 844                         free(str);
 845                         vector_slot(ripng->passive_interface, i) = NULL;
 846                 }
 847         ripng_passive_interface_apply_all(ripng);
 848 }
 849
 850 /* Write RIPng enable network and interface to the vty. */
 851 int ripng_network_write(struct vty *vty, struct ripng *ripng)
 852 {
 853         unsigned int i;
 854         const char *ifname;
 855         struct agg_node *node;
 856
 857         /* Write enable network. */
 858         for (node = agg_route_top(ripng->enable_network); node;
 859              node = agg_route_next(node))
 860                 if (node->info)
 861                         vty_out(vty, "    %pRN\n", node);
 862
 863         /* Write enable interface. */
 864         for (i = 0; i < vector_active(ripng->enable_if); i++)
 865                 if ((ifname = vector_slot(ripng->enable_if, i)) != NULL)
 866                         vty_out(vty, "    %s\n", ifname);
 867
 868         return 0;
 869 }
 870
 871 static struct ripng_interface *ri_new(void)
 872 {
 873         struct ripng_interface *ri;
 874
 875         ri = XCALLOC(MTYPE_RIPNG_IF, sizeof(struct ripng_interface));
 876
 877         /* Set default split-horizon behavior.  If the interface is Frame
 878            Relay or SMDS is enabled, the default value for split-horizon is
 879            off.  But currently Zebra does detect Frame Relay or SMDS
 880            interface.  So all interface is set to split horizon.  */
 881         ri->split_horizon =
 882                 yang_get_default_enum("%s/split-horizon", RIPNG_IFACE);
 883
 884         return ri;
 885 }
 886
 887 void ripng_interface_sync(struct interface *ifp)
 888 {
 889         struct ripng_interface *ri;
 890
 891         ri = ifp->info;
 892         if (ri)
 893                 ri->ripng = ifp->vrf->info;
 894 }
 895
 896 static int ripng_if_new_hook(struct interface *ifp)
 897 {
 898         ifp->info = ri_new();
 899         ripng_interface_sync(ifp);
 900
 901         return 0;
 902 }
 903
 904 /* Called when interface structure deleted. */
 905 static int ripng_if_delete_hook(struct interface *ifp)
 906 {
 907         XFREE(MTYPE_RIPNG_IF, ifp->info);
 908         return 0;
 909 }
 910
 911 /* Initialization of interface. */
 912 void ripng_if_init(void)
 913 {
 914         /* Interface initialize. */
 915         hook_register_prio(if_add, 0, ripng_if_new_hook);
 916         hook_register_prio(if_del, 0, ripng_if_delete_hook);
 917
 918         /* Install interface node. */
 919         if_cmd_init_default();
 920         if_zapi_callbacks(ripng_ifp_create, ripng_ifp_up,
 921                           ripng_ifp_down, ripng_ifp_destroy);
 922 }