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>
5 * This file is part of GNU Zebra.
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
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.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "sockunion.h"
39 #include "distribute.h"
44 #include "ripd/ripd.h"
45 #include "ripd/rip_debug.h"
49 /* UDP receive buffer size */
50 #define RIP_UDP_RCV_BUF 41600
52 /* privileges global */
53 extern struct zebra_privs_t ripd_privs
;
56 struct rip
*rip
= NULL
;
58 /* RIP neighbor address table. */
59 struct route_table
*rip_neighbor_table
;
61 /* RIP route changes. */
62 long rip_global_route_changes
= 0;
65 long rip_global_queries
= 0;
68 static void rip_event(enum rip_event
, int);
69 static void rip_output_process(struct connected
*, struct sockaddr_in
*, int,
71 static int rip_triggered_update(struct thread
*);
72 static int rip_update_jitter(unsigned long);
74 /* RIP output routes type. */
75 enum { rip_all_route
, rip_changed_route
};
77 /* RIP command strings. */
78 static const struct message rip_msg
[] = {{RIP_REQUEST
, "REQUEST"},
79 {RIP_RESPONSE
, "RESPONSE"},
80 {RIP_TRACEON
, "TRACEON"},
81 {RIP_TRACEOFF
, "TRACEOFF"},
83 {RIP_POLL_ENTRY
, "POLL ENTRY"},
86 /* Utility function to set boradcast option to the socket. */
87 static int sockopt_broadcast(int sock
)
92 ret
= setsockopt(sock
, SOL_SOCKET
, SO_BROADCAST
, (char *)&on
,
95 zlog_warn("can't set sockopt SO_BROADCAST to socket %d", sock
);
101 static int rip_route_rte(struct rip_info
*rinfo
)
103 return (rinfo
->type
== ZEBRA_ROUTE_RIP
104 && rinfo
->sub_type
== RIP_ROUTE_RTE
);
107 static struct rip_info
*rip_info_new(void)
109 return XCALLOC(MTYPE_RIP_INFO
, sizeof(struct rip_info
));
112 void rip_info_free(struct rip_info
*rinfo
)
114 XFREE(MTYPE_RIP_INFO
, rinfo
);
117 /* RIP route garbage collect timer. */
118 static int rip_garbage_collect(struct thread
*t
)
120 struct rip_info
*rinfo
;
121 struct route_node
*rp
;
123 rinfo
= THREAD_ARG(t
);
124 rinfo
->t_garbage_collect
= NULL
;
126 /* Off timeout timer. */
127 RIP_TIMER_OFF(rinfo
->t_timeout
);
129 /* Get route_node pointer. */
132 /* Unlock route_node. */
133 listnode_delete(rp
->info
, rinfo
);
134 if (list_isempty((struct list
*)rp
->info
)) {
137 route_unlock_node(rp
);
140 /* Free RIP routing information. */
141 rip_info_free(rinfo
);
146 static void rip_timeout_update(struct rip_info
*rinfo
);
148 /* Add new route to the ECMP list.
149 * RETURN: the new entry added in the list, or NULL if it is not the first
150 * entry and ECMP is not allowed.
152 struct rip_info
*rip_ecmp_add(struct rip_info
*rinfo_new
)
154 struct route_node
*rp
= rinfo_new
->rp
;
155 struct rip_info
*rinfo
= NULL
;
156 struct list
*list
= NULL
;
158 if (rp
->info
== NULL
)
159 rp
->info
= list_new();
160 list
= (struct list
*)rp
->info
;
162 /* If ECMP is not allowed and some entry already exists in the list,
164 if (listcount(list
) && !rip
->ecmp
)
167 rinfo
= rip_info_new();
168 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
169 listnode_add(list
, rinfo
);
171 if (rip_route_rte(rinfo
)) {
172 rip_timeout_update(rinfo
);
173 rip_zebra_ipv4_add(rp
);
176 /* Set the route change flag on the first entry. */
177 rinfo
= listgetdata(listhead(list
));
178 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
180 /* Signal the output process to trigger an update (see section 2.5). */
181 rip_event(RIP_TRIGGERED_UPDATE
, 0);
186 /* Replace the ECMP list with the new route.
187 * RETURN: the new entry added in the list
189 struct rip_info
*rip_ecmp_replace(struct rip_info
*rinfo_new
)
191 struct route_node
*rp
= rinfo_new
->rp
;
192 struct list
*list
= (struct list
*)rp
->info
;
193 struct rip_info
*rinfo
= NULL
, *tmp_rinfo
= NULL
;
194 struct listnode
*node
= NULL
, *nextnode
= NULL
;
196 if (list
== NULL
|| listcount(list
) == 0)
197 return rip_ecmp_add(rinfo_new
);
199 /* Get the first entry */
200 rinfo
= listgetdata(listhead(list
));
202 /* Learnt route replaced by a local one. Delete it from zebra. */
203 if (rip_route_rte(rinfo
) && !rip_route_rte(rinfo_new
))
204 if (CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
205 rip_zebra_ipv4_delete(rp
);
207 /* Re-use the first entry, and delete the others. */
208 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
))
209 if (tmp_rinfo
!= rinfo
) {
210 RIP_TIMER_OFF(tmp_rinfo
->t_timeout
);
211 RIP_TIMER_OFF(tmp_rinfo
->t_garbage_collect
);
212 list_delete_node(list
, node
);
213 rip_info_free(tmp_rinfo
);
216 RIP_TIMER_OFF(rinfo
->t_timeout
);
217 RIP_TIMER_OFF(rinfo
->t_garbage_collect
);
218 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
220 if (rip_route_rte(rinfo
)) {
221 rip_timeout_update(rinfo
);
222 /* The ADD message implies an update. */
223 rip_zebra_ipv4_add(rp
);
226 /* Set the route change flag. */
227 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
229 /* Signal the output process to trigger an update (see section 2.5). */
230 rip_event(RIP_TRIGGERED_UPDATE
, 0);
235 /* Delete one route from the ECMP list.
237 * null - the entry is freed, and other entries exist in the list
238 * the entry - the entry is the last one in the list; its metric is set
239 * to INFINITY, and the garbage collector is started for it
241 struct rip_info
*rip_ecmp_delete(struct rip_info
*rinfo
)
243 struct route_node
*rp
= rinfo
->rp
;
244 struct list
*list
= (struct list
*)rp
->info
;
246 RIP_TIMER_OFF(rinfo
->t_timeout
);
248 if (listcount(list
) > 1) {
249 /* Some other ECMP entries still exist. Just delete this entry.
251 RIP_TIMER_OFF(rinfo
->t_garbage_collect
);
252 listnode_delete(list
, rinfo
);
253 if (rip_route_rte(rinfo
)
254 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
255 /* The ADD message implies the update. */
256 rip_zebra_ipv4_add(rp
);
257 rip_info_free(rinfo
);
260 assert(rinfo
== listgetdata(listhead(list
)));
262 /* This is the only entry left in the list. We must keep it in
263 * the list for garbage collection time, with INFINITY metric.
266 rinfo
->metric
= RIP_METRIC_INFINITY
;
267 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
270 if (rip_route_rte(rinfo
)
271 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
272 rip_zebra_ipv4_delete(rp
);
275 /* Set the route change flag on the first entry. */
276 rinfo
= listgetdata(listhead(list
));
277 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
279 /* Signal the output process to trigger an update (see section 2.5). */
280 rip_event(RIP_TRIGGERED_UPDATE
, 0);
285 /* Timeout RIP routes. */
286 static int rip_timeout(struct thread
*t
)
288 rip_ecmp_delete((struct rip_info
*)THREAD_ARG(t
));
292 static void rip_timeout_update(struct rip_info
*rinfo
)
294 if (rinfo
->metric
!= RIP_METRIC_INFINITY
) {
295 RIP_TIMER_OFF(rinfo
->t_timeout
);
296 RIP_TIMER_ON(rinfo
->t_timeout
, rip_timeout
, rip
->timeout_time
);
300 static int rip_filter(int rip_distribute
, struct prefix_ipv4
*p
,
301 struct rip_interface
*ri
)
303 struct distribute
*dist
;
304 struct access_list
*alist
;
305 struct prefix_list
*plist
;
306 int distribute
= rip_distribute
== RIP_FILTER_OUT
? DISTRIBUTE_V4_OUT
308 const char *inout
= rip_distribute
== RIP_FILTER_OUT
? "out" : "in";
310 /* Input distribute-list filtering. */
311 if (ri
->list
[rip_distribute
]) {
312 if (access_list_apply(ri
->list
[rip_distribute
],
315 if (IS_RIP_DEBUG_PACKET
)
316 zlog_debug("%s/%d filtered by distribute %s",
317 inet_ntoa(p
->prefix
), p
->prefixlen
,
322 if (ri
->prefix
[rip_distribute
]) {
323 if (prefix_list_apply(ri
->prefix
[rip_distribute
],
326 if (IS_RIP_DEBUG_PACKET
)
327 zlog_debug("%s/%d filtered by prefix-list %s",
328 inet_ntoa(p
->prefix
), p
->prefixlen
,
334 /* All interface filter check. */
335 dist
= distribute_lookup(NULL
);
337 if (dist
->list
[distribute
]) {
338 alist
= access_list_lookup(AFI_IP
,
339 dist
->list
[distribute
]);
342 if (access_list_apply(alist
, (struct prefix
*)p
)
344 if (IS_RIP_DEBUG_PACKET
)
346 "%s/%d filtered by distribute %s",
347 inet_ntoa(p
->prefix
),
348 p
->prefixlen
, inout
);
353 if (dist
->prefix
[distribute
]) {
354 plist
= prefix_list_lookup(AFI_IP
,
355 dist
->prefix
[distribute
]);
358 if (prefix_list_apply(plist
, (struct prefix
*)p
)
360 if (IS_RIP_DEBUG_PACKET
)
362 "%s/%d filtered by prefix-list %s",
363 inet_ntoa(p
->prefix
),
364 p
->prefixlen
, inout
);
373 /* Check nexthop address validity. */
374 static int rip_nexthop_check(struct in_addr
*addr
)
376 struct listnode
*node
;
377 struct listnode
*cnode
;
378 struct interface
*ifp
;
379 struct connected
*ifc
;
382 /* If nexthop address matches local configured address then it is
385 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT
), node
, ifp
)) {
386 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, cnode
, ifc
)) {
389 if (p
->family
== AF_INET
390 && IPV4_ADDR_SAME(&p
->u
.prefix4
, addr
))
397 /* RIP add route to routing table. */
398 static void rip_rte_process(struct rte
*rte
, struct sockaddr_in
*from
,
399 struct interface
*ifp
)
402 struct prefix_ipv4 p
;
403 struct route_node
*rp
;
404 struct rip_info
*rinfo
= NULL
, newinfo
;
405 struct rip_interface
*ri
;
406 struct in_addr
*nexthop
;
408 unsigned char old_dist
, new_dist
;
409 struct list
*list
= NULL
;
410 struct listnode
*node
= NULL
;
412 /* Make prefix structure. */
413 memset(&p
, 0, sizeof(struct prefix_ipv4
));
415 p
.prefix
= rte
->prefix
;
416 p
.prefixlen
= ip_masklen(rte
->mask
);
418 /* Make sure mask is applied. */
421 /* Apply input filters. */
424 ret
= rip_filter(RIP_FILTER_IN
, &p
, ri
);
428 memset(&newinfo
, 0, sizeof(newinfo
));
429 newinfo
.type
= ZEBRA_ROUTE_RIP
;
430 newinfo
.sub_type
= RIP_ROUTE_RTE
;
431 newinfo
.nexthop
= rte
->nexthop
;
432 newinfo
.from
= from
->sin_addr
;
433 newinfo
.ifindex
= ifp
->ifindex
;
434 newinfo
.metric
= rte
->metric
;
435 newinfo
.metric_out
= rte
->metric
; /* XXX */
436 newinfo
.tag
= ntohs(rte
->tag
); /* XXX */
438 /* Modify entry according to the interface routemap. */
439 if (ri
->routemap
[RIP_FILTER_IN
]) {
442 /* The object should be of the type of rip_info */
443 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_IN
],
444 (struct prefix
*)&p
, RMAP_RIP
, &newinfo
);
446 if (ret
== RMAP_DENYMATCH
) {
447 if (IS_RIP_DEBUG_PACKET
)
449 "RIP %s/%d is filtered by route-map in",
450 inet_ntoa(p
.prefix
), p
.prefixlen
);
454 /* Get back the object */
455 rte
->nexthop
= newinfo
.nexthop_out
;
456 rte
->tag
= htons(newinfo
.tag_out
); /* XXX */
458 newinfo
.metric_out
; /* XXX: the routemap uses the
462 /* Once the entry has been validated, update the metric by
463 adding the cost of the network on wich the message
464 arrived. If the result is greater than infinity, use infinity
465 (RFC2453 Sec. 3.9.2) */
466 /* Zebra ripd can handle offset-list in. */
467 ret
= rip_offset_list_apply_in(&p
, ifp
, &rte
->metric
);
469 /* If offset-list does not modify the metric use interface's
472 rte
->metric
+= ifp
->metric
? ifp
->metric
: 1;
474 if (rte
->metric
> RIP_METRIC_INFINITY
)
475 rte
->metric
= RIP_METRIC_INFINITY
;
477 /* Set nexthop pointer. */
478 if (rte
->nexthop
.s_addr
== 0)
479 nexthop
= &from
->sin_addr
;
481 nexthop
= &rte
->nexthop
;
483 /* Check if nexthop address is myself, then do nothing. */
484 if (rip_nexthop_check(nexthop
) < 0) {
485 if (IS_RIP_DEBUG_PACKET
)
486 zlog_debug("Nexthop address %s is myself",
487 inet_ntoa(*nexthop
));
491 /* Get index for the prefix. */
492 rp
= route_node_get(rip
->table
, (struct prefix
*)&p
);
495 newinfo
.nexthop
= *nexthop
;
496 newinfo
.metric
= rte
->metric
;
497 newinfo
.tag
= ntohs(rte
->tag
);
498 newinfo
.distance
= rip_distance_apply(&newinfo
);
500 new_dist
= newinfo
.distance
? newinfo
.distance
501 : ZEBRA_RIP_DISTANCE_DEFAULT
;
503 /* Check to see whether there is already RIP route on the table. */
504 if ((list
= rp
->info
) != NULL
)
505 for (ALL_LIST_ELEMENTS_RO(list
, node
, rinfo
)) {
506 /* Need to compare with redistributed entry or local
508 if (!rip_route_rte(rinfo
))
511 if (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
512 && IPV4_ADDR_SAME(&rinfo
->nexthop
, nexthop
))
515 if (!listnextnode(node
)) {
516 /* Not found in the list */
518 if (rte
->metric
> rinfo
->metric
) {
519 /* New route has a greater metric.
521 route_unlock_node(rp
);
525 if (rte
->metric
< rinfo
->metric
)
526 /* New route has a smaller metric.
527 * Replace the ECMP list
528 * with the new one in below. */
531 /* Metrics are same. We compare the distances.
533 old_dist
= rinfo
->distance
535 : ZEBRA_RIP_DISTANCE_DEFAULT
;
537 if (new_dist
> old_dist
) {
538 /* New route has a greater distance.
540 route_unlock_node(rp
);
544 if (new_dist
< old_dist
)
545 /* New route has a smaller distance.
546 * Replace the ECMP list
547 * with the new one in below. */
550 /* Metrics and distances are both same. Keep
552 * the new route is added in the ECMP list in
558 /* Local static route. */
559 if (rinfo
->type
== ZEBRA_ROUTE_RIP
560 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
561 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))
562 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
563 route_unlock_node(rp
);
567 /* Redistributed route check. */
568 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
569 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
570 old_dist
= rinfo
->distance
;
571 /* Only routes directly connected to an interface
573 * may have a valid NULL distance */
574 if (rinfo
->nexthop
.s_addr
!= 0)
577 : ZEBRA_RIP_DISTANCE_DEFAULT
;
578 /* If imported route does not have STRICT precedence,
579 mark it as a ghost */
580 if (new_dist
<= old_dist
581 && rte
->metric
!= RIP_METRIC_INFINITY
)
582 rip_ecmp_replace(&newinfo
);
584 route_unlock_node(rp
);
591 route_unlock_node(rp
);
593 /* Now, check to see whether there is already an explicit route
594 for the destination prefix. If there is no such route, add
595 this route to the routing table, unless the metric is
596 infinity (there is no point in adding a route which
598 if (rte
->metric
!= RIP_METRIC_INFINITY
)
599 rip_ecmp_add(&newinfo
);
601 /* Route is there but we are not sure the route is RIP or not.
604 /* If there is an existing route, compare the next hop address
605 to the address of the router from which the datagram came.
606 If this datagram is from the same router as the existing
607 route, reinitialize the timeout. */
608 same
= (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
609 && (rinfo
->ifindex
== ifp
->ifindex
));
611 old_dist
= rinfo
->distance
? rinfo
->distance
612 : ZEBRA_RIP_DISTANCE_DEFAULT
;
614 /* Next, compare the metrics. If the datagram is from the same
615 router as the existing route, and the new metric is different
616 than the old one; or, if the new metric is lower than the old
617 one, or if the tag has been changed; or if there is a route
618 with a lower administrave distance; or an update of the
619 distance on the actual route; do the following actions: */
620 if ((same
&& rinfo
->metric
!= rte
->metric
)
621 || (rte
->metric
< rinfo
->metric
)
622 || ((same
) && (rinfo
->metric
== rte
->metric
)
623 && (newinfo
.tag
!= rinfo
->tag
))
624 || (old_dist
> new_dist
)
625 || ((old_dist
!= new_dist
) && same
)) {
626 if (listcount(list
) == 1) {
627 if (newinfo
.metric
!= RIP_METRIC_INFINITY
)
628 rip_ecmp_replace(&newinfo
);
630 rip_ecmp_delete(rinfo
);
632 if (newinfo
.metric
< rinfo
->metric
)
633 rip_ecmp_replace(&newinfo
);
634 else if (newinfo
.metric
> rinfo
->metric
)
635 rip_ecmp_delete(rinfo
);
636 else if (new_dist
< old_dist
)
637 rip_ecmp_replace(&newinfo
);
638 else if (new_dist
> old_dist
)
639 rip_ecmp_delete(rinfo
);
641 int update
= CHECK_FLAG(rinfo
->flags
,
646 assert(newinfo
.metric
647 != RIP_METRIC_INFINITY
);
649 RIP_TIMER_OFF(rinfo
->t_timeout
);
650 RIP_TIMER_OFF(rinfo
->t_garbage_collect
);
651 memcpy(rinfo
, &newinfo
,
652 sizeof(struct rip_info
));
653 rip_timeout_update(rinfo
);
656 rip_zebra_ipv4_add(rp
);
658 /* - Set the route change flag on the
660 rinfo
= listgetdata(listhead(list
));
661 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
662 rip_event(RIP_TRIGGERED_UPDATE
, 0);
665 } else /* same & no change */
666 rip_timeout_update(rinfo
);
668 /* Unlock tempolary lock of the route. */
669 route_unlock_node(rp
);
673 /* Dump RIP packet */
674 static void rip_packet_dump(struct rip_packet
*packet
, int size
,
679 const char *command_str
;
680 char pbuf
[BUFSIZ
], nbuf
[BUFSIZ
];
684 /* Set command string. */
685 if (packet
->command
> 0 && packet
->command
< RIP_COMMAND_MAX
)
686 command_str
= lookup_msg(rip_msg
, packet
->command
, NULL
);
688 command_str
= "unknown";
690 /* Dump packet header. */
691 zlog_debug("%s %s version %d packet size %d", sndrcv
, command_str
,
692 packet
->version
, size
);
694 /* Dump each routing table entry. */
697 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
698 if (packet
->version
== RIPv2
) {
699 netmask
= ip_masklen(rte
->mask
);
701 if (rte
->family
== htons(RIP_FAMILY_AUTH
)) {
703 == htons(RIP_AUTH_SIMPLE_PASSWORD
)) {
704 p
= (u_char
*)&rte
->prefix
;
707 " family 0x%X type %d auth string: %s",
710 } else if (rte
->tag
== htons(RIP_AUTH_MD5
)) {
711 struct rip_md5_info
*md5
;
713 md5
= (struct rip_md5_info
*)&packet
717 " family 0x%X type %d (MD5 authentication)",
721 " RIP-2 packet len %d Key ID %d"
723 ntohs(md5
->packet_len
),
724 md5
->keyid
, md5
->auth_len
);
726 " Sequence Number %ld",
727 (u_long
)ntohl(md5
->sequence
));
728 } else if (rte
->tag
== htons(RIP_AUTH_DATA
)) {
729 p
= (u_char
*)&rte
->prefix
;
732 " family 0x%X type %d (MD5 data)",
736 " MD5: %02X%02X%02X%02X%02X%02X%02X%02X"
737 "%02X%02X%02X%02X%02X%02X%02X%02X",
738 p
[0], p
[1], p
[2], p
[3], p
[4],
739 p
[5], p
[6], p
[7], p
[8], p
[9],
740 p
[10], p
[11], p
[12], p
[13],
744 " family 0x%X type %d (Unknown auth type)",
750 " %s/%d -> %s family %d tag %" ROUTE_TAG_PRI
752 inet_ntop(AF_INET
, &rte
->prefix
, pbuf
,
755 inet_ntop(AF_INET
, &rte
->nexthop
, nbuf
,
758 (route_tag_t
)ntohs(rte
->tag
),
759 (u_long
)ntohl(rte
->metric
));
762 " %s family %d tag %" ROUTE_TAG_PRI
764 inet_ntop(AF_INET
, &rte
->prefix
, pbuf
, BUFSIZ
),
766 (route_tag_t
)ntohs(rte
->tag
),
767 (u_long
)ntohl(rte
->metric
));
772 /* Check if the destination address is valid (unicast; not net 0
773 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
774 check net 0 because we accept default route. */
775 static int rip_destination_check(struct in_addr addr
)
777 u_int32_t destination
;
779 /* Convert to host byte order. */
780 destination
= ntohl(addr
.s_addr
);
782 if (IPV4_NET127(destination
))
785 /* Net 0 may match to the default route. */
786 if (IPV4_NET0(destination
) && destination
!= 0)
789 /* Unicast address must belong to class A, B, C. */
790 if (IN_CLASSA(destination
))
792 if (IN_CLASSB(destination
))
794 if (IN_CLASSC(destination
))
800 /* RIP version 2 authentication. */
801 static int rip_auth_simple_password(struct rte
*rte
, struct sockaddr_in
*from
,
802 struct interface
*ifp
)
804 struct rip_interface
*ri
;
805 char *auth_str
= (char *)&rte
->prefix
;
808 /* reject passwords with zeros in the middle of the string */
809 for (i
= strlen(auth_str
); i
< 16; i
++) {
810 if (auth_str
[i
] != '\0')
814 if (IS_RIP_DEBUG_EVENT
)
815 zlog_debug("RIPv2 simple password authentication from %s",
816 inet_ntoa(from
->sin_addr
));
820 if (ri
->auth_type
!= RIP_AUTH_SIMPLE_PASSWORD
821 || rte
->tag
!= htons(RIP_AUTH_SIMPLE_PASSWORD
))
824 /* Simple password authentication. */
826 if (strncmp(auth_str
, ri
->auth_str
, 16) == 0)
830 struct keychain
*keychain
;
833 keychain
= keychain_lookup(ri
->key_chain
);
834 if (keychain
== NULL
)
837 key
= key_match_for_accept(keychain
, auth_str
);
844 /* RIP version 2 authentication with MD5. */
845 static int rip_auth_md5(struct rip_packet
*packet
, struct sockaddr_in
*from
,
846 int length
, struct interface
*ifp
)
848 struct rip_interface
*ri
;
849 struct rip_md5_info
*md5
;
850 struct rip_md5_data
*md5data
;
851 struct keychain
*keychain
;
854 u_char digest
[RIP_AUTH_MD5_SIZE
];
855 u_int16_t packet_len
;
856 char auth_str
[RIP_AUTH_MD5_SIZE
];
858 if (IS_RIP_DEBUG_EVENT
)
859 zlog_debug("RIPv2 MD5 authentication from %s",
860 inet_ntoa(from
->sin_addr
));
863 md5
= (struct rip_md5_info
*)&packet
->rte
;
865 /* Check auth type. */
866 if (ri
->auth_type
!= RIP_AUTH_MD5
|| md5
->type
!= htons(RIP_AUTH_MD5
))
869 /* If the authentication length is less than 16, then it must be wrong
871 * any interpretation of rfc2082. Some implementations also interpret
872 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka
873 * RIP_AUTH_MD5_COMPAT_SIZE.
875 if (!((md5
->auth_len
== RIP_AUTH_MD5_SIZE
)
876 || (md5
->auth_len
== RIP_AUTH_MD5_COMPAT_SIZE
))) {
877 if (IS_RIP_DEBUG_EVENT
)
879 "RIPv2 MD5 authentication, strange authentication "
885 /* grab and verify check packet length */
886 packet_len
= ntohs(md5
->packet_len
);
888 if (packet_len
> (length
- RIP_HEADER_SIZE
- RIP_AUTH_MD5_SIZE
)) {
889 if (IS_RIP_DEBUG_EVENT
)
891 "RIPv2 MD5 authentication, packet length field %d "
892 "greater than received length %d!",
893 md5
->packet_len
, length
);
897 /* retrieve authentication data */
898 md5data
= (struct rip_md5_data
*)(((u_char
*)packet
) + packet_len
);
900 memset(auth_str
, 0, RIP_AUTH_MD5_SIZE
);
903 keychain
= keychain_lookup(ri
->key_chain
);
904 if (keychain
== NULL
)
907 key
= key_lookup_for_accept(keychain
, md5
->keyid
);
911 strncpy(auth_str
, key
->string
, RIP_AUTH_MD5_SIZE
);
912 } else if (ri
->auth_str
)
913 strncpy(auth_str
, ri
->auth_str
, RIP_AUTH_MD5_SIZE
);
915 if (auth_str
[0] == 0)
918 /* MD5 digest authentication. */
919 memset(&ctx
, 0, sizeof(ctx
));
921 MD5Update(&ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
922 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
923 MD5Final(digest
, &ctx
);
925 if (memcmp(md5data
->digest
, digest
, RIP_AUTH_MD5_SIZE
) == 0)
931 /* Pick correct auth string for sends, prepare auth_str buffer for use.
932 * (left justified and padded).
934 * presumes one of ri or key is valid, and that the auth strings they point
935 * to are nul terminated. If neither are present, auth_str will be fully
939 static void rip_auth_prepare_str_send(struct rip_interface
*ri
, struct key
*key
,
940 char *auth_str
, int len
)
944 memset(auth_str
, 0, len
);
945 if (key
&& key
->string
)
946 strncpy(auth_str
, key
->string
, len
);
947 else if (ri
->auth_str
)
948 strncpy(auth_str
, ri
->auth_str
, len
);
953 /* Write RIPv2 simple password authentication information
955 * auth_str is presumed to be 2 bytes and correctly prepared
956 * (left justified and zero padded).
958 static void rip_auth_simple_write(struct stream
*s
, char *auth_str
, int len
)
960 assert(s
&& len
== RIP_AUTH_SIMPLE_SIZE
);
962 stream_putw(s
, RIP_FAMILY_AUTH
);
963 stream_putw(s
, RIP_AUTH_SIMPLE_PASSWORD
);
964 stream_put(s
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
969 /* write RIPv2 MD5 "authentication header"
970 * (uses the auth key data field)
972 * Digest offset field is set to 0.
974 * returns: offset of the digest offset field, which must be set when
975 * length to the auth-data MD5 digest is known.
977 static size_t rip_auth_md5_ah_write(struct stream
*s
, struct rip_interface
*ri
,
982 assert(s
&& ri
&& ri
->auth_type
== RIP_AUTH_MD5
);
984 /* MD5 authentication. */
985 stream_putw(s
, RIP_FAMILY_AUTH
);
986 stream_putw(s
, RIP_AUTH_MD5
);
988 /* MD5 AH digest offset field.
990 * Set to placeholder value here, to true value when RIP-2 Packet length
991 * is known. Actual value is set in .....().
993 doff
= stream_get_endp(s
);
998 stream_putc(s
, key
->index
% 256);
1002 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1003 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for
1005 * to be configurable.
1007 stream_putc(s
, ri
->md5_auth_len
);
1009 /* Sequence Number (non-decreasing). */
1010 /* RFC2080: The value used in the sequence number is
1011 arbitrary, but two suggestions are the time of the
1012 message's creation or a simple message counter. */
1013 stream_putl(s
, time(NULL
));
1015 /* Reserved field must be zero. */
1022 /* If authentication is in used, write the appropriate header
1023 * returns stream offset to which length must later be written
1024 * or 0 if this is not required
1026 static size_t rip_auth_header_write(struct stream
*s
, struct rip_interface
*ri
,
1027 struct key
*key
, char *auth_str
, int len
)
1029 assert(ri
->auth_type
!= RIP_NO_AUTH
);
1031 switch (ri
->auth_type
) {
1032 case RIP_AUTH_SIMPLE_PASSWORD
:
1033 rip_auth_prepare_str_send(ri
, key
, auth_str
, len
);
1034 rip_auth_simple_write(s
, auth_str
, len
);
1037 return rip_auth_md5_ah_write(s
, ri
, key
);
1043 /* Write RIPv2 MD5 authentication data trailer */
1044 static void rip_auth_md5_set(struct stream
*s
, struct rip_interface
*ri
,
1045 size_t doff
, char *auth_str
, int authlen
)
1049 unsigned char digest
[RIP_AUTH_MD5_SIZE
];
1051 /* Make it sure this interface is configured as MD5
1053 assert((ri
->auth_type
== RIP_AUTH_MD5
)
1054 && (authlen
== RIP_AUTH_MD5_SIZE
));
1057 /* Get packet length. */
1058 len
= stream_get_endp(s
);
1060 /* Check packet length. */
1061 if (len
< (RIP_HEADER_SIZE
+ RIP_RTE_SIZE
)) {
1063 "rip_auth_md5_set(): packet length %ld is less than minimum length.",
1068 /* Set the digest offset length in the header */
1069 stream_putw_at(s
, doff
, len
);
1071 /* Set authentication data. */
1072 stream_putw(s
, RIP_FAMILY_AUTH
);
1073 stream_putw(s
, RIP_AUTH_DATA
);
1075 /* Generate a digest for the RIP packet. */
1076 memset(&ctx
, 0, sizeof(ctx
));
1078 MD5Update(&ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1079 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1080 MD5Final(digest
, &ctx
);
1082 /* Copy the digest to the packet. */
1083 stream_write(s
, digest
, RIP_AUTH_MD5_SIZE
);
1086 /* RIP routing information. */
1087 static void rip_response_process(struct rip_packet
*packet
, int size
,
1088 struct sockaddr_in
*from
,
1089 struct connected
*ifc
)
1093 struct prefix_ipv4 ifaddr
;
1094 struct prefix_ipv4 ifaddrclass
;
1097 memset(&ifaddr
, 0, sizeof(ifaddr
));
1098 /* We don't know yet. */
1101 /* The Response must be ignored if it is not from the RIP
1102 port. (RFC2453 - Sec. 3.9.2)*/
1103 if (from
->sin_port
!= htons(RIP_PORT_DEFAULT
)) {
1104 zlog_info("response doesn't come from RIP port: %d",
1106 rip_peer_bad_packet(from
);
1110 /* The datagram's IPv4 source address should be checked to see
1111 whether the datagram is from a valid neighbor; the source of the
1112 datagram must be on a directly connected network (RFC2453 - Sec.
1114 if (if_lookup_address((void *)&from
->sin_addr
, AF_INET
, VRF_DEFAULT
)
1117 "This datagram doesn't came from a valid neighbor: %s",
1118 inet_ntoa(from
->sin_addr
));
1119 rip_peer_bad_packet(from
);
1123 /* It is also worth checking to see whether the response is from one
1124 of the router's own addresses. */
1126 ; /* Alredy done in rip_read () */
1128 /* Update RIP peer. */
1129 rip_peer_update(from
, packet
->version
);
1131 /* Set RTE pointer. */
1134 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
1135 /* RIPv2 authentication check. */
1136 /* If the Address Family Identifier of the first (and only the
1137 first) entry in the message is 0xFFFF, then the remainder of
1138 the entry contains the authentication. */
1139 /* If the packet gets here it means authentication enabled */
1140 /* Check is done in rip_read(). So, just skipping it */
1141 if (packet
->version
== RIPv2
&& rte
== packet
->rte
1142 && rte
->family
== htons(RIP_FAMILY_AUTH
))
1145 if (rte
->family
!= htons(AF_INET
)) {
1146 /* Address family check. RIP only supports AF_INET. */
1147 zlog_info("Unsupported family %d from %s.",
1149 inet_ntoa(from
->sin_addr
));
1153 /* - is the destination address valid (e.g., unicast; not net 0
1155 if (!rip_destination_check(rte
->prefix
)) {
1157 "Network is net 0 or net 127 or it is not unicast network");
1158 rip_peer_bad_route(from
);
1162 /* Convert metric value to host byte order. */
1163 rte
->metric
= ntohl(rte
->metric
);
1165 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1166 if (!(rte
->metric
>= 1 && rte
->metric
<= 16)) {
1167 zlog_info("Route's metric is not in the 1-16 range.");
1168 rip_peer_bad_route(from
);
1172 /* RIPv1 does not have nexthop value. */
1173 if (packet
->version
== RIPv1
&& rte
->nexthop
.s_addr
!= 0) {
1174 zlog_info("RIPv1 packet with nexthop value %s",
1175 inet_ntoa(rte
->nexthop
));
1176 rip_peer_bad_route(from
);
1180 /* That is, if the provided information is ignored, a possibly
1181 sub-optimal, but absolutely valid, route may be taken. If
1182 the received Next Hop is not directly reachable, it should be
1183 treated as 0.0.0.0. */
1184 if (packet
->version
== RIPv2
&& rte
->nexthop
.s_addr
!= 0) {
1187 /* Multicast address check. */
1188 addrval
= ntohl(rte
->nexthop
.s_addr
);
1189 if (IN_CLASSD(addrval
)) {
1191 "Nexthop %s is multicast address, skip this rte",
1192 inet_ntoa(rte
->nexthop
));
1196 if (!if_lookup_address((void *)&rte
->nexthop
, AF_INET
,
1198 struct route_node
*rn
;
1199 struct rip_info
*rinfo
;
1201 rn
= route_node_match_ipv4(rip
->table
,
1207 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1210 if (IS_RIP_DEBUG_EVENT
)
1212 "Next hop %s is on RIP network. Set nexthop to the packet's originator",
1215 rte
->nexthop
= rinfo
->from
;
1217 if (IS_RIP_DEBUG_EVENT
)
1219 "Next hop %s is not directly reachable. Treat it as 0.0.0.0",
1222 rte
->nexthop
.s_addr
= 0;
1225 route_unlock_node(rn
);
1227 if (IS_RIP_DEBUG_EVENT
)
1229 "Next hop %s is not directly reachable. Treat it as 0.0.0.0",
1232 rte
->nexthop
.s_addr
= 0;
1237 /* For RIPv1, there won't be a valid netmask.
1239 This is a best guess at the masks. If everyone was using old
1240 Ciscos before the 'ip subnet zero' option, it would be almost
1243 Cisco summarize ripv1 advertisments to the classful boundary
1244 (/16 for class B's) except when the RIP packet does to inside
1245 the classful network in question. */
1247 if ((packet
->version
== RIPv1
&& rte
->prefix
.s_addr
!= 0)
1248 || (packet
->version
== RIPv2
1249 && (rte
->prefix
.s_addr
!= 0
1250 && rte
->mask
.s_addr
== 0))) {
1251 u_int32_t destination
;
1253 if (subnetted
== -1) {
1254 memcpy(&ifaddr
, ifc
->address
,
1255 sizeof(struct prefix_ipv4
));
1256 memcpy(&ifaddrclass
, &ifaddr
,
1257 sizeof(struct prefix_ipv4
));
1258 apply_classful_mask_ipv4(&ifaddrclass
);
1260 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1264 destination
= ntohl(rte
->prefix
.s_addr
);
1266 if (IN_CLASSA(destination
))
1267 masklen2ip(8, &rte
->mask
);
1268 else if (IN_CLASSB(destination
))
1269 masklen2ip(16, &rte
->mask
);
1270 else if (IN_CLASSC(destination
))
1271 masklen2ip(24, &rte
->mask
);
1274 masklen2ip(ifaddrclass
.prefixlen
,
1275 (struct in_addr
*)&destination
);
1276 if ((subnetted
== 1)
1277 && ((rte
->prefix
.s_addr
& destination
)
1278 == ifaddrclass
.prefix
.s_addr
)) {
1279 masklen2ip(ifaddr
.prefixlen
, &rte
->mask
);
1280 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1281 != rte
->prefix
.s_addr
)
1282 masklen2ip(32, &rte
->mask
);
1283 if (IS_RIP_DEBUG_EVENT
)
1284 zlog_debug("Subnetted route %s",
1285 inet_ntoa(rte
->prefix
));
1287 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1288 != rte
->prefix
.s_addr
)
1292 if (IS_RIP_DEBUG_EVENT
) {
1293 zlog_debug("Resultant route %s",
1294 inet_ntoa(rte
->prefix
));
1295 zlog_debug("Resultant mask %s",
1296 inet_ntoa(rte
->mask
));
1300 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1301 ignore the entry. */
1302 if ((packet
->version
== RIPv2
) && (rte
->mask
.s_addr
!= 0)
1303 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1304 != rte
->prefix
.s_addr
)) {
1306 "RIPv2 address %s is not mask /%d applied one",
1307 inet_ntoa(rte
->prefix
), ip_masklen(rte
->mask
));
1308 rip_peer_bad_route(from
);
1312 /* Default route's netmask is ignored. */
1313 if (packet
->version
== RIPv2
&& (rte
->prefix
.s_addr
== 0)
1314 && (rte
->mask
.s_addr
!= 0)) {
1315 if (IS_RIP_DEBUG_EVENT
)
1317 "Default route with non-zero netmask. Set zero to netmask");
1318 rte
->mask
.s_addr
= 0;
1321 /* Routing table updates. */
1322 rip_rte_process(rte
, from
, ifc
->ifp
);
1326 /* Make socket for RIP protocol. */
1327 static int rip_create_socket(void)
1331 struct sockaddr_in addr
;
1333 memset(&addr
, 0, sizeof(struct sockaddr_in
));
1334 addr
.sin_family
= AF_INET
;
1335 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1336 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1337 addr
.sin_len
= sizeof(struct sockaddr_in
);
1338 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1339 /* sending port must always be the RIP port */
1340 addr
.sin_port
= htons(RIP_PORT_DEFAULT
);
1342 /* Make datagram socket. */
1343 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
1345 zlog_err("Cannot create UDP socket: %s", safe_strerror(errno
));
1349 sockopt_broadcast(sock
);
1350 sockopt_reuseaddr(sock
);
1351 sockopt_reuseport(sock
);
1352 setsockopt_ipv4_multicast_loop(sock
, 0);
1354 setsockopt_pktinfo(sock
);
1355 #endif /* RIP_RECVMSG */
1356 #ifdef IPTOS_PREC_INTERNETCONTROL
1357 setsockopt_ipv4_tos(sock
, IPTOS_PREC_INTERNETCONTROL
);
1360 if (ripd_privs
.change(ZPRIVS_RAISE
))
1361 zlog_err("rip_create_socket: could not raise privs");
1362 setsockopt_so_recvbuf(sock
, RIP_UDP_RCV_BUF
);
1363 if ((ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
))) < 0)
1366 int save_errno
= errno
;
1367 if (ripd_privs
.change(ZPRIVS_LOWER
))
1368 zlog_err("rip_create_socket: could not lower privs");
1370 zlog_err("%s: Can't bind socket %d to %s port %d: %s", __func__
,
1371 sock
, inet_ntoa(addr
.sin_addr
),
1372 (int)ntohs(addr
.sin_port
), safe_strerror(save_errno
));
1378 if (ripd_privs
.change(ZPRIVS_LOWER
))
1379 zlog_err("rip_create_socket: could not lower privs");
1384 /* RIP packet send to destination address, on interface denoted by
1385 * by connected argument. NULL to argument denotes destination should be
1386 * should be RIP multicast group
1388 static int rip_send_packet(u_char
*buf
, int size
, struct sockaddr_in
*to
,
1389 struct connected
*ifc
)
1392 struct sockaddr_in sin
;
1394 assert(ifc
!= NULL
);
1396 if (IS_RIP_DEBUG_PACKET
) {
1397 #define ADDRESS_SIZE 20
1398 char dst
[ADDRESS_SIZE
];
1399 dst
[ADDRESS_SIZE
- 1] = '\0';
1402 strncpy(dst
, inet_ntoa(to
->sin_addr
), ADDRESS_SIZE
- 1);
1404 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1405 strncpy(dst
, inet_ntoa(sin
.sin_addr
), ADDRESS_SIZE
- 1);
1408 zlog_debug("rip_send_packet %s > %s (%s)",
1409 inet_ntoa(ifc
->address
->u
.prefix4
), dst
,
1413 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
)) {
1415 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1417 * with multiple addresses on the same subnet: the first address
1418 * on the subnet is configured "primary", and all subsequent
1420 * on that subnet are treated as "secondary" addresses.
1421 * In order to avoid routing-table bloat on other rip listeners,
1422 * we do not send out RIP packets with ZEBRA_IFA_SECONDARY
1424 * XXX Since Linux is the only system for which the
1425 * ZEBRA_IFA_SECONDARY
1426 * flag is set, we would end up sending a packet for a
1428 * source address on non-linux systems.
1430 if (IS_RIP_DEBUG_PACKET
)
1431 zlog_debug("duplicate dropped");
1435 /* Make destination address. */
1436 memset(&sin
, 0, sizeof(struct sockaddr_in
));
1437 sin
.sin_family
= AF_INET
;
1438 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1439 sin
.sin_len
= sizeof(struct sockaddr_in
);
1440 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1442 /* When destination is specified, use it's port and address. */
1444 sin
.sin_port
= to
->sin_port
;
1445 sin
.sin_addr
= to
->sin_addr
;
1447 sin
.sin_port
= htons(RIP_PORT_DEFAULT
);
1448 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1450 rip_interface_multicast_set(rip
->sock
, ifc
);
1453 ret
= sendto(rip
->sock
, buf
, size
, 0, (struct sockaddr
*)&sin
,
1454 sizeof(struct sockaddr_in
));
1456 if (IS_RIP_DEBUG_EVENT
)
1457 zlog_debug("SEND to %s.%d", inet_ntoa(sin
.sin_addr
),
1458 ntohs(sin
.sin_port
));
1461 zlog_warn("can't send packet : %s", safe_strerror(errno
));
1466 /* Add redistributed route to RIP table. */
1467 void rip_redistribute_add(int type
, int sub_type
, struct prefix_ipv4
*p
,
1468 ifindex_t ifindex
, struct in_addr
*nexthop
,
1469 unsigned int metric
, unsigned char distance
,
1473 struct route_node
*rp
= NULL
;
1474 struct rip_info
*rinfo
= NULL
, newinfo
;
1475 struct list
*list
= NULL
;
1477 /* Redistribute route */
1478 ret
= rip_destination_check(p
->prefix
);
1482 rp
= route_node_get(rip
->table
, (struct prefix
*)p
);
1484 memset(&newinfo
, 0, sizeof(struct rip_info
));
1485 newinfo
.type
= type
;
1486 newinfo
.sub_type
= sub_type
;
1487 newinfo
.ifindex
= ifindex
;
1489 newinfo
.external_metric
= metric
;
1490 newinfo
.distance
= distance
;
1491 if (tag
<= UINT16_MAX
) /* RIP only supports 16 bit tags */
1495 newinfo
.nexthop
= *nexthop
;
1497 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
1498 rinfo
= listgetdata(listhead(list
));
1500 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1501 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1502 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
1503 route_unlock_node(rp
);
1507 /* Manually configured RIP route check. */
1508 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1509 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
1510 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))) {
1511 if (type
!= ZEBRA_ROUTE_RIP
1512 || ((sub_type
!= RIP_ROUTE_STATIC
)
1513 && (sub_type
!= RIP_ROUTE_DEFAULT
))) {
1514 route_unlock_node(rp
);
1519 rinfo
= rip_ecmp_replace(&newinfo
);
1520 route_unlock_node(rp
);
1522 rinfo
= rip_ecmp_add(&newinfo
);
1524 if (IS_RIP_DEBUG_EVENT
) {
1527 "Redistribute new prefix %s/%d on the interface %s",
1528 inet_ntoa(p
->prefix
), p
->prefixlen
,
1529 ifindex2ifname(ifindex
, VRF_DEFAULT
));
1532 "Redistribute new prefix %s/%d with nexthop %s on the interface %s",
1533 inet_ntoa(p
->prefix
), p
->prefixlen
,
1534 inet_ntoa(rinfo
->nexthop
),
1535 ifindex2ifname(ifindex
, VRF_DEFAULT
));
1538 rip_event(RIP_TRIGGERED_UPDATE
, 0);
1541 /* Delete redistributed route from RIP table. */
1542 void rip_redistribute_delete(int type
, int sub_type
, struct prefix_ipv4
*p
,
1546 struct route_node
*rp
;
1547 struct rip_info
*rinfo
;
1549 ret
= rip_destination_check(p
->prefix
);
1553 rp
= route_node_lookup(rip
->table
, (struct prefix
*)p
);
1555 struct list
*list
= rp
->info
;
1557 if (list
!= NULL
&& listcount(list
) != 0) {
1558 rinfo
= listgetdata(listhead(list
));
1559 if (rinfo
!= NULL
&& rinfo
->type
== type
1560 && rinfo
->sub_type
== sub_type
1561 && rinfo
->ifindex
== ifindex
) {
1562 /* Perform poisoned reverse. */
1563 rinfo
->metric
= RIP_METRIC_INFINITY
;
1564 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
1565 rip_garbage_collect
,
1567 RIP_TIMER_OFF(rinfo
->t_timeout
);
1568 rinfo
->flags
|= RIP_RTF_CHANGED
;
1570 if (IS_RIP_DEBUG_EVENT
)
1572 "Poisone %s/%d on the interface %s with an "
1573 "infinity metric [delete]",
1574 inet_ntoa(p
->prefix
),
1576 ifindex2ifname(ifindex
,
1579 rip_event(RIP_TRIGGERED_UPDATE
, 0);
1582 route_unlock_node(rp
);
1586 /* Response to request called from rip_read ().*/
1587 static void rip_request_process(struct rip_packet
*packet
, int size
,
1588 struct sockaddr_in
*from
, struct connected
*ifc
)
1592 struct prefix_ipv4 p
;
1593 struct route_node
*rp
;
1594 struct rip_info
*rinfo
;
1595 struct rip_interface
*ri
;
1597 /* Does not reponse to the requests on the loopback interfaces */
1598 if (if_is_loopback(ifc
->ifp
))
1601 /* Check RIP process is enabled on this interface. */
1602 ri
= ifc
->ifp
->info
;
1606 /* When passive interface is specified, suppress responses */
1610 /* RIP peer update. */
1611 rip_peer_update(from
, packet
->version
);
1613 lim
= ((caddr_t
)packet
) + size
;
1616 /* The Request is processed entry by entry. If there are no
1617 entries, no response is given. */
1618 if (lim
== (caddr_t
)rte
)
1621 /* There is one special case. If there is exactly one entry in the
1622 request, and it has an address family identifier of zero and a
1623 metric of infinity (i.e., 16), then this is a request to send the
1624 entire routing table. */
1625 if (lim
== ((caddr_t
)(rte
+ 1)) && ntohs(rte
->family
) == 0
1626 && ntohl(rte
->metric
) == RIP_METRIC_INFINITY
) {
1627 /* All route with split horizon */
1628 rip_output_process(ifc
, from
, rip_all_route
, packet
->version
);
1630 if (ntohs(rte
->family
) != AF_INET
)
1633 /* Examine the list of RTEs in the Request one by one. For each
1634 entry, look up the destination in the router's routing
1635 database and, if there is a route, put that route's metric in
1636 the metric field of the RTE. If there is no explicit route
1637 to the specified destination, put infinity in the metric
1638 field. Once all the entries have been filled in, change the
1639 command from Request to Response and send the datagram back
1640 to the requestor. */
1643 for (; ((caddr_t
)rte
) < lim
; rte
++) {
1644 p
.prefix
= rte
->prefix
;
1645 p
.prefixlen
= ip_masklen(rte
->mask
);
1646 apply_mask_ipv4(&p
);
1648 rp
= route_node_lookup(rip
->table
, (struct prefix
*)&p
);
1650 rinfo
= listgetdata(
1651 listhead((struct list
*)rp
->info
));
1652 rte
->metric
= htonl(rinfo
->metric
);
1653 route_unlock_node(rp
);
1655 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
1657 packet
->command
= RIP_RESPONSE
;
1659 rip_send_packet((u_char
*)packet
, size
, from
, ifc
);
1661 rip_global_queries
++;
1665 /* Set IPv6 packet info to the socket. */
1666 static int setsockopt_pktinfo(int sock
)
1671 ret
= setsockopt(sock
, IPPROTO_IP
, IP_PKTINFO
, &val
, sizeof(val
));
1673 zlog_warn("Can't setsockopt IP_PKTINFO : %s",
1674 safe_strerror(errno
));
1678 /* Read RIP packet by recvmsg function. */
1679 int rip_recvmsg(int sock
, u_char
*buf
, int size
, struct sockaddr_in
*from
,
1685 struct cmsghdr
*ptr
;
1688 msg
.msg_name
= (void *)from
;
1689 msg
.msg_namelen
= sizeof(struct sockaddr_in
);
1692 msg
.msg_control
= (void *)adata
;
1693 msg
.msg_controllen
= sizeof adata
;
1697 ret
= recvmsg(sock
, &msg
, 0);
1701 for (ptr
= ZCMSG_FIRSTHDR(&msg
); ptr
!= NULL
;
1702 ptr
= CMSG_NXTHDR(&msg
, ptr
))
1703 if (ptr
->cmsg_level
== IPPROTO_IP
1704 && ptr
->cmsg_type
== IP_PKTINFO
) {
1705 struct in_pktinfo
*pktinfo
;
1708 pktinfo
= (struct in_pktinfo
*)CMSG_DATA(ptr
);
1709 i
= pktinfo
->ipi_ifindex
;
1714 /* RIP packet read function. */
1715 int rip_read_new(struct thread
*t
)
1719 char buf
[RIP_PACKET_MAXSIZ
];
1720 struct sockaddr_in from
;
1723 /* Fetch socket then register myself. */
1724 sock
= THREAD_FD(t
);
1725 rip_event(RIP_READ
, sock
);
1727 /* Read RIP packet. */
1728 ret
= rip_recvmsg(sock
, buf
, RIP_PACKET_MAXSIZ
, &from
, (int *)&ifindex
);
1730 zlog_warn("Can't read RIP packet: %s", safe_strerror(errno
));
1736 #endif /* RIP_RECVMSG */
1738 /* First entry point of RIP packet. */
1739 static int rip_read(struct thread
*t
)
1744 union rip_buf rip_buf
;
1745 struct rip_packet
*packet
;
1746 struct sockaddr_in from
;
1750 struct interface
*ifp
= NULL
;
1751 struct connected
*ifc
;
1752 struct rip_interface
*ri
;
1755 /* Fetch socket then register myself. */
1756 sock
= THREAD_FD(t
);
1759 /* Add myself to tne next event */
1760 rip_event(RIP_READ
, sock
);
1762 /* RIPd manages only IPv4. */
1763 memset(&from
, 0, sizeof(struct sockaddr_in
));
1764 fromlen
= sizeof(struct sockaddr_in
);
1766 len
= recvfrom(sock
, (char *)&rip_buf
.buf
, sizeof(rip_buf
.buf
), 0,
1767 (struct sockaddr
*)&from
, &fromlen
);
1769 zlog_info("recvfrom failed: %s", safe_strerror(errno
));
1773 /* Check is this packet comming from myself? */
1774 if (if_check_address(from
.sin_addr
)) {
1775 if (IS_RIP_DEBUG_PACKET
)
1776 zlog_debug("ignore packet comes from myself");
1780 /* Which interface is this packet comes from. */
1781 ifc
= if_lookup_address((void *)&from
.sin_addr
, AF_INET
, VRF_DEFAULT
);
1785 /* RIP packet received */
1786 if (IS_RIP_DEBUG_EVENT
)
1787 zlog_debug("RECV packet from %s port %d on %s",
1788 inet_ntoa(from
.sin_addr
), ntohs(from
.sin_port
),
1789 ifp
? ifp
->name
: "unknown");
1791 /* If this packet come from unknown interface, ignore it. */
1794 "rip_read: cannot find interface for packet from %s port %d",
1795 inet_ntoa(from
.sin_addr
), ntohs(from
.sin_port
));
1800 p
.u
.prefix4
= from
.sin_addr
;
1801 p
.prefixlen
= IPV4_MAX_BITLEN
;
1803 ifc
= connected_lookup_prefix(ifp
, &p
);
1807 "rip_read: cannot find connected address for packet from %s "
1808 "port %d on interface %s",
1809 inet_ntoa(from
.sin_addr
), ntohs(from
.sin_port
),
1814 /* Packet length check. */
1815 if (len
< RIP_PACKET_MINSIZ
) {
1816 zlog_warn("packet size %d is smaller than minimum size %d", len
,
1818 rip_peer_bad_packet(&from
);
1821 if (len
> RIP_PACKET_MAXSIZ
) {
1822 zlog_warn("packet size %d is larger than max size %d", len
,
1824 rip_peer_bad_packet(&from
);
1828 /* Packet alignment check. */
1829 if ((len
- RIP_PACKET_MINSIZ
) % 20) {
1830 zlog_warn("packet size %d is wrong for RIP packet alignment",
1832 rip_peer_bad_packet(&from
);
1836 /* Set RTE number. */
1837 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1839 /* For easy to handle. */
1840 packet
= &rip_buf
.rip_packet
;
1842 /* RIP version check. */
1843 if (packet
->version
== 0) {
1844 zlog_info("version 0 with command %d received.",
1846 rip_peer_bad_packet(&from
);
1850 /* Dump RIP packet. */
1851 if (IS_RIP_DEBUG_RECV
)
1852 rip_packet_dump(packet
, len
, "RECV");
1854 /* RIP version adjust. This code should rethink now. RFC1058 says
1855 that "Version 1 implementations are to ignore this extra data and
1856 process only the fields specified in this document.". So RIPv3
1857 packet should be treated as RIPv1 ignoring must be zero field. */
1858 if (packet
->version
> RIPv2
)
1859 packet
->version
= RIPv2
;
1861 /* Is RIP running or is this RIP neighbor ?*/
1863 if (!ri
->running
&& !rip_neighbor_lookup(&from
)) {
1864 if (IS_RIP_DEBUG_EVENT
)
1865 zlog_debug("RIP is not enabled on interface %s.",
1867 rip_peer_bad_packet(&from
);
1871 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1872 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ? rip
->version_recv
1874 if (vrecv
== RI_RIP_VERSION_NONE
1875 || ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1876 || ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))) {
1877 if (IS_RIP_DEBUG_PACKET
)
1879 " packet's v%d doesn't fit to if version spec",
1881 rip_peer_bad_packet(&from
);
1885 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1886 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1887 accepted; authenticated RIP-2 messages shall be discarded. */
1888 if ((ri
->auth_type
== RIP_NO_AUTH
) && rtenum
1889 && (packet
->version
== RIPv2
)
1890 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
))) {
1891 if (IS_RIP_DEBUG_EVENT
)
1893 "packet RIPv%d is dropped because authentication disabled",
1895 rip_peer_bad_packet(&from
);
1900 If the router is configured to authenticate RIP-2 messages, then
1901 RIP-1 messages and RIP-2 messages which pass authentication
1902 testing shall be accepted; unauthenticated and failed
1903 authentication RIP-2 messages shall be discarded. For maximum
1904 security, RIP-1 messages should be ignored when authentication is
1905 in use (see section 4.1); otherwise, the routing information from
1906 authenticated messages will be propagated by RIP-1 routers in an
1907 unauthenticated manner.
1909 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1910 * always reply regardless of authentication settings, because:
1912 * - if there other authorised routers on-link, the REQUESTor can
1913 * passively obtain the routing updates anyway
1914 * - if there are no other authorised routers on-link, RIP can
1915 * easily be disabled for the link to prevent giving out information
1916 * on state of this routers RIP routing table..
1918 * I.e. if RIPv1 has any place anymore these days, it's as a very
1919 * simple way to distribute routing information (e.g. to embedded
1920 * hosts / appliances) and the ability to give out RIPv1
1921 * routing-information freely, while still requiring RIPv2
1922 * authentication for any RESPONSEs might be vaguely useful.
1924 if (ri
->auth_type
!= RIP_NO_AUTH
&& packet
->version
== RIPv1
) {
1925 /* Discard RIPv1 messages other than REQUESTs */
1926 if (packet
->command
!= RIP_REQUEST
) {
1927 if (IS_RIP_DEBUG_PACKET
)
1930 " dropped because authentication enabled");
1931 rip_peer_bad_packet(&from
);
1934 } else if (ri
->auth_type
!= RIP_NO_AUTH
) {
1935 const char *auth_desc
;
1938 /* There definitely is no authentication in the packet.
1940 if (IS_RIP_DEBUG_PACKET
)
1942 "RIPv2 authentication failed: no auth RTE in packet");
1943 rip_peer_bad_packet(&from
);
1947 /* First RTE must be an Authentication Family RTE */
1948 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
)) {
1949 if (IS_RIP_DEBUG_PACKET
)
1952 " dropped because authentication enabled");
1953 rip_peer_bad_packet(&from
);
1957 /* Check RIPv2 authentication. */
1958 switch (ntohs(packet
->rte
->tag
)) {
1959 case RIP_AUTH_SIMPLE_PASSWORD
:
1960 auth_desc
= "simple";
1961 ret
= rip_auth_simple_password(packet
->rte
, &from
, ifp
);
1966 ret
= rip_auth_md5(packet
, &from
, len
, ifp
);
1967 /* Reset RIP packet length to trim MD5 data. */
1973 auth_desc
= "unknown type";
1974 if (IS_RIP_DEBUG_PACKET
)
1976 "RIPv2 Unknown authentication type %d",
1977 ntohs(packet
->rte
->tag
));
1981 if (IS_RIP_DEBUG_PACKET
)
1982 zlog_debug("RIPv2 %s authentication success",
1985 if (IS_RIP_DEBUG_PACKET
)
1986 zlog_debug("RIPv2 %s authentication failure",
1988 rip_peer_bad_packet(&from
);
1993 /* Process each command. */
1994 switch (packet
->command
) {
1996 rip_response_process(packet
, len
, &from
, ifc
);
2000 rip_request_process(packet
, len
, &from
, ifc
);
2005 "Obsolete command %s received, please sent it to routed",
2006 lookup_msg(rip_msg
, packet
->command
, NULL
));
2007 rip_peer_bad_packet(&from
);
2009 case RIP_POLL_ENTRY
:
2010 zlog_info("Obsolete command %s received",
2011 lookup_msg(rip_msg
, packet
->command
, NULL
));
2012 rip_peer_bad_packet(&from
);
2015 zlog_info("Unknown RIP command %d received", packet
->command
);
2016 rip_peer_bad_packet(&from
);
2023 /* Write routing table entry to the stream and return next index of
2024 the routing table entry in the stream. */
2025 static int rip_write_rte(int num
, struct stream
*s
, struct prefix_ipv4
*p
,
2026 u_char version
, struct rip_info
*rinfo
)
2028 struct in_addr mask
;
2030 /* Write routing table entry. */
2031 if (version
== RIPv1
) {
2032 stream_putw(s
, AF_INET
);
2034 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2035 stream_put_ipv4(s
, 0);
2036 stream_put_ipv4(s
, 0);
2037 stream_putl(s
, rinfo
->metric_out
);
2039 masklen2ip(p
->prefixlen
, &mask
);
2041 stream_putw(s
, AF_INET
);
2042 stream_putw(s
, rinfo
->tag_out
);
2043 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2044 stream_put_ipv4(s
, mask
.s_addr
);
2045 stream_put_ipv4(s
, rinfo
->nexthop_out
.s_addr
);
2046 stream_putl(s
, rinfo
->metric_out
);
2052 /* Send update to the ifp or spcified neighbor. */
2053 void rip_output_process(struct connected
*ifc
, struct sockaddr_in
*to
,
2054 int route_type
, u_char version
)
2058 struct route_node
*rp
;
2059 struct rip_info
*rinfo
;
2060 struct rip_interface
*ri
;
2061 struct prefix_ipv4
*p
;
2062 struct prefix_ipv4 classfull
;
2063 struct prefix_ipv4 ifaddrclass
;
2064 struct key
*key
= NULL
;
2065 /* this might need to made dynamic if RIP ever supported auth methods
2066 with larger key string sizes */
2067 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2068 size_t doff
= 0; /* offset of digest offset field */
2072 struct list
*list
= NULL
;
2073 struct listnode
*listnode
= NULL
;
2075 /* Logging output event. */
2076 if (IS_RIP_DEBUG_EVENT
) {
2078 zlog_debug("update routes to neighbor %s",
2079 inet_ntoa(to
->sin_addr
));
2081 zlog_debug("update routes on interface %s ifindex %d",
2082 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2085 /* Set output stream. */
2088 /* Reset stream and RTE counter. */
2090 rtemax
= RIP_MAX_RTE
;
2092 /* Get RIP interface. */
2093 ri
= ifc
->ifp
->info
;
2095 /* If output interface is in simple password authentication mode, we
2096 need space for authentication data. */
2097 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2100 /* If output interface is in MD5 authentication mode, we need space
2101 for authentication header and data. */
2102 if (ri
->auth_type
== RIP_AUTH_MD5
)
2105 /* If output interface is in simple password authentication mode
2106 and string or keychain is specified we need space for auth. data */
2107 if (ri
->auth_type
!= RIP_NO_AUTH
) {
2108 if (ri
->key_chain
) {
2109 struct keychain
*keychain
;
2111 keychain
= keychain_lookup(ri
->key_chain
);
2113 key
= key_lookup_for_send(keychain
);
2115 /* to be passed to auth functions later */
2116 rip_auth_prepare_str_send(ri
, key
, auth_str
,
2117 RIP_AUTH_SIMPLE_SIZE
);
2120 if (version
== RIPv1
) {
2121 memcpy(&ifaddrclass
, ifc
->address
, sizeof(struct prefix_ipv4
));
2122 apply_classful_mask_ipv4(&ifaddrclass
);
2124 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2128 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
))
2129 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
2130 rinfo
= listgetdata(listhead(list
));
2131 /* For RIPv1, if we are subnetted, output subnets in our
2133 /* that have the same mask as the output "interface".
2135 /* networks, only the classfull version is output. */
2137 if (version
== RIPv1
) {
2138 p
= (struct prefix_ipv4
*)&rp
->p
;
2140 if (IS_RIP_DEBUG_PACKET
)
2142 "RIPv1 mask check, %s/%d considered for output",
2143 inet_ntoa(rp
->p
.u
.prefix4
),
2148 (struct prefix
*)&ifaddrclass
,
2150 if ((ifc
->address
->prefixlen
2152 && (rp
->p
.prefixlen
!= 32))
2155 memcpy(&classfull
, &rp
->p
,
2156 sizeof(struct prefix_ipv4
));
2157 apply_classful_mask_ipv4(&classfull
);
2158 if (rp
->p
.u
.prefix4
.s_addr
!= 0
2159 && classfull
.prefixlen
2163 if (IS_RIP_DEBUG_PACKET
)
2165 "RIPv1 mask check, %s/%d made it through",
2166 inet_ntoa(rp
->p
.u
.prefix4
),
2169 p
= (struct prefix_ipv4
*)&rp
->p
;
2171 /* Apply output filters. */
2172 ret
= rip_filter(RIP_FILTER_OUT
, p
, ri
);
2176 /* Changed route only output. */
2177 if (route_type
== rip_changed_route
2178 && (!(rinfo
->flags
& RIP_RTF_CHANGED
)))
2181 /* Split horizon. */
2182 /* if (split_horizon == rip_split_horizon) */
2183 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
) {
2185 * We perform split horizon for RIP and
2187 * For rip routes, we want to suppress the route
2189 * end up sending the route back on the
2191 * learned it from, with a higher metric. For
2193 * we suppress the route if the prefix is a
2195 * source address that we are going to use for
2197 * (in order to handle the case when multiple
2199 * configured on the same interface).
2202 struct rip_info
*tmp_rinfo
= NULL
;
2204 for (ALL_LIST_ELEMENTS_RO(list
, listnode
,
2206 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
2207 && tmp_rinfo
->ifindex
2208 == ifc
->ifp
->ifindex
) {
2214 && rinfo
->type
== ZEBRA_ROUTE_CONNECT
2215 && prefix_match((struct prefix
*)p
,
2223 /* Preparation for route-map. */
2224 rinfo
->metric_set
= 0;
2225 rinfo
->nexthop_out
.s_addr
= 0;
2226 rinfo
->metric_out
= rinfo
->metric
;
2227 rinfo
->tag_out
= rinfo
->tag
;
2228 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2230 /* In order to avoid some local loops,
2231 * if the RIP route has a nexthop via this interface,
2233 * otherwise set it to 0. The nexthop should not be
2235 * beyond the local broadcast/multicast area in order
2236 * to avoid an IGP multi-level recursive look-up.
2239 if (rinfo
->ifindex
== ifc
->ifp
->ifindex
)
2240 rinfo
->nexthop_out
= rinfo
->nexthop
;
2242 /* Interface route-map */
2243 if (ri
->routemap
[RIP_FILTER_OUT
]) {
2244 ret
= route_map_apply(
2245 ri
->routemap
[RIP_FILTER_OUT
],
2246 (struct prefix
*)p
, RMAP_RIP
, rinfo
);
2248 if (ret
== RMAP_DENYMATCH
) {
2249 if (IS_RIP_DEBUG_PACKET
)
2251 "RIP %s/%d is filtered by route-map out",
2252 inet_ntoa(p
->prefix
),
2258 /* Apply redistribute route map - continue, if deny */
2259 if (rip
->route_map
[rinfo
->type
].name
2260 && rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2261 ret
= route_map_apply(
2262 rip
->route_map
[rinfo
->type
].map
,
2263 (struct prefix
*)p
, RMAP_RIP
, rinfo
);
2265 if (ret
== RMAP_DENYMATCH
) {
2266 if (IS_RIP_DEBUG_PACKET
)
2268 "%s/%d is filtered by route-map",
2269 inet_ntoa(p
->prefix
),
2275 /* When route-map does not set metric. */
2276 if (!rinfo
->metric_set
) {
2277 /* If redistribute metric is set. */
2278 if (rip
->route_map
[rinfo
->type
].metric_config
2279 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
2281 rip
->route_map
[rinfo
->type
]
2284 /* If the route is not connected or
2286 one, use default-metric value*/
2287 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
2289 != ZEBRA_ROUTE_CONNECT
2291 != RIP_METRIC_INFINITY
)
2293 rip
->default_metric
;
2297 /* Apply offset-list */
2298 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2299 rip_offset_list_apply_out(p
, ifc
->ifp
,
2300 &rinfo
->metric_out
);
2302 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2303 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2305 /* Perform split-horizon with poisoned reverse
2306 * for RIP and connected routes.
2308 if (ri
->split_horizon
2309 == RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2311 * We perform split horizon for RIP and
2313 * For rip routes, we want to suppress the route
2315 * end up sending the route back on the
2317 * learned it from, with a higher metric. For
2319 * we suppress the route if the prefix is a
2321 * source address that we are going to use for
2323 * (in order to handle the case when multiple
2325 * configured on the same interface).
2327 struct rip_info
*tmp_rinfo
= NULL
;
2329 for (ALL_LIST_ELEMENTS_RO(list
, listnode
,
2331 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
2332 && tmp_rinfo
->ifindex
2333 == ifc
->ifp
->ifindex
)
2335 RIP_METRIC_INFINITY
;
2336 if (tmp_rinfo
->type
== ZEBRA_ROUTE_CONNECT
2337 && prefix_match((struct prefix
*)p
,
2339 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2342 /* Prepare preamble, auth headers, if needs be */
2344 stream_putc(s
, RIP_RESPONSE
);
2345 stream_putc(s
, version
);
2348 /* auth header for !v1 && !no_auth */
2349 if ((ri
->auth_type
!= RIP_NO_AUTH
)
2350 && (version
!= RIPv1
))
2351 doff
= rip_auth_header_write(
2352 s
, ri
, key
, auth_str
,
2353 RIP_AUTH_SIMPLE_SIZE
);
2356 /* Write RTE to the stream. */
2357 num
= rip_write_rte(num
, s
, p
, version
, rinfo
);
2358 if (num
== rtemax
) {
2359 if (version
== RIPv2
2360 && ri
->auth_type
== RIP_AUTH_MD5
)
2361 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2362 RIP_AUTH_SIMPLE_SIZE
);
2364 ret
= rip_send_packet(STREAM_DATA(s
),
2365 stream_get_endp(s
), to
,
2368 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2369 rip_packet_dump((struct rip_packet
*)
2378 /* Flush unwritten RTE. */
2380 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2381 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2382 RIP_AUTH_SIMPLE_SIZE
);
2384 ret
= rip_send_packet(STREAM_DATA(s
), stream_get_endp(s
), to
,
2387 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2388 rip_packet_dump((struct rip_packet
*)STREAM_DATA(s
),
2389 stream_get_endp(s
), "SEND");
2393 /* Statistics updates. */
2397 /* Send RIP packet to the interface. */
2398 static void rip_update_interface(struct connected
*ifc
, u_char version
,
2401 struct interface
*ifp
= ifc
->ifp
;
2402 struct rip_interface
*ri
= ifp
->info
;
2403 struct sockaddr_in to
;
2405 /* When RIP version is 2 and multicast enable interface. */
2406 if (version
== RIPv2
&& !ri
->v2_broadcast
&& if_is_multicast(ifp
)) {
2407 if (IS_RIP_DEBUG_EVENT
)
2408 zlog_debug("multicast announce on %s ", ifp
->name
);
2410 rip_output_process(ifc
, NULL
, route_type
, version
);
2414 /* If we can't send multicast packet, send it with unicast. */
2415 if (if_is_broadcast(ifp
) || if_is_pointopoint(ifp
)) {
2416 if (ifc
->address
->family
== AF_INET
) {
2417 /* Destination address and port setting. */
2418 memset(&to
, 0, sizeof(struct sockaddr_in
));
2419 if (ifc
->destination
)
2420 /* use specified broadcast or peer destination
2422 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2423 else if (ifc
->address
->prefixlen
< IPV4_MAX_PREFIXLEN
)
2424 /* calculate the appropriate broadcast address
2426 to
.sin_addr
.s_addr
= ipv4_broadcast_addr(
2427 ifc
->address
->u
.prefix4
.s_addr
,
2428 ifc
->address
->prefixlen
);
2430 /* do not know where to send the packet */
2432 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2434 if (IS_RIP_DEBUG_EVENT
)
2435 zlog_debug("%s announce to %s on %s",
2436 CONNECTED_PEER(ifc
) ? "unicast"
2438 inet_ntoa(to
.sin_addr
), ifp
->name
);
2440 rip_output_process(ifc
, &to
, route_type
, version
);
2445 /* Update send to all interface and neighbor. */
2446 static void rip_update_process(int route_type
)
2448 struct listnode
*node
;
2449 struct listnode
*ifnode
, *ifnnode
;
2450 struct connected
*connected
;
2451 struct interface
*ifp
;
2452 struct rip_interface
*ri
;
2453 struct route_node
*rp
;
2454 struct sockaddr_in to
;
2457 /* Send RIP update to each interface. */
2458 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT
), node
, ifp
)) {
2459 if (if_is_loopback(ifp
))
2462 if (!if_is_operative(ifp
))
2465 /* Fetch RIP interface information. */
2468 /* When passive interface is specified, suppress announce to the
2475 * If there is no version configuration in the
2477 * use rip's version setting.
2479 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
)
2483 if (IS_RIP_DEBUG_EVENT
)
2484 zlog_debug("SEND UPDATE to %s ifindex %d",
2485 ifp
->name
, ifp
->ifindex
);
2487 /* send update on each connected network */
2488 for (ALL_LIST_ELEMENTS(ifp
->connected
, ifnode
, ifnnode
,
2490 if (connected
->address
->family
== AF_INET
) {
2492 rip_update_interface(
2496 && if_is_multicast(ifp
))
2497 rip_update_interface(
2505 /* RIP send updates to each neighbor. */
2506 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
))
2507 if (rp
->info
!= NULL
) {
2510 connected
= if_lookup_address(&p
->u
.prefix4
, AF_INET
,
2514 "Neighbor %s doesnt have connected interface!",
2515 inet_ntoa(p
->u
.prefix4
));
2519 /* Set destination address and port */
2520 memset(&to
, 0, sizeof(struct sockaddr_in
));
2521 to
.sin_addr
= p
->u
.prefix4
;
2522 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2524 /* RIP version is rip's configuration. */
2525 rip_output_process(connected
, &to
, route_type
,
2530 /* RIP's periodical timer. */
2531 static int rip_update(struct thread
*t
)
2533 /* Clear timer pointer. */
2534 rip
->t_update
= NULL
;
2536 if (IS_RIP_DEBUG_EVENT
)
2537 zlog_debug("update timer fire!");
2539 /* Process update output. */
2540 rip_update_process(rip_all_route
);
2542 /* Triggered updates may be suppressed if a regular update is due by
2543 the time the triggered update would be sent. */
2544 RIP_TIMER_OFF(rip
->t_triggered_interval
);
2547 /* Register myself. */
2548 rip_event(RIP_UPDATE_EVENT
, 0);
2553 /* Walk down the RIP routing table then clear changed flag. */
2554 static void rip_clear_changed_flag(void)
2556 struct route_node
*rp
;
2557 struct rip_info
*rinfo
= NULL
;
2558 struct list
*list
= NULL
;
2559 struct listnode
*listnode
= NULL
;
2561 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
))
2562 if ((list
= rp
->info
) != NULL
)
2563 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
2564 UNSET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2565 /* This flag can be set only on the first entry.
2571 /* Triggered update interval timer. */
2572 static int rip_triggered_interval(struct thread
*t
)
2574 int rip_triggered_update(struct thread
*);
2576 rip
->t_triggered_interval
= NULL
;
2580 rip_triggered_update(t
);
2585 /* Execute triggered update. */
2586 static int rip_triggered_update(struct thread
*t
)
2590 /* Clear thred pointer. */
2591 rip
->t_triggered_update
= NULL
;
2593 /* Cancel interval timer. */
2594 RIP_TIMER_OFF(rip
->t_triggered_interval
);
2597 /* Logging triggered update. */
2598 if (IS_RIP_DEBUG_EVENT
)
2599 zlog_debug("triggered update!");
2601 /* Split Horizon processing is done when generating triggered
2602 updates as well as normal updates (see section 2.6). */
2603 rip_update_process(rip_changed_route
);
2605 /* Once all of the triggered updates have been generated, the route
2606 change flags should be cleared. */
2607 rip_clear_changed_flag();
2609 /* After a triggered update is sent, a timer should be set for a
2610 random interval between 1 and 5 seconds. If other changes that
2611 would trigger updates occur before the timer expires, a single
2612 update is triggered when the timer expires. */
2613 interval
= (random() % 5) + 1;
2615 rip
->t_triggered_interval
= NULL
;
2616 thread_add_timer(master
, rip_triggered_interval
, NULL
, interval
,
2617 &rip
->t_triggered_interval
);
2622 /* Withdraw redistributed route. */
2623 void rip_redistribute_withdraw(int type
)
2625 struct route_node
*rp
;
2626 struct rip_info
*rinfo
= NULL
;
2627 struct list
*list
= NULL
;
2632 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
))
2633 if ((list
= rp
->info
) != NULL
) {
2634 rinfo
= listgetdata(listhead(list
));
2635 if (rinfo
->type
== type
2636 && rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2637 /* Perform poisoned reverse. */
2638 rinfo
->metric
= RIP_METRIC_INFINITY
;
2639 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
2640 rip_garbage_collect
,
2642 RIP_TIMER_OFF(rinfo
->t_timeout
);
2643 rinfo
->flags
|= RIP_RTF_CHANGED
;
2645 if (IS_RIP_DEBUG_EVENT
) {
2646 struct prefix_ipv4
*p
=
2647 (struct prefix_ipv4
*)&rp
->p
;
2650 "Poisone %s/%d on the interface %s with an infinity metric [withdraw]",
2651 inet_ntoa(p
->prefix
),
2653 ifindex2ifname(rinfo
->ifindex
,
2657 rip_event(RIP_TRIGGERED_UPDATE
, 0);
2662 /* Create new RIP instance and set it to global variable. */
2663 static int rip_create(void)
2665 rip
= XCALLOC(MTYPE_RIP
, sizeof(struct rip
));
2667 /* Set initial value. */
2668 rip
->version_send
= RI_RIP_VERSION_2
;
2669 rip
->version_recv
= RI_RIP_VERSION_1_AND_2
;
2670 rip
->update_time
= RIP_UPDATE_TIMER_DEFAULT
;
2671 rip
->timeout_time
= RIP_TIMEOUT_TIMER_DEFAULT
;
2672 rip
->garbage_time
= RIP_GARBAGE_TIMER_DEFAULT
;
2673 rip
->default_metric
= RIP_DEFAULT_METRIC_DEFAULT
;
2675 /* Initialize RIP routig table. */
2676 rip
->table
= route_table_init();
2677 rip
->route
= route_table_init();
2678 rip
->neighbor
= route_table_init();
2680 /* Make output stream. */
2681 rip
->obuf
= stream_new(1500);
2684 rip
->sock
= rip_create_socket();
2688 /* Create read and timer thread. */
2689 rip_event(RIP_READ
, rip
->sock
);
2690 rip_event(RIP_UPDATE_EVENT
, 1);
2697 /* Sned RIP request to the destination. */
2698 int rip_request_send(struct sockaddr_in
*to
, struct interface
*ifp
,
2699 u_char version
, struct connected
*connected
)
2702 struct rip_packet rip_packet
;
2703 struct listnode
*node
, *nnode
;
2705 memset(&rip_packet
, 0, sizeof(rip_packet
));
2707 rip_packet
.command
= RIP_REQUEST
;
2708 rip_packet
.version
= version
;
2709 rte
= rip_packet
.rte
;
2710 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
2714 * connected is only sent for ripv1 case, or when
2715 * interface does not support multicast. Caller loops
2716 * over each connected address for this case.
2718 if (rip_send_packet((u_char
*)&rip_packet
, sizeof(rip_packet
),
2720 != sizeof(rip_packet
))
2723 return sizeof(rip_packet
);
2726 /* send request on each connected network */
2727 for (ALL_LIST_ELEMENTS(ifp
->connected
, node
, nnode
, connected
)) {
2728 struct prefix_ipv4
*p
;
2730 p
= (struct prefix_ipv4
*)connected
->address
;
2732 if (p
->family
!= AF_INET
)
2735 if (rip_send_packet((u_char
*)&rip_packet
, sizeof(rip_packet
),
2737 != sizeof(rip_packet
))
2740 return sizeof(rip_packet
);
2743 static int rip_update_jitter(unsigned long time
)
2745 #define JITTER_BOUND 4
2746 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2747 Given that, we cannot let time be less than JITTER_BOUND seconds.
2748 The RIPv2 RFC says jitter should be small compared to
2749 update_time. We consider 1/JITTER_BOUND to be small.
2752 int jitter_input
= time
;
2755 if (jitter_input
< JITTER_BOUND
)
2756 jitter_input
= JITTER_BOUND
;
2758 jitter
= (((random() % ((jitter_input
* 2) + 1)) - jitter_input
));
2760 return jitter
/ JITTER_BOUND
;
2763 void rip_event(enum rip_event event
, int sock
)
2770 thread_add_read(master
, rip_read
, NULL
, sock
, &rip
->t_read
);
2772 case RIP_UPDATE_EVENT
:
2773 RIP_TIMER_OFF(rip
->t_update
);
2774 jitter
= rip_update_jitter(rip
->update_time
);
2775 thread_add_timer(master
, rip_update
, NULL
,
2776 sock
? 2 : rip
->update_time
+ jitter
,
2779 case RIP_TRIGGERED_UPDATE
:
2780 if (rip
->t_triggered_interval
)
2783 thread_add_event(master
, rip_triggered_update
, NULL
, 0,
2784 &rip
->t_triggered_update
);
2791 DEFUN_NOSH (router_rip
,
2794 "Enable a routing process\n"
2795 "Routing Information Protocol (RIP)\n")
2799 /* If rip is not enabled before. */
2803 zlog_info("Can't create RIP");
2804 return CMD_WARNING_CONFIG_FAILED
;
2807 VTY_PUSH_CONTEXT(RIP_NODE
, rip
);
2812 DEFUN (no_router_rip
,
2816 "Enable a routing process\n"
2817 "Routing Information Protocol (RIP)\n")
2827 "Set routing protocol version\n"
2833 version
= atoi(argv
[idx_number
]->arg
);
2834 if (version
!= RIPv1
&& version
!= RIPv2
) {
2835 vty_out(vty
, "invalid rip version %d\n", version
);
2836 return CMD_WARNING_CONFIG_FAILED
;
2838 rip
->version_send
= version
;
2839 rip
->version_recv
= version
;
2844 DEFUN (no_rip_version
,
2846 "no version [(1-2)]",
2848 "Set routing protocol version\n"
2851 /* Set RIP version to the default. */
2852 rip
->version_send
= RI_RIP_VERSION_2
;
2853 rip
->version_recv
= RI_RIP_VERSION_1_AND_2
;
2862 "RIP static route configuration\n"
2863 "IP prefix <network>/<length>\n")
2865 int idx_ipv4_prefixlen
= 1;
2867 struct prefix_ipv4 p
;
2868 struct route_node
*node
;
2870 ret
= str2prefix_ipv4(argv
[idx_ipv4_prefixlen
]->arg
, &p
);
2872 vty_out(vty
, "Malformed address\n");
2873 return CMD_WARNING_CONFIG_FAILED
;
2875 apply_mask_ipv4(&p
);
2877 /* For router rip configuration. */
2878 node
= route_node_get(rip
->route
, (struct prefix
*)&p
);
2881 vty_out(vty
, "There is already same static route.\n");
2882 route_unlock_node(node
);
2883 return CMD_WARNING_CONFIG_FAILED
;
2886 node
->info
= (void *)1;
2888 rip_redistribute_add(ZEBRA_ROUTE_RIP
, RIP_ROUTE_STATIC
, &p
, 0, NULL
, 0,
2894 DEFUN (no_rip_route
,
2896 "no route A.B.C.D/M",
2898 "RIP static route configuration\n"
2899 "IP prefix <network>/<length>\n")
2901 int idx_ipv4_prefixlen
= 2;
2903 struct prefix_ipv4 p
;
2904 struct route_node
*node
;
2906 ret
= str2prefix_ipv4(argv
[idx_ipv4_prefixlen
]->arg
, &p
);
2908 vty_out(vty
, "Malformed address\n");
2909 return CMD_WARNING_CONFIG_FAILED
;
2911 apply_mask_ipv4(&p
);
2913 /* For router rip configuration. */
2914 node
= route_node_lookup(rip
->route
, (struct prefix
*)&p
);
2916 vty_out(vty
, "Can't find route %s.\n",
2917 argv
[idx_ipv4_prefixlen
]->arg
);
2918 return CMD_WARNING_CONFIG_FAILED
;
2921 rip_redistribute_delete(ZEBRA_ROUTE_RIP
, RIP_ROUTE_STATIC
, &p
, 0);
2922 route_unlock_node(node
);
2925 route_unlock_node(node
);
2932 rip_update_default_metric (void)
2934 struct route_node
*np
;
2935 struct rip_info
*rinfo
= NULL
;
2936 struct list
*list
= NULL
;
2937 struct listnode
*listnode
= NULL
;
2939 for (np
= route_top (rip
->table
); np
; np
= route_next (np
))
2940 if ((list
= np
->info
) != NULL
)
2941 for (ALL_LIST_ELEMENTS_RO (list
, listnode
, rinfo
))
2942 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&& rinfo
->type
!= ZEBRA_ROUTE_CONNECT
)
2943 rinfo
->metric
= rip
->default_metric
;
2947 DEFUN (rip_default_metric
,
2948 rip_default_metric_cmd
,
2949 "default-metric (1-16)",
2950 "Set a metric of redistribute routes\n"
2955 rip
->default_metric
= atoi(argv
[idx_number
]->arg
);
2956 /* rip_update_default_metric (); */
2961 DEFUN (no_rip_default_metric
,
2962 no_rip_default_metric_cmd
,
2963 "no default-metric [(1-16)]",
2965 "Set a metric of redistribute routes\n"
2969 rip
->default_metric
= RIP_DEFAULT_METRIC_DEFAULT
;
2970 /* rip_update_default_metric (); */
2978 "timers basic (5-2147483647) (5-2147483647) (5-2147483647)",
2979 "Adjust routing timers\n"
2980 "Basic routing protocol update timers\n"
2981 "Routing table update timer value in second. Default is 30.\n"
2982 "Routing information timeout timer. Default is 180.\n"
2983 "Garbage collection timer. Default is 120.\n")
2986 int idx_number_2
= 3;
2987 int idx_number_3
= 4;
2988 unsigned long update
;
2989 unsigned long timeout
;
2990 unsigned long garbage
;
2991 char *endptr
= NULL
;
2992 unsigned long RIP_TIMER_MAX
= 2147483647;
2993 unsigned long RIP_TIMER_MIN
= 5;
2995 update
= strtoul(argv
[idx_number
]->arg
, &endptr
, 10);
2996 if (update
> RIP_TIMER_MAX
|| update
< RIP_TIMER_MIN
2997 || *endptr
!= '\0') {
2998 vty_out(vty
, "update timer value error\n");
2999 return CMD_WARNING_CONFIG_FAILED
;
3002 timeout
= strtoul(argv
[idx_number_2
]->arg
, &endptr
, 10);
3003 if (timeout
> RIP_TIMER_MAX
|| timeout
< RIP_TIMER_MIN
3004 || *endptr
!= '\0') {
3005 vty_out(vty
, "timeout timer value error\n");
3006 return CMD_WARNING_CONFIG_FAILED
;
3009 garbage
= strtoul(argv
[idx_number_3
]->arg
, &endptr
, 10);
3010 if (garbage
> RIP_TIMER_MAX
|| garbage
< RIP_TIMER_MIN
3011 || *endptr
!= '\0') {
3012 vty_out(vty
, "garbage timer value error\n");
3013 return CMD_WARNING_CONFIG_FAILED
;
3016 /* Set each timer value. */
3017 rip
->update_time
= update
;
3018 rip
->timeout_time
= timeout
;
3019 rip
->garbage_time
= garbage
;
3021 /* Reset update timer thread. */
3022 rip_event(RIP_UPDATE_EVENT
, 0);
3027 DEFUN (no_rip_timers
,
3029 "no timers basic [(0-65535) (0-65535) (0-65535)]",
3031 "Adjust routing timers\n"
3032 "Basic routing protocol update timers\n"
3033 "Routing table update timer value in second. Default is 30.\n"
3034 "Routing information timeout timer. Default is 180.\n"
3035 "Garbage collection timer. Default is 120.\n")
3037 /* Set each timer value to the default. */
3038 rip
->update_time
= RIP_UPDATE_TIMER_DEFAULT
;
3039 rip
->timeout_time
= RIP_TIMEOUT_TIMER_DEFAULT
;
3040 rip
->garbage_time
= RIP_GARBAGE_TIMER_DEFAULT
;
3042 /* Reset update timer thread. */
3043 rip_event(RIP_UPDATE_EVENT
, 0);
3049 struct route_table
*rip_distance_table
;
3051 struct rip_distance
{
3052 /* Distance value for the IP source prefix. */
3055 /* Name of the access-list to be matched. */
3059 static struct rip_distance
*rip_distance_new(void)
3061 return XCALLOC(MTYPE_RIP_DISTANCE
, sizeof(struct rip_distance
));
3064 static void rip_distance_free(struct rip_distance
*rdistance
)
3066 XFREE(MTYPE_RIP_DISTANCE
, rdistance
);
3069 static int rip_distance_set(struct vty
*vty
, const char *distance_str
,
3070 const char *ip_str
, const char *access_list_str
)
3073 struct prefix_ipv4 p
;
3075 struct route_node
*rn
;
3076 struct rip_distance
*rdistance
;
3078 ret
= str2prefix_ipv4(ip_str
, &p
);
3080 vty_out(vty
, "Malformed prefix\n");
3081 return CMD_WARNING_CONFIG_FAILED
;
3084 distance
= atoi(distance_str
);
3086 /* Get RIP distance node. */
3087 rn
= route_node_get(rip_distance_table
, (struct prefix
*)&p
);
3089 rdistance
= rn
->info
;
3090 route_unlock_node(rn
);
3092 rdistance
= rip_distance_new();
3093 rn
->info
= rdistance
;
3096 /* Set distance value. */
3097 rdistance
->distance
= distance
;
3099 /* Reset access-list configuration. */
3100 if (rdistance
->access_list
) {
3101 free(rdistance
->access_list
);
3102 rdistance
->access_list
= NULL
;
3104 if (access_list_str
)
3105 rdistance
->access_list
= strdup(access_list_str
);
3110 static int rip_distance_unset(struct vty
*vty
, const char *distance_str
,
3111 const char *ip_str
, const char *access_list_str
)
3114 struct prefix_ipv4 p
;
3115 struct route_node
*rn
;
3116 struct rip_distance
*rdistance
;
3118 ret
= str2prefix_ipv4(ip_str
, &p
);
3120 vty_out(vty
, "Malformed prefix\n");
3121 return CMD_WARNING_CONFIG_FAILED
;
3124 rn
= route_node_lookup(rip_distance_table
, (struct prefix
*)&p
);
3126 vty_out(vty
, "Can't find specified prefix\n");
3127 return CMD_WARNING_CONFIG_FAILED
;
3130 rdistance
= rn
->info
;
3132 if (rdistance
->access_list
)
3133 free(rdistance
->access_list
);
3134 rip_distance_free(rdistance
);
3137 route_unlock_node(rn
);
3138 route_unlock_node(rn
);
3143 static void rip_distance_reset(void)
3145 struct route_node
*rn
;
3146 struct rip_distance
*rdistance
;
3148 for (rn
= route_top(rip_distance_table
); rn
; rn
= route_next(rn
))
3149 if ((rdistance
= rn
->info
) != NULL
) {
3150 if (rdistance
->access_list
)
3151 free(rdistance
->access_list
);
3152 rip_distance_free(rdistance
);
3154 route_unlock_node(rn
);
3158 /* Apply RIP information to distance method. */
3159 u_char
rip_distance_apply(struct rip_info
*rinfo
)
3161 struct route_node
*rn
;
3162 struct prefix_ipv4 p
;
3163 struct rip_distance
*rdistance
;
3164 struct access_list
*alist
;
3169 memset(&p
, 0, sizeof(struct prefix_ipv4
));
3171 p
.prefix
= rinfo
->from
;
3172 p
.prefixlen
= IPV4_MAX_BITLEN
;
3174 /* Check source address. */
3175 rn
= route_node_match(rip_distance_table
, (struct prefix
*)&p
);
3177 rdistance
= rn
->info
;
3178 route_unlock_node(rn
);
3180 if (rdistance
->access_list
) {
3181 alist
= access_list_lookup(AFI_IP
,
3182 rdistance
->access_list
);
3185 if (access_list_apply(alist
, &rinfo
->rp
->p
)
3189 return rdistance
->distance
;
3191 return rdistance
->distance
;
3195 return rip
->distance
;
3200 static void rip_distance_show(struct vty
*vty
)
3202 struct route_node
*rn
;
3203 struct rip_distance
*rdistance
;
3207 vty_out(vty
, " Distance: (default is %d)\n",
3208 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
3210 for (rn
= route_top(rip_distance_table
); rn
; rn
= route_next(rn
))
3211 if ((rdistance
= rn
->info
) != NULL
) {
3214 " Address Distance List\n");
3217 sprintf(buf
, "%s/%d", inet_ntoa(rn
->p
.u
.prefix4
),
3219 vty_out(vty
, " %-20s %4d %s\n", buf
,
3220 rdistance
->distance
,
3221 rdistance
->access_list
? rdistance
->access_list
3226 DEFUN (rip_distance
,
3229 "Administrative distance\n"
3233 rip
->distance
= atoi(argv
[idx_number
]->arg
);
3237 DEFUN (no_rip_distance
,
3238 no_rip_distance_cmd
,
3239 "no distance (1-255)",
3241 "Administrative distance\n"
3248 DEFUN (rip_distance_source
,
3249 rip_distance_source_cmd
,
3250 "distance (1-255) A.B.C.D/M",
3251 "Administrative distance\n"
3253 "IP source prefix\n")
3256 int idx_ipv4_prefixlen
= 2;
3257 rip_distance_set(vty
, argv
[idx_number
]->arg
,
3258 argv
[idx_ipv4_prefixlen
]->arg
, NULL
);
3262 DEFUN (no_rip_distance_source
,
3263 no_rip_distance_source_cmd
,
3264 "no distance (1-255) A.B.C.D/M",
3266 "Administrative distance\n"
3268 "IP source prefix\n")
3271 int idx_ipv4_prefixlen
= 3;
3272 rip_distance_unset(vty
, argv
[idx_number
]->arg
,
3273 argv
[idx_ipv4_prefixlen
]->arg
, NULL
);
3277 DEFUN (rip_distance_source_access_list
,
3278 rip_distance_source_access_list_cmd
,
3279 "distance (1-255) A.B.C.D/M WORD",
3280 "Administrative distance\n"
3282 "IP source prefix\n"
3283 "Access list name\n")
3286 int idx_ipv4_prefixlen
= 2;
3288 rip_distance_set(vty
, argv
[idx_number
]->arg
,
3289 argv
[idx_ipv4_prefixlen
]->arg
, argv
[idx_word
]->arg
);
3293 DEFUN (no_rip_distance_source_access_list
,
3294 no_rip_distance_source_access_list_cmd
,
3295 "no distance (1-255) A.B.C.D/M WORD",
3297 "Administrative distance\n"
3299 "IP source prefix\n"
3300 "Access list name\n")
3303 int idx_ipv4_prefixlen
= 3;
3305 rip_distance_unset(vty
, argv
[idx_number
]->arg
,
3306 argv
[idx_ipv4_prefixlen
]->arg
, argv
[idx_word
]->arg
);
3310 /* Update ECMP routes to zebra when ECMP is disabled. */
3311 static void rip_ecmp_disable(void)
3313 struct route_node
*rp
;
3314 struct rip_info
*rinfo
, *tmp_rinfo
;
3316 struct listnode
*node
, *nextnode
;
3321 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
))
3322 if ((list
= rp
->info
) != NULL
&& listcount(list
) > 1) {
3323 rinfo
= listgetdata(listhead(list
));
3324 if (!rip_route_rte(rinfo
))
3327 /* Drop all other entries, except the first one. */
3328 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
))
3329 if (tmp_rinfo
!= rinfo
) {
3330 RIP_TIMER_OFF(tmp_rinfo
->t_timeout
);
3332 tmp_rinfo
->t_garbage_collect
);
3333 list_delete_node(list
, node
);
3334 rip_info_free(tmp_rinfo
);
3338 rip_zebra_ipv4_add(rp
);
3340 /* Set the route change flag. */
3341 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
3343 /* Signal the output process to trigger an update. */
3344 rip_event(RIP_TRIGGERED_UPDATE
, 0);
3348 DEFUN (rip_allow_ecmp
,
3351 "Allow Equal Cost MultiPath\n")
3354 vty_out(vty
, "ECMP is already enabled.\n");
3355 return CMD_WARNING_CONFIG_FAILED
;
3359 zlog_info("ECMP is enabled.");
3363 DEFUN (no_rip_allow_ecmp
,
3364 no_rip_allow_ecmp_cmd
,
3367 "Allow Equal Cost MultiPath\n")
3370 vty_out(vty
, "ECMP is already disabled.\n");
3371 return CMD_WARNING_CONFIG_FAILED
;
3375 zlog_info("ECMP is disabled.");
3380 /* Print out routes update time. */
3381 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
3386 char timebuf
[TIME_BUF
];
3387 struct thread
*thread
;
3389 if ((thread
= rinfo
->t_timeout
) != NULL
) {
3390 clock
= thread_timer_remain_second(thread
);
3391 tm
= gmtime(&clock
);
3392 strftime(timebuf
, TIME_BUF
, "%M:%S", tm
);
3393 vty_out(vty
, "%5s", timebuf
);
3394 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
3395 clock
= thread_timer_remain_second(thread
);
3396 tm
= gmtime(&clock
);
3397 strftime(timebuf
, TIME_BUF
, "%M:%S", tm
);
3398 vty_out(vty
, "%5s", timebuf
);
3402 static const char *rip_route_type_print(int sub_type
)
3407 case RIP_ROUTE_STATIC
:
3409 case RIP_ROUTE_DEFAULT
:
3411 case RIP_ROUTE_REDISTRIBUTE
:
3413 case RIP_ROUTE_INTERFACE
:
3425 "Show RIP routes\n")
3427 struct route_node
*np
;
3428 struct rip_info
*rinfo
= NULL
;
3429 struct list
*list
= NULL
;
3430 struct listnode
*listnode
= NULL
;
3436 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
3438 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
3439 " (i) - interface\n\n"
3440 " Network Next Hop Metric From Tag Time\n");
3442 for (np
= route_top(rip
->table
); np
; np
= route_next(np
))
3443 if ((list
= np
->info
) != NULL
)
3444 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3448 vty
, "%c(%s) %s/%d",
3449 /* np->lock, For debugging. */
3450 zebra_route_char(rinfo
->type
),
3451 rip_route_type_print(rinfo
->sub_type
),
3452 inet_ntoa(np
->p
.u
.prefix4
),
3458 vty_out(vty
, "%*s", len
, " ");
3460 if (rinfo
->nexthop
.s_addr
)
3461 vty_out(vty
, "%-20s %2d ",
3462 inet_ntoa(rinfo
->nexthop
),
3469 /* Route which exist in kernel routing table. */
3470 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
)
3471 && (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3472 vty_out(vty
, "%-15s ",
3473 inet_ntoa(rinfo
->from
));
3474 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3475 (route_tag_t
)rinfo
->tag
);
3476 rip_vty_out_uptime(vty
, rinfo
);
3477 } else if (rinfo
->metric
3478 == RIP_METRIC_INFINITY
) {
3479 vty_out(vty
, "self ");
3480 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3481 (route_tag_t
)rinfo
->tag
);
3482 rip_vty_out_uptime(vty
, rinfo
);
3484 if (rinfo
->external_metric
) {
3486 vty
, "self (%s:%d)",
3489 rinfo
->external_metric
);
3492 vty_out(vty
, "%*s", len
,
3497 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3498 (route_tag_t
)rinfo
->tag
);
3506 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3507 DEFUN (show_ip_rip_status
,
3508 show_ip_rip_status_cmd
,
3509 "show ip rip status",
3513 "IP routing protocol process parameters and statistics\n")
3515 struct listnode
*node
;
3516 struct interface
*ifp
;
3517 struct rip_interface
*ri
;
3518 extern const struct message ri_version_msg
[];
3519 const char *send_version
;
3520 const char *receive_version
;
3525 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3526 vty_out(vty
, " Sending updates every %ld seconds with +/-50%%,",
3528 vty_out(vty
, " next due in %lu seconds\n",
3529 thread_timer_remain_second(rip
->t_update
));
3530 vty_out(vty
, " Timeout after %ld seconds,", rip
->timeout_time
);
3531 vty_out(vty
, " garbage collect after %ld seconds\n", rip
->garbage_time
);
3533 /* Filtering status show. */
3534 config_show_distribute(vty
);
3536 /* Default metric information. */
3537 vty_out(vty
, " Default redistribution metric is %d\n",
3538 rip
->default_metric
);
3540 /* Redistribute information. */
3541 vty_out(vty
, " Redistributing:");
3542 config_write_rip_redistribute(vty
, 0);
3545 vty_out(vty
, " Default version control: send version %s,",
3546 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3547 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3548 vty_out(vty
, " receive any version \n");
3550 vty_out(vty
, " receive version %s \n",
3551 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3553 vty_out(vty
, " Interface Send Recv Key-chain\n");
3555 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT
), node
, ifp
)) {
3561 if (ri
->enable_network
|| ri
->enable_interface
) {
3562 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3564 lookup_msg(ri_version_msg
,
3565 rip
->version_send
, NULL
);
3567 send_version
= lookup_msg(ri_version_msg
,
3570 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3572 lookup_msg(ri_version_msg
,
3573 rip
->version_recv
, NULL
);
3575 receive_version
= lookup_msg(
3576 ri_version_msg
, ri
->ri_receive
, NULL
);
3578 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3579 send_version
, receive_version
,
3580 ri
->key_chain
? ri
->key_chain
: "");
3584 vty_out(vty
, " Routing for Networks:\n");
3585 config_write_rip_network(vty
, 0);
3588 int found_passive
= 0;
3589 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT
), node
, ifp
)) {
3592 if ((ri
->enable_network
|| ri
->enable_interface
)
3594 if (!found_passive
) {
3596 " Passive Interface(s):\n");
3599 vty_out(vty
, " %s\n", ifp
->name
);
3604 vty_out(vty
, " Routing Information Sources:\n");
3606 " Gateway BadPackets BadRoutes Distance Last Update\n");
3607 rip_peer_display(vty
);
3609 rip_distance_show(vty
);
3614 /* RIP configuration write function. */
3615 static int config_write_rip(struct vty
*vty
)
3618 struct route_node
*rn
;
3619 struct rip_distance
*rdistance
;
3622 /* Router RIP statement. */
3623 vty_out(vty
, "router rip\n");
3626 /* RIP version statement. Default is RIP version 2. */
3627 if (rip
->version_send
!= RI_RIP_VERSION_2
3628 || rip
->version_recv
!= RI_RIP_VERSION_1_AND_2
)
3629 vty_out(vty
, " version %d\n", rip
->version_send
);
3631 /* RIP timer configuration. */
3632 if (rip
->update_time
!= RIP_UPDATE_TIMER_DEFAULT
3633 || rip
->timeout_time
!= RIP_TIMEOUT_TIMER_DEFAULT
3634 || rip
->garbage_time
!= RIP_GARBAGE_TIMER_DEFAULT
)
3635 vty_out(vty
, " timers basic %lu %lu %lu\n",
3636 rip
->update_time
, rip
->timeout_time
,
3639 /* Default information configuration. */
3640 if (rip
->default_information
) {
3641 if (rip
->default_information_route_map
)
3643 " default-information originate route-map %s\n",
3644 rip
->default_information_route_map
);
3647 " default-information originate\n");
3650 /* Redistribute configuration. */
3651 config_write_rip_redistribute(vty
, 1);
3653 /* RIP offset-list configuration. */
3654 config_write_rip_offset_list(vty
);
3656 /* RIP enabled network and interface configuration. */
3657 config_write_rip_network(vty
, 1);
3659 /* RIP default metric configuration */
3660 if (rip
->default_metric
!= RIP_DEFAULT_METRIC_DEFAULT
)
3661 vty_out(vty
, " default-metric %d\n",
3662 rip
->default_metric
);
3664 /* Distribute configuration. */
3665 write
+= config_write_distribute(vty
);
3667 /* Interface routemap configuration */
3668 write
+= config_write_if_rmap(vty
);
3670 /* Distance configuration. */
3672 vty_out(vty
, " distance %d\n", rip
->distance
);
3674 /* RIP source IP prefix distance configuration. */
3675 for (rn
= route_top(rip_distance_table
); rn
;
3676 rn
= route_next(rn
))
3677 if ((rdistance
= rn
->info
) != NULL
)
3678 vty_out(vty
, " distance %d %s/%d %s\n",
3679 rdistance
->distance
,
3680 inet_ntoa(rn
->p
.u
.prefix4
),
3682 rdistance
->access_list
3683 ? rdistance
->access_list
3686 /* ECMP configuration. */
3688 vty_out(vty
, " allow-ecmp\n");
3690 /* RIP static route configuration. */
3691 for (rn
= route_top(rip
->route
); rn
; rn
= route_next(rn
))
3693 vty_out(vty
, " route %s/%d\n",
3694 inet_ntoa(rn
->p
.u
.prefix4
),
3700 /* RIP node structure. */
3701 static struct cmd_node rip_node
= {RIP_NODE
, "%s(config-router)# ", 1};
3703 /* Distribute-list update functions. */
3704 static void rip_distribute_update(struct distribute
*dist
)
3706 struct interface
*ifp
;
3707 struct rip_interface
*ri
;
3708 struct access_list
*alist
;
3709 struct prefix_list
*plist
;
3714 ifp
= if_lookup_by_name(dist
->ifname
, VRF_DEFAULT
);
3720 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3721 alist
= access_list_lookup(AFI_IP
,
3722 dist
->list
[DISTRIBUTE_V4_IN
]);
3724 ri
->list
[RIP_FILTER_IN
] = alist
;
3726 ri
->list
[RIP_FILTER_IN
] = NULL
;
3728 ri
->list
[RIP_FILTER_IN
] = NULL
;
3730 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3731 alist
= access_list_lookup(AFI_IP
,
3732 dist
->list
[DISTRIBUTE_V4_OUT
]);
3734 ri
->list
[RIP_FILTER_OUT
] = alist
;
3736 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3738 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3740 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3741 plist
= prefix_list_lookup(AFI_IP
,
3742 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3744 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3746 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3748 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3750 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3751 plist
= prefix_list_lookup(AFI_IP
,
3752 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3754 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3756 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3758 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3761 void rip_distribute_update_interface(struct interface
*ifp
)
3763 struct distribute
*dist
;
3765 dist
= distribute_lookup(ifp
->name
);
3767 rip_distribute_update(dist
);
3770 /* Update all interface's distribute list. */
3772 static void rip_distribute_update_all(struct prefix_list
*notused
)
3774 struct interface
*ifp
;
3775 struct listnode
*node
, *nnode
;
3777 for (ALL_LIST_ELEMENTS(vrf_iflist(VRF_DEFAULT
), node
, nnode
, ifp
))
3778 rip_distribute_update_interface(ifp
);
3781 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3783 rip_distribute_update_all(NULL
);
3786 /* Delete all added rip route. */
3787 void rip_clean(void)
3790 struct route_node
*rp
;
3791 struct rip_info
*rinfo
= NULL
;
3792 struct list
*list
= NULL
;
3793 struct listnode
*listnode
= NULL
;
3798 /* Clear RIP routes */
3799 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
))
3800 if ((list
= rp
->info
) != NULL
) {
3801 rinfo
= listgetdata(listhead(list
));
3802 if (rip_route_rte(rinfo
))
3803 rip_zebra_ipv4_delete(rp
);
3805 for (ALL_LIST_ELEMENTS_RO(list
, listnode
,
3807 RIP_TIMER_OFF(rinfo
->t_timeout
);
3808 RIP_TIMER_OFF(rinfo
->t_garbage_collect
);
3809 rip_info_free(rinfo
);
3813 route_unlock_node(rp
);
3816 /* Cancel RIP related timers. */
3817 RIP_TIMER_OFF(rip
->t_update
);
3818 RIP_TIMER_OFF(rip
->t_triggered_update
);
3819 RIP_TIMER_OFF(rip
->t_triggered_interval
);
3821 /* Cancel read thread. */
3822 THREAD_READ_OFF(rip
->t_read
);
3824 /* Close RIP socket. */
3825 if (rip
->sock
>= 0) {
3830 /* Static RIP route configuration. */
3831 for (rp
= route_top(rip
->route
); rp
; rp
= route_next(rp
))
3834 route_unlock_node(rp
);
3837 /* RIP neighbor configuration. */
3838 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
))
3841 route_unlock_node(rp
);
3844 /* Redistribute related clear. */
3845 if (rip
->default_information_route_map
)
3846 free(rip
->default_information_route_map
);
3848 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3849 if (rip
->route_map
[i
].name
)
3850 free(rip
->route_map
[i
].name
);
3852 XFREE(MTYPE_ROUTE_TABLE
, rip
->table
);
3853 XFREE(MTYPE_ROUTE_TABLE
, rip
->route
);
3854 XFREE(MTYPE_ROUTE_TABLE
, rip
->neighbor
);
3856 XFREE(MTYPE_RIP
, rip
);
3860 rip_clean_network();
3861 rip_passive_nondefault_clean();
3863 rip_interfaces_clean();
3864 rip_distance_reset();
3865 rip_redistribute_clean();
3868 /* Reset all values to the default settings. */
3869 void rip_reset(void)
3871 /* Reset global counters. */
3872 rip_global_route_changes
= 0;
3873 rip_global_queries
= 0;
3875 /* Call ripd related reset functions. */
3877 rip_route_map_reset();
3879 /* Call library reset functions. */
3881 access_list_reset();
3882 prefix_list_reset();
3884 distribute_list_reset();
3886 rip_interfaces_reset();
3887 rip_distance_reset();
3889 rip_zclient_reset();
3892 static void rip_if_rmap_update(struct if_rmap
*if_rmap
)
3894 struct interface
*ifp
;
3895 struct rip_interface
*ri
;
3896 struct route_map
*rmap
;
3898 ifp
= if_lookup_by_name(if_rmap
->ifname
, VRF_DEFAULT
);
3904 if (if_rmap
->routemap
[IF_RMAP_IN
]) {
3905 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_IN
]);
3907 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3909 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3911 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3913 if (if_rmap
->routemap
[IF_RMAP_OUT
]) {
3914 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_OUT
]);
3916 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3918 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3920 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3923 void rip_if_rmap_update_interface(struct interface
*ifp
)
3925 struct if_rmap
*if_rmap
;
3927 if_rmap
= if_rmap_lookup(ifp
->name
);
3929 rip_if_rmap_update(if_rmap
);
3932 static void rip_routemap_update_redistribute(void)
3937 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3938 if (rip
->route_map
[i
].name
)
3939 rip
->route_map
[i
].map
=
3940 route_map_lookup_by_name(
3941 rip
->route_map
[i
].name
);
3947 static void rip_routemap_update(const char *notused
)
3949 struct interface
*ifp
;
3950 struct listnode
*node
, *nnode
;
3952 for (ALL_LIST_ELEMENTS(vrf_iflist(VRF_DEFAULT
), node
, nnode
, ifp
))
3953 rip_if_rmap_update_interface(ifp
);
3955 rip_routemap_update_redistribute();
3958 /* Allocate new rip structure and set default value. */
3961 /* Install top nodes. */
3962 install_node(&rip_node
, config_write_rip
);
3964 /* Install rip commands. */
3965 install_element(VIEW_NODE
, &show_ip_rip_cmd
);
3966 install_element(VIEW_NODE
, &show_ip_rip_status_cmd
);
3967 install_element(CONFIG_NODE
, &router_rip_cmd
);
3968 install_element(CONFIG_NODE
, &no_router_rip_cmd
);
3970 install_default(RIP_NODE
);
3971 install_element(RIP_NODE
, &rip_version_cmd
);
3972 install_element(RIP_NODE
, &no_rip_version_cmd
);
3973 install_element(RIP_NODE
, &rip_default_metric_cmd
);
3974 install_element(RIP_NODE
, &no_rip_default_metric_cmd
);
3975 install_element(RIP_NODE
, &rip_timers_cmd
);
3976 install_element(RIP_NODE
, &no_rip_timers_cmd
);
3977 install_element(RIP_NODE
, &rip_route_cmd
);
3978 install_element(RIP_NODE
, &no_rip_route_cmd
);
3979 install_element(RIP_NODE
, &rip_distance_cmd
);
3980 install_element(RIP_NODE
, &no_rip_distance_cmd
);
3981 install_element(RIP_NODE
, &rip_distance_source_cmd
);
3982 install_element(RIP_NODE
, &no_rip_distance_source_cmd
);
3983 install_element(RIP_NODE
, &rip_distance_source_access_list_cmd
);
3984 install_element(RIP_NODE
, &no_rip_distance_source_access_list_cmd
);
3985 install_element(RIP_NODE
, &rip_allow_ecmp_cmd
);
3986 install_element(RIP_NODE
, &no_rip_allow_ecmp_cmd
);
3988 /* Debug related init. */
3991 /* Access list install. */
3993 access_list_add_hook(rip_distribute_update_all_wrapper
);
3994 access_list_delete_hook(rip_distribute_update_all_wrapper
);
3996 /* Prefix list initialize.*/
3998 prefix_list_add_hook(rip_distribute_update_all
);
3999 prefix_list_delete_hook(rip_distribute_update_all
);
4001 /* Distribute list install. */
4002 distribute_list_init(RIP_NODE
);
4003 distribute_list_add_hook(rip_distribute_update
);
4004 distribute_list_delete_hook(rip_distribute_update
);
4007 rip_route_map_init();
4010 route_map_add_hook(rip_routemap_update
);
4011 route_map_delete_hook(rip_routemap_update
);
4013 if_rmap_init(RIP_NODE
);
4014 if_rmap_hook_add(rip_if_rmap_update
);
4015 if_rmap_hook_delete(rip_if_rmap_update
);
4017 /* Distance control. */
4018 rip_distance_table
= route_table_init();