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"
40 #ifdef CRYPTO_INTERNAL
45 #include "lib_errors.h"
46 #include "northbound_cli.h"
48 #include "lib/printfrr.h"
50 #include "ripd/ripd.h"
51 #include "ripd/rip_nb.h"
52 #include "ripd/rip_debug.h"
53 #include "ripd/rip_errors.h"
54 #include "ripd/rip_interface.h"
56 /* UDP receive buffer size */
57 #define RIP_UDP_RCV_BUF 41600
59 DEFINE_MGROUP(RIPD
, "ripd");
60 DEFINE_MTYPE_STATIC(RIPD
, RIP
, "RIP structure");
61 DEFINE_MTYPE_STATIC(RIPD
, RIP_VRF_NAME
, "RIP VRF name");
62 DEFINE_MTYPE_STATIC(RIPD
, RIP_INFO
, "RIP route info");
63 DEFINE_MTYPE_STATIC(RIPD
, RIP_DISTANCE
, "RIP distance");
66 static void rip_output_process(struct connected
*, struct sockaddr_in
*, int,
68 static void rip_triggered_update(struct thread
*);
69 static int rip_update_jitter(unsigned long);
70 static void rip_distance_table_node_cleanup(struct route_table
*table
,
71 struct route_node
*node
);
72 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
);
73 static void rip_instance_disable(struct rip
*rip
);
75 static void rip_distribute_update(struct distribute_ctx
*ctx
,
76 struct distribute
*dist
);
78 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
79 struct if_rmap
*if_rmap
);
81 /* RIP output routes type. */
82 enum { rip_all_route
, rip_changed_route
};
84 /* RIP command strings. */
85 static const struct message rip_msg
[] = {{RIP_REQUEST
, "REQUEST"},
86 {RIP_RESPONSE
, "RESPONSE"},
87 {RIP_TRACEON
, "TRACEON"},
88 {RIP_TRACEOFF
, "TRACEOFF"},
90 {RIP_POLL_ENTRY
, "POLL ENTRY"},
93 /* Generate rb-tree of RIP instances. */
94 static inline int rip_instance_compare(const struct rip
*a
, const struct rip
*b
)
96 return strcmp(a
->vrf_name
, b
->vrf_name
);
98 RB_GENERATE(rip_instance_head
, rip
, entry
, rip_instance_compare
)
100 struct rip_instance_head rip_instances
= RB_INITIALIZER(&rip_instances
);
102 /* Utility function to set broadcast option to the socket. */
103 static int sockopt_broadcast(int sock
)
108 ret
= setsockopt(sock
, SOL_SOCKET
, SO_BROADCAST
, (char *)&on
,
111 zlog_warn("can't set sockopt SO_BROADCAST to socket %d", sock
);
117 int rip_route_rte(struct rip_info
*rinfo
)
119 return (rinfo
->type
== ZEBRA_ROUTE_RIP
120 && rinfo
->sub_type
== RIP_ROUTE_RTE
);
123 static struct rip_info
*rip_info_new(void)
125 return XCALLOC(MTYPE_RIP_INFO
, sizeof(struct rip_info
));
128 void rip_info_free(struct rip_info
*rinfo
)
130 XFREE(MTYPE_RIP_INFO
, rinfo
);
133 struct rip
*rip_info_get_instance(const struct rip_info
*rinfo
)
135 return route_table_get_info(rinfo
->rp
->table
);
138 /* RIP route garbage collect timer. */
139 static void rip_garbage_collect(struct thread
*t
)
141 struct rip_info
*rinfo
;
142 struct route_node
*rp
;
144 rinfo
= THREAD_ARG(t
);
146 /* Off timeout timer. */
147 THREAD_OFF(rinfo
->t_timeout
);
149 /* Get route_node pointer. */
152 /* Unlock route_node. */
153 listnode_delete(rp
->info
, rinfo
);
154 if (list_isempty((struct list
*)rp
->info
)) {
155 list_delete((struct list
**)&rp
->info
);
156 route_unlock_node(rp
);
159 /* Free RIP routing information. */
160 rip_info_free(rinfo
);
163 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
);
165 /* Add new route to the ECMP list.
166 * RETURN: the new entry added in the list, or NULL if it is not the first
167 * entry and ECMP is not allowed.
169 struct rip_info
*rip_ecmp_add(struct rip
*rip
, struct rip_info
*rinfo_new
)
171 struct route_node
*rp
= rinfo_new
->rp
;
172 struct rip_info
*rinfo
= NULL
;
173 struct list
*list
= NULL
;
175 if (rp
->info
== NULL
)
176 rp
->info
= list_new();
177 list
= (struct list
*)rp
->info
;
179 /* If ECMP is not allowed and some entry already exists in the list,
181 if (listcount(list
) && !rip
->ecmp
)
184 rinfo
= rip_info_new();
185 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
186 listnode_add(list
, rinfo
);
188 if (rip_route_rte(rinfo
)) {
189 rip_timeout_update(rip
, rinfo
);
190 rip_zebra_ipv4_add(rip
, rp
);
193 /* Set the route change flag on the first entry. */
194 rinfo
= listgetdata(listhead(list
));
195 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
197 /* Signal the output process to trigger an update (see section 2.5). */
198 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
203 /* Replace the ECMP list with the new route.
204 * RETURN: the new entry added in the list
206 struct rip_info
*rip_ecmp_replace(struct rip
*rip
, struct rip_info
*rinfo_new
)
208 struct route_node
*rp
= rinfo_new
->rp
;
209 struct list
*list
= (struct list
*)rp
->info
;
210 struct rip_info
*rinfo
= NULL
, *tmp_rinfo
= NULL
;
211 struct listnode
*node
= NULL
, *nextnode
= NULL
;
213 if (list
== NULL
|| listcount(list
) == 0)
214 return rip_ecmp_add(rip
, rinfo_new
);
216 /* Get the first entry */
217 rinfo
= listgetdata(listhead(list
));
219 /* Learnt route replaced by a local one. Delete it from zebra. */
220 if (rip_route_rte(rinfo
) && !rip_route_rte(rinfo_new
))
221 if (CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
222 rip_zebra_ipv4_delete(rip
, rp
);
224 /* Re-use the first entry, and delete the others. */
225 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
226 if (tmp_rinfo
== rinfo
)
229 THREAD_OFF(tmp_rinfo
->t_timeout
);
230 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
231 list_delete_node(list
, node
);
232 rip_info_free(tmp_rinfo
);
235 THREAD_OFF(rinfo
->t_timeout
);
236 THREAD_OFF(rinfo
->t_garbage_collect
);
237 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
239 if (rip_route_rte(rinfo
)) {
240 rip_timeout_update(rip
, rinfo
);
241 /* The ADD message implies an update. */
242 rip_zebra_ipv4_add(rip
, rp
);
245 /* Set the route change flag. */
246 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
248 /* Signal the output process to trigger an update (see section 2.5). */
249 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
254 /* Delete one route from the ECMP list.
256 * null - the entry is freed, and other entries exist in the list
257 * the entry - the entry is the last one in the list; its metric is set
258 * to INFINITY, and the garbage collector is started for it
260 struct rip_info
*rip_ecmp_delete(struct rip
*rip
, struct rip_info
*rinfo
)
262 struct route_node
*rp
= rinfo
->rp
;
263 struct list
*list
= (struct list
*)rp
->info
;
265 THREAD_OFF(rinfo
->t_timeout
);
267 if (listcount(list
) > 1) {
268 /* Some other ECMP entries still exist. Just delete this entry.
270 THREAD_OFF(rinfo
->t_garbage_collect
);
271 listnode_delete(list
, rinfo
);
272 if (rip_route_rte(rinfo
)
273 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
274 /* The ADD message implies the update. */
275 rip_zebra_ipv4_add(rip
, rp
);
276 rip_info_free(rinfo
);
279 assert(rinfo
== listgetdata(listhead(list
)));
281 /* This is the only entry left in the list. We must keep it in
282 * the list for garbage collection time, with INFINITY metric.
285 rinfo
->metric
= RIP_METRIC_INFINITY
;
286 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
289 if (rip_route_rte(rinfo
)
290 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
291 rip_zebra_ipv4_delete(rip
, rp
);
294 /* Set the route change flag on the first entry. */
295 rinfo
= listgetdata(listhead(list
));
296 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
298 /* Signal the output process to trigger an update (see section 2.5). */
299 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
304 /* Timeout RIP routes. */
305 static void rip_timeout(struct thread
*t
)
307 struct rip_info
*rinfo
= THREAD_ARG(t
);
308 struct rip
*rip
= rip_info_get_instance(rinfo
);
310 rip_ecmp_delete(rip
, rinfo
);
313 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
)
315 if (rinfo
->metric
!= RIP_METRIC_INFINITY
) {
316 THREAD_OFF(rinfo
->t_timeout
);
317 thread_add_timer(master
, rip_timeout
, rinfo
, rip
->timeout_time
,
322 static int rip_filter(int rip_distribute
, struct prefix_ipv4
*p
,
323 struct rip_interface
*ri
)
325 struct distribute
*dist
;
326 struct access_list
*alist
;
327 struct prefix_list
*plist
;
328 int distribute
= rip_distribute
== RIP_FILTER_OUT
? DISTRIBUTE_V4_OUT
330 const char *inout
= rip_distribute
== RIP_FILTER_OUT
? "out" : "in";
332 /* Input distribute-list filtering. */
333 if (ri
->list
[rip_distribute
] &&
334 access_list_apply(ri
->list
[rip_distribute
], (struct prefix
*)p
) ==
336 if (IS_RIP_DEBUG_PACKET
)
337 zlog_debug("%pFX filtered by distribute %s", p
, inout
);
341 if (ri
->prefix
[rip_distribute
] &&
342 prefix_list_apply(ri
->prefix
[rip_distribute
], (struct prefix
*)p
) ==
344 if (IS_RIP_DEBUG_PACKET
)
345 zlog_debug("%pFX filtered by prefix-list %s", p
, inout
);
349 /* All interface filter check. */
350 dist
= distribute_lookup(ri
->rip
->distribute_ctx
, NULL
);
354 if (dist
->list
[distribute
]) {
355 alist
= access_list_lookup(AFI_IP
, dist
->list
[distribute
]);
358 if (access_list_apply(alist
, (struct prefix
*)p
) ==
360 if (IS_RIP_DEBUG_PACKET
)
362 "%pFX filtered by distribute %s",
368 if (dist
->prefix
[distribute
]) {
369 plist
= prefix_list_lookup(AFI_IP
, dist
->prefix
[distribute
]);
372 if (prefix_list_apply(plist
, (struct prefix
*)p
) ==
374 if (IS_RIP_DEBUG_PACKET
)
376 "%pFX filtered by prefix-list %s",
386 /* Check nexthop address validity. */
387 static int rip_nexthop_check(struct rip
*rip
, struct in_addr
*addr
)
389 struct interface
*ifp
;
390 struct listnode
*cnode
;
391 struct connected
*ifc
;
394 /* If nexthop address matches local configured address then it is
397 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
398 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, cnode
, ifc
)) {
401 if (p
->family
== AF_INET
402 && IPV4_ADDR_SAME(&p
->u
.prefix4
, addr
))
409 /* RIP add route to routing table. */
410 static void rip_rte_process(struct rte
*rte
, struct sockaddr_in
*from
,
411 struct interface
*ifp
)
415 struct prefix_ipv4 p
;
416 struct route_node
*rp
;
417 struct rip_info
*rinfo
= NULL
, newinfo
;
418 struct rip_interface
*ri
;
419 struct in_addr
*nexthop
;
421 unsigned char old_dist
, new_dist
;
422 struct list
*list
= NULL
;
423 struct listnode
*node
= NULL
;
425 /* Make prefix structure. */
426 memset(&p
, 0, sizeof(struct prefix_ipv4
));
428 p
.prefix
= rte
->prefix
;
429 p
.prefixlen
= ip_masklen(rte
->mask
);
431 /* Make sure mask is applied. */
437 /* Apply input filters. */
438 ret
= rip_filter(RIP_FILTER_IN
, &p
, ri
);
442 memset(&newinfo
, 0, sizeof(newinfo
));
443 newinfo
.type
= ZEBRA_ROUTE_RIP
;
444 newinfo
.sub_type
= RIP_ROUTE_RTE
;
445 newinfo
.nh
.gate
.ipv4
= rte
->nexthop
;
446 newinfo
.from
= from
->sin_addr
;
447 newinfo
.nh
.ifindex
= ifp
->ifindex
;
448 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4_IFINDEX
;
449 newinfo
.metric
= rte
->metric
;
450 newinfo
.metric_out
= rte
->metric
; /* XXX */
451 newinfo
.tag
= ntohs(rte
->tag
); /* XXX */
453 /* Modify entry according to the interface routemap. */
454 if (ri
->routemap
[RIP_FILTER_IN
]) {
455 /* The object should be of the type of rip_info */
456 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_IN
],
457 (struct prefix
*)&p
, &newinfo
);
459 if (ret
== RMAP_DENYMATCH
) {
460 if (IS_RIP_DEBUG_PACKET
)
462 "RIP %pFX is filtered by route-map in",
467 /* Get back the object */
468 rte
->nexthop
= newinfo
.nexthop_out
;
469 rte
->tag
= htons(newinfo
.tag_out
); /* XXX */
470 rte
->metric
= newinfo
.metric_out
; /* XXX: the routemap uses the
474 /* Once the entry has been validated, update the metric by
475 adding the cost of the network on which the message
476 arrived. If the result is greater than infinity, use infinity
477 (RFC2453 Sec. 3.9.2) */
478 /* Zebra ripd can handle offset-list in. */
479 ret
= rip_offset_list_apply_in(&p
, ifp
, &rte
->metric
);
481 /* If offset-list does not modify the metric use interface's
484 rte
->metric
+= ifp
->metric
? ifp
->metric
: 1;
486 if (rte
->metric
> RIP_METRIC_INFINITY
)
487 rte
->metric
= RIP_METRIC_INFINITY
;
489 /* Set nexthop pointer. */
490 if (rte
->nexthop
.s_addr
== INADDR_ANY
)
491 nexthop
= &from
->sin_addr
;
493 nexthop
= &rte
->nexthop
;
495 /* Check if nexthop address is myself, then do nothing. */
496 if (rip_nexthop_check(rip
, nexthop
) < 0) {
497 if (IS_RIP_DEBUG_PACKET
)
498 zlog_debug("Nexthop address %pI4 is myself",
503 /* Get index for the prefix. */
504 rp
= route_node_get(rip
->table
, (struct prefix
*)&p
);
507 newinfo
.nh
.gate
.ipv4
= *nexthop
;
508 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4
;
509 newinfo
.metric
= rte
->metric
;
510 newinfo
.tag
= ntohs(rte
->tag
);
511 newinfo
.distance
= rip_distance_apply(rip
, &newinfo
);
513 new_dist
= newinfo
.distance
? newinfo
.distance
514 : ZEBRA_RIP_DISTANCE_DEFAULT
;
516 /* Check to see whether there is already RIP route on the table. */
517 if ((list
= rp
->info
) != NULL
)
518 for (ALL_LIST_ELEMENTS_RO(list
, node
, rinfo
)) {
519 /* Need to compare with redistributed entry or local
521 if (!rip_route_rte(rinfo
))
524 if (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
525 && IPV4_ADDR_SAME(&rinfo
->nh
.gate
.ipv4
, nexthop
))
528 if (listnextnode(node
))
531 /* Not found in the list */
533 if (rte
->metric
> rinfo
->metric
) {
534 /* New route has a greater metric.
536 route_unlock_node(rp
);
540 if (rte
->metric
< rinfo
->metric
)
541 /* New route has a smaller metric.
542 * Replace the ECMP list
543 * with the new one in below. */
546 /* Metrics are same. We compare the distances.
548 old_dist
= rinfo
->distance
? rinfo
->distance
549 : ZEBRA_RIP_DISTANCE_DEFAULT
;
551 if (new_dist
> old_dist
) {
552 /* New route has a greater distance.
554 route_unlock_node(rp
);
558 if (new_dist
< old_dist
)
559 /* New route has a smaller distance.
560 * Replace the ECMP list
561 * with the new one in below. */
564 /* Metrics and distances are both same. Keep
566 * the new route is added in the ECMP list in
571 /* Local static route. */
572 if (rinfo
->type
== ZEBRA_ROUTE_RIP
573 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
574 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))
575 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
576 route_unlock_node(rp
);
580 /* Redistributed route check. */
581 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
582 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
583 old_dist
= rinfo
->distance
;
584 /* Only routes directly connected to an interface
586 * may have a valid NULL distance */
587 if (rinfo
->nh
.gate
.ipv4
.s_addr
!= INADDR_ANY
)
590 : ZEBRA_RIP_DISTANCE_DEFAULT
;
591 /* If imported route does not have STRICT precedence,
592 mark it as a ghost */
593 if (new_dist
<= old_dist
594 && rte
->metric
!= RIP_METRIC_INFINITY
)
595 rip_ecmp_replace(rip
, &newinfo
);
597 route_unlock_node(rp
);
604 route_unlock_node(rp
);
606 /* Now, check to see whether there is already an explicit route
607 for the destination prefix. If there is no such route, add
608 this route to the routing table, unless the metric is
609 infinity (there is no point in adding a route which
611 if (rte
->metric
!= RIP_METRIC_INFINITY
)
612 rip_ecmp_add(rip
, &newinfo
);
614 /* Route is there but we are not sure the route is RIP or not.
617 /* If there is an existing route, compare the next hop address
618 to the address of the router from which the datagram came.
619 If this datagram is from the same router as the existing
620 route, reinitialize the timeout. */
621 same
= (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
622 && (rinfo
->nh
.ifindex
== ifp
->ifindex
));
624 old_dist
= rinfo
->distance
? rinfo
->distance
625 : ZEBRA_RIP_DISTANCE_DEFAULT
;
627 /* Next, compare the metrics. If the datagram is from the same
628 router as the existing route, and the new metric is different
629 than the old one; or, if the new metric is lower than the old
630 one, or if the tag has been changed; or if there is a route
631 with a lower administrave distance; or an update of the
632 distance on the actual route; do the following actions: */
633 if ((same
&& rinfo
->metric
!= rte
->metric
)
634 || (rte
->metric
< rinfo
->metric
)
635 || ((same
) && (rinfo
->metric
== rte
->metric
)
636 && (newinfo
.tag
!= rinfo
->tag
))
637 || (old_dist
> new_dist
)
638 || ((old_dist
!= new_dist
) && same
)) {
639 if (listcount(list
) == 1) {
640 if (newinfo
.metric
!= RIP_METRIC_INFINITY
)
641 rip_ecmp_replace(rip
, &newinfo
);
643 rip_ecmp_delete(rip
, rinfo
);
645 if (newinfo
.metric
< rinfo
->metric
)
646 rip_ecmp_replace(rip
, &newinfo
);
647 else if (newinfo
.metric
> rinfo
->metric
)
648 rip_ecmp_delete(rip
, rinfo
);
649 else if (new_dist
< old_dist
)
650 rip_ecmp_replace(rip
, &newinfo
);
651 else if (new_dist
> old_dist
)
652 rip_ecmp_delete(rip
, rinfo
);
654 int update
= CHECK_FLAG(rinfo
->flags
,
659 assert(newinfo
.metric
660 != RIP_METRIC_INFINITY
);
662 THREAD_OFF(rinfo
->t_timeout
);
663 THREAD_OFF(rinfo
->t_garbage_collect
);
664 memcpy(rinfo
, &newinfo
,
665 sizeof(struct rip_info
));
666 rip_timeout_update(rip
, rinfo
);
669 rip_zebra_ipv4_add(rip
, rp
);
671 /* - Set the route change flag on the
673 rinfo
= listgetdata(listhead(list
));
674 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
675 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
678 } else /* same & no change */
679 rip_timeout_update(rip
, rinfo
);
681 /* Unlock tempolary lock of the route. */
682 route_unlock_node(rp
);
686 /* Dump RIP packet */
687 static void rip_packet_dump(struct rip_packet
*packet
, int size
,
692 const char *command_str
;
696 /* Set command string. */
697 if (packet
->command
> 0 && packet
->command
< RIP_COMMAND_MAX
)
698 command_str
= lookup_msg(rip_msg
, packet
->command
, NULL
);
700 command_str
= "unknown";
702 /* Dump packet header. */
703 zlog_debug("%s %s version %d packet size %d", sndrcv
, command_str
,
704 packet
->version
, size
);
706 /* Dump each routing table entry. */
709 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
710 if (packet
->version
== RIPv2
) {
711 netmask
= ip_masklen(rte
->mask
);
713 if (rte
->family
== htons(RIP_FAMILY_AUTH
)) {
715 == htons(RIP_AUTH_SIMPLE_PASSWORD
)) {
716 p
= (uint8_t *)&rte
->prefix
;
719 " family 0x%X type %d auth string: %s",
722 } else if (rte
->tag
== htons(RIP_AUTH_MD5
)) {
723 struct rip_md5_info
*md5
;
725 md5
= (struct rip_md5_info
*)&packet
729 " family 0x%X type %d (MD5 authentication)",
733 " RIP-2 packet len %d Key ID %d Auth Data len %d",
734 ntohs(md5
->packet_len
),
735 md5
->keyid
, md5
->auth_len
);
736 zlog_debug(" Sequence Number %ld",
737 (unsigned long)ntohl(
739 } else if (rte
->tag
== htons(RIP_AUTH_DATA
)) {
740 p
= (uint8_t *)&rte
->prefix
;
743 " family 0x%X type %d (MD5 data)",
747 " MD5: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
748 p
[0], p
[1], p
[2], p
[3], p
[4],
749 p
[5], p
[6], p
[7], p
[8], p
[9],
750 p
[10], p
[11], p
[12], p
[13],
754 " family 0x%X type %d (Unknown auth type)",
760 " %pI4/%d -> %pI4 family %d tag %" ROUTE_TAG_PRI
762 &rte
->prefix
, netmask
, &rte
->nexthop
,
764 (route_tag_t
)ntohs(rte
->tag
),
765 (unsigned long)ntohl(rte
->metric
));
767 zlog_debug(" %pI4 family %d tag %" ROUTE_TAG_PRI
769 &rte
->prefix
, ntohs(rte
->family
),
770 (route_tag_t
)ntohs(rte
->tag
),
771 (unsigned long)ntohl(rte
->metric
));
776 /* Check if the destination address is valid (unicast; not net 0
777 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
778 check net 0 because we accept default route. */
779 static int rip_destination_check(struct in_addr addr
)
781 uint32_t destination
;
783 /* Convert to host byte order. */
784 destination
= ntohl(addr
.s_addr
);
786 if (IPV4_NET127(destination
))
789 /* Net 0 may match to the default route. */
790 if (IPV4_NET0(destination
) && destination
!= 0)
793 /* Unicast address must belong to class A, B, C. */
794 if (IN_CLASSA(destination
))
796 if (IN_CLASSB(destination
))
798 if (IN_CLASSC(destination
))
804 /* RIP version 2 authentication. */
805 static int rip_auth_simple_password(struct rte
*rte
, struct sockaddr_in
*from
,
806 struct interface
*ifp
)
808 struct rip_interface
*ri
;
809 char *auth_str
= (char *)rte
+ offsetof(struct rte
, prefix
);
812 /* reject passwords with zeros in the middle of the string */
813 for (i
= strnlen(auth_str
, 16); i
< 16; i
++) {
814 if (auth_str
[i
] != '\0')
818 if (IS_RIP_DEBUG_EVENT
)
819 zlog_debug("RIPv2 simple password authentication from %pI4",
824 if (ri
->auth_type
!= RIP_AUTH_SIMPLE_PASSWORD
825 || rte
->tag
!= htons(RIP_AUTH_SIMPLE_PASSWORD
))
828 /* Simple password authentication. */
830 if (strncmp(auth_str
, ri
->auth_str
, 16) == 0)
834 struct keychain
*keychain
;
837 keychain
= keychain_lookup(ri
->key_chain
);
838 if (keychain
== NULL
|| keychain
->key
== NULL
)
841 key
= key_match_for_accept(keychain
, auth_str
);
848 /* RIP version 2 authentication with MD5. */
849 static int rip_auth_md5(struct rip_packet
*packet
, struct sockaddr_in
*from
,
850 int length
, struct interface
*ifp
)
852 struct rip_interface
*ri
;
853 struct rip_md5_info
*md5
;
854 struct rip_md5_data
*md5data
;
855 struct keychain
*keychain
;
857 #ifdef CRYPTO_OPENSSL
859 #elif CRYPTO_INTERNAL
862 uint8_t digest
[RIP_AUTH_MD5_SIZE
];
864 char auth_str
[RIP_AUTH_MD5_SIZE
] = {};
866 if (IS_RIP_DEBUG_EVENT
)
867 zlog_debug("RIPv2 MD5 authentication from %pI4",
871 md5
= (struct rip_md5_info
*)&packet
->rte
;
873 /* Check auth type. */
874 if (ri
->auth_type
!= RIP_AUTH_MD5
|| md5
->type
!= htons(RIP_AUTH_MD5
))
877 /* If the authentication length is less than 16, then it must be wrong
879 * any interpretation of rfc2082. Some implementations also interpret
880 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka
881 * RIP_AUTH_MD5_COMPAT_SIZE.
883 if (!((md5
->auth_len
== RIP_AUTH_MD5_SIZE
)
884 || (md5
->auth_len
== RIP_AUTH_MD5_COMPAT_SIZE
))) {
885 if (IS_RIP_DEBUG_EVENT
)
887 "RIPv2 MD5 authentication, strange authentication length field %d",
892 /* grab and verify check packet length */
893 packet_len
= ntohs(md5
->packet_len
);
895 if (packet_len
> (length
- RIP_HEADER_SIZE
- RIP_AUTH_MD5_SIZE
)) {
896 if (IS_RIP_DEBUG_EVENT
)
898 "RIPv2 MD5 authentication, packet length field %d greater than received length %d!",
899 md5
->packet_len
, length
);
903 /* retrieve authentication data */
904 md5data
= (struct rip_md5_data
*)(((uint8_t *)packet
) + packet_len
);
907 keychain
= keychain_lookup(ri
->key_chain
);
908 if (keychain
== NULL
)
911 key
= key_lookup_for_accept(keychain
, md5
->keyid
);
912 if (key
== NULL
|| key
->string
== NULL
)
915 memcpy(auth_str
, key
->string
,
916 MIN(sizeof(auth_str
), strlen(key
->string
)));
917 } else if (ri
->auth_str
)
918 memcpy(auth_str
, ri
->auth_str
,
919 MIN(sizeof(auth_str
), strlen(ri
->auth_str
)));
921 if (auth_str
[0] == 0)
924 /* MD5 digest authentication. */
925 #ifdef CRYPTO_OPENSSL
926 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
927 ctx
= EVP_MD_CTX_new();
928 EVP_DigestInit(ctx
, EVP_md5());
929 EVP_DigestUpdate(ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
930 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
931 EVP_DigestFinal(ctx
, digest
, &md5_size
);
932 EVP_MD_CTX_free(ctx
);
933 #elif CRYPTO_INTERNAL
934 memset(&ctx
, 0, sizeof(ctx
));
936 MD5Update(&ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
937 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
938 MD5Final(digest
, &ctx
);
941 if (memcmp(md5data
->digest
, digest
, RIP_AUTH_MD5_SIZE
) == 0)
947 /* Pick correct auth string for sends, prepare auth_str buffer for use.
948 * (left justified and padded).
950 * presumes one of ri or key is valid, and that the auth strings they point
951 * to are nul terminated. If neither are present, auth_str will be fully
955 static void rip_auth_prepare_str_send(struct rip_interface
*ri
, struct key
*key
,
956 char *auth_str
, int len
)
960 memset(auth_str
, 0, len
);
961 if (key
&& key
->string
)
962 memcpy(auth_str
, key
->string
,
963 MIN((size_t)len
, strlen(key
->string
)));
964 else if (ri
->auth_str
)
965 memcpy(auth_str
, ri
->auth_str
,
966 MIN((size_t)len
, strlen(ri
->auth_str
)));
971 /* Write RIPv2 simple password authentication information
973 * auth_str is presumed to be 2 bytes and correctly prepared
974 * (left justified and zero padded).
976 static void rip_auth_simple_write(struct stream
*s
, char *auth_str
, int len
)
978 assert(s
&& len
== RIP_AUTH_SIMPLE_SIZE
);
980 stream_putw(s
, RIP_FAMILY_AUTH
);
981 stream_putw(s
, RIP_AUTH_SIMPLE_PASSWORD
);
982 stream_put(s
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
987 /* write RIPv2 MD5 "authentication header"
988 * (uses the auth key data field)
990 * Digest offset field is set to 0.
992 * returns: offset of the digest offset field, which must be set when
993 * length to the auth-data MD5 digest is known.
995 static size_t rip_auth_md5_ah_write(struct stream
*s
, struct rip_interface
*ri
,
999 static uint32_t seq
= 0;
1001 assert(s
&& ri
&& ri
->auth_type
== RIP_AUTH_MD5
);
1003 /* MD5 authentication. */
1004 stream_putw(s
, RIP_FAMILY_AUTH
);
1005 stream_putw(s
, RIP_AUTH_MD5
);
1007 /* MD5 AH digest offset field.
1009 * Set to placeholder value here, to true value when RIP-2 Packet length
1010 * is known. Actual value is set in .....().
1012 doff
= stream_get_endp(s
);
1017 stream_putc(s
, key
->index
% 256);
1021 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1022 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for
1024 * to be configurable.
1026 stream_putc(s
, ri
->md5_auth_len
);
1028 /* Sequence Number (non-decreasing). */
1029 /* RFC2080: The value used in the sequence number is
1030 arbitrary, but two suggestions are the time of the
1031 message's creation or a simple message counter. */
1032 stream_putl(s
, ++seq
);
1034 /* Reserved field must be zero. */
1041 /* If authentication is in used, write the appropriate header
1042 * returns stream offset to which length must later be written
1043 * or 0 if this is not required
1045 static size_t rip_auth_header_write(struct stream
*s
, struct rip_interface
*ri
,
1046 struct key
*key
, char *auth_str
, int len
)
1048 assert(ri
->auth_type
!= RIP_NO_AUTH
);
1050 switch (ri
->auth_type
) {
1051 case RIP_AUTH_SIMPLE_PASSWORD
:
1052 rip_auth_prepare_str_send(ri
, key
, auth_str
, len
);
1053 rip_auth_simple_write(s
, auth_str
, len
);
1056 return rip_auth_md5_ah_write(s
, ri
, key
);
1062 /* Write RIPv2 MD5 authentication data trailer */
1063 static void rip_auth_md5_set(struct stream
*s
, struct rip_interface
*ri
,
1064 size_t doff
, char *auth_str
, int authlen
)
1067 #ifdef CRYPTO_OPENSSL
1069 #elif CRYPTO_INTERNAL
1072 unsigned char digest
[RIP_AUTH_MD5_SIZE
];
1074 /* Make it sure this interface is configured as MD5
1076 assert((ri
->auth_type
== RIP_AUTH_MD5
)
1077 && (authlen
== RIP_AUTH_MD5_SIZE
));
1080 /* Get packet length. */
1081 len
= stream_get_endp(s
);
1083 /* Check packet length. */
1084 if (len
< (RIP_HEADER_SIZE
+ RIP_RTE_SIZE
)) {
1087 "rip_auth_md5_set(): packet length %ld is less than minimum length.",
1092 /* Set the digest offset length in the header */
1093 stream_putw_at(s
, doff
, len
);
1095 /* Set authentication data. */
1096 stream_putw(s
, RIP_FAMILY_AUTH
);
1097 stream_putw(s
, RIP_AUTH_DATA
);
1099 /* Generate a digest for the RIP packet. */
1100 #ifdef CRYPTO_OPENSSL
1101 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
1102 ctx
= EVP_MD_CTX_new();
1103 EVP_DigestInit(ctx
, EVP_md5());
1104 EVP_DigestUpdate(ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1105 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1106 EVP_DigestFinal(ctx
, digest
, &md5_size
);
1107 EVP_MD_CTX_free(ctx
);
1108 #elif CRYPTO_INTERNAL
1109 memset(&ctx
, 0, sizeof(ctx
));
1111 MD5Update(&ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1112 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1113 MD5Final(digest
, &ctx
);
1116 /* Copy the digest to the packet. */
1117 stream_write(s
, digest
, RIP_AUTH_MD5_SIZE
);
1120 /* RIP routing information. */
1121 static void rip_response_process(struct rip_packet
*packet
, int size
,
1122 struct sockaddr_in
*from
,
1123 struct connected
*ifc
)
1125 struct rip_interface
*ri
= ifc
->ifp
->info
;
1126 struct rip
*rip
= ri
->rip
;
1129 struct prefix_ipv4 ifaddr
;
1130 struct prefix_ipv4 ifaddrclass
;
1133 memset(&ifaddr
, 0, sizeof(ifaddr
));
1134 /* We don't know yet. */
1137 /* The Response must be ignored if it is not from the RIP
1138 port. (RFC2453 - Sec. 3.9.2)*/
1139 if (from
->sin_port
!= htons(RIP_PORT_DEFAULT
)) {
1140 zlog_info("response doesn't come from RIP port: %d",
1142 rip_peer_bad_packet(rip
, from
);
1146 /* The datagram's IPv4 source address should be checked to see
1147 whether the datagram is from a valid neighbor; the source of the
1148 datagram must be on a directly connected network (RFC2453 - Sec.
1150 if (if_lookup_address((void *)&from
->sin_addr
, AF_INET
,
1154 "This datagram doesn't come from a valid neighbor: %pI4",
1156 rip_peer_bad_packet(rip
, from
);
1160 /* It is also worth checking to see whether the response is from one
1161 of the router's own addresses. */
1163 ; /* Alredy done in rip_read () */
1165 /* Update RIP peer. */
1166 rip_peer_update(rip
, from
, packet
->version
);
1168 /* Set RTE pointer. */
1171 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
1172 /* RIPv2 authentication check. */
1173 /* If the Address Family Identifier of the first (and only the
1174 first) entry in the message is 0xFFFF, then the remainder of
1175 the entry contains the authentication. */
1176 /* If the packet gets here it means authentication enabled */
1177 /* Check is done in rip_read(). So, just skipping it */
1178 if (packet
->version
== RIPv2
&& rte
== packet
->rte
1179 && rte
->family
== htons(RIP_FAMILY_AUTH
))
1182 if (rte
->family
!= htons(AF_INET
)) {
1183 /* Address family check. RIP only supports AF_INET. */
1184 zlog_info("Unsupported family %d from %pI4",
1190 /* - is the destination address valid (e.g., unicast; not net 0
1192 if (!rip_destination_check(rte
->prefix
)) {
1194 "Network is net 0 or net 127 or it is not unicast network");
1195 rip_peer_bad_route(rip
, from
);
1199 /* Convert metric value to host byte order. */
1200 rte
->metric
= ntohl(rte
->metric
);
1202 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1203 if (!(rte
->metric
>= 1 && rte
->metric
<= 16)) {
1204 zlog_info("Route's metric is not in the 1-16 range.");
1205 rip_peer_bad_route(rip
, from
);
1209 /* RIPv1 does not have nexthop value. */
1210 if (packet
->version
== RIPv1
1211 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1212 zlog_info("RIPv1 packet with nexthop value %pI4",
1214 rip_peer_bad_route(rip
, from
);
1218 /* That is, if the provided information is ignored, a possibly
1219 sub-optimal, but absolutely valid, route may be taken. If
1220 the received Next Hop is not directly reachable, it should be
1221 treated as 0.0.0.0. */
1222 if (packet
->version
== RIPv2
1223 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1226 /* Multicast address check. */
1227 addrval
= ntohl(rte
->nexthop
.s_addr
);
1228 if (IN_CLASSD(addrval
)) {
1230 "Nexthop %pI4 is multicast address, skip this rte",
1235 if (!if_lookup_address((void *)&rte
->nexthop
, AF_INET
,
1236 rip
->vrf
->vrf_id
)) {
1237 struct route_node
*rn
;
1238 struct rip_info
*rinfo
;
1240 rn
= route_node_match_ipv4(rip
->table
,
1246 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1249 if (IS_RIP_DEBUG_EVENT
)
1251 "Next hop %pI4 is on RIP network. Set nexthop to the packet's originator",
1253 rte
->nexthop
= rinfo
->from
;
1255 if (IS_RIP_DEBUG_EVENT
)
1257 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1259 rte
->nexthop
.s_addr
=
1263 route_unlock_node(rn
);
1265 if (IS_RIP_DEBUG_EVENT
)
1267 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1269 rte
->nexthop
.s_addr
= INADDR_ANY
;
1274 /* For RIPv1, there won't be a valid netmask.
1275 * This is a best guess at the masks. If everyone was using old
1276 * Ciscos before the 'ip subnet zero' option, it would be almost
1279 * Cisco summarize ripv1 advertisements to the classful boundary
1280 * (/16 for class B's) except when the RIP packet does to inside
1281 * the classful network in question.
1283 if ((packet
->version
== RIPv1
1284 && rte
->prefix
.s_addr
!= INADDR_ANY
)
1285 || (packet
->version
== RIPv2
1286 && (rte
->prefix
.s_addr
!= INADDR_ANY
1287 && rte
->mask
.s_addr
== INADDR_ANY
))) {
1288 uint32_t destination
;
1290 if (subnetted
== -1) {
1291 memcpy(&ifaddr
, ifc
->address
, sizeof(ifaddr
));
1292 memcpy(&ifaddrclass
, &ifaddr
,
1293 sizeof(ifaddrclass
));
1294 apply_classful_mask_ipv4(&ifaddrclass
);
1296 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1300 destination
= ntohl(rte
->prefix
.s_addr
);
1302 if (IN_CLASSA(destination
))
1303 masklen2ip(8, &rte
->mask
);
1304 else if (IN_CLASSB(destination
))
1305 masklen2ip(16, &rte
->mask
);
1306 else if (IN_CLASSC(destination
))
1307 masklen2ip(24, &rte
->mask
);
1310 masklen2ip(ifaddrclass
.prefixlen
,
1311 (struct in_addr
*)&destination
);
1312 if ((subnetted
== 1)
1313 && ((rte
->prefix
.s_addr
& destination
)
1314 == ifaddrclass
.prefix
.s_addr
)) {
1315 masklen2ip(ifaddr
.prefixlen
, &rte
->mask
);
1316 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1317 != rte
->prefix
.s_addr
)
1318 masklen2ip(32, &rte
->mask
);
1319 if (IS_RIP_DEBUG_EVENT
)
1320 zlog_debug("Subnetted route %pI4",
1323 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1324 != rte
->prefix
.s_addr
)
1328 if (IS_RIP_DEBUG_EVENT
) {
1329 zlog_debug("Resultant route %pI4",
1331 zlog_debug("Resultant mask %pI4",
1336 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1337 ignore the entry. */
1338 if ((packet
->version
== RIPv2
)
1339 && (rte
->mask
.s_addr
!= INADDR_ANY
)
1340 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1341 != rte
->prefix
.s_addr
)) {
1343 "RIPv2 address %pI4 is not mask /%d applied one",
1344 &rte
->prefix
, ip_masklen(rte
->mask
));
1345 rip_peer_bad_route(rip
, from
);
1349 /* Default route's netmask is ignored. */
1350 if (packet
->version
== RIPv2
1351 && (rte
->prefix
.s_addr
== INADDR_ANY
)
1352 && (rte
->mask
.s_addr
!= INADDR_ANY
)) {
1353 if (IS_RIP_DEBUG_EVENT
)
1355 "Default route with non-zero netmask. Set zero to netmask");
1356 rte
->mask
.s_addr
= INADDR_ANY
;
1359 /* Routing table updates. */
1360 rip_rte_process(rte
, from
, ifc
->ifp
);
1364 /* Make socket for RIP protocol. */
1365 int rip_create_socket(struct vrf
*vrf
)
1369 struct sockaddr_in addr
;
1370 const char *vrf_dev
= NULL
;
1372 memset(&addr
, 0, sizeof(struct sockaddr_in
));
1373 addr
.sin_family
= AF_INET
;
1374 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1375 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1376 addr
.sin_len
= sizeof(struct sockaddr_in
);
1377 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1378 /* sending port must always be the RIP port */
1379 addr
.sin_port
= htons(RIP_PORT_DEFAULT
);
1381 /* Make datagram socket. */
1382 if (vrf
->vrf_id
!= VRF_DEFAULT
)
1383 vrf_dev
= vrf
->name
;
1384 frr_with_privs(&ripd_privs
) {
1385 sock
= vrf_socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, vrf
->vrf_id
,
1388 flog_err_sys(EC_LIB_SOCKET
,
1389 "Cannot create UDP socket: %s",
1390 safe_strerror(errno
));
1395 sockopt_broadcast(sock
);
1396 sockopt_reuseaddr(sock
);
1397 sockopt_reuseport(sock
);
1398 setsockopt_ipv4_multicast_loop(sock
, 0);
1399 #ifdef IPTOS_PREC_INTERNETCONTROL
1400 setsockopt_ipv4_tos(sock
, IPTOS_PREC_INTERNETCONTROL
);
1402 setsockopt_so_recvbuf(sock
, RIP_UDP_RCV_BUF
);
1404 frr_with_privs(&ripd_privs
) {
1405 if ((ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
)))
1407 zlog_err("%s: Can't bind socket %d to %pI4 port %d: %s",
1408 __func__
, sock
, &addr
.sin_addr
,
1409 (int)ntohs(addr
.sin_port
),
1410 safe_strerror(errno
));
1420 /* RIP packet send to destination address, on interface denoted by
1421 * by connected argument. NULL to argument denotes destination should be
1422 * should be RIP multicast group
1424 static int rip_send_packet(uint8_t *buf
, int size
, struct sockaddr_in
*to
,
1425 struct connected
*ifc
)
1427 struct rip_interface
*ri
;
1430 struct sockaddr_in sin
;
1434 struct cmsghdr
*cmsgptr
;
1435 char adata
[256] = {};
1436 struct in_pktinfo
*pkt
;
1437 #endif /* GNU_LINUX */
1439 assert(ifc
!= NULL
);
1440 ri
= ifc
->ifp
->info
;
1443 if (IS_RIP_DEBUG_PACKET
) {
1444 #define ADDRESS_SIZE 20
1445 char dst
[ADDRESS_SIZE
];
1448 inet_ntop(AF_INET
, &to
->sin_addr
, dst
, sizeof(dst
));
1450 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1451 inet_ntop(AF_INET
, &sin
.sin_addr
, dst
, sizeof(dst
));
1454 zlog_debug("rip_send_packet %pI4 > %s (%s)",
1455 &ifc
->address
->u
.prefix4
, dst
,
1459 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
)) {
1461 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1462 * configured with multiple addresses on the same
1463 * subnet: the first address on the subnet is configured
1464 * "primary", and all subsequent addresses on that subnet
1465 * are treated as "secondary" addresses. In order to avoid
1466 * routing-table bloat on other rip listeners, we do not send
1467 * out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
1468 * XXX Since Linux is the only system for which the
1469 * ZEBRA_IFA_SECONDARY flag is set, we would end up
1470 * sending a packet for a "secondary" source address on
1471 * non-linux systems.
1473 if (IS_RIP_DEBUG_PACKET
)
1474 zlog_debug("duplicate dropped");
1478 /* Make destination address. */
1479 memset(&sin
, 0, sizeof(sin
));
1480 sin
.sin_family
= AF_INET
;
1481 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1482 sin
.sin_len
= sizeof(struct sockaddr_in
);
1483 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1485 /* When destination is specified, use it's port and address. */
1487 sin
.sin_port
= to
->sin_port
;
1488 sin
.sin_addr
= to
->sin_addr
;
1490 sin
.sin_port
= htons(RIP_PORT_DEFAULT
);
1491 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1493 rip_interface_multicast_set(rip
->sock
, ifc
);
1496 memset(&msg
, 0, sizeof(msg
));
1497 msg
.msg_name
= (void *)&sin
;
1498 msg
.msg_namelen
= sizeof(struct sockaddr_in
);
1505 msg
.msg_control
= (void *)adata
;
1506 msg
.msg_controllen
= CMSG_SPACE(sizeof(struct in_pktinfo
));
1508 cmsgptr
= (struct cmsghdr
*)adata
;
1509 cmsgptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_pktinfo
));
1510 cmsgptr
->cmsg_level
= IPPROTO_IP
;
1511 cmsgptr
->cmsg_type
= IP_PKTINFO
;
1512 pkt
= (struct in_pktinfo
*)CMSG_DATA(cmsgptr
);
1513 pkt
->ipi_ifindex
= ifc
->ifp
->ifindex
;
1514 pkt
->ipi_spec_dst
.s_addr
= ifc
->address
->u
.prefix4
.s_addr
;
1515 #endif /* GNU_LINUX */
1517 ret
= sendmsg(rip
->sock
, &msg
, 0);
1519 if (IS_RIP_DEBUG_EVENT
)
1520 zlog_debug("SEND to %pI4%d", &sin
.sin_addr
,
1521 ntohs(sin
.sin_port
));
1524 zlog_warn("can't send packet : %s", safe_strerror(errno
));
1529 /* Add redistributed route to RIP table. */
1530 void rip_redistribute_add(struct rip
*rip
, int type
, int sub_type
,
1531 struct prefix_ipv4
*p
, struct nexthop
*nh
,
1532 unsigned int metric
, unsigned char distance
,
1536 struct route_node
*rp
= NULL
;
1537 struct rip_info
*rinfo
= NULL
, newinfo
;
1538 struct list
*list
= NULL
;
1540 /* Redistribute route */
1541 ret
= rip_destination_check(p
->prefix
);
1545 rp
= route_node_get(rip
->table
, (struct prefix
*)p
);
1547 memset(&newinfo
, 0, sizeof(newinfo
));
1548 newinfo
.type
= type
;
1549 newinfo
.sub_type
= sub_type
;
1551 newinfo
.external_metric
= metric
;
1552 newinfo
.distance
= distance
;
1553 if (tag
<= UINT16_MAX
) /* RIP only supports 16 bit tags */
1558 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
1559 rinfo
= listgetdata(listhead(list
));
1561 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1562 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1563 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
1564 route_unlock_node(rp
);
1568 /* Manually configured RIP route check. */
1569 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1570 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
1571 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))) {
1572 if (type
!= ZEBRA_ROUTE_RIP
1573 || ((sub_type
!= RIP_ROUTE_STATIC
)
1574 && (sub_type
!= RIP_ROUTE_DEFAULT
))) {
1575 route_unlock_node(rp
);
1580 (void)rip_ecmp_replace(rip
, &newinfo
);
1581 route_unlock_node(rp
);
1583 (void)rip_ecmp_add(rip
, &newinfo
);
1585 if (IS_RIP_DEBUG_EVENT
) {
1586 zlog_debug("Redistribute new prefix %pFX", p
);
1589 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1592 /* Delete redistributed route from RIP table. */
1593 void rip_redistribute_delete(struct rip
*rip
, int type
, int sub_type
,
1594 struct prefix_ipv4
*p
, ifindex_t ifindex
)
1597 struct route_node
*rp
;
1598 struct rip_info
*rinfo
;
1600 ret
= rip_destination_check(p
->prefix
);
1604 rp
= route_node_lookup(rip
->table
, (struct prefix
*)p
);
1606 struct list
*list
= rp
->info
;
1608 if (list
!= NULL
&& listcount(list
) != 0) {
1609 rinfo
= listgetdata(listhead(list
));
1610 if (rinfo
!= NULL
&& rinfo
->type
== type
1611 && rinfo
->sub_type
== sub_type
1612 && rinfo
->nh
.ifindex
== ifindex
) {
1613 /* Perform poisoned reverse. */
1614 rinfo
->metric
= RIP_METRIC_INFINITY
;
1615 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
1616 rip_garbage_collect
,
1618 THREAD_OFF(rinfo
->t_timeout
);
1619 rinfo
->flags
|= RIP_RTF_CHANGED
;
1621 if (IS_RIP_DEBUG_EVENT
)
1623 "Poison %pFX on the interface %s with an infinity metric [delete]",
1629 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1632 route_unlock_node(rp
);
1636 /* Response to request called from rip_read ().*/
1637 static void rip_request_process(struct rip_packet
*packet
, int size
,
1638 struct sockaddr_in
*from
, struct connected
*ifc
)
1643 struct prefix_ipv4 p
;
1644 struct route_node
*rp
;
1645 struct rip_info
*rinfo
;
1646 struct rip_interface
*ri
;
1648 /* Does not reponse to the requests on the loopback interfaces */
1649 if (if_is_loopback(ifc
->ifp
))
1652 /* Check RIP process is enabled on this interface. */
1653 ri
= ifc
->ifp
->info
;
1658 /* When passive interface is specified, suppress responses */
1662 /* RIP peer update. */
1663 rip_peer_update(rip
, from
, packet
->version
);
1665 lim
= ((caddr_t
)packet
) + size
;
1668 /* The Request is processed entry by entry. If there are no
1669 entries, no response is given. */
1670 if (lim
== (caddr_t
)rte
)
1673 /* There is one special case. If there is exactly one entry in the
1674 request, and it has an address family identifier of zero and a
1675 metric of infinity (i.e., 16), then this is a request to send the
1676 entire routing table. */
1677 if (lim
== ((caddr_t
)(rte
+ 1)) && ntohs(rte
->family
) == 0
1678 && ntohl(rte
->metric
) == RIP_METRIC_INFINITY
) {
1679 /* All route with split horizon */
1680 rip_output_process(ifc
, from
, rip_all_route
, packet
->version
);
1682 if (ntohs(rte
->family
) != AF_INET
)
1685 /* Examine the list of RTEs in the Request one by one. For each
1686 entry, look up the destination in the router's routing
1687 database and, if there is a route, put that route's metric in
1688 the metric field of the RTE. If there is no explicit route
1689 to the specified destination, put infinity in the metric
1690 field. Once all the entries have been filled in, change the
1691 command from Request to Response and send the datagram back
1692 to the requestor. */
1695 for (; ((caddr_t
)rte
) < lim
; rte
++) {
1696 p
.prefix
= rte
->prefix
;
1697 p
.prefixlen
= ip_masklen(rte
->mask
);
1698 apply_mask_ipv4(&p
);
1700 rp
= route_node_lookup(rip
->table
, (struct prefix
*)&p
);
1702 rinfo
= listgetdata(
1703 listhead((struct list
*)rp
->info
));
1704 rte
->metric
= htonl(rinfo
->metric
);
1705 route_unlock_node(rp
);
1707 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
1709 packet
->command
= RIP_RESPONSE
;
1711 (void)rip_send_packet((uint8_t *)packet
, size
, from
, ifc
);
1713 rip
->counters
.queries
++;
1716 /* First entry point of RIP packet. */
1717 static void rip_read(struct thread
*t
)
1719 struct rip
*rip
= THREAD_ARG(t
);
1723 union rip_buf rip_buf
;
1724 struct rip_packet
*packet
;
1725 struct sockaddr_in from
;
1729 struct interface
*ifp
= NULL
;
1730 struct connected
*ifc
;
1731 struct rip_interface
*ri
;
1734 /* Fetch socket then register myself. */
1735 sock
= THREAD_FD(t
);
1737 /* Add myself to tne next event */
1738 rip_event(rip
, RIP_READ
, sock
);
1740 /* RIPd manages only IPv4. */
1741 memset(&from
, 0, sizeof(from
));
1742 fromlen
= sizeof(struct sockaddr_in
);
1744 len
= recvfrom(sock
, (char *)&rip_buf
.buf
, sizeof(rip_buf
.buf
), 0,
1745 (struct sockaddr
*)&from
, &fromlen
);
1747 zlog_info("recvfrom failed (VRF %s): %s", rip
->vrf_name
,
1748 safe_strerror(errno
));
1752 /* Check is this packet comming from myself? */
1753 if (if_check_address(rip
, from
.sin_addr
)) {
1754 if (IS_RIP_DEBUG_PACKET
)
1755 zlog_debug("ignore packet comes from myself (VRF %s)",
1760 /* Which interface is this packet comes from. */
1761 ifc
= if_lookup_address((void *)&from
.sin_addr
, AF_INET
,
1766 /* RIP packet received */
1767 if (IS_RIP_DEBUG_EVENT
)
1768 zlog_debug("RECV packet from %pI4 port %d on %s (VRF %s)",
1769 &from
.sin_addr
, ntohs(from
.sin_port
),
1770 ifp
? ifp
->name
: "unknown", rip
->vrf_name
);
1772 /* If this packet come from unknown interface, ignore it. */
1775 "rip_read: cannot find interface for packet from %pI4 port %d (VRF %s)",
1776 &from
.sin_addr
, ntohs(from
.sin_port
),
1782 p
.u
.prefix4
= from
.sin_addr
;
1783 p
.prefixlen
= IPV4_MAX_BITLEN
;
1785 ifc
= connected_lookup_prefix(ifp
, &p
);
1789 "rip_read: cannot find connected address for packet from %pI4 port %d on interface %s (VRF %s)",
1790 &from
.sin_addr
, ntohs(from
.sin_port
),
1791 ifp
->name
, rip
->vrf_name
);
1795 /* Packet length check. */
1796 if (len
< RIP_PACKET_MINSIZ
) {
1797 zlog_warn("packet size %d is smaller than minimum size %d", len
,
1799 rip_peer_bad_packet(rip
, &from
);
1802 if (len
> RIP_PACKET_MAXSIZ
) {
1803 zlog_warn("packet size %d is larger than max size %d", len
,
1805 rip_peer_bad_packet(rip
, &from
);
1809 /* Packet alignment check. */
1810 if ((len
- RIP_PACKET_MINSIZ
) % 20) {
1811 zlog_warn("packet size %d is wrong for RIP packet alignment",
1813 rip_peer_bad_packet(rip
, &from
);
1817 /* Set RTE number. */
1818 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1820 /* For easy to handle. */
1821 packet
= &rip_buf
.rip_packet
;
1823 /* RIP version check. */
1824 if (packet
->version
== 0) {
1825 zlog_info("version 0 with command %d received.",
1827 rip_peer_bad_packet(rip
, &from
);
1831 /* Dump RIP packet. */
1832 if (IS_RIP_DEBUG_RECV
)
1833 rip_packet_dump(packet
, len
, "RECV");
1835 /* RIP version adjust. This code should rethink now. RFC1058 says
1836 that "Version 1 implementations are to ignore this extra data and
1837 process only the fields specified in this document.". So RIPv3
1838 packet should be treated as RIPv1 ignoring must be zero field. */
1839 if (packet
->version
> RIPv2
)
1840 packet
->version
= RIPv2
;
1842 /* Is RIP running or is this RIP neighbor ?*/
1844 if (!ri
->running
&& !rip_neighbor_lookup(rip
, &from
)) {
1845 if (IS_RIP_DEBUG_EVENT
)
1846 zlog_debug("RIP is not enabled on interface %s.",
1848 rip_peer_bad_packet(rip
, &from
);
1852 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1853 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ? rip
->version_recv
1855 if (vrecv
== RI_RIP_VERSION_NONE
1856 || ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1857 || ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))) {
1858 if (IS_RIP_DEBUG_PACKET
)
1860 " packet's v%d doesn't fit to if version spec",
1862 rip_peer_bad_packet(rip
, &from
);
1866 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1867 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1868 accepted; authenticated RIP-2 messages shall be discarded. */
1869 if ((ri
->auth_type
== RIP_NO_AUTH
) && rtenum
1870 && (packet
->version
== RIPv2
)
1871 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
))) {
1872 if (IS_RIP_DEBUG_EVENT
)
1874 "packet RIPv%d is dropped because authentication disabled",
1876 ripd_notif_send_auth_type_failure(ifp
->name
);
1877 rip_peer_bad_packet(rip
, &from
);
1882 If the router is configured to authenticate RIP-2 messages, then
1883 RIP-1 messages and RIP-2 messages which pass authentication
1884 testing shall be accepted; unauthenticated and failed
1885 authentication RIP-2 messages shall be discarded. For maximum
1886 security, RIP-1 messages should be ignored when authentication is
1887 in use (see section 4.1); otherwise, the routing information from
1888 authenticated messages will be propagated by RIP-1 routers in an
1889 unauthenticated manner.
1891 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1892 * always reply regardless of authentication settings, because:
1894 * - if there other authorised routers on-link, the REQUESTor can
1895 * passively obtain the routing updates anyway
1896 * - if there are no other authorised routers on-link, RIP can
1897 * easily be disabled for the link to prevent giving out information
1898 * on state of this routers RIP routing table..
1900 * I.e. if RIPv1 has any place anymore these days, it's as a very
1901 * simple way to distribute routing information (e.g. to embedded
1902 * hosts / appliances) and the ability to give out RIPv1
1903 * routing-information freely, while still requiring RIPv2
1904 * authentication for any RESPONSEs might be vaguely useful.
1906 if (ri
->auth_type
!= RIP_NO_AUTH
&& packet
->version
== RIPv1
) {
1907 /* Discard RIPv1 messages other than REQUESTs */
1908 if (packet
->command
!= RIP_REQUEST
) {
1909 if (IS_RIP_DEBUG_PACKET
)
1911 "RIPv1 dropped because authentication enabled");
1912 ripd_notif_send_auth_type_failure(ifp
->name
);
1913 rip_peer_bad_packet(rip
, &from
);
1916 } else if (ri
->auth_type
!= RIP_NO_AUTH
) {
1917 const char *auth_desc
;
1920 /* There definitely is no authentication in the packet.
1922 if (IS_RIP_DEBUG_PACKET
)
1924 "RIPv2 authentication failed: no auth RTE in packet");
1925 ripd_notif_send_auth_type_failure(ifp
->name
);
1926 rip_peer_bad_packet(rip
, &from
);
1930 /* First RTE must be an Authentication Family RTE */
1931 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
)) {
1932 if (IS_RIP_DEBUG_PACKET
)
1934 "RIPv2 dropped because authentication enabled");
1935 ripd_notif_send_auth_type_failure(ifp
->name
);
1936 rip_peer_bad_packet(rip
, &from
);
1940 /* Check RIPv2 authentication. */
1941 switch (ntohs(packet
->rte
->tag
)) {
1942 case RIP_AUTH_SIMPLE_PASSWORD
:
1943 auth_desc
= "simple";
1944 ret
= rip_auth_simple_password(packet
->rte
, &from
, ifp
);
1949 ret
= rip_auth_md5(packet
, &from
, len
, ifp
);
1950 /* Reset RIP packet length to trim MD5 data. */
1956 auth_desc
= "unknown type";
1957 if (IS_RIP_DEBUG_PACKET
)
1959 "RIPv2 Unknown authentication type %d",
1960 ntohs(packet
->rte
->tag
));
1964 if (IS_RIP_DEBUG_PACKET
)
1965 zlog_debug("RIPv2 %s authentication success",
1968 if (IS_RIP_DEBUG_PACKET
)
1969 zlog_debug("RIPv2 %s authentication failure",
1971 ripd_notif_send_auth_failure(ifp
->name
);
1972 rip_peer_bad_packet(rip
, &from
);
1977 /* Process each command. */
1978 switch (packet
->command
) {
1980 rip_response_process(packet
, len
, &from
, ifc
);
1984 rip_request_process(packet
, len
, &from
, ifc
);
1989 "Obsolete command %s received, please sent it to routed",
1990 lookup_msg(rip_msg
, packet
->command
, NULL
));
1991 rip_peer_bad_packet(rip
, &from
);
1993 case RIP_POLL_ENTRY
:
1994 zlog_info("Obsolete command %s received",
1995 lookup_msg(rip_msg
, packet
->command
, NULL
));
1996 rip_peer_bad_packet(rip
, &from
);
1999 zlog_info("Unknown RIP command %d received", packet
->command
);
2000 rip_peer_bad_packet(rip
, &from
);
2005 /* Write routing table entry to the stream and return next index of
2006 the routing table entry in the stream. */
2007 static int rip_write_rte(int num
, struct stream
*s
, struct prefix_ipv4
*p
,
2008 uint8_t version
, struct rip_info
*rinfo
)
2010 struct in_addr mask
;
2012 /* Write routing table entry. */
2013 if (version
== RIPv1
) {
2014 stream_putw(s
, AF_INET
);
2016 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2017 stream_put_ipv4(s
, 0);
2018 stream_put_ipv4(s
, 0);
2019 stream_putl(s
, rinfo
->metric_out
);
2021 masklen2ip(p
->prefixlen
, &mask
);
2023 stream_putw(s
, AF_INET
);
2024 stream_putw(s
, rinfo
->tag_out
);
2025 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2026 stream_put_ipv4(s
, mask
.s_addr
);
2027 stream_put_ipv4(s
, rinfo
->nexthop_out
.s_addr
);
2028 stream_putl(s
, rinfo
->metric_out
);
2034 /* Send update to the ifp or spcified neighbor. */
2035 void rip_output_process(struct connected
*ifc
, struct sockaddr_in
*to
,
2036 int route_type
, uint8_t version
)
2041 struct route_node
*rp
;
2042 struct rip_info
*rinfo
;
2043 struct rip_interface
*ri
;
2044 struct prefix_ipv4
*p
;
2045 struct prefix_ipv4 classfull
;
2046 struct prefix_ipv4 ifaddrclass
;
2047 struct key
*key
= NULL
;
2048 /* this might need to made dynamic if RIP ever supported auth methods
2049 with larger key string sizes */
2050 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2051 size_t doff
= 0; /* offset of digest offset field */
2055 struct list
*list
= NULL
;
2056 struct listnode
*listnode
= NULL
;
2058 /* Logging output event. */
2059 if (IS_RIP_DEBUG_EVENT
) {
2061 zlog_debug("update routes to neighbor %pI4",
2064 zlog_debug("update routes on interface %s ifindex %d",
2065 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2068 /* Get RIP interface. */
2069 ri
= ifc
->ifp
->info
;
2072 /* Set output stream. */
2075 /* Reset stream and RTE counter. */
2077 rtemax
= RIP_MAX_RTE
;
2079 /* If output interface is in simple password authentication mode, we
2080 need space for authentication data. */
2081 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2084 /* If output interface is in MD5 authentication mode, we need space
2085 for authentication header and data. */
2086 if (ri
->auth_type
== RIP_AUTH_MD5
)
2089 /* If output interface is in simple password authentication mode
2090 and string or keychain is specified we need space for auth. data */
2091 if (ri
->auth_type
!= RIP_NO_AUTH
) {
2092 if (ri
->key_chain
) {
2093 struct keychain
*keychain
;
2095 keychain
= keychain_lookup(ri
->key_chain
);
2097 key
= key_lookup_for_send(keychain
);
2099 /* to be passed to auth functions later */
2100 rip_auth_prepare_str_send(ri
, key
, auth_str
, sizeof(auth_str
));
2101 if (strlen(auth_str
) == 0)
2105 if (version
== RIPv1
) {
2106 memcpy(&ifaddrclass
, ifc
->address
, sizeof(ifaddrclass
));
2107 apply_classful_mask_ipv4(&ifaddrclass
);
2109 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2113 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2119 if (listcount(list
) == 0)
2122 rinfo
= listgetdata(listhead(list
));
2124 * For RIPv1, if we are subnetted, output subnets in our
2125 * network that have the same mask as the output "interface".
2126 * For other networks, only the classfull version is output.
2128 if (version
== RIPv1
) {
2129 p
= (struct prefix_ipv4
*)&rp
->p
;
2131 if (IS_RIP_DEBUG_PACKET
)
2133 "RIPv1 mask check, %pFX considered for output",
2137 prefix_match((struct prefix
*)&ifaddrclass
,
2139 if ((ifc
->address
->prefixlen
!=
2141 (rp
->p
.prefixlen
!= IPV4_MAX_BITLEN
))
2144 memcpy(&classfull
, &rp
->p
,
2145 sizeof(struct prefix_ipv4
));
2146 apply_classful_mask_ipv4(&classfull
);
2147 if (rp
->p
.u
.prefix4
.s_addr
!= INADDR_ANY
&&
2148 classfull
.prefixlen
!= rp
->p
.prefixlen
)
2151 if (IS_RIP_DEBUG_PACKET
)
2153 "RIPv1 mask check, %pFX made it through",
2156 p
= (struct prefix_ipv4
*)&rp
->p
;
2158 /* Apply output filters. */
2159 ret
= rip_filter(RIP_FILTER_OUT
, p
, ri
);
2163 /* Changed route only output. */
2164 if (route_type
== rip_changed_route
&&
2165 (!(rinfo
->flags
& RIP_RTF_CHANGED
)))
2168 /* Split horizon. */
2169 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
) {
2171 * We perform split horizon for RIP and connected
2172 * route. For rip routes, we want to suppress the
2173 * route if we would end up sending the route back on
2174 * the interface that we learned it from, with a
2175 * higher metric. For connected routes, we suppress
2176 * the route if the prefix is a subset of the source
2177 * address that we are going to use for the packet
2178 * (in order to handle the case when multiple subnets
2179 * are configured on the same interface).
2182 struct rip_info
*tmp_rinfo
= NULL
;
2183 struct connected
*tmp_ifc
= NULL
;
2185 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2186 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2187 tmp_rinfo
->nh
.ifindex
==
2188 ifc
->ifp
->ifindex
) {
2193 if (!suppress
&& rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2194 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2196 if (prefix_match((struct prefix
*)p
,
2197 tmp_ifc
->address
)) {
2207 /* Preparation for route-map. */
2208 rinfo
->metric_set
= 0;
2209 rinfo
->nexthop_out
.s_addr
= 0;
2210 rinfo
->metric_out
= rinfo
->metric
;
2211 rinfo
->tag_out
= rinfo
->tag
;
2212 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2214 /* In order to avoid some local loops, if the RIP route has
2215 * a nexthop via this interface, keep the nexthop, otherwise
2216 * set it to 0. The nexthop should not be propagated beyond
2217 * the local broadcast/multicast area in order to avoid an
2218 * IGP multi-level recursive look-up. see (4.4)
2220 if (rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2221 rinfo
->nexthop_out
= rinfo
->nh
.gate
.ipv4
;
2223 /* Interface route-map */
2224 if (ri
->routemap
[RIP_FILTER_OUT
]) {
2225 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_OUT
],
2226 (struct prefix
*)p
, rinfo
);
2228 if (ret
== RMAP_DENYMATCH
) {
2229 if (IS_RIP_DEBUG_PACKET
)
2231 "RIP %pFX is filtered by route-map out",
2237 /* Apply redistribute route map - continue, if deny */
2238 if (rip
->redist
[rinfo
->type
].route_map
.name
&&
2239 rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2240 ret
= route_map_apply(
2241 rip
->redist
[rinfo
->type
].route_map
.map
,
2242 (struct prefix
*)p
, rinfo
);
2244 if (ret
== RMAP_DENYMATCH
) {
2245 if (IS_RIP_DEBUG_PACKET
)
2247 "%pFX is filtered by route-map",
2253 /* When route-map does not set metric. */
2254 if (!rinfo
->metric_set
) {
2255 /* If redistribute metric is set. */
2256 if (rip
->redist
[rinfo
->type
].metric_config
&&
2257 rinfo
->metric
!= RIP_METRIC_INFINITY
) {
2259 rip
->redist
[rinfo
->type
].metric
;
2261 /* If the route is not connected or localy
2262 * generated one, use default-metric value
2264 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&&
2265 rinfo
->type
!= ZEBRA_ROUTE_CONNECT
&&
2266 rinfo
->metric
!= RIP_METRIC_INFINITY
)
2267 rinfo
->metric_out
= rip
->default_metric
;
2271 /* Apply offset-list */
2272 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2273 rip_offset_list_apply_out(p
, ifc
->ifp
,
2274 &rinfo
->metric_out
);
2276 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2277 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2279 /* Perform split-horizon with poisoned reverse
2280 * for RIP and connected routes.
2282 if (ri
->split_horizon
== RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2284 * We perform split horizon for RIP and connected
2285 * route. For rip routes, we want to suppress the
2286 * route if we would end up sending the route back
2287 * on the interface that we learned it from, with a
2288 * higher metric. For connected routes, we suppress
2289 * the route if the prefix is a subset of the source
2290 * address that we are going to use for the packet
2291 * (in order to handle the case when multiple
2292 * subnets are configured on the same interface).
2294 struct rip_info
*tmp_rinfo
= NULL
;
2295 struct connected
*tmp_ifc
= NULL
;
2297 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2298 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2299 tmp_rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2300 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2302 if (rinfo
->metric_out
!= RIP_METRIC_INFINITY
&&
2303 rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2304 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2306 if (prefix_match((struct prefix
*)p
,
2307 tmp_ifc
->address
)) {
2309 RIP_METRIC_INFINITY
;
2315 /* Prepare preamble, auth headers, if needs be */
2317 stream_putc(s
, RIP_RESPONSE
);
2318 stream_putc(s
, version
);
2321 /* auth header for !v1 && !no_auth */
2322 if ((ri
->auth_type
!= RIP_NO_AUTH
) &&
2324 doff
= rip_auth_header_write(
2325 s
, ri
, key
, auth_str
,
2326 RIP_AUTH_SIMPLE_SIZE
);
2329 /* Write RTE to the stream. */
2330 num
= rip_write_rte(num
, s
, p
, version
, rinfo
);
2331 if (num
== rtemax
) {
2332 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2333 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2334 RIP_AUTH_SIMPLE_SIZE
);
2336 ret
= rip_send_packet(STREAM_DATA(s
),
2337 stream_get_endp(s
), to
, ifc
);
2339 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2341 (struct rip_packet
*)STREAM_DATA(s
),
2342 stream_get_endp(s
), "SEND");
2348 /* Flush unwritten RTE. */
2350 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2351 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2352 RIP_AUTH_SIMPLE_SIZE
);
2354 ret
= rip_send_packet(STREAM_DATA(s
), stream_get_endp(s
), to
,
2357 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2358 rip_packet_dump((struct rip_packet
*)STREAM_DATA(s
),
2359 stream_get_endp(s
), "SEND");
2363 /* Statistics updates. */
2367 /* Send RIP packet to the interface. */
2368 static void rip_update_interface(struct connected
*ifc
, uint8_t version
,
2371 struct interface
*ifp
= ifc
->ifp
;
2372 struct rip_interface
*ri
= ifp
->info
;
2373 struct sockaddr_in to
;
2375 /* When RIP version is 2 and multicast enable interface. */
2376 if (version
== RIPv2
&& !ri
->v2_broadcast
&& if_is_multicast(ifp
)) {
2377 if (IS_RIP_DEBUG_EVENT
)
2378 zlog_debug("multicast announce on %s ", ifp
->name
);
2380 rip_output_process(ifc
, NULL
, route_type
, version
);
2384 /* If we can't send multicast packet, send it with unicast. */
2385 if (if_is_broadcast(ifp
) || if_is_pointopoint(ifp
)) {
2386 if (ifc
->address
->family
== AF_INET
) {
2387 /* Destination address and port setting. */
2388 memset(&to
, 0, sizeof(to
));
2389 if (ifc
->destination
)
2390 /* use specified broadcast or peer destination
2392 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2393 else if (ifc
->address
->prefixlen
< IPV4_MAX_BITLEN
)
2394 /* calculate the appropriate broadcast address
2396 to
.sin_addr
.s_addr
= ipv4_broadcast_addr(
2397 ifc
->address
->u
.prefix4
.s_addr
,
2398 ifc
->address
->prefixlen
);
2400 /* do not know where to send the packet */
2402 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2404 if (IS_RIP_DEBUG_EVENT
)
2405 zlog_debug("%s announce to %pI4 on %s",
2406 CONNECTED_PEER(ifc
) ? "unicast"
2408 &to
.sin_addr
, ifp
->name
);
2410 rip_output_process(ifc
, &to
, route_type
, version
);
2415 /* Update send to all interface and neighbor. */
2416 static void rip_update_process(struct rip
*rip
, int route_type
)
2418 struct listnode
*ifnode
, *ifnnode
;
2419 struct connected
*connected
;
2420 struct interface
*ifp
;
2421 struct rip_interface
*ri
;
2422 struct route_node
*rp
;
2423 struct sockaddr_in to
;
2426 /* Send RIP update to each interface. */
2427 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
2428 if (if_is_loopback(ifp
))
2431 if (!if_is_operative(ifp
))
2434 /* Fetch RIP interface information. */
2437 /* When passive interface is specified, suppress announce to the
2446 * If there is no version configuration in the
2447 * interface, use rip's version setting.
2449 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
) ? rip
->version_send
2452 if (IS_RIP_DEBUG_EVENT
)
2453 zlog_debug("SEND UPDATE to %s ifindex %d", ifp
->name
,
2456 /* send update on each connected network */
2457 for (ALL_LIST_ELEMENTS(ifp
->connected
, ifnode
, ifnnode
,
2459 if (connected
->address
->family
== AF_INET
) {
2461 rip_update_interface(connected
, RIPv1
,
2463 if ((vsend
& RIPv2
) && if_is_multicast(ifp
))
2464 rip_update_interface(connected
, RIPv2
,
2470 /* RIP send updates to each neighbor. */
2471 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
)) {
2472 if (rp
->info
== NULL
)
2477 connected
= if_lookup_address(&p
->u
.prefix4
, AF_INET
,
2481 "Neighbor %pI4 doesn't have connected interface!",
2486 /* Set destination address and port */
2487 memset(&to
, 0, sizeof(struct sockaddr_in
));
2488 to
.sin_addr
= p
->u
.prefix4
;
2489 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2491 /* RIP version is rip's configuration. */
2492 rip_output_process(connected
, &to
, route_type
,
2497 /* RIP's periodical timer. */
2498 static void rip_update(struct thread
*t
)
2500 struct rip
*rip
= THREAD_ARG(t
);
2502 if (IS_RIP_DEBUG_EVENT
)
2503 zlog_debug("update timer fire!");
2505 /* Process update output. */
2506 rip_update_process(rip
, rip_all_route
);
2508 /* Triggered updates may be suppressed if a regular update is due by
2509 the time the triggered update would be sent. */
2510 THREAD_OFF(rip
->t_triggered_interval
);
2513 /* Register myself. */
2514 rip_event(rip
, RIP_UPDATE_EVENT
, 0);
2517 /* Walk down the RIP routing table then clear changed flag. */
2518 static void rip_clear_changed_flag(struct rip
*rip
)
2520 struct route_node
*rp
;
2521 struct rip_info
*rinfo
= NULL
;
2522 struct list
*list
= NULL
;
2523 struct listnode
*listnode
= NULL
;
2525 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2531 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
2532 UNSET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2533 /* This flag can be set only on the first entry. */
2539 /* Triggered update interval timer. */
2540 static void rip_triggered_interval(struct thread
*t
)
2542 struct rip
*rip
= THREAD_ARG(t
);
2546 rip_triggered_update(t
);
2550 /* Execute triggered update. */
2551 static void rip_triggered_update(struct thread
*t
)
2553 struct rip
*rip
= THREAD_ARG(t
);
2556 /* Cancel interval timer. */
2557 THREAD_OFF(rip
->t_triggered_interval
);
2560 /* Logging triggered update. */
2561 if (IS_RIP_DEBUG_EVENT
)
2562 zlog_debug("triggered update!");
2564 /* Split Horizon processing is done when generating triggered
2565 updates as well as normal updates (see section 2.6). */
2566 rip_update_process(rip
, rip_changed_route
);
2568 /* Once all of the triggered updates have been generated, the route
2569 change flags should be cleared. */
2570 rip_clear_changed_flag(rip
);
2572 /* After a triggered update is sent, a timer should be set for a
2573 random interval between 1 and 5 seconds. If other changes that
2574 would trigger updates occur before the timer expires, a single
2575 update is triggered when the timer expires. */
2576 interval
= (frr_weak_random() % 5) + 1;
2578 thread_add_timer(master
, rip_triggered_interval
, rip
, interval
,
2579 &rip
->t_triggered_interval
);
2582 /* Withdraw redistributed route. */
2583 void rip_redistribute_withdraw(struct rip
*rip
, int type
)
2585 struct route_node
*rp
;
2586 struct rip_info
*rinfo
= NULL
;
2587 struct list
*list
= NULL
;
2589 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2595 rinfo
= listgetdata(listhead(list
));
2597 if (rinfo
->type
!= type
)
2600 if (rinfo
->sub_type
== RIP_ROUTE_INTERFACE
)
2603 /* Perform poisoned reverse. */
2604 rinfo
->metric
= RIP_METRIC_INFINITY
;
2605 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
2607 THREAD_OFF(rinfo
->t_timeout
);
2608 rinfo
->flags
|= RIP_RTF_CHANGED
;
2610 if (IS_RIP_DEBUG_EVENT
) {
2611 struct prefix_ipv4
*p
= (struct prefix_ipv4
*)&rp
->p
;
2614 "Poisone %pFX on the interface %s with an infinity metric [withdraw]",
2616 ifindex2ifname(rinfo
->nh
.ifindex
,
2620 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2624 struct rip
*rip_lookup_by_vrf_id(vrf_id_t vrf_id
)
2628 vrf
= vrf_lookup_by_id(vrf_id
);
2635 struct rip
*rip_lookup_by_vrf_name(const char *vrf_name
)
2639 rip
.vrf_name
= (char *)vrf_name
;
2641 return RB_FIND(rip_instance_head
, &rip_instances
, &rip
);
2644 /* Create new RIP instance and set it to global variable. */
2645 struct rip
*rip_create(const char *vrf_name
, struct vrf
*vrf
, int socket
)
2649 rip
= XCALLOC(MTYPE_RIP
, sizeof(struct rip
));
2650 rip
->vrf_name
= XSTRDUP(MTYPE_RIP_VRF_NAME
, vrf_name
);
2652 /* Set initial value. */
2653 rip
->ecmp
= yang_get_default_bool("%s/allow-ecmp", RIP_INSTANCE
);
2654 rip
->default_metric
=
2655 yang_get_default_uint8("%s/default-metric", RIP_INSTANCE
);
2657 yang_get_default_uint8("%s/distance/default", RIP_INSTANCE
);
2658 rip
->passive_default
=
2659 yang_get_default_bool("%s/passive-default", RIP_INSTANCE
);
2660 rip
->garbage_time
= yang_get_default_uint32("%s/timers/flush-interval",
2662 rip
->timeout_time
= yang_get_default_uint32(
2663 "%s/timers/holddown-interval", RIP_INSTANCE
);
2664 rip
->update_time
= yang_get_default_uint32("%s/timers/update-interval",
2667 yang_get_default_enum("%s/version/send", RIP_INSTANCE
);
2669 yang_get_default_enum("%s/version/receive", RIP_INSTANCE
);
2671 /* Initialize RIP data structures. */
2672 rip
->table
= route_table_init();
2673 route_table_set_info(rip
->table
, rip
);
2674 rip
->neighbor
= route_table_init();
2675 rip
->peer_list
= list_new();
2676 rip
->peer_list
->cmp
= (int (*)(void *, void *))rip_peer_list_cmp
;
2677 rip
->peer_list
->del
= rip_peer_list_del
;
2678 rip
->distance_table
= route_table_init();
2679 rip
->distance_table
->cleanup
= rip_distance_table_node_cleanup
;
2680 rip
->enable_interface
= vector_init(1);
2681 rip
->enable_network
= route_table_init();
2682 rip
->passive_nondefault
= vector_init(1);
2683 rip
->offset_list_master
= list_new();
2684 rip
->offset_list_master
->cmp
= (int (*)(void *, void *))offset_list_cmp
;
2685 rip
->offset_list_master
->del
= (void (*)(void *))offset_list_free
;
2687 /* Distribute list install. */
2688 rip
->distribute_ctx
= distribute_list_ctx_create(vrf
);
2689 distribute_list_add_hook(rip
->distribute_ctx
, rip_distribute_update
);
2690 distribute_list_delete_hook(rip
->distribute_ctx
, rip_distribute_update
);
2692 /* if rmap install. */
2693 rip
->if_rmap_ctx
= if_rmap_ctx_create(vrf_name
);
2694 if_rmap_hook_add(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2695 if_rmap_hook_delete(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2697 /* Make output stream. */
2698 rip
->obuf
= stream_new(1500);
2700 /* Enable the routing instance if possible. */
2701 if (vrf
&& vrf_is_enabled(vrf
))
2702 rip_instance_enable(rip
, vrf
, socket
);
2708 RB_INSERT(rip_instance_head
, &rip_instances
, rip
);
2713 /* Sned RIP request to the destination. */
2714 int rip_request_send(struct sockaddr_in
*to
, struct interface
*ifp
,
2715 uint8_t version
, struct connected
*connected
)
2718 struct rip_packet rip_packet
;
2719 struct listnode
*node
, *nnode
;
2721 memset(&rip_packet
, 0, sizeof(rip_packet
));
2723 rip_packet
.command
= RIP_REQUEST
;
2724 rip_packet
.version
= version
;
2725 rte
= rip_packet
.rte
;
2726 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
2730 * connected is only sent for ripv1 case, or when
2731 * interface does not support multicast. Caller loops
2732 * over each connected address for this case.
2734 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2736 != sizeof(rip_packet
))
2739 return sizeof(rip_packet
);
2742 /* send request on each connected network */
2743 for (ALL_LIST_ELEMENTS(ifp
->connected
, node
, nnode
, connected
)) {
2744 struct prefix_ipv4
*p
;
2746 p
= (struct prefix_ipv4
*)connected
->address
;
2748 if (p
->family
!= AF_INET
)
2751 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2753 != sizeof(rip_packet
))
2756 return sizeof(rip_packet
);
2759 static int rip_update_jitter(unsigned long time
)
2761 #define JITTER_BOUND 4
2762 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2763 Given that, we cannot let time be less than JITTER_BOUND seconds.
2764 The RIPv2 RFC says jitter should be small compared to
2765 update_time. We consider 1/JITTER_BOUND to be small.
2768 int jitter_input
= time
;
2771 if (jitter_input
< JITTER_BOUND
)
2772 jitter_input
= JITTER_BOUND
;
2774 jitter
= (((frr_weak_random() % ((jitter_input
* 2) + 1))
2777 return jitter
/ JITTER_BOUND
;
2780 void rip_event(struct rip
*rip
, enum rip_event event
, int sock
)
2786 thread_add_read(master
, rip_read
, rip
, sock
, &rip
->t_read
);
2788 case RIP_UPDATE_EVENT
:
2789 THREAD_OFF(rip
->t_update
);
2790 jitter
= rip_update_jitter(rip
->update_time
);
2791 thread_add_timer(master
, rip_update
, rip
,
2792 sock
? 2 : rip
->update_time
+ jitter
,
2795 case RIP_TRIGGERED_UPDATE
:
2796 if (rip
->t_triggered_interval
)
2799 thread_add_event(master
, rip_triggered_update
, rip
, 0,
2800 &rip
->t_triggered_update
);
2807 struct rip_distance
*rip_distance_new(void)
2809 return XCALLOC(MTYPE_RIP_DISTANCE
, sizeof(struct rip_distance
));
2812 void rip_distance_free(struct rip_distance
*rdistance
)
2814 if (rdistance
->access_list
)
2815 free(rdistance
->access_list
);
2816 XFREE(MTYPE_RIP_DISTANCE
, rdistance
);
2819 static void rip_distance_table_node_cleanup(struct route_table
*table
,
2820 struct route_node
*node
)
2822 struct rip_distance
*rdistance
;
2824 rdistance
= node
->info
;
2826 rip_distance_free(rdistance
);
2829 /* Apply RIP information to distance method. */
2830 uint8_t rip_distance_apply(struct rip
*rip
, struct rip_info
*rinfo
)
2832 struct route_node
*rn
;
2833 struct prefix_ipv4 p
;
2834 struct rip_distance
*rdistance
;
2835 struct access_list
*alist
;
2837 memset(&p
, 0, sizeof(p
));
2839 p
.prefix
= rinfo
->from
;
2840 p
.prefixlen
= IPV4_MAX_BITLEN
;
2842 /* Check source address. */
2843 rn
= route_node_match(rip
->distance_table
, (struct prefix
*)&p
);
2845 rdistance
= rn
->info
;
2846 route_unlock_node(rn
);
2848 if (rdistance
->access_list
) {
2849 alist
= access_list_lookup(AFI_IP
,
2850 rdistance
->access_list
);
2853 if (access_list_apply(alist
, &rinfo
->rp
->p
)
2857 return rdistance
->distance
;
2859 return rdistance
->distance
;
2863 return rip
->distance
;
2868 static void rip_distance_show(struct vty
*vty
, struct rip
*rip
)
2870 struct route_node
*rn
;
2871 struct rip_distance
*rdistance
;
2875 vty_out(vty
, " Distance: (default is %u)\n",
2876 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
2878 for (rn
= route_top(rip
->distance_table
); rn
; rn
= route_next(rn
)) {
2879 rdistance
= rn
->info
;
2881 if (rdistance
== NULL
)
2885 vty_out(vty
, " Address Distance List\n");
2888 snprintfrr(buf
, sizeof(buf
), "%pFX", &rn
->p
);
2889 vty_out(vty
, " %-20s %4d %s\n", buf
, rdistance
->distance
,
2890 rdistance
->access_list
? rdistance
->access_list
: "");
2894 /* Update ECMP routes to zebra when ECMP is disabled. */
2895 void rip_ecmp_disable(struct rip
*rip
)
2897 struct route_node
*rp
;
2898 struct rip_info
*rinfo
, *tmp_rinfo
;
2900 struct listnode
*node
, *nextnode
;
2902 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2907 if (listcount(list
) == 0)
2910 rinfo
= listgetdata(listhead(list
));
2911 if (!rip_route_rte(rinfo
))
2914 /* Drop all other entries, except the first one. */
2915 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
2916 if (tmp_rinfo
== rinfo
)
2919 THREAD_OFF(tmp_rinfo
->t_timeout
);
2920 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
2921 list_delete_node(list
, node
);
2922 rip_info_free(tmp_rinfo
);
2926 rip_zebra_ipv4_add(rip
, rp
);
2928 /* Set the route change flag. */
2929 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2931 /* Signal the output process to trigger an update. */
2932 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2936 /* Print out routes update time. */
2937 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
2942 char timebuf
[TIME_BUF
];
2943 struct thread
*thread
;
2945 if ((thread
= rinfo
->t_timeout
) != NULL
) {
2946 clock
= thread_timer_remain_second(thread
);
2947 gmtime_r(&clock
, &tm
);
2948 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2949 vty_out(vty
, "%5s", timebuf
);
2950 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
2951 clock
= thread_timer_remain_second(thread
);
2952 gmtime_r(&clock
, &tm
);
2953 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2954 vty_out(vty
, "%5s", timebuf
);
2958 static const char *rip_route_type_print(int sub_type
)
2963 case RIP_ROUTE_STATIC
:
2965 case RIP_ROUTE_DEFAULT
:
2967 case RIP_ROUTE_REDISTRIBUTE
:
2969 case RIP_ROUTE_INTERFACE
:
2978 "show ip rip [vrf NAME]",
2985 struct route_node
*np
;
2986 struct rip_info
*rinfo
= NULL
;
2987 struct list
*list
= NULL
;
2988 struct listnode
*listnode
= NULL
;
2989 const char *vrf_name
;
2992 if (argv_find(argv
, argc
, "vrf", &idx
))
2993 vrf_name
= argv
[idx
+ 1]->arg
;
2995 vrf_name
= VRF_DEFAULT_NAME
;
2997 rip
= rip_lookup_by_vrf_name(vrf_name
);
2999 vty_out(vty
, "%% RIP instance not found\n");
3002 if (!rip
->enabled
) {
3003 vty_out(vty
, "%% RIP instance is disabled\n");
3008 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
3010 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
3011 " (i) - interface\n\n"
3012 " Network Next Hop Metric From Tag Time\n");
3014 for (np
= route_top(rip
->table
); np
; np
= route_next(np
)) {
3020 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3023 len
= vty_out(vty
, "%c(%s) %pFX",
3024 /* np->lock, For debugging. */
3025 zebra_route_char(rinfo
->type
),
3026 rip_route_type_print(rinfo
->sub_type
),
3032 vty_out(vty
, "%*s", len
, " ");
3034 switch (rinfo
->nh
.type
) {
3035 case NEXTHOP_TYPE_IPV4
:
3036 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3037 vty_out(vty
, "%-20pI4 %2d ",
3038 &rinfo
->nh
.gate
.ipv4
, rinfo
->metric
);
3040 case NEXTHOP_TYPE_IFINDEX
:
3041 vty_out(vty
, "0.0.0.0 %2d ",
3044 case NEXTHOP_TYPE_BLACKHOLE
:
3045 vty_out(vty
, "blackhole %2d ",
3048 case NEXTHOP_TYPE_IPV6
:
3049 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3050 vty_out(vty
, "V6 Address Hidden %2d ",
3055 /* Route which exist in kernel routing table. */
3056 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3057 (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3058 vty_out(vty
, "%-15pI4 ", &rinfo
->from
);
3059 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3060 (route_tag_t
)rinfo
->tag
);
3061 rip_vty_out_uptime(vty
, rinfo
);
3062 } else if (rinfo
->metric
== RIP_METRIC_INFINITY
) {
3063 vty_out(vty
, "self ");
3064 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3065 (route_tag_t
)rinfo
->tag
);
3066 rip_vty_out_uptime(vty
, rinfo
);
3068 if (rinfo
->external_metric
) {
3070 vty
, "self (%s:%d)",
3071 zebra_route_string(rinfo
->type
),
3072 rinfo
->external_metric
);
3075 vty_out(vty
, "%*s", len
, " ");
3077 vty_out(vty
, "self ");
3078 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3079 (route_tag_t
)rinfo
->tag
);
3088 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3089 DEFUN (show_ip_rip_status
,
3090 show_ip_rip_status_cmd
,
3091 "show ip rip [vrf NAME] status",
3096 "IP routing protocol process parameters and statistics\n")
3099 struct interface
*ifp
;
3100 struct rip_interface
*ri
;
3101 extern const struct message ri_version_msg
[];
3102 const char *send_version
;
3103 const char *receive_version
;
3104 const char *vrf_name
;
3107 if (argv_find(argv
, argc
, "vrf", &idx
))
3108 vrf_name
= argv
[idx
+ 1]->arg
;
3110 vrf_name
= VRF_DEFAULT_NAME
;
3112 rip
= rip_lookup_by_vrf_name(vrf_name
);
3114 vty_out(vty
, "%% RIP instance not found\n");
3117 if (!rip
->enabled
) {
3118 vty_out(vty
, "%% RIP instance is disabled\n");
3122 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3123 vty_out(vty
, " Sending updates every %u seconds with +/-50%%,",
3125 vty_out(vty
, " next due in %lu seconds\n",
3126 thread_timer_remain_second(rip
->t_update
));
3127 vty_out(vty
, " Timeout after %u seconds,", rip
->timeout_time
);
3128 vty_out(vty
, " garbage collect after %u seconds\n", rip
->garbage_time
);
3130 /* Filtering status show. */
3131 config_show_distribute(vty
, rip
->distribute_ctx
);
3133 /* Default metric information. */
3134 vty_out(vty
, " Default redistribution metric is %u\n",
3135 rip
->default_metric
);
3137 /* Redistribute information. */
3138 vty_out(vty
, " Redistributing:");
3139 rip_show_redistribute_config(vty
, rip
);
3142 vty_out(vty
, " Default version control: send version %s,",
3143 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3144 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3145 vty_out(vty
, " receive any version \n");
3147 vty_out(vty
, " receive version %s \n",
3148 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3150 vty_out(vty
, " Interface Send Recv Key-chain\n");
3152 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3158 if (ri
->enable_network
|| ri
->enable_interface
) {
3159 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3161 lookup_msg(ri_version_msg
,
3162 rip
->version_send
, NULL
);
3164 send_version
= lookup_msg(ri_version_msg
,
3167 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3169 lookup_msg(ri_version_msg
,
3170 rip
->version_recv
, NULL
);
3172 receive_version
= lookup_msg(
3173 ri_version_msg
, ri
->ri_receive
, NULL
);
3175 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3176 send_version
, receive_version
,
3177 ri
->key_chain
? ri
->key_chain
: "");
3181 vty_out(vty
, " Routing for Networks:\n");
3182 rip_show_network_config(vty
, rip
);
3184 int found_passive
= 0;
3185 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3188 if ((ri
->enable_network
|| ri
->enable_interface
) &&
3190 if (!found_passive
) {
3191 vty_out(vty
, " Passive Interface(s):\n");
3194 vty_out(vty
, " %s\n", ifp
->name
);
3198 vty_out(vty
, " Routing Information Sources:\n");
3200 " Gateway BadPackets BadRoutes Distance Last Update\n");
3201 rip_peer_display(vty
, rip
);
3203 rip_distance_show(vty
, rip
);
3208 /* RIP configuration write function. */
3209 static int config_write_rip(struct vty
*vty
)
3214 RB_FOREACH(rip
, rip_instance_head
, &rip_instances
) {
3215 char xpath
[XPATH_MAXLEN
];
3216 struct lyd_node
*dnode
;
3218 snprintf(xpath
, sizeof(xpath
),
3219 "/frr-ripd:ripd/instance[vrf='%s']", rip
->vrf_name
);
3221 dnode
= yang_dnode_get(running_config
->dnode
, xpath
);
3224 nb_cli_show_dnode_cmds(vty
, dnode
, false);
3226 /* Distribute configuration. */
3227 config_write_distribute(vty
, rip
->distribute_ctx
);
3229 /* Interface routemap configuration */
3230 config_write_if_rmap(vty
, rip
->if_rmap_ctx
);
3232 vty_out(vty
, "exit\n");
3240 static int config_write_rip(struct vty
*vty
);
3241 /* RIP node structure. */
3242 static struct cmd_node rip_node
= {
3245 .parent_node
= CONFIG_NODE
,
3246 .prompt
= "%s(config-router)# ",
3247 .config_write
= config_write_rip
,
3250 /* Distribute-list update functions. */
3251 static void rip_distribute_update(struct distribute_ctx
*ctx
,
3252 struct distribute
*dist
)
3254 struct interface
*ifp
;
3255 struct rip_interface
*ri
;
3256 struct access_list
*alist
;
3257 struct prefix_list
*plist
;
3259 if (!ctx
->vrf
|| !dist
->ifname
)
3262 ifp
= if_lookup_by_name(dist
->ifname
, ctx
->vrf
->vrf_id
);
3268 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3269 alist
= access_list_lookup(AFI_IP
,
3270 dist
->list
[DISTRIBUTE_V4_IN
]);
3272 ri
->list
[RIP_FILTER_IN
] = alist
;
3274 ri
->list
[RIP_FILTER_IN
] = NULL
;
3276 ri
->list
[RIP_FILTER_IN
] = NULL
;
3278 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3279 alist
= access_list_lookup(AFI_IP
,
3280 dist
->list
[DISTRIBUTE_V4_OUT
]);
3282 ri
->list
[RIP_FILTER_OUT
] = alist
;
3284 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3286 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3288 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3289 plist
= prefix_list_lookup(AFI_IP
,
3290 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3292 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3294 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3296 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3298 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3299 plist
= prefix_list_lookup(AFI_IP
,
3300 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3302 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3304 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3306 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3309 void rip_distribute_update_interface(struct interface
*ifp
)
3311 struct rip_interface
*ri
= ifp
->info
;
3312 struct rip
*rip
= ri
->rip
;
3313 struct distribute
*dist
;
3317 dist
= distribute_lookup(rip
->distribute_ctx
, ifp
->name
);
3319 rip_distribute_update(rip
->distribute_ctx
, dist
);
3322 /* Update all interface's distribute list. */
3324 static void rip_distribute_update_all(struct prefix_list
*notused
)
3326 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3327 struct interface
*ifp
;
3329 FOR_ALL_INTERFACES (vrf
, ifp
)
3330 rip_distribute_update_interface(ifp
);
3333 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3335 rip_distribute_update_all(NULL
);
3338 /* Delete all added rip route. */
3339 void rip_clean(struct rip
*rip
)
3341 rip_interfaces_clean(rip
);
3344 rip_instance_disable(rip
);
3346 stream_free(rip
->obuf
);
3348 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3349 if (rip
->redist
[i
].route_map
.name
)
3350 free(rip
->redist
[i
].route_map
.name
);
3352 route_table_finish(rip
->table
);
3353 route_table_finish(rip
->neighbor
);
3354 list_delete(&rip
->peer_list
);
3355 distribute_list_delete(&rip
->distribute_ctx
);
3356 if_rmap_ctx_delete(rip
->if_rmap_ctx
);
3358 rip_clean_network(rip
);
3359 rip_passive_nondefault_clean(rip
);
3360 vector_free(rip
->enable_interface
);
3361 route_table_finish(rip
->enable_network
);
3362 vector_free(rip
->passive_nondefault
);
3363 list_delete(&rip
->offset_list_master
);
3364 route_table_finish(rip
->distance_table
);
3366 RB_REMOVE(rip_instance_head
, &rip_instances
, rip
);
3367 XFREE(MTYPE_RIP_VRF_NAME
, rip
->vrf_name
);
3368 XFREE(MTYPE_RIP
, rip
);
3371 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
3372 struct if_rmap
*if_rmap
)
3374 struct interface
*ifp
= NULL
;
3375 struct rip_interface
*ri
;
3376 struct route_map
*rmap
;
3377 struct vrf
*vrf
= NULL
;
3380 vrf
= vrf_lookup_by_name(ctx
->name
);
3382 ifp
= if_lookup_by_name(if_rmap
->ifname
, vrf
->vrf_id
);
3387 if (if_rmap
->routemap
[IF_RMAP_IN
]) {
3388 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_IN
]);
3390 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3392 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3394 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3396 if (if_rmap
->routemap
[IF_RMAP_OUT
]) {
3397 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_OUT
]);
3399 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3401 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3403 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3406 void rip_if_rmap_update_interface(struct interface
*ifp
)
3408 struct rip_interface
*ri
= ifp
->info
;
3409 struct rip
*rip
= ri
->rip
;
3410 struct if_rmap
*if_rmap
;
3411 struct if_rmap_ctx
*ctx
;
3415 ctx
= rip
->if_rmap_ctx
;
3418 if_rmap
= if_rmap_lookup(ctx
, ifp
->name
);
3420 rip_if_rmap_update(ctx
, if_rmap
);
3423 static void rip_routemap_update_redistribute(struct rip
*rip
)
3425 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3426 if (rip
->redist
[i
].route_map
.name
) {
3427 rip
->redist
[i
].route_map
.map
= route_map_lookup_by_name(
3428 rip
->redist
[i
].route_map
.name
);
3429 route_map_counter_increment(
3430 rip
->redist
[i
].route_map
.map
);
3436 static void rip_routemap_update(const char *notused
)
3438 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3440 struct interface
*ifp
;
3442 FOR_ALL_INTERFACES (vrf
, ifp
)
3443 rip_if_rmap_update_interface(ifp
);
3447 rip_routemap_update_redistribute(rip
);
3450 /* Link RIP instance to VRF. */
3451 static void rip_vrf_link(struct rip
*rip
, struct vrf
*vrf
)
3453 struct interface
*ifp
;
3456 rip
->distribute_ctx
->vrf
= vrf
;
3459 FOR_ALL_INTERFACES (vrf
, ifp
)
3460 rip_interface_sync(ifp
);
3463 /* Unlink RIP instance from VRF. */
3464 static void rip_vrf_unlink(struct rip
*rip
, struct vrf
*vrf
)
3466 struct interface
*ifp
;
3469 rip
->distribute_ctx
->vrf
= NULL
;
3472 FOR_ALL_INTERFACES (vrf
, ifp
)
3473 rip_interface_sync(ifp
);
3476 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
)
3480 rip_vrf_link(rip
, vrf
);
3481 rip
->enabled
= true;
3483 /* Resend all redistribute requests. */
3484 rip_redistribute_enable(rip
);
3486 /* Create read and timer thread. */
3487 rip_event(rip
, RIP_READ
, rip
->sock
);
3488 rip_event(rip
, RIP_UPDATE_EVENT
, 1);
3490 rip_zebra_vrf_register(vrf
);
3493 static void rip_instance_disable(struct rip
*rip
)
3495 struct vrf
*vrf
= rip
->vrf
;
3496 struct route_node
*rp
;
3498 /* Clear RIP routes */
3499 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
3500 struct rip_info
*rinfo
;
3502 struct listnode
*listnode
;
3504 if ((list
= rp
->info
) == NULL
)
3507 rinfo
= listgetdata(listhead(list
));
3508 if (rip_route_rte(rinfo
))
3509 rip_zebra_ipv4_delete(rip
, rp
);
3511 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3512 THREAD_OFF(rinfo
->t_timeout
);
3513 THREAD_OFF(rinfo
->t_garbage_collect
);
3514 rip_info_free(rinfo
);
3518 route_unlock_node(rp
);
3521 /* Flush all redistribute requests. */
3522 rip_redistribute_disable(rip
);
3524 /* Cancel RIP related timers. */
3525 THREAD_OFF(rip
->t_update
);
3526 THREAD_OFF(rip
->t_triggered_update
);
3527 THREAD_OFF(rip
->t_triggered_interval
);
3529 /* Cancel read thread. */
3530 THREAD_OFF(rip
->t_read
);
3532 /* Close RIP socket. */
3536 /* Clear existing peers. */
3537 list_delete_all_node(rip
->peer_list
);
3539 rip_zebra_vrf_deregister(vrf
);
3541 rip_vrf_unlink(rip
, vrf
);
3542 rip
->enabled
= false;
3545 static int rip_vrf_new(struct vrf
*vrf
)
3547 if (IS_RIP_DEBUG_EVENT
)
3548 zlog_debug("%s: VRF created: %s(%u)", __func__
, vrf
->name
,
3554 static int rip_vrf_delete(struct vrf
*vrf
)
3556 if (IS_RIP_DEBUG_EVENT
)
3557 zlog_debug("%s: VRF deleted: %s(%u)", __func__
, vrf
->name
,
3563 static int rip_vrf_enable(struct vrf
*vrf
)
3568 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3569 if (!rip
|| rip
->enabled
)
3572 if (IS_RIP_DEBUG_EVENT
)
3573 zlog_debug("%s: VRF %s(%u) enabled", __func__
, vrf
->name
,
3576 /* Activate the VRF RIP instance. */
3577 if (!rip
->enabled
) {
3578 socket
= rip_create_socket(vrf
);
3582 rip_instance_enable(rip
, vrf
, socket
);
3588 static int rip_vrf_disable(struct vrf
*vrf
)
3592 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3593 if (!rip
|| !rip
->enabled
)
3596 if (IS_RIP_DEBUG_EVENT
)
3597 zlog_debug("%s: VRF %s(%u) disabled", __func__
, vrf
->name
,
3600 /* Deactivate the VRF RIP instance. */
3602 rip_instance_disable(rip
);
3607 void rip_vrf_init(void)
3609 vrf_init(rip_vrf_new
, rip_vrf_enable
, rip_vrf_disable
, rip_vrf_delete
);
3614 void rip_vrf_terminate(void)
3619 /* Allocate new rip structure and set default value. */
3622 /* Install top nodes. */
3623 install_node(&rip_node
);
3625 /* Install rip commands. */
3626 install_element(VIEW_NODE
, &show_ip_rip_cmd
);
3627 install_element(VIEW_NODE
, &show_ip_rip_status_cmd
);
3629 install_default(RIP_NODE
);
3631 /* Debug related init. */
3634 /* Access list install. */
3636 access_list_add_hook(rip_distribute_update_all_wrapper
);
3637 access_list_delete_hook(rip_distribute_update_all_wrapper
);
3639 /* Prefix list initialize.*/
3641 prefix_list_add_hook(rip_distribute_update_all
);
3642 prefix_list_delete_hook(rip_distribute_update_all
);
3645 rip_route_map_init();
3647 route_map_add_hook(rip_routemap_update
);
3648 route_map_delete_hook(rip_routemap_update
);
3650 if_rmap_init(RIP_NODE
);