Annotation of embedaddon/quagga/ripd/ripd.c, revision 1.1
1.1 ! misho 1: /* RIP version 1 and 2.
! 2: * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
! 3: * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro <kunihiro@zebra.org>
! 4: *
! 5: * This file is part of GNU Zebra.
! 6: *
! 7: * GNU Zebra is free software; you can redistribute it and/or modify it
! 8: * under the terms of the GNU General Public License as published by the
! 9: * Free Software Foundation; either version 2, or (at your option) any
! 10: * later version.
! 11: *
! 12: * GNU Zebra is distributed in the hope that it will be useful, but
! 13: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 15: * General Public License for more details.
! 16: *
! 17: * You should have received a copy of the GNU General Public License
! 18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 20: * 02111-1307, USA.
! 21: */
! 22:
! 23: #include <zebra.h>
! 24:
! 25: #include "if.h"
! 26: #include "command.h"
! 27: #include "prefix.h"
! 28: #include "table.h"
! 29: #include "thread.h"
! 30: #include "memory.h"
! 31: #include "log.h"
! 32: #include "stream.h"
! 33: #include "filter.h"
! 34: #include "sockunion.h"
! 35: #include "sockopt.h"
! 36: #include "routemap.h"
! 37: #include "if_rmap.h"
! 38: #include "plist.h"
! 39: #include "distribute.h"
! 40: #include "md5.h"
! 41: #include "keychain.h"
! 42: #include "privs.h"
! 43:
! 44: #include "ripd/ripd.h"
! 45: #include "ripd/rip_debug.h"
! 46:
! 47: /* UDP receive buffer size */
! 48: #define RIP_UDP_RCV_BUF 41600
! 49:
! 50: /* privileges global */
! 51: extern struct zebra_privs_t ripd_privs;
! 52:
! 53: /* RIP Structure. */
! 54: struct rip *rip = NULL;
! 55:
! 56: /* RIP neighbor address table. */
! 57: struct route_table *rip_neighbor_table;
! 58:
! 59: /* RIP route changes. */
! 60: long rip_global_route_changes = 0;
! 61:
! 62: /* RIP queries. */
! 63: long rip_global_queries = 0;
! 64:
! 65: /* Prototypes. */
! 66: static void rip_event (enum rip_event, int);
! 67: static void rip_output_process (struct connected *, struct sockaddr_in *, int, u_char);
! 68: static int rip_triggered_update (struct thread *);
! 69: static int rip_update_jitter (unsigned long);
! 70:
! 71: /* RIP output routes type. */
! 72: enum
! 73: {
! 74: rip_all_route,
! 75: rip_changed_route
! 76: };
! 77:
! 78: /* RIP command strings. */
! 79: static const struct message rip_msg[] =
! 80: {
! 81: {RIP_REQUEST, "REQUEST"},
! 82: {RIP_RESPONSE, "RESPONSE"},
! 83: {RIP_TRACEON, "TRACEON"},
! 84: {RIP_TRACEOFF, "TRACEOFF"},
! 85: {RIP_POLL, "POLL"},
! 86: {RIP_POLL_ENTRY, "POLL ENTRY"},
! 87: {0, NULL},
! 88: };
! 89:
! 90: /* Utility function to set boradcast option to the socket. */
! 91: static int
! 92: sockopt_broadcast (int sock)
! 93: {
! 94: int ret;
! 95: int on = 1;
! 96:
! 97: ret = setsockopt (sock, SOL_SOCKET, SO_BROADCAST, (char *) &on, sizeof on);
! 98: if (ret < 0)
! 99: {
! 100: zlog_warn ("can't set sockopt SO_BROADCAST to socket %d", sock);
! 101: return -1;
! 102: }
! 103: return 0;
! 104: }
! 105:
! 106: static int
! 107: rip_route_rte (struct rip_info *rinfo)
! 108: {
! 109: return (rinfo->type == ZEBRA_ROUTE_RIP && rinfo->sub_type == RIP_ROUTE_RTE);
! 110: }
! 111:
! 112: static struct rip_info *
! 113: rip_info_new (void)
! 114: {
! 115: return XCALLOC (MTYPE_RIP_INFO, sizeof (struct rip_info));
! 116: }
! 117:
! 118: void
! 119: rip_info_free (struct rip_info *rinfo)
! 120: {
! 121: XFREE (MTYPE_RIP_INFO, rinfo);
! 122: }
! 123:
! 124: /* RIP route garbage collect timer. */
! 125: static int
! 126: rip_garbage_collect (struct thread *t)
! 127: {
! 128: struct rip_info *rinfo;
! 129: struct route_node *rp;
! 130:
! 131: rinfo = THREAD_ARG (t);
! 132: rinfo->t_garbage_collect = NULL;
! 133:
! 134: /* Off timeout timer. */
! 135: RIP_TIMER_OFF (rinfo->t_timeout);
! 136:
! 137: /* Get route_node pointer. */
! 138: rp = rinfo->rp;
! 139:
! 140: /* Unlock route_node. */
! 141: rp->info = NULL;
! 142: route_unlock_node (rp);
! 143:
! 144: /* Free RIP routing information. */
! 145: rip_info_free (rinfo);
! 146:
! 147: return 0;
! 148: }
! 149:
! 150: /* Timeout RIP routes. */
! 151: static int
! 152: rip_timeout (struct thread *t)
! 153: {
! 154: struct rip_info *rinfo;
! 155: struct route_node *rn;
! 156:
! 157: rinfo = THREAD_ARG (t);
! 158: rinfo->t_timeout = NULL;
! 159:
! 160: rn = rinfo->rp;
! 161:
! 162: /* - The garbage-collection timer is set for 120 seconds. */
! 163: RIP_TIMER_ON (rinfo->t_garbage_collect, rip_garbage_collect,
! 164: rip->garbage_time);
! 165:
! 166: rip_zebra_ipv4_delete ((struct prefix_ipv4 *)&rn->p, &rinfo->nexthop,
! 167: rinfo->metric);
! 168: /* - The metric for the route is set to 16 (infinity). This causes
! 169: the route to be removed from service. */
! 170: rinfo->metric = RIP_METRIC_INFINITY;
! 171: rinfo->flags &= ~RIP_RTF_FIB;
! 172:
! 173: /* - The route change flag is to indicate that this entry has been
! 174: changed. */
! 175: rinfo->flags |= RIP_RTF_CHANGED;
! 176:
! 177: /* - The output process is signalled to trigger a response. */
! 178: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 179:
! 180: return 0;
! 181: }
! 182:
! 183: static void
! 184: rip_timeout_update (struct rip_info *rinfo)
! 185: {
! 186: if (rinfo->metric != RIP_METRIC_INFINITY)
! 187: {
! 188: RIP_TIMER_OFF (rinfo->t_timeout);
! 189: RIP_TIMER_ON (rinfo->t_timeout, rip_timeout, rip->timeout_time);
! 190: }
! 191: }
! 192:
! 193: static int
! 194: rip_incoming_filter (struct prefix_ipv4 *p, struct rip_interface *ri)
! 195: {
! 196: struct distribute *dist;
! 197: struct access_list *alist;
! 198: struct prefix_list *plist;
! 199:
! 200: /* Input distribute-list filtering. */
! 201: if (ri->list[RIP_FILTER_IN])
! 202: {
! 203: if (access_list_apply (ri->list[RIP_FILTER_IN],
! 204: (struct prefix *) p) == FILTER_DENY)
! 205: {
! 206: if (IS_RIP_DEBUG_PACKET)
! 207: zlog_debug ("%s/%d filtered by distribute in",
! 208: inet_ntoa (p->prefix), p->prefixlen);
! 209: return -1;
! 210: }
! 211: }
! 212: if (ri->prefix[RIP_FILTER_IN])
! 213: {
! 214: if (prefix_list_apply (ri->prefix[RIP_FILTER_IN],
! 215: (struct prefix *) p) == PREFIX_DENY)
! 216: {
! 217: if (IS_RIP_DEBUG_PACKET)
! 218: zlog_debug ("%s/%d filtered by prefix-list in",
! 219: inet_ntoa (p->prefix), p->prefixlen);
! 220: return -1;
! 221: }
! 222: }
! 223:
! 224: /* All interface filter check. */
! 225: dist = distribute_lookup (NULL);
! 226: if (dist)
! 227: {
! 228: if (dist->list[DISTRIBUTE_IN])
! 229: {
! 230: alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_IN]);
! 231:
! 232: if (alist)
! 233: {
! 234: if (access_list_apply (alist,
! 235: (struct prefix *) p) == FILTER_DENY)
! 236: {
! 237: if (IS_RIP_DEBUG_PACKET)
! 238: zlog_debug ("%s/%d filtered by distribute in",
! 239: inet_ntoa (p->prefix), p->prefixlen);
! 240: return -1;
! 241: }
! 242: }
! 243: }
! 244: if (dist->prefix[DISTRIBUTE_IN])
! 245: {
! 246: plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_IN]);
! 247:
! 248: if (plist)
! 249: {
! 250: if (prefix_list_apply (plist,
! 251: (struct prefix *) p) == PREFIX_DENY)
! 252: {
! 253: if (IS_RIP_DEBUG_PACKET)
! 254: zlog_debug ("%s/%d filtered by prefix-list in",
! 255: inet_ntoa (p->prefix), p->prefixlen);
! 256: return -1;
! 257: }
! 258: }
! 259: }
! 260: }
! 261: return 0;
! 262: }
! 263:
! 264: static int
! 265: rip_outgoing_filter (struct prefix_ipv4 *p, struct rip_interface *ri)
! 266: {
! 267: struct distribute *dist;
! 268: struct access_list *alist;
! 269: struct prefix_list *plist;
! 270:
! 271: if (ri->list[RIP_FILTER_OUT])
! 272: {
! 273: if (access_list_apply (ri->list[RIP_FILTER_OUT],
! 274: (struct prefix *) p) == FILTER_DENY)
! 275: {
! 276: if (IS_RIP_DEBUG_PACKET)
! 277: zlog_debug ("%s/%d is filtered by distribute out",
! 278: inet_ntoa (p->prefix), p->prefixlen);
! 279: return -1;
! 280: }
! 281: }
! 282: if (ri->prefix[RIP_FILTER_OUT])
! 283: {
! 284: if (prefix_list_apply (ri->prefix[RIP_FILTER_OUT],
! 285: (struct prefix *) p) == PREFIX_DENY)
! 286: {
! 287: if (IS_RIP_DEBUG_PACKET)
! 288: zlog_debug ("%s/%d is filtered by prefix-list out",
! 289: inet_ntoa (p->prefix), p->prefixlen);
! 290: return -1;
! 291: }
! 292: }
! 293:
! 294: /* All interface filter check. */
! 295: dist = distribute_lookup (NULL);
! 296: if (dist)
! 297: {
! 298: if (dist->list[DISTRIBUTE_OUT])
! 299: {
! 300: alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_OUT]);
! 301:
! 302: if (alist)
! 303: {
! 304: if (access_list_apply (alist,
! 305: (struct prefix *) p) == FILTER_DENY)
! 306: {
! 307: if (IS_RIP_DEBUG_PACKET)
! 308: zlog_debug ("%s/%d filtered by distribute out",
! 309: inet_ntoa (p->prefix), p->prefixlen);
! 310: return -1;
! 311: }
! 312: }
! 313: }
! 314: if (dist->prefix[DISTRIBUTE_OUT])
! 315: {
! 316: plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_OUT]);
! 317:
! 318: if (plist)
! 319: {
! 320: if (prefix_list_apply (plist,
! 321: (struct prefix *) p) == PREFIX_DENY)
! 322: {
! 323: if (IS_RIP_DEBUG_PACKET)
! 324: zlog_debug ("%s/%d filtered by prefix-list out",
! 325: inet_ntoa (p->prefix), p->prefixlen);
! 326: return -1;
! 327: }
! 328: }
! 329: }
! 330: }
! 331: return 0;
! 332: }
! 333:
! 334: /* Check nexthop address validity. */
! 335: static int
! 336: rip_nexthop_check (struct in_addr *addr)
! 337: {
! 338: struct listnode *node;
! 339: struct listnode *cnode;
! 340: struct interface *ifp;
! 341: struct connected *ifc;
! 342: struct prefix *p;
! 343:
! 344: /* If nexthop address matches local configured address then it is
! 345: invalid nexthop. */
! 346: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 347: {
! 348: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, ifc))
! 349: {
! 350: p = ifc->address;
! 351:
! 352: if (p->family == AF_INET
! 353: && IPV4_ADDR_SAME (&p->u.prefix4, addr))
! 354: return -1;
! 355: }
! 356: }
! 357: return 0;
! 358: }
! 359:
! 360: /* RIP add route to routing table. */
! 361: static void
! 362: rip_rte_process (struct rte *rte, struct sockaddr_in *from,
! 363: struct interface *ifp)
! 364: {
! 365: int ret;
! 366: struct prefix_ipv4 p;
! 367: struct route_node *rp;
! 368: struct rip_info *rinfo, rinfotmp;
! 369: struct rip_interface *ri;
! 370: struct in_addr *nexthop;
! 371: u_char oldmetric;
! 372: int same = 0;
! 373: int route_reuse = 0;
! 374: unsigned char old_dist, new_dist;
! 375:
! 376: /* Make prefix structure. */
! 377: memset (&p, 0, sizeof (struct prefix_ipv4));
! 378: p.family = AF_INET;
! 379: p.prefix = rte->prefix;
! 380: p.prefixlen = ip_masklen (rte->mask);
! 381:
! 382: /* Make sure mask is applied. */
! 383: apply_mask_ipv4 (&p);
! 384:
! 385: /* Apply input filters. */
! 386: ri = ifp->info;
! 387:
! 388: ret = rip_incoming_filter (&p, ri);
! 389: if (ret < 0)
! 390: return;
! 391:
! 392: /* Modify entry according to the interface routemap. */
! 393: if (ri->routemap[RIP_FILTER_IN])
! 394: {
! 395: int ret;
! 396: struct rip_info newinfo;
! 397:
! 398: memset (&newinfo, 0, sizeof (newinfo));
! 399: newinfo.type = ZEBRA_ROUTE_RIP;
! 400: newinfo.sub_type = RIP_ROUTE_RTE;
! 401: newinfo.nexthop = rte->nexthop;
! 402: newinfo.from = from->sin_addr;
! 403: newinfo.ifindex = ifp->ifindex;
! 404: newinfo.metric = rte->metric;
! 405: newinfo.metric_out = rte->metric; /* XXX */
! 406: newinfo.tag = ntohs (rte->tag); /* XXX */
! 407:
! 408: /* The object should be of the type of rip_info */
! 409: ret = route_map_apply (ri->routemap[RIP_FILTER_IN],
! 410: (struct prefix *) &p, RMAP_RIP, &newinfo);
! 411:
! 412: if (ret == RMAP_DENYMATCH)
! 413: {
! 414: if (IS_RIP_DEBUG_PACKET)
! 415: zlog_debug ("RIP %s/%d is filtered by route-map in",
! 416: inet_ntoa (p.prefix), p.prefixlen);
! 417: return;
! 418: }
! 419:
! 420: /* Get back the object */
! 421: rte->nexthop = newinfo.nexthop_out;
! 422: rte->tag = htons (newinfo.tag_out); /* XXX */
! 423: rte->metric = newinfo.metric_out; /* XXX: the routemap uses the metric_out field */
! 424: }
! 425:
! 426: /* Once the entry has been validated, update the metric by
! 427: adding the cost of the network on wich the message
! 428: arrived. If the result is greater than infinity, use infinity
! 429: (RFC2453 Sec. 3.9.2) */
! 430: /* Zebra ripd can handle offset-list in. */
! 431: ret = rip_offset_list_apply_in (&p, ifp, &rte->metric);
! 432:
! 433: /* If offset-list does not modify the metric use interface's
! 434: metric. */
! 435: if (!ret)
! 436: rte->metric += ifp->metric;
! 437:
! 438: if (rte->metric > RIP_METRIC_INFINITY)
! 439: rte->metric = RIP_METRIC_INFINITY;
! 440:
! 441: /* Set nexthop pointer. */
! 442: if (rte->nexthop.s_addr == 0)
! 443: nexthop = &from->sin_addr;
! 444: else
! 445: nexthop = &rte->nexthop;
! 446:
! 447: /* Check if nexthop address is myself, then do nothing. */
! 448: if (rip_nexthop_check (nexthop) < 0)
! 449: {
! 450: if (IS_RIP_DEBUG_PACKET)
! 451: zlog_debug ("Nexthop address %s is myself", inet_ntoa (*nexthop));
! 452: return;
! 453: }
! 454:
! 455: /* Get index for the prefix. */
! 456: rp = route_node_get (rip->table, (struct prefix *) &p);
! 457:
! 458: /* Check to see whether there is already RIP route on the table. */
! 459: rinfo = rp->info;
! 460:
! 461: if (rinfo)
! 462: {
! 463: /* Local static route. */
! 464: if (rinfo->type == ZEBRA_ROUTE_RIP
! 465: && ((rinfo->sub_type == RIP_ROUTE_STATIC) ||
! 466: (rinfo->sub_type == RIP_ROUTE_DEFAULT))
! 467: && rinfo->metric != RIP_METRIC_INFINITY)
! 468: {
! 469: route_unlock_node (rp);
! 470: return;
! 471: }
! 472:
! 473: /* Redistributed route check. */
! 474: if (rinfo->type != ZEBRA_ROUTE_RIP
! 475: && rinfo->metric != RIP_METRIC_INFINITY)
! 476: {
! 477: /* Fill in a minimaly temporary rip_info structure, for a future
! 478: rip_distance_apply() use) */
! 479: memset (&rinfotmp, 0, sizeof (rinfotmp));
! 480: IPV4_ADDR_COPY (&rinfotmp.from, &from->sin_addr);
! 481: rinfotmp.rp = rinfo->rp;
! 482: new_dist = rip_distance_apply (&rinfotmp);
! 483: new_dist = new_dist ? new_dist : ZEBRA_RIP_DISTANCE_DEFAULT;
! 484: old_dist = rinfo->distance;
! 485: /* Only connected routes may have a valid NULL distance */
! 486: if (rinfo->type != ZEBRA_ROUTE_CONNECT)
! 487: old_dist = old_dist ? old_dist : ZEBRA_RIP_DISTANCE_DEFAULT;
! 488: /* If imported route does not have STRICT precedence,
! 489: mark it as a ghost */
! 490: if (new_dist > old_dist
! 491: || rte->metric == RIP_METRIC_INFINITY)
! 492: {
! 493: route_unlock_node (rp);
! 494: return;
! 495: }
! 496: else
! 497: {
! 498: RIP_TIMER_OFF (rinfo->t_timeout);
! 499: RIP_TIMER_OFF (rinfo->t_garbage_collect);
! 500:
! 501: rp->info = NULL;
! 502: if (rip_route_rte (rinfo))
! 503: rip_zebra_ipv4_delete ((struct prefix_ipv4 *)&rp->p,
! 504: &rinfo->nexthop, rinfo->metric);
! 505: rip_info_free (rinfo);
! 506: rinfo = NULL;
! 507: route_reuse = 1;
! 508: }
! 509: }
! 510: }
! 511:
! 512: if (!rinfo)
! 513: {
! 514: /* Now, check to see whether there is already an explicit route
! 515: for the destination prefix. If there is no such route, add
! 516: this route to the routing table, unless the metric is
! 517: infinity (there is no point in adding a route which
! 518: unusable). */
! 519: if (rte->metric != RIP_METRIC_INFINITY)
! 520: {
! 521: rinfo = rip_info_new ();
! 522:
! 523: /* - Setting the destination prefix and length to those in
! 524: the RTE. */
! 525: rinfo->rp = rp;
! 526:
! 527: /* - Setting the metric to the newly calculated metric (as
! 528: described above). */
! 529: rinfo->metric = rte->metric;
! 530: rinfo->tag = ntohs (rte->tag);
! 531:
! 532: /* - Set the next hop address to be the address of the router
! 533: from which the datagram came or the next hop address
! 534: specified by a next hop RTE. */
! 535: IPV4_ADDR_COPY (&rinfo->nexthop, nexthop);
! 536: IPV4_ADDR_COPY (&rinfo->from, &from->sin_addr);
! 537: rinfo->ifindex = ifp->ifindex;
! 538:
! 539: /* - Initialize the timeout for the route. If the
! 540: garbage-collection timer is running for this route, stop it
! 541: (see section 2.3 for a discussion of the timers). */
! 542: rip_timeout_update (rinfo);
! 543:
! 544: /* - Set the route change flag. */
! 545: rinfo->flags |= RIP_RTF_CHANGED;
! 546:
! 547: /* - Signal the output process to trigger an update (see section
! 548: 2.5). */
! 549: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 550:
! 551: /* Finally, route goes into the kernel. */
! 552: rinfo->type = ZEBRA_ROUTE_RIP;
! 553: rinfo->sub_type = RIP_ROUTE_RTE;
! 554:
! 555: /* Set distance value. */
! 556: rinfo->distance = rip_distance_apply (rinfo);
! 557:
! 558: rp->info = rinfo;
! 559: rip_zebra_ipv4_add (&p, &rinfo->nexthop, rinfo->metric,
! 560: rinfo->distance);
! 561: rinfo->flags |= RIP_RTF_FIB;
! 562: }
! 563:
! 564: /* Unlock temporary lock, i.e. same behaviour */
! 565: if (route_reuse)
! 566: route_unlock_node (rp);
! 567: }
! 568: else
! 569: {
! 570: /* Route is there but we are not sure the route is RIP or not. */
! 571: rinfo = rp->info;
! 572:
! 573: /* If there is an existing route, compare the next hop address
! 574: to the address of the router from which the datagram came.
! 575: If this datagram is from the same router as the existing
! 576: route, reinitialize the timeout. */
! 577: same = (IPV4_ADDR_SAME (&rinfo->from, &from->sin_addr)
! 578: && (rinfo->ifindex == ifp->ifindex));
! 579:
! 580: if (same)
! 581: rip_timeout_update (rinfo);
! 582:
! 583:
! 584: /* Fill in a minimaly temporary rip_info structure, for a future
! 585: rip_distance_apply() use) */
! 586: memset (&rinfotmp, 0, sizeof (rinfotmp));
! 587: IPV4_ADDR_COPY (&rinfotmp.from, &from->sin_addr);
! 588: rinfotmp.rp = rinfo->rp;
! 589:
! 590:
! 591: /* Next, compare the metrics. If the datagram is from the same
! 592: router as the existing route, and the new metric is different
! 593: than the old one; or, if the new metric is lower than the old
! 594: one, or if the tag has been changed; or if there is a route
! 595: with a lower administrave distance; or an update of the
! 596: distance on the actual route; do the following actions: */
! 597: if ((same && rinfo->metric != rte->metric)
! 598: || (rte->metric < rinfo->metric)
! 599: || ((same)
! 600: && (rinfo->metric == rte->metric)
! 601: && ntohs (rte->tag) != rinfo->tag)
! 602: || (rinfo->distance > rip_distance_apply (&rinfotmp))
! 603: || ((rinfo->distance != rip_distance_apply (rinfo)) && same))
! 604: {
! 605: /* - Adopt the route from the datagram. That is, put the
! 606: new metric in, and adjust the next hop address (if
! 607: necessary). */
! 608: oldmetric = rinfo->metric;
! 609: rinfo->metric = rte->metric;
! 610: rinfo->tag = ntohs (rte->tag);
! 611: IPV4_ADDR_COPY (&rinfo->from, &from->sin_addr);
! 612: rinfo->ifindex = ifp->ifindex;
! 613: rinfo->distance = rip_distance_apply (rinfo);
! 614:
! 615: /* Should a new route to this network be established
! 616: while the garbage-collection timer is running, the
! 617: new route will replace the one that is about to be
! 618: deleted. In this case the garbage-collection timer
! 619: must be cleared. */
! 620:
! 621: if (oldmetric == RIP_METRIC_INFINITY &&
! 622: rinfo->metric < RIP_METRIC_INFINITY)
! 623: {
! 624: rinfo->type = ZEBRA_ROUTE_RIP;
! 625: rinfo->sub_type = RIP_ROUTE_RTE;
! 626:
! 627: RIP_TIMER_OFF (rinfo->t_garbage_collect);
! 628:
! 629: if (!IPV4_ADDR_SAME (&rinfo->nexthop, nexthop))
! 630: IPV4_ADDR_COPY (&rinfo->nexthop, nexthop);
! 631:
! 632: rip_zebra_ipv4_add (&p, nexthop, rinfo->metric,
! 633: rinfo->distance);
! 634: rinfo->flags |= RIP_RTF_FIB;
! 635: }
! 636:
! 637: /* Update nexthop and/or metric value. */
! 638: if (oldmetric != RIP_METRIC_INFINITY)
! 639: {
! 640: rip_zebra_ipv4_delete (&p, &rinfo->nexthop, oldmetric);
! 641: rip_zebra_ipv4_add (&p, nexthop, rinfo->metric,
! 642: rinfo->distance);
! 643: rinfo->flags |= RIP_RTF_FIB;
! 644:
! 645: if (!IPV4_ADDR_SAME (&rinfo->nexthop, nexthop))
! 646: IPV4_ADDR_COPY (&rinfo->nexthop, nexthop);
! 647: }
! 648:
! 649: /* - Set the route change flag and signal the output process
! 650: to trigger an update. */
! 651: rinfo->flags |= RIP_RTF_CHANGED;
! 652: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 653:
! 654: /* - If the new metric is infinity, start the deletion
! 655: process (described above); */
! 656: if (rinfo->metric == RIP_METRIC_INFINITY)
! 657: {
! 658: /* If the new metric is infinity, the deletion process
! 659: begins for the route, which is no longer used for
! 660: routing packets. Note that the deletion process is
! 661: started only when the metric is first set to
! 662: infinity. If the metric was already infinity, then a
! 663: new deletion process is not started. */
! 664: if (oldmetric != RIP_METRIC_INFINITY)
! 665: {
! 666: /* - The garbage-collection timer is set for 120 seconds. */
! 667: RIP_TIMER_ON (rinfo->t_garbage_collect,
! 668: rip_garbage_collect, rip->garbage_time);
! 669: RIP_TIMER_OFF (rinfo->t_timeout);
! 670:
! 671: /* - The metric for the route is set to 16
! 672: (infinity). This causes the route to be removed
! 673: from service. */
! 674: rip_zebra_ipv4_delete (&p, &rinfo->nexthop, oldmetric);
! 675: rinfo->flags &= ~RIP_RTF_FIB;
! 676:
! 677: /* - The route change flag is to indicate that this
! 678: entry has been changed. */
! 679: /* - The output process is signalled to trigger a
! 680: response. */
! 681: ; /* Above processes are already done previously. */
! 682: }
! 683: }
! 684: else
! 685: {
! 686: /* otherwise, re-initialize the timeout. */
! 687: rip_timeout_update (rinfo);
! 688: }
! 689: }
! 690: /* Unlock tempolary lock of the route. */
! 691: route_unlock_node (rp);
! 692: }
! 693: }
! 694:
! 695: /* Dump RIP packet */
! 696: static void
! 697: rip_packet_dump (struct rip_packet *packet, int size, const char *sndrcv)
! 698: {
! 699: caddr_t lim;
! 700: struct rte *rte;
! 701: const char *command_str;
! 702: char pbuf[BUFSIZ], nbuf[BUFSIZ];
! 703: u_char netmask = 0;
! 704: u_char *p;
! 705:
! 706: /* Set command string. */
! 707: if (packet->command > 0 && packet->command < RIP_COMMAND_MAX)
! 708: command_str = lookup (rip_msg, packet->command);
! 709: else
! 710: command_str = "unknown";
! 711:
! 712: /* Dump packet header. */
! 713: zlog_debug ("%s %s version %d packet size %d",
! 714: sndrcv, command_str, packet->version, size);
! 715:
! 716: /* Dump each routing table entry. */
! 717: rte = packet->rte;
! 718:
! 719: for (lim = (caddr_t) packet + size; (caddr_t) rte < lim; rte++)
! 720: {
! 721: if (packet->version == RIPv2)
! 722: {
! 723: netmask = ip_masklen (rte->mask);
! 724:
! 725: if (rte->family == htons (RIP_FAMILY_AUTH))
! 726: {
! 727: if (rte->tag == htons (RIP_AUTH_SIMPLE_PASSWORD))
! 728: {
! 729: p = (u_char *)&rte->prefix;
! 730:
! 731: zlog_debug (" family 0x%X type %d auth string: %s",
! 732: ntohs (rte->family), ntohs (rte->tag), p);
! 733: }
! 734: else if (rte->tag == htons (RIP_AUTH_MD5))
! 735: {
! 736: struct rip_md5_info *md5;
! 737:
! 738: md5 = (struct rip_md5_info *) &packet->rte;
! 739:
! 740: zlog_debug (" family 0x%X type %d (MD5 authentication)",
! 741: ntohs (md5->family), ntohs (md5->type));
! 742: zlog_debug (" RIP-2 packet len %d Key ID %d"
! 743: " Auth Data len %d",
! 744: ntohs (md5->packet_len), md5->keyid,
! 745: md5->auth_len);
! 746: zlog_debug (" Sequence Number %ld",
! 747: (u_long) ntohl (md5->sequence));
! 748: }
! 749: else if (rte->tag == htons (RIP_AUTH_DATA))
! 750: {
! 751: p = (u_char *)&rte->prefix;
! 752:
! 753: zlog_debug (" family 0x%X type %d (MD5 data)",
! 754: ntohs (rte->family), ntohs (rte->tag));
! 755: zlog_debug (" MD5: %02X%02X%02X%02X%02X%02X%02X%02X"
! 756: "%02X%02X%02X%02X%02X%02X%02X",
! 757: p[0], p[1], p[2], p[3], p[4], p[5], p[6],
! 758: p[7], p[9], p[10], p[11], p[12], p[13],
! 759: p[14], p[15]);
! 760: }
! 761: else
! 762: {
! 763: zlog_debug (" family 0x%X type %d (Unknown auth type)",
! 764: ntohs (rte->family), ntohs (rte->tag));
! 765: }
! 766: }
! 767: else
! 768: zlog_debug (" %s/%d -> %s family %d tag %d metric %ld",
! 769: inet_ntop (AF_INET, &rte->prefix, pbuf, BUFSIZ),
! 770: netmask, inet_ntop (AF_INET, &rte->nexthop, nbuf,
! 771: BUFSIZ), ntohs (rte->family),
! 772: ntohs (rte->tag), (u_long) ntohl (rte->metric));
! 773: }
! 774: else
! 775: {
! 776: zlog_debug (" %s family %d tag %d metric %ld",
! 777: inet_ntop (AF_INET, &rte->prefix, pbuf, BUFSIZ),
! 778: ntohs (rte->family), ntohs (rte->tag),
! 779: (u_long)ntohl (rte->metric));
! 780: }
! 781: }
! 782: }
! 783:
! 784: /* Check if the destination address is valid (unicast; not net 0
! 785: or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
! 786: check net 0 because we accept default route. */
! 787: static int
! 788: rip_destination_check (struct in_addr addr)
! 789: {
! 790: u_int32_t destination;
! 791:
! 792: /* Convert to host byte order. */
! 793: destination = ntohl (addr.s_addr);
! 794:
! 795: if (IPV4_NET127 (destination))
! 796: return 0;
! 797:
! 798: /* Net 0 may match to the default route. */
! 799: if (IPV4_NET0 (destination) && destination != 0)
! 800: return 0;
! 801:
! 802: /* Unicast address must belong to class A, B, C. */
! 803: if (IN_CLASSA (destination))
! 804: return 1;
! 805: if (IN_CLASSB (destination))
! 806: return 1;
! 807: if (IN_CLASSC (destination))
! 808: return 1;
! 809:
! 810: return 0;
! 811: }
! 812:
! 813: /* RIP version 2 authentication. */
! 814: static int
! 815: rip_auth_simple_password (struct rte *rte, struct sockaddr_in *from,
! 816: struct interface *ifp)
! 817: {
! 818: struct rip_interface *ri;
! 819: char *auth_str;
! 820:
! 821: if (IS_RIP_DEBUG_EVENT)
! 822: zlog_debug ("RIPv2 simple password authentication from %s",
! 823: inet_ntoa (from->sin_addr));
! 824:
! 825: ri = ifp->info;
! 826:
! 827: if (ri->auth_type != RIP_AUTH_SIMPLE_PASSWORD
! 828: || rte->tag != htons(RIP_AUTH_SIMPLE_PASSWORD))
! 829: return 0;
! 830:
! 831: /* Simple password authentication. */
! 832: if (ri->auth_str)
! 833: {
! 834: auth_str = (char *) &rte->prefix;
! 835:
! 836: if (strncmp (auth_str, ri->auth_str, 16) == 0)
! 837: return 1;
! 838: }
! 839: if (ri->key_chain)
! 840: {
! 841: struct keychain *keychain;
! 842: struct key *key;
! 843:
! 844: keychain = keychain_lookup (ri->key_chain);
! 845: if (keychain == NULL)
! 846: return 0;
! 847:
! 848: key = key_match_for_accept (keychain, (char *) &rte->prefix);
! 849: if (key)
! 850: return 1;
! 851: }
! 852: return 0;
! 853: }
! 854:
! 855: /* RIP version 2 authentication with MD5. */
! 856: static int
! 857: rip_auth_md5 (struct rip_packet *packet, struct sockaddr_in *from,
! 858: int length, struct interface *ifp)
! 859: {
! 860: struct rip_interface *ri;
! 861: struct rip_md5_info *md5;
! 862: struct rip_md5_data *md5data;
! 863: struct keychain *keychain;
! 864: struct key *key;
! 865: MD5_CTX ctx;
! 866: u_char digest[RIP_AUTH_MD5_SIZE];
! 867: u_int16_t packet_len;
! 868: char auth_str[RIP_AUTH_MD5_SIZE];
! 869:
! 870: if (IS_RIP_DEBUG_EVENT)
! 871: zlog_debug ("RIPv2 MD5 authentication from %s",
! 872: inet_ntoa (from->sin_addr));
! 873:
! 874: ri = ifp->info;
! 875: md5 = (struct rip_md5_info *) &packet->rte;
! 876:
! 877: /* Check auth type. */
! 878: if (ri->auth_type != RIP_AUTH_MD5 || md5->type != htons(RIP_AUTH_MD5))
! 879: return 0;
! 880:
! 881: /* If the authentication length is less than 16, then it must be wrong for
! 882: * any interpretation of rfc2082. Some implementations also interpret
! 883: * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka RIP_AUTH_MD5_COMPAT_SIZE.
! 884: */
! 885: if ( !((md5->auth_len == RIP_AUTH_MD5_SIZE)
! 886: || (md5->auth_len == RIP_AUTH_MD5_COMPAT_SIZE)))
! 887: {
! 888: if (IS_RIP_DEBUG_EVENT)
! 889: zlog_debug ("RIPv2 MD5 authentication, strange authentication "
! 890: "length field %d", md5->auth_len);
! 891: return 0;
! 892: }
! 893:
! 894: /* grab and verify check packet length */
! 895: packet_len = ntohs (md5->packet_len);
! 896:
! 897: if (packet_len > (length - RIP_HEADER_SIZE - RIP_AUTH_MD5_SIZE))
! 898: {
! 899: if (IS_RIP_DEBUG_EVENT)
! 900: zlog_debug ("RIPv2 MD5 authentication, packet length field %d "
! 901: "greater than received length %d!",
! 902: md5->packet_len, length);
! 903: return 0;
! 904: }
! 905:
! 906: /* retrieve authentication data */
! 907: md5data = (struct rip_md5_data *) (((u_char *) packet) + packet_len);
! 908:
! 909: memset (auth_str, 0, RIP_AUTH_MD5_SIZE);
! 910:
! 911: if (ri->key_chain)
! 912: {
! 913: keychain = keychain_lookup (ri->key_chain);
! 914: if (keychain == NULL)
! 915: return 0;
! 916:
! 917: key = key_lookup_for_accept (keychain, md5->keyid);
! 918: if (key == NULL)
! 919: return 0;
! 920:
! 921: strncpy (auth_str, key->string, RIP_AUTH_MD5_SIZE);
! 922: }
! 923: else if (ri->auth_str)
! 924: strncpy (auth_str, ri->auth_str, RIP_AUTH_MD5_SIZE);
! 925:
! 926: if (auth_str[0] == 0)
! 927: return 0;
! 928:
! 929: /* MD5 digest authentication. */
! 930: memset (&ctx, 0, sizeof(ctx));
! 931: MD5Init(&ctx);
! 932: MD5Update(&ctx, packet, packet_len + RIP_HEADER_SIZE);
! 933: MD5Update(&ctx, auth_str, RIP_AUTH_MD5_SIZE);
! 934: MD5Final(digest, &ctx);
! 935:
! 936: if (memcmp (md5data->digest, digest, RIP_AUTH_MD5_SIZE) == 0)
! 937: return packet_len;
! 938: else
! 939: return 0;
! 940: }
! 941:
! 942: /* Pick correct auth string for sends, prepare auth_str buffer for use.
! 943: * (left justified and padded).
! 944: *
! 945: * presumes one of ri or key is valid, and that the auth strings they point
! 946: * to are nul terminated. If neither are present, auth_str will be fully
! 947: * zero padded.
! 948: *
! 949: */
! 950: static void
! 951: rip_auth_prepare_str_send (struct rip_interface *ri, struct key *key,
! 952: char *auth_str, int len)
! 953: {
! 954: assert (ri || key);
! 955:
! 956: memset (auth_str, 0, len);
! 957: if (key && key->string)
! 958: strncpy (auth_str, key->string, len);
! 959: else if (ri->auth_str)
! 960: strncpy (auth_str, ri->auth_str, len);
! 961:
! 962: return;
! 963: }
! 964:
! 965: /* Write RIPv2 simple password authentication information
! 966: *
! 967: * auth_str is presumed to be 2 bytes and correctly prepared
! 968: * (left justified and zero padded).
! 969: */
! 970: static void
! 971: rip_auth_simple_write (struct stream *s, char *auth_str, int len)
! 972: {
! 973: assert (s && len == RIP_AUTH_SIMPLE_SIZE);
! 974:
! 975: stream_putw (s, RIP_FAMILY_AUTH);
! 976: stream_putw (s, RIP_AUTH_SIMPLE_PASSWORD);
! 977: stream_put (s, auth_str, RIP_AUTH_SIMPLE_SIZE);
! 978:
! 979: return;
! 980: }
! 981:
! 982: /* write RIPv2 MD5 "authentication header"
! 983: * (uses the auth key data field)
! 984: *
! 985: * Digest offset field is set to 0.
! 986: *
! 987: * returns: offset of the digest offset field, which must be set when
! 988: * length to the auth-data MD5 digest is known.
! 989: */
! 990: static size_t
! 991: rip_auth_md5_ah_write (struct stream *s, struct rip_interface *ri,
! 992: struct key *key)
! 993: {
! 994: size_t doff = 0;
! 995:
! 996: assert (s && ri && ri->auth_type == RIP_AUTH_MD5);
! 997:
! 998: /* MD5 authentication. */
! 999: stream_putw (s, RIP_FAMILY_AUTH);
! 1000: stream_putw (s, RIP_AUTH_MD5);
! 1001:
! 1002: /* MD5 AH digest offset field.
! 1003: *
! 1004: * Set to placeholder value here, to true value when RIP-2 Packet length
! 1005: * is known. Actual value is set in .....().
! 1006: */
! 1007: doff = stream_get_endp(s);
! 1008: stream_putw (s, 0);
! 1009:
! 1010: /* Key ID. */
! 1011: if (key)
! 1012: stream_putc (s, key->index % 256);
! 1013: else
! 1014: stream_putc (s, 1);
! 1015:
! 1016: /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
! 1017: * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for this
! 1018: * to be configurable.
! 1019: */
! 1020: stream_putc (s, ri->md5_auth_len);
! 1021:
! 1022: /* Sequence Number (non-decreasing). */
! 1023: /* RFC2080: The value used in the sequence number is
! 1024: arbitrary, but two suggestions are the time of the
! 1025: message's creation or a simple message counter. */
! 1026: stream_putl (s, time (NULL));
! 1027:
! 1028: /* Reserved field must be zero. */
! 1029: stream_putl (s, 0);
! 1030: stream_putl (s, 0);
! 1031:
! 1032: return doff;
! 1033: }
! 1034:
! 1035: /* If authentication is in used, write the appropriate header
! 1036: * returns stream offset to which length must later be written
! 1037: * or 0 if this is not required
! 1038: */
! 1039: static size_t
! 1040: rip_auth_header_write (struct stream *s, struct rip_interface *ri,
! 1041: struct key *key, char *auth_str, int len)
! 1042: {
! 1043: assert (ri->auth_type != RIP_NO_AUTH);
! 1044:
! 1045: switch (ri->auth_type)
! 1046: {
! 1047: case RIP_AUTH_SIMPLE_PASSWORD:
! 1048: rip_auth_prepare_str_send (ri, key, auth_str, len);
! 1049: rip_auth_simple_write (s, auth_str, len);
! 1050: return 0;
! 1051: case RIP_AUTH_MD5:
! 1052: return rip_auth_md5_ah_write (s, ri, key);
! 1053: }
! 1054: assert (1);
! 1055: return 0;
! 1056: }
! 1057:
! 1058: /* Write RIPv2 MD5 authentication data trailer */
! 1059: static void
! 1060: rip_auth_md5_set (struct stream *s, struct rip_interface *ri, size_t doff,
! 1061: char *auth_str, int authlen)
! 1062: {
! 1063: unsigned long len;
! 1064: MD5_CTX ctx;
! 1065: unsigned char digest[RIP_AUTH_MD5_SIZE];
! 1066:
! 1067: /* Make it sure this interface is configured as MD5
! 1068: authentication. */
! 1069: assert ((ri->auth_type == RIP_AUTH_MD5) && (authlen == RIP_AUTH_MD5_SIZE));
! 1070: assert (doff > 0);
! 1071:
! 1072: /* Get packet length. */
! 1073: len = stream_get_endp(s);
! 1074:
! 1075: /* Check packet length. */
! 1076: if (len < (RIP_HEADER_SIZE + RIP_RTE_SIZE))
! 1077: {
! 1078: zlog_err ("rip_auth_md5_set(): packet length %ld is less than minimum length.", len);
! 1079: return;
! 1080: }
! 1081:
! 1082: /* Set the digest offset length in the header */
! 1083: stream_putw_at (s, doff, len);
! 1084:
! 1085: /* Set authentication data. */
! 1086: stream_putw (s, RIP_FAMILY_AUTH);
! 1087: stream_putw (s, RIP_AUTH_DATA);
! 1088:
! 1089: /* Generate a digest for the RIP packet. */
! 1090: memset(&ctx, 0, sizeof(ctx));
! 1091: MD5Init(&ctx);
! 1092: MD5Update(&ctx, STREAM_DATA (s), stream_get_endp (s));
! 1093: MD5Update(&ctx, auth_str, RIP_AUTH_MD5_SIZE);
! 1094: MD5Final(digest, &ctx);
! 1095:
! 1096: /* Copy the digest to the packet. */
! 1097: stream_write (s, digest, RIP_AUTH_MD5_SIZE);
! 1098: }
! 1099:
! 1100: /* RIP routing information. */
! 1101: static void
! 1102: rip_response_process (struct rip_packet *packet, int size,
! 1103: struct sockaddr_in *from, struct connected *ifc)
! 1104: {
! 1105: caddr_t lim;
! 1106: struct rte *rte;
! 1107: struct prefix_ipv4 ifaddr;
! 1108: struct prefix_ipv4 ifaddrclass;
! 1109: int subnetted;
! 1110:
! 1111: /* We don't know yet. */
! 1112: subnetted = -1;
! 1113:
! 1114: /* The Response must be ignored if it is not from the RIP
! 1115: port. (RFC2453 - Sec. 3.9.2)*/
! 1116: if (from->sin_port != htons(RIP_PORT_DEFAULT))
! 1117: {
! 1118: zlog_info ("response doesn't come from RIP port: %d",
! 1119: from->sin_port);
! 1120: rip_peer_bad_packet (from);
! 1121: return;
! 1122: }
! 1123:
! 1124: /* The datagram's IPv4 source address should be checked to see
! 1125: whether the datagram is from a valid neighbor; the source of the
! 1126: datagram must be on a directly connected network (RFC2453 - Sec. 3.9.2) */
! 1127: if (if_lookup_address(from->sin_addr) == NULL)
! 1128: {
! 1129: zlog_info ("This datagram doesn't came from a valid neighbor: %s",
! 1130: inet_ntoa (from->sin_addr));
! 1131: rip_peer_bad_packet (from);
! 1132: return;
! 1133: }
! 1134:
! 1135: /* It is also worth checking to see whether the response is from one
! 1136: of the router's own addresses. */
! 1137:
! 1138: ; /* Alredy done in rip_read () */
! 1139:
! 1140: /* Update RIP peer. */
! 1141: rip_peer_update (from, packet->version);
! 1142:
! 1143: /* Set RTE pointer. */
! 1144: rte = packet->rte;
! 1145:
! 1146: for (lim = (caddr_t) packet + size; (caddr_t) rte < lim; rte++)
! 1147: {
! 1148: /* RIPv2 authentication check. */
! 1149: /* If the Address Family Identifier of the first (and only the
! 1150: first) entry in the message is 0xFFFF, then the remainder of
! 1151: the entry contains the authentication. */
! 1152: /* If the packet gets here it means authentication enabled */
! 1153: /* Check is done in rip_read(). So, just skipping it */
! 1154: if (packet->version == RIPv2 &&
! 1155: rte == packet->rte &&
! 1156: rte->family == htons(RIP_FAMILY_AUTH))
! 1157: continue;
! 1158:
! 1159: if (rte->family != htons(AF_INET))
! 1160: {
! 1161: /* Address family check. RIP only supports AF_INET. */
! 1162: zlog_info ("Unsupported family %d from %s.",
! 1163: ntohs (rte->family), inet_ntoa (from->sin_addr));
! 1164: continue;
! 1165: }
! 1166:
! 1167: /* - is the destination address valid (e.g., unicast; not net 0
! 1168: or 127) */
! 1169: if (! rip_destination_check (rte->prefix))
! 1170: {
! 1171: zlog_info ("Network is net 0 or net 127 or it is not unicast network");
! 1172: rip_peer_bad_route (from);
! 1173: continue;
! 1174: }
! 1175:
! 1176: /* Convert metric value to host byte order. */
! 1177: rte->metric = ntohl (rte->metric);
! 1178:
! 1179: /* - is the metric valid (i.e., between 1 and 16, inclusive) */
! 1180: if (! (rte->metric >= 1 && rte->metric <= 16))
! 1181: {
! 1182: zlog_info ("Route's metric is not in the 1-16 range.");
! 1183: rip_peer_bad_route (from);
! 1184: continue;
! 1185: }
! 1186:
! 1187: /* RIPv1 does not have nexthop value. */
! 1188: if (packet->version == RIPv1 && rte->nexthop.s_addr != 0)
! 1189: {
! 1190: zlog_info ("RIPv1 packet with nexthop value %s",
! 1191: inet_ntoa (rte->nexthop));
! 1192: rip_peer_bad_route (from);
! 1193: continue;
! 1194: }
! 1195:
! 1196: /* That is, if the provided information is ignored, a possibly
! 1197: sub-optimal, but absolutely valid, route may be taken. If
! 1198: the received Next Hop is not directly reachable, it should be
! 1199: treated as 0.0.0.0. */
! 1200: if (packet->version == RIPv2 && rte->nexthop.s_addr != 0)
! 1201: {
! 1202: u_int32_t addrval;
! 1203:
! 1204: /* Multicast address check. */
! 1205: addrval = ntohl (rte->nexthop.s_addr);
! 1206: if (IN_CLASSD (addrval))
! 1207: {
! 1208: zlog_info ("Nexthop %s is multicast address, skip this rte",
! 1209: inet_ntoa (rte->nexthop));
! 1210: continue;
! 1211: }
! 1212:
! 1213: if (! if_lookup_address (rte->nexthop))
! 1214: {
! 1215: struct route_node *rn;
! 1216: struct rip_info *rinfo;
! 1217:
! 1218: rn = route_node_match_ipv4 (rip->table, &rte->nexthop);
! 1219:
! 1220: if (rn)
! 1221: {
! 1222: rinfo = rn->info;
! 1223:
! 1224: if (rinfo->type == ZEBRA_ROUTE_RIP
! 1225: && rinfo->sub_type == RIP_ROUTE_RTE)
! 1226: {
! 1227: if (IS_RIP_DEBUG_EVENT)
! 1228: zlog_debug ("Next hop %s is on RIP network. Set nexthop to the packet's originator", inet_ntoa (rte->nexthop));
! 1229: rte->nexthop = rinfo->from;
! 1230: }
! 1231: else
! 1232: {
! 1233: if (IS_RIP_DEBUG_EVENT)
! 1234: zlog_debug ("Next hop %s is not directly reachable. Treat it as 0.0.0.0", inet_ntoa (rte->nexthop));
! 1235: rte->nexthop.s_addr = 0;
! 1236: }
! 1237:
! 1238: route_unlock_node (rn);
! 1239: }
! 1240: else
! 1241: {
! 1242: if (IS_RIP_DEBUG_EVENT)
! 1243: zlog_debug ("Next hop %s is not directly reachable. Treat it as 0.0.0.0", inet_ntoa (rte->nexthop));
! 1244: rte->nexthop.s_addr = 0;
! 1245: }
! 1246:
! 1247: }
! 1248: }
! 1249:
! 1250: /* For RIPv1, there won't be a valid netmask.
! 1251:
! 1252: This is a best guess at the masks. If everyone was using old
! 1253: Ciscos before the 'ip subnet zero' option, it would be almost
! 1254: right too :-)
! 1255:
! 1256: Cisco summarize ripv1 advertisments to the classful boundary
! 1257: (/16 for class B's) except when the RIP packet does to inside
! 1258: the classful network in question. */
! 1259:
! 1260: if ((packet->version == RIPv1 && rte->prefix.s_addr != 0)
! 1261: || (packet->version == RIPv2
! 1262: && (rte->prefix.s_addr != 0 && rte->mask.s_addr == 0)))
! 1263: {
! 1264: u_int32_t destination;
! 1265:
! 1266: if (subnetted == -1)
! 1267: {
! 1268: memcpy (&ifaddr, ifc->address, sizeof (struct prefix_ipv4));
! 1269: memcpy (&ifaddrclass, &ifaddr, sizeof (struct prefix_ipv4));
! 1270: apply_classful_mask_ipv4 (&ifaddrclass);
! 1271: subnetted = 0;
! 1272: if (ifaddr.prefixlen > ifaddrclass.prefixlen)
! 1273: subnetted = 1;
! 1274: }
! 1275:
! 1276: destination = ntohl (rte->prefix.s_addr);
! 1277:
! 1278: if (IN_CLASSA (destination))
! 1279: masklen2ip (8, &rte->mask);
! 1280: else if (IN_CLASSB (destination))
! 1281: masklen2ip (16, &rte->mask);
! 1282: else if (IN_CLASSC (destination))
! 1283: masklen2ip (24, &rte->mask);
! 1284:
! 1285: if (subnetted == 1)
! 1286: masklen2ip (ifaddrclass.prefixlen,
! 1287: (struct in_addr *) &destination);
! 1288: if ((subnetted == 1) && ((rte->prefix.s_addr & destination) ==
! 1289: ifaddrclass.prefix.s_addr))
! 1290: {
! 1291: masklen2ip (ifaddr.prefixlen, &rte->mask);
! 1292: if ((rte->prefix.s_addr & rte->mask.s_addr) != rte->prefix.s_addr)
! 1293: masklen2ip (32, &rte->mask);
! 1294: if (IS_RIP_DEBUG_EVENT)
! 1295: zlog_debug ("Subnetted route %s", inet_ntoa (rte->prefix));
! 1296: }
! 1297: else
! 1298: {
! 1299: if ((rte->prefix.s_addr & rte->mask.s_addr) != rte->prefix.s_addr)
! 1300: continue;
! 1301: }
! 1302:
! 1303: if (IS_RIP_DEBUG_EVENT)
! 1304: {
! 1305: zlog_debug ("Resultant route %s", inet_ntoa (rte->prefix));
! 1306: zlog_debug ("Resultant mask %s", inet_ntoa (rte->mask));
! 1307: }
! 1308: }
! 1309:
! 1310: /* In case of RIPv2, if prefix in RTE is not netmask applied one
! 1311: ignore the entry. */
! 1312: if ((packet->version == RIPv2)
! 1313: && (rte->mask.s_addr != 0)
! 1314: && ((rte->prefix.s_addr & rte->mask.s_addr) != rte->prefix.s_addr))
! 1315: {
! 1316: zlog_warn ("RIPv2 address %s is not mask /%d applied one",
! 1317: inet_ntoa (rte->prefix), ip_masklen (rte->mask));
! 1318: rip_peer_bad_route (from);
! 1319: continue;
! 1320: }
! 1321:
! 1322: /* Default route's netmask is ignored. */
! 1323: if (packet->version == RIPv2
! 1324: && (rte->prefix.s_addr == 0)
! 1325: && (rte->mask.s_addr != 0))
! 1326: {
! 1327: if (IS_RIP_DEBUG_EVENT)
! 1328: zlog_debug ("Default route with non-zero netmask. Set zero to netmask");
! 1329: rte->mask.s_addr = 0;
! 1330: }
! 1331:
! 1332: /* Routing table updates. */
! 1333: rip_rte_process (rte, from, ifc->ifp);
! 1334: }
! 1335: }
! 1336:
! 1337: /* Make socket for RIP protocol. */
! 1338: static int
! 1339: rip_create_socket (struct sockaddr_in *from)
! 1340: {
! 1341: int ret;
! 1342: int sock;
! 1343: struct sockaddr_in addr;
! 1344:
! 1345: memset (&addr, 0, sizeof (struct sockaddr_in));
! 1346:
! 1347: if (!from)
! 1348: {
! 1349: addr.sin_family = AF_INET;
! 1350: addr.sin_addr.s_addr = INADDR_ANY;
! 1351: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 1352: addr.sin_len = sizeof (struct sockaddr_in);
! 1353: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 1354: } else {
! 1355: memcpy(&addr, from, sizeof(addr));
! 1356: }
! 1357:
! 1358: /* sending port must always be the RIP port */
! 1359: addr.sin_port = htons (RIP_PORT_DEFAULT);
! 1360:
! 1361: /* Make datagram socket. */
! 1362: sock = socket (AF_INET, SOCK_DGRAM, 0);
! 1363: if (sock < 0)
! 1364: {
! 1365: zlog_err("Cannot create UDP socket: %s", safe_strerror(errno));
! 1366: exit (1);
! 1367: }
! 1368:
! 1369: sockopt_broadcast (sock);
! 1370: sockopt_reuseaddr (sock);
! 1371: sockopt_reuseport (sock);
! 1372: #ifdef RIP_RECVMSG
! 1373: setsockopt_pktinfo (sock);
! 1374: #endif /* RIP_RECVMSG */
! 1375: #ifdef IPTOS_PREC_INTERNETCONTROL
! 1376: setsockopt_ipv4_tos (sock, IPTOS_PREC_INTERNETCONTROL);
! 1377: #endif
! 1378:
! 1379: if (ripd_privs.change (ZPRIVS_RAISE))
! 1380: zlog_err ("rip_create_socket: could not raise privs");
! 1381: setsockopt_so_recvbuf (sock, RIP_UDP_RCV_BUF);
! 1382: if ( (ret = bind (sock, (struct sockaddr *) & addr, sizeof (addr))) < 0)
! 1383:
! 1384: {
! 1385: int save_errno = errno;
! 1386: if (ripd_privs.change (ZPRIVS_LOWER))
! 1387: zlog_err ("rip_create_socket: could not lower privs");
! 1388:
! 1389: zlog_err("%s: Can't bind socket %d to %s port %d: %s", __func__,
! 1390: sock, inet_ntoa(addr.sin_addr),
! 1391: (int) ntohs(addr.sin_port),
! 1392: safe_strerror(save_errno));
! 1393:
! 1394: close (sock);
! 1395: return ret;
! 1396: }
! 1397:
! 1398: if (ripd_privs.change (ZPRIVS_LOWER))
! 1399: zlog_err ("rip_create_socket: could not lower privs");
! 1400:
! 1401: return sock;
! 1402: }
! 1403:
! 1404: /* RIP packet send to destination address, on interface denoted by
! 1405: * by connected argument. NULL to argument denotes destination should be
! 1406: * should be RIP multicast group
! 1407: */
! 1408: static int
! 1409: rip_send_packet (u_char * buf, int size, struct sockaddr_in *to,
! 1410: struct connected *ifc)
! 1411: {
! 1412: int ret, send_sock;
! 1413: struct sockaddr_in sin;
! 1414:
! 1415: assert (ifc != NULL);
! 1416:
! 1417: if (IS_RIP_DEBUG_PACKET)
! 1418: {
! 1419: #define ADDRESS_SIZE 20
! 1420: char dst[ADDRESS_SIZE];
! 1421: dst[ADDRESS_SIZE - 1] = '\0';
! 1422:
! 1423: if (to)
! 1424: {
! 1425: strncpy (dst, inet_ntoa(to->sin_addr), ADDRESS_SIZE - 1);
! 1426: }
! 1427: else
! 1428: {
! 1429: sin.sin_addr.s_addr = htonl (INADDR_RIP_GROUP);
! 1430: strncpy (dst, inet_ntoa(sin.sin_addr), ADDRESS_SIZE - 1);
! 1431: }
! 1432: #undef ADDRESS_SIZE
! 1433: zlog_debug("rip_send_packet %s > %s (%s)",
! 1434: inet_ntoa(ifc->address->u.prefix4),
! 1435: dst, ifc->ifp->name);
! 1436: }
! 1437:
! 1438: if ( CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY) )
! 1439: {
! 1440: /*
! 1441: * ZEBRA_IFA_SECONDARY is set on linux when an interface is configured
! 1442: * with multiple addresses on the same subnet: the first address
! 1443: * on the subnet is configured "primary", and all subsequent addresses
! 1444: * on that subnet are treated as "secondary" addresses.
! 1445: * In order to avoid routing-table bloat on other rip listeners,
! 1446: * we do not send out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
! 1447: * XXX Since Linux is the only system for which the ZEBRA_IFA_SECONDARY
! 1448: * flag is set, we would end up sending a packet for a "secondary"
! 1449: * source address on non-linux systems.
! 1450: */
! 1451: if (IS_RIP_DEBUG_PACKET)
! 1452: zlog_debug("duplicate dropped");
! 1453: return 0;
! 1454: }
! 1455:
! 1456: /* Make destination address. */
! 1457: memset (&sin, 0, sizeof (struct sockaddr_in));
! 1458: sin.sin_family = AF_INET;
! 1459: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 1460: sin.sin_len = sizeof (struct sockaddr_in);
! 1461: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 1462:
! 1463: /* When destination is specified, use it's port and address. */
! 1464: if (to)
! 1465: {
! 1466: sin.sin_port = to->sin_port;
! 1467: sin.sin_addr = to->sin_addr;
! 1468: send_sock = rip->sock;
! 1469: }
! 1470: else
! 1471: {
! 1472: struct sockaddr_in from;
! 1473:
! 1474: sin.sin_port = htons (RIP_PORT_DEFAULT);
! 1475: sin.sin_addr.s_addr = htonl (INADDR_RIP_GROUP);
! 1476:
! 1477: /* multicast send should bind to local interface address */
! 1478: from.sin_family = AF_INET;
! 1479: from.sin_port = htons (RIP_PORT_DEFAULT);
! 1480: from.sin_addr = ifc->address->u.prefix4;
! 1481: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 1482: from.sin_len = sizeof (struct sockaddr_in);
! 1483: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 1484:
! 1485: /*
! 1486: * we have to open a new socket for each packet because this
! 1487: * is the most portable way to bind to a different source
! 1488: * ipv4 address for each packet.
! 1489: */
! 1490: if ( (send_sock = rip_create_socket (&from)) < 0)
! 1491: {
! 1492: zlog_warn("rip_send_packet could not create socket.");
! 1493: return -1;
! 1494: }
! 1495: rip_interface_multicast_set (send_sock, ifc);
! 1496: }
! 1497:
! 1498: ret = sendto (send_sock, buf, size, 0, (struct sockaddr *)&sin,
! 1499: sizeof (struct sockaddr_in));
! 1500:
! 1501: if (IS_RIP_DEBUG_EVENT)
! 1502: zlog_debug ("SEND to %s.%d", inet_ntoa(sin.sin_addr),
! 1503: ntohs (sin.sin_port));
! 1504:
! 1505: if (ret < 0)
! 1506: zlog_warn ("can't send packet : %s", safe_strerror (errno));
! 1507:
! 1508: if (!to)
! 1509: close(send_sock);
! 1510:
! 1511: return ret;
! 1512: }
! 1513:
! 1514: /* Add redistributed route to RIP table. */
! 1515: void
! 1516: rip_redistribute_add (int type, int sub_type, struct prefix_ipv4 *p,
! 1517: unsigned int ifindex, struct in_addr *nexthop,
! 1518: unsigned int metric, unsigned char distance)
! 1519: {
! 1520: int ret;
! 1521: struct route_node *rp;
! 1522: struct rip_info *rinfo;
! 1523:
! 1524: /* Redistribute route */
! 1525: ret = rip_destination_check (p->prefix);
! 1526: if (! ret)
! 1527: return;
! 1528:
! 1529: rp = route_node_get (rip->table, (struct prefix *) p);
! 1530:
! 1531: rinfo = rp->info;
! 1532:
! 1533: if (rinfo)
! 1534: {
! 1535: if (rinfo->type == ZEBRA_ROUTE_CONNECT
! 1536: && rinfo->sub_type == RIP_ROUTE_INTERFACE
! 1537: && rinfo->metric != RIP_METRIC_INFINITY)
! 1538: {
! 1539: route_unlock_node (rp);
! 1540: return;
! 1541: }
! 1542:
! 1543: /* Manually configured RIP route check. */
! 1544: if (rinfo->type == ZEBRA_ROUTE_RIP
! 1545: && ((rinfo->sub_type == RIP_ROUTE_STATIC) ||
! 1546: (rinfo->sub_type == RIP_ROUTE_DEFAULT)) )
! 1547: {
! 1548: if (type != ZEBRA_ROUTE_RIP || ((sub_type != RIP_ROUTE_STATIC) &&
! 1549: (sub_type != RIP_ROUTE_DEFAULT)))
! 1550: {
! 1551: route_unlock_node (rp);
! 1552: return;
! 1553: }
! 1554: }
! 1555:
! 1556: RIP_TIMER_OFF (rinfo->t_timeout);
! 1557: RIP_TIMER_OFF (rinfo->t_garbage_collect);
! 1558:
! 1559: if (rip_route_rte (rinfo))
! 1560: rip_zebra_ipv4_delete ((struct prefix_ipv4 *)&rp->p, &rinfo->nexthop,
! 1561: rinfo->metric);
! 1562: rp->info = NULL;
! 1563: rip_info_free (rinfo);
! 1564:
! 1565: route_unlock_node (rp);
! 1566: }
! 1567:
! 1568: rinfo = rip_info_new ();
! 1569:
! 1570: rinfo->type = type;
! 1571: rinfo->sub_type = sub_type;
! 1572: rinfo->ifindex = ifindex;
! 1573: rinfo->metric = 1;
! 1574: rinfo->external_metric = metric;
! 1575: rinfo->distance = distance;
! 1576: rinfo->rp = rp;
! 1577:
! 1578: if (nexthop)
! 1579: rinfo->nexthop = *nexthop;
! 1580:
! 1581: rinfo->flags |= RIP_RTF_FIB;
! 1582: rp->info = rinfo;
! 1583:
! 1584: rinfo->flags |= RIP_RTF_CHANGED;
! 1585:
! 1586: if (IS_RIP_DEBUG_EVENT) {
! 1587: if (!nexthop)
! 1588: zlog_debug ("Redistribute new prefix %s/%d on the interface %s",
! 1589: inet_ntoa(p->prefix), p->prefixlen,
! 1590: ifindex2ifname(ifindex));
! 1591: else
! 1592: zlog_debug ("Redistribute new prefix %s/%d with nexthop %s on the interface %s",
! 1593: inet_ntoa(p->prefix), p->prefixlen, inet_ntoa(rinfo->nexthop),
! 1594: ifindex2ifname(ifindex));
! 1595: }
! 1596:
! 1597:
! 1598: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 1599: }
! 1600:
! 1601: /* Delete redistributed route from RIP table. */
! 1602: void
! 1603: rip_redistribute_delete (int type, int sub_type, struct prefix_ipv4 *p,
! 1604: unsigned int ifindex)
! 1605: {
! 1606: int ret;
! 1607: struct route_node *rp;
! 1608: struct rip_info *rinfo;
! 1609:
! 1610: ret = rip_destination_check (p->prefix);
! 1611: if (! ret)
! 1612: return;
! 1613:
! 1614: rp = route_node_lookup (rip->table, (struct prefix *) p);
! 1615: if (rp)
! 1616: {
! 1617: rinfo = rp->info;
! 1618:
! 1619: if (rinfo != NULL
! 1620: && rinfo->type == type
! 1621: && rinfo->sub_type == sub_type
! 1622: && rinfo->ifindex == ifindex)
! 1623: {
! 1624: /* Perform poisoned reverse. */
! 1625: rinfo->metric = RIP_METRIC_INFINITY;
! 1626: RIP_TIMER_ON (rinfo->t_garbage_collect,
! 1627: rip_garbage_collect, rip->garbage_time);
! 1628: RIP_TIMER_OFF (rinfo->t_timeout);
! 1629: rinfo->flags |= RIP_RTF_CHANGED;
! 1630:
! 1631: if (IS_RIP_DEBUG_EVENT)
! 1632: zlog_debug ("Poisone %s/%d on the interface %s with an infinity metric [delete]",
! 1633: inet_ntoa(p->prefix), p->prefixlen,
! 1634: ifindex2ifname(ifindex));
! 1635:
! 1636: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 1637: }
! 1638: }
! 1639: }
! 1640:
! 1641: /* Response to request called from rip_read ().*/
! 1642: static void
! 1643: rip_request_process (struct rip_packet *packet, int size,
! 1644: struct sockaddr_in *from, struct connected *ifc)
! 1645: {
! 1646: caddr_t lim;
! 1647: struct rte *rte;
! 1648: struct prefix_ipv4 p;
! 1649: struct route_node *rp;
! 1650: struct rip_info *rinfo;
! 1651: struct rip_interface *ri;
! 1652:
! 1653: /* Does not reponse to the requests on the loopback interfaces */
! 1654: if (if_is_loopback (ifc->ifp))
! 1655: return;
! 1656:
! 1657: /* Check RIP process is enabled on this interface. */
! 1658: ri = ifc->ifp->info;
! 1659: if (! ri->running)
! 1660: return;
! 1661:
! 1662: /* When passive interface is specified, suppress responses */
! 1663: if (ri->passive)
! 1664: return;
! 1665:
! 1666: /* RIP peer update. */
! 1667: rip_peer_update (from, packet->version);
! 1668:
! 1669: lim = ((caddr_t) packet) + size;
! 1670: rte = packet->rte;
! 1671:
! 1672: /* The Request is processed entry by entry. If there are no
! 1673: entries, no response is given. */
! 1674: if (lim == (caddr_t) rte)
! 1675: return;
! 1676:
! 1677: /* There is one special case. If there is exactly one entry in the
! 1678: request, and it has an address family identifier of zero and a
! 1679: metric of infinity (i.e., 16), then this is a request to send the
! 1680: entire routing table. */
! 1681: if (lim == ((caddr_t) (rte + 1)) &&
! 1682: ntohs (rte->family) == 0 &&
! 1683: ntohl (rte->metric) == RIP_METRIC_INFINITY)
! 1684: {
! 1685: struct prefix_ipv4 saddr;
! 1686:
! 1687: /* saddr will be used for determining which routes to split-horizon.
! 1688: Since the source address we'll pick will be on the same subnet as the
! 1689: destination, for the purpose of split-horizoning, we'll
! 1690: pretend that "from" is our source address. */
! 1691: saddr.family = AF_INET;
! 1692: saddr.prefixlen = IPV4_MAX_BITLEN;
! 1693: saddr.prefix = from->sin_addr;
! 1694:
! 1695: /* All route with split horizon */
! 1696: rip_output_process (ifc, from, rip_all_route, packet->version);
! 1697: }
! 1698: else
! 1699: {
! 1700: /* Examine the list of RTEs in the Request one by one. For each
! 1701: entry, look up the destination in the router's routing
! 1702: database and, if there is a route, put that route's metric in
! 1703: the metric field of the RTE. If there is no explicit route
! 1704: to the specified destination, put infinity in the metric
! 1705: field. Once all the entries have been filled in, change the
! 1706: command from Request to Response and send the datagram back
! 1707: to the requestor. */
! 1708: p.family = AF_INET;
! 1709:
! 1710: for (; ((caddr_t) rte) < lim; rte++)
! 1711: {
! 1712: p.prefix = rte->prefix;
! 1713: p.prefixlen = ip_masklen (rte->mask);
! 1714: apply_mask_ipv4 (&p);
! 1715:
! 1716: rp = route_node_lookup (rip->table, (struct prefix *) &p);
! 1717: if (rp)
! 1718: {
! 1719: rinfo = rp->info;
! 1720: rte->metric = htonl (rinfo->metric);
! 1721: route_unlock_node (rp);
! 1722: }
! 1723: else
! 1724: rte->metric = htonl (RIP_METRIC_INFINITY);
! 1725: }
! 1726: packet->command = RIP_RESPONSE;
! 1727:
! 1728: rip_send_packet ((u_char *)packet, size, from, ifc);
! 1729: }
! 1730: rip_global_queries++;
! 1731: }
! 1732:
! 1733: #if RIP_RECVMSG
! 1734: /* Set IPv6 packet info to the socket. */
! 1735: static int
! 1736: setsockopt_pktinfo (int sock)
! 1737: {
! 1738: int ret;
! 1739: int val = 1;
! 1740:
! 1741: ret = setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &val, sizeof(val));
! 1742: if (ret < 0)
! 1743: zlog_warn ("Can't setsockopt IP_PKTINFO : %s", safe_strerror (errno));
! 1744: return ret;
! 1745: }
! 1746:
! 1747: /* Read RIP packet by recvmsg function. */
! 1748: int
! 1749: rip_recvmsg (int sock, u_char *buf, int size, struct sockaddr_in *from,
! 1750: int *ifindex)
! 1751: {
! 1752: int ret;
! 1753: struct msghdr msg;
! 1754: struct iovec iov;
! 1755: struct cmsghdr *ptr;
! 1756: char adata[1024];
! 1757:
! 1758: msg.msg_name = (void *) from;
! 1759: msg.msg_namelen = sizeof (struct sockaddr_in);
! 1760: msg.msg_iov = &iov;
! 1761: msg.msg_iovlen = 1;
! 1762: msg.msg_control = (void *) adata;
! 1763: msg.msg_controllen = sizeof adata;
! 1764: iov.iov_base = buf;
! 1765: iov.iov_len = size;
! 1766:
! 1767: ret = recvmsg (sock, &msg, 0);
! 1768: if (ret < 0)
! 1769: return ret;
! 1770:
! 1771: for (ptr = ZCMSG_FIRSTHDR(&msg); ptr != NULL; ptr = CMSG_NXTHDR(&msg, ptr))
! 1772: if (ptr->cmsg_level == IPPROTO_IP && ptr->cmsg_type == IP_PKTINFO)
! 1773: {
! 1774: struct in_pktinfo *pktinfo;
! 1775: int i;
! 1776:
! 1777: pktinfo = (struct in_pktinfo *) CMSG_DATA (ptr);
! 1778: i = pktinfo->ipi_ifindex;
! 1779: }
! 1780: return ret;
! 1781: }
! 1782:
! 1783: /* RIP packet read function. */
! 1784: int
! 1785: rip_read_new (struct thread *t)
! 1786: {
! 1787: int ret;
! 1788: int sock;
! 1789: char buf[RIP_PACKET_MAXSIZ];
! 1790: struct sockaddr_in from;
! 1791: unsigned int ifindex;
! 1792:
! 1793: /* Fetch socket then register myself. */
! 1794: sock = THREAD_FD (t);
! 1795: rip_event (RIP_READ, sock);
! 1796:
! 1797: /* Read RIP packet. */
! 1798: ret = rip_recvmsg (sock, buf, RIP_PACKET_MAXSIZ, &from, (int *)&ifindex);
! 1799: if (ret < 0)
! 1800: {
! 1801: zlog_warn ("Can't read RIP packet: %s", safe_strerror (errno));
! 1802: return ret;
! 1803: }
! 1804:
! 1805: return ret;
! 1806: }
! 1807: #endif /* RIP_RECVMSG */
! 1808:
! 1809: /* First entry point of RIP packet. */
! 1810: static int
! 1811: rip_read (struct thread *t)
! 1812: {
! 1813: int sock;
! 1814: int ret;
! 1815: int rtenum;
! 1816: union rip_buf rip_buf;
! 1817: struct rip_packet *packet;
! 1818: struct sockaddr_in from;
! 1819: int len;
! 1820: int vrecv;
! 1821: socklen_t fromlen;
! 1822: struct interface *ifp;
! 1823: struct connected *ifc;
! 1824: struct rip_interface *ri;
! 1825:
! 1826: /* Fetch socket then register myself. */
! 1827: sock = THREAD_FD (t);
! 1828: rip->t_read = NULL;
! 1829:
! 1830: /* Add myself to tne next event */
! 1831: rip_event (RIP_READ, sock);
! 1832:
! 1833: /* RIPd manages only IPv4. */
! 1834: memset (&from, 0, sizeof (struct sockaddr_in));
! 1835: fromlen = sizeof (struct sockaddr_in);
! 1836:
! 1837: len = recvfrom (sock, (char *)&rip_buf.buf, sizeof (rip_buf.buf), 0,
! 1838: (struct sockaddr *) &from, &fromlen);
! 1839: if (len < 0)
! 1840: {
! 1841: zlog_info ("recvfrom failed: %s", safe_strerror (errno));
! 1842: return len;
! 1843: }
! 1844:
! 1845: /* Check is this packet comming from myself? */
! 1846: if (if_check_address (from.sin_addr))
! 1847: {
! 1848: if (IS_RIP_DEBUG_PACKET)
! 1849: zlog_debug ("ignore packet comes from myself");
! 1850: return -1;
! 1851: }
! 1852:
! 1853: /* Which interface is this packet comes from. */
! 1854: ifp = if_lookup_address (from.sin_addr);
! 1855:
! 1856: /* RIP packet received */
! 1857: if (IS_RIP_DEBUG_EVENT)
! 1858: zlog_debug ("RECV packet from %s port %d on %s",
! 1859: inet_ntoa (from.sin_addr), ntohs (from.sin_port),
! 1860: ifp ? ifp->name : "unknown");
! 1861:
! 1862: /* If this packet come from unknown interface, ignore it. */
! 1863: if (ifp == NULL)
! 1864: {
! 1865: zlog_info ("rip_read: cannot find interface for packet from %s port %d",
! 1866: inet_ntoa(from.sin_addr), ntohs (from.sin_port));
! 1867: return -1;
! 1868: }
! 1869:
! 1870: ifc = connected_lookup_address (ifp, from.sin_addr);
! 1871:
! 1872: if (ifc == NULL)
! 1873: {
! 1874: zlog_info ("rip_read: cannot find connected address for packet from %s "
! 1875: "port %d on interface %s",
! 1876: inet_ntoa(from.sin_addr), ntohs (from.sin_port), ifp->name);
! 1877: return -1;
! 1878: }
! 1879:
! 1880: /* Packet length check. */
! 1881: if (len < RIP_PACKET_MINSIZ)
! 1882: {
! 1883: zlog_warn ("packet size %d is smaller than minimum size %d",
! 1884: len, RIP_PACKET_MINSIZ);
! 1885: rip_peer_bad_packet (&from);
! 1886: return len;
! 1887: }
! 1888: if (len > RIP_PACKET_MAXSIZ)
! 1889: {
! 1890: zlog_warn ("packet size %d is larger than max size %d",
! 1891: len, RIP_PACKET_MAXSIZ);
! 1892: rip_peer_bad_packet (&from);
! 1893: return len;
! 1894: }
! 1895:
! 1896: /* Packet alignment check. */
! 1897: if ((len - RIP_PACKET_MINSIZ) % 20)
! 1898: {
! 1899: zlog_warn ("packet size %d is wrong for RIP packet alignment", len);
! 1900: rip_peer_bad_packet (&from);
! 1901: return len;
! 1902: }
! 1903:
! 1904: /* Set RTE number. */
! 1905: rtenum = ((len - RIP_PACKET_MINSIZ) / 20);
! 1906:
! 1907: /* For easy to handle. */
! 1908: packet = &rip_buf.rip_packet;
! 1909:
! 1910: /* RIP version check. */
! 1911: if (packet->version == 0)
! 1912: {
! 1913: zlog_info ("version 0 with command %d received.", packet->command);
! 1914: rip_peer_bad_packet (&from);
! 1915: return -1;
! 1916: }
! 1917:
! 1918: /* Dump RIP packet. */
! 1919: if (IS_RIP_DEBUG_RECV)
! 1920: rip_packet_dump (packet, len, "RECV");
! 1921:
! 1922: /* RIP version adjust. This code should rethink now. RFC1058 says
! 1923: that "Version 1 implementations are to ignore this extra data and
! 1924: process only the fields specified in this document.". So RIPv3
! 1925: packet should be treated as RIPv1 ignoring must be zero field. */
! 1926: if (packet->version > RIPv2)
! 1927: packet->version = RIPv2;
! 1928:
! 1929: /* Is RIP running or is this RIP neighbor ?*/
! 1930: ri = ifp->info;
! 1931: if (! ri->running && ! rip_neighbor_lookup (&from))
! 1932: {
! 1933: if (IS_RIP_DEBUG_EVENT)
! 1934: zlog_debug ("RIP is not enabled on interface %s.", ifp->name);
! 1935: rip_peer_bad_packet (&from);
! 1936: return -1;
! 1937: }
! 1938:
! 1939: /* RIP Version check. RFC2453, 4.6 and 5.1 */
! 1940: vrecv = ((ri->ri_receive == RI_RIP_UNSPEC) ?
! 1941: rip->version_recv : ri->ri_receive);
! 1942: if ((packet->version == RIPv1) && !(vrecv & RIPv1))
! 1943: {
! 1944: if (IS_RIP_DEBUG_PACKET)
! 1945: zlog_debug (" packet's v%d doesn't fit to if version spec",
! 1946: packet->version);
! 1947: rip_peer_bad_packet (&from);
! 1948: return -1;
! 1949: }
! 1950: if ((packet->version == RIPv2) && !(vrecv & RIPv2))
! 1951: {
! 1952: if (IS_RIP_DEBUG_PACKET)
! 1953: zlog_debug (" packet's v%d doesn't fit to if version spec",
! 1954: packet->version);
! 1955: rip_peer_bad_packet (&from);
! 1956: return -1;
! 1957: }
! 1958:
! 1959: /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
! 1960: messages, then RIP-1 and unauthenticated RIP-2 messages will be
! 1961: accepted; authenticated RIP-2 messages shall be discarded. */
! 1962: if ((ri->auth_type == RIP_NO_AUTH)
! 1963: && rtenum
! 1964: && (packet->version == RIPv2)
! 1965: && (packet->rte->family == htons(RIP_FAMILY_AUTH)))
! 1966: {
! 1967: if (IS_RIP_DEBUG_EVENT)
! 1968: zlog_debug ("packet RIPv%d is dropped because authentication disabled",
! 1969: packet->version);
! 1970: rip_peer_bad_packet (&from);
! 1971: return -1;
! 1972: }
! 1973:
! 1974: /* RFC:
! 1975: If the router is configured to authenticate RIP-2 messages, then
! 1976: RIP-1 messages and RIP-2 messages which pass authentication
! 1977: testing shall be accepted; unauthenticated and failed
! 1978: authentication RIP-2 messages shall be discarded. For maximum
! 1979: security, RIP-1 messages should be ignored when authentication is
! 1980: in use (see section 4.1); otherwise, the routing information from
! 1981: authenticated messages will be propagated by RIP-1 routers in an
! 1982: unauthenticated manner.
! 1983: */
! 1984: /* We make an exception for RIPv1 REQUEST packets, to which we'll
! 1985: * always reply regardless of authentication settings, because:
! 1986: *
! 1987: * - if there other authorised routers on-link, the REQUESTor can
! 1988: * passively obtain the routing updates anyway
! 1989: * - if there are no other authorised routers on-link, RIP can
! 1990: * easily be disabled for the link to prevent giving out information
! 1991: * on state of this routers RIP routing table..
! 1992: *
! 1993: * I.e. if RIPv1 has any place anymore these days, it's as a very
! 1994: * simple way to distribute routing information (e.g. to embedded
! 1995: * hosts / appliances) and the ability to give out RIPv1
! 1996: * routing-information freely, while still requiring RIPv2
! 1997: * authentication for any RESPONSEs might be vaguely useful.
! 1998: */
! 1999: if (ri->auth_type != RIP_NO_AUTH
! 2000: && packet->version == RIPv1)
! 2001: {
! 2002: /* Discard RIPv1 messages other than REQUESTs */
! 2003: if (packet->command != RIP_REQUEST)
! 2004: {
! 2005: if (IS_RIP_DEBUG_PACKET)
! 2006: zlog_debug ("RIPv1" " dropped because authentication enabled");
! 2007: rip_peer_bad_packet (&from);
! 2008: return -1;
! 2009: }
! 2010: }
! 2011: else if (ri->auth_type != RIP_NO_AUTH)
! 2012: {
! 2013: const char *auth_desc;
! 2014:
! 2015: if (rtenum == 0)
! 2016: {
! 2017: /* There definitely is no authentication in the packet. */
! 2018: if (IS_RIP_DEBUG_PACKET)
! 2019: zlog_debug ("RIPv2 authentication failed: no auth RTE in packet");
! 2020: rip_peer_bad_packet (&from);
! 2021: return -1;
! 2022: }
! 2023:
! 2024: /* First RTE must be an Authentication Family RTE */
! 2025: if (packet->rte->family != htons(RIP_FAMILY_AUTH))
! 2026: {
! 2027: if (IS_RIP_DEBUG_PACKET)
! 2028: zlog_debug ("RIPv2" " dropped because authentication enabled");
! 2029: rip_peer_bad_packet (&from);
! 2030: return -1;
! 2031: }
! 2032:
! 2033: /* Check RIPv2 authentication. */
! 2034: switch (ntohs(packet->rte->tag))
! 2035: {
! 2036: case RIP_AUTH_SIMPLE_PASSWORD:
! 2037: auth_desc = "simple";
! 2038: ret = rip_auth_simple_password (packet->rte, &from, ifp);
! 2039: break;
! 2040:
! 2041: case RIP_AUTH_MD5:
! 2042: auth_desc = "MD5";
! 2043: ret = rip_auth_md5 (packet, &from, len, ifp);
! 2044: /* Reset RIP packet length to trim MD5 data. */
! 2045: len = ret;
! 2046: break;
! 2047:
! 2048: default:
! 2049: ret = 0;
! 2050: auth_desc = "unknown type";
! 2051: if (IS_RIP_DEBUG_PACKET)
! 2052: zlog_debug ("RIPv2 Unknown authentication type %d",
! 2053: ntohs (packet->rte->tag));
! 2054: }
! 2055:
! 2056: if (ret)
! 2057: {
! 2058: if (IS_RIP_DEBUG_PACKET)
! 2059: zlog_debug ("RIPv2 %s authentication success", auth_desc);
! 2060: }
! 2061: else
! 2062: {
! 2063: if (IS_RIP_DEBUG_PACKET)
! 2064: zlog_debug ("RIPv2 %s authentication failure", auth_desc);
! 2065: rip_peer_bad_packet (&from);
! 2066: return -1;
! 2067: }
! 2068: }
! 2069:
! 2070: /* Process each command. */
! 2071: switch (packet->command)
! 2072: {
! 2073: case RIP_RESPONSE:
! 2074: rip_response_process (packet, len, &from, ifc);
! 2075: break;
! 2076: case RIP_REQUEST:
! 2077: case RIP_POLL:
! 2078: rip_request_process (packet, len, &from, ifc);
! 2079: break;
! 2080: case RIP_TRACEON:
! 2081: case RIP_TRACEOFF:
! 2082: zlog_info ("Obsolete command %s received, please sent it to routed",
! 2083: lookup (rip_msg, packet->command));
! 2084: rip_peer_bad_packet (&from);
! 2085: break;
! 2086: case RIP_POLL_ENTRY:
! 2087: zlog_info ("Obsolete command %s received",
! 2088: lookup (rip_msg, packet->command));
! 2089: rip_peer_bad_packet (&from);
! 2090: break;
! 2091: default:
! 2092: zlog_info ("Unknown RIP command %d received", packet->command);
! 2093: rip_peer_bad_packet (&from);
! 2094: break;
! 2095: }
! 2096:
! 2097: return len;
! 2098: }
! 2099:
! 2100: /* Write routing table entry to the stream and return next index of
! 2101: the routing table entry in the stream. */
! 2102: static int
! 2103: rip_write_rte (int num, struct stream *s, struct prefix_ipv4 *p,
! 2104: u_char version, struct rip_info *rinfo)
! 2105: {
! 2106: struct in_addr mask;
! 2107:
! 2108: /* Write routing table entry. */
! 2109: if (version == RIPv1)
! 2110: {
! 2111: stream_putw (s, AF_INET);
! 2112: stream_putw (s, 0);
! 2113: stream_put_ipv4 (s, p->prefix.s_addr);
! 2114: stream_put_ipv4 (s, 0);
! 2115: stream_put_ipv4 (s, 0);
! 2116: stream_putl (s, rinfo->metric_out);
! 2117: }
! 2118: else
! 2119: {
! 2120: masklen2ip (p->prefixlen, &mask);
! 2121:
! 2122: stream_putw (s, AF_INET);
! 2123: stream_putw (s, rinfo->tag_out);
! 2124: stream_put_ipv4 (s, p->prefix.s_addr);
! 2125: stream_put_ipv4 (s, mask.s_addr);
! 2126: stream_put_ipv4 (s, rinfo->nexthop_out.s_addr);
! 2127: stream_putl (s, rinfo->metric_out);
! 2128: }
! 2129:
! 2130: return ++num;
! 2131: }
! 2132:
! 2133: /* Send update to the ifp or spcified neighbor. */
! 2134: void
! 2135: rip_output_process (struct connected *ifc, struct sockaddr_in *to,
! 2136: int route_type, u_char version)
! 2137: {
! 2138: int ret;
! 2139: struct stream *s;
! 2140: struct route_node *rp;
! 2141: struct rip_info *rinfo;
! 2142: struct rip_interface *ri;
! 2143: struct prefix_ipv4 *p;
! 2144: struct prefix_ipv4 classfull;
! 2145: struct prefix_ipv4 ifaddrclass;
! 2146: struct key *key = NULL;
! 2147: /* this might need to made dynamic if RIP ever supported auth methods
! 2148: with larger key string sizes */
! 2149: char auth_str[RIP_AUTH_SIMPLE_SIZE];
! 2150: size_t doff = 0; /* offset of digest offset field */
! 2151: int num = 0;
! 2152: int rtemax;
! 2153: int subnetted = 0;
! 2154:
! 2155: /* Logging output event. */
! 2156: if (IS_RIP_DEBUG_EVENT)
! 2157: {
! 2158: if (to)
! 2159: zlog_debug ("update routes to neighbor %s", inet_ntoa (to->sin_addr));
! 2160: else
! 2161: zlog_debug ("update routes on interface %s ifindex %d",
! 2162: ifc->ifp->name, ifc->ifp->ifindex);
! 2163: }
! 2164:
! 2165: /* Set output stream. */
! 2166: s = rip->obuf;
! 2167:
! 2168: /* Reset stream and RTE counter. */
! 2169: stream_reset (s);
! 2170: rtemax = (RIP_PACKET_MAXSIZ - 4) / 20;
! 2171:
! 2172: /* Get RIP interface. */
! 2173: ri = ifc->ifp->info;
! 2174:
! 2175: /* If output interface is in simple password authentication mode, we
! 2176: need space for authentication data. */
! 2177: if (ri->auth_type == RIP_AUTH_SIMPLE_PASSWORD)
! 2178: rtemax -= 1;
! 2179:
! 2180: /* If output interface is in MD5 authentication mode, we need space
! 2181: for authentication header and data. */
! 2182: if (ri->auth_type == RIP_AUTH_MD5)
! 2183: rtemax -= 2;
! 2184:
! 2185: /* If output interface is in simple password authentication mode
! 2186: and string or keychain is specified we need space for auth. data */
! 2187: if (ri->auth_type != RIP_NO_AUTH)
! 2188: {
! 2189: if (ri->key_chain)
! 2190: {
! 2191: struct keychain *keychain;
! 2192:
! 2193: keychain = keychain_lookup (ri->key_chain);
! 2194: if (keychain)
! 2195: key = key_lookup_for_send (keychain);
! 2196: }
! 2197: /* to be passed to auth functions later */
! 2198: rip_auth_prepare_str_send (ri, key, auth_str, RIP_AUTH_SIMPLE_SIZE);
! 2199: }
! 2200:
! 2201: if (version == RIPv1)
! 2202: {
! 2203: memcpy (&ifaddrclass, ifc->address, sizeof (struct prefix_ipv4));
! 2204: apply_classful_mask_ipv4 (&ifaddrclass);
! 2205: subnetted = 0;
! 2206: if (ifc->address->prefixlen > ifaddrclass.prefixlen)
! 2207: subnetted = 1;
! 2208: }
! 2209:
! 2210: for (rp = route_top (rip->table); rp; rp = route_next (rp))
! 2211: if ((rinfo = rp->info) != NULL)
! 2212: {
! 2213: /* For RIPv1, if we are subnetted, output subnets in our network */
! 2214: /* that have the same mask as the output "interface". For other */
! 2215: /* networks, only the classfull version is output. */
! 2216:
! 2217: if (version == RIPv1)
! 2218: {
! 2219: p = (struct prefix_ipv4 *) &rp->p;
! 2220:
! 2221: if (IS_RIP_DEBUG_PACKET)
! 2222: zlog_debug("RIPv1 mask check, %s/%d considered for output",
! 2223: inet_ntoa (rp->p.u.prefix4), rp->p.prefixlen);
! 2224:
! 2225: if (subnetted &&
! 2226: prefix_match ((struct prefix *) &ifaddrclass, &rp->p))
! 2227: {
! 2228: if ((ifc->address->prefixlen != rp->p.prefixlen) &&
! 2229: (rp->p.prefixlen != 32))
! 2230: continue;
! 2231: }
! 2232: else
! 2233: {
! 2234: memcpy (&classfull, &rp->p, sizeof(struct prefix_ipv4));
! 2235: apply_classful_mask_ipv4(&classfull);
! 2236: if (rp->p.u.prefix4.s_addr != 0 &&
! 2237: classfull.prefixlen != rp->p.prefixlen)
! 2238: continue;
! 2239: }
! 2240: if (IS_RIP_DEBUG_PACKET)
! 2241: zlog_debug("RIPv1 mask check, %s/%d made it through",
! 2242: inet_ntoa (rp->p.u.prefix4), rp->p.prefixlen);
! 2243: }
! 2244: else
! 2245: p = (struct prefix_ipv4 *) &rp->p;
! 2246:
! 2247: /* Apply output filters. */
! 2248: ret = rip_outgoing_filter (p, ri);
! 2249: if (ret < 0)
! 2250: continue;
! 2251:
! 2252: /* Changed route only output. */
! 2253: if (route_type == rip_changed_route &&
! 2254: (! (rinfo->flags & RIP_RTF_CHANGED)))
! 2255: continue;
! 2256:
! 2257: /* Split horizon. */
! 2258: /* if (split_horizon == rip_split_horizon) */
! 2259: if (ri->split_horizon == RIP_SPLIT_HORIZON)
! 2260: {
! 2261: /*
! 2262: * We perform split horizon for RIP and connected route.
! 2263: * For rip routes, we want to suppress the route if we would
! 2264: * end up sending the route back on the interface that we
! 2265: * learned it from, with a higher metric. For connected routes,
! 2266: * we suppress the route if the prefix is a subset of the
! 2267: * source address that we are going to use for the packet
! 2268: * (in order to handle the case when multiple subnets are
! 2269: * configured on the same interface).
! 2270: */
! 2271: if (rinfo->type == ZEBRA_ROUTE_RIP &&
! 2272: rinfo->ifindex == ifc->ifp->ifindex)
! 2273: continue;
! 2274: if (rinfo->type == ZEBRA_ROUTE_CONNECT &&
! 2275: prefix_match((struct prefix *)p, ifc->address))
! 2276: continue;
! 2277: }
! 2278:
! 2279: /* Preparation for route-map. */
! 2280: rinfo->metric_set = 0;
! 2281: rinfo->nexthop_out.s_addr = 0;
! 2282: rinfo->metric_out = rinfo->metric;
! 2283: rinfo->tag_out = rinfo->tag;
! 2284: rinfo->ifindex_out = ifc->ifp->ifindex;
! 2285:
! 2286: /* In order to avoid some local loops,
! 2287: * if the RIP route has a nexthop via this interface, keep the nexthop,
! 2288: * otherwise set it to 0. The nexthop should not be propagated
! 2289: * beyond the local broadcast/multicast area in order
! 2290: * to avoid an IGP multi-level recursive look-up.
! 2291: * see (4.4)
! 2292: */
! 2293: if (rinfo->ifindex == ifc->ifp->ifindex)
! 2294: rinfo->nexthop_out = rinfo->nexthop;
! 2295:
! 2296: /* Interface route-map */
! 2297: if (ri->routemap[RIP_FILTER_OUT])
! 2298: {
! 2299: ret = route_map_apply (ri->routemap[RIP_FILTER_OUT],
! 2300: (struct prefix *) p, RMAP_RIP,
! 2301: rinfo);
! 2302:
! 2303: if (ret == RMAP_DENYMATCH)
! 2304: {
! 2305: if (IS_RIP_DEBUG_PACKET)
! 2306: zlog_debug ("RIP %s/%d is filtered by route-map out",
! 2307: inet_ntoa (p->prefix), p->prefixlen);
! 2308: continue;
! 2309: }
! 2310: }
! 2311:
! 2312: /* Apply redistribute route map - continue, if deny */
! 2313: if (rip->route_map[rinfo->type].name
! 2314: && rinfo->sub_type != RIP_ROUTE_INTERFACE)
! 2315: {
! 2316: ret = route_map_apply (rip->route_map[rinfo->type].map,
! 2317: (struct prefix *)p, RMAP_RIP, rinfo);
! 2318:
! 2319: if (ret == RMAP_DENYMATCH)
! 2320: {
! 2321: if (IS_RIP_DEBUG_PACKET)
! 2322: zlog_debug ("%s/%d is filtered by route-map",
! 2323: inet_ntoa (p->prefix), p->prefixlen);
! 2324: continue;
! 2325: }
! 2326: }
! 2327:
! 2328: /* When route-map does not set metric. */
! 2329: if (! rinfo->metric_set)
! 2330: {
! 2331: /* If redistribute metric is set. */
! 2332: if (rip->route_map[rinfo->type].metric_config
! 2333: && rinfo->metric != RIP_METRIC_INFINITY)
! 2334: {
! 2335: rinfo->metric_out = rip->route_map[rinfo->type].metric;
! 2336: }
! 2337: else
! 2338: {
! 2339: /* If the route is not connected or localy generated
! 2340: one, use default-metric value*/
! 2341: if (rinfo->type != ZEBRA_ROUTE_RIP
! 2342: && rinfo->type != ZEBRA_ROUTE_CONNECT
! 2343: && rinfo->metric != RIP_METRIC_INFINITY)
! 2344: rinfo->metric_out = rip->default_metric;
! 2345: }
! 2346: }
! 2347:
! 2348: /* Apply offset-list */
! 2349: if (rinfo->metric != RIP_METRIC_INFINITY)
! 2350: rip_offset_list_apply_out (p, ifc->ifp, &rinfo->metric_out);
! 2351:
! 2352: if (rinfo->metric_out > RIP_METRIC_INFINITY)
! 2353: rinfo->metric_out = RIP_METRIC_INFINITY;
! 2354:
! 2355: /* Perform split-horizon with poisoned reverse
! 2356: * for RIP and connected routes.
! 2357: **/
! 2358: if (ri->split_horizon == RIP_SPLIT_HORIZON_POISONED_REVERSE) {
! 2359: /*
! 2360: * We perform split horizon for RIP and connected route.
! 2361: * For rip routes, we want to suppress the route if we would
! 2362: * end up sending the route back on the interface that we
! 2363: * learned it from, with a higher metric. For connected routes,
! 2364: * we suppress the route if the prefix is a subset of the
! 2365: * source address that we are going to use for the packet
! 2366: * (in order to handle the case when multiple subnets are
! 2367: * configured on the same interface).
! 2368: */
! 2369: if (rinfo->type == ZEBRA_ROUTE_RIP &&
! 2370: rinfo->ifindex == ifc->ifp->ifindex)
! 2371: rinfo->metric_out = RIP_METRIC_INFINITY;
! 2372: if (rinfo->type == ZEBRA_ROUTE_CONNECT &&
! 2373: prefix_match((struct prefix *)p, ifc->address))
! 2374: rinfo->metric_out = RIP_METRIC_INFINITY;
! 2375: }
! 2376:
! 2377: /* Prepare preamble, auth headers, if needs be */
! 2378: if (num == 0)
! 2379: {
! 2380: stream_putc (s, RIP_RESPONSE);
! 2381: stream_putc (s, version);
! 2382: stream_putw (s, 0);
! 2383:
! 2384: /* auth header for !v1 && !no_auth */
! 2385: if ( (ri->auth_type != RIP_NO_AUTH) && (version != RIPv1) )
! 2386: doff = rip_auth_header_write (s, ri, key, auth_str,
! 2387: RIP_AUTH_SIMPLE_SIZE);
! 2388: }
! 2389:
! 2390: /* Write RTE to the stream. */
! 2391: num = rip_write_rte (num, s, p, version, rinfo);
! 2392: if (num == rtemax)
! 2393: {
! 2394: if (version == RIPv2 && ri->auth_type == RIP_AUTH_MD5)
! 2395: rip_auth_md5_set (s, ri, doff, auth_str, RIP_AUTH_SIMPLE_SIZE);
! 2396:
! 2397: ret = rip_send_packet (STREAM_DATA (s), stream_get_endp (s),
! 2398: to, ifc);
! 2399:
! 2400: if (ret >= 0 && IS_RIP_DEBUG_SEND)
! 2401: rip_packet_dump ((struct rip_packet *)STREAM_DATA (s),
! 2402: stream_get_endp(s), "SEND");
! 2403: num = 0;
! 2404: stream_reset (s);
! 2405: }
! 2406: }
! 2407:
! 2408: /* Flush unwritten RTE. */
! 2409: if (num != 0)
! 2410: {
! 2411: if (version == RIPv2 && ri->auth_type == RIP_AUTH_MD5)
! 2412: rip_auth_md5_set (s, ri, doff, auth_str, RIP_AUTH_SIMPLE_SIZE);
! 2413:
! 2414: ret = rip_send_packet (STREAM_DATA (s), stream_get_endp (s), to, ifc);
! 2415:
! 2416: if (ret >= 0 && IS_RIP_DEBUG_SEND)
! 2417: rip_packet_dump ((struct rip_packet *)STREAM_DATA (s),
! 2418: stream_get_endp (s), "SEND");
! 2419: num = 0;
! 2420: stream_reset (s);
! 2421: }
! 2422:
! 2423: /* Statistics updates. */
! 2424: ri->sent_updates++;
! 2425: }
! 2426:
! 2427: /* Send RIP packet to the interface. */
! 2428: static void
! 2429: rip_update_interface (struct connected *ifc, u_char version, int route_type)
! 2430: {
! 2431: struct sockaddr_in to;
! 2432:
! 2433: /* When RIP version is 2 and multicast enable interface. */
! 2434: if (version == RIPv2 && if_is_multicast (ifc->ifp))
! 2435: {
! 2436: if (IS_RIP_DEBUG_EVENT)
! 2437: zlog_debug ("multicast announce on %s ", ifc->ifp->name);
! 2438:
! 2439: rip_output_process (ifc, NULL, route_type, version);
! 2440: return;
! 2441: }
! 2442:
! 2443: /* If we can't send multicast packet, send it with unicast. */
! 2444: if (if_is_broadcast (ifc->ifp) || if_is_pointopoint (ifc->ifp))
! 2445: {
! 2446: if (ifc->address->family == AF_INET)
! 2447: {
! 2448: /* Destination address and port setting. */
! 2449: memset (&to, 0, sizeof (struct sockaddr_in));
! 2450: if (ifc->destination)
! 2451: /* use specified broadcast or peer destination addr */
! 2452: to.sin_addr = ifc->destination->u.prefix4;
! 2453: else if (ifc->address->prefixlen < IPV4_MAX_PREFIXLEN)
! 2454: /* calculate the appropriate broadcast address */
! 2455: to.sin_addr.s_addr =
! 2456: ipv4_broadcast_addr(ifc->address->u.prefix4.s_addr,
! 2457: ifc->address->prefixlen);
! 2458: else
! 2459: /* do not know where to send the packet */
! 2460: return;
! 2461: to.sin_port = htons (RIP_PORT_DEFAULT);
! 2462:
! 2463: if (IS_RIP_DEBUG_EVENT)
! 2464: zlog_debug("%s announce to %s on %s",
! 2465: CONNECTED_PEER(ifc) ? "unicast" : "broadcast",
! 2466: inet_ntoa (to.sin_addr), ifc->ifp->name);
! 2467:
! 2468: rip_output_process (ifc, &to, route_type, version);
! 2469: }
! 2470: }
! 2471: }
! 2472:
! 2473: /* Update send to all interface and neighbor. */
! 2474: static void
! 2475: rip_update_process (int route_type)
! 2476: {
! 2477: struct listnode *node;
! 2478: struct listnode *ifnode, *ifnnode;
! 2479: struct connected *connected;
! 2480: struct interface *ifp;
! 2481: struct rip_interface *ri;
! 2482: struct route_node *rp;
! 2483: struct sockaddr_in to;
! 2484: struct prefix_ipv4 *p;
! 2485:
! 2486: /* Send RIP update to each interface. */
! 2487: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 2488: {
! 2489: if (if_is_loopback (ifp))
! 2490: continue;
! 2491:
! 2492: if (! if_is_operative (ifp))
! 2493: continue;
! 2494:
! 2495: /* Fetch RIP interface information. */
! 2496: ri = ifp->info;
! 2497:
! 2498: /* When passive interface is specified, suppress announce to the
! 2499: interface. */
! 2500: if (ri->passive)
! 2501: continue;
! 2502:
! 2503: if (ri->running)
! 2504: {
! 2505: /*
! 2506: * If there is no version configuration in the interface,
! 2507: * use rip's version setting.
! 2508: */
! 2509: int vsend = ((ri->ri_send == RI_RIP_UNSPEC) ?
! 2510: rip->version_send : ri->ri_send);
! 2511:
! 2512: if (IS_RIP_DEBUG_EVENT)
! 2513: zlog_debug("SEND UPDATE to %s ifindex %d",
! 2514: (ifp->name ? ifp->name : "_unknown_"), ifp->ifindex);
! 2515:
! 2516: /* send update on each connected network */
! 2517: for (ALL_LIST_ELEMENTS (ifp->connected, ifnode, ifnnode, connected))
! 2518: {
! 2519: if (connected->address->family == AF_INET)
! 2520: {
! 2521: if (vsend & RIPv1)
! 2522: rip_update_interface (connected, RIPv1, route_type);
! 2523: if ((vsend & RIPv2) && if_is_multicast(ifp))
! 2524: rip_update_interface (connected, RIPv2, route_type);
! 2525: }
! 2526: }
! 2527: }
! 2528: }
! 2529:
! 2530: /* RIP send updates to each neighbor. */
! 2531: for (rp = route_top (rip->neighbor); rp; rp = route_next (rp))
! 2532: if (rp->info != NULL)
! 2533: {
! 2534: p = (struct prefix_ipv4 *) &rp->p;
! 2535:
! 2536: ifp = if_lookup_address (p->prefix);
! 2537: if (! ifp)
! 2538: {
! 2539: zlog_warn ("Neighbor %s doesnt have connected interface!",
! 2540: inet_ntoa (p->prefix));
! 2541: continue;
! 2542: }
! 2543:
! 2544: if ( (connected = connected_lookup_address (ifp, p->prefix)) == NULL)
! 2545: {
! 2546: zlog_warn ("Neighbor %s doesnt have connected network",
! 2547: inet_ntoa (p->prefix));
! 2548: continue;
! 2549: }
! 2550:
! 2551: /* Set destination address and port */
! 2552: memset (&to, 0, sizeof (struct sockaddr_in));
! 2553: to.sin_addr = p->prefix;
! 2554: to.sin_port = htons (RIP_PORT_DEFAULT);
! 2555:
! 2556: /* RIP version is rip's configuration. */
! 2557: rip_output_process (connected, &to, route_type, rip->version_send);
! 2558: }
! 2559: }
! 2560:
! 2561: /* RIP's periodical timer. */
! 2562: static int
! 2563: rip_update (struct thread *t)
! 2564: {
! 2565: /* Clear timer pointer. */
! 2566: rip->t_update = NULL;
! 2567:
! 2568: if (IS_RIP_DEBUG_EVENT)
! 2569: zlog_debug ("update timer fire!");
! 2570:
! 2571: /* Process update output. */
! 2572: rip_update_process (rip_all_route);
! 2573:
! 2574: /* Triggered updates may be suppressed if a regular update is due by
! 2575: the time the triggered update would be sent. */
! 2576: if (rip->t_triggered_interval)
! 2577: {
! 2578: thread_cancel (rip->t_triggered_interval);
! 2579: rip->t_triggered_interval = NULL;
! 2580: }
! 2581: rip->trigger = 0;
! 2582:
! 2583: /* Register myself. */
! 2584: rip_event (RIP_UPDATE_EVENT, 0);
! 2585:
! 2586: return 0;
! 2587: }
! 2588:
! 2589: /* Walk down the RIP routing table then clear changed flag. */
! 2590: static void
! 2591: rip_clear_changed_flag (void)
! 2592: {
! 2593: struct route_node *rp;
! 2594: struct rip_info *rinfo;
! 2595:
! 2596: for (rp = route_top (rip->table); rp; rp = route_next (rp))
! 2597: if ((rinfo = rp->info) != NULL)
! 2598: if (rinfo->flags & RIP_RTF_CHANGED)
! 2599: rinfo->flags &= ~RIP_RTF_CHANGED;
! 2600: }
! 2601:
! 2602: /* Triggered update interval timer. */
! 2603: static int
! 2604: rip_triggered_interval (struct thread *t)
! 2605: {
! 2606: int rip_triggered_update (struct thread *);
! 2607:
! 2608: rip->t_triggered_interval = NULL;
! 2609:
! 2610: if (rip->trigger)
! 2611: {
! 2612: rip->trigger = 0;
! 2613: rip_triggered_update (t);
! 2614: }
! 2615: return 0;
! 2616: }
! 2617:
! 2618: /* Execute triggered update. */
! 2619: static int
! 2620: rip_triggered_update (struct thread *t)
! 2621: {
! 2622: int interval;
! 2623:
! 2624: /* Clear thred pointer. */
! 2625: rip->t_triggered_update = NULL;
! 2626:
! 2627: /* Cancel interval timer. */
! 2628: if (rip->t_triggered_interval)
! 2629: {
! 2630: thread_cancel (rip->t_triggered_interval);
! 2631: rip->t_triggered_interval = NULL;
! 2632: }
! 2633: rip->trigger = 0;
! 2634:
! 2635: /* Logging triggered update. */
! 2636: if (IS_RIP_DEBUG_EVENT)
! 2637: zlog_debug ("triggered update!");
! 2638:
! 2639: /* Split Horizon processing is done when generating triggered
! 2640: updates as well as normal updates (see section 2.6). */
! 2641: rip_update_process (rip_changed_route);
! 2642:
! 2643: /* Once all of the triggered updates have been generated, the route
! 2644: change flags should be cleared. */
! 2645: rip_clear_changed_flag ();
! 2646:
! 2647: /* After a triggered update is sent, a timer should be set for a
! 2648: random interval between 1 and 5 seconds. If other changes that
! 2649: would trigger updates occur before the timer expires, a single
! 2650: update is triggered when the timer expires. */
! 2651: interval = (random () % 5) + 1;
! 2652:
! 2653: rip->t_triggered_interval =
! 2654: thread_add_timer (master, rip_triggered_interval, NULL, interval);
! 2655:
! 2656: return 0;
! 2657: }
! 2658:
! 2659: /* Withdraw redistributed route. */
! 2660: void
! 2661: rip_redistribute_withdraw (int type)
! 2662: {
! 2663: struct route_node *rp;
! 2664: struct rip_info *rinfo;
! 2665:
! 2666: if (!rip)
! 2667: return;
! 2668:
! 2669: for (rp = route_top (rip->table); rp; rp = route_next (rp))
! 2670: if ((rinfo = rp->info) != NULL)
! 2671: {
! 2672: if (rinfo->type == type
! 2673: && rinfo->sub_type != RIP_ROUTE_INTERFACE)
! 2674: {
! 2675: /* Perform poisoned reverse. */
! 2676: rinfo->metric = RIP_METRIC_INFINITY;
! 2677: RIP_TIMER_ON (rinfo->t_garbage_collect,
! 2678: rip_garbage_collect, rip->garbage_time);
! 2679: RIP_TIMER_OFF (rinfo->t_timeout);
! 2680: rinfo->flags |= RIP_RTF_CHANGED;
! 2681:
! 2682: if (IS_RIP_DEBUG_EVENT) {
! 2683: struct prefix_ipv4 *p = (struct prefix_ipv4 *) &rp->p;
! 2684:
! 2685: zlog_debug ("Poisone %s/%d on the interface %s with an infinity metric [withdraw]",
! 2686: inet_ntoa(p->prefix), p->prefixlen,
! 2687: ifindex2ifname(rinfo->ifindex));
! 2688: }
! 2689:
! 2690: rip_event (RIP_TRIGGERED_UPDATE, 0);
! 2691: }
! 2692: }
! 2693: }
! 2694:
! 2695: /* Create new RIP instance and set it to global variable. */
! 2696: static int
! 2697: rip_create (void)
! 2698: {
! 2699: rip = XCALLOC (MTYPE_RIP, sizeof (struct rip));
! 2700:
! 2701: /* Set initial value. */
! 2702: rip->version_send = RI_RIP_VERSION_2;
! 2703: rip->version_recv = RI_RIP_VERSION_1_AND_2;
! 2704: rip->update_time = RIP_UPDATE_TIMER_DEFAULT;
! 2705: rip->timeout_time = RIP_TIMEOUT_TIMER_DEFAULT;
! 2706: rip->garbage_time = RIP_GARBAGE_TIMER_DEFAULT;
! 2707: rip->default_metric = RIP_DEFAULT_METRIC_DEFAULT;
! 2708:
! 2709: /* Initialize RIP routig table. */
! 2710: rip->table = route_table_init ();
! 2711: rip->route = route_table_init ();
! 2712: rip->neighbor = route_table_init ();
! 2713:
! 2714: /* Make output stream. */
! 2715: rip->obuf = stream_new (1500);
! 2716:
! 2717: /* Make socket. */
! 2718: rip->sock = rip_create_socket (NULL);
! 2719: if (rip->sock < 0)
! 2720: return rip->sock;
! 2721:
! 2722: /* Create read and timer thread. */
! 2723: rip_event (RIP_READ, rip->sock);
! 2724: rip_event (RIP_UPDATE_EVENT, 1);
! 2725:
! 2726: return 0;
! 2727: }
! 2728:
! 2729: /* Sned RIP request to the destination. */
! 2730: int
! 2731: rip_request_send (struct sockaddr_in *to, struct interface *ifp,
! 2732: u_char version, struct connected *connected)
! 2733: {
! 2734: struct rte *rte;
! 2735: struct rip_packet rip_packet;
! 2736: struct listnode *node, *nnode;
! 2737:
! 2738: memset (&rip_packet, 0, sizeof (rip_packet));
! 2739:
! 2740: rip_packet.command = RIP_REQUEST;
! 2741: rip_packet.version = version;
! 2742: rte = rip_packet.rte;
! 2743: rte->metric = htonl (RIP_METRIC_INFINITY);
! 2744:
! 2745: if (connected)
! 2746: {
! 2747: /*
! 2748: * connected is only sent for ripv1 case, or when
! 2749: * interface does not support multicast. Caller loops
! 2750: * over each connected address for this case.
! 2751: */
! 2752: if (rip_send_packet ((u_char *) &rip_packet, sizeof (rip_packet),
! 2753: to, connected) != sizeof (rip_packet))
! 2754: return -1;
! 2755: else
! 2756: return sizeof (rip_packet);
! 2757: }
! 2758:
! 2759: /* send request on each connected network */
! 2760: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, connected))
! 2761: {
! 2762: struct prefix_ipv4 *p;
! 2763:
! 2764: p = (struct prefix_ipv4 *) connected->address;
! 2765:
! 2766: if (p->family != AF_INET)
! 2767: continue;
! 2768:
! 2769: if (rip_send_packet ((u_char *) &rip_packet, sizeof (rip_packet),
! 2770: to, connected) != sizeof (rip_packet))
! 2771: return -1;
! 2772: }
! 2773: return sizeof (rip_packet);
! 2774: }
! 2775:
! 2776: static int
! 2777: rip_update_jitter (unsigned long time)
! 2778: {
! 2779: #define JITTER_BOUND 4
! 2780: /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
! 2781: Given that, we cannot let time be less than JITTER_BOUND seconds.
! 2782: The RIPv2 RFC says jitter should be small compared to
! 2783: update_time. We consider 1/JITTER_BOUND to be small.
! 2784: */
! 2785:
! 2786: int jitter_input = time;
! 2787: int jitter;
! 2788:
! 2789: if (jitter_input < JITTER_BOUND)
! 2790: jitter_input = JITTER_BOUND;
! 2791:
! 2792: jitter = (((rand () % ((jitter_input * 2) + 1)) - jitter_input));
! 2793:
! 2794: return jitter/JITTER_BOUND;
! 2795: }
! 2796:
! 2797: void
! 2798: rip_event (enum rip_event event, int sock)
! 2799: {
! 2800: int jitter = 0;
! 2801:
! 2802: switch (event)
! 2803: {
! 2804: case RIP_READ:
! 2805: rip->t_read = thread_add_read (master, rip_read, NULL, sock);
! 2806: break;
! 2807: case RIP_UPDATE_EVENT:
! 2808: if (rip->t_update)
! 2809: {
! 2810: thread_cancel (rip->t_update);
! 2811: rip->t_update = NULL;
! 2812: }
! 2813: jitter = rip_update_jitter (rip->update_time);
! 2814: rip->t_update =
! 2815: thread_add_timer (master, rip_update, NULL,
! 2816: sock ? 2 : rip->update_time + jitter);
! 2817: break;
! 2818: case RIP_TRIGGERED_UPDATE:
! 2819: if (rip->t_triggered_interval)
! 2820: rip->trigger = 1;
! 2821: else if (! rip->t_triggered_update)
! 2822: rip->t_triggered_update =
! 2823: thread_add_event (master, rip_triggered_update, NULL, 0);
! 2824: break;
! 2825: default:
! 2826: break;
! 2827: }
! 2828: }
! 2829:
! 2830: DEFUN (router_rip,
! 2831: router_rip_cmd,
! 2832: "router rip",
! 2833: "Enable a routing process\n"
! 2834: "Routing Information Protocol (RIP)\n")
! 2835: {
! 2836: int ret;
! 2837:
! 2838: /* If rip is not enabled before. */
! 2839: if (! rip)
! 2840: {
! 2841: ret = rip_create ();
! 2842: if (ret < 0)
! 2843: {
! 2844: zlog_info ("Can't create RIP");
! 2845: return CMD_WARNING;
! 2846: }
! 2847: }
! 2848: vty->node = RIP_NODE;
! 2849: vty->index = rip;
! 2850:
! 2851: return CMD_SUCCESS;
! 2852: }
! 2853:
! 2854: DEFUN (no_router_rip,
! 2855: no_router_rip_cmd,
! 2856: "no router rip",
! 2857: NO_STR
! 2858: "Enable a routing process\n"
! 2859: "Routing Information Protocol (RIP)\n")
! 2860: {
! 2861: if (rip)
! 2862: rip_clean ();
! 2863: return CMD_SUCCESS;
! 2864: }
! 2865:
! 2866: DEFUN (rip_version,
! 2867: rip_version_cmd,
! 2868: "version <1-2>",
! 2869: "Set routing protocol version\n"
! 2870: "version\n")
! 2871: {
! 2872: int version;
! 2873:
! 2874: version = atoi (argv[0]);
! 2875: if (version != RIPv1 && version != RIPv2)
! 2876: {
! 2877: vty_out (vty, "invalid rip version %d%s", version,
! 2878: VTY_NEWLINE);
! 2879: return CMD_WARNING;
! 2880: }
! 2881: rip->version_send = version;
! 2882: rip->version_recv = version;
! 2883:
! 2884: return CMD_SUCCESS;
! 2885: }
! 2886:
! 2887: DEFUN (no_rip_version,
! 2888: no_rip_version_cmd,
! 2889: "no version",
! 2890: NO_STR
! 2891: "Set routing protocol version\n")
! 2892: {
! 2893: /* Set RIP version to the default. */
! 2894: rip->version_send = RI_RIP_VERSION_2;
! 2895: rip->version_recv = RI_RIP_VERSION_1_AND_2;
! 2896:
! 2897: return CMD_SUCCESS;
! 2898: }
! 2899:
! 2900: ALIAS (no_rip_version,
! 2901: no_rip_version_val_cmd,
! 2902: "no version <1-2>",
! 2903: NO_STR
! 2904: "Set routing protocol version\n"
! 2905: "version\n")
! 2906:
! 2907: DEFUN (rip_route,
! 2908: rip_route_cmd,
! 2909: "route A.B.C.D/M",
! 2910: "RIP static route configuration\n"
! 2911: "IP prefix <network>/<length>\n")
! 2912: {
! 2913: int ret;
! 2914: struct prefix_ipv4 p;
! 2915: struct route_node *node;
! 2916:
! 2917: ret = str2prefix_ipv4 (argv[0], &p);
! 2918: if (ret < 0)
! 2919: {
! 2920: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2921: return CMD_WARNING;
! 2922: }
! 2923: apply_mask_ipv4 (&p);
! 2924:
! 2925: /* For router rip configuration. */
! 2926: node = route_node_get (rip->route, (struct prefix *) &p);
! 2927:
! 2928: if (node->info)
! 2929: {
! 2930: vty_out (vty, "There is already same static route.%s", VTY_NEWLINE);
! 2931: route_unlock_node (node);
! 2932: return CMD_WARNING;
! 2933: }
! 2934:
! 2935: node->info = (char *)"static";
! 2936:
! 2937: rip_redistribute_add (ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, 0, NULL, 0, 0);
! 2938:
! 2939: return CMD_SUCCESS;
! 2940: }
! 2941:
! 2942: DEFUN (no_rip_route,
! 2943: no_rip_route_cmd,
! 2944: "no route A.B.C.D/M",
! 2945: NO_STR
! 2946: "RIP static route configuration\n"
! 2947: "IP prefix <network>/<length>\n")
! 2948: {
! 2949: int ret;
! 2950: struct prefix_ipv4 p;
! 2951: struct route_node *node;
! 2952:
! 2953: ret = str2prefix_ipv4 (argv[0], &p);
! 2954: if (ret < 0)
! 2955: {
! 2956: vty_out (vty, "Malformed address%s", VTY_NEWLINE);
! 2957: return CMD_WARNING;
! 2958: }
! 2959: apply_mask_ipv4 (&p);
! 2960:
! 2961: /* For router rip configuration. */
! 2962: node = route_node_lookup (rip->route, (struct prefix *) &p);
! 2963: if (! node)
! 2964: {
! 2965: vty_out (vty, "Can't find route %s.%s", argv[0],
! 2966: VTY_NEWLINE);
! 2967: return CMD_WARNING;
! 2968: }
! 2969:
! 2970: rip_redistribute_delete (ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, 0);
! 2971: route_unlock_node (node);
! 2972:
! 2973: node->info = NULL;
! 2974: route_unlock_node (node);
! 2975:
! 2976: return CMD_SUCCESS;
! 2977: }
! 2978:
! 2979: #if 0
! 2980: static void
! 2981: rip_update_default_metric (void)
! 2982: {
! 2983: struct route_node *np;
! 2984: struct rip_info *rinfo;
! 2985:
! 2986: for (np = route_top (rip->table); np; np = route_next (np))
! 2987: if ((rinfo = np->info) != NULL)
! 2988: if (rinfo->type != ZEBRA_ROUTE_RIP && rinfo->type != ZEBRA_ROUTE_CONNECT)
! 2989: rinfo->metric = rip->default_metric;
! 2990: }
! 2991: #endif
! 2992:
! 2993: DEFUN (rip_default_metric,
! 2994: rip_default_metric_cmd,
! 2995: "default-metric <1-16>",
! 2996: "Set a metric of redistribute routes\n"
! 2997: "Default metric\n")
! 2998: {
! 2999: if (rip)
! 3000: {
! 3001: rip->default_metric = atoi (argv[0]);
! 3002: /* rip_update_default_metric (); */
! 3003: }
! 3004: return CMD_SUCCESS;
! 3005: }
! 3006:
! 3007: DEFUN (no_rip_default_metric,
! 3008: no_rip_default_metric_cmd,
! 3009: "no default-metric",
! 3010: NO_STR
! 3011: "Set a metric of redistribute routes\n"
! 3012: "Default metric\n")
! 3013: {
! 3014: if (rip)
! 3015: {
! 3016: rip->default_metric = RIP_DEFAULT_METRIC_DEFAULT;
! 3017: /* rip_update_default_metric (); */
! 3018: }
! 3019: return CMD_SUCCESS;
! 3020: }
! 3021:
! 3022: ALIAS (no_rip_default_metric,
! 3023: no_rip_default_metric_val_cmd,
! 3024: "no default-metric <1-16>",
! 3025: NO_STR
! 3026: "Set a metric of redistribute routes\n"
! 3027: "Default metric\n")
! 3028:
! 3029: DEFUN (rip_timers,
! 3030: rip_timers_cmd,
! 3031: "timers basic <5-2147483647> <5-2147483647> <5-2147483647>",
! 3032: "Adjust routing timers\n"
! 3033: "Basic routing protocol update timers\n"
! 3034: "Routing table update timer value in second. Default is 30.\n"
! 3035: "Routing information timeout timer. Default is 180.\n"
! 3036: "Garbage collection timer. Default is 120.\n")
! 3037: {
! 3038: unsigned long update;
! 3039: unsigned long timeout;
! 3040: unsigned long garbage;
! 3041: char *endptr = NULL;
! 3042: unsigned long RIP_TIMER_MAX = 2147483647;
! 3043: unsigned long RIP_TIMER_MIN = 5;
! 3044:
! 3045: update = strtoul (argv[0], &endptr, 10);
! 3046: if (update > RIP_TIMER_MAX || update < RIP_TIMER_MIN || *endptr != '\0')
! 3047: {
! 3048: vty_out (vty, "update timer value error%s", VTY_NEWLINE);
! 3049: return CMD_WARNING;
! 3050: }
! 3051:
! 3052: timeout = strtoul (argv[1], &endptr, 10);
! 3053: if (timeout > RIP_TIMER_MAX || timeout < RIP_TIMER_MIN || *endptr != '\0')
! 3054: {
! 3055: vty_out (vty, "timeout timer value error%s", VTY_NEWLINE);
! 3056: return CMD_WARNING;
! 3057: }
! 3058:
! 3059: garbage = strtoul (argv[2], &endptr, 10);
! 3060: if (garbage > RIP_TIMER_MAX || garbage < RIP_TIMER_MIN || *endptr != '\0')
! 3061: {
! 3062: vty_out (vty, "garbage timer value error%s", VTY_NEWLINE);
! 3063: return CMD_WARNING;
! 3064: }
! 3065:
! 3066: /* Set each timer value. */
! 3067: rip->update_time = update;
! 3068: rip->timeout_time = timeout;
! 3069: rip->garbage_time = garbage;
! 3070:
! 3071: /* Reset update timer thread. */
! 3072: rip_event (RIP_UPDATE_EVENT, 0);
! 3073:
! 3074: return CMD_SUCCESS;
! 3075: }
! 3076:
! 3077: DEFUN (no_rip_timers,
! 3078: no_rip_timers_cmd,
! 3079: "no timers basic",
! 3080: NO_STR
! 3081: "Adjust routing timers\n"
! 3082: "Basic routing protocol update timers\n")
! 3083: {
! 3084: /* Set each timer value to the default. */
! 3085: rip->update_time = RIP_UPDATE_TIMER_DEFAULT;
! 3086: rip->timeout_time = RIP_TIMEOUT_TIMER_DEFAULT;
! 3087: rip->garbage_time = RIP_GARBAGE_TIMER_DEFAULT;
! 3088:
! 3089: /* Reset update timer thread. */
! 3090: rip_event (RIP_UPDATE_EVENT, 0);
! 3091:
! 3092: return CMD_SUCCESS;
! 3093: }
! 3094:
! 3095: ALIAS (no_rip_timers,
! 3096: no_rip_timers_val_cmd,
! 3097: "no timers basic <0-65535> <0-65535> <0-65535>",
! 3098: NO_STR
! 3099: "Adjust routing timers\n"
! 3100: "Basic routing protocol update timers\n"
! 3101: "Routing table update timer value in second. Default is 30.\n"
! 3102: "Routing information timeout timer. Default is 180.\n"
! 3103: "Garbage collection timer. Default is 120.\n")
! 3104:
! 3105:
! 3106: struct route_table *rip_distance_table;
! 3107:
! 3108: struct rip_distance
! 3109: {
! 3110: /* Distance value for the IP source prefix. */
! 3111: u_char distance;
! 3112:
! 3113: /* Name of the access-list to be matched. */
! 3114: char *access_list;
! 3115: };
! 3116:
! 3117: static struct rip_distance *
! 3118: rip_distance_new (void)
! 3119: {
! 3120: return XCALLOC (MTYPE_RIP_DISTANCE, sizeof (struct rip_distance));
! 3121: }
! 3122:
! 3123: static void
! 3124: rip_distance_free (struct rip_distance *rdistance)
! 3125: {
! 3126: XFREE (MTYPE_RIP_DISTANCE, rdistance);
! 3127: }
! 3128:
! 3129: static int
! 3130: rip_distance_set (struct vty *vty, const char *distance_str, const char *ip_str,
! 3131: const char *access_list_str)
! 3132: {
! 3133: int ret;
! 3134: struct prefix_ipv4 p;
! 3135: u_char distance;
! 3136: struct route_node *rn;
! 3137: struct rip_distance *rdistance;
! 3138:
! 3139: ret = str2prefix_ipv4 (ip_str, &p);
! 3140: if (ret == 0)
! 3141: {
! 3142: vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
! 3143: return CMD_WARNING;
! 3144: }
! 3145:
! 3146: distance = atoi (distance_str);
! 3147:
! 3148: /* Get RIP distance node. */
! 3149: rn = route_node_get (rip_distance_table, (struct prefix *) &p);
! 3150: if (rn->info)
! 3151: {
! 3152: rdistance = rn->info;
! 3153: route_unlock_node (rn);
! 3154: }
! 3155: else
! 3156: {
! 3157: rdistance = rip_distance_new ();
! 3158: rn->info = rdistance;
! 3159: }
! 3160:
! 3161: /* Set distance value. */
! 3162: rdistance->distance = distance;
! 3163:
! 3164: /* Reset access-list configuration. */
! 3165: if (rdistance->access_list)
! 3166: {
! 3167: free (rdistance->access_list);
! 3168: rdistance->access_list = NULL;
! 3169: }
! 3170: if (access_list_str)
! 3171: rdistance->access_list = strdup (access_list_str);
! 3172:
! 3173: return CMD_SUCCESS;
! 3174: }
! 3175:
! 3176: static int
! 3177: rip_distance_unset (struct vty *vty, const char *distance_str,
! 3178: const char *ip_str, const char *access_list_str)
! 3179: {
! 3180: int ret;
! 3181: struct prefix_ipv4 p;
! 3182: u_char distance;
! 3183: struct route_node *rn;
! 3184: struct rip_distance *rdistance;
! 3185:
! 3186: ret = str2prefix_ipv4 (ip_str, &p);
! 3187: if (ret == 0)
! 3188: {
! 3189: vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
! 3190: return CMD_WARNING;
! 3191: }
! 3192:
! 3193: distance = atoi (distance_str);
! 3194:
! 3195: rn = route_node_lookup (rip_distance_table, (struct prefix *)&p);
! 3196: if (! rn)
! 3197: {
! 3198: vty_out (vty, "Can't find specified prefix%s", VTY_NEWLINE);
! 3199: return CMD_WARNING;
! 3200: }
! 3201:
! 3202: rdistance = rn->info;
! 3203:
! 3204: if (rdistance->access_list)
! 3205: free (rdistance->access_list);
! 3206: rip_distance_free (rdistance);
! 3207:
! 3208: rn->info = NULL;
! 3209: route_unlock_node (rn);
! 3210: route_unlock_node (rn);
! 3211:
! 3212: return CMD_SUCCESS;
! 3213: }
! 3214:
! 3215: static void
! 3216: rip_distance_reset (void)
! 3217: {
! 3218: struct route_node *rn;
! 3219: struct rip_distance *rdistance;
! 3220:
! 3221: for (rn = route_top (rip_distance_table); rn; rn = route_next (rn))
! 3222: if ((rdistance = rn->info) != NULL)
! 3223: {
! 3224: if (rdistance->access_list)
! 3225: free (rdistance->access_list);
! 3226: rip_distance_free (rdistance);
! 3227: rn->info = NULL;
! 3228: route_unlock_node (rn);
! 3229: }
! 3230: }
! 3231:
! 3232: /* Apply RIP information to distance method. */
! 3233: u_char
! 3234: rip_distance_apply (struct rip_info *rinfo)
! 3235: {
! 3236: struct route_node *rn;
! 3237: struct prefix_ipv4 p;
! 3238: struct rip_distance *rdistance;
! 3239: struct access_list *alist;
! 3240:
! 3241: if (! rip)
! 3242: return 0;
! 3243:
! 3244: memset (&p, 0, sizeof (struct prefix_ipv4));
! 3245: p.family = AF_INET;
! 3246: p.prefix = rinfo->from;
! 3247: p.prefixlen = IPV4_MAX_BITLEN;
! 3248:
! 3249: /* Check source address. */
! 3250: rn = route_node_match (rip_distance_table, (struct prefix *) &p);
! 3251: if (rn)
! 3252: {
! 3253: rdistance = rn->info;
! 3254: route_unlock_node (rn);
! 3255:
! 3256: if (rdistance->access_list)
! 3257: {
! 3258: alist = access_list_lookup (AFI_IP, rdistance->access_list);
! 3259: if (alist == NULL)
! 3260: return 0;
! 3261: if (access_list_apply (alist, &rinfo->rp->p) == FILTER_DENY)
! 3262: return 0;
! 3263:
! 3264: return rdistance->distance;
! 3265: }
! 3266: else
! 3267: return rdistance->distance;
! 3268: }
! 3269:
! 3270: if (rip->distance)
! 3271: return rip->distance;
! 3272:
! 3273: return 0;
! 3274: }
! 3275:
! 3276: static void
! 3277: rip_distance_show (struct vty *vty)
! 3278: {
! 3279: struct route_node *rn;
! 3280: struct rip_distance *rdistance;
! 3281: int header = 1;
! 3282: char buf[BUFSIZ];
! 3283:
! 3284: vty_out (vty, " Distance: (default is %d)%s",
! 3285: rip->distance ? rip->distance :ZEBRA_RIP_DISTANCE_DEFAULT,
! 3286: VTY_NEWLINE);
! 3287:
! 3288: for (rn = route_top (rip_distance_table); rn; rn = route_next (rn))
! 3289: if ((rdistance = rn->info) != NULL)
! 3290: {
! 3291: if (header)
! 3292: {
! 3293: vty_out (vty, " Address Distance List%s",
! 3294: VTY_NEWLINE);
! 3295: header = 0;
! 3296: }
! 3297: sprintf (buf, "%s/%d", inet_ntoa (rn->p.u.prefix4), rn->p.prefixlen);
! 3298: vty_out (vty, " %-20s %4d %s%s",
! 3299: buf, rdistance->distance,
! 3300: rdistance->access_list ? rdistance->access_list : "",
! 3301: VTY_NEWLINE);
! 3302: }
! 3303: }
! 3304:
! 3305: DEFUN (rip_distance,
! 3306: rip_distance_cmd,
! 3307: "distance <1-255>",
! 3308: "Administrative distance\n"
! 3309: "Distance value\n")
! 3310: {
! 3311: rip->distance = atoi (argv[0]);
! 3312: return CMD_SUCCESS;
! 3313: }
! 3314:
! 3315: DEFUN (no_rip_distance,
! 3316: no_rip_distance_cmd,
! 3317: "no distance <1-255>",
! 3318: NO_STR
! 3319: "Administrative distance\n"
! 3320: "Distance value\n")
! 3321: {
! 3322: rip->distance = 0;
! 3323: return CMD_SUCCESS;
! 3324: }
! 3325:
! 3326: DEFUN (rip_distance_source,
! 3327: rip_distance_source_cmd,
! 3328: "distance <1-255> A.B.C.D/M",
! 3329: "Administrative distance\n"
! 3330: "Distance value\n"
! 3331: "IP source prefix\n")
! 3332: {
! 3333: rip_distance_set (vty, argv[0], argv[1], NULL);
! 3334: return CMD_SUCCESS;
! 3335: }
! 3336:
! 3337: DEFUN (no_rip_distance_source,
! 3338: no_rip_distance_source_cmd,
! 3339: "no distance <1-255> A.B.C.D/M",
! 3340: NO_STR
! 3341: "Administrative distance\n"
! 3342: "Distance value\n"
! 3343: "IP source prefix\n")
! 3344: {
! 3345: rip_distance_unset (vty, argv[0], argv[1], NULL);
! 3346: return CMD_SUCCESS;
! 3347: }
! 3348:
! 3349: DEFUN (rip_distance_source_access_list,
! 3350: rip_distance_source_access_list_cmd,
! 3351: "distance <1-255> A.B.C.D/M WORD",
! 3352: "Administrative distance\n"
! 3353: "Distance value\n"
! 3354: "IP source prefix\n"
! 3355: "Access list name\n")
! 3356: {
! 3357: rip_distance_set (vty, argv[0], argv[1], argv[2]);
! 3358: return CMD_SUCCESS;
! 3359: }
! 3360:
! 3361: DEFUN (no_rip_distance_source_access_list,
! 3362: no_rip_distance_source_access_list_cmd,
! 3363: "no distance <1-255> A.B.C.D/M WORD",
! 3364: NO_STR
! 3365: "Administrative distance\n"
! 3366: "Distance value\n"
! 3367: "IP source prefix\n"
! 3368: "Access list name\n")
! 3369: {
! 3370: rip_distance_unset (vty, argv[0], argv[1], argv[2]);
! 3371: return CMD_SUCCESS;
! 3372: }
! 3373:
! 3374: /* Print out routes update time. */
! 3375: static void
! 3376: rip_vty_out_uptime (struct vty *vty, struct rip_info *rinfo)
! 3377: {
! 3378: time_t clock;
! 3379: struct tm *tm;
! 3380: #define TIME_BUF 25
! 3381: char timebuf [TIME_BUF];
! 3382: struct thread *thread;
! 3383:
! 3384: if ((thread = rinfo->t_timeout) != NULL)
! 3385: {
! 3386: clock = thread_timer_remain_second (thread);
! 3387: tm = gmtime (&clock);
! 3388: strftime (timebuf, TIME_BUF, "%M:%S", tm);
! 3389: vty_out (vty, "%5s", timebuf);
! 3390: }
! 3391: else if ((thread = rinfo->t_garbage_collect) != NULL)
! 3392: {
! 3393: clock = thread_timer_remain_second (thread);
! 3394: tm = gmtime (&clock);
! 3395: strftime (timebuf, TIME_BUF, "%M:%S", tm);
! 3396: vty_out (vty, "%5s", timebuf);
! 3397: }
! 3398: }
! 3399:
! 3400: static const char *
! 3401: rip_route_type_print (int sub_type)
! 3402: {
! 3403: switch (sub_type)
! 3404: {
! 3405: case RIP_ROUTE_RTE:
! 3406: return "n";
! 3407: case RIP_ROUTE_STATIC:
! 3408: return "s";
! 3409: case RIP_ROUTE_DEFAULT:
! 3410: return "d";
! 3411: case RIP_ROUTE_REDISTRIBUTE:
! 3412: return "r";
! 3413: case RIP_ROUTE_INTERFACE:
! 3414: return "i";
! 3415: default:
! 3416: return "?";
! 3417: }
! 3418: }
! 3419:
! 3420: DEFUN (show_ip_rip,
! 3421: show_ip_rip_cmd,
! 3422: "show ip rip",
! 3423: SHOW_STR
! 3424: IP_STR
! 3425: "Show RIP routes\n")
! 3426: {
! 3427: struct route_node *np;
! 3428: struct rip_info *rinfo;
! 3429:
! 3430: if (! rip)
! 3431: return CMD_SUCCESS;
! 3432:
! 3433: vty_out (vty, "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP%s"
! 3434: "Sub-codes:%s"
! 3435: " (n) - normal, (s) - static, (d) - default, (r) - redistribute,%s"
! 3436: " (i) - interface%s%s"
! 3437: " Network Next Hop Metric From Tag Time%s",
! 3438: VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
! 3439:
! 3440: for (np = route_top (rip->table); np; np = route_next (np))
! 3441: if ((rinfo = np->info) != NULL)
! 3442: {
! 3443: int len;
! 3444:
! 3445: len = vty_out (vty, "%c(%s) %s/%d",
! 3446: /* np->lock, For debugging. */
! 3447: zebra_route_char(rinfo->type),
! 3448: rip_route_type_print (rinfo->sub_type),
! 3449: inet_ntoa (np->p.u.prefix4), np->p.prefixlen);
! 3450:
! 3451: len = 24 - len;
! 3452:
! 3453: if (len > 0)
! 3454: vty_out (vty, "%*s", len, " ");
! 3455:
! 3456: if (rinfo->nexthop.s_addr)
! 3457: vty_out (vty, "%-20s %2d ", inet_ntoa (rinfo->nexthop),
! 3458: rinfo->metric);
! 3459: else
! 3460: vty_out (vty, "0.0.0.0 %2d ", rinfo->metric);
! 3461:
! 3462: /* Route which exist in kernel routing table. */
! 3463: if ((rinfo->type == ZEBRA_ROUTE_RIP) &&
! 3464: (rinfo->sub_type == RIP_ROUTE_RTE))
! 3465: {
! 3466: vty_out (vty, "%-15s ", inet_ntoa (rinfo->from));
! 3467: vty_out (vty, "%3d ", rinfo->tag);
! 3468: rip_vty_out_uptime (vty, rinfo);
! 3469: }
! 3470: else if (rinfo->metric == RIP_METRIC_INFINITY)
! 3471: {
! 3472: vty_out (vty, "self ");
! 3473: vty_out (vty, "%3d ", rinfo->tag);
! 3474: rip_vty_out_uptime (vty, rinfo);
! 3475: }
! 3476: else
! 3477: {
! 3478: if (rinfo->external_metric)
! 3479: {
! 3480: len = vty_out (vty, "self (%s:%d)",
! 3481: zebra_route_string(rinfo->type),
! 3482: rinfo->external_metric);
! 3483: len = 16 - len;
! 3484: if (len > 0)
! 3485: vty_out (vty, "%*s", len, " ");
! 3486: }
! 3487: else
! 3488: vty_out (vty, "self ");
! 3489: vty_out (vty, "%3d", rinfo->tag);
! 3490: }
! 3491:
! 3492: vty_out (vty, "%s", VTY_NEWLINE);
! 3493: }
! 3494: return CMD_SUCCESS;
! 3495: }
! 3496:
! 3497: /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
! 3498: DEFUN (show_ip_rip_status,
! 3499: show_ip_rip_status_cmd,
! 3500: "show ip rip status",
! 3501: SHOW_STR
! 3502: IP_STR
! 3503: "Show RIP routes\n"
! 3504: "IP routing protocol process parameters and statistics\n")
! 3505: {
! 3506: struct listnode *node;
! 3507: struct interface *ifp;
! 3508: struct rip_interface *ri;
! 3509: extern const struct message ri_version_msg[];
! 3510: const char *send_version;
! 3511: const char *receive_version;
! 3512:
! 3513: if (! rip)
! 3514: return CMD_SUCCESS;
! 3515:
! 3516: vty_out (vty, "Routing Protocol is \"rip\"%s", VTY_NEWLINE);
! 3517: vty_out (vty, " Sending updates every %ld seconds with +/-50%%,",
! 3518: rip->update_time);
! 3519: vty_out (vty, " next due in %lu seconds%s",
! 3520: thread_timer_remain_second(rip->t_update),
! 3521: VTY_NEWLINE);
! 3522: vty_out (vty, " Timeout after %ld seconds,", rip->timeout_time);
! 3523: vty_out (vty, " garbage collect after %ld seconds%s", rip->garbage_time,
! 3524: VTY_NEWLINE);
! 3525:
! 3526: /* Filtering status show. */
! 3527: config_show_distribute (vty);
! 3528:
! 3529: /* Default metric information. */
! 3530: vty_out (vty, " Default redistribution metric is %d%s",
! 3531: rip->default_metric, VTY_NEWLINE);
! 3532:
! 3533: /* Redistribute information. */
! 3534: vty_out (vty, " Redistributing:");
! 3535: config_write_rip_redistribute (vty, 0);
! 3536: vty_out (vty, "%s", VTY_NEWLINE);
! 3537:
! 3538: vty_out (vty, " Default version control: send version %s,",
! 3539: lookup(ri_version_msg,rip->version_send));
! 3540: if (rip->version_recv == RI_RIP_VERSION_1_AND_2)
! 3541: vty_out (vty, " receive any version %s", VTY_NEWLINE);
! 3542: else
! 3543: vty_out (vty, " receive version %s %s",
! 3544: lookup(ri_version_msg,rip->version_recv), VTY_NEWLINE);
! 3545:
! 3546: vty_out (vty, " Interface Send Recv Key-chain%s", VTY_NEWLINE);
! 3547:
! 3548: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 3549: {
! 3550: ri = ifp->info;
! 3551:
! 3552: if (!ri->running)
! 3553: continue;
! 3554:
! 3555: if (ri->enable_network || ri->enable_interface)
! 3556: {
! 3557: if (ri->ri_send == RI_RIP_UNSPEC)
! 3558: send_version = lookup (ri_version_msg, rip->version_send);
! 3559: else
! 3560: send_version = lookup (ri_version_msg, ri->ri_send);
! 3561:
! 3562: if (ri->ri_receive == RI_RIP_UNSPEC)
! 3563: receive_version = lookup (ri_version_msg, rip->version_recv);
! 3564: else
! 3565: receive_version = lookup (ri_version_msg, ri->ri_receive);
! 3566:
! 3567: vty_out (vty, " %-17s%-3s %-3s %s%s", ifp->name,
! 3568: send_version,
! 3569: receive_version,
! 3570: ri->key_chain ? ri->key_chain : "",
! 3571: VTY_NEWLINE);
! 3572: }
! 3573: }
! 3574:
! 3575: vty_out (vty, " Routing for Networks:%s", VTY_NEWLINE);
! 3576: config_write_rip_network (vty, 0);
! 3577:
! 3578: {
! 3579: int found_passive = 0;
! 3580: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 3581: {
! 3582: ri = ifp->info;
! 3583:
! 3584: if ((ri->enable_network || ri->enable_interface) && ri->passive)
! 3585: {
! 3586: if (!found_passive)
! 3587: {
! 3588: vty_out (vty, " Passive Interface(s):%s", VTY_NEWLINE);
! 3589: found_passive = 1;
! 3590: }
! 3591: vty_out (vty, " %s%s", ifp->name, VTY_NEWLINE);
! 3592: }
! 3593: }
! 3594: }
! 3595:
! 3596: vty_out (vty, " Routing Information Sources:%s", VTY_NEWLINE);
! 3597: vty_out (vty, " Gateway BadPackets BadRoutes Distance Last Update%s", VTY_NEWLINE);
! 3598: rip_peer_display (vty);
! 3599:
! 3600: rip_distance_show (vty);
! 3601:
! 3602: return CMD_SUCCESS;
! 3603: }
! 3604:
! 3605: /* RIP configuration write function. */
! 3606: static int
! 3607: config_write_rip (struct vty *vty)
! 3608: {
! 3609: int write = 0;
! 3610: struct route_node *rn;
! 3611: struct rip_distance *rdistance;
! 3612:
! 3613: if (rip)
! 3614: {
! 3615: /* Router RIP statement. */
! 3616: vty_out (vty, "router rip%s", VTY_NEWLINE);
! 3617: write++;
! 3618:
! 3619: /* RIP version statement. Default is RIP version 2. */
! 3620: if (rip->version_send != RI_RIP_VERSION_2
! 3621: || rip->version_recv != RI_RIP_VERSION_1_AND_2)
! 3622: vty_out (vty, " version %d%s", rip->version_send,
! 3623: VTY_NEWLINE);
! 3624:
! 3625: /* RIP timer configuration. */
! 3626: if (rip->update_time != RIP_UPDATE_TIMER_DEFAULT
! 3627: || rip->timeout_time != RIP_TIMEOUT_TIMER_DEFAULT
! 3628: || rip->garbage_time != RIP_GARBAGE_TIMER_DEFAULT)
! 3629: vty_out (vty, " timers basic %lu %lu %lu%s",
! 3630: rip->update_time,
! 3631: rip->timeout_time,
! 3632: rip->garbage_time,
! 3633: VTY_NEWLINE);
! 3634:
! 3635: /* Default information configuration. */
! 3636: if (rip->default_information)
! 3637: {
! 3638: if (rip->default_information_route_map)
! 3639: vty_out (vty, " default-information originate route-map %s%s",
! 3640: rip->default_information_route_map, VTY_NEWLINE);
! 3641: else
! 3642: vty_out (vty, " default-information originate%s",
! 3643: VTY_NEWLINE);
! 3644: }
! 3645:
! 3646: /* Redistribute configuration. */
! 3647: config_write_rip_redistribute (vty, 1);
! 3648:
! 3649: /* RIP offset-list configuration. */
! 3650: config_write_rip_offset_list (vty);
! 3651:
! 3652: /* RIP enabled network and interface configuration. */
! 3653: config_write_rip_network (vty, 1);
! 3654:
! 3655: /* RIP default metric configuration */
! 3656: if (rip->default_metric != RIP_DEFAULT_METRIC_DEFAULT)
! 3657: vty_out (vty, " default-metric %d%s",
! 3658: rip->default_metric, VTY_NEWLINE);
! 3659:
! 3660: /* Distribute configuration. */
! 3661: write += config_write_distribute (vty);
! 3662:
! 3663: /* Interface routemap configuration */
! 3664: write += config_write_if_rmap (vty);
! 3665:
! 3666: /* Distance configuration. */
! 3667: if (rip->distance)
! 3668: vty_out (vty, " distance %d%s", rip->distance, VTY_NEWLINE);
! 3669:
! 3670: /* RIP source IP prefix distance configuration. */
! 3671: for (rn = route_top (rip_distance_table); rn; rn = route_next (rn))
! 3672: if ((rdistance = rn->info) != NULL)
! 3673: vty_out (vty, " distance %d %s/%d %s%s", rdistance->distance,
! 3674: inet_ntoa (rn->p.u.prefix4), rn->p.prefixlen,
! 3675: rdistance->access_list ? rdistance->access_list : "",
! 3676: VTY_NEWLINE);
! 3677:
! 3678: /* RIP static route configuration. */
! 3679: for (rn = route_top (rip->route); rn; rn = route_next (rn))
! 3680: if (rn->info)
! 3681: vty_out (vty, " route %s/%d%s",
! 3682: inet_ntoa (rn->p.u.prefix4),
! 3683: rn->p.prefixlen,
! 3684: VTY_NEWLINE);
! 3685:
! 3686: }
! 3687: return write;
! 3688: }
! 3689:
! 3690: /* RIP node structure. */
! 3691: static struct cmd_node rip_node =
! 3692: {
! 3693: RIP_NODE,
! 3694: "%s(config-router)# ",
! 3695: 1
! 3696: };
! 3697:
! 3698: /* Distribute-list update functions. */
! 3699: static void
! 3700: rip_distribute_update (struct distribute *dist)
! 3701: {
! 3702: struct interface *ifp;
! 3703: struct rip_interface *ri;
! 3704: struct access_list *alist;
! 3705: struct prefix_list *plist;
! 3706:
! 3707: if (! dist->ifname)
! 3708: return;
! 3709:
! 3710: ifp = if_lookup_by_name (dist->ifname);
! 3711: if (ifp == NULL)
! 3712: return;
! 3713:
! 3714: ri = ifp->info;
! 3715:
! 3716: if (dist->list[DISTRIBUTE_IN])
! 3717: {
! 3718: alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_IN]);
! 3719: if (alist)
! 3720: ri->list[RIP_FILTER_IN] = alist;
! 3721: else
! 3722: ri->list[RIP_FILTER_IN] = NULL;
! 3723: }
! 3724: else
! 3725: ri->list[RIP_FILTER_IN] = NULL;
! 3726:
! 3727: if (dist->list[DISTRIBUTE_OUT])
! 3728: {
! 3729: alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_OUT]);
! 3730: if (alist)
! 3731: ri->list[RIP_FILTER_OUT] = alist;
! 3732: else
! 3733: ri->list[RIP_FILTER_OUT] = NULL;
! 3734: }
! 3735: else
! 3736: ri->list[RIP_FILTER_OUT] = NULL;
! 3737:
! 3738: if (dist->prefix[DISTRIBUTE_IN])
! 3739: {
! 3740: plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_IN]);
! 3741: if (plist)
! 3742: ri->prefix[RIP_FILTER_IN] = plist;
! 3743: else
! 3744: ri->prefix[RIP_FILTER_IN] = NULL;
! 3745: }
! 3746: else
! 3747: ri->prefix[RIP_FILTER_IN] = NULL;
! 3748:
! 3749: if (dist->prefix[DISTRIBUTE_OUT])
! 3750: {
! 3751: plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_OUT]);
! 3752: if (plist)
! 3753: ri->prefix[RIP_FILTER_OUT] = plist;
! 3754: else
! 3755: ri->prefix[RIP_FILTER_OUT] = NULL;
! 3756: }
! 3757: else
! 3758: ri->prefix[RIP_FILTER_OUT] = NULL;
! 3759: }
! 3760:
! 3761: void
! 3762: rip_distribute_update_interface (struct interface *ifp)
! 3763: {
! 3764: struct distribute *dist;
! 3765:
! 3766: dist = distribute_lookup (ifp->name);
! 3767: if (dist)
! 3768: rip_distribute_update (dist);
! 3769: }
! 3770:
! 3771: /* Update all interface's distribute list. */
! 3772: /* ARGSUSED */
! 3773: static void
! 3774: rip_distribute_update_all (struct prefix_list *notused)
! 3775: {
! 3776: struct interface *ifp;
! 3777: struct listnode *node, *nnode;
! 3778:
! 3779: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 3780: rip_distribute_update_interface (ifp);
! 3781: }
! 3782: /* ARGSUSED */
! 3783: static void
! 3784: rip_distribute_update_all_wrapper(struct access_list *notused)
! 3785: {
! 3786: rip_distribute_update_all(NULL);
! 3787: }
! 3788:
! 3789: /* Delete all added rip route. */
! 3790: void
! 3791: rip_clean (void)
! 3792: {
! 3793: int i;
! 3794: struct route_node *rp;
! 3795: struct rip_info *rinfo;
! 3796:
! 3797: if (rip)
! 3798: {
! 3799: /* Clear RIP routes */
! 3800: for (rp = route_top (rip->table); rp; rp = route_next (rp))
! 3801: if ((rinfo = rp->info) != NULL)
! 3802: {
! 3803: if (rinfo->type == ZEBRA_ROUTE_RIP &&
! 3804: rinfo->sub_type == RIP_ROUTE_RTE)
! 3805: rip_zebra_ipv4_delete ((struct prefix_ipv4 *)&rp->p,
! 3806: &rinfo->nexthop, rinfo->metric);
! 3807:
! 3808: RIP_TIMER_OFF (rinfo->t_timeout);
! 3809: RIP_TIMER_OFF (rinfo->t_garbage_collect);
! 3810:
! 3811: rp->info = NULL;
! 3812: route_unlock_node (rp);
! 3813:
! 3814: rip_info_free (rinfo);
! 3815: }
! 3816:
! 3817: /* Cancel RIP related timers. */
! 3818: RIP_TIMER_OFF (rip->t_update);
! 3819: RIP_TIMER_OFF (rip->t_triggered_update);
! 3820: RIP_TIMER_OFF (rip->t_triggered_interval);
! 3821:
! 3822: /* Cancel read thread. */
! 3823: if (rip->t_read)
! 3824: {
! 3825: thread_cancel (rip->t_read);
! 3826: rip->t_read = NULL;
! 3827: }
! 3828:
! 3829: /* Close RIP socket. */
! 3830: if (rip->sock >= 0)
! 3831: {
! 3832: close (rip->sock);
! 3833: rip->sock = -1;
! 3834: }
! 3835:
! 3836: /* Static RIP route configuration. */
! 3837: for (rp = route_top (rip->route); rp; rp = route_next (rp))
! 3838: if (rp->info)
! 3839: {
! 3840: rp->info = NULL;
! 3841: route_unlock_node (rp);
! 3842: }
! 3843:
! 3844: /* RIP neighbor configuration. */
! 3845: for (rp = route_top (rip->neighbor); rp; rp = route_next (rp))
! 3846: if (rp->info)
! 3847: {
! 3848: rp->info = NULL;
! 3849: route_unlock_node (rp);
! 3850: }
! 3851:
! 3852: /* Redistribute related clear. */
! 3853: if (rip->default_information_route_map)
! 3854: free (rip->default_information_route_map);
! 3855:
! 3856: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
! 3857: if (rip->route_map[i].name)
! 3858: free (rip->route_map[i].name);
! 3859:
! 3860: XFREE (MTYPE_ROUTE_TABLE, rip->table);
! 3861: XFREE (MTYPE_ROUTE_TABLE, rip->route);
! 3862: XFREE (MTYPE_ROUTE_TABLE, rip->neighbor);
! 3863:
! 3864: XFREE (MTYPE_RIP, rip);
! 3865: rip = NULL;
! 3866: }
! 3867:
! 3868: rip_clean_network ();
! 3869: rip_passive_nondefault_clean ();
! 3870: rip_offset_clean ();
! 3871: rip_interface_clean ();
! 3872: rip_distance_reset ();
! 3873: rip_redistribute_clean ();
! 3874: }
! 3875:
! 3876: /* Reset all values to the default settings. */
! 3877: void
! 3878: rip_reset (void)
! 3879: {
! 3880: /* Reset global counters. */
! 3881: rip_global_route_changes = 0;
! 3882: rip_global_queries = 0;
! 3883:
! 3884: /* Call ripd related reset functions. */
! 3885: rip_debug_reset ();
! 3886: rip_route_map_reset ();
! 3887:
! 3888: /* Call library reset functions. */
! 3889: vty_reset ();
! 3890: access_list_reset ();
! 3891: prefix_list_reset ();
! 3892:
! 3893: distribute_list_reset ();
! 3894:
! 3895: rip_interface_reset ();
! 3896: rip_distance_reset ();
! 3897:
! 3898: rip_zclient_reset ();
! 3899: }
! 3900:
! 3901: static void
! 3902: rip_if_rmap_update (struct if_rmap *if_rmap)
! 3903: {
! 3904: struct interface *ifp;
! 3905: struct rip_interface *ri;
! 3906: struct route_map *rmap;
! 3907:
! 3908: ifp = if_lookup_by_name (if_rmap->ifname);
! 3909: if (ifp == NULL)
! 3910: return;
! 3911:
! 3912: ri = ifp->info;
! 3913:
! 3914: if (if_rmap->routemap[IF_RMAP_IN])
! 3915: {
! 3916: rmap = route_map_lookup_by_name (if_rmap->routemap[IF_RMAP_IN]);
! 3917: if (rmap)
! 3918: ri->routemap[IF_RMAP_IN] = rmap;
! 3919: else
! 3920: ri->routemap[IF_RMAP_IN] = NULL;
! 3921: }
! 3922: else
! 3923: ri->routemap[RIP_FILTER_IN] = NULL;
! 3924:
! 3925: if (if_rmap->routemap[IF_RMAP_OUT])
! 3926: {
! 3927: rmap = route_map_lookup_by_name (if_rmap->routemap[IF_RMAP_OUT]);
! 3928: if (rmap)
! 3929: ri->routemap[IF_RMAP_OUT] = rmap;
! 3930: else
! 3931: ri->routemap[IF_RMAP_OUT] = NULL;
! 3932: }
! 3933: else
! 3934: ri->routemap[RIP_FILTER_OUT] = NULL;
! 3935: }
! 3936:
! 3937: void
! 3938: rip_if_rmap_update_interface (struct interface *ifp)
! 3939: {
! 3940: struct if_rmap *if_rmap;
! 3941:
! 3942: if_rmap = if_rmap_lookup (ifp->name);
! 3943: if (if_rmap)
! 3944: rip_if_rmap_update (if_rmap);
! 3945: }
! 3946:
! 3947: static void
! 3948: rip_routemap_update_redistribute (void)
! 3949: {
! 3950: int i;
! 3951:
! 3952: if (rip)
! 3953: {
! 3954: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
! 3955: {
! 3956: if (rip->route_map[i].name)
! 3957: rip->route_map[i].map =
! 3958: route_map_lookup_by_name (rip->route_map[i].name);
! 3959: }
! 3960: }
! 3961: }
! 3962:
! 3963: /* ARGSUSED */
! 3964: static void
! 3965: rip_routemap_update (const char *notused)
! 3966: {
! 3967: struct interface *ifp;
! 3968: struct listnode *node, *nnode;
! 3969:
! 3970: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
! 3971: rip_if_rmap_update_interface (ifp);
! 3972:
! 3973: rip_routemap_update_redistribute ();
! 3974: }
! 3975:
! 3976: /* Allocate new rip structure and set default value. */
! 3977: void
! 3978: rip_init (void)
! 3979: {
! 3980: /* Randomize for triggered update random(). */
! 3981: srand (time (NULL));
! 3982:
! 3983: /* Install top nodes. */
! 3984: install_node (&rip_node, config_write_rip);
! 3985:
! 3986: /* Install rip commands. */
! 3987: install_element (VIEW_NODE, &show_ip_rip_cmd);
! 3988: install_element (VIEW_NODE, &show_ip_rip_status_cmd);
! 3989: install_element (ENABLE_NODE, &show_ip_rip_cmd);
! 3990: install_element (ENABLE_NODE, &show_ip_rip_status_cmd);
! 3991: install_element (CONFIG_NODE, &router_rip_cmd);
! 3992: install_element (CONFIG_NODE, &no_router_rip_cmd);
! 3993:
! 3994: install_default (RIP_NODE);
! 3995: install_element (RIP_NODE, &rip_version_cmd);
! 3996: install_element (RIP_NODE, &no_rip_version_cmd);
! 3997: install_element (RIP_NODE, &no_rip_version_val_cmd);
! 3998: install_element (RIP_NODE, &rip_default_metric_cmd);
! 3999: install_element (RIP_NODE, &no_rip_default_metric_cmd);
! 4000: install_element (RIP_NODE, &no_rip_default_metric_val_cmd);
! 4001: install_element (RIP_NODE, &rip_timers_cmd);
! 4002: install_element (RIP_NODE, &no_rip_timers_cmd);
! 4003: install_element (RIP_NODE, &no_rip_timers_val_cmd);
! 4004: install_element (RIP_NODE, &rip_route_cmd);
! 4005: install_element (RIP_NODE, &no_rip_route_cmd);
! 4006: install_element (RIP_NODE, &rip_distance_cmd);
! 4007: install_element (RIP_NODE, &no_rip_distance_cmd);
! 4008: install_element (RIP_NODE, &rip_distance_source_cmd);
! 4009: install_element (RIP_NODE, &no_rip_distance_source_cmd);
! 4010: install_element (RIP_NODE, &rip_distance_source_access_list_cmd);
! 4011: install_element (RIP_NODE, &no_rip_distance_source_access_list_cmd);
! 4012:
! 4013: /* Debug related init. */
! 4014: rip_debug_init ();
! 4015:
! 4016: /* SNMP init. */
! 4017: #ifdef HAVE_SNMP
! 4018: rip_snmp_init ();
! 4019: #endif /* HAVE_SNMP */
! 4020:
! 4021: /* Access list install. */
! 4022: access_list_init ();
! 4023: access_list_add_hook (rip_distribute_update_all_wrapper);
! 4024: access_list_delete_hook (rip_distribute_update_all_wrapper);
! 4025:
! 4026: /* Prefix list initialize.*/
! 4027: prefix_list_init ();
! 4028: prefix_list_add_hook (rip_distribute_update_all);
! 4029: prefix_list_delete_hook (rip_distribute_update_all);
! 4030:
! 4031: /* Distribute list install. */
! 4032: distribute_list_init (RIP_NODE);
! 4033: distribute_list_add_hook (rip_distribute_update);
! 4034: distribute_list_delete_hook (rip_distribute_update);
! 4035:
! 4036: /* Route-map */
! 4037: rip_route_map_init ();
! 4038: rip_offset_init ();
! 4039:
! 4040: route_map_add_hook (rip_routemap_update);
! 4041: route_map_delete_hook (rip_routemap_update);
! 4042:
! 4043: if_rmap_init (RIP_NODE);
! 4044: if_rmap_hook_add (rip_if_rmap_update);
! 4045: if_rmap_hook_delete (rip_if_rmap_update);
! 4046:
! 4047: /* Distance control. */
! 4048: rip_distance_table = route_table_init ();
! 4049: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ripd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ripd