Annotation of embedaddon/quagga/ripd/rip_interface.c, revision 1.1
1.1 ! misho 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
! 17: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 18: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 19: * 02111-1307, USA.
! 20: */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #include "command.h"
! 25: #include "if.h"
! 26: #include "sockunion.h"
! 27: #include "prefix.h"
! 28: #include "memory.h"
! 29: #include "network.h"
! 30: #include "table.h"
! 31: #include "log.h"
! 32: #include "stream.h"
! 33: #include "thread.h"
! 34: #include "zclient.h"
! 35: #include "filter.h"
! 36: #include "sockopt.h"
! 37: #include "privs.h"
! 38:
! 39: #include "zebra/connected.h"
! 40:
! 41: #include "ripd/ripd.h"
! 42: #include "ripd/rip_debug.h"
! 43: #include "ripd/rip_interface.h"
! 44:
! 45: /* static prototypes */
! 46: static void rip_enable_apply (struct interface *);
! 47: static void rip_passive_interface_apply (struct interface *);
! 48: static int rip_if_down(struct interface *ifp);
! 49: static int rip_enable_if_lookup (const char *ifname);
! 50: static int rip_enable_network_lookup2 (struct connected *connected);
! 51: static void rip_enable_apply_all (void);
! 52:
! 53: struct message ri_version_msg[] =
! 54: {
! 55: {RI_RIP_VERSION_1, "1"},
! 56: {RI_RIP_VERSION_2, "2"},
! 57: {RI_RIP_VERSION_1_AND_2, "1 2"},
! 58: };
! 59:
! 60: extern struct zebra_privs_t ripd_privs;
! 61:
! 62: /* RIP enabled network vector. */
! 63: vector rip_enable_interface;
! 64:
! 65: /* RIP enabled interface table. */
! 66: struct route_table *rip_enable_network;
! 67:
! 68: /* Vector to store passive-interface name. */
! 69: static int passive_default; /* are we in passive-interface default mode? */
! 70: vector Vrip_passive_nondefault;
! 71:
! 72: /* Join to the RIP version 2 multicast group. */
! 73: static int
! 74: ipv4_multicast_join (int sock,
! 75: struct in_addr group,
! 76: struct in_addr ifa,
! 77: unsigned int ifindex)
! 78: {
! 79: int ret;
! 80:
! 81: ret = setsockopt_ipv4_multicast (sock,
! 82: IP_ADD_MEMBERSHIP,
! 83: group.s_addr,
! 84: ifindex);
! 85:
! 86: if (ret < 0)
! 87: zlog (NULL, LOG_INFO, "can't setsockopt IP_ADD_MEMBERSHIP %s",
! 88: safe_strerror (errno));
! 89:
! 90: return ret;
! 91: }
! 92:
! 93: /* Leave from the RIP version 2 multicast group. */
! 94: static int
! 95: ipv4_multicast_leave (int sock,
! 96: struct in_addr group,
! 97: struct in_addr ifa,
! 98: unsigned int ifindex)
! 99: {
! 100: int ret;
! 101:
! 102: ret = setsockopt_ipv4_multicast (sock,
! 103: IP_DROP_MEMBERSHIP,
! 104: group.s_addr,
! 105: ifindex);
! 106:
! 107: if (ret < 0)
! 108: zlog (NULL, LOG_INFO, "can't setsockopt IP_DROP_MEMBERSHIP");
! 109:
! 110: return ret;
! 111: }
! 112:
! 113: /* Allocate new RIP's interface configuration. */
! 114: static struct rip_interface *
! 115: rip_interface_new (void)
! 116: {
! 117: struct rip_interface *ri;
! 118:
! 119: ri = XCALLOC (MTYPE_RIP_INTERFACE, sizeof (struct rip_interface));
! 120:
! 121: /* Default authentication type is simple password for Cisco
! 122: compatibility. */
! 123: ri->auth_type = RIP_NO_AUTH;
! 124: ri->md5_auth_len = RIP_AUTH_MD5_COMPAT_SIZE;
! 125:
! 126: /* Set default split-horizon behavior. If the interface is Frame
! 127: Relay or SMDS is enabled, the default value for split-horizon is
! 128: off. But currently Zebra does detect Frame Relay or SMDS
! 129: interface. So all interface is set to split horizon. */
! 130: ri->split_horizon_default = RIP_SPLIT_HORIZON;
! 131: ri->split_horizon = ri->split_horizon_default;
! 132:
! 133: return ri;
! 134: }
! 135:
! 136: void
! 137: rip_interface_multicast_set (int sock, struct connected *connected)
! 138: {
! 139: assert (connected != NULL);
! 140:
! 141: if (setsockopt_ipv4_multicast_if (sock, connected->ifp->ifindex) < 0)
! 142: {
! 143: zlog_warn ("Can't setsockopt IP_MULTICAST_IF on fd %d to "
! 144: "ifindex %d for interface %s",
! 145: sock, connected->ifp->ifindex,
! 146: connected->ifp->name);
! 147: }
! 148:
! 149: return;
! 150: }
! 151:
! 152: /* Send RIP request packet to specified interface. */
! 153: static void
! 154: rip_request_interface_send (struct interface *ifp, u_char version)
! 155: {
! 156: struct sockaddr_in to;
! 157:
! 158: /* RIPv2 support multicast. */
! 159: if (version == RIPv2 && if_is_multicast (ifp))
! 160: {
! 161:
! 162: if (IS_RIP_DEBUG_EVENT)
! 163: zlog_debug ("multicast request on %s", ifp->name);
! 164:
! 165: rip_request_send (NULL, ifp, version, NULL);
! 166: return;
! 167: }
! 168:
! 169: /* RIPv1 and non multicast interface. */
! 170: if (if_is_pointopoint (ifp) || if_is_broadcast (ifp))
! 171: {
! 172: struct listnode *cnode, *cnnode;
! 173: struct connected *connected;
! 174:
! 175: if (IS_RIP_DEBUG_EVENT)
! 176: zlog_debug ("broadcast request to %s", ifp->name);
! 177:
! 178: for (ALL_LIST_ELEMENTS (ifp->connected, cnode, cnnode, connected))
! 179: {
! 180: if (connected->address->family == AF_INET)
! 181: {
! 182: memset (&to, 0, sizeof (struct sockaddr_in));
! 183: to.sin_port = htons (RIP_PORT_DEFAULT);
! 184: if (connected->destination)
! 185: /* use specified broadcast or peer destination addr */
! 186: to.sin_addr = connected->destination->u.prefix4;
! 187: else if (connected->address->prefixlen < IPV4_MAX_PREFIXLEN)
! 188: /* calculate the appropriate broadcast address */
! 189: to.sin_addr.s_addr =
! 190: ipv4_broadcast_addr(connected->address->u.prefix4.s_addr,
! 191: connected->address->prefixlen);
! 192: else
! 193: /* do not know where to send the packet */
! 194: continue;
! 195:
! 196: if (IS_RIP_DEBUG_EVENT)
! 197: zlog_debug ("SEND request to %s", inet_ntoa (to.sin_addr));
! 198:
! 199: rip_request_send (&to, ifp, version, connected);
! 200: }
! 201: }
! 202: }
! 203: }
! 204:
! 205: /* This will be executed when interface goes up. */
! 206: static void
! 207: rip_request_interface (struct interface *ifp)
! 208: {
! 209: struct rip_interface *ri;
! 210:
! 211: /* In default ripd doesn't send RIP_REQUEST to the loopback interface. */
! 212: if (if_is_loopback (ifp))
! 213: return;
! 214:
! 215: /* If interface is down, don't send RIP packet. */
! 216: if (! if_is_operative (ifp))
! 217: return;
! 218:
! 219: /* Fetch RIP interface information. */
! 220: ri = ifp->info;
! 221:
! 222:
! 223: /* If there is no version configuration in the interface,
! 224: use rip's version setting. */
! 225: {
! 226: int vsend = ((ri->ri_send == RI_RIP_UNSPEC) ?
! 227: rip->version_send : ri->ri_send);
! 228: if (vsend & RIPv1)
! 229: rip_request_interface_send (ifp, RIPv1);
! 230: if (vsend & RIPv2)
! 231: rip_request_interface_send (ifp, RIPv2);
! 232: }
! 233: }
! 234:
! 235: #if 0
! 236: /* Send RIP request to the neighbor. */
! 237: static void
! 238: rip_request_neighbor (struct in_addr addr)
! 239: {
! 240: struct sockaddr_in to;
! 241:
! 242: memset (&to, 0, sizeof (struct sockaddr_in));
! 243: to.sin_port = htons (RIP_PORT_DEFAULT);
! 244: to.sin_addr = addr;
! 245:
! 246: rip_request_send (&to, NULL, rip->version_send, NULL);
! 247: }
! 248:
! 249: /* Request routes at all interfaces. */
! 250: static void
! 251: rip_request_neighbor_all (void)
! 252: {
! 253: struct route_node *rp;
! 254:
! 255: if (! rip)
! 256: return;
! 257:
! 258: if (IS_RIP_DEBUG_EVENT)
! 259: zlog_debug ("request to the all neighbor");
! 260:
! 261: /* Send request to all neighbor. */
! 262: for (rp = route_top (rip->neighbor); rp; rp = route_next (rp))
! 263: if (rp->info)
! 264: rip_request_neighbor (rp->p.u.prefix4);
! 265: }
! 266: #endif
! 267:
! 268: /* Multicast packet receive socket. */
! 269: static int
! 270: rip_multicast_join (struct interface *ifp, int sock)
! 271: {
! 272: struct listnode *cnode;
! 273: struct connected *ifc;
! 274:
! 275: if (if_is_operative (ifp) && if_is_multicast (ifp))
! 276: {
! 277: if (IS_RIP_DEBUG_EVENT)
! 278: zlog_debug ("multicast join at %s", ifp->name);
! 279:
! 280: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, ifc))
! 281: {
! 282: struct prefix_ipv4 *p;
! 283: struct in_addr group;
! 284:
! 285: p = (struct prefix_ipv4 *) ifc->address;
! 286:
! 287: if (p->family != AF_INET)
! 288: continue;
! 289:
! 290: group.s_addr = htonl (INADDR_RIP_GROUP);
! 291: if (ipv4_multicast_join (sock, group, p->prefix, ifp->ifindex) < 0)
! 292: return -1;
! 293: else
! 294: return 0;
! 295: }
! 296: }
! 297: return 0;
! 298: }
! 299:
! 300: /* Leave from multicast group. */
! 301: static void
! 302: rip_multicast_leave (struct interface *ifp, int sock)
! 303: {
! 304: struct listnode *cnode;
! 305: struct connected *connected;
! 306:
! 307: if (if_is_up (ifp) && if_is_multicast (ifp))
! 308: {
! 309: if (IS_RIP_DEBUG_EVENT)
! 310: zlog_debug ("multicast leave from %s", ifp->name);
! 311:
! 312: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
! 313: {
! 314: struct prefix_ipv4 *p;
! 315: struct in_addr group;
! 316:
! 317: p = (struct prefix_ipv4 *) connected->address;
! 318:
! 319: if (p->family != AF_INET)
! 320: continue;
! 321:
! 322: group.s_addr = htonl (INADDR_RIP_GROUP);
! 323: if (ipv4_multicast_leave (sock, group, p->prefix, ifp->ifindex) == 0)
! 324: return;
! 325: }
! 326: }
! 327: }
! 328:
! 329: /* Is there and address on interface that I could use ? */
! 330: static int
! 331: rip_if_ipv4_address_check (struct interface *ifp)
! 332: {
! 333: struct listnode *nn;
! 334: struct connected *connected;
! 335: int count = 0;
! 336:
! 337: for (ALL_LIST_ELEMENTS_RO (ifp->connected, nn, connected))
! 338: {
! 339: struct prefix *p;
! 340:
! 341: p = connected->address;
! 342:
! 343: if (p->family == AF_INET)
! 344: count++;
! 345: }
! 346:
! 347: return count;
! 348: }
! 349:
! 350:
! 351:
! 352:
! 353: /* Does this address belongs to me ? */
! 354: int
! 355: if_check_address (struct in_addr addr)
! 356: {
! 357: struct listnode *node;
! 358: struct interface *ifp;
! 359:
! 360: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 361: {
! 362: struct listnode *cnode;
! 363: struct connected *connected;
! 364:
! 365: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
! 366: {
! 367: struct prefix_ipv4 *p;
! 368:
! 369: p = (struct prefix_ipv4 *) connected->address;
! 370:
! 371: if (p->family != AF_INET)
! 372: continue;
! 373:
! 374: if (IPV4_ADDR_CMP (&p->prefix, &addr) == 0)
! 375: return 1;
! 376: }
! 377: }
! 378: return 0;
! 379: }
! 380:
! 381: /* Inteface link down message processing. */
! 382: int
! 383: rip_interface_down (int command, struct zclient *zclient, zebra_size_t length)
! 384: {
! 385: struct interface *ifp;
! 386: struct stream *s;
! 387:
! 388: s = zclient->ibuf;
! 389:
! 390: /* zebra_interface_state_read() updates interface structure in
! 391: iflist. */
! 392: ifp = zebra_interface_state_read(s);
! 393:
! 394: if (ifp == NULL)
! 395: return 0;
! 396:
! 397: rip_if_down(ifp);
! 398:
! 399: if (IS_RIP_DEBUG_ZEBRA)
! 400: zlog_debug ("interface %s index %d flags %llx metric %d mtu %d is down",
! 401: ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
! 402: ifp->metric, ifp->mtu);
! 403:
! 404: return 0;
! 405: }
! 406:
! 407: /* Inteface link up message processing */
! 408: int
! 409: rip_interface_up (int command, struct zclient *zclient, zebra_size_t length)
! 410: {
! 411: struct interface *ifp;
! 412:
! 413: /* zebra_interface_state_read () updates interface structure in
! 414: iflist. */
! 415: ifp = zebra_interface_state_read (zclient->ibuf);
! 416:
! 417: if (ifp == NULL)
! 418: return 0;
! 419:
! 420: if (IS_RIP_DEBUG_ZEBRA)
! 421: zlog_debug ("interface %s index %d flags %#llx metric %d mtu %d is up",
! 422: ifp->name, ifp->ifindex, (unsigned long long) ifp->flags,
! 423: ifp->metric, ifp->mtu);
! 424:
! 425: /* Check if this interface is RIP enabled or not.*/
! 426: rip_enable_apply (ifp);
! 427:
! 428: /* Check for a passive interface */
! 429: rip_passive_interface_apply (ifp);
! 430:
! 431: /* Apply distribute list to the all interface. */
! 432: rip_distribute_update_interface (ifp);
! 433:
! 434: return 0;
! 435: }
! 436:
! 437: /* Inteface addition message from zebra. */
! 438: int
! 439: rip_interface_add (int command, struct zclient *zclient, zebra_size_t length)
! 440: {
! 441: struct interface *ifp;
! 442:
! 443: ifp = zebra_interface_add_read (zclient->ibuf);
! 444:
! 445: if (IS_RIP_DEBUG_ZEBRA)
! 446: zlog_debug ("interface add %s index %d flags %#llx metric %d mtu %d",
! 447: ifp->name, ifp->ifindex, (unsigned long long) ifp->flags,
! 448: ifp->metric, ifp->mtu);
! 449:
! 450: /* Check if this interface is RIP enabled or not.*/
! 451: rip_enable_apply (ifp);
! 452:
! 453: /* Check for a passive interface */
! 454: rip_passive_interface_apply (ifp);
! 455:
! 456: /* Apply distribute list to the all interface. */
! 457: rip_distribute_update_interface (ifp);
! 458:
! 459: /* rip_request_neighbor_all (); */
! 460:
! 461: /* Check interface routemap. */
! 462: rip_if_rmap_update_interface (ifp);
! 463:
! 464: return 0;
! 465: }
! 466:
! 467: int
! 468: rip_interface_delete (int command, struct zclient *zclient,
! 469: zebra_size_t length)
! 470: {
! 471: struct interface *ifp;
! 472: struct stream *s;
! 473:
! 474:
! 475: s = zclient->ibuf;
! 476: /* zebra_interface_state_read() updates interface structure in iflist */
! 477: ifp = zebra_interface_state_read(s);
! 478:
! 479: if (ifp == NULL)
! 480: return 0;
! 481:
! 482: if (if_is_up (ifp)) {
! 483: rip_if_down(ifp);
! 484: }
! 485:
! 486: zlog_info("interface delete %s index %d flags %#llx metric %d mtu %d",
! 487: ifp->name, ifp->ifindex, (unsigned long long) ifp->flags,
! 488: ifp->metric, ifp->mtu);
! 489:
! 490: /* To support pseudo interface do not free interface structure. */
! 491: /* if_delete(ifp); */
! 492: ifp->ifindex = IFINDEX_INTERNAL;
! 493:
! 494: return 0;
! 495: }
! 496:
! 497: void
! 498: rip_interface_clean (void)
! 499: {
! 500: struct listnode *node;
! 501: struct interface *ifp;
! 502: struct rip_interface *ri;
! 503:
! 504: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 505: {
! 506: ri = ifp->info;
! 507:
! 508: ri->enable_network = 0;
! 509: ri->enable_interface = 0;
! 510: ri->running = 0;
! 511:
! 512: if (ri->t_wakeup)
! 513: {
! 514: thread_cancel (ri->t_wakeup);
! 515: ri->t_wakeup = NULL;
! 516: }
! 517: }
! 518: }
! 519:
! 520: void
! 521: rip_interface_reset (void)
! 522: {
! 523: struct listnode *node;
! 524: struct interface *ifp;
! 525: struct rip_interface *ri;
! 526:
! 527: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 528: {
! 529: ri = ifp->info;
! 530:
! 531: ri->enable_network = 0;
! 532: ri->enable_interface = 0;
! 533: ri->running = 0;
! 534:
! 535: ri->ri_send = RI_RIP_UNSPEC;
! 536: ri->ri_receive = RI_RIP_UNSPEC;
! 537:
! 538: ri->auth_type = RIP_NO_AUTH;
! 539:
! 540: if (ri->auth_str)
! 541: {
! 542: free (ri->auth_str);
! 543: ri->auth_str = NULL;
! 544: }
! 545: if (ri->key_chain)
! 546: {
! 547: free (ri->key_chain);
! 548: ri->key_chain = NULL;
! 549: }
! 550:
! 551: ri->split_horizon = RIP_NO_SPLIT_HORIZON;
! 552: ri->split_horizon_default = RIP_NO_SPLIT_HORIZON;
! 553:
! 554: ri->list[RIP_FILTER_IN] = NULL;
! 555: ri->list[RIP_FILTER_OUT] = NULL;
! 556:
! 557: ri->prefix[RIP_FILTER_IN] = NULL;
! 558: ri->prefix[RIP_FILTER_OUT] = NULL;
! 559:
! 560: if (ri->t_wakeup)
! 561: {
! 562: thread_cancel (ri->t_wakeup);
! 563: ri->t_wakeup = NULL;
! 564: }
! 565:
! 566: ri->recv_badpackets = 0;
! 567: ri->recv_badroutes = 0;
! 568: ri->sent_updates = 0;
! 569:
! 570: ri->passive = 0;
! 571: }
! 572: }
! 573:
! 574: int
! 575: rip_if_down(struct interface *ifp)
! 576: {
! 577: struct route_node *rp;
! 578: struct rip_info *rinfo;
! 579: struct rip_interface *ri = NULL;
! 580: if (rip)
! 581: {
! 582: for (rp = route_top (rip->table); rp; rp = route_next (rp))
! 583: if ((rinfo = rp->info) != NULL)
! 584: {
! 585: /* Routes got through this interface. */
! 586: if (rinfo->ifindex == ifp->ifindex &&
! 587: rinfo->type == ZEBRA_ROUTE_RIP &&
! 588: rinfo->sub_type == RIP_ROUTE_RTE)
! 589: {
! 590: rip_zebra_ipv4_delete ((struct prefix_ipv4 *) &rp->p,
! 591: &rinfo->nexthop,
! 592: rinfo->metric);
! 593:
! 594: rip_redistribute_delete (rinfo->type,rinfo->sub_type,
! 595: (struct prefix_ipv4 *)&rp->p,
! 596: rinfo->ifindex);
! 597: }
! 598: else
! 599: {
! 600: /* All redistributed routes but static and system */
! 601: if ((rinfo->ifindex == ifp->ifindex) &&
! 602: /* (rinfo->type != ZEBRA_ROUTE_STATIC) && */
! 603: (rinfo->type != ZEBRA_ROUTE_SYSTEM))
! 604: rip_redistribute_delete (rinfo->type,rinfo->sub_type,
! 605: (struct prefix_ipv4 *)&rp->p,
! 606: rinfo->ifindex);
! 607: }
! 608: }
! 609: }
! 610:
! 611: ri = ifp->info;
! 612:
! 613: if (ri->running)
! 614: {
! 615: if (IS_RIP_DEBUG_EVENT)
! 616: zlog_debug ("turn off %s", ifp->name);
! 617:
! 618: /* Leave from multicast group. */
! 619: rip_multicast_leave (ifp, rip->sock);
! 620:
! 621: ri->running = 0;
! 622: }
! 623:
! 624: return 0;
! 625: }
! 626:
! 627: /* Needed for stop RIP process. */
! 628: void
! 629: rip_if_down_all ()
! 630: {
! 631: struct interface *ifp;
! 632: struct listnode *node, *nnode;
! 633:
! 634: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 635: rip_if_down (ifp);
! 636: }
! 637:
! 638: static void
! 639: rip_apply_address_add (struct connected *ifc)
! 640: {
! 641: struct prefix_ipv4 address;
! 642: struct prefix *p;
! 643:
! 644: if (!rip)
! 645: return;
! 646:
! 647: if (! if_is_up(ifc->ifp))
! 648: return;
! 649:
! 650: p = ifc->address;
! 651:
! 652: memset (&address, 0, sizeof (address));
! 653: address.family = p->family;
! 654: address.prefix = p->u.prefix4;
! 655: address.prefixlen = p->prefixlen;
! 656: apply_mask_ipv4(&address);
! 657:
! 658: /* Check if this interface is RIP enabled or not
! 659: or Check if this address's prefix is RIP enabled */
! 660: if ((rip_enable_if_lookup(ifc->ifp->name) >= 0) ||
! 661: (rip_enable_network_lookup2(ifc) >= 0))
! 662: rip_redistribute_add(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
! 663: &address, ifc->ifp->ifindex, NULL, 0, 0);
! 664:
! 665: }
! 666:
! 667: int
! 668: rip_interface_address_add (int command, struct zclient *zclient,
! 669: zebra_size_t length)
! 670: {
! 671: struct connected *ifc;
! 672: struct prefix *p;
! 673:
! 674: ifc = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
! 675: zclient->ibuf);
! 676:
! 677: if (ifc == NULL)
! 678: return 0;
! 679:
! 680: p = ifc->address;
! 681:
! 682: if (p->family == AF_INET)
! 683: {
! 684: if (IS_RIP_DEBUG_ZEBRA)
! 685: zlog_debug ("connected address %s/%d is added",
! 686: inet_ntoa (p->u.prefix4), p->prefixlen);
! 687:
! 688: rip_enable_apply(ifc->ifp);
! 689: /* Check if this prefix needs to be redistributed */
! 690: rip_apply_address_add(ifc);
! 691:
! 692: #ifdef HAVE_SNMP
! 693: rip_ifaddr_add (ifc->ifp, ifc);
! 694: #endif /* HAVE_SNMP */
! 695: }
! 696:
! 697: return 0;
! 698: }
! 699:
! 700: static void
! 701: rip_apply_address_del (struct connected *ifc) {
! 702: struct prefix_ipv4 address;
! 703: struct prefix *p;
! 704:
! 705: if (!rip)
! 706: return;
! 707:
! 708: if (! if_is_up(ifc->ifp))
! 709: return;
! 710:
! 711: p = ifc->address;
! 712:
! 713: memset (&address, 0, sizeof (address));
! 714: address.family = p->family;
! 715: address.prefix = p->u.prefix4;
! 716: address.prefixlen = p->prefixlen;
! 717: apply_mask_ipv4(&address);
! 718:
! 719: rip_redistribute_delete(ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
! 720: &address, ifc->ifp->ifindex);
! 721: }
! 722:
! 723: int
! 724: rip_interface_address_delete (int command, struct zclient *zclient,
! 725: zebra_size_t length)
! 726: {
! 727: struct connected *ifc;
! 728: struct prefix *p;
! 729:
! 730: ifc = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
! 731: zclient->ibuf);
! 732:
! 733: if (ifc)
! 734: {
! 735: p = ifc->address;
! 736: if (p->family == AF_INET)
! 737: {
! 738: if (IS_RIP_DEBUG_ZEBRA)
! 739: zlog_debug ("connected address %s/%d is deleted",
! 740: inet_ntoa (p->u.prefix4), p->prefixlen);
! 741:
! 742: #ifdef HAVE_SNMP
! 743: rip_ifaddr_delete (ifc->ifp, ifc);
! 744: #endif /* HAVE_SNMP */
! 745:
! 746: /* Chech wether this prefix needs to be removed */
! 747: rip_apply_address_del(ifc);
! 748:
! 749: }
! 750:
! 751: connected_free (ifc);
! 752:
! 753: }
! 754:
! 755: return 0;
! 756: }
! 757:
! 758: /* Check interface is enabled by network statement. */
! 759: /* Check wether the interface has at least a connected prefix that
! 760: * is within the ripng_enable_network table. */
! 761: static int
! 762: rip_enable_network_lookup_if (struct interface *ifp)
! 763: {
! 764: struct listnode *node, *nnode;
! 765: struct connected *connected;
! 766: struct prefix_ipv4 address;
! 767:
! 768: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, connected))
! 769: {
! 770: struct prefix *p;
! 771: struct route_node *node;
! 772:
! 773: p = connected->address;
! 774:
! 775: if (p->family == AF_INET)
! 776: {
! 777: address.family = AF_INET;
! 778: address.prefix = p->u.prefix4;
! 779: address.prefixlen = IPV4_MAX_BITLEN;
! 780:
! 781: node = route_node_match (rip_enable_network,
! 782: (struct prefix *)&address);
! 783: if (node)
! 784: {
! 785: route_unlock_node (node);
! 786: return 1;
! 787: }
! 788: }
! 789: }
! 790: return -1;
! 791: }
! 792:
! 793: /* Check wether connected is within the ripng_enable_network table. */
! 794: int
! 795: rip_enable_network_lookup2 (struct connected *connected)
! 796: {
! 797: struct prefix_ipv4 address;
! 798: struct prefix *p;
! 799:
! 800: p = connected->address;
! 801:
! 802: if (p->family == AF_INET) {
! 803: struct route_node *node;
! 804:
! 805: address.family = p->family;
! 806: address.prefix = p->u.prefix4;
! 807: address.prefixlen = IPV4_MAX_BITLEN;
! 808:
! 809: /* LPM on p->family, p->u.prefix4/IPV4_MAX_BITLEN within rip_enable_network */
! 810: node = route_node_match (rip_enable_network,
! 811: (struct prefix *)&address);
! 812:
! 813: if (node) {
! 814: route_unlock_node (node);
! 815: return 1;
! 816: }
! 817: }
! 818:
! 819: return -1;
! 820: }
! 821: /* Add RIP enable network. */
! 822: static int
! 823: rip_enable_network_add (struct prefix *p)
! 824: {
! 825: struct route_node *node;
! 826:
! 827: node = route_node_get (rip_enable_network, p);
! 828:
! 829: if (node->info)
! 830: {
! 831: route_unlock_node (node);
! 832: return -1;
! 833: }
! 834: else
! 835: node->info = (char *) "enabled";
! 836:
! 837: /* XXX: One should find a better solution than a generic one */
! 838: rip_enable_apply_all();
! 839:
! 840: return 1;
! 841: }
! 842:
! 843: /* Delete RIP enable network. */
! 844: static int
! 845: rip_enable_network_delete (struct prefix *p)
! 846: {
! 847: struct route_node *node;
! 848:
! 849: node = route_node_lookup (rip_enable_network, p);
! 850: if (node)
! 851: {
! 852: node->info = NULL;
! 853:
! 854: /* Unlock info lock. */
! 855: route_unlock_node (node);
! 856:
! 857: /* Unlock lookup lock. */
! 858: route_unlock_node (node);
! 859:
! 860: /* XXX: One should find a better solution than a generic one */
! 861: rip_enable_apply_all ();
! 862:
! 863: return 1;
! 864: }
! 865: return -1;
! 866: }
! 867:
! 868: /* Check interface is enabled by ifname statement. */
! 869: static int
! 870: rip_enable_if_lookup (const char *ifname)
! 871: {
! 872: unsigned int i;
! 873: char *str;
! 874:
! 875: for (i = 0; i < vector_active (rip_enable_interface); i++)
! 876: if ((str = vector_slot (rip_enable_interface, i)) != NULL)
! 877: if (strcmp (str, ifname) == 0)
! 878: return i;
! 879: return -1;
! 880: }
! 881:
! 882: /* Add interface to rip_enable_if. */
! 883: static int
! 884: rip_enable_if_add (const char *ifname)
! 885: {
! 886: int ret;
! 887:
! 888: ret = rip_enable_if_lookup (ifname);
! 889: if (ret >= 0)
! 890: return -1;
! 891:
! 892: vector_set (rip_enable_interface, strdup (ifname));
! 893:
! 894: rip_enable_apply_all(); /* TODOVJ */
! 895:
! 896: return 1;
! 897: }
! 898:
! 899: /* Delete interface from rip_enable_if. */
! 900: static int
! 901: rip_enable_if_delete (const char *ifname)
! 902: {
! 903: int index;
! 904: char *str;
! 905:
! 906: index = rip_enable_if_lookup (ifname);
! 907: if (index < 0)
! 908: return -1;
! 909:
! 910: str = vector_slot (rip_enable_interface, index);
! 911: free (str);
! 912: vector_unset (rip_enable_interface, index);
! 913:
! 914: rip_enable_apply_all(); /* TODOVJ */
! 915:
! 916: return 1;
! 917: }
! 918:
! 919: /* Join to multicast group and send request to the interface. */
! 920: static int
! 921: rip_interface_wakeup (struct thread *t)
! 922: {
! 923: struct interface *ifp;
! 924: struct rip_interface *ri;
! 925:
! 926: /* Get interface. */
! 927: ifp = THREAD_ARG (t);
! 928:
! 929: ri = ifp->info;
! 930: ri->t_wakeup = NULL;
! 931:
! 932: /* Join to multicast group. */
! 933: if (rip_multicast_join (ifp, rip->sock) < 0)
! 934: {
! 935: zlog_err ("multicast join failed, interface %s not running", ifp->name);
! 936: return 0;
! 937: }
! 938:
! 939: /* Set running flag. */
! 940: ri->running = 1;
! 941:
! 942: /* Send RIP request to the interface. */
! 943: rip_request_interface (ifp);
! 944:
! 945: return 0;
! 946: }
! 947:
! 948: static void
! 949: rip_connect_set (struct interface *ifp, int set)
! 950: {
! 951: struct listnode *node, *nnode;
! 952: struct connected *connected;
! 953: struct prefix_ipv4 address;
! 954:
! 955: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, connected))
! 956: {
! 957: struct prefix *p;
! 958: p = connected->address;
! 959:
! 960: if (p->family != AF_INET)
! 961: continue;
! 962:
! 963: address.family = AF_INET;
! 964: address.prefix = p->u.prefix4;
! 965: address.prefixlen = p->prefixlen;
! 966: apply_mask_ipv4 (&address);
! 967:
! 968: if (set) {
! 969: /* Check once more wether this prefix is within a "network IF_OR_PREF" one */
! 970: if ((rip_enable_if_lookup(connected->ifp->name) >= 0) ||
! 971: (rip_enable_network_lookup2(connected) >= 0))
! 972: rip_redistribute_add (ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
! 973: &address, connected->ifp->ifindex,
! 974: NULL, 0, 0);
! 975: } else
! 976: {
! 977: rip_redistribute_delete (ZEBRA_ROUTE_CONNECT, RIP_ROUTE_INTERFACE,
! 978: &address, connected->ifp->ifindex);
! 979: if (rip_redistribute_check (ZEBRA_ROUTE_CONNECT))
! 980: rip_redistribute_add (ZEBRA_ROUTE_CONNECT, RIP_ROUTE_REDISTRIBUTE,
! 981: &address, connected->ifp->ifindex,
! 982: NULL, 0, 0);
! 983: }
! 984: }
! 985: }
! 986:
! 987: /* Update interface status. */
! 988: void
! 989: rip_enable_apply (struct interface *ifp)
! 990: {
! 991: int ret;
! 992: struct rip_interface *ri = NULL;
! 993:
! 994: /* Check interface. */
! 995: if (! if_is_operative (ifp))
! 996: return;
! 997:
! 998: ri = ifp->info;
! 999:
! 1000: /* Check network configuration. */
! 1001: ret = rip_enable_network_lookup_if (ifp);
! 1002:
! 1003: /* If the interface is matched. */
! 1004: if (ret > 0)
! 1005: ri->enable_network = 1;
! 1006: else
! 1007: ri->enable_network = 0;
! 1008:
! 1009: /* Check interface name configuration. */
! 1010: ret = rip_enable_if_lookup (ifp->name);
! 1011: if (ret >= 0)
! 1012: ri->enable_interface = 1;
! 1013: else
! 1014: ri->enable_interface = 0;
! 1015:
! 1016: /* any interface MUST have an IPv4 address */
! 1017: if ( ! rip_if_ipv4_address_check (ifp) )
! 1018: {
! 1019: ri->enable_network = 0;
! 1020: ri->enable_interface = 0;
! 1021: }
! 1022:
! 1023: /* Update running status of the interface. */
! 1024: if (ri->enable_network || ri->enable_interface)
! 1025: {
! 1026: {
! 1027: if (IS_RIP_DEBUG_EVENT)
! 1028: zlog_debug ("turn on %s", ifp->name);
! 1029:
! 1030: /* Add interface wake up thread. */
! 1031: if (! ri->t_wakeup)
! 1032: ri->t_wakeup = thread_add_timer (master, rip_interface_wakeup,
! 1033: ifp, 1);
! 1034: rip_connect_set (ifp, 1);
! 1035: }
! 1036: }
! 1037: else
! 1038: {
! 1039: if (ri->running)
! 1040: {
! 1041: /* Might as well clean up the route table as well
! 1042: * rip_if_down sets to 0 ri->running, and displays "turn off %s"
! 1043: **/
! 1044: rip_if_down(ifp);
! 1045:
! 1046: rip_connect_set (ifp, 0);
! 1047: }
! 1048: }
! 1049: }
! 1050:
! 1051: /* Apply network configuration to all interface. */
! 1052: void
! 1053: rip_enable_apply_all ()
! 1054: {
! 1055: struct interface *ifp;
! 1056: struct listnode *node, *nnode;
! 1057:
! 1058: /* Check each interface. */
! 1059: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 1060: rip_enable_apply (ifp);
! 1061: }
! 1062:
! 1063: int
! 1064: rip_neighbor_lookup (struct sockaddr_in *from)
! 1065: {
! 1066: struct prefix_ipv4 p;
! 1067: struct route_node *node;
! 1068:
! 1069: memset (&p, 0, sizeof (struct prefix_ipv4));
! 1070: p.family = AF_INET;
! 1071: p.prefix = from->sin_addr;
! 1072: p.prefixlen = IPV4_MAX_BITLEN;
! 1073:
! 1074: node = route_node_lookup (rip->neighbor, (struct prefix *) &p);
! 1075: if (node)
! 1076: {
! 1077: route_unlock_node (node);
! 1078: return 1;
! 1079: }
! 1080: return 0;
! 1081: }
! 1082:
! 1083: /* Add new RIP neighbor to the neighbor tree. */
! 1084: static int
! 1085: rip_neighbor_add (struct prefix_ipv4 *p)
! 1086: {
! 1087: struct route_node *node;
! 1088:
! 1089: node = route_node_get (rip->neighbor, (struct prefix *) p);
! 1090:
! 1091: if (node->info)
! 1092: return -1;
! 1093:
! 1094: node->info = rip->neighbor;
! 1095:
! 1096: return 0;
! 1097: }
! 1098:
! 1099: /* Delete RIP neighbor from the neighbor tree. */
! 1100: static int
! 1101: rip_neighbor_delete (struct prefix_ipv4 *p)
! 1102: {
! 1103: struct route_node *node;
! 1104:
! 1105: /* Lock for look up. */
! 1106: node = route_node_lookup (rip->neighbor, (struct prefix *) p);
! 1107: if (! node)
! 1108: return -1;
! 1109:
! 1110: node->info = NULL;
! 1111:
! 1112: /* Unlock lookup lock. */
! 1113: route_unlock_node (node);
! 1114:
! 1115: /* Unlock real neighbor information lock. */
! 1116: route_unlock_node (node);
! 1117:
! 1118: return 0;
! 1119: }
! 1120:
! 1121: /* Clear all network and neighbor configuration. */
! 1122: void
! 1123: rip_clean_network ()
! 1124: {
! 1125: unsigned int i;
! 1126: char *str;
! 1127: struct route_node *rn;
! 1128:
! 1129: /* rip_enable_network. */
! 1130: for (rn = route_top (rip_enable_network); rn; rn = route_next (rn))
! 1131: if (rn->info)
! 1132: {
! 1133: rn->info = NULL;
! 1134: route_unlock_node (rn);
! 1135: }
! 1136:
! 1137: /* rip_enable_interface. */
! 1138: for (i = 0; i < vector_active (rip_enable_interface); i++)
! 1139: if ((str = vector_slot (rip_enable_interface, i)) != NULL)
! 1140: {
! 1141: free (str);
! 1142: vector_slot (rip_enable_interface, i) = NULL;
! 1143: }
! 1144: }
! 1145:
! 1146: /* Utility function for looking up passive interface settings. */
! 1147: static int
! 1148: rip_passive_nondefault_lookup (const char *ifname)
! 1149: {
! 1150: unsigned int i;
! 1151: char *str;
! 1152:
! 1153: for (i = 0; i < vector_active (Vrip_passive_nondefault); i++)
! 1154: if ((str = vector_slot (Vrip_passive_nondefault, i)) != NULL)
! 1155: if (strcmp (str, ifname) == 0)
! 1156: return i;
! 1157: return -1;
! 1158: }
! 1159:
! 1160: void
! 1161: rip_passive_interface_apply (struct interface *ifp)
! 1162: {
! 1163: struct rip_interface *ri;
! 1164:
! 1165: ri = ifp->info;
! 1166:
! 1167: ri->passive = ((rip_passive_nondefault_lookup (ifp->name) < 0) ?
! 1168: passive_default : !passive_default);
! 1169:
! 1170: if (IS_RIP_DEBUG_ZEBRA)
! 1171: zlog_debug ("interface %s: passive = %d",ifp->name,ri->passive);
! 1172: }
! 1173:
! 1174: static void
! 1175: rip_passive_interface_apply_all (void)
! 1176: {
! 1177: struct interface *ifp;
! 1178: struct listnode *node, *nnode;
! 1179:
! 1180: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 1181: rip_passive_interface_apply (ifp);
! 1182: }
! 1183:
! 1184: /* Passive interface. */
! 1185: static int
! 1186: rip_passive_nondefault_set (struct vty *vty, const char *ifname)
! 1187: {
! 1188: if (rip_passive_nondefault_lookup (ifname) >= 0)
! 1189: return CMD_WARNING;
! 1190:
! 1191: vector_set (Vrip_passive_nondefault, strdup (ifname));
! 1192:
! 1193: rip_passive_interface_apply_all ();
! 1194:
! 1195: return CMD_SUCCESS;
! 1196: }
! 1197:
! 1198: static int
! 1199: rip_passive_nondefault_unset (struct vty *vty, const char *ifname)
! 1200: {
! 1201: int i;
! 1202: char *str;
! 1203:
! 1204: i = rip_passive_nondefault_lookup (ifname);
! 1205: if (i < 0)
! 1206: return CMD_WARNING;
! 1207:
! 1208: str = vector_slot (Vrip_passive_nondefault, i);
! 1209: free (str);
! 1210: vector_unset (Vrip_passive_nondefault, i);
! 1211:
! 1212: rip_passive_interface_apply_all ();
! 1213:
! 1214: return CMD_SUCCESS;
! 1215: }
! 1216:
! 1217: /* Free all configured RIP passive-interface settings. */
! 1218: void
! 1219: rip_passive_nondefault_clean (void)
! 1220: {
! 1221: unsigned int i;
! 1222: char *str;
! 1223:
! 1224: for (i = 0; i < vector_active (Vrip_passive_nondefault); i++)
! 1225: if ((str = vector_slot (Vrip_passive_nondefault, i)) != NULL)
! 1226: {
! 1227: free (str);
! 1228: vector_slot (Vrip_passive_nondefault, i) = NULL;
! 1229: }
! 1230: rip_passive_interface_apply_all ();
! 1231: }
! 1232:
! 1233: /* RIP enable network or interface configuration. */
! 1234: DEFUN (rip_network,
! 1235: rip_network_cmd,
! 1236: "network (A.B.C.D/M|WORD)",
! 1237: "Enable routing on an IP network\n"
! 1238: "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
! 1239: "Interface name\n")
! 1240: {
! 1241: int ret;
! 1242: struct prefix_ipv4 p;
! 1243:
! 1244: ret = str2prefix_ipv4 (argv[0], &p);
! 1245:
! 1246: if (ret)
! 1247: ret = rip_enable_network_add ((struct prefix *) &p);
! 1248: else
! 1249: ret = rip_enable_if_add (argv[0]);
! 1250:
! 1251: if (ret < 0)
! 1252: {
! 1253: vty_out (vty, "There is a same network configuration %s%s", argv[0],
! 1254: VTY_NEWLINE);
! 1255: return CMD_WARNING;
! 1256: }
! 1257:
! 1258: return CMD_SUCCESS;
! 1259: }
! 1260:
! 1261: /* RIP enable network or interface configuration. */
! 1262: DEFUN (no_rip_network,
! 1263: no_rip_network_cmd,
! 1264: "no network (A.B.C.D/M|WORD)",
! 1265: NO_STR
! 1266: "Enable routing on an IP network\n"
! 1267: "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
! 1268: "Interface name\n")
! 1269: {
! 1270: int ret;
! 1271: struct prefix_ipv4 p;
! 1272:
! 1273: ret = str2prefix_ipv4 (argv[0], &p);
! 1274:
! 1275: if (ret)
! 1276: ret = rip_enable_network_delete ((struct prefix *) &p);
! 1277: else
! 1278: ret = rip_enable_if_delete (argv[0]);
! 1279:
! 1280: if (ret < 0)
! 1281: {
! 1282: vty_out (vty, "Can't find network configuration %s%s", argv[0],
! 1283: VTY_NEWLINE);
! 1284: return CMD_WARNING;
! 1285: }
! 1286:
! 1287: return CMD_SUCCESS;
! 1288: }
! 1289:
! 1290: /* RIP neighbor configuration set. */
! 1291: DEFUN (rip_neighbor,
! 1292: rip_neighbor_cmd,
! 1293: "neighbor A.B.C.D",
! 1294: "Specify a neighbor router\n"
! 1295: "Neighbor address\n")
! 1296: {
! 1297: int ret;
! 1298: struct prefix_ipv4 p;
! 1299:
! 1300: ret = str2prefix_ipv4 (argv[0], &p);
! 1301:
! 1302: if (ret <= 0)
! 1303: {
! 1304: vty_out (vty, "Please specify address by A.B.C.D%s", VTY_NEWLINE);
! 1305: return CMD_WARNING;
! 1306: }
! 1307:
! 1308: rip_neighbor_add (&p);
! 1309:
! 1310: return CMD_SUCCESS;
! 1311: }
! 1312:
! 1313: /* RIP neighbor configuration unset. */
! 1314: DEFUN (no_rip_neighbor,
! 1315: no_rip_neighbor_cmd,
! 1316: "no neighbor A.B.C.D",
! 1317: NO_STR
! 1318: "Specify a neighbor router\n"
! 1319: "Neighbor address\n")
! 1320: {
! 1321: int ret;
! 1322: struct prefix_ipv4 p;
! 1323:
! 1324: ret = str2prefix_ipv4 (argv[0], &p);
! 1325:
! 1326: if (ret <= 0)
! 1327: {
! 1328: vty_out (vty, "Please specify address by A.B.C.D%s", VTY_NEWLINE);
! 1329: return CMD_WARNING;
! 1330: }
! 1331:
! 1332: rip_neighbor_delete (&p);
! 1333:
! 1334: return CMD_SUCCESS;
! 1335: }
! 1336:
! 1337: DEFUN (ip_rip_receive_version,
! 1338: ip_rip_receive_version_cmd,
! 1339: "ip rip receive version (1|2)",
! 1340: IP_STR
! 1341: "Routing Information Protocol\n"
! 1342: "Advertisement reception\n"
! 1343: "Version control\n"
! 1344: "RIP version 1\n"
! 1345: "RIP version 2\n")
! 1346: {
! 1347: struct interface *ifp;
! 1348: struct rip_interface *ri;
! 1349:
! 1350: ifp = (struct interface *)vty->index;
! 1351: ri = ifp->info;
! 1352:
! 1353: /* Version 1. */
! 1354: if (atoi (argv[0]) == 1)
! 1355: {
! 1356: ri->ri_receive = RI_RIP_VERSION_1;
! 1357: return CMD_SUCCESS;
! 1358: }
! 1359: if (atoi (argv[0]) == 2)
! 1360: {
! 1361: ri->ri_receive = RI_RIP_VERSION_2;
! 1362: return CMD_SUCCESS;
! 1363: }
! 1364: return CMD_WARNING;
! 1365: }
! 1366:
! 1367: DEFUN (ip_rip_receive_version_1,
! 1368: ip_rip_receive_version_1_cmd,
! 1369: "ip rip receive version 1 2",
! 1370: IP_STR
! 1371: "Routing Information Protocol\n"
! 1372: "Advertisement reception\n"
! 1373: "Version control\n"
! 1374: "RIP version 1\n"
! 1375: "RIP version 2\n")
! 1376: {
! 1377: struct interface *ifp;
! 1378: struct rip_interface *ri;
! 1379:
! 1380: ifp = (struct interface *)vty->index;
! 1381: ri = ifp->info;
! 1382:
! 1383: /* Version 1 and 2. */
! 1384: ri->ri_receive = RI_RIP_VERSION_1_AND_2;
! 1385: return CMD_SUCCESS;
! 1386: }
! 1387:
! 1388: DEFUN (ip_rip_receive_version_2,
! 1389: ip_rip_receive_version_2_cmd,
! 1390: "ip rip receive version 2 1",
! 1391: IP_STR
! 1392: "Routing Information Protocol\n"
! 1393: "Advertisement reception\n"
! 1394: "Version control\n"
! 1395: "RIP version 2\n"
! 1396: "RIP version 1\n")
! 1397: {
! 1398: struct interface *ifp;
! 1399: struct rip_interface *ri;
! 1400:
! 1401: ifp = (struct interface *)vty->index;
! 1402: ri = ifp->info;
! 1403:
! 1404: /* Version 1 and 2. */
! 1405: ri->ri_receive = RI_RIP_VERSION_1_AND_2;
! 1406: return CMD_SUCCESS;
! 1407: }
! 1408:
! 1409: DEFUN (no_ip_rip_receive_version,
! 1410: no_ip_rip_receive_version_cmd,
! 1411: "no ip rip receive version",
! 1412: NO_STR
! 1413: IP_STR
! 1414: "Routing Information Protocol\n"
! 1415: "Advertisement reception\n"
! 1416: "Version control\n")
! 1417: {
! 1418: struct interface *ifp;
! 1419: struct rip_interface *ri;
! 1420:
! 1421: ifp = (struct interface *)vty->index;
! 1422: ri = ifp->info;
! 1423:
! 1424: ri->ri_receive = RI_RIP_UNSPEC;
! 1425: return CMD_SUCCESS;
! 1426: }
! 1427:
! 1428: ALIAS (no_ip_rip_receive_version,
! 1429: no_ip_rip_receive_version_num_cmd,
! 1430: "no ip rip receive version (1|2)",
! 1431: NO_STR
! 1432: IP_STR
! 1433: "Routing Information Protocol\n"
! 1434: "Advertisement reception\n"
! 1435: "Version control\n"
! 1436: "Version 1\n"
! 1437: "Version 2\n")
! 1438:
! 1439: DEFUN (ip_rip_send_version,
! 1440: ip_rip_send_version_cmd,
! 1441: "ip rip send version (1|2)",
! 1442: IP_STR
! 1443: "Routing Information Protocol\n"
! 1444: "Advertisement transmission\n"
! 1445: "Version control\n"
! 1446: "RIP version 1\n"
! 1447: "RIP version 2\n")
! 1448: {
! 1449: struct interface *ifp;
! 1450: struct rip_interface *ri;
! 1451:
! 1452: ifp = (struct interface *)vty->index;
! 1453: ri = ifp->info;
! 1454:
! 1455: /* Version 1. */
! 1456: if (atoi (argv[0]) == 1)
! 1457: {
! 1458: ri->ri_send = RI_RIP_VERSION_1;
! 1459: return CMD_SUCCESS;
! 1460: }
! 1461: if (atoi (argv[0]) == 2)
! 1462: {
! 1463: ri->ri_send = RI_RIP_VERSION_2;
! 1464: return CMD_SUCCESS;
! 1465: }
! 1466: return CMD_WARNING;
! 1467: }
! 1468:
! 1469: DEFUN (ip_rip_send_version_1,
! 1470: ip_rip_send_version_1_cmd,
! 1471: "ip rip send version 1 2",
! 1472: IP_STR
! 1473: "Routing Information Protocol\n"
! 1474: "Advertisement transmission\n"
! 1475: "Version control\n"
! 1476: "RIP version 1\n"
! 1477: "RIP version 2\n")
! 1478: {
! 1479: struct interface *ifp;
! 1480: struct rip_interface *ri;
! 1481:
! 1482: ifp = (struct interface *)vty->index;
! 1483: ri = ifp->info;
! 1484:
! 1485: /* Version 1 and 2. */
! 1486: ri->ri_send = RI_RIP_VERSION_1_AND_2;
! 1487: return CMD_SUCCESS;
! 1488: }
! 1489:
! 1490: DEFUN (ip_rip_send_version_2,
! 1491: ip_rip_send_version_2_cmd,
! 1492: "ip rip send version 2 1",
! 1493: IP_STR
! 1494: "Routing Information Protocol\n"
! 1495: "Advertisement transmission\n"
! 1496: "Version control\n"
! 1497: "RIP version 2\n"
! 1498: "RIP version 1\n")
! 1499: {
! 1500: struct interface *ifp;
! 1501: struct rip_interface *ri;
! 1502:
! 1503: ifp = (struct interface *)vty->index;
! 1504: ri = ifp->info;
! 1505:
! 1506: /* Version 1 and 2. */
! 1507: ri->ri_send = RI_RIP_VERSION_1_AND_2;
! 1508: return CMD_SUCCESS;
! 1509: }
! 1510:
! 1511: DEFUN (no_ip_rip_send_version,
! 1512: no_ip_rip_send_version_cmd,
! 1513: "no ip rip send version",
! 1514: NO_STR
! 1515: IP_STR
! 1516: "Routing Information Protocol\n"
! 1517: "Advertisement transmission\n"
! 1518: "Version control\n")
! 1519: {
! 1520: struct interface *ifp;
! 1521: struct rip_interface *ri;
! 1522:
! 1523: ifp = (struct interface *)vty->index;
! 1524: ri = ifp->info;
! 1525:
! 1526: ri->ri_send = RI_RIP_UNSPEC;
! 1527: return CMD_SUCCESS;
! 1528: }
! 1529:
! 1530: ALIAS (no_ip_rip_send_version,
! 1531: no_ip_rip_send_version_num_cmd,
! 1532: "no ip rip send version (1|2)",
! 1533: NO_STR
! 1534: IP_STR
! 1535: "Routing Information Protocol\n"
! 1536: "Advertisement transmission\n"
! 1537: "Version control\n"
! 1538: "Version 1\n"
! 1539: "Version 2\n")
! 1540:
! 1541: DEFUN (ip_rip_authentication_mode,
! 1542: ip_rip_authentication_mode_cmd,
! 1543: "ip rip authentication mode (md5|text)",
! 1544: IP_STR
! 1545: "Routing Information Protocol\n"
! 1546: "Authentication control\n"
! 1547: "Authentication mode\n"
! 1548: "Keyed message digest\n"
! 1549: "Clear text authentication\n")
! 1550: {
! 1551: struct interface *ifp;
! 1552: struct rip_interface *ri;
! 1553: int auth_type;
! 1554:
! 1555: ifp = (struct interface *)vty->index;
! 1556: ri = ifp->info;
! 1557:
! 1558: if ( (argc < 1) || (argc > 2) )
! 1559: {
! 1560: vty_out (vty, "incorrect argument count%s", VTY_NEWLINE);
! 1561: return CMD_WARNING;
! 1562: }
! 1563:
! 1564: if (strncmp ("md5", argv[0], strlen (argv[0])) == 0)
! 1565: auth_type = RIP_AUTH_MD5;
! 1566: else if (strncmp ("text", argv[0], strlen (argv[0])) == 0)
! 1567: auth_type = RIP_AUTH_SIMPLE_PASSWORD;
! 1568: else
! 1569: {
! 1570: vty_out (vty, "mode should be md5 or text%s", VTY_NEWLINE);
! 1571: return CMD_WARNING;
! 1572: }
! 1573:
! 1574: if (argc == 1)
! 1575: {
! 1576: ri->auth_type = auth_type;
! 1577: return CMD_SUCCESS;
! 1578: }
! 1579:
! 1580: if ( (argc == 2) && (auth_type != RIP_AUTH_MD5) )
! 1581: {
! 1582: vty_out (vty, "auth length argument only valid for md5%s", VTY_NEWLINE);
! 1583: return CMD_WARNING;
! 1584: }
! 1585:
! 1586: if (strncmp ("r", argv[1], 1) == 0)
! 1587: ri->md5_auth_len = RIP_AUTH_MD5_SIZE;
! 1588: else if (strncmp ("o", argv[1], 1) == 0)
! 1589: ri->md5_auth_len = RIP_AUTH_MD5_COMPAT_SIZE;
! 1590: else
! 1591: return CMD_WARNING;
! 1592:
! 1593: ri->auth_type = auth_type;
! 1594:
! 1595: return CMD_SUCCESS;
! 1596: }
! 1597:
! 1598: ALIAS (ip_rip_authentication_mode,
! 1599: ip_rip_authentication_mode_authlen_cmd,
! 1600: "ip rip authentication mode (md5|text) auth-length (rfc|old-ripd)",
! 1601: IP_STR
! 1602: "Routing Information Protocol\n"
! 1603: "Authentication control\n"
! 1604: "Authentication mode\n"
! 1605: "Keyed message digest\n"
! 1606: "Clear text authentication\n"
! 1607: "MD5 authentication data length\n"
! 1608: "RFC compatible\n"
! 1609: "Old ripd compatible\n")
! 1610:
! 1611: DEFUN (no_ip_rip_authentication_mode,
! 1612: no_ip_rip_authentication_mode_cmd,
! 1613: "no ip rip authentication mode",
! 1614: NO_STR
! 1615: IP_STR
! 1616: "Routing Information Protocol\n"
! 1617: "Authentication control\n"
! 1618: "Authentication mode\n")
! 1619: {
! 1620: struct interface *ifp;
! 1621: struct rip_interface *ri;
! 1622:
! 1623: ifp = (struct interface *)vty->index;
! 1624: ri = ifp->info;
! 1625:
! 1626: ri->auth_type = RIP_NO_AUTH;
! 1627: ri->md5_auth_len = RIP_AUTH_MD5_COMPAT_SIZE;
! 1628:
! 1629: return CMD_SUCCESS;
! 1630: }
! 1631:
! 1632: ALIAS (no_ip_rip_authentication_mode,
! 1633: no_ip_rip_authentication_mode_type_cmd,
! 1634: "no ip rip authentication mode (md5|text)",
! 1635: NO_STR
! 1636: IP_STR
! 1637: "Routing Information Protocol\n"
! 1638: "Authentication control\n"
! 1639: "Authentication mode\n"
! 1640: "Keyed message digest\n"
! 1641: "Clear text authentication\n")
! 1642:
! 1643: ALIAS (no_ip_rip_authentication_mode,
! 1644: no_ip_rip_authentication_mode_type_authlen_cmd,
! 1645: "no ip rip authentication mode (md5|text) auth-length (rfc|old-ripd)",
! 1646: NO_STR
! 1647: IP_STR
! 1648: "Routing Information Protocol\n"
! 1649: "Authentication control\n"
! 1650: "Authentication mode\n"
! 1651: "Keyed message digest\n"
! 1652: "Clear text authentication\n"
! 1653: "MD5 authentication data length\n"
! 1654: "RFC compatible\n"
! 1655: "Old ripd compatible\n")
! 1656:
! 1657: DEFUN (ip_rip_authentication_string,
! 1658: ip_rip_authentication_string_cmd,
! 1659: "ip rip authentication string LINE",
! 1660: IP_STR
! 1661: "Routing Information Protocol\n"
! 1662: "Authentication control\n"
! 1663: "Authentication string\n"
! 1664: "Authentication string\n")
! 1665: {
! 1666: struct interface *ifp;
! 1667: struct rip_interface *ri;
! 1668:
! 1669: ifp = (struct interface *)vty->index;
! 1670: ri = ifp->info;
! 1671:
! 1672: if (strlen (argv[0]) > 16)
! 1673: {
! 1674: vty_out (vty, "%% RIPv2 authentication string must be shorter than 16%s",
! 1675: VTY_NEWLINE);
! 1676: return CMD_WARNING;
! 1677: }
! 1678:
! 1679: if (ri->key_chain)
! 1680: {
! 1681: vty_out (vty, "%% key-chain configuration exists%s", VTY_NEWLINE);
! 1682: return CMD_WARNING;
! 1683: }
! 1684:
! 1685: if (ri->auth_str)
! 1686: free (ri->auth_str);
! 1687:
! 1688: ri->auth_str = strdup (argv[0]);
! 1689:
! 1690: return CMD_SUCCESS;
! 1691: }
! 1692:
! 1693: DEFUN (no_ip_rip_authentication_string,
! 1694: no_ip_rip_authentication_string_cmd,
! 1695: "no ip rip authentication string",
! 1696: NO_STR
! 1697: IP_STR
! 1698: "Routing Information Protocol\n"
! 1699: "Authentication control\n"
! 1700: "Authentication string\n")
! 1701: {
! 1702: struct interface *ifp;
! 1703: struct rip_interface *ri;
! 1704:
! 1705: ifp = (struct interface *)vty->index;
! 1706: ri = ifp->info;
! 1707:
! 1708: if (ri->auth_str)
! 1709: free (ri->auth_str);
! 1710:
! 1711: ri->auth_str = NULL;
! 1712:
! 1713: return CMD_SUCCESS;
! 1714: }
! 1715:
! 1716: ALIAS (no_ip_rip_authentication_string,
! 1717: no_ip_rip_authentication_string2_cmd,
! 1718: "no ip rip authentication string LINE",
! 1719: NO_STR
! 1720: IP_STR
! 1721: "Routing Information Protocol\n"
! 1722: "Authentication control\n"
! 1723: "Authentication string\n"
! 1724: "Authentication string\n")
! 1725:
! 1726: DEFUN (ip_rip_authentication_key_chain,
! 1727: ip_rip_authentication_key_chain_cmd,
! 1728: "ip rip authentication key-chain LINE",
! 1729: IP_STR
! 1730: "Routing Information Protocol\n"
! 1731: "Authentication control\n"
! 1732: "Authentication key-chain\n"
! 1733: "name of key-chain\n")
! 1734: {
! 1735: struct interface *ifp;
! 1736: struct rip_interface *ri;
! 1737:
! 1738: ifp = (struct interface *) vty->index;
! 1739: ri = ifp->info;
! 1740:
! 1741: if (ri->auth_str)
! 1742: {
! 1743: vty_out (vty, "%% authentication string configuration exists%s",
! 1744: VTY_NEWLINE);
! 1745: return CMD_WARNING;
! 1746: }
! 1747:
! 1748: if (ri->key_chain)
! 1749: free (ri->key_chain);
! 1750:
! 1751: ri->key_chain = strdup (argv[0]);
! 1752:
! 1753: return CMD_SUCCESS;
! 1754: }
! 1755:
! 1756: DEFUN (no_ip_rip_authentication_key_chain,
! 1757: no_ip_rip_authentication_key_chain_cmd,
! 1758: "no ip rip authentication key-chain",
! 1759: NO_STR
! 1760: IP_STR
! 1761: "Routing Information Protocol\n"
! 1762: "Authentication control\n"
! 1763: "Authentication key-chain\n")
! 1764: {
! 1765: struct interface *ifp;
! 1766: struct rip_interface *ri;
! 1767:
! 1768: ifp = (struct interface *) vty->index;
! 1769: ri = ifp->info;
! 1770:
! 1771: if (ri->key_chain)
! 1772: free (ri->key_chain);
! 1773:
! 1774: ri->key_chain = NULL;
! 1775:
! 1776: return CMD_SUCCESS;
! 1777: }
! 1778:
! 1779: ALIAS (no_ip_rip_authentication_key_chain,
! 1780: no_ip_rip_authentication_key_chain2_cmd,
! 1781: "no ip rip authentication key-chain LINE",
! 1782: NO_STR
! 1783: IP_STR
! 1784: "Routing Information Protocol\n"
! 1785: "Authentication control\n"
! 1786: "Authentication key-chain\n"
! 1787: "name of key-chain\n")
! 1788:
! 1789: /* CHANGED: ip rip split-horizon
! 1790: Cisco and Zebra's command is
! 1791: ip split-horizon
! 1792: */
! 1793: DEFUN (ip_rip_split_horizon,
! 1794: ip_rip_split_horizon_cmd,
! 1795: "ip rip split-horizon",
! 1796: IP_STR
! 1797: "Routing Information Protocol\n"
! 1798: "Perform split horizon\n")
! 1799: {
! 1800: struct interface *ifp;
! 1801: struct rip_interface *ri;
! 1802:
! 1803: ifp = vty->index;
! 1804: ri = ifp->info;
! 1805:
! 1806: ri->split_horizon = RIP_SPLIT_HORIZON;
! 1807: return CMD_SUCCESS;
! 1808: }
! 1809:
! 1810: DEFUN (ip_rip_split_horizon_poisoned_reverse,
! 1811: ip_rip_split_horizon_poisoned_reverse_cmd,
! 1812: "ip rip split-horizon poisoned-reverse",
! 1813: IP_STR
! 1814: "Routing Information Protocol\n"
! 1815: "Perform split horizon\n"
! 1816: "With poisoned-reverse\n")
! 1817: {
! 1818: struct interface *ifp;
! 1819: struct rip_interface *ri;
! 1820:
! 1821: ifp = vty->index;
! 1822: ri = ifp->info;
! 1823:
! 1824: ri->split_horizon = RIP_SPLIT_HORIZON_POISONED_REVERSE;
! 1825: return CMD_SUCCESS;
! 1826: }
! 1827:
! 1828: /* CHANGED: no ip rip split-horizon
! 1829: Cisco and Zebra's command is
! 1830: no ip split-horizon
! 1831: */
! 1832: DEFUN (no_ip_rip_split_horizon,
! 1833: no_ip_rip_split_horizon_cmd,
! 1834: "no ip rip split-horizon",
! 1835: NO_STR
! 1836: IP_STR
! 1837: "Routing Information Protocol\n"
! 1838: "Perform split horizon\n")
! 1839: {
! 1840: struct interface *ifp;
! 1841: struct rip_interface *ri;
! 1842:
! 1843: ifp = vty->index;
! 1844: ri = ifp->info;
! 1845:
! 1846: ri->split_horizon = RIP_NO_SPLIT_HORIZON;
! 1847: return CMD_SUCCESS;
! 1848: }
! 1849:
! 1850: DEFUN (no_ip_rip_split_horizon_poisoned_reverse,
! 1851: no_ip_rip_split_horizon_poisoned_reverse_cmd,
! 1852: "no ip rip split-horizon poisoned-reverse",
! 1853: NO_STR
! 1854: IP_STR
! 1855: "Routing Information Protocol\n"
! 1856: "Perform split horizon\n"
! 1857: "With poisoned-reverse\n")
! 1858: {
! 1859: struct interface *ifp;
! 1860: struct rip_interface *ri;
! 1861:
! 1862: ifp = vty->index;
! 1863: ri = ifp->info;
! 1864:
! 1865: switch( ri->split_horizon )
! 1866: {
! 1867: case RIP_SPLIT_HORIZON_POISONED_REVERSE:
! 1868: ri->split_horizon = RIP_SPLIT_HORIZON;
! 1869: default:
! 1870: break;
! 1871: }
! 1872:
! 1873: return CMD_SUCCESS;
! 1874: }
! 1875:
! 1876: DEFUN (rip_passive_interface,
! 1877: rip_passive_interface_cmd,
! 1878: "passive-interface (IFNAME|default)",
! 1879: "Suppress routing updates on an interface\n"
! 1880: "Interface name\n"
! 1881: "default for all interfaces\n")
! 1882: {
! 1883: const char *ifname = argv[0];
! 1884:
! 1885: if (!strcmp(ifname,"default")) {
! 1886: passive_default = 1;
! 1887: rip_passive_nondefault_clean();
! 1888: return CMD_SUCCESS;
! 1889: }
! 1890: if (passive_default)
! 1891: return rip_passive_nondefault_unset (vty, ifname);
! 1892: else
! 1893: return rip_passive_nondefault_set (vty, ifname);
! 1894: }
! 1895:
! 1896: DEFUN (no_rip_passive_interface,
! 1897: no_rip_passive_interface_cmd,
! 1898: "no passive-interface (IFNAME|default)",
! 1899: NO_STR
! 1900: "Suppress routing updates on an interface\n"
! 1901: "Interface name\n"
! 1902: "default for all interfaces\n")
! 1903: {
! 1904: const char *ifname = argv[0];
! 1905:
! 1906: if (!strcmp(ifname,"default")) {
! 1907: passive_default = 0;
! 1908: rip_passive_nondefault_clean();
! 1909: return CMD_SUCCESS;
! 1910: }
! 1911: if (passive_default)
! 1912: return rip_passive_nondefault_set (vty, ifname);
! 1913: else
! 1914: return rip_passive_nondefault_unset (vty, ifname);
! 1915: }
! 1916:
! 1917: /* Write rip configuration of each interface. */
! 1918: static int
! 1919: rip_interface_config_write (struct vty *vty)
! 1920: {
! 1921: struct listnode *node;
! 1922: struct interface *ifp;
! 1923:
! 1924: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 1925: {
! 1926: struct rip_interface *ri;
! 1927:
! 1928: ri = ifp->info;
! 1929:
! 1930: /* Do not display the interface if there is no
! 1931: * configuration about it.
! 1932: **/
! 1933: if ((!ifp->desc) &&
! 1934: (ri->split_horizon == ri->split_horizon_default) &&
! 1935: (ri->ri_send == RI_RIP_UNSPEC) &&
! 1936: (ri->ri_receive == RI_RIP_UNSPEC) &&
! 1937: (ri->auth_type != RIP_AUTH_MD5) &&
! 1938: (ri->md5_auth_len != RIP_AUTH_MD5_SIZE) &&
! 1939: (!ri->auth_str) &&
! 1940: (!ri->key_chain) )
! 1941: continue;
! 1942:
! 1943: vty_out (vty, "interface %s%s", ifp->name,
! 1944: VTY_NEWLINE);
! 1945:
! 1946: if (ifp->desc)
! 1947: vty_out (vty, " description %s%s", ifp->desc,
! 1948: VTY_NEWLINE);
! 1949:
! 1950: /* Split horizon. */
! 1951: if (ri->split_horizon != ri->split_horizon_default)
! 1952: {
! 1953: switch (ri->split_horizon) {
! 1954: case RIP_SPLIT_HORIZON:
! 1955: vty_out (vty, " ip rip split-horizon%s", VTY_NEWLINE);
! 1956: break;
! 1957: case RIP_SPLIT_HORIZON_POISONED_REVERSE:
! 1958: vty_out (vty, " ip rip split-horizon poisoned-reverse%s",
! 1959: VTY_NEWLINE);
! 1960: break;
! 1961: case RIP_NO_SPLIT_HORIZON:
! 1962: default:
! 1963: vty_out (vty, " no ip rip split-horizon%s", VTY_NEWLINE);
! 1964: break;
! 1965: }
! 1966: }
! 1967:
! 1968: /* RIP version setting. */
! 1969: if (ri->ri_send != RI_RIP_UNSPEC)
! 1970: vty_out (vty, " ip rip send version %s%s",
! 1971: lookup (ri_version_msg, ri->ri_send),
! 1972: VTY_NEWLINE);
! 1973:
! 1974: if (ri->ri_receive != RI_RIP_UNSPEC)
! 1975: vty_out (vty, " ip rip receive version %s%s",
! 1976: lookup (ri_version_msg, ri->ri_receive),
! 1977: VTY_NEWLINE);
! 1978:
! 1979: /* RIP authentication. */
! 1980: if (ri->auth_type == RIP_AUTH_SIMPLE_PASSWORD)
! 1981: vty_out (vty, " ip rip authentication mode text%s", VTY_NEWLINE);
! 1982:
! 1983: if (ri->auth_type == RIP_AUTH_MD5)
! 1984: {
! 1985: vty_out (vty, " ip rip authentication mode md5");
! 1986: if (ri->md5_auth_len == RIP_AUTH_MD5_COMPAT_SIZE)
! 1987: vty_out (vty, " auth-length old-ripd");
! 1988: else
! 1989: vty_out (vty, " auth-length rfc");
! 1990: vty_out (vty, "%s", VTY_NEWLINE);
! 1991: }
! 1992:
! 1993: if (ri->auth_str)
! 1994: vty_out (vty, " ip rip authentication string %s%s",
! 1995: ri->auth_str, VTY_NEWLINE);
! 1996:
! 1997: if (ri->key_chain)
! 1998: vty_out (vty, " ip rip authentication key-chain %s%s",
! 1999: ri->key_chain, VTY_NEWLINE);
! 2000:
! 2001: vty_out (vty, "!%s", VTY_NEWLINE);
! 2002: }
! 2003: return 0;
! 2004: }
! 2005:
! 2006: int
! 2007: config_write_rip_network (struct vty *vty, int config_mode)
! 2008: {
! 2009: unsigned int i;
! 2010: char *ifname;
! 2011: struct route_node *node;
! 2012:
! 2013: /* Network type RIP enable interface statement. */
! 2014: for (node = route_top (rip_enable_network); node; node = route_next (node))
! 2015: if (node->info)
! 2016: vty_out (vty, "%s%s/%d%s",
! 2017: config_mode ? " network " : " ",
! 2018: inet_ntoa (node->p.u.prefix4),
! 2019: node->p.prefixlen,
! 2020: VTY_NEWLINE);
! 2021:
! 2022: /* Interface name RIP enable statement. */
! 2023: for (i = 0; i < vector_active (rip_enable_interface); i++)
! 2024: if ((ifname = vector_slot (rip_enable_interface, i)) != NULL)
! 2025: vty_out (vty, "%s%s%s",
! 2026: config_mode ? " network " : " ",
! 2027: ifname,
! 2028: VTY_NEWLINE);
! 2029:
! 2030: /* RIP neighbors listing. */
! 2031: for (node = route_top (rip->neighbor); node; node = route_next (node))
! 2032: if (node->info)
! 2033: vty_out (vty, "%s%s%s",
! 2034: config_mode ? " neighbor " : " ",
! 2035: inet_ntoa (node->p.u.prefix4),
! 2036: VTY_NEWLINE);
! 2037:
! 2038: /* RIP passive interface listing. */
! 2039: if (config_mode) {
! 2040: if (passive_default)
! 2041: vty_out (vty, " passive-interface default%s", VTY_NEWLINE);
! 2042: for (i = 0; i < vector_active (Vrip_passive_nondefault); i++)
! 2043: if ((ifname = vector_slot (Vrip_passive_nondefault, i)) != NULL)
! 2044: vty_out (vty, " %spassive-interface %s%s",
! 2045: (passive_default ? "no " : ""), ifname, VTY_NEWLINE);
! 2046: }
! 2047:
! 2048: return 0;
! 2049: }
! 2050:
! 2051: static struct cmd_node interface_node =
! 2052: {
! 2053: INTERFACE_NODE,
! 2054: "%s(config-if)# ",
! 2055: 1,
! 2056: };
! 2057:
! 2058: /* Called when interface structure allocated. */
! 2059: static int
! 2060: rip_interface_new_hook (struct interface *ifp)
! 2061: {
! 2062: ifp->info = rip_interface_new ();
! 2063: return 0;
! 2064: }
! 2065:
! 2066: /* Called when interface structure deleted. */
! 2067: static int
! 2068: rip_interface_delete_hook (struct interface *ifp)
! 2069: {
! 2070: XFREE (MTYPE_RIP_INTERFACE, ifp->info);
! 2071: ifp->info = NULL;
! 2072: return 0;
! 2073: }
! 2074:
! 2075: /* Allocate and initialize interface vector. */
! 2076: void
! 2077: rip_if_init (void)
! 2078: {
! 2079: /* Default initial size of interface vector. */
! 2080: if_init();
! 2081: if_add_hook (IF_NEW_HOOK, rip_interface_new_hook);
! 2082: if_add_hook (IF_DELETE_HOOK, rip_interface_delete_hook);
! 2083:
! 2084: /* RIP network init. */
! 2085: rip_enable_interface = vector_init (1);
! 2086: rip_enable_network = route_table_init ();
! 2087:
! 2088: /* RIP passive interface. */
! 2089: Vrip_passive_nondefault = vector_init (1);
! 2090:
! 2091: /* Install interface node. */
! 2092: install_node (&interface_node, rip_interface_config_write);
! 2093:
! 2094: /* Install commands. */
! 2095: install_element (CONFIG_NODE, &interface_cmd);
! 2096: install_element (CONFIG_NODE, &no_interface_cmd);
! 2097: install_default (INTERFACE_NODE);
! 2098: install_element (INTERFACE_NODE, &interface_desc_cmd);
! 2099: install_element (INTERFACE_NODE, &no_interface_desc_cmd);
! 2100: install_element (RIP_NODE, &rip_network_cmd);
! 2101: install_element (RIP_NODE, &no_rip_network_cmd);
! 2102: install_element (RIP_NODE, &rip_neighbor_cmd);
! 2103: install_element (RIP_NODE, &no_rip_neighbor_cmd);
! 2104:
! 2105: install_element (RIP_NODE, &rip_passive_interface_cmd);
! 2106: install_element (RIP_NODE, &no_rip_passive_interface_cmd);
! 2107:
! 2108: install_element (INTERFACE_NODE, &ip_rip_send_version_cmd);
! 2109: install_element (INTERFACE_NODE, &ip_rip_send_version_1_cmd);
! 2110: install_element (INTERFACE_NODE, &ip_rip_send_version_2_cmd);
! 2111: install_element (INTERFACE_NODE, &no_ip_rip_send_version_cmd);
! 2112: install_element (INTERFACE_NODE, &no_ip_rip_send_version_num_cmd);
! 2113:
! 2114: install_element (INTERFACE_NODE, &ip_rip_receive_version_cmd);
! 2115: install_element (INTERFACE_NODE, &ip_rip_receive_version_1_cmd);
! 2116: install_element (INTERFACE_NODE, &ip_rip_receive_version_2_cmd);
! 2117: install_element (INTERFACE_NODE, &no_ip_rip_receive_version_cmd);
! 2118: install_element (INTERFACE_NODE, &no_ip_rip_receive_version_num_cmd);
! 2119:
! 2120: install_element (INTERFACE_NODE, &ip_rip_authentication_mode_cmd);
! 2121: install_element (INTERFACE_NODE, &ip_rip_authentication_mode_authlen_cmd);
! 2122: install_element (INTERFACE_NODE, &no_ip_rip_authentication_mode_cmd);
! 2123: install_element (INTERFACE_NODE, &no_ip_rip_authentication_mode_type_cmd);
! 2124: install_element (INTERFACE_NODE, &no_ip_rip_authentication_mode_type_authlen_cmd);
! 2125:
! 2126: install_element (INTERFACE_NODE, &ip_rip_authentication_key_chain_cmd);
! 2127: install_element (INTERFACE_NODE, &no_ip_rip_authentication_key_chain_cmd);
! 2128: install_element (INTERFACE_NODE, &no_ip_rip_authentication_key_chain2_cmd);
! 2129:
! 2130: install_element (INTERFACE_NODE, &ip_rip_authentication_string_cmd);
! 2131: install_element (INTERFACE_NODE, &no_ip_rip_authentication_string_cmd);
! 2132: install_element (INTERFACE_NODE, &no_ip_rip_authentication_string2_cmd);
! 2133:
! 2134: install_element (INTERFACE_NODE, &ip_rip_split_horizon_cmd);
! 2135: install_element (INTERFACE_NODE, &ip_rip_split_horizon_poisoned_reverse_cmd);
! 2136: install_element (INTERFACE_NODE, &no_ip_rip_split_horizon_cmd);
! 2137: install_element (INTERFACE_NODE, &no_ip_rip_split_horizon_poisoned_reverse_cmd);
! 2138: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rip_interface.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ripd