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 void rip_interfaces_reset(void)
 535 {
 536         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 537         struct interface *ifp;
 538
 539         FOR_ALL_INTERFACES (vrf, ifp)
 540                 rip_interface_reset(ifp->info);
 541 }
 542
 543 int rip_if_down(struct interface *ifp)
 544 {
 545         struct route_node *rp;
 546         struct rip_info *rinfo;
 547         struct rip_interface *ri = NULL;
 548         struct list *list = NULL;
 549         struct listnode *listnode = NULL, *nextnode = NULL;
 550         if (rip) {
 551                 for (rp = route_top(rip->table); rp; rp = route_next(rp))
 552                         if ((list = rp->info) != NULL)
 553                                 for (ALL_LIST_ELEMENTS(list, listnode, nextnode,
 554                                                        rinfo))
 555                                         if (rinfo->nh.ifindex == ifp->ifindex)
 556                                                 rip_ecmp_delete(rinfo);
 557
 558                 ri = ifp->info;
 559
 560                 if (ri->running) {
 561                         if (IS_RIP_DEBUG_EVENT)
 562                                 zlog_debug("turn off %s", ifp->name);
 563
 564                         /* Leave from multicast group. */
 565                         rip_multicast_leave(ifp, rip->sock);
 566
 567                         ri->running = 0;
 568                 }
 569         }
 570
 571         return 0;
 572 }
 573
 574 /* Needed for stop RIP process. */
 575 void rip_if_down_all()
 576 {
 577         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 578         struct interface *ifp;
 579
 580         FOR_ALL_INTERFACES (vrf, ifp)
 581                 rip_if_down(ifp);
 582 }
 583
 584 static void rip_apply_address_add(struct connected *ifc)
 585 {
 586         struct prefix_ipv4 address;
 587         struct nexthop nh;
 588         struct prefix *p;
 589
 590         if (!rip)
 591                 return;
 592
 593         if (!if_is_up(ifc->ifp))
 594                 return;
 595
 596         p = ifc->address;
 597
 598         memset(&address, 0, sizeof(address));
 599         memset(&nh, 0, sizeof(nh));
 600
 601         address.family = p->family;
 602         address.prefix = p->u.prefix4;
 603         address.prefixlen = p->prefixlen;
 604         apply_mask_ipv4(&address);
 605
 606         nh.ifindex = ifc->ifp->ifindex;
 607         nh.type = NEXTHOP_TYPE_IFINDEX;
 608
 609         /* Check if this interface is RIP enabled or not
 610            or  Check if this address's prefix is RIP enabled */
 611         if ((rip_enable_if_lookup(ifc->ifp->name) >= 0)
 612             || (rip_enable_network_lookup2(ifc) >= 0))
 613                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
 614                                      &address, &nh, 0, 0, 0);
 615 }
 616
 617 int rip_interface_address_add(int command, struct zclient *zclient,
 618                               zebra_size_t length, vrf_id_t vrf_id)
 619 {
 620         struct connected *ifc;
 621         struct prefix *p;
 622
 623         ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
 624                                            zclient->ibuf, vrf_id);
 625
 626         if (ifc == NULL)
 627                 return 0;
 628
 629         p = ifc->address;
 630
 631         if (p->family == AF_INET) {
 632                 if (IS_RIP_DEBUG_ZEBRA)
 633                         zlog_debug("connected address %s/%d is added",
 634                                    inet_ntoa(p->u.prefix4), p->prefixlen);
 635
 636                 rip_enable_apply(ifc->ifp);
 637                 /* Check if this prefix needs to be redistributed */
 638                 rip_apply_address_add(ifc);
 639
 640                 hook_call(rip_ifaddr_add, ifc);
 641         }
 642
 643         return 0;
 644 }
 645
 646 static void rip_apply_address_del(struct connected *ifc)
 647 {
 648         struct prefix_ipv4 address;
 649         struct prefix *p;
 650
 651         if (!rip)
 652                 return;
 653
 654         if (!if_is_up(ifc->ifp))
 655                 return;
 656
 657         p = ifc->address;
 658
 659         memset(&address, 0, sizeof(address));
 660         address.family = p->family;
 661         address.prefix = p->u.prefix4;
 662         address.prefixlen = p->prefixlen;
 663         apply_mask_ipv4(&address);
 664
 665         rip_redistribute_delete(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
 666                                 &address, ifc->ifp->ifindex);
 667 }
 668
 669 int rip_interface_address_delete(int command, struct zclient *zclient,
 670                                  zebra_size_t length, vrf_id_t vrf_id)
 671 {
 672         struct connected *ifc;
 673         struct prefix *p;
 674
 675         ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
 676                                            zclient->ibuf, vrf_id);
 677
 678         if (ifc) {
 679                 p = ifc->address;
 680                 if (p->family == AF_INET) {
 681                         if (IS_RIP_DEBUG_ZEBRA)
 682                                 zlog_debug("connected address %s/%d is deleted",
 683                                            inet_ntoa(p->u.prefix4),
 684                                            p->prefixlen);
 685
 686                         hook_call(rip_ifaddr_del, ifc);
 687
 688                         /* Chech wether this prefix needs to be removed */
 689                         rip_apply_address_del(ifc);
 690                 }
 691
 692                 connected_free(ifc);
 693         }
 694
 695         return 0;
 696 }
 697
 698 /* Check interface is enabled by network statement. */
 699 /* Check wether the interface has at least a connected prefix that
 700  * is within the ripng_enable_network table. */
 701 static int rip_enable_network_lookup_if(struct interface *ifp)
 702 {
 703         struct listnode *node, *nnode;
 704         struct connected *connected;
 705         struct prefix_ipv4 address;
 706
 707         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
 708                 struct prefix *p;
 709                 struct route_node *n;
 710
 711                 p = connected->address;
 712
 713                 if (p->family == AF_INET) {
 714                         address.family = AF_INET;
 715                         address.prefix = p->u.prefix4;
 716                         address.prefixlen = IPV4_MAX_BITLEN;
 717
 718                         n = route_node_match(rip_enable_network,
 719                                              (struct prefix *)&address);
 720                         if (n) {
 721                                 route_unlock_node(n);
 722                                 return 1;
 723                         }
 724                 }
 725         }
 726         return -1;
 727 }
 728
 729 /* Check wether connected is within the ripng_enable_network table. */
 730 int rip_enable_network_lookup2(struct connected *connected)
 731 {
 732         struct prefix_ipv4 address;
 733         struct prefix *p;
 734
 735         p = connected->address;
 736
 737         if (p->family == AF_INET) {
 738                 struct route_node *node;
 739
 740                 address.family = p->family;
 741                 address.prefix = p->u.prefix4;
 742                 address.prefixlen = IPV4_MAX_BITLEN;
 743
 744                 /* LPM on p->family, p->u.prefix4/IPV4_MAX_BITLEN within
 745                  * rip_enable_network */
 746                 node = route_node_match(rip_enable_network,
 747                                         (struct prefix *)&address);
 748
 749                 if (node) {
 750                         route_unlock_node(node);
 751                         return 1;
 752                 }
 753         }
 754
 755         return -1;
 756 }
 757 /* Add RIP enable network. */
 758 int rip_enable_network_add(struct prefix *p)
 759 {
 760         struct route_node *node;
 761
 762         node = route_node_get(rip_enable_network, p);
 763
 764         if (node->info) {
 765                 route_unlock_node(node);
 766                 return NB_ERR_INCONSISTENCY;
 767         } else
 768                 node->info = (void *)1;
 769
 770         /* XXX: One should find a better solution than a generic one */
 771         rip_enable_apply_all();
 772
 773         return NB_OK;
 774 }
 775
 776 /* Delete RIP enable network. */
 777 int rip_enable_network_delete(struct prefix *p)
 778 {
 779         struct route_node *node;
 780
 781         node = route_node_lookup(rip_enable_network, p);
 782         if (node) {
 783                 node->info = NULL;
 784
 785                 /* Unlock info lock. */
 786                 route_unlock_node(node);
 787
 788                 /* Unlock lookup lock. */
 789                 route_unlock_node(node);
 790
 791                 /* XXX: One should find a better solution than a generic one */
 792                 rip_enable_apply_all();
 793
 794                 return NB_OK;
 795         }
 796
 797         return NB_ERR_INCONSISTENCY;
 798 }
 799
 800 /* Check interface is enabled by ifname statement. */
 801 static int rip_enable_if_lookup(const char *ifname)
 802 {
 803         unsigned int i;
 804         char *str;
 805
 806         for (i = 0; i < vector_active(rip_enable_interface); i++)
 807                 if ((str = vector_slot(rip_enable_interface, i)) != NULL)
 808                         if (strcmp(str, ifname) == 0)
 809                                 return i;
 810         return -1;
 811 }
 812
 813 /* Add interface to rip_enable_if. */
 814 int rip_enable_if_add(const char *ifname)
 815 {
 816         int ret;
 817
 818         ret = rip_enable_if_lookup(ifname);
 819         if (ret >= 0)
 820                 return NB_ERR_INCONSISTENCY;
 821
 822         vector_set(rip_enable_interface,
 823                    XSTRDUP(MTYPE_RIP_INTERFACE_STRING, ifname));
 824
 825         rip_enable_apply_all(); /* TODOVJ */
 826
 827         return NB_OK;
 828 }
 829
 830 /* Delete interface from rip_enable_if. */
 831 int rip_enable_if_delete(const char *ifname)
 832 {
 833         int index;
 834         char *str;
 835
 836         index = rip_enable_if_lookup(ifname);
 837         if (index < 0)
 838                 return NB_ERR_INCONSISTENCY;
 839
 840         str = vector_slot(rip_enable_interface, index);
 841         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
 842         vector_unset(rip_enable_interface, index);
 843
 844         rip_enable_apply_all(); /* TODOVJ */
 845
 846         return NB_OK;
 847 }
 848
 849 /* Join to multicast group and send request to the interface. */
 850 static int rip_interface_wakeup(struct thread *t)
 851 {
 852         struct interface *ifp;
 853         struct rip_interface *ri;
 854
 855         /* Get interface. */
 856         ifp = THREAD_ARG(t);
 857
 858         ri = ifp->info;
 859         ri->t_wakeup = NULL;
 860
 861         /* Join to multicast group. */
 862         if (rip_multicast_join(ifp, rip->sock) < 0) {
 863                 flog_err_sys(EC_LIB_SOCKET,
 864                              "multicast join failed, interface %s not running",
 865                              ifp->name);
 866                 return 0;
 867         }
 868
 869         /* Set running flag. */
 870         ri->running = 1;
 871
 872         /* Send RIP request to the interface. */
 873         rip_request_interface(ifp);
 874
 875         return 0;
 876 }
 877
 878 static void rip_connect_set(struct interface *ifp, int set)
 879 {
 880         struct listnode *node, *nnode;
 881         struct connected *connected;
 882         struct prefix_ipv4 address;
 883         struct nexthop nh;
 884
 885         memset(&nh, 0, sizeof(nh));
 886
 887         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
 888                 struct prefix *p;
 889                 p = connected->address;
 890
 891                 if (p->family != AF_INET)
 892                         continue;
 893
 894                 address.family = AF_INET;
 895                 address.prefix = p->u.prefix4;
 896                 address.prefixlen = p->prefixlen;
 897                 apply_mask_ipv4(&address);
 898
 899                 nh.ifindex = connected->ifp->ifindex;
 900                 nh.type = NEXTHOP_TYPE_IFINDEX;
 901                 if (set) {
 902                         /* Check once more wether this prefix is within a
 903                          * "network IF_OR_PREF" one */
 904                         if ((rip_enable_if_lookup(connected->ifp->name) >= 0)
 905                             || (rip_enable_network_lookup2(connected) >= 0))
 906                                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
 907                                                      RIP_ROUTE_INTERFACE,
 908                                                      &address, &nh, 0, 0, 0);
 909                 } else {
 910                         rip_redistribute_delete(ZEBRA_ROUTE_CONNECT,
 911                                                 RIP_ROUTE_INTERFACE, &address,
 912                                                 connected->ifp->ifindex);
 913                         if (rip_redistribute_check(ZEBRA_ROUTE_CONNECT))
 914                                 rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
 915                                                      RIP_ROUTE_REDISTRIBUTE,
 916                                                      &address, &nh, 0, 0, 0);
 917                 }
 918         }
 919 }
 920
 921 /* Update interface status. */
 922 void rip_enable_apply(struct interface *ifp)
 923 {
 924         int ret;
 925         struct rip_interface *ri = NULL;
 926
 927         /* Check interface. */
 928         if (!if_is_operative(ifp))
 929                 return;
 930
 931         ri = ifp->info;
 932
 933         /* Check network configuration. */
 934         ret = rip_enable_network_lookup_if(ifp);
 935
 936         /* If the interface is matched. */
 937         if (ret > 0)
 938                 ri->enable_network = 1;
 939         else
 940                 ri->enable_network = 0;
 941
 942         /* Check interface name configuration. */
 943         ret = rip_enable_if_lookup(ifp->name);
 944         if (ret >= 0)
 945                 ri->enable_interface = 1;
 946         else
 947                 ri->enable_interface = 0;
 948
 949         /* any interface MUST have an IPv4 address */
 950         if (!rip_if_ipv4_address_check(ifp)) {
 951                 ri->enable_network = 0;
 952                 ri->enable_interface = 0;
 953         }
 954
 955         /* Update running status of the interface. */
 956         if (ri->enable_network || ri->enable_interface) {
 957                 if (IS_RIP_DEBUG_EVENT)
 958                         zlog_debug("turn on %s", ifp->name);
 959
 960                 /* Add interface wake up thread. */
 961                 thread_add_timer(master, rip_interface_wakeup, ifp, 1,
 962                                  &ri->t_wakeup);
 963                 rip_connect_set(ifp, 1);
 964         } else if (ri->running) {
 965                 /* Might as well clean up the route table as well
 966                  * rip_if_down sets to 0 ri->running, and displays "turn
 967                  *off %s"
 968                  **/
 969                 rip_if_down(ifp);
 970
 971                 rip_connect_set(ifp, 0);
 972         }
 973 }
 974
 975 /* Apply network configuration to all interface. */
 976 void rip_enable_apply_all()
 977 {
 978         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 979         struct interface *ifp;
 980
 981         /* Check each interface. */
 982         FOR_ALL_INTERFACES (vrf, ifp)
 983                 rip_enable_apply(ifp);
 984 }
 985
 986 int rip_neighbor_lookup(struct sockaddr_in *from)
 987 {
 988         struct prefix_ipv4 p;
 989         struct route_node *node;
 990
 991         memset(&p, 0, sizeof(struct prefix_ipv4));
 992         p.family = AF_INET;
 993         p.prefix = from->sin_addr;
 994         p.prefixlen = IPV4_MAX_BITLEN;
 995
 996         node = route_node_lookup(rip->neighbor, (struct prefix *)&p);
 997         if (node) {
 998                 route_unlock_node(node);
 999                 return 1;
1000         }
1001         return 0;
1002 }
1003
1004 /* Add new RIP neighbor to the neighbor tree. */
1005 int rip_neighbor_add(struct prefix_ipv4 *p)
1006 {
1007         struct route_node *node;
1008
1009         node = route_node_get(rip->neighbor, (struct prefix *)p);
1010
1011         if (node->info)
1012                 return NB_ERR_INCONSISTENCY;
1013
1014         node->info = rip->neighbor;
1015
1016         return NB_OK;
1017 }
1018
1019 /* Delete RIP neighbor from the neighbor tree. */
1020 int rip_neighbor_delete(struct prefix_ipv4 *p)
1021 {
1022         struct route_node *node;
1023
1024         /* Lock for look up. */
1025         node = route_node_lookup(rip->neighbor, (struct prefix *)p);
1026         if (!node)
1027                 return NB_ERR_INCONSISTENCY;
1028
1029         node->info = NULL;
1030
1031         /* Unlock lookup lock. */
1032         route_unlock_node(node);
1033
1034         /* Unlock real neighbor information lock. */
1035         route_unlock_node(node);
1036
1037         return NB_OK;
1038 }
1039
1040 /* Clear all network and neighbor configuration. */
1041 void rip_clean_network()
1042 {
1043         unsigned int i;
1044         char *str;
1045         struct route_node *rn;
1046
1047         /* rip_enable_network. */
1048         for (rn = route_top(rip_enable_network); rn; rn = route_next(rn))
1049                 if (rn->info) {
1050                         rn->info = NULL;
1051                         route_unlock_node(rn);
1052                 }
1053
1054         /* rip_enable_interface. */
1055         for (i = 0; i < vector_active(rip_enable_interface); i++)
1056                 if ((str = vector_slot(rip_enable_interface, i)) != NULL) {
1057                         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1058                         vector_slot(rip_enable_interface, i) = NULL;
1059                 }
1060 }
1061
1062 /* Utility function for looking up passive interface settings. */
1063 static int rip_passive_nondefault_lookup(const char *ifname)
1064 {
1065         unsigned int i;
1066         char *str;
1067
1068         for (i = 0; i < vector_active(Vrip_passive_nondefault); i++)
1069                 if ((str = vector_slot(Vrip_passive_nondefault, i)) != NULL)
1070                         if (strcmp(str, ifname) == 0)
1071                                 return i;
1072         return -1;
1073 }
1074
1075 void rip_passive_interface_apply(struct interface *ifp)
1076 {
1077         struct rip_interface *ri;
1078
1079         if (rip == NULL)
1080                 return;
1081
1082         ri = ifp->info;
1083
1084         ri->passive = ((rip_passive_nondefault_lookup(ifp->name) < 0)
1085                                ? rip->passive_default
1086                                : !rip->passive_default);
1087
1088         if (IS_RIP_DEBUG_ZEBRA)
1089                 zlog_debug("interface %s: passive = %d", ifp->name,
1090                            ri->passive);
1091 }
1092
1093 static void rip_passive_interface_apply_all(void)
1094 {
1095         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
1096         struct interface *ifp;
1097
1098         FOR_ALL_INTERFACES (vrf, ifp)
1099                 rip_passive_interface_apply(ifp);
1100 }
1101
1102 /* Passive interface. */
1103 int rip_passive_nondefault_set(const char *ifname)
1104 {
1105         if (rip_passive_nondefault_lookup(ifname) >= 0)
1106                 /*
1107                  * Don't return an error, this can happen after changing
1108                  * 'passive-default'.
1109                  */
1110                 return NB_OK;
1111
1112         vector_set(Vrip_passive_nondefault,
1113                    XSTRDUP(MTYPE_RIP_INTERFACE_STRING, ifname));
1114
1115         rip_passive_interface_apply_all();
1116
1117         return NB_OK;
1118 }
1119
1120 int rip_passive_nondefault_unset(const char *ifname)
1121 {
1122         int i;
1123         char *str;
1124
1125         i = rip_passive_nondefault_lookup(ifname);
1126         if (i < 0)
1127                 /*
1128                  * Don't return an error, this can happen after changing
1129                  * 'passive-default'.
1130                  */
1131                 return NB_OK;
1132
1133         str = vector_slot(Vrip_passive_nondefault, i);
1134         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1135         vector_unset(Vrip_passive_nondefault, i);
1136
1137         rip_passive_interface_apply_all();
1138
1139         return NB_OK;
1140 }
1141
1142 /* Free all configured RIP passive-interface settings. */
1143 void rip_passive_nondefault_clean(void)
1144 {
1145         unsigned int i;
1146         char *str;
1147
1148         for (i = 0; i < vector_active(Vrip_passive_nondefault); i++)
1149                 if ((str = vector_slot(Vrip_passive_nondefault, i)) != NULL) {
1150                         XFREE(MTYPE_RIP_INTERFACE_STRING, str);
1151                         vector_slot(Vrip_passive_nondefault, i) = NULL;
1152                 }
1153         rip_passive_interface_apply_all();
1154 }
1155
1156 /* Write rip configuration of each interface. */
1157 static int rip_interface_config_write(struct vty *vty)
1158 {
1159         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
1160         struct interface *ifp;
1161         int write = 0;
1162
1163         FOR_ALL_INTERFACES (vrf, ifp) {
1164                 struct lyd_node *dnode;
1165
1166                 dnode = yang_dnode_get(
1167                         running_config->dnode,
1168                         "/frr-interface:lib/interface[name='%s'][vrf='%s']",
1169                         ifp->name, vrf->name);
1170                 if (dnode == NULL)
1171                         continue;
1172
1173                 write = 1;
1174                 nb_cli_show_dnode_cmds(vty, dnode, false);
1175         }
1176
1177         return write;
1178 }
1179
1180 int rip_show_network_config(struct vty *vty)
1181 {
1182         unsigned int i;
1183         char *ifname;
1184         struct route_node *node;
1185
1186         /* Network type RIP enable interface statement. */
1187         for (node = route_top(rip_enable_network); node;
1188              node = route_next(node))
1189                 if (node->info)
1190                         vty_out(vty, "    %s/%u\n",
1191                                 inet_ntoa(node->p.u.prefix4),
1192                                 node->p.prefixlen);
1193
1194         /* Interface name RIP enable statement. */
1195         for (i = 0; i < vector_active(rip_enable_interface); i++)
1196                 if ((ifname = vector_slot(rip_enable_interface, i)) != NULL)
1197                         vty_out(vty, "    %s\n", ifname);
1198
1199         /* RIP neighbors listing. */
1200         for (node = route_top(rip->neighbor); node; node = route_next(node))
1201                 if (node->info)
1202                         vty_out(vty, "    %s\n", inet_ntoa(node->p.u.prefix4));
1203
1204         return 0;
1205 }
1206
1207 static struct cmd_node interface_node = {
1208         INTERFACE_NODE, "%s(config-if)# ", 1,
1209 };
1210
1211 /* Called when interface structure allocated. */
1212 static int rip_interface_new_hook(struct interface *ifp)
1213 {
1214         ifp->info = rip_interface_new();
1215         return 0;
1216 }
1217
1218 /* Called when interface structure deleted. */
1219 static int rip_interface_delete_hook(struct interface *ifp)
1220 {
1221         rip_interface_reset(ifp->info);
1222         XFREE(MTYPE_RIP_INTERFACE, ifp->info);
1223         ifp->info = NULL;
1224         return 0;
1225 }
1226
1227 /* Allocate and initialize interface vector. */
1228 void rip_if_init(void)
1229 {
1230         /* Default initial size of interface vector. */
1231         hook_register_prio(if_add, 0, rip_interface_new_hook);
1232         hook_register_prio(if_del, 0, rip_interface_delete_hook);
1233
1234         /* RIP network init. */
1235         rip_enable_interface = vector_init(1);
1236         rip_enable_network = route_table_init();
1237
1238         /* RIP passive interface. */
1239         Vrip_passive_nondefault = vector_init(1);
1240
1241         /* Install interface node. */
1242         install_node(&interface_node, rip_interface_config_write);
1243         if_cmd_init();
1244 }