Annotation of embedaddon/quagga/ripngd/ripngd.c, revision 1.1
1.1 ! misho 1: /* RIPng daemon
! 2: * Copyright (C) 1998, 1999 Kunihiro Ishiguro
! 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 "prefix.h"
! 25: #include "filter.h"
! 26: #include "log.h"
! 27: #include "thread.h"
! 28: #include "memory.h"
! 29: #include "if.h"
! 30: #include "stream.h"
! 31: #include "table.h"
! 32: #include "command.h"
! 33: #include "sockopt.h"
! 34: #include "distribute.h"
! 35: #include "plist.h"
! 36: #include "routemap.h"
! 37: #include "if_rmap.h"
! 38: #include "privs.h"
! 39:
! 40: #include "ripngd/ripngd.h"
! 41: #include "ripngd/ripng_route.h"
! 42: #include "ripngd/ripng_debug.h"
! 43: #include "ripngd/ripng_nexthop.h"
! 44:
! 45: /* RIPng structure which includes many parameters related to RIPng
! 46: protocol. If ripng couldn't active or ripng doesn't configured,
! 47: ripng->fd must be negative value. */
! 48: struct ripng *ripng = NULL;
! 49:
! 50: enum
! 51: {
! 52: ripng_all_route,
! 53: ripng_changed_route,
! 54: };
! 55:
! 56: extern struct zebra_privs_t ripngd_privs;
! 57:
! 58: /* Prototypes. */
! 59: void
! 60: ripng_output_process (struct interface *, struct sockaddr_in6 *, int);
! 61:
! 62: int
! 63: ripng_triggered_update (struct thread *);
! 64:
! 65: /* RIPng next hop specification. */
! 66: struct ripng_nexthop
! 67: {
! 68: enum ripng_nexthop_type
! 69: {
! 70: RIPNG_NEXTHOP_UNSPEC,
! 71: RIPNG_NEXTHOP_ADDRESS
! 72: } flag;
! 73: struct in6_addr address;
! 74: };
! 75:
! 76: static int
! 77: ripng_route_rte (struct ripng_info *rinfo)
! 78: {
! 79: return (rinfo->type == ZEBRA_ROUTE_RIPNG && rinfo->sub_type == RIPNG_ROUTE_RTE);
! 80: }
! 81:
! 82: /* Allocate new ripng information. */
! 83: struct ripng_info *
! 84: ripng_info_new ()
! 85: {
! 86: struct ripng_info *new;
! 87:
! 88: new = XCALLOC (MTYPE_RIPNG_ROUTE, sizeof (struct ripng_info));
! 89: return new;
! 90: }
! 91:
! 92: /* Free ripng information. */
! 93: void
! 94: ripng_info_free (struct ripng_info *rinfo)
! 95: {
! 96: XFREE (MTYPE_RIPNG_ROUTE, rinfo);
! 97: }
! 98:
! 99: /* Create ripng socket. */
! 100: static int
! 101: ripng_make_socket (void)
! 102: {
! 103: int ret;
! 104: int sock;
! 105: struct sockaddr_in6 ripaddr;
! 106:
! 107: sock = socket (AF_INET6, SOCK_DGRAM, 0);
! 108: if (sock < 0)
! 109: {
! 110: zlog (NULL, LOG_ERR, "Can't make ripng socket");
! 111: return sock;
! 112: }
! 113:
! 114: ret = setsockopt_so_recvbuf (sock, 8096);
! 115: if (ret < 0)
! 116: return ret;
! 117: ret = setsockopt_ipv6_pktinfo (sock, 1);
! 118: if (ret < 0)
! 119: return ret;
! 120: ret = setsockopt_ipv6_multicast_hops (sock, 255);
! 121: if (ret < 0)
! 122: return ret;
! 123: ret = setsockopt_ipv6_multicast_loop (sock, 0);
! 124: if (ret < 0)
! 125: return ret;
! 126: ret = setsockopt_ipv6_hoplimit (sock, 1);
! 127: if (ret < 0)
! 128: return ret;
! 129:
! 130: memset (&ripaddr, 0, sizeof (ripaddr));
! 131: ripaddr.sin6_family = AF_INET6;
! 132: #ifdef SIN6_LEN
! 133: ripaddr.sin6_len = sizeof (struct sockaddr_in6);
! 134: #endif /* SIN6_LEN */
! 135: ripaddr.sin6_port = htons (RIPNG_PORT_DEFAULT);
! 136:
! 137: if (ripngd_privs.change (ZPRIVS_RAISE))
! 138: zlog_err ("ripng_make_socket: could not raise privs");
! 139:
! 140: ret = bind (sock, (struct sockaddr *) &ripaddr, sizeof (ripaddr));
! 141: if (ret < 0)
! 142: {
! 143: zlog (NULL, LOG_ERR, "Can't bind ripng socket: %s.", safe_strerror (errno));
! 144: if (ripngd_privs.change (ZPRIVS_LOWER))
! 145: zlog_err ("ripng_make_socket: could not lower privs");
! 146: return ret;
! 147: }
! 148: if (ripngd_privs.change (ZPRIVS_LOWER))
! 149: zlog_err ("ripng_make_socket: could not lower privs");
! 150: return sock;
! 151: }
! 152:
! 153: /* Send RIPng packet. */
! 154: int
! 155: ripng_send_packet (caddr_t buf, int bufsize, struct sockaddr_in6 *to,
! 156: struct interface *ifp)
! 157: {
! 158: int ret;
! 159: struct msghdr msg;
! 160: struct iovec iov;
! 161: struct cmsghdr *cmsgptr;
! 162: char adata [256];
! 163: struct in6_pktinfo *pkt;
! 164: struct sockaddr_in6 addr;
! 165:
! 166: if (IS_RIPNG_DEBUG_SEND) {
! 167: if (to)
! 168: zlog_debug ("send to %s", inet6_ntoa (to->sin6_addr));
! 169: zlog_debug (" send interface %s", ifp->name);
! 170: zlog_debug (" send packet size %d", bufsize);
! 171: }
! 172:
! 173: memset (&addr, 0, sizeof (struct sockaddr_in6));
! 174: addr.sin6_family = AF_INET6;
! 175: #ifdef SIN6_LEN
! 176: addr.sin6_len = sizeof (struct sockaddr_in6);
! 177: #endif /* SIN6_LEN */
! 178: addr.sin6_flowinfo = htonl (RIPNG_PRIORITY_DEFAULT);
! 179:
! 180: /* When destination is specified. */
! 181: if (to != NULL)
! 182: {
! 183: addr.sin6_addr = to->sin6_addr;
! 184: addr.sin6_port = to->sin6_port;
! 185: }
! 186: else
! 187: {
! 188: inet_pton(AF_INET6, RIPNG_GROUP, &addr.sin6_addr);
! 189: addr.sin6_port = htons (RIPNG_PORT_DEFAULT);
! 190: }
! 191:
! 192: msg.msg_name = (void *) &addr;
! 193: msg.msg_namelen = sizeof (struct sockaddr_in6);
! 194: msg.msg_iov = &iov;
! 195: msg.msg_iovlen = 1;
! 196: msg.msg_control = (void *) adata;
! 197: msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
! 198:
! 199: iov.iov_base = buf;
! 200: iov.iov_len = bufsize;
! 201:
! 202: cmsgptr = (struct cmsghdr *)adata;
! 203: cmsgptr->cmsg_len = CMSG_LEN(sizeof (struct in6_pktinfo));
! 204: cmsgptr->cmsg_level = IPPROTO_IPV6;
! 205: cmsgptr->cmsg_type = IPV6_PKTINFO;
! 206:
! 207: pkt = (struct in6_pktinfo *) CMSG_DATA (cmsgptr);
! 208: memset (&pkt->ipi6_addr, 0, sizeof (struct in6_addr));
! 209: pkt->ipi6_ifindex = ifp->ifindex;
! 210:
! 211: ret = sendmsg (ripng->sock, &msg, 0);
! 212:
! 213: if (ret < 0) {
! 214: if (to)
! 215: zlog_err ("RIPng send fail on %s to %s: %s", ifp->name,
! 216: inet6_ntoa (to->sin6_addr), safe_strerror (errno));
! 217: else
! 218: zlog_err ("RIPng send fail on %s: %s", ifp->name, safe_strerror (errno));
! 219: }
! 220:
! 221: return ret;
! 222: }
! 223:
! 224: /* Receive UDP RIPng packet from socket. */
! 225: static int
! 226: ripng_recv_packet (int sock, u_char *buf, int bufsize,
! 227: struct sockaddr_in6 *from, unsigned int *ifindex,
! 228: int *hoplimit)
! 229: {
! 230: int ret;
! 231: struct msghdr msg;
! 232: struct iovec iov;
! 233: struct cmsghdr *cmsgptr;
! 234: struct in6_addr dst;
! 235:
! 236: /* Ancillary data. This store cmsghdr and in6_pktinfo. But at this
! 237: point I can't determine size of cmsghdr */
! 238: char adata[1024];
! 239:
! 240: /* Fill in message and iovec. */
! 241: msg.msg_name = (void *) from;
! 242: msg.msg_namelen = sizeof (struct sockaddr_in6);
! 243: msg.msg_iov = &iov;
! 244: msg.msg_iovlen = 1;
! 245: msg.msg_control = (void *) adata;
! 246: msg.msg_controllen = sizeof adata;
! 247: iov.iov_base = buf;
! 248: iov.iov_len = bufsize;
! 249:
! 250: /* If recvmsg fail return minus value. */
! 251: ret = recvmsg (sock, &msg, 0);
! 252: if (ret < 0)
! 253: return ret;
! 254:
! 255: for (cmsgptr = ZCMSG_FIRSTHDR(&msg); cmsgptr != NULL;
! 256: cmsgptr = CMSG_NXTHDR(&msg, cmsgptr))
! 257: {
! 258: /* I want interface index which this packet comes from. */
! 259: if (cmsgptr->cmsg_level == IPPROTO_IPV6 &&
! 260: cmsgptr->cmsg_type == IPV6_PKTINFO)
! 261: {
! 262: struct in6_pktinfo *ptr;
! 263:
! 264: ptr = (struct in6_pktinfo *) CMSG_DATA (cmsgptr);
! 265: *ifindex = ptr->ipi6_ifindex;
! 266: dst = ptr->ipi6_addr;
! 267:
! 268: if (*ifindex == 0)
! 269: zlog_warn ("Interface index returned by IPV6_PKTINFO is zero");
! 270: }
! 271:
! 272: /* Incoming packet's multicast hop limit. */
! 273: if (cmsgptr->cmsg_level == IPPROTO_IPV6 &&
! 274: cmsgptr->cmsg_type == IPV6_HOPLIMIT)
! 275: {
! 276: int *phoplimit = (int *) CMSG_DATA (cmsgptr);
! 277: *hoplimit = *phoplimit;
! 278: }
! 279: }
! 280:
! 281: /* Hoplimit check shold be done when destination address is
! 282: multicast address. */
! 283: if (! IN6_IS_ADDR_MULTICAST (&dst))
! 284: *hoplimit = -1;
! 285:
! 286: return ret;
! 287: }
! 288:
! 289: /* Dump rip packet */
! 290: void
! 291: ripng_packet_dump (struct ripng_packet *packet, int size, const char *sndrcv)
! 292: {
! 293: caddr_t lim;
! 294: struct rte *rte;
! 295: const char *command_str;
! 296:
! 297: /* Set command string. */
! 298: if (packet->command == RIPNG_REQUEST)
! 299: command_str = "request";
! 300: else if (packet->command == RIPNG_RESPONSE)
! 301: command_str = "response";
! 302: else
! 303: command_str = "unknown";
! 304:
! 305: /* Dump packet header. */
! 306: zlog_debug ("%s %s version %d packet size %d",
! 307: sndrcv, command_str, packet->version, size);
! 308:
! 309: /* Dump each routing table entry. */
! 310: rte = packet->rte;
! 311:
! 312: for (lim = (caddr_t) packet + size; (caddr_t) rte < lim; rte++)
! 313: {
! 314: if (rte->metric == RIPNG_METRIC_NEXTHOP)
! 315: zlog_debug (" nexthop %s/%d", inet6_ntoa (rte->addr), rte->prefixlen);
! 316: else
! 317: zlog_debug (" %s/%d metric %d tag %d",
! 318: inet6_ntoa (rte->addr), rte->prefixlen,
! 319: rte->metric, ntohs (rte->tag));
! 320: }
! 321: }
! 322:
! 323: /* RIPng next hop address RTE (Route Table Entry). */
! 324: static void
! 325: ripng_nexthop_rte (struct rte *rte,
! 326: struct sockaddr_in6 *from,
! 327: struct ripng_nexthop *nexthop)
! 328: {
! 329: char buf[INET6_BUFSIZ];
! 330:
! 331: /* Logging before checking RTE. */
! 332: if (IS_RIPNG_DEBUG_RECV)
! 333: zlog_debug ("RIPng nexthop RTE address %s tag %d prefixlen %d",
! 334: inet6_ntoa (rte->addr), ntohs (rte->tag), rte->prefixlen);
! 335:
! 336: /* RFC2080 2.1.1 Next Hop:
! 337: The route tag and prefix length in the next hop RTE must be
! 338: set to zero on sending and ignored on receiption. */
! 339: if (ntohs (rte->tag) != 0)
! 340: zlog_warn ("RIPng nexthop RTE with non zero tag value %d from %s",
! 341: ntohs (rte->tag), inet6_ntoa (from->sin6_addr));
! 342:
! 343: if (rte->prefixlen != 0)
! 344: zlog_warn ("RIPng nexthop RTE with non zero prefixlen value %d from %s",
! 345: rte->prefixlen, inet6_ntoa (from->sin6_addr));
! 346:
! 347: /* Specifying a value of 0:0:0:0:0:0:0:0 in the prefix field of a
! 348: next hop RTE indicates that the next hop address should be the
! 349: originator of the RIPng advertisement. An address specified as a
! 350: next hop must be a link-local address. */
! 351: if (IN6_IS_ADDR_UNSPECIFIED (&rte->addr))
! 352: {
! 353: nexthop->flag = RIPNG_NEXTHOP_UNSPEC;
! 354: memset (&nexthop->address, 0, sizeof (struct in6_addr));
! 355: return;
! 356: }
! 357:
! 358: if (IN6_IS_ADDR_LINKLOCAL (&rte->addr))
! 359: {
! 360: nexthop->flag = RIPNG_NEXTHOP_ADDRESS;
! 361: IPV6_ADDR_COPY (&nexthop->address, &rte->addr);
! 362: return;
! 363: }
! 364:
! 365: /* The purpose of the next hop RTE is to eliminate packets being
! 366: routed through extra hops in the system. It is particularly useful
! 367: when RIPng is not being run on all of the routers on a network.
! 368: Note that next hop RTE is "advisory". That is, if the provided
! 369: information is ignored, a possibly sub-optimal, but absolutely
! 370: valid, route may be taken. If the received next hop address is not
! 371: a link-local address, it should be treated as 0:0:0:0:0:0:0:0. */
! 372: zlog_warn ("RIPng nexthop RTE with non link-local address %s from %s",
! 373: inet6_ntoa (rte->addr),
! 374: inet_ntop (AF_INET6, &from->sin6_addr, buf, INET6_BUFSIZ));
! 375:
! 376: nexthop->flag = RIPNG_NEXTHOP_UNSPEC;
! 377: memset (&nexthop->address, 0, sizeof (struct in6_addr));
! 378:
! 379: return;
! 380: }
! 381:
! 382: /* If ifp has same link-local address then return 1. */
! 383: static int
! 384: ripng_lladdr_check (struct interface *ifp, struct in6_addr *addr)
! 385: {
! 386: struct listnode *node;
! 387: struct connected *connected;
! 388: struct prefix *p;
! 389:
! 390: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, connected))
! 391: {
! 392: p = connected->address;
! 393:
! 394: if (p->family == AF_INET6 &&
! 395: IN6_IS_ADDR_LINKLOCAL (&p->u.prefix6) &&
! 396: IN6_ARE_ADDR_EQUAL (&p->u.prefix6, addr))
! 397: return 1;
! 398: }
! 399: return 0;
! 400: }
! 401:
! 402: /* RIPng route garbage collect timer. */
! 403: static int
! 404: ripng_garbage_collect (struct thread *t)
! 405: {
! 406: struct ripng_info *rinfo;
! 407: struct route_node *rp;
! 408:
! 409: rinfo = THREAD_ARG (t);
! 410: rinfo->t_garbage_collect = NULL;
! 411:
! 412: /* Off timeout timer. */
! 413: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 414:
! 415: /* Get route_node pointer. */
! 416: rp = rinfo->rp;
! 417:
! 418: /* Unlock route_node. */
! 419: rp->info = NULL;
! 420: route_unlock_node (rp);
! 421:
! 422: /* Free RIPng routing information. */
! 423: ripng_info_free (rinfo);
! 424:
! 425: return 0;
! 426: }
! 427:
! 428: /* Timeout RIPng routes. */
! 429: static int
! 430: ripng_timeout (struct thread *t)
! 431: {
! 432: struct ripng_info *rinfo;
! 433: struct route_node *rp;
! 434:
! 435: rinfo = THREAD_ARG (t);
! 436: rinfo->t_timeout = NULL;
! 437:
! 438: /* Get route_node pointer. */
! 439: rp = rinfo->rp;
! 440:
! 441: /* - The garbage-collection timer is set for 120 seconds. */
! 442: RIPNG_TIMER_ON (rinfo->t_garbage_collect, ripng_garbage_collect,
! 443: ripng->garbage_time);
! 444:
! 445: /* Delete this route from the kernel. */
! 446: ripng_zebra_ipv6_delete ((struct prefix_ipv6 *)&rp->p, &rinfo->nexthop,
! 447: rinfo->ifindex);
! 448: /* - The metric for the route is set to 16 (infinity). This causes
! 449: the route to be removed from service. */
! 450: rinfo->metric = RIPNG_METRIC_INFINITY;
! 451: rinfo->flags &= ~RIPNG_RTF_FIB;
! 452:
! 453: /* Aggregate count decrement. */
! 454: ripng_aggregate_decrement (rp, rinfo);
! 455:
! 456: /* - The route change flag is to indicate that this entry has been
! 457: changed. */
! 458: rinfo->flags |= RIPNG_RTF_CHANGED;
! 459:
! 460: /* - The output process is signalled to trigger a response. */
! 461: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 462:
! 463: return 0;
! 464: }
! 465:
! 466: static void
! 467: ripng_timeout_update (struct ripng_info *rinfo)
! 468: {
! 469: if (rinfo->metric != RIPNG_METRIC_INFINITY)
! 470: {
! 471: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 472: RIPNG_TIMER_ON (rinfo->t_timeout, ripng_timeout, ripng->timeout_time);
! 473: }
! 474: }
! 475:
! 476: static int
! 477: ripng_incoming_filter (struct prefix_ipv6 *p, struct ripng_interface *ri)
! 478: {
! 479: struct distribute *dist;
! 480: struct access_list *alist;
! 481: struct prefix_list *plist;
! 482:
! 483: /* Input distribute-list filtering. */
! 484: if (ri->list[RIPNG_FILTER_IN])
! 485: {
! 486: if (access_list_apply (ri->list[RIPNG_FILTER_IN],
! 487: (struct prefix *) p) == FILTER_DENY)
! 488: {
! 489: if (IS_RIPNG_DEBUG_PACKET)
! 490: zlog_debug ("%s/%d filtered by distribute in",
! 491: inet6_ntoa (p->prefix), p->prefixlen);
! 492: return -1;
! 493: }
! 494: }
! 495: if (ri->prefix[RIPNG_FILTER_IN])
! 496: {
! 497: if (prefix_list_apply (ri->prefix[RIPNG_FILTER_IN],
! 498: (struct prefix *) p) == PREFIX_DENY)
! 499: {
! 500: if (IS_RIPNG_DEBUG_PACKET)
! 501: zlog_debug ("%s/%d filtered by prefix-list in",
! 502: inet6_ntoa (p->prefix), p->prefixlen);
! 503: return -1;
! 504: }
! 505: }
! 506:
! 507: /* All interface filter check. */
! 508: dist = distribute_lookup (NULL);
! 509: if (dist)
! 510: {
! 511: if (dist->list[DISTRIBUTE_IN])
! 512: {
! 513: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_IN]);
! 514:
! 515: if (alist)
! 516: {
! 517: if (access_list_apply (alist,
! 518: (struct prefix *) p) == FILTER_DENY)
! 519: {
! 520: if (IS_RIPNG_DEBUG_PACKET)
! 521: zlog_debug ("%s/%d filtered by distribute in",
! 522: inet6_ntoa (p->prefix), p->prefixlen);
! 523: return -1;
! 524: }
! 525: }
! 526: }
! 527: if (dist->prefix[DISTRIBUTE_IN])
! 528: {
! 529: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_IN]);
! 530:
! 531: if (plist)
! 532: {
! 533: if (prefix_list_apply (plist,
! 534: (struct prefix *) p) == PREFIX_DENY)
! 535: {
! 536: if (IS_RIPNG_DEBUG_PACKET)
! 537: zlog_debug ("%s/%d filtered by prefix-list in",
! 538: inet6_ntoa (p->prefix), p->prefixlen);
! 539: return -1;
! 540: }
! 541: }
! 542: }
! 543: }
! 544: return 0;
! 545: }
! 546:
! 547: static int
! 548: ripng_outgoing_filter (struct prefix_ipv6 *p, struct ripng_interface *ri)
! 549: {
! 550: struct distribute *dist;
! 551: struct access_list *alist;
! 552: struct prefix_list *plist;
! 553:
! 554: if (ri->list[RIPNG_FILTER_OUT])
! 555: {
! 556: if (access_list_apply (ri->list[RIPNG_FILTER_OUT],
! 557: (struct prefix *) p) == FILTER_DENY)
! 558: {
! 559: if (IS_RIPNG_DEBUG_PACKET)
! 560: zlog_debug ("%s/%d is filtered by distribute out",
! 561: inet6_ntoa (p->prefix), p->prefixlen);
! 562: return -1;
! 563: }
! 564: }
! 565: if (ri->prefix[RIPNG_FILTER_OUT])
! 566: {
! 567: if (prefix_list_apply (ri->prefix[RIPNG_FILTER_OUT],
! 568: (struct prefix *) p) == PREFIX_DENY)
! 569: {
! 570: if (IS_RIPNG_DEBUG_PACKET)
! 571: zlog_debug ("%s/%d is filtered by prefix-list out",
! 572: inet6_ntoa (p->prefix), p->prefixlen);
! 573: return -1;
! 574: }
! 575: }
! 576:
! 577: /* All interface filter check. */
! 578: dist = distribute_lookup (NULL);
! 579: if (dist)
! 580: {
! 581: if (dist->list[DISTRIBUTE_OUT])
! 582: {
! 583: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_OUT]);
! 584:
! 585: if (alist)
! 586: {
! 587: if (access_list_apply (alist,
! 588: (struct prefix *) p) == FILTER_DENY)
! 589: {
! 590: if (IS_RIPNG_DEBUG_PACKET)
! 591: zlog_debug ("%s/%d filtered by distribute out",
! 592: inet6_ntoa (p->prefix), p->prefixlen);
! 593: return -1;
! 594: }
! 595: }
! 596: }
! 597: if (dist->prefix[DISTRIBUTE_OUT])
! 598: {
! 599: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_OUT]);
! 600:
! 601: if (plist)
! 602: {
! 603: if (prefix_list_apply (plist,
! 604: (struct prefix *) p) == PREFIX_DENY)
! 605: {
! 606: if (IS_RIPNG_DEBUG_PACKET)
! 607: zlog_debug ("%s/%d filtered by prefix-list out",
! 608: inet6_ntoa (p->prefix), p->prefixlen);
! 609: return -1;
! 610: }
! 611: }
! 612: }
! 613: }
! 614: return 0;
! 615: }
! 616:
! 617: /* Process RIPng route according to RFC2080. */
! 618: static void
! 619: ripng_route_process (struct rte *rte, struct sockaddr_in6 *from,
! 620: struct ripng_nexthop *ripng_nexthop,
! 621: struct interface *ifp)
! 622: {
! 623: int ret;
! 624: struct prefix_ipv6 p;
! 625: struct route_node *rp;
! 626: struct ripng_info *rinfo;
! 627: struct ripng_interface *ri;
! 628: struct in6_addr *nexthop;
! 629: u_char oldmetric;
! 630: int same = 0;
! 631:
! 632: /* Make prefix structure. */
! 633: memset (&p, 0, sizeof (struct prefix_ipv6));
! 634: p.family = AF_INET6;
! 635: /* p.prefix = rte->addr; */
! 636: IPV6_ADDR_COPY (&p.prefix, &rte->addr);
! 637: p.prefixlen = rte->prefixlen;
! 638:
! 639: /* Make sure mask is applied. */
! 640: /* XXX We have to check the prefix is valid or not before call
! 641: apply_mask_ipv6. */
! 642: apply_mask_ipv6 (&p);
! 643:
! 644: /* Apply input filters. */
! 645: ri = ifp->info;
! 646:
! 647: ret = ripng_incoming_filter (&p, ri);
! 648: if (ret < 0)
! 649: return;
! 650:
! 651: /* Modify entry. */
! 652: if (ri->routemap[RIPNG_FILTER_IN])
! 653: {
! 654: int ret;
! 655: struct ripng_info newinfo;
! 656:
! 657: memset (&newinfo, 0, sizeof (struct ripng_info));
! 658: newinfo.type = ZEBRA_ROUTE_RIPNG;
! 659: newinfo.sub_type = RIPNG_ROUTE_RTE;
! 660: if (ripng_nexthop->flag == RIPNG_NEXTHOP_ADDRESS)
! 661: newinfo.nexthop = ripng_nexthop->address;
! 662: else
! 663: newinfo.nexthop = from->sin6_addr;
! 664: newinfo.from = from->sin6_addr;
! 665: newinfo.ifindex = ifp->ifindex;
! 666: newinfo.metric = rte->metric;
! 667: newinfo.metric_out = rte->metric; /* XXX */
! 668: newinfo.tag = ntohs(rte->tag); /* XXX */
! 669:
! 670: ret = route_map_apply (ri->routemap[RIPNG_FILTER_IN],
! 671: (struct prefix *)&p, RMAP_RIPNG, &newinfo);
! 672:
! 673: if (ret == RMAP_DENYMATCH)
! 674: {
! 675: if (IS_RIPNG_DEBUG_PACKET)
! 676: zlog_debug ("RIPng %s/%d is filtered by route-map in",
! 677: inet6_ntoa (p.prefix), p.prefixlen);
! 678: return;
! 679: }
! 680:
! 681: /* Get back the object */
! 682: if (ripng_nexthop->flag == RIPNG_NEXTHOP_ADDRESS) {
! 683: if (! IPV6_ADDR_SAME(&newinfo.nexthop, &ripng_nexthop->address) ) {
! 684: /* the nexthop get changed by the routemap */
! 685: if (IN6_IS_ADDR_LINKLOCAL(&newinfo.nexthop))
! 686: ripng_nexthop->address = newinfo.nexthop;
! 687: else
! 688: ripng_nexthop->address = in6addr_any;
! 689: }
! 690: } else {
! 691: if (! IPV6_ADDR_SAME(&newinfo.nexthop, &from->sin6_addr) ) {
! 692: /* the nexthop get changed by the routemap */
! 693: if (IN6_IS_ADDR_LINKLOCAL(&newinfo.nexthop)) {
! 694: ripng_nexthop->flag = RIPNG_NEXTHOP_ADDRESS;
! 695: ripng_nexthop->address = newinfo.nexthop;
! 696: }
! 697: }
! 698: }
! 699: rte->tag = htons(newinfo.tag_out); /* XXX */
! 700: rte->metric = newinfo.metric_out; /* XXX: the routemap uses the metric_out field */
! 701: }
! 702:
! 703: /* Once the entry has been validated, update the metric by
! 704: * adding the cost of the network on wich the message
! 705: * arrived. If the result is greater than infinity, use infinity
! 706: * (RFC2453 Sec. 3.9.2)
! 707: **/
! 708:
! 709: /* Zebra ripngd can handle offset-list in. */
! 710: ret = ripng_offset_list_apply_in (&p, ifp, &rte->metric);
! 711:
! 712: /* If offset-list does not modify the metric use interface's
! 713: * one. */
! 714: if (! ret)
! 715: rte->metric += ifp->metric;
! 716:
! 717: if (rte->metric > RIPNG_METRIC_INFINITY)
! 718: rte->metric = RIPNG_METRIC_INFINITY;
! 719:
! 720: /* Set nexthop pointer. */
! 721: if (ripng_nexthop->flag == RIPNG_NEXTHOP_ADDRESS)
! 722: nexthop = &ripng_nexthop->address;
! 723: else
! 724: nexthop = &from->sin6_addr;
! 725:
! 726: /* Lookup RIPng routing table. */
! 727: rp = route_node_get (ripng->table, (struct prefix *) &p);
! 728:
! 729: /* Sanity check */
! 730: rinfo = rp->info;
! 731: if (rinfo)
! 732: {
! 733: /* Redistributed route check. */
! 734: if (rinfo->type != ZEBRA_ROUTE_RIPNG
! 735: && rinfo->metric != RIPNG_METRIC_INFINITY)
! 736: return;
! 737:
! 738: /* Local static route. */
! 739: if (rinfo->type == ZEBRA_ROUTE_RIPNG
! 740: && ((rinfo->sub_type == RIPNG_ROUTE_STATIC) ||
! 741: (rinfo->sub_type == RIPNG_ROUTE_DEFAULT))
! 742: && rinfo->metric != RIPNG_METRIC_INFINITY)
! 743: return;
! 744: }
! 745:
! 746: if (rp->info == NULL)
! 747: {
! 748: /* Now, check to see whether there is already an explicit route
! 749: for the destination prefix. If there is no such route, add
! 750: this route to the routing table, unless the metric is
! 751: infinity (there is no point in adding a route which
! 752: unusable). */
! 753: if (rte->metric != RIPNG_METRIC_INFINITY)
! 754: {
! 755: rinfo = ripng_info_new ();
! 756:
! 757: /* - Setting the destination prefix and length to those in
! 758: the RTE. */
! 759: rp->info = rinfo;
! 760: rinfo->rp = rp;
! 761:
! 762: /* - Setting the metric to the newly calculated metric (as
! 763: described above). */
! 764: rinfo->metric = rte->metric;
! 765: rinfo->tag = ntohs (rte->tag);
! 766:
! 767: /* - Set the next hop address to be the address of the router
! 768: from which the datagram came or the next hop address
! 769: specified by a next hop RTE. */
! 770: IPV6_ADDR_COPY (&rinfo->nexthop, nexthop);
! 771: IPV6_ADDR_COPY (&rinfo->from, &from->sin6_addr);
! 772: rinfo->ifindex = ifp->ifindex;
! 773:
! 774: /* - Initialize the timeout for the route. If the
! 775: garbage-collection timer is running for this route, stop it. */
! 776: ripng_timeout_update (rinfo);
! 777:
! 778: /* - Set the route change flag. */
! 779: rinfo->flags |= RIPNG_RTF_CHANGED;
! 780:
! 781: /* - Signal the output process to trigger an update (see section
! 782: 2.5). */
! 783: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 784:
! 785: /* Finally, route goes into the kernel. */
! 786: rinfo->type = ZEBRA_ROUTE_RIPNG;
! 787: rinfo->sub_type = RIPNG_ROUTE_RTE;
! 788:
! 789: ripng_zebra_ipv6_add (&p, &rinfo->nexthop, rinfo->ifindex,
! 790: rinfo->metric);
! 791: rinfo->flags |= RIPNG_RTF_FIB;
! 792:
! 793: /* Aggregate check. */
! 794: ripng_aggregate_increment (rp, rinfo);
! 795: }
! 796: }
! 797: else
! 798: {
! 799: rinfo = rp->info;
! 800:
! 801: /* If there is an existing route, compare the next hop address
! 802: to the address of the router from which the datagram came.
! 803: If this datagram is from the same router as the existing
! 804: route, reinitialize the timeout. */
! 805: same = (IN6_ARE_ADDR_EQUAL (&rinfo->from, &from->sin6_addr)
! 806: && (rinfo->ifindex == ifp->ifindex));
! 807:
! 808: if (same)
! 809: ripng_timeout_update (rinfo);
! 810:
! 811: /* Next, compare the metrics. If the datagram is from the same
! 812: router as the existing route, and the new metric is different
! 813: than the old one; or, if the new metric is lower than the old
! 814: one; do the following actions: */
! 815: if ((same && rinfo->metric != rte->metric) ||
! 816: rte->metric < rinfo->metric)
! 817: {
! 818: /* - Adopt the route from the datagram. That is, put the
! 819: new metric in, and adjust the next hop address (if
! 820: necessary). */
! 821: oldmetric = rinfo->metric;
! 822: rinfo->metric = rte->metric;
! 823: rinfo->tag = ntohs (rte->tag);
! 824: IPV6_ADDR_COPY (&rinfo->from, &from->sin6_addr);
! 825: rinfo->ifindex = ifp->ifindex;
! 826:
! 827: /* Should a new route to this network be established
! 828: while the garbage-collection timer is running, the
! 829: new route will replace the one that is about to be
! 830: deleted. In this case the garbage-collection timer
! 831: must be cleared. */
! 832:
! 833: if (oldmetric == RIPNG_METRIC_INFINITY &&
! 834: rinfo->metric < RIPNG_METRIC_INFINITY)
! 835: {
! 836: rinfo->type = ZEBRA_ROUTE_RIPNG;
! 837: rinfo->sub_type = RIPNG_ROUTE_RTE;
! 838:
! 839: RIPNG_TIMER_OFF (rinfo->t_garbage_collect);
! 840:
! 841: if (! IPV6_ADDR_SAME (&rinfo->nexthop, nexthop))
! 842: IPV6_ADDR_COPY (&rinfo->nexthop, nexthop);
! 843:
! 844: ripng_zebra_ipv6_add (&p, nexthop, ifp->ifindex, rinfo->metric);
! 845: rinfo->flags |= RIPNG_RTF_FIB;
! 846:
! 847: /* The aggregation counter needs to be updated because
! 848: the prefixes, which are into the gc, have been
! 849: removed from the aggregator (see ripng_timout). */
! 850: ripng_aggregate_increment (rp, rinfo);
! 851: }
! 852:
! 853: /* Update nexthop and/or metric value. */
! 854: if (oldmetric != RIPNG_METRIC_INFINITY)
! 855: {
! 856: ripng_zebra_ipv6_delete (&p, &rinfo->nexthop, rinfo->ifindex);
! 857: ripng_zebra_ipv6_add (&p, nexthop, ifp->ifindex, rinfo->metric);
! 858: rinfo->flags |= RIPNG_RTF_FIB;
! 859:
! 860: if (! IPV6_ADDR_SAME (&rinfo->nexthop, nexthop))
! 861: IPV6_ADDR_COPY (&rinfo->nexthop, nexthop);
! 862: }
! 863:
! 864: /* - Set the route change flag and signal the output process
! 865: to trigger an update. */
! 866: rinfo->flags |= RIPNG_RTF_CHANGED;
! 867: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 868:
! 869: /* - If the new metric is infinity, start the deletion
! 870: process (described above); */
! 871: if (rinfo->metric == RIPNG_METRIC_INFINITY)
! 872: {
! 873: /* If the new metric is infinity, the deletion process
! 874: begins for the route, which is no longer used for
! 875: routing packets. Note that the deletion process is
! 876: started only when the metric is first set to
! 877: infinity. If the metric was already infinity, then a
! 878: new deletion process is not started. */
! 879: if (oldmetric != RIPNG_METRIC_INFINITY)
! 880: {
! 881: /* - The garbage-collection timer is set for 120 seconds. */
! 882: RIPNG_TIMER_ON (rinfo->t_garbage_collect,
! 883: ripng_garbage_collect, ripng->garbage_time);
! 884: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 885:
! 886: /* - The metric for the route is set to 16
! 887: (infinity). This causes the route to be removed
! 888: from service.*/
! 889: ripng_zebra_ipv6_delete (&p, &rinfo->nexthop, rinfo->ifindex);
! 890: rinfo->flags &= ~RIPNG_RTF_FIB;
! 891:
! 892: /* Aggregate count decrement. */
! 893: ripng_aggregate_decrement (rp, rinfo);
! 894:
! 895: /* - The route change flag is to indicate that this
! 896: entry has been changed. */
! 897: /* - The output process is signalled to trigger a
! 898: response. */
! 899: ; /* Above processes are already done previously. */
! 900: }
! 901: }
! 902: else
! 903: {
! 904: /* otherwise, re-initialize the timeout. */
! 905: ripng_timeout_update (rinfo);
! 906: }
! 907: }
! 908: /* Unlock tempolary lock of the route. */
! 909: route_unlock_node (rp);
! 910: }
! 911: }
! 912:
! 913: /* Add redistributed route to RIPng table. */
! 914: void
! 915: ripng_redistribute_add (int type, int sub_type, struct prefix_ipv6 *p,
! 916: unsigned int ifindex, struct in6_addr *nexthop)
! 917: {
! 918: struct route_node *rp;
! 919: struct ripng_info *rinfo;
! 920:
! 921: /* Redistribute route */
! 922: if (IN6_IS_ADDR_LINKLOCAL (&p->prefix))
! 923: return;
! 924: if (IN6_IS_ADDR_LOOPBACK (&p->prefix))
! 925: return;
! 926: #if defined (MUSICA) || defined (LINUX)
! 927: /* XXX As long as the RIPng redistribution is applied to all the connected
! 928: * routes, one needs to filter the ::/96 prefixes.
! 929: * However it could be a wanted case, it will be removed soon.
! 930: */
! 931: if ((IN6_IS_ADDR_V4COMPAT(&p->prefix)) ||
! 932: (IN6_IS_ADDR_UNSPECIFIED (&p->prefix) && (p->prefixlen == 96)))
! 933: return;
! 934: #endif /* MUSICA or LINUX */
! 935:
! 936: rp = route_node_get (ripng->table, (struct prefix *) p);
! 937: rinfo = rp->info;
! 938:
! 939: if (rinfo)
! 940: {
! 941: if (rinfo->type == ZEBRA_ROUTE_CONNECT
! 942: && rinfo->sub_type == RIPNG_ROUTE_INTERFACE
! 943: && rinfo->metric != RIPNG_METRIC_INFINITY) {
! 944: route_unlock_node (rp);
! 945: return;
! 946: }
! 947:
! 948: /* Manually configured RIPng route check.
! 949: * They have the precedence on all the other entries.
! 950: **/
! 951: if (rinfo->type == ZEBRA_ROUTE_RIPNG
! 952: && ((rinfo->sub_type == RIPNG_ROUTE_STATIC) ||
! 953: (rinfo->sub_type == RIPNG_ROUTE_DEFAULT)) ) {
! 954: if (type != ZEBRA_ROUTE_RIPNG || ((sub_type != RIPNG_ROUTE_STATIC) &&
! 955: (sub_type != RIPNG_ROUTE_DEFAULT))) {
! 956: route_unlock_node (rp);
! 957: return;
! 958: }
! 959: }
! 960:
! 961: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 962: RIPNG_TIMER_OFF (rinfo->t_garbage_collect);
! 963:
! 964: /* Tells the other daemons about the deletion of
! 965: * this RIPng route
! 966: **/
! 967: if (ripng_route_rte (rinfo))
! 968: ripng_zebra_ipv6_delete ((struct prefix_ipv6 *)&rp->p, &rinfo->nexthop,
! 969: rinfo->metric);
! 970:
! 971: rp->info = NULL;
! 972: ripng_info_free (rinfo);
! 973:
! 974: route_unlock_node (rp);
! 975:
! 976: }
! 977:
! 978: rinfo = ripng_info_new ();
! 979:
! 980: rinfo->type = type;
! 981: rinfo->sub_type = sub_type;
! 982: rinfo->ifindex = ifindex;
! 983: rinfo->metric = 1;
! 984: rinfo->rp = rp;
! 985:
! 986: if (nexthop && IN6_IS_ADDR_LINKLOCAL(nexthop))
! 987: rinfo->nexthop = *nexthop;
! 988:
! 989: rinfo->flags |= RIPNG_RTF_FIB;
! 990: rp->info = rinfo;
! 991:
! 992: /* Aggregate check. */
! 993: ripng_aggregate_increment (rp, rinfo);
! 994:
! 995: rinfo->flags |= RIPNG_RTF_CHANGED;
! 996:
! 997: if (IS_RIPNG_DEBUG_EVENT) {
! 998: if (!nexthop)
! 999: zlog_debug ("Redistribute new prefix %s/%d on the interface %s",
! 1000: inet6_ntoa(p->prefix), p->prefixlen,
! 1001: ifindex2ifname(ifindex));
! 1002: else
! 1003: zlog_debug ("Redistribute new prefix %s/%d with nexthop %s on the interface %s",
! 1004: inet6_ntoa(p->prefix), p->prefixlen, inet6_ntoa(*nexthop),
! 1005: ifindex2ifname(ifindex));
! 1006: }
! 1007:
! 1008: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 1009: }
! 1010:
! 1011: /* Delete redistributed route to RIPng table. */
! 1012: void
! 1013: ripng_redistribute_delete (int type, int sub_type, struct prefix_ipv6 *p,
! 1014: unsigned int ifindex)
! 1015: {
! 1016: struct route_node *rp;
! 1017: struct ripng_info *rinfo;
! 1018:
! 1019: if (IN6_IS_ADDR_LINKLOCAL (&p->prefix))
! 1020: return;
! 1021: if (IN6_IS_ADDR_LOOPBACK (&p->prefix))
! 1022: return;
! 1023: #if defined (MUSICA) || defined (LINUX)
! 1024: /* XXX As long as the RIPng redistribution is applied to all the connected
! 1025: * routes, one needs to filter the ::/96 prefixes.
! 1026: * However it could be a wanted case, it will be removed soon.
! 1027: */
! 1028: if ((IN6_IS_ADDR_V4COMPAT(&p->prefix)) ||
! 1029: (IN6_IS_ADDR_UNSPECIFIED (&p->prefix) && (p->prefixlen == 96)))
! 1030: return;
! 1031: #endif /* MUSICA or LINUX */
! 1032:
! 1033: rp = route_node_lookup (ripng->table, (struct prefix *) p);
! 1034:
! 1035: if (rp)
! 1036: {
! 1037: rinfo = rp->info;
! 1038:
! 1039: if (rinfo != NULL
! 1040: && rinfo->type == type
! 1041: && rinfo->sub_type == sub_type
! 1042: && rinfo->ifindex == ifindex)
! 1043: {
! 1044: /* Perform poisoned reverse. */
! 1045: rinfo->metric = RIPNG_METRIC_INFINITY;
! 1046: RIPNG_TIMER_ON (rinfo->t_garbage_collect,
! 1047: ripng_garbage_collect, ripng->garbage_time);
! 1048: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 1049:
! 1050: /* Aggregate count decrement. */
! 1051: ripng_aggregate_decrement (rp, rinfo);
! 1052:
! 1053: rinfo->flags |= RIPNG_RTF_CHANGED;
! 1054:
! 1055: if (IS_RIPNG_DEBUG_EVENT)
! 1056: zlog_debug ("Poisone %s/%d on the interface %s with an infinity metric [delete]",
! 1057: inet6_ntoa(p->prefix), p->prefixlen,
! 1058: ifindex2ifname(ifindex));
! 1059:
! 1060: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 1061: }
! 1062: }
! 1063: }
! 1064:
! 1065: /* Withdraw redistributed route. */
! 1066: void
! 1067: ripng_redistribute_withdraw (int type)
! 1068: {
! 1069: struct route_node *rp;
! 1070: struct ripng_info *rinfo;
! 1071:
! 1072: if (!ripng)
! 1073: return;
! 1074:
! 1075: for (rp = route_top (ripng->table); rp; rp = route_next (rp))
! 1076: if ((rinfo = rp->info) != NULL)
! 1077: {
! 1078: if ((rinfo->type == type)
! 1079: && (rinfo->sub_type != RIPNG_ROUTE_INTERFACE))
! 1080: {
! 1081: /* Perform poisoned reverse. */
! 1082: rinfo->metric = RIPNG_METRIC_INFINITY;
! 1083: RIPNG_TIMER_ON (rinfo->t_garbage_collect,
! 1084: ripng_garbage_collect, ripng->garbage_time);
! 1085: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 1086:
! 1087: /* Aggregate count decrement. */
! 1088: ripng_aggregate_decrement (rp, rinfo);
! 1089:
! 1090: rinfo->flags |= RIPNG_RTF_CHANGED;
! 1091:
! 1092: if (IS_RIPNG_DEBUG_EVENT) {
! 1093: struct prefix_ipv6 *p = (struct prefix_ipv6 *) &rp->p;
! 1094:
! 1095: zlog_debug ("Poisone %s/%d on the interface %s [withdraw]",
! 1096: inet6_ntoa(p->prefix), p->prefixlen,
! 1097: ifindex2ifname(rinfo->ifindex));
! 1098: }
! 1099:
! 1100: ripng_event (RIPNG_TRIGGERED_UPDATE, 0);
! 1101: }
! 1102: }
! 1103: }
! 1104:
! 1105: /* RIP routing information. */
! 1106: static void
! 1107: ripng_response_process (struct ripng_packet *packet, int size,
! 1108: struct sockaddr_in6 *from, struct interface *ifp,
! 1109: int hoplimit)
! 1110: {
! 1111: caddr_t lim;
! 1112: struct rte *rte;
! 1113: struct ripng_nexthop nexthop;
! 1114:
! 1115: /* RFC2080 2.4.2 Response Messages:
! 1116: The Response must be ignored if it is not from the RIPng port. */
! 1117: if (ntohs (from->sin6_port) != RIPNG_PORT_DEFAULT)
! 1118: {
! 1119: zlog_warn ("RIPng packet comes from non RIPng port %d from %s",
! 1120: ntohs (from->sin6_port), inet6_ntoa (from->sin6_addr));
! 1121: ripng_peer_bad_packet (from);
! 1122: return;
! 1123: }
! 1124:
! 1125: /* The datagram's IPv6 source address should be checked to see
! 1126: whether the datagram is from a valid neighbor; the source of the
! 1127: datagram must be a link-local address. */
! 1128: if (! IN6_IS_ADDR_LINKLOCAL(&from->sin6_addr))
! 1129: {
! 1130: zlog_warn ("RIPng packet comes from non link local address %s",
! 1131: inet6_ntoa (from->sin6_addr));
! 1132: ripng_peer_bad_packet (from);
! 1133: return;
! 1134: }
! 1135:
! 1136: /* It is also worth checking to see whether the response is from one
! 1137: of the router's own addresses. Interfaces on broadcast networks
! 1138: may receive copies of their own multicasts immediately. If a
! 1139: router processes its own output as new input, confusion is likely,
! 1140: and such datagrams must be ignored. */
! 1141: if (ripng_lladdr_check (ifp, &from->sin6_addr))
! 1142: {
! 1143: zlog_warn ("RIPng packet comes from my own link local address %s",
! 1144: inet6_ntoa (from->sin6_addr));
! 1145: ripng_peer_bad_packet (from);
! 1146: return;
! 1147: }
! 1148:
! 1149: /* As an additional check, periodic advertisements must have their
! 1150: hop counts set to 255, and inbound, multicast packets sent from the
! 1151: RIPng port (i.e. periodic advertisement or triggered update
! 1152: packets) must be examined to ensure that the hop count is 255. */
! 1153: if (hoplimit >= 0 && hoplimit != 255)
! 1154: {
! 1155: zlog_warn ("RIPng packet comes with non 255 hop count %d from %s",
! 1156: hoplimit, inet6_ntoa (from->sin6_addr));
! 1157: ripng_peer_bad_packet (from);
! 1158: return;
! 1159: }
! 1160:
! 1161: /* Update RIPng peer. */
! 1162: ripng_peer_update (from, packet->version);
! 1163:
! 1164: /* Reset nexthop. */
! 1165: memset (&nexthop, 0, sizeof (struct ripng_nexthop));
! 1166: nexthop.flag = RIPNG_NEXTHOP_UNSPEC;
! 1167:
! 1168: /* Set RTE pointer. */
! 1169: rte = packet->rte;
! 1170:
! 1171: for (lim = ((caddr_t) packet) + size; (caddr_t) rte < lim; rte++)
! 1172: {
! 1173: /* First of all, we have to check this RTE is next hop RTE or
! 1174: not. Next hop RTE is completely different with normal RTE so
! 1175: we need special treatment. */
! 1176: if (rte->metric == RIPNG_METRIC_NEXTHOP)
! 1177: {
! 1178: ripng_nexthop_rte (rte, from, &nexthop);
! 1179: continue;
! 1180: }
! 1181:
! 1182: /* RTE information validation. */
! 1183:
! 1184: /* - is the destination prefix valid (e.g., not a multicast
! 1185: prefix and not a link-local address) A link-local address
! 1186: should never be present in an RTE. */
! 1187: if (IN6_IS_ADDR_MULTICAST (&rte->addr))
! 1188: {
! 1189: zlog_warn ("Destination prefix is a multicast address %s/%d [%d]",
! 1190: inet6_ntoa (rte->addr), rte->prefixlen, rte->metric);
! 1191: ripng_peer_bad_route (from);
! 1192: continue;
! 1193: }
! 1194: if (IN6_IS_ADDR_LINKLOCAL (&rte->addr))
! 1195: {
! 1196: zlog_warn ("Destination prefix is a link-local address %s/%d [%d]",
! 1197: inet6_ntoa (rte->addr), rte->prefixlen, rte->metric);
! 1198: ripng_peer_bad_route (from);
! 1199: continue;
! 1200: }
! 1201: if (IN6_IS_ADDR_LOOPBACK (&rte->addr))
! 1202: {
! 1203: zlog_warn ("Destination prefix is a loopback address %s/%d [%d]",
! 1204: inet6_ntoa (rte->addr), rte->prefixlen, rte->metric);
! 1205: ripng_peer_bad_route (from);
! 1206: continue;
! 1207: }
! 1208:
! 1209: /* - is the prefix length valid (i.e., between 0 and 128,
! 1210: inclusive) */
! 1211: if (rte->prefixlen > 128)
! 1212: {
! 1213: zlog_warn ("Invalid prefix length %s/%d from %s%%%s",
! 1214: inet6_ntoa (rte->addr), rte->prefixlen,
! 1215: inet6_ntoa (from->sin6_addr), ifp->name);
! 1216: ripng_peer_bad_route (from);
! 1217: continue;
! 1218: }
! 1219:
! 1220: /* - is the metric valid (i.e., between 1 and 16, inclusive) */
! 1221: if (! (rte->metric >= 1 && rte->metric <= 16))
! 1222: {
! 1223: zlog_warn ("Invalid metric %d from %s%%%s", rte->metric,
! 1224: inet6_ntoa (from->sin6_addr), ifp->name);
! 1225: ripng_peer_bad_route (from);
! 1226: continue;
! 1227: }
! 1228:
! 1229: /* Vincent: XXX Should we compute the direclty reachable nexthop
! 1230: * for our RIPng network ?
! 1231: **/
! 1232:
! 1233: /* Routing table updates. */
! 1234: ripng_route_process (rte, from, &nexthop, ifp);
! 1235: }
! 1236: }
! 1237:
! 1238: /* Response to request message. */
! 1239: static void
! 1240: ripng_request_process (struct ripng_packet *packet,int size,
! 1241: struct sockaddr_in6 *from, struct interface *ifp)
! 1242: {
! 1243: caddr_t lim;
! 1244: struct rte *rte;
! 1245: struct prefix_ipv6 p;
! 1246: struct route_node *rp;
! 1247: struct ripng_info *rinfo;
! 1248: struct ripng_interface *ri;
! 1249:
! 1250: /* Does not reponse to the requests on the loopback interfaces */
! 1251: if (if_is_loopback (ifp))
! 1252: return;
! 1253:
! 1254: /* Check RIPng process is enabled on this interface. */
! 1255: ri = ifp->info;
! 1256: if (! ri->running)
! 1257: return;
! 1258:
! 1259: /* When passive interface is specified, suppress responses */
! 1260: if (ri->passive)
! 1261: return;
! 1262:
! 1263: /* RIPng peer update. */
! 1264: ripng_peer_update (from, packet->version);
! 1265:
! 1266: lim = ((caddr_t) packet) + size;
! 1267: rte = packet->rte;
! 1268:
! 1269: /* The Request is processed entry by entry. If there are no
! 1270: entries, no response is given. */
! 1271: if (lim == (caddr_t) rte)
! 1272: return;
! 1273:
! 1274: /* There is one special case. If there is exactly one entry in the
! 1275: request, and it has a destination prefix of zero, a prefix length
! 1276: of zero, and a metric of infinity (i.e., 16), then this is a
! 1277: request to send the entire routing table. In that case, a call
! 1278: is made to the output process to send the routing table to the
! 1279: requesting address/port. */
! 1280: if (lim == ((caddr_t) (rte + 1)) &&
! 1281: IN6_IS_ADDR_UNSPECIFIED (&rte->addr) &&
! 1282: rte->prefixlen == 0 &&
! 1283: rte->metric == RIPNG_METRIC_INFINITY)
! 1284: {
! 1285: /* All route with split horizon */
! 1286: ripng_output_process (ifp, from, ripng_all_route);
! 1287: }
! 1288: else
! 1289: {
! 1290: /* Except for this special case, processing is quite simple.
! 1291: Examine the list of RTEs in the Request one by one. For each
! 1292: entry, look up the destination in the router's routing
! 1293: database and, if there is a route, put that route's metric in
! 1294: the metric field of the RTE. If there is no explicit route
! 1295: to the specified destination, put infinity in the metric
! 1296: field. Once all the entries have been filled in, change the
! 1297: command from Request to Response and send the datagram back
! 1298: to the requestor. */
! 1299: memset (&p, 0, sizeof (struct prefix_ipv6));
! 1300: p.family = AF_INET6;
! 1301:
! 1302: for (; ((caddr_t) rte) < lim; rte++)
! 1303: {
! 1304: p.prefix = rte->addr;
! 1305: p.prefixlen = rte->prefixlen;
! 1306: apply_mask_ipv6 (&p);
! 1307:
! 1308: rp = route_node_lookup (ripng->table, (struct prefix *) &p);
! 1309:
! 1310: if (rp)
! 1311: {
! 1312: rinfo = rp->info;
! 1313: rte->metric = rinfo->metric;
! 1314: route_unlock_node (rp);
! 1315: }
! 1316: else
! 1317: rte->metric = RIPNG_METRIC_INFINITY;
! 1318: }
! 1319: packet->command = RIPNG_RESPONSE;
! 1320:
! 1321: ripng_send_packet ((caddr_t) packet, size, from, ifp);
! 1322: }
! 1323: }
! 1324:
! 1325: /* First entry point of reading RIPng packet. */
! 1326: static int
! 1327: ripng_read (struct thread *thread)
! 1328: {
! 1329: int len;
! 1330: int sock;
! 1331: struct sockaddr_in6 from;
! 1332: struct ripng_packet *packet;
! 1333: unsigned int ifindex;
! 1334: struct interface *ifp;
! 1335: int hoplimit = -1;
! 1336:
! 1337: /* Check ripng is active and alive. */
! 1338: assert (ripng != NULL);
! 1339: assert (ripng->sock >= 0);
! 1340:
! 1341: /* Fetch thread data and set read pointer to empty for event
! 1342: managing. `sock' sould be same as ripng->sock. */
! 1343: sock = THREAD_FD (thread);
! 1344: ripng->t_read = NULL;
! 1345:
! 1346: /* Add myself to the next event. */
! 1347: ripng_event (RIPNG_READ, sock);
! 1348:
! 1349: /* Read RIPng packet. */
! 1350: len = ripng_recv_packet (sock, STREAM_DATA (ripng->ibuf),
! 1351: STREAM_SIZE (ripng->ibuf), &from, &ifindex,
! 1352: &hoplimit);
! 1353: if (len < 0)
! 1354: {
! 1355: zlog_warn ("RIPng recvfrom failed: %s.", safe_strerror (errno));
! 1356: return len;
! 1357: }
! 1358:
! 1359: /* Check RTE boundary. RTE size (Packet length - RIPng header size
! 1360: (4)) must be multiple size of one RTE size (20). */
! 1361: if (((len - 4) % 20) != 0)
! 1362: {
! 1363: zlog_warn ("RIPng invalid packet size %d from %s", len,
! 1364: inet6_ntoa (from.sin6_addr));
! 1365: ripng_peer_bad_packet (&from);
! 1366: return 0;
! 1367: }
! 1368:
! 1369: packet = (struct ripng_packet *) STREAM_DATA (ripng->ibuf);
! 1370: ifp = if_lookup_by_index (ifindex);
! 1371:
! 1372: /* RIPng packet received. */
! 1373: if (IS_RIPNG_DEBUG_EVENT)
! 1374: zlog_debug ("RIPng packet received from %s port %d on %s",
! 1375: inet6_ntoa (from.sin6_addr), ntohs (from.sin6_port),
! 1376: ifp ? ifp->name : "unknown");
! 1377:
! 1378: /* Logging before packet checking. */
! 1379: if (IS_RIPNG_DEBUG_RECV)
! 1380: ripng_packet_dump (packet, len, "RECV");
! 1381:
! 1382: /* Packet comes from unknown interface. */
! 1383: if (ifp == NULL)
! 1384: {
! 1385: zlog_warn ("RIPng packet comes from unknown interface %d", ifindex);
! 1386: return 0;
! 1387: }
! 1388:
! 1389: /* Packet version mismatch checking. */
! 1390: if (packet->version != ripng->version)
! 1391: {
! 1392: zlog_warn ("RIPng packet version %d doesn't fit to my version %d",
! 1393: packet->version, ripng->version);
! 1394: ripng_peer_bad_packet (&from);
! 1395: return 0;
! 1396: }
! 1397:
! 1398: /* Process RIPng packet. */
! 1399: switch (packet->command)
! 1400: {
! 1401: case RIPNG_REQUEST:
! 1402: ripng_request_process (packet, len, &from, ifp);
! 1403: break;
! 1404: case RIPNG_RESPONSE:
! 1405: ripng_response_process (packet, len, &from, ifp, hoplimit);
! 1406: break;
! 1407: default:
! 1408: zlog_warn ("Invalid RIPng command %d", packet->command);
! 1409: ripng_peer_bad_packet (&from);
! 1410: break;
! 1411: }
! 1412: return 0;
! 1413: }
! 1414:
! 1415: /* Walk down the RIPng routing table then clear changed flag. */
! 1416: static void
! 1417: ripng_clear_changed_flag (void)
! 1418: {
! 1419: struct route_node *rp;
! 1420: struct ripng_info *rinfo;
! 1421:
! 1422: for (rp = route_top (ripng->table); rp; rp = route_next (rp))
! 1423: if ((rinfo = rp->info) != NULL)
! 1424: if (rinfo->flags & RIPNG_RTF_CHANGED)
! 1425: rinfo->flags &= ~RIPNG_RTF_CHANGED;
! 1426: }
! 1427:
! 1428: /* Regular update of RIPng route. Send all routing formation to RIPng
! 1429: enabled interface. */
! 1430: static int
! 1431: ripng_update (struct thread *t)
! 1432: {
! 1433: struct listnode *node;
! 1434: struct interface *ifp;
! 1435: struct ripng_interface *ri;
! 1436:
! 1437: /* Clear update timer thread. */
! 1438: ripng->t_update = NULL;
! 1439:
! 1440: /* Logging update event. */
! 1441: if (IS_RIPNG_DEBUG_EVENT)
! 1442: zlog_debug ("RIPng update timer expired!");
! 1443:
! 1444: /* Supply routes to each interface. */
! 1445: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 1446: {
! 1447: ri = ifp->info;
! 1448:
! 1449: if (if_is_loopback (ifp) || ! if_is_up (ifp))
! 1450: continue;
! 1451:
! 1452: if (! ri->running)
! 1453: continue;
! 1454:
! 1455: /* When passive interface is specified, suppress announce to the
! 1456: interface. */
! 1457: if (ri->passive)
! 1458: continue;
! 1459:
! 1460: #if RIPNG_ADVANCED
! 1461: if (ri->ri_send == RIPNG_SEND_OFF)
! 1462: {
! 1463: if (IS_RIPNG_DEBUG_EVENT)
! 1464: zlog (NULL, LOG_DEBUG,
! 1465: "[Event] RIPng send to if %d is suppressed by config",
! 1466: ifp->ifindex);
! 1467: continue;
! 1468: }
! 1469: #endif /* RIPNG_ADVANCED */
! 1470:
! 1471: ripng_output_process (ifp, NULL, ripng_all_route);
! 1472: }
! 1473:
! 1474: /* Triggered updates may be suppressed if a regular update is due by
! 1475: the time the triggered update would be sent. */
! 1476: if (ripng->t_triggered_interval)
! 1477: {
! 1478: thread_cancel (ripng->t_triggered_interval);
! 1479: ripng->t_triggered_interval = NULL;
! 1480: }
! 1481: ripng->trigger = 0;
! 1482:
! 1483: /* Reset flush event. */
! 1484: ripng_event (RIPNG_UPDATE_EVENT, 0);
! 1485:
! 1486: return 0;
! 1487: }
! 1488:
! 1489: /* Triggered update interval timer. */
! 1490: static int
! 1491: ripng_triggered_interval (struct thread *t)
! 1492: {
! 1493: ripng->t_triggered_interval = NULL;
! 1494:
! 1495: if (ripng->trigger)
! 1496: {
! 1497: ripng->trigger = 0;
! 1498: ripng_triggered_update (t);
! 1499: }
! 1500: return 0;
! 1501: }
! 1502:
! 1503: /* Execute triggered update. */
! 1504: int
! 1505: ripng_triggered_update (struct thread *t)
! 1506: {
! 1507: struct listnode *node;
! 1508: struct interface *ifp;
! 1509: struct ripng_interface *ri;
! 1510: int interval;
! 1511:
! 1512: ripng->t_triggered_update = NULL;
! 1513:
! 1514: /* Cancel interval timer. */
! 1515: if (ripng->t_triggered_interval)
! 1516: {
! 1517: thread_cancel (ripng->t_triggered_interval);
! 1518: ripng->t_triggered_interval = NULL;
! 1519: }
! 1520: ripng->trigger = 0;
! 1521:
! 1522: /* Logging triggered update. */
! 1523: if (IS_RIPNG_DEBUG_EVENT)
! 1524: zlog_debug ("RIPng triggered update!");
! 1525:
! 1526: /* Split Horizon processing is done when generating triggered
! 1527: updates as well as normal updates (see section 2.6). */
! 1528: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 1529: {
! 1530: ri = ifp->info;
! 1531:
! 1532: if (if_is_loopback (ifp) || ! if_is_up (ifp))
! 1533: continue;
! 1534:
! 1535: if (! ri->running)
! 1536: continue;
! 1537:
! 1538: /* When passive interface is specified, suppress announce to the
! 1539: interface. */
! 1540: if (ri->passive)
! 1541: continue;
! 1542:
! 1543: ripng_output_process (ifp, NULL, ripng_changed_route);
! 1544: }
! 1545:
! 1546: /* Once all of the triggered updates have been generated, the route
! 1547: change flags should be cleared. */
! 1548: ripng_clear_changed_flag ();
! 1549:
! 1550: /* After a triggered update is sent, a timer should be set for a
! 1551: random interval between 1 and 5 seconds. If other changes that
! 1552: would trigger updates occur before the timer expires, a single
! 1553: update is triggered when the timer expires. */
! 1554: interval = (random () % 5) + 1;
! 1555:
! 1556: ripng->t_triggered_interval =
! 1557: thread_add_timer (master, ripng_triggered_interval, NULL, interval);
! 1558:
! 1559: return 0;
! 1560: }
! 1561:
! 1562: /* Write routing table entry to the stream and return next index of
! 1563: the routing table entry in the stream. */
! 1564: int
! 1565: ripng_write_rte (int num, struct stream *s, struct prefix_ipv6 *p,
! 1566: struct in6_addr *nexthop, u_int16_t tag, u_char metric)
! 1567: {
! 1568: /* RIPng packet header. */
! 1569: if (num == 0)
! 1570: {
! 1571: stream_putc (s, RIPNG_RESPONSE);
! 1572: stream_putc (s, RIPNG_V1);
! 1573: stream_putw (s, 0);
! 1574: }
! 1575:
! 1576: /* Write routing table entry. */
! 1577: if (!nexthop)
! 1578: stream_write (s, (u_char *) &p->prefix, sizeof (struct in6_addr));
! 1579: else
! 1580: stream_write (s, (u_char *) nexthop, sizeof (struct in6_addr));
! 1581: stream_putw (s, tag);
! 1582: if (p)
! 1583: stream_putc (s, p->prefixlen);
! 1584: else
! 1585: stream_putc (s, 0);
! 1586: stream_putc (s, metric);
! 1587:
! 1588: return ++num;
! 1589: }
! 1590:
! 1591: /* Send RESPONSE message to specified destination. */
! 1592: void
! 1593: ripng_output_process (struct interface *ifp, struct sockaddr_in6 *to,
! 1594: int route_type)
! 1595: {
! 1596: int ret;
! 1597: struct route_node *rp;
! 1598: struct ripng_info *rinfo;
! 1599: struct ripng_interface *ri;
! 1600: struct ripng_aggregate *aggregate;
! 1601: struct prefix_ipv6 *p;
! 1602: struct list * ripng_rte_list;
! 1603:
! 1604: if (IS_RIPNG_DEBUG_EVENT) {
! 1605: if (to)
! 1606: zlog_debug ("RIPng update routes to neighbor %s",
! 1607: inet6_ntoa(to->sin6_addr));
! 1608: else
! 1609: zlog_debug ("RIPng update routes on interface %s", ifp->name);
! 1610: }
! 1611:
! 1612: /* Get RIPng interface. */
! 1613: ri = ifp->info;
! 1614:
! 1615: ripng_rte_list = ripng_rte_new();
! 1616:
! 1617: for (rp = route_top (ripng->table); rp; rp = route_next (rp))
! 1618: {
! 1619: if ((rinfo = rp->info) != NULL && rinfo->suppress == 0)
! 1620: {
! 1621: /* If no route-map are applied, the RTE will be these following
! 1622: * informations.
! 1623: */
! 1624: p = (struct prefix_ipv6 *) &rp->p;
! 1625: rinfo->metric_out = rinfo->metric;
! 1626: rinfo->tag_out = rinfo->tag;
! 1627: memset(&rinfo->nexthop_out, 0, sizeof(rinfo->nexthop_out));
! 1628: /* In order to avoid some local loops,
! 1629: * if the RIPng route has a nexthop via this interface, keep the nexthop,
! 1630: * otherwise set it to 0. The nexthop should not be propagated
! 1631: * beyond the local broadcast/multicast area in order
! 1632: * to avoid an IGP multi-level recursive look-up.
! 1633: */
! 1634: if (rinfo->ifindex == ifp->ifindex)
! 1635: rinfo->nexthop_out = rinfo->nexthop;
! 1636:
! 1637: /* Apply output filters. */
! 1638: ret = ripng_outgoing_filter (p, ri);
! 1639: if (ret < 0)
! 1640: continue;
! 1641:
! 1642: /* Changed route only output. */
! 1643: if (route_type == ripng_changed_route &&
! 1644: (! (rinfo->flags & RIPNG_RTF_CHANGED)))
! 1645: continue;
! 1646:
! 1647: /* Split horizon. */
! 1648: if (ri->split_horizon == RIPNG_SPLIT_HORIZON)
! 1649: {
! 1650: /* We perform split horizon for RIPng routes. */
! 1651: if ((rinfo->type == ZEBRA_ROUTE_RIPNG) &&
! 1652: rinfo->ifindex == ifp->ifindex)
! 1653: continue;
! 1654: }
! 1655:
! 1656: /* Preparation for route-map. */
! 1657: rinfo->metric_set = 0;
! 1658: /* nexthop_out,
! 1659: * metric_out
! 1660: * and tag_out are already initialized.
! 1661: */
! 1662:
! 1663: /* Interface route-map */
! 1664: if (ri->routemap[RIPNG_FILTER_OUT])
! 1665: {
! 1666: int ret;
! 1667:
! 1668: ret = route_map_apply (ri->routemap[RIPNG_FILTER_OUT],
! 1669: (struct prefix *) p, RMAP_RIPNG,
! 1670: rinfo);
! 1671:
! 1672: if (ret == RMAP_DENYMATCH)
! 1673: {
! 1674: if (IS_RIPNG_DEBUG_PACKET)
! 1675: zlog_debug ("RIPng %s/%d is filtered by route-map out",
! 1676: inet6_ntoa (p->prefix), p->prefixlen);
! 1677: continue;
! 1678: }
! 1679:
! 1680: }
! 1681:
! 1682: /* Redistribute route-map. */
! 1683: if (ripng->route_map[rinfo->type].name)
! 1684: {
! 1685: int ret;
! 1686:
! 1687: ret = route_map_apply (ripng->route_map[rinfo->type].map,
! 1688: (struct prefix *) p, RMAP_RIPNG,
! 1689: rinfo);
! 1690:
! 1691: if (ret == RMAP_DENYMATCH)
! 1692: {
! 1693: if (IS_RIPNG_DEBUG_PACKET)
! 1694: zlog_debug ("RIPng %s/%d is filtered by route-map",
! 1695: inet6_ntoa (p->prefix), p->prefixlen);
! 1696: continue;
! 1697: }
! 1698: }
! 1699:
! 1700: /* When the route-map does not set metric. */
! 1701: if (! rinfo->metric_set)
! 1702: {
! 1703: /* If the redistribute metric is set. */
! 1704: if (ripng->route_map[rinfo->type].metric_config
! 1705: && rinfo->metric != RIPNG_METRIC_INFINITY)
! 1706: {
! 1707: rinfo->metric_out = ripng->route_map[rinfo->type].metric;
! 1708: }
! 1709: else
! 1710: {
! 1711: /* If the route is not connected or localy generated
! 1712: one, use default-metric value */
! 1713: if (rinfo->type != ZEBRA_ROUTE_RIPNG
! 1714: && rinfo->type != ZEBRA_ROUTE_CONNECT
! 1715: && rinfo->metric != RIPNG_METRIC_INFINITY)
! 1716: rinfo->metric_out = ripng->default_metric;
! 1717: }
! 1718: }
! 1719:
! 1720: /* Apply offset-list */
! 1721: if (rinfo->metric_out != RIPNG_METRIC_INFINITY)
! 1722: ripng_offset_list_apply_out (p, ifp, &rinfo->metric_out);
! 1723:
! 1724: if (rinfo->metric_out > RIPNG_METRIC_INFINITY)
! 1725: rinfo->metric_out = RIPNG_METRIC_INFINITY;
! 1726:
! 1727: /* Perform split-horizon with poisoned reverse
! 1728: * for RIPng routes.
! 1729: **/
! 1730: if (ri->split_horizon == RIPNG_SPLIT_HORIZON_POISONED_REVERSE) {
! 1731: if ((rinfo->type == ZEBRA_ROUTE_RIPNG) &&
! 1732: rinfo->ifindex == ifp->ifindex)
! 1733: rinfo->metric_out = RIPNG_METRIC_INFINITY;
! 1734: }
! 1735:
! 1736: /* Add RTE to the list */
! 1737: ripng_rte_add(ripng_rte_list, p, rinfo, NULL);
! 1738: }
! 1739:
! 1740: /* Process the aggregated RTE entry */
! 1741: if ((aggregate = rp->aggregate) != NULL &&
! 1742: aggregate->count > 0 &&
! 1743: aggregate->suppress == 0)
! 1744: {
! 1745: /* If no route-map are applied, the RTE will be these following
! 1746: * informations.
! 1747: */
! 1748: p = (struct prefix_ipv6 *) &rp->p;
! 1749: aggregate->metric_set = 0;
! 1750: aggregate->metric_out = aggregate->metric;
! 1751: aggregate->tag_out = aggregate->tag;
! 1752: memset(&aggregate->nexthop_out, 0, sizeof(aggregate->nexthop_out));
! 1753:
! 1754: /* Apply output filters.*/
! 1755: ret = ripng_outgoing_filter (p, ri);
! 1756: if (ret < 0)
! 1757: continue;
! 1758:
! 1759: /* Interface route-map */
! 1760: if (ri->routemap[RIPNG_FILTER_OUT])
! 1761: {
! 1762: int ret;
! 1763: struct ripng_info newinfo;
! 1764:
! 1765: /* let's cast the aggregate structure to ripng_info */
! 1766: memset (&newinfo, 0, sizeof (struct ripng_info));
! 1767: /* the nexthop is :: */
! 1768: newinfo.metric = aggregate->metric;
! 1769: newinfo.metric_out = aggregate->metric_out;
! 1770: newinfo.tag = aggregate->tag;
! 1771: newinfo.tag_out = aggregate->tag_out;
! 1772:
! 1773: ret = route_map_apply (ri->routemap[RIPNG_FILTER_OUT],
! 1774: (struct prefix *) p, RMAP_RIPNG,
! 1775: &newinfo);
! 1776:
! 1777: if (ret == RMAP_DENYMATCH)
! 1778: {
! 1779: if (IS_RIPNG_DEBUG_PACKET)
! 1780: zlog_debug ("RIPng %s/%d is filtered by route-map out",
! 1781: inet6_ntoa (p->prefix), p->prefixlen);
! 1782: continue;
! 1783: }
! 1784:
! 1785: aggregate->metric_out = newinfo.metric_out;
! 1786: aggregate->tag_out = newinfo.tag_out;
! 1787: if (IN6_IS_ADDR_LINKLOCAL(&newinfo.nexthop_out))
! 1788: aggregate->nexthop_out = newinfo.nexthop_out;
! 1789: }
! 1790:
! 1791: /* There is no redistribute routemap for the aggregated RTE */
! 1792:
! 1793: /* Changed route only output. */
! 1794: /* XXX, vincent, in order to increase time convergence,
! 1795: * it should be announced if a child has changed.
! 1796: */
! 1797: if (route_type == ripng_changed_route)
! 1798: continue;
! 1799:
! 1800: /* Apply offset-list */
! 1801: if (aggregate->metric_out != RIPNG_METRIC_INFINITY)
! 1802: ripng_offset_list_apply_out (p, ifp, &aggregate->metric_out);
! 1803:
! 1804: if (aggregate->metric_out > RIPNG_METRIC_INFINITY)
! 1805: aggregate->metric_out = RIPNG_METRIC_INFINITY;
! 1806:
! 1807: /* Add RTE to the list */
! 1808: ripng_rte_add(ripng_rte_list, p, NULL, aggregate);
! 1809: }
! 1810:
! 1811: }
! 1812:
! 1813: /* Flush the list */
! 1814: ripng_rte_send(ripng_rte_list, ifp, to);
! 1815: ripng_rte_free(ripng_rte_list);
! 1816: }
! 1817:
! 1818: /* Create new RIPng instance and set it to global variable. */
! 1819: static int
! 1820: ripng_create (void)
! 1821: {
! 1822: /* ripng should be NULL. */
! 1823: assert (ripng == NULL);
! 1824:
! 1825: /* Allocaste RIPng instance. */
! 1826: ripng = XCALLOC (MTYPE_RIPNG, sizeof (struct ripng));
! 1827:
! 1828: /* Default version and timer values. */
! 1829: ripng->version = RIPNG_V1;
! 1830: ripng->update_time = RIPNG_UPDATE_TIMER_DEFAULT;
! 1831: ripng->timeout_time = RIPNG_TIMEOUT_TIMER_DEFAULT;
! 1832: ripng->garbage_time = RIPNG_GARBAGE_TIMER_DEFAULT;
! 1833: ripng->default_metric = RIPNG_DEFAULT_METRIC_DEFAULT;
! 1834:
! 1835: /* Make buffer. */
! 1836: ripng->ibuf = stream_new (RIPNG_MAX_PACKET_SIZE * 5);
! 1837: ripng->obuf = stream_new (RIPNG_MAX_PACKET_SIZE);
! 1838:
! 1839: /* Initialize RIPng routig table. */
! 1840: ripng->table = route_table_init ();
! 1841: ripng->route = route_table_init ();
! 1842: ripng->aggregate = route_table_init ();
! 1843:
! 1844: /* Make socket. */
! 1845: ripng->sock = ripng_make_socket ();
! 1846: if (ripng->sock < 0)
! 1847: return ripng->sock;
! 1848:
! 1849: /* Threads. */
! 1850: ripng_event (RIPNG_READ, ripng->sock);
! 1851: ripng_event (RIPNG_UPDATE_EVENT, 1);
! 1852:
! 1853: return 0;
! 1854: }
! 1855:
! 1856: /* Send RIPng request to the interface. */
! 1857: int
! 1858: ripng_request (struct interface *ifp)
! 1859: {
! 1860: struct rte *rte;
! 1861: struct ripng_packet ripng_packet;
! 1862:
! 1863: /* In default ripd doesn't send RIP_REQUEST to the loopback interface. */
! 1864: if (if_is_loopback(ifp))
! 1865: return 0;
! 1866:
! 1867: /* If interface is down, don't send RIP packet. */
! 1868: if (! if_is_up (ifp))
! 1869: return 0;
! 1870:
! 1871: if (IS_RIPNG_DEBUG_EVENT)
! 1872: zlog_debug ("RIPng send request to %s", ifp->name);
! 1873:
! 1874: memset (&ripng_packet, 0, sizeof (ripng_packet));
! 1875: ripng_packet.command = RIPNG_REQUEST;
! 1876: ripng_packet.version = RIPNG_V1;
! 1877: rte = ripng_packet.rte;
! 1878: rte->metric = RIPNG_METRIC_INFINITY;
! 1879:
! 1880: return ripng_send_packet ((caddr_t) &ripng_packet, sizeof (ripng_packet),
! 1881: NULL, ifp);
! 1882: }
! 1883:
! 1884:
! 1885: static int
! 1886: ripng_update_jitter (int time)
! 1887: {
! 1888: return ((rand () % (time + 1)) - (time / 2));
! 1889: }
! 1890:
! 1891: void
! 1892: ripng_event (enum ripng_event event, int sock)
! 1893: {
! 1894: int jitter = 0;
! 1895:
! 1896: switch (event)
! 1897: {
! 1898: case RIPNG_READ:
! 1899: if (!ripng->t_read)
! 1900: ripng->t_read = thread_add_read (master, ripng_read, NULL, sock);
! 1901: break;
! 1902: case RIPNG_UPDATE_EVENT:
! 1903: if (ripng->t_update)
! 1904: {
! 1905: thread_cancel (ripng->t_update);
! 1906: ripng->t_update = NULL;
! 1907: }
! 1908: /* Update timer jitter. */
! 1909: jitter = ripng_update_jitter (ripng->update_time);
! 1910:
! 1911: ripng->t_update =
! 1912: thread_add_timer (master, ripng_update, NULL,
! 1913: sock ? 2 : ripng->update_time + jitter);
! 1914: break;
! 1915: case RIPNG_TRIGGERED_UPDATE:
! 1916: if (ripng->t_triggered_interval)
! 1917: ripng->trigger = 1;
! 1918: else if (! ripng->t_triggered_update)
! 1919: ripng->t_triggered_update =
! 1920: thread_add_event (master, ripng_triggered_update, NULL, 0);
! 1921: break;
! 1922: default:
! 1923: break;
! 1924: }
! 1925: }
! 1926:
! 1927:
! 1928: /* Print out routes update time. */
! 1929: static void
! 1930: ripng_vty_out_uptime (struct vty *vty, struct ripng_info *rinfo)
! 1931: {
! 1932: time_t clock;
! 1933: struct tm *tm;
! 1934: #define TIME_BUF 25
! 1935: char timebuf [TIME_BUF];
! 1936: struct thread *thread;
! 1937:
! 1938: if ((thread = rinfo->t_timeout) != NULL)
! 1939: {
! 1940: clock = thread_timer_remain_second (thread);
! 1941: tm = gmtime (&clock);
! 1942: strftime (timebuf, TIME_BUF, "%M:%S", tm);
! 1943: vty_out (vty, "%5s", timebuf);
! 1944: }
! 1945: else if ((thread = rinfo->t_garbage_collect) != NULL)
! 1946: {
! 1947: clock = thread_timer_remain_second (thread);
! 1948: tm = gmtime (&clock);
! 1949: strftime (timebuf, TIME_BUF, "%M:%S", tm);
! 1950: vty_out (vty, "%5s", timebuf);
! 1951: }
! 1952: }
! 1953:
! 1954: static char *
! 1955: ripng_route_subtype_print (struct ripng_info *rinfo)
! 1956: {
! 1957: static char str[3];
! 1958: memset(str, 0, 3);
! 1959:
! 1960: if (rinfo->suppress)
! 1961: strcat(str, "S");
! 1962:
! 1963: switch (rinfo->sub_type)
! 1964: {
! 1965: case RIPNG_ROUTE_RTE:
! 1966: strcat(str, "n");
! 1967: break;
! 1968: case RIPNG_ROUTE_STATIC:
! 1969: strcat(str, "s");
! 1970: break;
! 1971: case RIPNG_ROUTE_DEFAULT:
! 1972: strcat(str, "d");
! 1973: break;
! 1974: case RIPNG_ROUTE_REDISTRIBUTE:
! 1975: strcat(str, "r");
! 1976: break;
! 1977: case RIPNG_ROUTE_INTERFACE:
! 1978: strcat(str, "i");
! 1979: break;
! 1980: default:
! 1981: strcat(str, "?");
! 1982: break;
! 1983: }
! 1984:
! 1985: return str;
! 1986: }
! 1987:
! 1988: DEFUN (show_ipv6_ripng,
! 1989: show_ipv6_ripng_cmd,
! 1990: "show ipv6 ripng",
! 1991: SHOW_STR
! 1992: IPV6_STR
! 1993: "Show RIPng routes\n")
! 1994: {
! 1995: struct route_node *rp;
! 1996: struct ripng_info *rinfo;
! 1997: struct ripng_aggregate *aggregate;
! 1998: struct prefix_ipv6 *p;
! 1999: int len;
! 2000:
! 2001: if (! ripng)
! 2002: return CMD_SUCCESS;
! 2003:
! 2004: /* Header of display. */
! 2005: vty_out (vty, "Codes: R - RIPng, C - connected, S - Static, O - OSPF, B - BGP%s"
! 2006: "Sub-codes:%s"
! 2007: " (n) - normal, (s) - static, (d) - default, (r) - redistribute,%s"
! 2008: " (i) - interface, (a/S) - aggregated/Suppressed%s%s"
! 2009: " Network Next Hop Via Metric Tag Time%s",
! 2010: VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE,
! 2011: VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
! 2012:
! 2013: for (rp = route_top (ripng->table); rp; rp = route_next (rp))
! 2014: {
! 2015: if ((aggregate = rp->aggregate) != NULL)
! 2016: {
! 2017: p = (struct prefix_ipv6 *) &rp->p;
! 2018:
! 2019: #ifdef DEBUG
! 2020: len = vty_out (vty, "R(a) %d/%d %s/%d ",
! 2021: aggregate->count, aggregate->suppress,
! 2022: inet6_ntoa (p->prefix), p->prefixlen);
! 2023: #else
! 2024: len = vty_out (vty, "R(a) %s/%d ",
! 2025: inet6_ntoa (p->prefix), p->prefixlen);
! 2026: #endif /* DEBUG */
! 2027: vty_out (vty, "%s", VTY_NEWLINE);
! 2028: vty_out (vty, "%*s", 18, " ");
! 2029:
! 2030: vty_out (vty, "%*s", 28, " ");
! 2031: vty_out (vty, "self %2d %3d%s", aggregate->metric,
! 2032: aggregate->tag,
! 2033: VTY_NEWLINE);
! 2034: }
! 2035:
! 2036: if ((rinfo = rp->info) != NULL)
! 2037: {
! 2038: p = (struct prefix_ipv6 *) &rp->p;
! 2039:
! 2040: #ifdef DEBUG
! 2041: len = vty_out (vty, "%c(%s) 0/%d %s/%d ",
! 2042: zebra_route_char(rinfo->type),
! 2043: ripng_route_subtype_print(rinfo),
! 2044: rinfo->suppress,
! 2045: inet6_ntoa (p->prefix), p->prefixlen);
! 2046: #else
! 2047: len = vty_out (vty, "%c(%s) %s/%d ",
! 2048: zebra_route_char(rinfo->type),
! 2049: ripng_route_subtype_print(rinfo),
! 2050: inet6_ntoa (p->prefix), p->prefixlen);
! 2051: #endif /* DEBUG */
! 2052: vty_out (vty, "%s", VTY_NEWLINE);
! 2053: vty_out (vty, "%*s", 18, " ");
! 2054: len = vty_out (vty, "%s", inet6_ntoa (rinfo->nexthop));
! 2055:
! 2056: len = 28 - len;
! 2057: if (len > 0)
! 2058: len = vty_out (vty, "%*s", len, " ");
! 2059:
! 2060: /* from */
! 2061: if ((rinfo->type == ZEBRA_ROUTE_RIPNG) &&
! 2062: (rinfo->sub_type == RIPNG_ROUTE_RTE))
! 2063: {
! 2064: len = vty_out (vty, "%s", ifindex2ifname(rinfo->ifindex));
! 2065: } else if (rinfo->metric == RIPNG_METRIC_INFINITY)
! 2066: {
! 2067: len = vty_out (vty, "kill");
! 2068: } else
! 2069: len = vty_out (vty, "self");
! 2070:
! 2071: len = 9 - len;
! 2072: if (len > 0)
! 2073: vty_out (vty, "%*s", len, " ");
! 2074:
! 2075: vty_out (vty, " %2d %3d ",
! 2076: rinfo->metric, rinfo->tag);
! 2077:
! 2078: /* time */
! 2079: if ((rinfo->type == ZEBRA_ROUTE_RIPNG) &&
! 2080: (rinfo->sub_type == RIPNG_ROUTE_RTE))
! 2081: {
! 2082: /* RTE from remote RIP routers */
! 2083: ripng_vty_out_uptime (vty, rinfo);
! 2084: } else if (rinfo->metric == RIPNG_METRIC_INFINITY)
! 2085: {
! 2086: /* poisonous reversed routes (gc) */
! 2087: ripng_vty_out_uptime (vty, rinfo);
! 2088: }
! 2089:
! 2090: vty_out (vty, "%s", VTY_NEWLINE);
! 2091: }
! 2092: }
! 2093:
! 2094: return CMD_SUCCESS;
! 2095: }
! 2096:
! 2097: DEFUN (show_ipv6_ripng_status,
! 2098: show_ipv6_ripng_status_cmd,
! 2099: "show ipv6 ripng status",
! 2100: SHOW_STR
! 2101: IPV6_STR
! 2102: "Show RIPng routes\n"
! 2103: "IPv6 routing protocol process parameters and statistics\n")
! 2104: {
! 2105: struct listnode *node;
! 2106: struct interface *ifp;
! 2107:
! 2108: if (! ripng)
! 2109: return CMD_SUCCESS;
! 2110:
! 2111: vty_out (vty, "Routing Protocol is \"RIPng\"%s", VTY_NEWLINE);
! 2112: vty_out (vty, " Sending updates every %ld seconds with +/-50%%,",
! 2113: ripng->update_time);
! 2114: vty_out (vty, " next due in %lu seconds%s",
! 2115: thread_timer_remain_second (ripng->t_update),
! 2116: VTY_NEWLINE);
! 2117: vty_out (vty, " Timeout after %ld seconds,", ripng->timeout_time);
! 2118: vty_out (vty, " garbage collect after %ld seconds%s", ripng->garbage_time,
! 2119: VTY_NEWLINE);
! 2120:
! 2121: /* Filtering status show. */
! 2122: config_show_distribute (vty);
! 2123:
! 2124: /* Default metric information. */
! 2125: vty_out (vty, " Default redistribution metric is %d%s",
! 2126: ripng->default_metric, VTY_NEWLINE);
! 2127:
! 2128: /* Redistribute information. */
! 2129: vty_out (vty, " Redistributing:");
! 2130: ripng_redistribute_write (vty, 0);
! 2131: vty_out (vty, "%s", VTY_NEWLINE);
! 2132:
! 2133: vty_out (vty, " Default version control: send version %d,", ripng->version);
! 2134: vty_out (vty, " receive version %d %s", ripng->version,
! 2135: VTY_NEWLINE);
! 2136:
! 2137: vty_out (vty, " Interface Send Recv%s", VTY_NEWLINE);
! 2138:
! 2139: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 2140: {
! 2141: struct ripng_interface *ri;
! 2142:
! 2143: ri = ifp->info;
! 2144:
! 2145: if (ri->enable_network || ri->enable_interface)
! 2146: {
! 2147:
! 2148: vty_out (vty, " %-17s%-3d %-3d%s", ifp->name,
! 2149: ripng->version,
! 2150: ripng->version,
! 2151: VTY_NEWLINE);
! 2152: }
! 2153: }
! 2154:
! 2155: vty_out (vty, " Routing for Networks:%s", VTY_NEWLINE);
! 2156: ripng_network_write (vty, 0);
! 2157:
! 2158: vty_out (vty, " Routing Information Sources:%s", VTY_NEWLINE);
! 2159: vty_out (vty, " Gateway BadPackets BadRoutes Distance Last Update%s", VTY_NEWLINE);
! 2160: ripng_peer_display (vty);
! 2161:
! 2162: return CMD_SUCCESS;
! 2163: }
! 2164:
! 2165: DEFUN (router_ripng,
! 2166: router_ripng_cmd,
! 2167: "router ripng",
! 2168: "Enable a routing process\n"
! 2169: "Make RIPng instance command\n")
! 2170: {
! 2171: int ret;
! 2172:
! 2173: vty->node = RIPNG_NODE;
! 2174:
! 2175: if (!ripng)
! 2176: {
! 2177: ret = ripng_create ();
! 2178:
! 2179: /* Notice to user we couldn't create RIPng. */
! 2180: if (ret < 0)
! 2181: {
! 2182: zlog_warn ("can't create RIPng");
! 2183: return CMD_WARNING;
! 2184: }
! 2185: }
! 2186:
! 2187: return CMD_SUCCESS;
! 2188: }
! 2189:
! 2190: DEFUN (no_router_ripng,
! 2191: no_router_ripng_cmd,
! 2192: "no router ripng",
! 2193: NO_STR
! 2194: "Enable a routing process\n"
! 2195: "Make RIPng instance command\n")
! 2196: {
! 2197: if(ripng)
! 2198: ripng_clean();
! 2199: return CMD_SUCCESS;
! 2200: }
! 2201:
! 2202: DEFUN (ripng_route,
! 2203: ripng_route_cmd,
! 2204: "route IPV6ADDR",
! 2205: "Static route setup\n"
! 2206: "Set static RIPng route announcement\n")
! 2207: {
! 2208: int ret;
! 2209: struct prefix_ipv6 p;
! 2210: struct route_node *rp;
! 2211:
! 2212: ret = str2prefix_ipv6 (argv[0], (struct prefix_ipv6 *)&p);
! 2213: if (ret <= 0)
! 2214: {
! 2215: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2216: return CMD_WARNING;
! 2217: }
! 2218: apply_mask_ipv6 (&p);
! 2219:
! 2220: rp = route_node_get (ripng->route, (struct prefix *) &p);
! 2221: if (rp->info)
! 2222: {
! 2223: vty_out (vty, "There is already same static route.%s", VTY_NEWLINE);
! 2224: route_unlock_node (rp);
! 2225: return CMD_WARNING;
! 2226: }
! 2227: rp->info = (void *)1;
! 2228:
! 2229: ripng_redistribute_add (ZEBRA_ROUTE_RIPNG, RIPNG_ROUTE_STATIC, &p, 0, NULL);
! 2230:
! 2231: return CMD_SUCCESS;
! 2232: }
! 2233:
! 2234: DEFUN (no_ripng_route,
! 2235: no_ripng_route_cmd,
! 2236: "no route IPV6ADDR",
! 2237: NO_STR
! 2238: "Static route setup\n"
! 2239: "Delete static RIPng route announcement\n")
! 2240: {
! 2241: int ret;
! 2242: struct prefix_ipv6 p;
! 2243: struct route_node *rp;
! 2244:
! 2245: ret = str2prefix_ipv6 (argv[0], (struct prefix_ipv6 *)&p);
! 2246: if (ret <= 0)
! 2247: {
! 2248: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2249: return CMD_WARNING;
! 2250: }
! 2251: apply_mask_ipv6 (&p);
! 2252:
! 2253: rp = route_node_lookup (ripng->route, (struct prefix *) &p);
! 2254: if (! rp)
! 2255: {
! 2256: vty_out (vty, "Can't find static route.%s", VTY_NEWLINE);
! 2257: return CMD_WARNING;
! 2258: }
! 2259:
! 2260: ripng_redistribute_delete (ZEBRA_ROUTE_RIPNG, RIPNG_ROUTE_STATIC, &p, 0);
! 2261: route_unlock_node (rp);
! 2262:
! 2263: rp->info = NULL;
! 2264: route_unlock_node (rp);
! 2265:
! 2266: return CMD_SUCCESS;
! 2267: }
! 2268:
! 2269: DEFUN (ripng_aggregate_address,
! 2270: ripng_aggregate_address_cmd,
! 2271: "aggregate-address X:X::X:X/M",
! 2272: "Set aggregate RIPng route announcement\n"
! 2273: "Aggregate network\n")
! 2274: {
! 2275: int ret;
! 2276: struct prefix p;
! 2277: struct route_node *node;
! 2278:
! 2279: ret = str2prefix_ipv6 (argv[0], (struct prefix_ipv6 *)&p);
! 2280: if (ret <= 0)
! 2281: {
! 2282: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2283: return CMD_WARNING;
! 2284: }
! 2285:
! 2286: /* Check aggregate alredy exist or not. */
! 2287: node = route_node_get (ripng->aggregate, &p);
! 2288: if (node->info)
! 2289: {
! 2290: vty_out (vty, "There is already same aggregate route.%s", VTY_NEWLINE);
! 2291: route_unlock_node (node);
! 2292: return CMD_WARNING;
! 2293: }
! 2294: node->info = (void *)1;
! 2295:
! 2296: ripng_aggregate_add (&p);
! 2297:
! 2298: return CMD_SUCCESS;
! 2299: }
! 2300:
! 2301: DEFUN (no_ripng_aggregate_address,
! 2302: no_ripng_aggregate_address_cmd,
! 2303: "no aggregate-address X:X::X:X/M",
! 2304: NO_STR
! 2305: "Delete aggregate RIPng route announcement\n"
! 2306: "Aggregate network")
! 2307: {
! 2308: int ret;
! 2309: struct prefix p;
! 2310: struct route_node *rn;
! 2311:
! 2312: ret = str2prefix_ipv6 (argv[0], (struct prefix_ipv6 *) &p);
! 2313: if (ret <= 0)
! 2314: {
! 2315: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2316: return CMD_WARNING;
! 2317: }
! 2318:
! 2319: rn = route_node_lookup (ripng->aggregate, &p);
! 2320: if (! rn)
! 2321: {
! 2322: vty_out (vty, "Can't find aggregate route.%s", VTY_NEWLINE);
! 2323: return CMD_WARNING;
! 2324: }
! 2325: route_unlock_node (rn);
! 2326: rn->info = NULL;
! 2327: route_unlock_node (rn);
! 2328:
! 2329: ripng_aggregate_delete (&p);
! 2330:
! 2331: return CMD_SUCCESS;
! 2332: }
! 2333:
! 2334: DEFUN (ripng_default_metric,
! 2335: ripng_default_metric_cmd,
! 2336: "default-metric <1-16>",
! 2337: "Set a metric of redistribute routes\n"
! 2338: "Default metric\n")
! 2339: {
! 2340: if (ripng)
! 2341: {
! 2342: ripng->default_metric = atoi (argv[0]);
! 2343: }
! 2344: return CMD_SUCCESS;
! 2345: }
! 2346:
! 2347: DEFUN (no_ripng_default_metric,
! 2348: no_ripng_default_metric_cmd,
! 2349: "no default-metric",
! 2350: NO_STR
! 2351: "Set a metric of redistribute routes\n"
! 2352: "Default metric\n")
! 2353: {
! 2354: if (ripng)
! 2355: {
! 2356: ripng->default_metric = RIPNG_DEFAULT_METRIC_DEFAULT;
! 2357: }
! 2358: return CMD_SUCCESS;
! 2359: }
! 2360:
! 2361: ALIAS (no_ripng_default_metric,
! 2362: no_ripng_default_metric_val_cmd,
! 2363: "no default-metric <1-16>",
! 2364: NO_STR
! 2365: "Set a metric of redistribute routes\n"
! 2366: "Default metric\n")
! 2367:
! 2368: #if 0
! 2369: /* RIPng update timer setup. */
! 2370: DEFUN (ripng_update_timer,
! 2371: ripng_update_timer_cmd,
! 2372: "update-timer SECOND",
! 2373: "Set RIPng update timer in seconds\n"
! 2374: "Seconds\n")
! 2375: {
! 2376: unsigned long update;
! 2377: char *endptr = NULL;
! 2378:
! 2379: update = strtoul (argv[0], &endptr, 10);
! 2380: if (update == ULONG_MAX || *endptr != '\0')
! 2381: {
! 2382: vty_out (vty, "update timer value error%s", VTY_NEWLINE);
! 2383: return CMD_WARNING;
! 2384: }
! 2385:
! 2386: ripng->update_time = update;
! 2387:
! 2388: ripng_event (RIPNG_UPDATE_EVENT, 0);
! 2389: return CMD_SUCCESS;
! 2390: }
! 2391:
! 2392: DEFUN (no_ripng_update_timer,
! 2393: no_ripng_update_timer_cmd,
! 2394: "no update-timer SECOND",
! 2395: NO_STR
! 2396: "Unset RIPng update timer in seconds\n"
! 2397: "Seconds\n")
! 2398: {
! 2399: ripng->update_time = RIPNG_UPDATE_TIMER_DEFAULT;
! 2400: ripng_event (RIPNG_UPDATE_EVENT, 0);
! 2401: return CMD_SUCCESS;
! 2402: }
! 2403:
! 2404: /* RIPng timeout timer setup. */
! 2405: DEFUN (ripng_timeout_timer,
! 2406: ripng_timeout_timer_cmd,
! 2407: "timeout-timer SECOND",
! 2408: "Set RIPng timeout timer in seconds\n"
! 2409: "Seconds\n")
! 2410: {
! 2411: unsigned long timeout;
! 2412: char *endptr = NULL;
! 2413:
! 2414: timeout = strtoul (argv[0], &endptr, 10);
! 2415: if (timeout == ULONG_MAX || *endptr != '\0')
! 2416: {
! 2417: vty_out (vty, "timeout timer value error%s", VTY_NEWLINE);
! 2418: return CMD_WARNING;
! 2419: }
! 2420:
! 2421: ripng->timeout_time = timeout;
! 2422:
! 2423: return CMD_SUCCESS;
! 2424: }
! 2425:
! 2426: DEFUN (no_ripng_timeout_timer,
! 2427: no_ripng_timeout_timer_cmd,
! 2428: "no timeout-timer SECOND",
! 2429: NO_STR
! 2430: "Unset RIPng timeout timer in seconds\n"
! 2431: "Seconds\n")
! 2432: {
! 2433: ripng->timeout_time = RIPNG_TIMEOUT_TIMER_DEFAULT;
! 2434: return CMD_SUCCESS;
! 2435: }
! 2436:
! 2437: /* RIPng garbage timer setup. */
! 2438: DEFUN (ripng_garbage_timer,
! 2439: ripng_garbage_timer_cmd,
! 2440: "garbage-timer SECOND",
! 2441: "Set RIPng garbage timer in seconds\n"
! 2442: "Seconds\n")
! 2443: {
! 2444: unsigned long garbage;
! 2445: char *endptr = NULL;
! 2446:
! 2447: garbage = strtoul (argv[0], &endptr, 10);
! 2448: if (garbage == ULONG_MAX || *endptr != '\0')
! 2449: {
! 2450: vty_out (vty, "garbage timer value error%s", VTY_NEWLINE);
! 2451: return CMD_WARNING;
! 2452: }
! 2453:
! 2454: ripng->garbage_time = garbage;
! 2455:
! 2456: return CMD_SUCCESS;
! 2457: }
! 2458:
! 2459: DEFUN (no_ripng_garbage_timer,
! 2460: no_ripng_garbage_timer_cmd,
! 2461: "no garbage-timer SECOND",
! 2462: NO_STR
! 2463: "Unset RIPng garbage timer in seconds\n"
! 2464: "Seconds\n")
! 2465: {
! 2466: ripng->garbage_time = RIPNG_GARBAGE_TIMER_DEFAULT;
! 2467: return CMD_SUCCESS;
! 2468: }
! 2469: #endif /* 0 */
! 2470:
! 2471: DEFUN (ripng_timers,
! 2472: ripng_timers_cmd,
! 2473: "timers basic <0-65535> <0-65535> <0-65535>",
! 2474: "RIPng timers setup\n"
! 2475: "Basic timer\n"
! 2476: "Routing table update timer value in second. Default is 30.\n"
! 2477: "Routing information timeout timer. Default is 180.\n"
! 2478: "Garbage collection timer. Default is 120.\n")
! 2479: {
! 2480: unsigned long update;
! 2481: unsigned long timeout;
! 2482: unsigned long garbage;
! 2483: char *endptr = NULL;
! 2484:
! 2485: update = strtoul (argv[0], &endptr, 10);
! 2486: if (update == ULONG_MAX || *endptr != '\0')
! 2487: {
! 2488: vty_out (vty, "update timer value error%s", VTY_NEWLINE);
! 2489: return CMD_WARNING;
! 2490: }
! 2491:
! 2492: timeout = strtoul (argv[1], &endptr, 10);
! 2493: if (timeout == ULONG_MAX || *endptr != '\0')
! 2494: {
! 2495: vty_out (vty, "timeout timer value error%s", VTY_NEWLINE);
! 2496: return CMD_WARNING;
! 2497: }
! 2498:
! 2499: garbage = strtoul (argv[2], &endptr, 10);
! 2500: if (garbage == ULONG_MAX || *endptr != '\0')
! 2501: {
! 2502: vty_out (vty, "garbage timer value error%s", VTY_NEWLINE);
! 2503: return CMD_WARNING;
! 2504: }
! 2505:
! 2506: /* Set each timer value. */
! 2507: ripng->update_time = update;
! 2508: ripng->timeout_time = timeout;
! 2509: ripng->garbage_time = garbage;
! 2510:
! 2511: /* Reset update timer thread. */
! 2512: ripng_event (RIPNG_UPDATE_EVENT, 0);
! 2513:
! 2514: return CMD_SUCCESS;
! 2515: }
! 2516:
! 2517: DEFUN (no_ripng_timers,
! 2518: no_ripng_timers_cmd,
! 2519: "no timers basic",
! 2520: NO_STR
! 2521: "RIPng timers setup\n"
! 2522: "Basic timer\n")
! 2523: {
! 2524: /* Set each timer value to the default. */
! 2525: ripng->update_time = RIPNG_UPDATE_TIMER_DEFAULT;
! 2526: ripng->timeout_time = RIPNG_TIMEOUT_TIMER_DEFAULT;
! 2527: ripng->garbage_time = RIPNG_GARBAGE_TIMER_DEFAULT;
! 2528:
! 2529: /* Reset update timer thread. */
! 2530: ripng_event (RIPNG_UPDATE_EVENT, 0);
! 2531:
! 2532: return CMD_SUCCESS;
! 2533: }
! 2534:
! 2535: ALIAS (no_ripng_timers,
! 2536: no_ripng_timers_val_cmd,
! 2537: "no timers basic <0-65535> <0-65535> <0-65535>",
! 2538: NO_STR
! 2539: "RIPng timers setup\n"
! 2540: "Basic timer\n"
! 2541: "Routing table update timer value in second. Default is 30.\n"
! 2542: "Routing information timeout timer. Default is 180.\n"
! 2543: "Garbage collection timer. Default is 120.\n")
! 2544:
! 2545: DEFUN (show_ipv6_protocols, show_ipv6_protocols_cmd,
! 2546: "show ipv6 protocols",
! 2547: SHOW_STR
! 2548: IPV6_STR
! 2549: "Routing protocol information")
! 2550: {
! 2551: if (! ripng)
! 2552: return CMD_SUCCESS;
! 2553:
! 2554: vty_out (vty, "Routing Protocol is \"ripng\"%s", VTY_NEWLINE);
! 2555:
! 2556: vty_out (vty, "Sending updates every %ld seconds, next due in %d seconds%s",
! 2557: ripng->update_time, 0,
! 2558: VTY_NEWLINE);
! 2559:
! 2560: vty_out (vty, "Timerout after %ld seconds, garbage correct %ld%s",
! 2561: ripng->timeout_time,
! 2562: ripng->garbage_time,
! 2563: VTY_NEWLINE);
! 2564:
! 2565: vty_out (vty, "Outgoing update filter list for all interfaces is not set");
! 2566: vty_out (vty, "Incoming update filter list for all interfaces is not set");
! 2567:
! 2568: return CMD_SUCCESS;
! 2569: }
! 2570:
! 2571: /* Please be carefull to use this command. */
! 2572: DEFUN (ripng_default_information_originate,
! 2573: ripng_default_information_originate_cmd,
! 2574: "default-information originate",
! 2575: "Default route information\n"
! 2576: "Distribute default route\n")
! 2577: {
! 2578: struct prefix_ipv6 p;
! 2579:
! 2580: if (! ripng ->default_information) {
! 2581: ripng->default_information = 1;
! 2582:
! 2583: str2prefix_ipv6 ("::/0", &p);
! 2584: ripng_redistribute_add (ZEBRA_ROUTE_RIPNG, RIPNG_ROUTE_DEFAULT, &p, 0, NULL);
! 2585: }
! 2586:
! 2587: return CMD_SUCCESS;
! 2588: }
! 2589:
! 2590: DEFUN (no_ripng_default_information_originate,
! 2591: no_ripng_default_information_originate_cmd,
! 2592: "no default-information originate",
! 2593: NO_STR
! 2594: "Default route information\n"
! 2595: "Distribute default route\n")
! 2596: {
! 2597: struct prefix_ipv6 p;
! 2598:
! 2599: if (ripng->default_information) {
! 2600: ripng->default_information = 0;
! 2601:
! 2602: str2prefix_ipv6 ("::/0", &p);
! 2603: ripng_redistribute_delete (ZEBRA_ROUTE_RIPNG, RIPNG_ROUTE_DEFAULT, &p, 0);
! 2604: }
! 2605:
! 2606: return CMD_SUCCESS;
! 2607: }
! 2608:
! 2609: /* RIPng configuration write function. */
! 2610: static int
! 2611: ripng_config_write (struct vty *vty)
! 2612: {
! 2613: int ripng_network_write (struct vty *, int);
! 2614: void ripng_redistribute_write (struct vty *, int);
! 2615: int write = 0;
! 2616: struct route_node *rp;
! 2617:
! 2618: if (ripng)
! 2619: {
! 2620:
! 2621: /* RIPng router. */
! 2622: vty_out (vty, "router ripng%s", VTY_NEWLINE);
! 2623:
! 2624: if (ripng->default_information)
! 2625: vty_out (vty, " default-information originate%s", VTY_NEWLINE);
! 2626:
! 2627: ripng_network_write (vty, 1);
! 2628:
! 2629: /* RIPng default metric configuration */
! 2630: if (ripng->default_metric != RIPNG_DEFAULT_METRIC_DEFAULT)
! 2631: vty_out (vty, " default-metric %d%s",
! 2632: ripng->default_metric, VTY_NEWLINE);
! 2633:
! 2634: ripng_redistribute_write (vty, 1);
! 2635:
! 2636: /* RIP offset-list configuration. */
! 2637: config_write_ripng_offset_list (vty);
! 2638:
! 2639: /* RIPng aggregate routes. */
! 2640: for (rp = route_top (ripng->aggregate); rp; rp = route_next (rp))
! 2641: if (rp->info != NULL)
! 2642: vty_out (vty, " aggregate-address %s/%d%s",
! 2643: inet6_ntoa (rp->p.u.prefix6),
! 2644: rp->p.prefixlen,
! 2645:
! 2646: VTY_NEWLINE);
! 2647:
! 2648: /* RIPng static routes. */
! 2649: for (rp = route_top (ripng->route); rp; rp = route_next (rp))
! 2650: if (rp->info != NULL)
! 2651: vty_out (vty, " route %s/%d%s", inet6_ntoa (rp->p.u.prefix6),
! 2652: rp->p.prefixlen,
! 2653: VTY_NEWLINE);
! 2654:
! 2655: /* RIPng timers configuration. */
! 2656: if (ripng->update_time != RIPNG_UPDATE_TIMER_DEFAULT ||
! 2657: ripng->timeout_time != RIPNG_TIMEOUT_TIMER_DEFAULT ||
! 2658: ripng->garbage_time != RIPNG_GARBAGE_TIMER_DEFAULT)
! 2659: {
! 2660: vty_out (vty, " timers basic %ld %ld %ld%s",
! 2661: ripng->update_time,
! 2662: ripng->timeout_time,
! 2663: ripng->garbage_time,
! 2664: VTY_NEWLINE);
! 2665: }
! 2666: #if 0
! 2667: if (ripng->update_time != RIPNG_UPDATE_TIMER_DEFAULT)
! 2668: vty_out (vty, " update-timer %d%s", ripng->update_time,
! 2669: VTY_NEWLINE);
! 2670: if (ripng->timeout_time != RIPNG_TIMEOUT_TIMER_DEFAULT)
! 2671: vty_out (vty, " timeout-timer %d%s", ripng->timeout_time,
! 2672: VTY_NEWLINE);
! 2673: if (ripng->garbage_time != RIPNG_GARBAGE_TIMER_DEFAULT)
! 2674: vty_out (vty, " garbage-timer %d%s", ripng->garbage_time,
! 2675: VTY_NEWLINE);
! 2676: #endif /* 0 */
! 2677:
! 2678: write += config_write_distribute (vty);
! 2679:
! 2680: write += config_write_if_rmap (vty);
! 2681:
! 2682: write++;
! 2683: }
! 2684: return write;
! 2685: }
! 2686:
! 2687: /* RIPng node structure. */
! 2688: static struct cmd_node cmd_ripng_node =
! 2689: {
! 2690: RIPNG_NODE,
! 2691: "%s(config-router)# ",
! 2692: 1,
! 2693: };
! 2694:
! 2695: static void
! 2696: ripng_distribute_update (struct distribute *dist)
! 2697: {
! 2698: struct interface *ifp;
! 2699: struct ripng_interface *ri;
! 2700: struct access_list *alist;
! 2701: struct prefix_list *plist;
! 2702:
! 2703: if (! dist->ifname)
! 2704: return;
! 2705:
! 2706: ifp = if_lookup_by_name (dist->ifname);
! 2707: if (ifp == NULL)
! 2708: return;
! 2709:
! 2710: ri = ifp->info;
! 2711:
! 2712: if (dist->list[DISTRIBUTE_IN])
! 2713: {
! 2714: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_IN]);
! 2715: if (alist)
! 2716: ri->list[RIPNG_FILTER_IN] = alist;
! 2717: else
! 2718: ri->list[RIPNG_FILTER_IN] = NULL;
! 2719: }
! 2720: else
! 2721: ri->list[RIPNG_FILTER_IN] = NULL;
! 2722:
! 2723: if (dist->list[DISTRIBUTE_OUT])
! 2724: {
! 2725: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_OUT]);
! 2726: if (alist)
! 2727: ri->list[RIPNG_FILTER_OUT] = alist;
! 2728: else
! 2729: ri->list[RIPNG_FILTER_OUT] = NULL;
! 2730: }
! 2731: else
! 2732: ri->list[RIPNG_FILTER_OUT] = NULL;
! 2733:
! 2734: if (dist->prefix[DISTRIBUTE_IN])
! 2735: {
! 2736: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_IN]);
! 2737: if (plist)
! 2738: ri->prefix[RIPNG_FILTER_IN] = plist;
! 2739: else
! 2740: ri->prefix[RIPNG_FILTER_IN] = NULL;
! 2741: }
! 2742: else
! 2743: ri->prefix[RIPNG_FILTER_IN] = NULL;
! 2744:
! 2745: if (dist->prefix[DISTRIBUTE_OUT])
! 2746: {
! 2747: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_OUT]);
! 2748: if (plist)
! 2749: ri->prefix[RIPNG_FILTER_OUT] = plist;
! 2750: else
! 2751: ri->prefix[RIPNG_FILTER_OUT] = NULL;
! 2752: }
! 2753: else
! 2754: ri->prefix[RIPNG_FILTER_OUT] = NULL;
! 2755: }
! 2756:
! 2757: void
! 2758: ripng_distribute_update_interface (struct interface *ifp)
! 2759: {
! 2760: struct distribute *dist;
! 2761:
! 2762: dist = distribute_lookup (ifp->name);
! 2763: if (dist)
! 2764: ripng_distribute_update (dist);
! 2765: }
! 2766:
! 2767: /* Update all interface's distribute list. */
! 2768: static void
! 2769: ripng_distribute_update_all (struct prefix_list *notused)
! 2770: {
! 2771: struct interface *ifp;
! 2772: struct listnode *node;
! 2773:
! 2774: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 2775: ripng_distribute_update_interface (ifp);
! 2776: }
! 2777:
! 2778: static void
! 2779: ripng_distribute_update_all_wrapper (struct access_list *notused)
! 2780: {
! 2781: ripng_distribute_update_all(NULL);
! 2782: }
! 2783:
! 2784: /* delete all the added ripng routes. */
! 2785: void
! 2786: ripng_clean()
! 2787: {
! 2788: int i;
! 2789: struct route_node *rp;
! 2790: struct ripng_info *rinfo;
! 2791:
! 2792: if (ripng) {
! 2793: /* Clear RIPng routes */
! 2794: for (rp = route_top (ripng->table); rp; rp = route_next (rp)) {
! 2795: if ((rinfo = rp->info) != NULL) {
! 2796: if ((rinfo->type == ZEBRA_ROUTE_RIPNG) &&
! 2797: (rinfo->sub_type == RIPNG_ROUTE_RTE))
! 2798: ripng_zebra_ipv6_delete ((struct prefix_ipv6 *)&rp->p,
! 2799: &rinfo->nexthop, rinfo->metric);
! 2800:
! 2801: RIPNG_TIMER_OFF (rinfo->t_timeout);
! 2802: RIPNG_TIMER_OFF (rinfo->t_garbage_collect);
! 2803:
! 2804: rp->info = NULL;
! 2805: route_unlock_node (rp);
! 2806:
! 2807: ripng_info_free(rinfo);
! 2808: }
! 2809: }
! 2810:
! 2811: /* Cancel the RIPng timers */
! 2812: RIPNG_TIMER_OFF (ripng->t_update);
! 2813: RIPNG_TIMER_OFF (ripng->t_triggered_update);
! 2814: RIPNG_TIMER_OFF (ripng->t_triggered_interval);
! 2815:
! 2816: /* Cancel the read thread */
! 2817: if (ripng->t_read) {
! 2818: thread_cancel (ripng->t_read);
! 2819: ripng->t_read = NULL;
! 2820: }
! 2821:
! 2822: /* Close the RIPng socket */
! 2823: if (ripng->sock >= 0) {
! 2824: close(ripng->sock);
! 2825: ripng->sock = -1;
! 2826: }
! 2827:
! 2828: /* Static RIPng route configuration. */
! 2829: for (rp = route_top (ripng->route); rp; rp = route_next (rp))
! 2830: if (rp->info) {
! 2831: rp->info = NULL;
! 2832: route_unlock_node (rp);
! 2833: }
! 2834:
! 2835: /* RIPng aggregated prefixes */
! 2836: for (rp = route_top (ripng->aggregate); rp; rp = route_next (rp))
! 2837: if (rp->info) {
! 2838: rp->info = NULL;
! 2839: route_unlock_node (rp);
! 2840: }
! 2841:
! 2842: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
! 2843: if (ripng->route_map[i].name)
! 2844: free (ripng->route_map[i].name);
! 2845:
! 2846: XFREE (MTYPE_ROUTE_TABLE, ripng->table);
! 2847: XFREE (MTYPE_ROUTE_TABLE, ripng->route);
! 2848: XFREE (MTYPE_ROUTE_TABLE, ripng->aggregate);
! 2849:
! 2850: XFREE (MTYPE_RIPNG, ripng);
! 2851: ripng = NULL;
! 2852: } /* if (ripng) */
! 2853:
! 2854: ripng_clean_network();
! 2855: ripng_passive_interface_clean ();
! 2856: ripng_offset_clean ();
! 2857: ripng_interface_clean ();
! 2858: ripng_redistribute_clean ();
! 2859: }
! 2860:
! 2861: /* Reset all values to the default settings. */
! 2862: void
! 2863: ripng_reset ()
! 2864: {
! 2865: /* Call ripd related reset functions. */
! 2866: ripng_debug_reset ();
! 2867: ripng_route_map_reset ();
! 2868:
! 2869: /* Call library reset functions. */
! 2870: vty_reset ();
! 2871: access_list_reset ();
! 2872: prefix_list_reset ();
! 2873:
! 2874: distribute_list_reset ();
! 2875:
! 2876: ripng_interface_reset ();
! 2877:
! 2878: ripng_zclient_reset ();
! 2879: }
! 2880:
! 2881: static void
! 2882: ripng_if_rmap_update (struct if_rmap *if_rmap)
! 2883: {
! 2884: struct interface *ifp;
! 2885: struct ripng_interface *ri;
! 2886: struct route_map *rmap;
! 2887:
! 2888: ifp = if_lookup_by_name (if_rmap->ifname);
! 2889: if (ifp == NULL)
! 2890: return;
! 2891:
! 2892: ri = ifp->info;
! 2893:
! 2894: if (if_rmap->routemap[IF_RMAP_IN])
! 2895: {
! 2896: rmap = route_map_lookup_by_name (if_rmap->routemap[IF_RMAP_IN]);
! 2897: if (rmap)
! 2898: ri->routemap[IF_RMAP_IN] = rmap;
! 2899: else
! 2900: ri->routemap[IF_RMAP_IN] = NULL;
! 2901: }
! 2902: else
! 2903: ri->routemap[RIPNG_FILTER_IN] = NULL;
! 2904:
! 2905: if (if_rmap->routemap[IF_RMAP_OUT])
! 2906: {
! 2907: rmap = route_map_lookup_by_name (if_rmap->routemap[IF_RMAP_OUT]);
! 2908: if (rmap)
! 2909: ri->routemap[IF_RMAP_OUT] = rmap;
! 2910: else
! 2911: ri->routemap[IF_RMAP_OUT] = NULL;
! 2912: }
! 2913: else
! 2914: ri->routemap[RIPNG_FILTER_OUT] = NULL;
! 2915: }
! 2916:
! 2917: void
! 2918: ripng_if_rmap_update_interface (struct interface *ifp)
! 2919: {
! 2920: struct if_rmap *if_rmap;
! 2921:
! 2922: if_rmap = if_rmap_lookup (ifp->name);
! 2923: if (if_rmap)
! 2924: ripng_if_rmap_update (if_rmap);
! 2925: }
! 2926:
! 2927: static void
! 2928: ripng_routemap_update_redistribute (void)
! 2929: {
! 2930: int i;
! 2931:
! 2932: if (ripng)
! 2933: {
! 2934: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
! 2935: {
! 2936: if (ripng->route_map[i].name)
! 2937: ripng->route_map[i].map =
! 2938: route_map_lookup_by_name (ripng->route_map[i].name);
! 2939: }
! 2940: }
! 2941: }
! 2942:
! 2943: static void
! 2944: ripng_routemap_update (const char *unused)
! 2945: {
! 2946: struct interface *ifp;
! 2947: struct listnode *node;
! 2948:
! 2949: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 2950: ripng_if_rmap_update_interface (ifp);
! 2951:
! 2952: ripng_routemap_update_redistribute ();
! 2953: }
! 2954:
! 2955: /* Initialize ripng structure and set commands. */
! 2956: void
! 2957: ripng_init ()
! 2958: {
! 2959: /* Randomize. */
! 2960: srand (time (NULL));
! 2961:
! 2962: /* Install RIPNG_NODE. */
! 2963: install_node (&cmd_ripng_node, ripng_config_write);
! 2964:
! 2965: /* Install ripng commands. */
! 2966: install_element (VIEW_NODE, &show_ipv6_ripng_cmd);
! 2967: install_element (VIEW_NODE, &show_ipv6_ripng_status_cmd);
! 2968:
! 2969: install_element (ENABLE_NODE, &show_ipv6_ripng_cmd);
! 2970: install_element (ENABLE_NODE, &show_ipv6_ripng_status_cmd);
! 2971:
! 2972: install_element (CONFIG_NODE, &router_ripng_cmd);
! 2973: install_element (CONFIG_NODE, &no_router_ripng_cmd);
! 2974:
! 2975: install_default (RIPNG_NODE);
! 2976: install_element (RIPNG_NODE, &ripng_route_cmd);
! 2977: install_element (RIPNG_NODE, &no_ripng_route_cmd);
! 2978: install_element (RIPNG_NODE, &ripng_aggregate_address_cmd);
! 2979: install_element (RIPNG_NODE, &no_ripng_aggregate_address_cmd);
! 2980:
! 2981: install_element (RIPNG_NODE, &ripng_default_metric_cmd);
! 2982: install_element (RIPNG_NODE, &no_ripng_default_metric_cmd);
! 2983: install_element (RIPNG_NODE, &no_ripng_default_metric_val_cmd);
! 2984:
! 2985: install_element (RIPNG_NODE, &ripng_timers_cmd);
! 2986: install_element (RIPNG_NODE, &no_ripng_timers_cmd);
! 2987: install_element (RIPNG_NODE, &no_ripng_timers_val_cmd);
! 2988: #if 0
! 2989: install_element (RIPNG_NODE, &ripng_update_timer_cmd);
! 2990: install_element (RIPNG_NODE, &no_ripng_update_timer_cmd);
! 2991: install_element (RIPNG_NODE, &ripng_timeout_timer_cmd);
! 2992: install_element (RIPNG_NODE, &no_ripng_timeout_timer_cmd);
! 2993: install_element (RIPNG_NODE, &ripng_garbage_timer_cmd);
! 2994: install_element (RIPNG_NODE, &no_ripng_garbage_timer_cmd);
! 2995: #endif /* 0 */
! 2996:
! 2997: install_element (RIPNG_NODE, &ripng_default_information_originate_cmd);
! 2998: install_element (RIPNG_NODE, &no_ripng_default_information_originate_cmd);
! 2999:
! 3000: ripng_if_init ();
! 3001: ripng_debug_init ();
! 3002:
! 3003: /* Access list install. */
! 3004: access_list_init ();
! 3005: access_list_add_hook (ripng_distribute_update_all_wrapper);
! 3006: access_list_delete_hook (ripng_distribute_update_all_wrapper);
! 3007:
! 3008: /* Prefix list initialize.*/
! 3009: prefix_list_init ();
! 3010: prefix_list_add_hook (ripng_distribute_update_all);
! 3011: prefix_list_delete_hook (ripng_distribute_update_all);
! 3012:
! 3013: /* Distribute list install. */
! 3014: distribute_list_init (RIPNG_NODE);
! 3015: distribute_list_add_hook (ripng_distribute_update);
! 3016: distribute_list_delete_hook (ripng_distribute_update);
! 3017:
! 3018: /* Route-map for interface. */
! 3019: ripng_route_map_init ();
! 3020: ripng_offset_init ();
! 3021:
! 3022: route_map_add_hook (ripng_routemap_update);
! 3023: route_map_delete_hook (ripng_routemap_update);
! 3024:
! 3025: if_rmap_init (RIPNG_NODE);
! 3026: if_rmap_hook_add (ripng_if_rmap_update);
! 3027: if_rmap_hook_delete (ripng_if_rmap_update);
! 3028: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ripngd.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 / ripngd