ripd/rip_interface.c

   1 /* Interface related function for RIP.
   2  * Copyright (C) 1997, 98 Kunihiro Ishiguro <kunihiro@zebra.org>
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "if.h"
  25 #include "sockunion.h"
  26 #include "prefix.h"
  27 #include "memory.h"
  28 #include "network.h"
  29 #include "table.h"
  30 #include "log.h"
  31 #include "stream.h"
  32 #include "thread.h"
  33 #include "zclient.h"
  34 #include "filter.h"
  35 #include "sockopt.h"
  36 #include "privs.h"
  37 #include "lib_errors.h"
  38 #include "northbound_cli.h"
  39
  40 #include "zebra/connected.h"
  41
  42 #include "ripd/ripd.h"
  43 #include "ripd/rip_debug.h"
  44 #include "ripd/rip_interface.h"
  45
  46 DEFINE_HOOK(rip_ifaddr_add, (struct connected * ifc), (ifc))
  47 DEFINE_HOOK(rip_ifaddr_del, (struct connected * ifc), (ifc))
  48
  49 /* static prototypes */
  50 static void rip_enable_apply(struct interface *);
  51 static void rip_passive_interface_apply(struct interface *);
  52 static int rip_if_down(struct interface *ifp);
  53 static int rip_enable_if_lookup(const char *ifname);
  54 static int rip_enable_network_lookup2(struct connected *connected);
  55 static void rip_enable_apply_all(void);
  56
  57 const struct message ri_version_msg[] = {{RI_RIP_VERSION_1, "1"},
  58                                          {RI_RIP_VERSION_2, "2"},
  59                                          {RI_RIP_VERSION_1_AND_2, "1 2"},
  60                                          {RI_RIP_VERSION_NONE, "none"},
  61                                          {0}};
  62
  63 /* RIP enabled network vector. */
  64 vector rip_enable_interface;
  65
  66 /* RIP enabled interface table. */
  67 struct route_table *rip_enable_network;
  68
  69 /* Vector to store passive-interface name. */
  70 vector Vrip_passive_nondefault;
  71
  72 /* Join to the RIP version 2 multicast group. */
  73 static int ipv4_multicast_join(int sock, struct in_addr group,
  74                                struct in_addr ifa, ifindex_t ifindex)
  75 {
  76         int ret;
  77
  78         ret = setsockopt_ipv4_multicast(sock, IP_ADD_MEMBERSHIP, ifa,
  79                                         group.s_addr, ifindex);
  80
  81         if (ret < 0)
  82                 zlog_info("can't setsockopt IP_ADD_MEMBERSHIP %s",
  83                           safe_strerror(errno));
  84
  85         return ret;
  86 }
  87
  88 /* Leave from the RIP version 2 multicast group. */
  89 static int ipv4_multicast_leave(int sock, struct in_addr group,
  90                                 struct in_addr ifa, ifindex_t ifindex)
  91 {
  92         int ret;
  93
  94         ret = setsockopt_ipv4_multicast(sock, IP_DROP_MEMBERSHIP, ifa,
  95                                         group.s_addr, ifindex);
  96
  97         if (ret < 0)
  98                 zlog_info("can't setsockopt IP_DROP_MEMBERSHIP");
  99
 100         return ret;
 101 }
 102
 103 static void rip_interface_reset(struct rip_interface *);
 104
 105 /* Allocate new RIP's interface configuration. */
 106 static struct rip_interface *rip_interface_new(void)
 107 {
 108         struct rip_interface *ri;
 109
 110         ri = XCALLOC(MTYPE_RIP_INTERFACE, sizeof(struct rip_interface));
 111
 112         rip_interface_reset(ri);
 113
 114         return ri;
 115 }
 116
 117 void rip_interface_multicast_set(int sock, struct connected *connected)
 118 {
 119         struct in_addr addr;
 120
 121         assert(connected != NULL);
 122
 123         addr = CONNECTED_ID(connected)->u.prefix4;
 124
 125         if (setsockopt_ipv4_multicast_if(sock, addr, connected->ifp->ifindex)
 126             < 0) {
 127                 zlog_warn(
 128                         "Can't setsockopt IP_MULTICAST_IF on fd %d to "
 129                         "ifindex %d for interface %s",
 130                         sock, connected->ifp->ifindex, connected->ifp->name);
 131         }
 132
 133         return;
 134 }
 135
 136 /* Send RIP request packet to specified interface. */
 137 static void rip_request_interface_send(struct interface *ifp, uint8_t version)
 138 {
 139         struct sockaddr_in to;
 140
 141         /* RIPv2 support multicast. */
 142         if (version == RIPv2 && if_is_multicast(ifp)) {
 143
 144                 if (IS_RIP_DEBUG_EVENT)
 145                         zlog_debug("multicast request on %s", ifp->name);
 146
 147                 rip_request_send(NULL, ifp, version, NULL);
 148                 return;
 149         }
 150
 151         /* RIPv1 and non multicast interface. */
 152         if (if_is_pointopoint(ifp) || if_is_broadcast(ifp)) {
 153                 struct listnode *cnode, *cnnode;
 154                 struct connected *connected;
 155
 156                 if (IS_RIP_DEBUG_EVENT)
 157                         zlog_debug("broadcast request to %s", ifp->name);
 158
 159                 for (ALL_LIST_ELEMENTS(ifp->connected, cnode, cnnode,
 160                                        connected)) {
 161                         if (connected->address->family != AF_INET)
 162                                 continue;
 163
 164                         memset(&to, 0, sizeof(struct sockaddr_in));
 165                         to.sin_port = htons(RIP_PORT_DEFAULT);
 166                         if (connected->destination)
 167                                 /* use specified broadcast or peer
 168                                  * destination addr */
 169                                 to.sin_addr = connected->destination->u.prefix4;
 170                         else if (connected->address->prefixlen
 171                                  < IPV4_MAX_PREFIXLEN)
 172                                 /* calculate the appropriate broadcast
 173                                  * address */
 174                                 to.sin_addr.s_addr = ipv4_broadcast_addr(
 175                                         connected->address->u.prefix4.s_addr,
 176                                         connected->address->prefixlen);
 177                         else
 178                                 /* do not know where to send the packet
 179                                  */
 180                                 continue;
 181
 182                         if (IS_RIP_DEBUG_EVENT)
 183                                 zlog_debug("SEND request to %s",
 184                                            inet_ntoa(to.sin_addr));
 185
 186                         rip_request_send(&to, ifp, version, connected);
 187                 }
 188         }
 189 }
 190
 191 /* This will be executed when interface goes up. */
 192 static void rip_request_interface(struct interface *ifp)
 193 {
 194         struct rip_interface *ri;
 195         int vsend;
 196
 197         /* In default ripd doesn't send RIP_REQUEST to the loopback interface.
 198          */
 199         if (if_is_loopback(ifp))
 200                 return;
 201
 202         /* If interface is down, don't send RIP packet. */
 203         if (!if_is_operative(ifp))
 204                 return;
 205
 206         /* Fetch RIP interface information. */
 207         ri = ifp->info;
 208
 209         /* If there is no version configuration in the interface,
 210            use rip's version setting. */
 211         vsend = ((ri->ri_send == RI_RIP_UNSPEC) ? rip->version_send
 212                                                 : ri->ri_send);
 213         if (vsend & RIPv1)
 214                 rip_request_interface_send(ifp, RIPv1);
 215         if (vsend & RIPv2)
 216                 rip_request_interface_send(ifp, RIPv2);
 217 }
 218
 219 #if 0
 220 /* Send RIP request to the neighbor. */
 221 static void
 222 rip_request_neighbor (struct in_addr addr)
 223 {
 224   struct sockaddr_in to;
 225
 226   memset (&to, 0, sizeof (struct sockaddr_in));
 227   to.sin_port = htons (RIP_PORT_DEFAULT);
 228   to.sin_addr = addr;
 229
 230   rip_request_send (&to, NULL, rip->version_send, NULL);
 231 }
 232
 233 /* Request routes at all interfaces. */
 234 static void
 235 rip_request_neighbor_all (void)
 236 {
 237   struct route_node *rp;
 238
 239   if (! rip)
 240     return;
 241
 242   if (IS_RIP_DEBUG_EVENT)
 243     zlog_debug ("request to the all neighbor");
 244
 245   /* Send request to all neighbor. */
 246   for (rp = route_top (rip->neighbor); rp; rp = route_next (rp))
 247     if (rp->info)
 248       rip_request_neighbor (rp->p.u.prefix4);
 249 }
 250 #endif
 251
 252 /* Multicast packet receive socket. */
 253 static int rip_multicast_join(struct interface *ifp, int sock)
 254 {
 255         struct listnode *cnode;
 256         struct connected *ifc;
 257
 258         if (if_is_operative(ifp) && if_is_multicast(ifp)) {
 259                 if (IS_RIP_DEBUG_EVENT)
 260                         zlog_debug("multicast join at %s", ifp->name);
 261
 262                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, ifc)) {
 263                         struct prefix_ipv4 *p;
 264                         struct in_addr group;
 265
 266                         p = (struct prefix_ipv4 *)ifc->address;
 267
 268                         if (p->family != AF_INET)
 269                                 continue;
 270
 271                         group.s_addr = htonl(INADDR_RIP_GROUP);
 272                         if (ipv4_multicast_join(sock, group, p->prefix,
 273                                                 ifp->ifindex)
 274                             < 0)
 275                                 return -1;
 276                         else
 277                                 return 0;
 278                 }
 279         }
 280         return 0;
 281 }
 282
 283 /* Leave from multicast group. */
 284 static void rip_multicast_leave(struct interface *ifp, int sock)
 285 {
 286         struct listnode *cnode;
 287         struct connected *connected;
 288
 289         if (if_is_up(ifp) && if_is_multicast(ifp)) {
 290                 if (IS_RIP_DEBUG_EVENT)
 291                         zlog_debug("multicast leave from %s", ifp->name);
 292
 293                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
 294                         struct prefix_ipv4 *p;
 295                         struct in_addr group;
 296
 297                         p = (struct prefix_ipv4 *)connected->address;
 298
 299                         if (p->family != AF_INET)
 300                                 continue;
 301
 302                         group.s_addr = htonl(INADDR_RIP_GROUP);
 303                         if (ipv4_multicast_leave(sock, group, p->prefix,
 304                                                  ifp->ifindex)
 305                             == 0)
 306                                 return;
 307                 }
 308         }
 309 }
 310
 311 /* Is there and address on interface that I could use ? */
 312 static int rip_if_ipv4_address_check(struct interface *ifp)
 313 {
 314         struct listnode *nn;
 315         struct connected *connected;
 316         int count = 0;
 317
 318         for (ALL_LIST_ELEMENTS_RO(ifp->connected, nn, connected)) {
 319                 struct prefix *p;
 320
 321                 p = connected->address;
 322
 323                 if (p->family == AF_INET)
 324                         count++;
 325         }
 326
 327         return count;
 328 }
 329
 330
 331 /* Does this address belongs to me ? */
 332 int if_check_address(struct in_addr addr)
 333 {
 334         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 335         struct interface *ifp;
 336
 337         FOR_ALL_INTERFACES (vrf, ifp) {
 338                 struct listnode *cnode;
 339                 struct connected *connected;
 340
 341                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, connected)) {
 342                         struct prefix_ipv4 *p;
 343
 344                         p = (struct prefix_ipv4 *)connected->address;
 345
 346                         if (p->family != AF_INET)
 347                                 continue;
 348
 349                         if (IPV4_ADDR_CMP(&p->prefix, &addr) == 0)
 350                                 return 1;
 351                 }
 352         }
 353         return 0;
 354 }
 355
 356 /* Inteface link down message processing. */
 357 int rip_interface_down(int command, struct zclient *zclient,
 358                        zebra_size_t length, vrf_id_t vrf_id)
 359 {
 360         struct interface *ifp;
 361         struct stream *s;
 362
 363         s = zclient->ibuf;
 364
 365         /* zebra_interface_state_read() updates interface structure in
 366            iflist. */
 367         ifp = zebra_interface_state_read(s, vrf_id);
 368
 369         if (ifp == NULL)
 370                 return 0;
 371
 372         rip_if_down(ifp);
 373
 374         if (IS_RIP_DEBUG_ZEBRA)
 375                 zlog_debug(
 376                         "interface %s index %d flags %llx metric %d mtu %d is down",
 377                         ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
 378                         ifp->metric, ifp->mtu);
 379
 380         return 0;
 381 }
 382
 383 /* Inteface link up message processing */
 384 int rip_interface_up(int command, struct zclient *zclient, zebra_size_t length,
 385                      vrf_id_t vrf_id)
 386 {
 387         struct interface *ifp;
 388
 389         /* zebra_interface_state_read () updates interface structure in
 390            iflist. */
 391         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 392
 393         if (ifp == NULL)
 394                 return 0;
 395
 396         if (IS_RIP_DEBUG_ZEBRA)
 397                 zlog_debug(
 398                         "interface %s index %d flags %#llx metric %d mtu %d is up",
 399                         ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
 400                         ifp->metric, ifp->mtu);
 401
 402         /* Check if this interface is RIP enabled or not.*/
 403         rip_enable_apply(ifp);
 404
 405         /* Check for a passive interface */
 406         rip_passive_interface_apply(ifp);
 407
 408         /* Apply distribute list to the all interface. */
 409         rip_distribute_update_interface(ifp);
 410
 411         return 0;
 412 }
 413
 414 /* Inteface addition message from zebra. */
 415 int rip_interface_add(int command, struct zclient *zclient, zebra_size_t length,
 416                       vrf_id_t vrf_id)
 417 {
 418         struct interface *ifp;
 419
 420         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
 421
 422         if (IS_RIP_DEBUG_ZEBRA)
 423                 zlog_debug(
 424                         "interface add %s index %d flags %#llx metric %d mtu %d",
 425                         ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
 426                         ifp->metric, ifp->mtu);
 427
 428         /* Check if this interface is RIP enabled or not.*/
 429         rip_enable_apply(ifp);
 430
 431         /* Check for a passive interface */
 432         rip_passive_interface_apply(ifp);
 433
 434         /* Apply distribute list to the all interface. */
 435         rip_distribute_update_interface(ifp);
 436
 437         /* rip_request_neighbor_all (); */
 438
 439         /* Check interface routemap. */
 440         rip_if_rmap_update_interface(ifp);
 441
 442         return 0;
 443 }
 444
 445 int rip_interface_delete(int command, struct zclient *zclient,
 446                          zebra_size_t length, vrf_id_t vrf_id)
 447 {
 448         struct interface *ifp;
 449         struct stream *s;
 450
 451
 452         s = zclient->ibuf;
 453         /* zebra_interface_state_read() updates interface structure in iflist */
 454         ifp = zebra_interface_state_read(s, vrf_id);
 455
 456         if (ifp == NULL)
 457                 return 0;
 458
 459         if (if_is_up(ifp)) {
 460                 rip_if_down(ifp);
 461         }
 462
 463         zlog_info("interface delete %s index %d flags %#llx metric %d mtu %d",
 464                   ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
 465                   ifp->metric, ifp->mtu);
 466
 467         /* To support pseudo interface do not free interface structure.  */
 468         /* if_delete(ifp); */
 469         if_set_index(ifp, IFINDEX_INTERNAL);
 470
 471         return 0;
 472 }
 473
 474 static void rip_interface_clean(struct rip_interface *ri)
 475 {
 476         ri->enable_network = 0;
 477         ri->enable_interface = 0;
 478         ri->running = 0;
 479
 480         if (ri->t_wakeup) {
 481                 thread_cancel(ri->t_wakeup);
 482                 ri->t_wakeup = NULL;
 483         }
 484 }
 485
 486 void rip_interfaces_clean(void)
 487 {
 488         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 489         struct interface *ifp;
 490
 491         FOR_ALL_INTERFACES (vrf, ifp)
 492                 rip_interface_clean(ifp->info);
 493 }
 494
 495 static void rip_interface_reset(struct rip_interface *ri)
 496 {
 497         ri->auth_type = yang_get_default_enum("%s/authentication-scheme/mode",
 498                                               RIP_IFACE);
 499         ri->md5_auth_len = yang_get_default_enum(
 500                 "%s/authentication-scheme/md5-auth-length", RIP_IFACE);
 501
 502         /* Set default split-horizon behavior.  If the interface is Frame
 503            Relay or SMDS is enabled, the default value for split-horizon is
 504            off.  But currently Zebra does detect Frame Relay or SMDS
 505            interface.  So all interface is set to split horizon.  */
 506         ri->split_horizon =
 507                 yang_get_default_enum("%s/split-horizon", RIP_IFACE);
 508
 509         ri->ri_send = yang_get_default_enum("%s/version-send", RIP_IFACE);
 510         ri->ri_receive = yang_get_default_enum("%s/version-receive", RIP_IFACE);
 511         ri->v2_broadcast = yang_get_default_bool("%s/v2-broadcast", RIP_IFACE);
 512
 513         if (ri->auth_str)
 514                 XFREE(MTYPE_RIP_INTERFACE_STRING, ri->auth_str);
 515
 516         if (ri->key_chain)
 517                 XFREE(MTYPE_RIP_INTERFACE_STRING, ri->key_chain);
 518
 519         ri->list[RIP_FILTER_IN] = NULL;
 520         ri->list[RIP_FILTER_OUT] = NULL;
 521
 522         ri->prefix[RIP_FILTER_IN] = NULL;
 523         ri->prefix[RIP_FILTER_OUT] = NULL;
 524
 525         ri->recv_badpackets = 0;
 526         ri->recv_badroutes = 0;
 527         ri->sent_updates = 0;
 528
 529         ri->passive = 0;
 530
 531         rip_interface_clean(ri);
 532 }
 533
 534 int rip_if_down(struct interface *ifp)
 535 {
 536         struct route_node *rp;
 537         struct rip_info *rinfo;
 538         struct rip_interface *ri = NULL;
 539         struct list *list = NULL;
 540         struct listnode *listnode = NULL, *nextnode = NULL;
 541         if (rip) {
 542                 for (rp = route_top(rip->table); rp; rp = route_next(rp))
 543                         if ((list = rp->info) != NULL)
 544                                 for (ALL_LIST_ELEMENTS(list, listnode, nextnode,
 545                                                        rinfo))
 546                                         if (rinfo->nh.ifindex == ifp->ifindex)
 547                                                 rip_ecmp_delete(rinfo);
 548
 549                 ri = ifp->info;
 550
 551                 if (ri->running) {
 552                         if (IS_RIP_DEBUG_EVENT)
 553                                 zlog_debug("turn off %s", ifp->name);
 554
 555                         /* Leave from multicast group. */
 556                         rip_multicast_leave(ifp, rip->sock);
 557
 558                         ri->running = 0;
 559                 }
 560         }
 561
 562         return 0;
 563 }
 564
 565 /* Needed for stop RIP process. */
 566 void rip_if_down_all()
 567 {
 568         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 569         struct interface *ifp;
 570
 571         FOR_ALL_INTERFACES (vrf, ifp)
 572                 rip_if_down(ifp);
 573 }
 574
 575 static void rip_apply_address_add(struct connected *ifc)
 576 {
 577         struct prefix_ipv4 address;
 578         struct nexthop nh;
 579         struct prefix *p;
 580
 581         if (!rip)
 582                 return;
 583
 584         if (!if_is_up(ifc->ifp))
 585                 return;
 586
 587         p = ifc->address;
 588
 589         memset(&address, 0, sizeof(address));
 590         memset(&nh, 0, sizeof(nh));
 591
 592         address.family = p->family;
 593         address.prefix = p->u.prefix4;
 594         address.prefixlen = p->prefixlen;
 595         apply_mask_ipv4(&address);
 596
 597         nh.ifindex = ifc->ifp->ifindex;
 598         nh.type = NEXTHOP_TYPE_IFINDEX;
 599
 600         /* Check if this interface is RIP enabled or not
 601            or  Check if this address's prefix is RIP enabled */
 602         if ((rip_enable_if_lookup(ifc->ifp->name) >= 0)
 603             || (rip_enable_network_lookup2(ifc) >= 0))
 604                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
 605                                      &address, &nh, 0, 0, 0);
 606 }
 607
 608 int rip_interface_address_add(int command, struct zclient *zclient,
 609                               zebra_size_t length, vrf_id_t vrf_id)
 610 {
 611         struct connected *ifc;
 612         struct prefix *p;
 613
 614         ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
 615                                            zclient->ibuf, vrf_id);
 616
 617         if (ifc == NULL)
 618                 return 0;
 619
 620         p = ifc->address;
 621
 622         if (p->family == AF_INET) {
 623                 if (IS_RIP_DEBUG_ZEBRA)
 624                         zlog_debug("connected address %s/%d is added",
 625                                    inet_ntoa(p->u.prefix4), p->prefixlen);
 626
 627                 rip_enable_apply(ifc->ifp);
 628                 /* Check if this prefix needs to be redistributed */
 629                 rip_apply_address_add(ifc);
 630
 631                 hook_call(rip_ifaddr_add, ifc);
 632         }
 633
 634         return 0;
 635 }
 636
 637 static void rip_apply_address_del(struct connected *ifc)
 638 {
 639         struct prefix_ipv4 address;
 640         struct prefix *p;
 641
 642         if (!rip)
 643                 return;
 644
 645         if (!if_is_up(ifc->ifp))
 646                 return;
 647
 648         p = ifc->address;
 649
 650         memset(&address, 0, sizeof(address));
 651         address.family = p->family;
 652         address.prefix = p->u.prefix4;
 653         address.prefixlen = p->prefixlen;
 654         apply_mask_ipv4(&address);
 655
 656         rip_redistribute_delete(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
 657                                 &address, ifc->ifp->ifindex);
 658 }
 659
 660 int rip_interface_address_delete(int command, struct zclient *zclient,
 661                                  zebra_size_t length, vrf_id_t vrf_id)
 662 {
 663         struct connected *ifc;
 664         struct prefix *p;
 665
 666         ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
 667                                            zclient->ibuf, vrf_id);
 668
 669         if (ifc) {
 670                 p = ifc->address;
 671                 if (p->family == AF_INET) {
 672                         if (IS_RIP_DEBUG_ZEBRA)
 673                                 zlog_debug("connected address %s/%d is deleted",
 674                                            inet_ntoa(p->u.prefix4),
 675                                            p->prefixlen);
 676
 677                         hook_call(rip_ifaddr_del, ifc);
 678
 679                         /* Chech wether this prefix needs to be removed */
 680                         rip_apply_address_del(ifc);
 681                 }
 682
 683                 connected_free(ifc);
 684         }
 685
 686         return 0;
 687 }
 688
 689 /* Check interface is enabled by network statement. */
 690 /* Check wether the interface has at least a connected prefix that
 691  * is within the ripng_enable_network table. */
 692 static int rip_enable_network_lookup_if(struct interface *ifp)
 693 {
 694         struct listnode *node, *nnode;
 695         struct connected *connected;
 696         struct prefix_ipv4 address;
 697
 698         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
 699                 struct prefix *p;
 700                 struct route_node *n;
 701
 702                 p = connected->address;
 703
 704                 if (p->family == AF_INET) {
 705                         address.family = AF_INET;
 706                         address.prefix = p->u.prefix4;
 707                         address.prefixlen = IPV4_MAX_BITLEN;
 708
 709                         n = route_node_match(rip_enable_network,
 710                                              (struct prefix *)&address);
 711                         if (n) {
 712                                 route_unlock_node(n);
 713                                 return 1;
 714                         }
 715                 }
 716         }
 717         return -1;
 718 }
 719
 720 /* Check wether connected is within the ripng_enable_network table. */
 721 int rip_enable_network_lookup2(struct connected *connected)
 722 {
 723         struct prefix_ipv4 address;
 724         struct prefix *p;
 725
 726         p = connected->address;
 727
 728         if (p->family == AF_INET) {
 729                 struct route_node *node;
 730
 731                 address.family = p->family;
 732                 address.prefix = p->u.prefix4;
 733                 address.prefixlen = IPV4_MAX_BITLEN;
 734
 735                 /* LPM on p->family, p->u.prefix4/IPV4_MAX_BITLEN within
 736                  * rip_enable_network */
 737                 node = route_node_match(rip_enable_network,
 738                                         (struct prefix *)&address);
 739
 740                 if (node) {
 741                         route_unlock_node(node);
 742                         return 1;
 743                 }
 744         }
 745
 746         return -1;
 747 }
 748 /* Add RIP enable network. */
 749 int rip_enable_network_add(struct prefix *p)
 750 {
 751         struct route_node *node;
 752
 753         node = route_node_get(rip_enable_network, p);
 754
 755         if (node->info) {
 756                 route_unlock_node(node);
 757                 return NB_ERR_INCONSISTENCY;
 758         } else
 759                 node->info = (void *)1;
 760
 761         /* XXX: One should find a better solution than a generic one */
 762         rip_enable_apply_all();
 763
 764         return NB_OK;
 765 }
 766
 767 /* Delete RIP enable network. */
 768 int rip_enable_network_delete(struct prefix *p)
 769 {
 770         struct route_node *node;
 771
 772         node = route_node_lookup(rip_enable_network, p);
 773         if (node) {
 774                 node->info = NULL;
 775
 776                 /* Unlock info lock. */
 777                 route_unlock_node(node);
 778
 779                 /* Unlock lookup lock. */
 780                 route_unlock_node(node);
 781
 782                 /* XXX: One should find a better solution than a generic one */
 783                 rip_enable_apply_all();
 784
 785                 return NB_OK;
 786         }
 787
 788         return NB_ERR_INCONSISTENCY;
 789 }
 790
 791 /* Check interface is enabled by ifname statement. */
 792 static int rip_enable_if_lookup(const char *ifname)
 793 {
 794         unsigned int i;
 795         char *str;
 796
 797         for (i = 0; i < vector_active(rip_enable_interface); i++)
 798                 if ((str = vector_slot(rip_enable_interface, i)) != NULL)
 799                         if (strcmp(str, ifname) == 0)
 800                                 return i;
 801         return -1;
 802 }
 803
 804 /* Add interface to rip_enable_if. */
 805 int rip_enable_if_add(const char *ifname)
 806 {
 807         int ret;
 808
 809         ret = rip_enable_if_lookup(ifname);
 810         if (ret >= 0)
 811                 return NB_ERR_INCONSISTENCY;
 812
 813         vector_set(rip_enable_interface,
 814                    XSTRDUP(MTYPE_RIP_INTERFACE_STRING, ifname));
 815
 816         rip_enable_apply_all(); /* TODOVJ */
 817
 818         return NB_OK;
 819 }
 820
 821 /* Delete interface from rip_enable_if. */
 822 int rip_enable_if_delete(const char *ifname)
 823 {
 824         int index;
 825         char *str;
 826
 827         index = rip_enable_if_lookup(ifname);
 828         if (index < 0)
 829                 return NB_ERR_INCONSISTENCY;
 830
 831         str = vector_slot(rip_enable_interface, index);
 832         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
 833         vector_unset(rip_enable_interface, index);
 834
 835         rip_enable_apply_all(); /* TODOVJ */
 836
 837         return NB_OK;
 838 }
 839
 840 /* Join to multicast group and send request to the interface. */
 841 static int rip_interface_wakeup(struct thread *t)
 842 {
 843         struct interface *ifp;
 844         struct rip_interface *ri;
 845
 846         /* Get interface. */
 847         ifp = THREAD_ARG(t);
 848
 849         ri = ifp->info;
 850         ri->t_wakeup = NULL;
 851
 852         /* Join to multicast group. */
 853         if (rip_multicast_join(ifp, rip->sock) < 0) {
 854                 flog_err_sys(EC_LIB_SOCKET,
 855                              "multicast join failed, interface %s not running",
 856                              ifp->name);
 857                 return 0;
 858         }
 859
 860         /* Set running flag. */
 861         ri->running = 1;
 862
 863         /* Send RIP request to the interface. */
 864         rip_request_interface(ifp);
 865
 866         return 0;
 867 }
 868
 869 static void rip_connect_set(struct interface *ifp, int set)
 870 {
 871         struct listnode *node, *nnode;
 872         struct connected *connected;
 873         struct prefix_ipv4 address;
 874         struct nexthop nh;
 875
 876         memset(&nh, 0, sizeof(nh));
 877
 878         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
 879                 struct prefix *p;
 880                 p = connected->address;
 881
 882                 if (p->family != AF_INET)
 883                         continue;
 884
 885                 address.family = AF_INET;
 886                 address.prefix = p->u.prefix4;
 887                 address.prefixlen = p->prefixlen;
 888                 apply_mask_ipv4(&address);
 889
 890                 nh.ifindex = connected->ifp->ifindex;
 891                 nh.type = NEXTHOP_TYPE_IFINDEX;
 892                 if (set) {
 893                         /* Check once more wether this prefix is within a
 894                          * "network IF_OR_PREF" one */
 895                         if ((rip_enable_if_lookup(connected->ifp->name) >= 0)
 896                             || (rip_enable_network_lookup2(connected) >= 0))
 897                                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
 898                                                      RIP_ROUTE_INTERFACE,
 899                                                      &address, &nh, 0, 0, 0);
 900                 } else {
 901                         rip_redistribute_delete(ZEBRA_ROUTE_CONNECT,
 902                                                 RIP_ROUTE_INTERFACE, &address,
 903                                                 connected->ifp->ifindex);
 904                         if (rip_redistribute_check(ZEBRA_ROUTE_CONNECT))
 905                                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
 906                                                      RIP_ROUTE_REDISTRIBUTE,
 907                                                      &address, &nh, 0, 0, 0);
 908                 }
 909         }
 910 }
 911
 912 /* Update interface status. */
 913 void rip_enable_apply(struct interface *ifp)
 914 {
 915         int ret;
 916         struct rip_interface *ri = NULL;
 917
 918         /* Check interface. */
 919         if (!if_is_operative(ifp))
 920                 return;
 921
 922         ri = ifp->info;
 923
 924         /* Check network configuration. */
 925         ret = rip_enable_network_lookup_if(ifp);
 926
 927         /* If the interface is matched. */
 928         if (ret > 0)
 929                 ri->enable_network = 1;
 930         else
 931                 ri->enable_network = 0;
 932
 933         /* Check interface name configuration. */
 934         ret = rip_enable_if_lookup(ifp->name);
 935         if (ret >= 0)
 936                 ri->enable_interface = 1;
 937         else
 938                 ri->enable_interface = 0;
 939
 940         /* any interface MUST have an IPv4 address */
 941         if (!rip_if_ipv4_address_check(ifp)) {
 942                 ri->enable_network = 0;
 943                 ri->enable_interface = 0;
 944         }
 945
 946         /* Update running status of the interface. */
 947         if (ri->enable_network || ri->enable_interface) {
 948                 if (IS_RIP_DEBUG_EVENT)
 949                         zlog_debug("turn on %s", ifp->name);
 950
 951                 /* Add interface wake up thread. */
 952                 thread_add_timer(master, rip_interface_wakeup, ifp, 1,
 953                                  &ri->t_wakeup);
 954                 rip_connect_set(ifp, 1);
 955         } else if (ri->running) {
 956                 /* Might as well clean up the route table as well
 957                  * rip_if_down sets to 0 ri->running, and displays "turn
 958                  *off %s"
 959                  **/
 960                 rip_if_down(ifp);
 961
 962                 rip_connect_set(ifp, 0);
 963         }
 964 }
 965
 966 /* Apply network configuration to all interface. */
 967 void rip_enable_apply_all()
 968 {
 969         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 970         struct interface *ifp;
 971
 972         /* Check each interface. */
 973         FOR_ALL_INTERFACES (vrf, ifp)
 974                 rip_enable_apply(ifp);
 975 }
 976
 977 int rip_neighbor_lookup(struct sockaddr_in *from)
 978 {
 979         struct prefix_ipv4 p;
 980         struct route_node *node;
 981
 982         memset(&p, 0, sizeof(struct prefix_ipv4));
 983         p.family = AF_INET;
 984         p.prefix = from->sin_addr;
 985         p.prefixlen = IPV4_MAX_BITLEN;
 986
 987         node = route_node_lookup(rip->neighbor, (struct prefix *)&p);
 988         if (node) {
 989                 route_unlock_node(node);
 990                 return 1;
 991         }
 992         return 0;
 993 }
 994
 995 /* Add new RIP neighbor to the neighbor tree. */
 996 int rip_neighbor_add(struct prefix_ipv4 *p)
 997 {
 998         struct route_node *node;
 999
1000         node = route_node_get(rip->neighbor, (struct prefix *)p);
1001
1002         if (node->info)
1003                 return NB_ERR_INCONSISTENCY;
1004
1005         node->info = rip->neighbor;
1006
1007         return NB_OK;
1008 }
1009
1010 /* Delete RIP neighbor from the neighbor tree. */
1011 int rip_neighbor_delete(struct prefix_ipv4 *p)
1012 {
1013         struct route_node *node;
1014
1015         /* Lock for look up. */
1016         node = route_node_lookup(rip->neighbor, (struct prefix *)p);
1017         if (!node)
1018                 return NB_ERR_INCONSISTENCY;
1019
1020         node->info = NULL;
1021
1022         /* Unlock lookup lock. */
1023         route_unlock_node(node);
1024
1025         /* Unlock real neighbor information lock. */
1026         route_unlock_node(node);
1027
1028         return NB_OK;
1029 }
1030
1031 /* Clear all network and neighbor configuration. */
1032 void rip_clean_network()
1033 {
1034         unsigned int i;
1035         char *str;
1036         struct route_node *rn;
1037
1038         /* rip_enable_network. */
1039         for (rn = route_top(rip_enable_network); rn; rn = route_next(rn))
1040                 if (rn->info) {
1041                         rn->info = NULL;
1042                         route_unlock_node(rn);
1043                 }
1044
1045         /* rip_enable_interface. */
1046         for (i = 0; i < vector_active(rip_enable_interface); i++)
1047                 if ((str = vector_slot(rip_enable_interface, i)) != NULL) {
1048                         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1049                         vector_slot(rip_enable_interface, i) = NULL;
1050                 }
1051 }
1052
1053 /* Utility function for looking up passive interface settings. */
1054 static int rip_passive_nondefault_lookup(const char *ifname)
1055 {
1056         unsigned int i;
1057         char *str;
1058
1059         for (i = 0; i < vector_active(Vrip_passive_nondefault); i++)
1060                 if ((str = vector_slot(Vrip_passive_nondefault, i)) != NULL)
1061                         if (strcmp(str, ifname) == 0)
1062                                 return i;
1063         return -1;
1064 }
1065
1066 void rip_passive_interface_apply(struct interface *ifp)
1067 {
1068         struct rip_interface *ri;
1069
1070         if (rip == NULL)
1071                 return;
1072
1073         ri = ifp->info;
1074
1075         ri->passive = ((rip_passive_nondefault_lookup(ifp->name) < 0)
1076                                ? rip->passive_default
1077                                : !rip->passive_default);
1078
1079         if (IS_RIP_DEBUG_ZEBRA)
1080                 zlog_debug("interface %s: passive = %d", ifp->name,
1081                            ri->passive);
1082 }
1083
1084 static void rip_passive_interface_apply_all(void)
1085 {
1086         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
1087         struct interface *ifp;
1088
1089         FOR_ALL_INTERFACES (vrf, ifp)
1090                 rip_passive_interface_apply(ifp);
1091 }
1092
1093 /* Passive interface. */
1094 int rip_passive_nondefault_set(const char *ifname)
1095 {
1096         if (rip_passive_nondefault_lookup(ifname) >= 0)
1097                 /*
1098                  * Don't return an error, this can happen after changing
1099                  * 'passive-default'.
1100                  */
1101                 return NB_OK;
1102
1103         vector_set(Vrip_passive_nondefault,
1104                    XSTRDUP(MTYPE_RIP_INTERFACE_STRING, ifname));
1105
1106         rip_passive_interface_apply_all();
1107
1108         return NB_OK;
1109 }
1110
1111 int rip_passive_nondefault_unset(const char *ifname)
1112 {
1113         int i;
1114         char *str;
1115
1116         i = rip_passive_nondefault_lookup(ifname);
1117         if (i < 0)
1118                 /*
1119                  * Don't return an error, this can happen after changing
1120                  * 'passive-default'.
1121                  */
1122                 return NB_OK;
1123
1124         str = vector_slot(Vrip_passive_nondefault, i);
1125         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1126         vector_unset(Vrip_passive_nondefault, i);
1127
1128         rip_passive_interface_apply_all();
1129
1130         return NB_OK;
1131 }
1132
1133 /* Free all configured RIP passive-interface settings. */
1134 void rip_passive_nondefault_clean(void)
1135 {
1136         unsigned int i;
1137         char *str;
1138
1139         for (i = 0; i < vector_active(Vrip_passive_nondefault); i++)
1140                 if ((str = vector_slot(Vrip_passive_nondefault, i)) != NULL) {
1141                         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1142                         vector_slot(Vrip_passive_nondefault, i) = NULL;
1143                 }
1144         rip_passive_interface_apply_all();
1145 }
1146
1147 /* Write rip configuration of each interface. */
1148 static int rip_interface_config_write(struct vty *vty)
1149 {
1150         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
1151         struct interface *ifp;
1152         int write = 0;
1153
1154         FOR_ALL_INTERFACES (vrf, ifp) {
1155                 struct lyd_node *dnode;
1156
1157                 dnode = yang_dnode_get(
1158                         running_config->dnode,
1159                         "/frr-interface:lib/interface[name='%s'][vrf='%s']",
1160                         ifp->name, vrf->name);
1161                 if (dnode == NULL)
1162                         continue;
1163
1164                 write = 1;
1165                 nb_cli_show_dnode_cmds(vty, dnode, false);
1166         }
1167
1168         return write;
1169 }
1170
1171 int rip_show_network_config(struct vty *vty)
1172 {
1173         unsigned int i;
1174         char *ifname;
1175         struct route_node *node;
1176
1177         /* Network type RIP enable interface statement. */
1178         for (node = route_top(rip_enable_network); node;
1179              node = route_next(node))
1180                 if (node->info)
1181                         vty_out(vty, "    %s/%u\n",
1182                                 inet_ntoa(node->p.u.prefix4),
1183                                 node->p.prefixlen);
1184
1185         /* Interface name RIP enable statement. */
1186         for (i = 0; i < vector_active(rip_enable_interface); i++)
1187                 if ((ifname = vector_slot(rip_enable_interface, i)) != NULL)
1188                         vty_out(vty, "    %s\n", ifname);
1189
1190         /* RIP neighbors listing. */
1191         for (node = route_top(rip->neighbor); node; node = route_next(node))
1192                 if (node->info)
1193                         vty_out(vty, "    %s\n", inet_ntoa(node->p.u.prefix4));
1194
1195         return 0;
1196 }
1197
1198 static struct cmd_node interface_node = {
1199         INTERFACE_NODE, "%s(config-if)# ", 1,
1200 };
1201
1202 /* Called when interface structure allocated. */
1203 static int rip_interface_new_hook(struct interface *ifp)
1204 {
1205         ifp->info = rip_interface_new();
1206         return 0;
1207 }
1208
1209 /* Called when interface structure deleted. */
1210 static int rip_interface_delete_hook(struct interface *ifp)
1211 {
1212         rip_interface_reset(ifp->info);
1213         XFREE(MTYPE_RIP_INTERFACE, ifp->info);
1214         ifp->info = NULL;
1215         return 0;
1216 }
1217
1218 /* Allocate and initialize interface vector. */
1219 void rip_if_init(void)
1220 {
1221         /* Default initial size of interface vector. */
1222         hook_register_prio(if_add, 0, rip_interface_new_hook);
1223         hook_register_prio(if_del, 0, rip_interface_delete_hook);
1224
1225         /* RIP network init. */
1226         rip_enable_interface = vector_init(1);
1227         rip_enable_network = route_table_init();
1228
1229         /* RIP passive interface. */
1230         Vrip_passive_nondefault = vector_init(1);
1231
1232         /* Install interface node. */
1233         install_node(&interface_node, rip_interface_config_write);
1234         if_cmd_init();
1235 }