1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* RIP version 1 and 2.
3 * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
4 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro <kunihiro@zebra.org>
19 #include "sockunion.h"
24 #include "distribute.h"
25 #ifdef CRYPTO_INTERNAL
30 #include "lib_errors.h"
31 #include "northbound_cli.h"
33 #include "lib/printfrr.h"
35 #include "ripd/ripd.h"
36 #include "ripd/rip_nb.h"
37 #include "ripd/rip_debug.h"
38 #include "ripd/rip_errors.h"
39 #include "ripd/rip_interface.h"
41 /* UDP receive buffer size */
42 #define RIP_UDP_RCV_BUF 41600
44 DEFINE_MGROUP(RIPD
, "ripd");
45 DEFINE_MTYPE_STATIC(RIPD
, RIP
, "RIP structure");
46 DEFINE_MTYPE_STATIC(RIPD
, RIP_VRF_NAME
, "RIP VRF name");
47 DEFINE_MTYPE_STATIC(RIPD
, RIP_INFO
, "RIP route info");
48 DEFINE_MTYPE_STATIC(RIPD
, RIP_DISTANCE
, "RIP distance");
51 static void rip_output_process(struct connected
*, struct sockaddr_in
*, int,
53 static void rip_triggered_update(struct event
*);
54 static int rip_update_jitter(unsigned long);
55 static void rip_distance_table_node_cleanup(struct route_table
*table
,
56 struct route_node
*node
);
57 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
);
58 static void rip_instance_disable(struct rip
*rip
);
60 static void rip_distribute_update(struct distribute_ctx
*ctx
,
61 struct distribute
*dist
);
63 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
64 struct if_rmap
*if_rmap
);
66 /* RIP output routes type. */
67 enum { rip_all_route
, rip_changed_route
};
69 /* RIP command strings. */
70 static const struct message rip_msg
[] = {{RIP_REQUEST
, "REQUEST"},
71 {RIP_RESPONSE
, "RESPONSE"},
72 {RIP_TRACEON
, "TRACEON"},
73 {RIP_TRACEOFF
, "TRACEOFF"},
75 {RIP_POLL_ENTRY
, "POLL ENTRY"},
78 /* Generate rb-tree of RIP instances. */
79 static inline int rip_instance_compare(const struct rip
*a
, const struct rip
*b
)
81 return strcmp(a
->vrf_name
, b
->vrf_name
);
83 RB_GENERATE(rip_instance_head
, rip
, entry
, rip_instance_compare
)
85 struct rip_instance_head rip_instances
= RB_INITIALIZER(&rip_instances
);
87 /* Utility function to set broadcast option to the socket. */
88 static int sockopt_broadcast(int sock
)
93 ret
= setsockopt(sock
, SOL_SOCKET
, SO_BROADCAST
, (char *)&on
,
96 zlog_warn("can't set sockopt SO_BROADCAST to socket %d", sock
);
102 int rip_route_rte(struct rip_info
*rinfo
)
104 return (rinfo
->type
== ZEBRA_ROUTE_RIP
105 && rinfo
->sub_type
== RIP_ROUTE_RTE
);
108 static struct rip_info
*rip_info_new(void)
110 return XCALLOC(MTYPE_RIP_INFO
, sizeof(struct rip_info
));
113 void rip_info_free(struct rip_info
*rinfo
)
115 XFREE(MTYPE_RIP_INFO
, rinfo
);
118 struct rip
*rip_info_get_instance(const struct rip_info
*rinfo
)
120 return route_table_get_info(rinfo
->rp
->table
);
123 /* RIP route garbage collect timer. */
124 static void rip_garbage_collect(struct event
*t
)
126 struct rip_info
*rinfo
;
127 struct route_node
*rp
;
129 rinfo
= THREAD_ARG(t
);
131 /* Off timeout timer. */
132 THREAD_OFF(rinfo
->t_timeout
);
134 /* Get route_node pointer. */
137 /* Unlock route_node. */
138 listnode_delete(rp
->info
, rinfo
);
139 if (list_isempty((struct list
*)rp
->info
)) {
140 list_delete((struct list
**)&rp
->info
);
141 route_unlock_node(rp
);
144 /* Free RIP routing information. */
145 rip_info_free(rinfo
);
148 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
);
150 /* Add new route to the ECMP list.
151 * RETURN: the new entry added in the list, or NULL if it is not the first
152 * entry and ECMP is not allowed.
154 struct rip_info
*rip_ecmp_add(struct rip
*rip
, struct rip_info
*rinfo_new
)
156 struct route_node
*rp
= rinfo_new
->rp
;
157 struct rip_info
*rinfo
= NULL
;
158 struct list
*list
= NULL
;
160 if (rp
->info
== NULL
)
161 rp
->info
= list_new();
162 list
= (struct list
*)rp
->info
;
164 /* If ECMP is not allowed and some entry already exists in the list,
166 if (listcount(list
) && !rip
->ecmp
)
169 rinfo
= rip_info_new();
170 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
171 listnode_add(list
, rinfo
);
173 if (rip_route_rte(rinfo
)) {
174 rip_timeout_update(rip
, rinfo
);
175 rip_zebra_ipv4_add(rip
, rp
);
178 /* Set the route change flag on the first entry. */
179 rinfo
= listgetdata(listhead(list
));
180 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
182 /* Signal the output process to trigger an update (see section 2.5). */
183 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
188 /* Replace the ECMP list with the new route.
189 * RETURN: the new entry added in the list
191 struct rip_info
*rip_ecmp_replace(struct rip
*rip
, struct rip_info
*rinfo_new
)
193 struct route_node
*rp
= rinfo_new
->rp
;
194 struct list
*list
= (struct list
*)rp
->info
;
195 struct rip_info
*rinfo
= NULL
, *tmp_rinfo
= NULL
;
196 struct listnode
*node
= NULL
, *nextnode
= NULL
;
198 if (list
== NULL
|| listcount(list
) == 0)
199 return rip_ecmp_add(rip
, rinfo_new
);
201 /* Get the first entry */
202 rinfo
= listgetdata(listhead(list
));
204 /* Learnt route replaced by a local one. Delete it from zebra. */
205 if (rip_route_rte(rinfo
) && !rip_route_rte(rinfo_new
))
206 if (CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
207 rip_zebra_ipv4_delete(rip
, rp
);
209 /* Re-use the first entry, and delete the others. */
210 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
211 if (tmp_rinfo
== rinfo
)
214 THREAD_OFF(tmp_rinfo
->t_timeout
);
215 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
216 list_delete_node(list
, node
);
217 rip_info_free(tmp_rinfo
);
220 THREAD_OFF(rinfo
->t_timeout
);
221 THREAD_OFF(rinfo
->t_garbage_collect
);
222 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
224 if (rip_route_rte(rinfo
)) {
225 rip_timeout_update(rip
, rinfo
);
226 /* The ADD message implies an update. */
227 rip_zebra_ipv4_add(rip
, rp
);
230 /* Set the route change flag. */
231 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
233 /* Signal the output process to trigger an update (see section 2.5). */
234 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
239 /* Delete one route from the ECMP list.
241 * null - the entry is freed, and other entries exist in the list
242 * the entry - the entry is the last one in the list; its metric is set
243 * to INFINITY, and the garbage collector is started for it
245 struct rip_info
*rip_ecmp_delete(struct rip
*rip
, struct rip_info
*rinfo
)
247 struct route_node
*rp
= rinfo
->rp
;
248 struct list
*list
= (struct list
*)rp
->info
;
250 THREAD_OFF(rinfo
->t_timeout
);
252 if (listcount(list
) > 1) {
253 /* Some other ECMP entries still exist. Just delete this entry.
255 THREAD_OFF(rinfo
->t_garbage_collect
);
256 listnode_delete(list
, rinfo
);
257 if (rip_route_rte(rinfo
)
258 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
259 /* The ADD message implies the update. */
260 rip_zebra_ipv4_add(rip
, rp
);
261 rip_info_free(rinfo
);
264 assert(rinfo
== listgetdata(listhead(list
)));
266 /* This is the only entry left in the list. We must keep it in
267 * the list for garbage collection time, with INFINITY metric.
270 rinfo
->metric
= RIP_METRIC_INFINITY
;
271 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
274 if (rip_route_rte(rinfo
)
275 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
276 rip_zebra_ipv4_delete(rip
, rp
);
279 /* Set the route change flag on the first entry. */
280 rinfo
= listgetdata(listhead(list
));
281 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
283 /* Signal the output process to trigger an update (see section 2.5). */
284 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
289 /* Timeout RIP routes. */
290 static void rip_timeout(struct event
*t
)
292 struct rip_info
*rinfo
= THREAD_ARG(t
);
293 struct rip
*rip
= rip_info_get_instance(rinfo
);
295 rip_ecmp_delete(rip
, rinfo
);
298 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
)
300 if (rinfo
->metric
!= RIP_METRIC_INFINITY
) {
301 THREAD_OFF(rinfo
->t_timeout
);
302 event_add_timer(master
, rip_timeout
, rinfo
, rip
->timeout_time
,
307 static int rip_filter(int rip_distribute
, struct prefix_ipv4
*p
,
308 struct rip_interface
*ri
)
310 struct distribute
*dist
;
311 struct access_list
*alist
;
312 struct prefix_list
*plist
;
313 int distribute
= rip_distribute
== RIP_FILTER_OUT
? DISTRIBUTE_V4_OUT
315 const char *inout
= rip_distribute
== RIP_FILTER_OUT
? "out" : "in";
317 /* Input distribute-list filtering. */
318 if (ri
->list
[rip_distribute
] &&
319 access_list_apply(ri
->list
[rip_distribute
], (struct prefix
*)p
) ==
321 if (IS_RIP_DEBUG_PACKET
)
322 zlog_debug("%pFX filtered by distribute %s", p
, inout
);
326 if (ri
->prefix
[rip_distribute
] &&
327 prefix_list_apply(ri
->prefix
[rip_distribute
], (struct prefix
*)p
) ==
329 if (IS_RIP_DEBUG_PACKET
)
330 zlog_debug("%pFX filtered by prefix-list %s", p
, inout
);
334 /* All interface filter check. */
335 dist
= distribute_lookup(ri
->rip
->distribute_ctx
, NULL
);
339 if (dist
->list
[distribute
]) {
340 alist
= access_list_lookup(AFI_IP
, dist
->list
[distribute
]);
343 if (access_list_apply(alist
, (struct prefix
*)p
) ==
345 if (IS_RIP_DEBUG_PACKET
)
347 "%pFX filtered by distribute %s",
353 if (dist
->prefix
[distribute
]) {
354 plist
= prefix_list_lookup(AFI_IP
, dist
->prefix
[distribute
]);
357 if (prefix_list_apply(plist
, (struct prefix
*)p
) ==
359 if (IS_RIP_DEBUG_PACKET
)
361 "%pFX filtered by prefix-list %s",
371 /* Check nexthop address validity. */
372 static int rip_nexthop_check(struct rip
*rip
, struct in_addr
*addr
)
374 struct interface
*ifp
;
375 struct listnode
*cnode
;
376 struct connected
*ifc
;
379 /* If nexthop address matches local configured address then it is
382 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
383 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, cnode
, ifc
)) {
386 if (p
->family
== AF_INET
387 && IPV4_ADDR_SAME(&p
->u
.prefix4
, addr
))
394 /* RIP add route to routing table. */
395 static void rip_rte_process(struct rte
*rte
, struct sockaddr_in
*from
,
396 struct interface
*ifp
)
400 struct prefix_ipv4 p
;
401 struct route_node
*rp
;
402 struct rip_info
*rinfo
= NULL
, newinfo
;
403 struct rip_interface
*ri
;
404 struct in_addr
*nexthop
;
406 unsigned char old_dist
, new_dist
;
407 struct list
*list
= NULL
;
408 struct listnode
*node
= NULL
;
410 /* Make prefix structure. */
411 memset(&p
, 0, sizeof(struct prefix_ipv4
));
413 p
.prefix
= rte
->prefix
;
414 p
.prefixlen
= ip_masklen(rte
->mask
);
416 /* Make sure mask is applied. */
422 /* Apply input filters. */
423 ret
= rip_filter(RIP_FILTER_IN
, &p
, ri
);
427 memset(&newinfo
, 0, sizeof(newinfo
));
428 newinfo
.type
= ZEBRA_ROUTE_RIP
;
429 newinfo
.sub_type
= RIP_ROUTE_RTE
;
430 newinfo
.nh
.gate
.ipv4
= rte
->nexthop
;
431 newinfo
.from
= from
->sin_addr
;
432 newinfo
.nh
.ifindex
= ifp
->ifindex
;
433 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4_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
]) {
440 /* The object should be of the type of rip_info */
441 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_IN
],
442 (struct prefix
*)&p
, &newinfo
);
444 if (ret
== RMAP_DENYMATCH
) {
445 if (IS_RIP_DEBUG_PACKET
)
447 "RIP %pFX is filtered by route-map in",
452 /* Get back the object */
453 rte
->nexthop
= newinfo
.nexthop_out
;
454 rte
->tag
= htons(newinfo
.tag_out
); /* XXX */
455 rte
->metric
= newinfo
.metric_out
; /* XXX: the routemap uses the
459 /* Once the entry has been validated, update the metric by
460 adding the cost of the network on which the message
461 arrived. If the result is greater than infinity, use infinity
462 (RFC2453 Sec. 3.9.2) */
463 /* Zebra ripd can handle offset-list in. */
464 ret
= rip_offset_list_apply_in(&p
, ifp
, &rte
->metric
);
466 /* If offset-list does not modify the metric use interface's
469 rte
->metric
+= ifp
->metric
? ifp
->metric
: 1;
471 if (rte
->metric
> RIP_METRIC_INFINITY
)
472 rte
->metric
= RIP_METRIC_INFINITY
;
474 /* Set nexthop pointer. */
475 if (rte
->nexthop
.s_addr
== INADDR_ANY
)
476 nexthop
= &from
->sin_addr
;
478 nexthop
= &rte
->nexthop
;
480 /* Check if nexthop address is myself, then do nothing. */
481 if (rip_nexthop_check(rip
, nexthop
) < 0) {
482 if (IS_RIP_DEBUG_PACKET
)
483 zlog_debug("Nexthop address %pI4 is myself",
488 /* Get index for the prefix. */
489 rp
= route_node_get(rip
->table
, (struct prefix
*)&p
);
492 newinfo
.nh
.gate
.ipv4
= *nexthop
;
493 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4
;
494 newinfo
.metric
= rte
->metric
;
495 newinfo
.tag
= ntohs(rte
->tag
);
496 newinfo
.distance
= rip_distance_apply(rip
, &newinfo
);
498 new_dist
= newinfo
.distance
? newinfo
.distance
499 : ZEBRA_RIP_DISTANCE_DEFAULT
;
501 /* Check to see whether there is already RIP route on the table. */
502 if ((list
= rp
->info
) != NULL
)
503 for (ALL_LIST_ELEMENTS_RO(list
, node
, rinfo
)) {
504 /* Need to compare with redistributed entry or local
506 if (!rip_route_rte(rinfo
))
509 if (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
510 && IPV4_ADDR_SAME(&rinfo
->nh
.gate
.ipv4
, nexthop
))
513 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
? rinfo
->distance
534 : ZEBRA_RIP_DISTANCE_DEFAULT
;
536 if (new_dist
> old_dist
) {
537 /* New route has a greater distance.
539 route_unlock_node(rp
);
543 if (new_dist
< old_dist
)
544 /* New route has a smaller distance.
545 * Replace the ECMP list
546 * with the new one in below. */
549 /* Metrics and distances are both same. Keep
551 * the new route is added in the ECMP list in
556 /* Local static route. */
557 if (rinfo
->type
== ZEBRA_ROUTE_RIP
558 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
559 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))
560 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
561 route_unlock_node(rp
);
565 /* Redistributed route check. */
566 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
567 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
568 old_dist
= rinfo
->distance
;
569 /* Only routes directly connected to an interface
571 * may have a valid NULL distance */
572 if (rinfo
->nh
.gate
.ipv4
.s_addr
!= INADDR_ANY
)
575 : ZEBRA_RIP_DISTANCE_DEFAULT
;
576 /* If imported route does not have STRICT precedence,
577 mark it as a ghost */
578 if (new_dist
<= old_dist
579 && rte
->metric
!= RIP_METRIC_INFINITY
)
580 rip_ecmp_replace(rip
, &newinfo
);
582 route_unlock_node(rp
);
589 route_unlock_node(rp
);
591 /* Now, check to see whether there is already an explicit route
592 for the destination prefix. If there is no such route, add
593 this route to the routing table, unless the metric is
594 infinity (there is no point in adding a route which
596 if (rte
->metric
!= RIP_METRIC_INFINITY
)
597 rip_ecmp_add(rip
, &newinfo
);
599 /* Route is there but we are not sure the route is RIP or not.
602 /* If there is an existing route, compare the next hop address
603 to the address of the router from which the datagram came.
604 If this datagram is from the same router as the existing
605 route, reinitialize the timeout. */
606 same
= (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
607 && (rinfo
->nh
.ifindex
== ifp
->ifindex
));
609 old_dist
= rinfo
->distance
? rinfo
->distance
610 : ZEBRA_RIP_DISTANCE_DEFAULT
;
612 /* Next, compare the metrics. If the datagram is from the same
613 router as the existing route, and the new metric is different
614 than the old one; or, if the new metric is lower than the old
615 one, or if the tag has been changed; or if there is a route
616 with a lower administrave distance; or an update of the
617 distance on the actual route; do the following actions: */
618 if ((same
&& rinfo
->metric
!= rte
->metric
)
619 || (rte
->metric
< rinfo
->metric
)
620 || ((same
) && (rinfo
->metric
== rte
->metric
)
621 && (newinfo
.tag
!= rinfo
->tag
))
622 || (old_dist
> new_dist
)
623 || ((old_dist
!= new_dist
) && same
)) {
624 if (listcount(list
) == 1) {
625 if (newinfo
.metric
!= RIP_METRIC_INFINITY
)
626 rip_ecmp_replace(rip
, &newinfo
);
628 rip_ecmp_delete(rip
, rinfo
);
630 if (newinfo
.metric
< rinfo
->metric
)
631 rip_ecmp_replace(rip
, &newinfo
);
632 else if (newinfo
.metric
> rinfo
->metric
)
633 rip_ecmp_delete(rip
, rinfo
);
634 else if (new_dist
< old_dist
)
635 rip_ecmp_replace(rip
, &newinfo
);
636 else if (new_dist
> old_dist
)
637 rip_ecmp_delete(rip
, rinfo
);
639 int update
= CHECK_FLAG(rinfo
->flags
,
644 assert(newinfo
.metric
645 != RIP_METRIC_INFINITY
);
647 THREAD_OFF(rinfo
->t_timeout
);
648 THREAD_OFF(rinfo
->t_garbage_collect
);
649 memcpy(rinfo
, &newinfo
,
650 sizeof(struct rip_info
));
651 rip_timeout_update(rip
, rinfo
);
654 rip_zebra_ipv4_add(rip
, rp
);
656 /* - Set the route change flag on the
658 rinfo
= listgetdata(listhead(list
));
659 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
660 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
663 } else /* same & no change */
664 rip_timeout_update(rip
, rinfo
);
666 /* Unlock tempolary lock of the route. */
667 route_unlock_node(rp
);
671 /* Dump RIP packet */
672 static void rip_packet_dump(struct rip_packet
*packet
, int size
,
677 const char *command_str
;
681 /* Set command string. */
682 if (packet
->command
> 0 && packet
->command
< RIP_COMMAND_MAX
)
683 command_str
= lookup_msg(rip_msg
, packet
->command
, NULL
);
685 command_str
= "unknown";
687 /* Dump packet header. */
688 zlog_debug("%s %s version %d packet size %d", sndrcv
, command_str
,
689 packet
->version
, size
);
691 /* Dump each routing table entry. */
694 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
695 if (packet
->version
== RIPv2
) {
696 netmask
= ip_masklen(rte
->mask
);
698 if (rte
->family
== htons(RIP_FAMILY_AUTH
)) {
700 == htons(RIP_AUTH_SIMPLE_PASSWORD
)) {
701 p
= (uint8_t *)&rte
->prefix
;
704 " family 0x%X type %d auth string: %s",
707 } else if (rte
->tag
== htons(RIP_AUTH_MD5
)) {
708 struct rip_md5_info
*md5
;
710 md5
= (struct rip_md5_info
*)&packet
714 " family 0x%X type %d (MD5 authentication)",
718 " RIP-2 packet len %d Key ID %d Auth Data len %d",
719 ntohs(md5
->packet_len
),
720 md5
->keyid
, md5
->auth_len
);
721 zlog_debug(" Sequence Number %ld",
722 (unsigned long)ntohl(
724 } else if (rte
->tag
== htons(RIP_AUTH_DATA
)) {
725 p
= (uint8_t *)&rte
->prefix
;
728 " family 0x%X type %d (MD5 data)",
732 " MD5: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
733 p
[0], p
[1], p
[2], p
[3], p
[4],
734 p
[5], p
[6], p
[7], p
[8], p
[9],
735 p
[10], p
[11], p
[12], p
[13],
739 " family 0x%X type %d (Unknown auth type)",
745 " %pI4/%d -> %pI4 family %d tag %" ROUTE_TAG_PRI
747 &rte
->prefix
, netmask
, &rte
->nexthop
,
749 (route_tag_t
)ntohs(rte
->tag
),
750 (unsigned long)ntohl(rte
->metric
));
752 zlog_debug(" %pI4 family %d tag %" ROUTE_TAG_PRI
754 &rte
->prefix
, ntohs(rte
->family
),
755 (route_tag_t
)ntohs(rte
->tag
),
756 (unsigned long)ntohl(rte
->metric
));
761 /* Check if the destination address is valid (unicast; not net 0
762 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
763 check net 0 because we accept default route. */
764 static int rip_destination_check(struct in_addr addr
)
766 uint32_t destination
;
768 /* Convert to host byte order. */
769 destination
= ntohl(addr
.s_addr
);
771 if (IPV4_NET127(destination
))
774 /* Net 0 may match to the default route. */
775 if (IPV4_NET0(destination
) && destination
!= 0)
778 /* Unicast address must belong to class A, B, C. */
779 if (IN_CLASSA(destination
))
781 if (IN_CLASSB(destination
))
783 if (IN_CLASSC(destination
))
789 /* RIP version 2 authentication. */
790 static int rip_auth_simple_password(struct rte
*rte
, struct sockaddr_in
*from
,
791 struct interface
*ifp
)
793 struct rip_interface
*ri
;
794 char *auth_str
= (char *)rte
+ offsetof(struct rte
, prefix
);
797 /* reject passwords with zeros in the middle of the string */
798 for (i
= strnlen(auth_str
, 16); i
< 16; i
++) {
799 if (auth_str
[i
] != '\0')
803 if (IS_RIP_DEBUG_EVENT
)
804 zlog_debug("RIPv2 simple password authentication from %pI4",
809 if (ri
->auth_type
!= RIP_AUTH_SIMPLE_PASSWORD
810 || rte
->tag
!= htons(RIP_AUTH_SIMPLE_PASSWORD
))
813 /* Simple password authentication. */
815 if (strncmp(auth_str
, ri
->auth_str
, 16) == 0)
819 struct keychain
*keychain
;
822 keychain
= keychain_lookup(ri
->key_chain
);
823 if (keychain
== NULL
|| keychain
->key
== NULL
)
826 key
= key_match_for_accept(keychain
, auth_str
);
833 /* RIP version 2 authentication with MD5. */
834 static int rip_auth_md5(struct rip_packet
*packet
, struct sockaddr_in
*from
,
835 int length
, struct interface
*ifp
)
837 struct rip_interface
*ri
;
838 struct rip_md5_info
*md5
;
839 struct rip_md5_data
*md5data
;
840 struct keychain
*keychain
;
842 #ifdef CRYPTO_OPENSSL
844 #elif CRYPTO_INTERNAL
847 uint8_t digest
[RIP_AUTH_MD5_SIZE
];
849 char auth_str
[RIP_AUTH_MD5_SIZE
] = {};
851 if (IS_RIP_DEBUG_EVENT
)
852 zlog_debug("RIPv2 MD5 authentication from %pI4",
856 md5
= (struct rip_md5_info
*)&packet
->rte
;
858 /* Check auth type. */
859 if (ri
->auth_type
!= RIP_AUTH_MD5
|| md5
->type
!= htons(RIP_AUTH_MD5
))
862 /* If the authentication length is less than 16, then it must be wrong
864 * any interpretation of rfc2082. Some implementations also interpret
865 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka
866 * RIP_AUTH_MD5_COMPAT_SIZE.
868 if (!((md5
->auth_len
== RIP_AUTH_MD5_SIZE
)
869 || (md5
->auth_len
== RIP_AUTH_MD5_COMPAT_SIZE
))) {
870 if (IS_RIP_DEBUG_EVENT
)
872 "RIPv2 MD5 authentication, strange authentication length field %d",
877 /* grab and verify check packet length */
878 packet_len
= ntohs(md5
->packet_len
);
880 if (packet_len
> (length
- RIP_HEADER_SIZE
- RIP_AUTH_MD5_SIZE
)) {
881 if (IS_RIP_DEBUG_EVENT
)
883 "RIPv2 MD5 authentication, packet length field %d greater than received length %d!",
884 md5
->packet_len
, length
);
888 /* retrieve authentication data */
889 md5data
= (struct rip_md5_data
*)(((uint8_t *)packet
) + packet_len
);
892 keychain
= keychain_lookup(ri
->key_chain
);
893 if (keychain
== NULL
)
896 key
= key_lookup_for_accept(keychain
, md5
->keyid
);
897 if (key
== NULL
|| key
->string
== NULL
)
900 memcpy(auth_str
, key
->string
,
901 MIN(sizeof(auth_str
), strlen(key
->string
)));
902 } else if (ri
->auth_str
)
903 memcpy(auth_str
, ri
->auth_str
,
904 MIN(sizeof(auth_str
), strlen(ri
->auth_str
)));
906 if (auth_str
[0] == 0)
909 /* MD5 digest authentication. */
910 #ifdef CRYPTO_OPENSSL
911 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
912 ctx
= EVP_MD_CTX_new();
913 EVP_DigestInit(ctx
, EVP_md5());
914 EVP_DigestUpdate(ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
915 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
916 EVP_DigestFinal(ctx
, digest
, &md5_size
);
917 EVP_MD_CTX_free(ctx
);
918 #elif CRYPTO_INTERNAL
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
);
926 if (memcmp(md5data
->digest
, digest
, RIP_AUTH_MD5_SIZE
) == 0)
932 /* Pick correct auth string for sends, prepare auth_str buffer for use.
933 * (left justified and padded).
935 * presumes one of ri or key is valid, and that the auth strings they point
936 * to are nul terminated. If neither are present, auth_str will be fully
940 static void rip_auth_prepare_str_send(struct rip_interface
*ri
, struct key
*key
,
941 char *auth_str
, int len
)
945 memset(auth_str
, 0, len
);
946 if (key
&& key
->string
)
947 memcpy(auth_str
, key
->string
,
948 MIN((size_t)len
, strlen(key
->string
)));
949 else if (ri
->auth_str
)
950 memcpy(auth_str
, ri
->auth_str
,
951 MIN((size_t)len
, strlen(ri
->auth_str
)));
956 /* Write RIPv2 simple password authentication information
958 * auth_str is presumed to be 2 bytes and correctly prepared
959 * (left justified and zero padded).
961 static void rip_auth_simple_write(struct stream
*s
, char *auth_str
, int len
)
963 assert(s
&& len
== RIP_AUTH_SIMPLE_SIZE
);
965 stream_putw(s
, RIP_FAMILY_AUTH
);
966 stream_putw(s
, RIP_AUTH_SIMPLE_PASSWORD
);
967 stream_put(s
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
972 /* write RIPv2 MD5 "authentication header"
973 * (uses the auth key data field)
975 * Digest offset field is set to 0.
977 * returns: offset of the digest offset field, which must be set when
978 * length to the auth-data MD5 digest is known.
980 static size_t rip_auth_md5_ah_write(struct stream
*s
, struct rip_interface
*ri
,
984 static uint32_t seq
= 0;
986 assert(s
&& ri
&& ri
->auth_type
== RIP_AUTH_MD5
);
988 /* MD5 authentication. */
989 stream_putw(s
, RIP_FAMILY_AUTH
);
990 stream_putw(s
, RIP_AUTH_MD5
);
992 /* MD5 AH digest offset field.
994 * Set to placeholder value here, to true value when RIP-2 Packet length
995 * is known. Actual value is set in .....().
997 doff
= stream_get_endp(s
);
1002 stream_putc(s
, key
->index
% 256);
1006 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1007 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for
1009 * to be configurable.
1011 stream_putc(s
, ri
->md5_auth_len
);
1013 /* Sequence Number (non-decreasing). */
1014 /* RFC2080: The value used in the sequence number is
1015 arbitrary, but two suggestions are the time of the
1016 message's creation or a simple message counter. */
1017 stream_putl(s
, ++seq
);
1019 /* Reserved field must be zero. */
1026 /* If authentication is in used, write the appropriate header
1027 * returns stream offset to which length must later be written
1028 * or 0 if this is not required
1030 static size_t rip_auth_header_write(struct stream
*s
, struct rip_interface
*ri
,
1031 struct key
*key
, char *auth_str
, int len
)
1033 assert(ri
->auth_type
!= RIP_NO_AUTH
);
1035 switch (ri
->auth_type
) {
1036 case RIP_AUTH_SIMPLE_PASSWORD
:
1037 rip_auth_prepare_str_send(ri
, key
, auth_str
, len
);
1038 rip_auth_simple_write(s
, auth_str
, len
);
1041 return rip_auth_md5_ah_write(s
, ri
, key
);
1047 /* Write RIPv2 MD5 authentication data trailer */
1048 static void rip_auth_md5_set(struct stream
*s
, struct rip_interface
*ri
,
1049 size_t doff
, char *auth_str
, int authlen
)
1052 #ifdef CRYPTO_OPENSSL
1054 #elif CRYPTO_INTERNAL
1057 unsigned char digest
[RIP_AUTH_MD5_SIZE
];
1059 /* Make it sure this interface is configured as MD5
1061 assert((ri
->auth_type
== RIP_AUTH_MD5
)
1062 && (authlen
== RIP_AUTH_MD5_SIZE
));
1065 /* Get packet length. */
1066 len
= stream_get_endp(s
);
1068 /* Check packet length. */
1069 if (len
< (RIP_HEADER_SIZE
+ RIP_RTE_SIZE
)) {
1070 flog_err(EC_RIP_PACKET
,
1071 "%s: packet length %ld is less than minimum length.",
1076 /* Set the digest offset length in the header */
1077 stream_putw_at(s
, doff
, len
);
1079 /* Set authentication data. */
1080 stream_putw(s
, RIP_FAMILY_AUTH
);
1081 stream_putw(s
, RIP_AUTH_DATA
);
1083 /* Generate a digest for the RIP packet. */
1084 #ifdef CRYPTO_OPENSSL
1085 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
1086 ctx
= EVP_MD_CTX_new();
1087 EVP_DigestInit(ctx
, EVP_md5());
1088 EVP_DigestUpdate(ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1089 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1090 EVP_DigestFinal(ctx
, digest
, &md5_size
);
1091 EVP_MD_CTX_free(ctx
);
1092 #elif CRYPTO_INTERNAL
1093 memset(&ctx
, 0, sizeof(ctx
));
1095 MD5Update(&ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1096 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1097 MD5Final(digest
, &ctx
);
1100 /* Copy the digest to the packet. */
1101 stream_write(s
, digest
, RIP_AUTH_MD5_SIZE
);
1104 /* RIP routing information. */
1105 static void rip_response_process(struct rip_packet
*packet
, int size
,
1106 struct sockaddr_in
*from
,
1107 struct connected
*ifc
)
1109 struct rip_interface
*ri
= ifc
->ifp
->info
;
1110 struct rip
*rip
= ri
->rip
;
1113 struct prefix_ipv4 ifaddr
;
1114 struct prefix_ipv4 ifaddrclass
;
1117 memset(&ifaddr
, 0, sizeof(ifaddr
));
1118 /* We don't know yet. */
1121 /* The Response must be ignored if it is not from the RIP
1122 port. (RFC2453 - Sec. 3.9.2)*/
1123 if (from
->sin_port
!= htons(RIP_PORT_DEFAULT
)) {
1124 zlog_info("response doesn't come from RIP port: %d",
1126 rip_peer_bad_packet(rip
, from
);
1130 /* The datagram's IPv4 source address should be checked to see
1131 whether the datagram is from a valid neighbor; the source of the
1132 datagram must be on a directly connected network (RFC2453 - Sec.
1134 if (if_lookup_address((void *)&from
->sin_addr
, AF_INET
,
1138 "This datagram doesn't come from a valid neighbor: %pI4",
1140 rip_peer_bad_packet(rip
, from
);
1144 /* It is also worth checking to see whether the response is from one
1145 of the router's own addresses. */
1147 ; /* Alredy done in rip_read () */
1149 /* Update RIP peer. */
1150 rip_peer_update(rip
, from
, packet
->version
);
1152 /* Set RTE pointer. */
1155 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
1156 /* RIPv2 authentication check. */
1157 /* If the Address Family Identifier of the first (and only the
1158 first) entry in the message is 0xFFFF, then the remainder of
1159 the entry contains the authentication. */
1160 /* If the packet gets here it means authentication enabled */
1161 /* Check is done in rip_read(). So, just skipping it */
1162 if (packet
->version
== RIPv2
&& rte
== packet
->rte
1163 && rte
->family
== htons(RIP_FAMILY_AUTH
))
1166 if (rte
->family
!= htons(AF_INET
)) {
1167 /* Address family check. RIP only supports AF_INET. */
1168 zlog_info("Unsupported family %d from %pI4",
1174 /* - is the destination address valid (e.g., unicast; not net 0
1176 if (!rip_destination_check(rte
->prefix
)) {
1178 "Network is net 0 or net 127 or it is not unicast network");
1179 rip_peer_bad_route(rip
, from
);
1183 /* Convert metric value to host byte order. */
1184 rte
->metric
= ntohl(rte
->metric
);
1186 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1187 if (!(rte
->metric
>= 1 && rte
->metric
<= 16)) {
1188 zlog_info("Route's metric is not in the 1-16 range.");
1189 rip_peer_bad_route(rip
, from
);
1193 /* RIPv1 does not have nexthop value. */
1194 if (packet
->version
== RIPv1
1195 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1196 zlog_info("RIPv1 packet with nexthop value %pI4",
1198 rip_peer_bad_route(rip
, from
);
1202 /* That is, if the provided information is ignored, a possibly
1203 sub-optimal, but absolutely valid, route may be taken. If
1204 the received Next Hop is not directly reachable, it should be
1205 treated as 0.0.0.0. */
1206 if (packet
->version
== RIPv2
1207 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1210 /* Multicast address check. */
1211 addrval
= ntohl(rte
->nexthop
.s_addr
);
1212 if (IN_CLASSD(addrval
)) {
1214 "Nexthop %pI4 is multicast address, skip this rte",
1219 if (!if_lookup_address((void *)&rte
->nexthop
, AF_INET
,
1220 rip
->vrf
->vrf_id
)) {
1221 struct route_node
*rn
;
1222 struct rip_info
*rinfo
;
1224 rn
= route_node_match_ipv4(rip
->table
,
1230 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1233 if (IS_RIP_DEBUG_EVENT
)
1235 "Next hop %pI4 is on RIP network. Set nexthop to the packet's originator",
1237 rte
->nexthop
= rinfo
->from
;
1239 if (IS_RIP_DEBUG_EVENT
)
1241 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1243 rte
->nexthop
.s_addr
=
1247 route_unlock_node(rn
);
1249 if (IS_RIP_DEBUG_EVENT
)
1251 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1253 rte
->nexthop
.s_addr
= INADDR_ANY
;
1258 /* For RIPv1, there won't be a valid netmask.
1259 * This is a best guess at the masks. If everyone was using old
1260 * Ciscos before the 'ip subnet zero' option, it would be almost
1263 * Cisco summarize ripv1 advertisements to the classful boundary
1264 * (/16 for class B's) except when the RIP packet does to inside
1265 * the classful network in question.
1267 if ((packet
->version
== RIPv1
1268 && rte
->prefix
.s_addr
!= INADDR_ANY
)
1269 || (packet
->version
== RIPv2
1270 && (rte
->prefix
.s_addr
!= INADDR_ANY
1271 && rte
->mask
.s_addr
== INADDR_ANY
))) {
1272 uint32_t destination
;
1274 if (subnetted
== -1) {
1275 memcpy(&ifaddr
, ifc
->address
, sizeof(ifaddr
));
1276 memcpy(&ifaddrclass
, &ifaddr
,
1277 sizeof(ifaddrclass
));
1278 apply_classful_mask_ipv4(&ifaddrclass
);
1280 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1284 destination
= ntohl(rte
->prefix
.s_addr
);
1286 if (IN_CLASSA(destination
))
1287 masklen2ip(8, &rte
->mask
);
1288 else if (IN_CLASSB(destination
))
1289 masklen2ip(16, &rte
->mask
);
1290 else if (IN_CLASSC(destination
))
1291 masklen2ip(24, &rte
->mask
);
1294 masklen2ip(ifaddrclass
.prefixlen
,
1295 (struct in_addr
*)&destination
);
1296 if ((subnetted
== 1)
1297 && ((rte
->prefix
.s_addr
& destination
)
1298 == ifaddrclass
.prefix
.s_addr
)) {
1299 masklen2ip(ifaddr
.prefixlen
, &rte
->mask
);
1300 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1301 != rte
->prefix
.s_addr
)
1302 masklen2ip(32, &rte
->mask
);
1303 if (IS_RIP_DEBUG_EVENT
)
1304 zlog_debug("Subnetted route %pI4",
1307 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1308 != rte
->prefix
.s_addr
)
1312 if (IS_RIP_DEBUG_EVENT
) {
1313 zlog_debug("Resultant route %pI4",
1315 zlog_debug("Resultant mask %pI4",
1320 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1321 ignore the entry. */
1322 if ((packet
->version
== RIPv2
)
1323 && (rte
->mask
.s_addr
!= INADDR_ANY
)
1324 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1325 != rte
->prefix
.s_addr
)) {
1327 "RIPv2 address %pI4 is not mask /%d applied one",
1328 &rte
->prefix
, ip_masklen(rte
->mask
));
1329 rip_peer_bad_route(rip
, from
);
1333 /* Default route's netmask is ignored. */
1334 if (packet
->version
== RIPv2
1335 && (rte
->prefix
.s_addr
== INADDR_ANY
)
1336 && (rte
->mask
.s_addr
!= INADDR_ANY
)) {
1337 if (IS_RIP_DEBUG_EVENT
)
1339 "Default route with non-zero netmask. Set zero to netmask");
1340 rte
->mask
.s_addr
= INADDR_ANY
;
1343 /* Routing table updates. */
1344 rip_rte_process(rte
, from
, ifc
->ifp
);
1348 /* Make socket for RIP protocol. */
1349 int rip_create_socket(struct vrf
*vrf
)
1353 struct sockaddr_in addr
;
1354 const char *vrf_dev
= NULL
;
1356 memset(&addr
, 0, sizeof(struct sockaddr_in
));
1357 addr
.sin_family
= AF_INET
;
1358 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1359 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1360 addr
.sin_len
= sizeof(struct sockaddr_in
);
1361 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1362 /* sending port must always be the RIP port */
1363 addr
.sin_port
= htons(RIP_PORT_DEFAULT
);
1365 /* Make datagram socket. */
1366 if (vrf
->vrf_id
!= VRF_DEFAULT
)
1367 vrf_dev
= vrf
->name
;
1368 frr_with_privs(&ripd_privs
) {
1369 sock
= vrf_socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, vrf
->vrf_id
,
1372 flog_err_sys(EC_LIB_SOCKET
,
1373 "Cannot create UDP socket: %s",
1374 safe_strerror(errno
));
1379 sockopt_broadcast(sock
);
1380 sockopt_reuseaddr(sock
);
1381 sockopt_reuseport(sock
);
1382 setsockopt_ipv4_multicast_loop(sock
, 0);
1383 #ifdef IPTOS_PREC_INTERNETCONTROL
1384 setsockopt_ipv4_tos(sock
, IPTOS_PREC_INTERNETCONTROL
);
1386 setsockopt_so_recvbuf(sock
, RIP_UDP_RCV_BUF
);
1388 frr_with_privs(&ripd_privs
) {
1389 if ((ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
)))
1391 zlog_err("%s: Can't bind socket %d to %pI4 port %d: %s",
1392 __func__
, sock
, &addr
.sin_addr
,
1393 (int)ntohs(addr
.sin_port
),
1394 safe_strerror(errno
));
1404 /* RIP packet send to destination address, on interface denoted by
1405 * by connected argument. NULL to argument denotes destination should be
1406 * should be RIP multicast group
1408 static int rip_send_packet(uint8_t *buf
, int size
, struct sockaddr_in
*to
,
1409 struct connected
*ifc
)
1411 struct rip_interface
*ri
;
1414 struct sockaddr_in sin
;
1418 struct cmsghdr
*cmsgptr
;
1419 char adata
[256] = {};
1420 struct in_pktinfo
*pkt
;
1421 #endif /* GNU_LINUX */
1423 assert(ifc
!= NULL
);
1424 ri
= ifc
->ifp
->info
;
1427 if (IS_RIP_DEBUG_PACKET
) {
1428 #define ADDRESS_SIZE 20
1429 char dst
[ADDRESS_SIZE
];
1432 inet_ntop(AF_INET
, &to
->sin_addr
, dst
, sizeof(dst
));
1434 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1435 inet_ntop(AF_INET
, &sin
.sin_addr
, dst
, sizeof(dst
));
1438 zlog_debug("%s %pI4 > %s (%s)", __func__
,
1439 &ifc
->address
->u
.prefix4
, dst
, ifc
->ifp
->name
);
1442 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
)) {
1444 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1445 * configured with multiple addresses on the same
1446 * subnet: the first address on the subnet is configured
1447 * "primary", and all subsequent addresses on that subnet
1448 * are treated as "secondary" addresses. In order to avoid
1449 * routing-table bloat on other rip listeners, we do not send
1450 * out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
1451 * XXX Since Linux is the only system for which the
1452 * ZEBRA_IFA_SECONDARY flag is set, we would end up
1453 * sending a packet for a "secondary" source address on
1454 * non-linux systems.
1456 if (IS_RIP_DEBUG_PACKET
)
1457 zlog_debug("duplicate dropped");
1461 /* Make destination address. */
1462 memset(&sin
, 0, sizeof(sin
));
1463 sin
.sin_family
= AF_INET
;
1464 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1465 sin
.sin_len
= sizeof(struct sockaddr_in
);
1466 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1468 /* When destination is specified, use it's port and address. */
1470 sin
.sin_port
= to
->sin_port
;
1471 sin
.sin_addr
= to
->sin_addr
;
1473 sin
.sin_port
= htons(RIP_PORT_DEFAULT
);
1474 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1476 rip_interface_multicast_set(rip
->sock
, ifc
);
1479 memset(&msg
, 0, sizeof(msg
));
1480 msg
.msg_name
= (void *)&sin
;
1481 msg
.msg_namelen
= sizeof(struct sockaddr_in
);
1488 msg
.msg_control
= (void *)adata
;
1489 msg
.msg_controllen
= CMSG_SPACE(sizeof(struct in_pktinfo
));
1491 cmsgptr
= (struct cmsghdr
*)adata
;
1492 cmsgptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_pktinfo
));
1493 cmsgptr
->cmsg_level
= IPPROTO_IP
;
1494 cmsgptr
->cmsg_type
= IP_PKTINFO
;
1495 pkt
= (struct in_pktinfo
*)CMSG_DATA(cmsgptr
);
1496 pkt
->ipi_ifindex
= ifc
->ifp
->ifindex
;
1497 pkt
->ipi_spec_dst
.s_addr
= ifc
->address
->u
.prefix4
.s_addr
;
1498 #endif /* GNU_LINUX */
1500 ret
= sendmsg(rip
->sock
, &msg
, 0);
1502 if (IS_RIP_DEBUG_EVENT
)
1503 zlog_debug("SEND to %pI4%d", &sin
.sin_addr
,
1504 ntohs(sin
.sin_port
));
1507 zlog_warn("can't send packet : %s", safe_strerror(errno
));
1512 /* Add redistributed route to RIP table. */
1513 void rip_redistribute_add(struct rip
*rip
, int type
, int sub_type
,
1514 struct prefix_ipv4
*p
, struct nexthop
*nh
,
1515 unsigned int metric
, unsigned char distance
,
1519 struct route_node
*rp
= NULL
;
1520 struct rip_info
*rinfo
= NULL
, newinfo
;
1521 struct list
*list
= NULL
;
1523 /* Redistribute route */
1524 ret
= rip_destination_check(p
->prefix
);
1528 rp
= route_node_get(rip
->table
, (struct prefix
*)p
);
1530 memset(&newinfo
, 0, sizeof(newinfo
));
1531 newinfo
.type
= type
;
1532 newinfo
.sub_type
= sub_type
;
1534 newinfo
.external_metric
= metric
;
1535 newinfo
.distance
= distance
;
1536 if (tag
<= UINT16_MAX
) /* RIP only supports 16 bit tags */
1541 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
1542 rinfo
= listgetdata(listhead(list
));
1544 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1545 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1546 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
1547 route_unlock_node(rp
);
1551 /* Manually configured RIP route check. */
1552 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1553 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
1554 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))) {
1555 if (type
!= ZEBRA_ROUTE_RIP
1556 || ((sub_type
!= RIP_ROUTE_STATIC
)
1557 && (sub_type
!= RIP_ROUTE_DEFAULT
))) {
1558 route_unlock_node(rp
);
1563 (void)rip_ecmp_replace(rip
, &newinfo
);
1564 route_unlock_node(rp
);
1566 (void)rip_ecmp_add(rip
, &newinfo
);
1568 if (IS_RIP_DEBUG_EVENT
) {
1569 zlog_debug("Redistribute new prefix %pFX", p
);
1572 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1575 /* Delete redistributed route from RIP table. */
1576 void rip_redistribute_delete(struct rip
*rip
, int type
, int sub_type
,
1577 struct prefix_ipv4
*p
, ifindex_t ifindex
)
1580 struct route_node
*rp
;
1581 struct rip_info
*rinfo
;
1583 ret
= rip_destination_check(p
->prefix
);
1587 rp
= route_node_lookup(rip
->table
, (struct prefix
*)p
);
1589 struct list
*list
= rp
->info
;
1591 if (list
!= NULL
&& listcount(list
) != 0) {
1592 rinfo
= listgetdata(listhead(list
));
1593 if (rinfo
!= NULL
&& rinfo
->type
== type
1594 && rinfo
->sub_type
== sub_type
1595 && rinfo
->nh
.ifindex
== ifindex
) {
1596 /* Perform poisoned reverse. */
1597 rinfo
->metric
= RIP_METRIC_INFINITY
;
1598 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
1599 rip_garbage_collect
,
1601 THREAD_OFF(rinfo
->t_timeout
);
1602 rinfo
->flags
|= RIP_RTF_CHANGED
;
1604 if (IS_RIP_DEBUG_EVENT
)
1606 "Poison %pFX on the interface %s with an infinity metric [delete]",
1612 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1615 route_unlock_node(rp
);
1619 /* Response to request called from rip_read ().*/
1620 static void rip_request_process(struct rip_packet
*packet
, int size
,
1621 struct sockaddr_in
*from
, struct connected
*ifc
)
1626 struct prefix_ipv4 p
;
1627 struct route_node
*rp
;
1628 struct rip_info
*rinfo
;
1629 struct rip_interface
*ri
;
1631 /* Does not reponse to the requests on the loopback interfaces */
1632 if (if_is_loopback(ifc
->ifp
))
1635 /* Check RIP process is enabled on this interface. */
1636 ri
= ifc
->ifp
->info
;
1641 /* When passive interface is specified, suppress responses */
1645 /* RIP peer update. */
1646 rip_peer_update(rip
, from
, packet
->version
);
1648 lim
= ((caddr_t
)packet
) + size
;
1651 /* The Request is processed entry by entry. If there are no
1652 entries, no response is given. */
1653 if (lim
== (caddr_t
)rte
)
1656 /* There is one special case. If there is exactly one entry in the
1657 request, and it has an address family identifier of zero and a
1658 metric of infinity (i.e., 16), then this is a request to send the
1659 entire routing table. */
1660 if (lim
== ((caddr_t
)(rte
+ 1)) && ntohs(rte
->family
) == 0
1661 && ntohl(rte
->metric
) == RIP_METRIC_INFINITY
) {
1662 /* All route with split horizon */
1663 rip_output_process(ifc
, from
, rip_all_route
, packet
->version
);
1665 if (ntohs(rte
->family
) != AF_INET
)
1668 /* Examine the list of RTEs in the Request one by one. For each
1669 entry, look up the destination in the router's routing
1670 database and, if there is a route, put that route's metric in
1671 the metric field of the RTE. If there is no explicit route
1672 to the specified destination, put infinity in the metric
1673 field. Once all the entries have been filled in, change the
1674 command from Request to Response and send the datagram back
1675 to the requestor. */
1678 for (; ((caddr_t
)rte
) < lim
; rte
++) {
1679 p
.prefix
= rte
->prefix
;
1680 p
.prefixlen
= ip_masklen(rte
->mask
);
1681 apply_mask_ipv4(&p
);
1683 rp
= route_node_lookup(rip
->table
, (struct prefix
*)&p
);
1685 rinfo
= listgetdata(
1686 listhead((struct list
*)rp
->info
));
1687 rte
->metric
= htonl(rinfo
->metric
);
1688 route_unlock_node(rp
);
1690 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
1692 packet
->command
= RIP_RESPONSE
;
1694 (void)rip_send_packet((uint8_t *)packet
, size
, from
, ifc
);
1696 rip
->counters
.queries
++;
1699 /* First entry point of RIP packet. */
1700 static void rip_read(struct event
*t
)
1702 struct rip
*rip
= THREAD_ARG(t
);
1706 union rip_buf rip_buf
;
1707 struct rip_packet
*packet
;
1708 struct sockaddr_in from
;
1712 struct interface
*ifp
= NULL
;
1713 struct connected
*ifc
;
1714 struct rip_interface
*ri
;
1717 /* Fetch socket then register myself. */
1718 sock
= THREAD_FD(t
);
1720 /* Add myself to tne next event */
1721 rip_event(rip
, RIP_READ
, sock
);
1723 /* RIPd manages only IPv4. */
1724 memset(&from
, 0, sizeof(from
));
1725 fromlen
= sizeof(struct sockaddr_in
);
1727 len
= recvfrom(sock
, (char *)&rip_buf
.buf
, sizeof(rip_buf
.buf
), 0,
1728 (struct sockaddr
*)&from
, &fromlen
);
1730 zlog_info("recvfrom failed (VRF %s): %s", rip
->vrf_name
,
1731 safe_strerror(errno
));
1735 /* Check is this packet comming from myself? */
1736 if (if_check_address(rip
, from
.sin_addr
)) {
1737 if (IS_RIP_DEBUG_PACKET
)
1738 zlog_debug("ignore packet comes from myself (VRF %s)",
1743 /* Which interface is this packet comes from. */
1744 ifc
= if_lookup_address((void *)&from
.sin_addr
, AF_INET
,
1749 /* RIP packet received */
1750 if (IS_RIP_DEBUG_EVENT
)
1751 zlog_debug("RECV packet from %pI4 port %d on %s (VRF %s)",
1752 &from
.sin_addr
, ntohs(from
.sin_port
),
1753 ifp
? ifp
->name
: "unknown", rip
->vrf_name
);
1755 /* If this packet come from unknown interface, ignore it. */
1758 "%s: cannot find interface for packet from %pI4 port %d (VRF %s)",
1759 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1765 p
.u
.prefix4
= from
.sin_addr
;
1766 p
.prefixlen
= IPV4_MAX_BITLEN
;
1768 ifc
= connected_lookup_prefix(ifp
, &p
);
1772 "%s: cannot find connected address for packet from %pI4 port %d on interface %s (VRF %s)",
1773 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1774 ifp
->name
, rip
->vrf_name
);
1778 /* Packet length check. */
1779 if (len
< RIP_PACKET_MINSIZ
) {
1780 zlog_warn("packet size %d is smaller than minimum size %d", len
,
1782 rip_peer_bad_packet(rip
, &from
);
1785 if (len
> RIP_PACKET_MAXSIZ
) {
1786 zlog_warn("packet size %d is larger than max size %d", len
,
1788 rip_peer_bad_packet(rip
, &from
);
1792 /* Packet alignment check. */
1793 if ((len
- RIP_PACKET_MINSIZ
) % 20) {
1794 zlog_warn("packet size %d is wrong for RIP packet alignment",
1796 rip_peer_bad_packet(rip
, &from
);
1800 /* Set RTE number. */
1801 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1803 /* For easy to handle. */
1804 packet
= &rip_buf
.rip_packet
;
1806 /* RIP version check. */
1807 if (packet
->version
== 0) {
1808 zlog_info("version 0 with command %d received.",
1810 rip_peer_bad_packet(rip
, &from
);
1814 /* Dump RIP packet. */
1815 if (IS_RIP_DEBUG_RECV
)
1816 rip_packet_dump(packet
, len
, "RECV");
1818 /* RIP version adjust. This code should rethink now. RFC1058 says
1819 that "Version 1 implementations are to ignore this extra data and
1820 process only the fields specified in this document.". So RIPv3
1821 packet should be treated as RIPv1 ignoring must be zero field. */
1822 if (packet
->version
> RIPv2
)
1823 packet
->version
= RIPv2
;
1825 /* Is RIP running or is this RIP neighbor ?*/
1827 if (!ri
->running
&& !rip_neighbor_lookup(rip
, &from
)) {
1828 if (IS_RIP_DEBUG_EVENT
)
1829 zlog_debug("RIP is not enabled on interface %s.",
1831 rip_peer_bad_packet(rip
, &from
);
1835 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1836 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ? rip
->version_recv
1838 if (vrecv
== RI_RIP_VERSION_NONE
1839 || ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1840 || ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))) {
1841 if (IS_RIP_DEBUG_PACKET
)
1843 " packet's v%d doesn't fit to if version spec",
1845 rip_peer_bad_packet(rip
, &from
);
1849 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1850 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1851 accepted; authenticated RIP-2 messages shall be discarded. */
1852 if ((ri
->auth_type
== RIP_NO_AUTH
) && rtenum
1853 && (packet
->version
== RIPv2
)
1854 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
))) {
1855 if (IS_RIP_DEBUG_EVENT
)
1857 "packet RIPv%d is dropped because authentication disabled",
1859 ripd_notif_send_auth_type_failure(ifp
->name
);
1860 rip_peer_bad_packet(rip
, &from
);
1865 If the router is configured to authenticate RIP-2 messages, then
1866 RIP-1 messages and RIP-2 messages which pass authentication
1867 testing shall be accepted; unauthenticated and failed
1868 authentication RIP-2 messages shall be discarded. For maximum
1869 security, RIP-1 messages should be ignored when authentication is
1870 in use (see section 4.1); otherwise, the routing information from
1871 authenticated messages will be propagated by RIP-1 routers in an
1872 unauthenticated manner.
1874 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1875 * always reply regardless of authentication settings, because:
1877 * - if there other authorised routers on-link, the REQUESTor can
1878 * passively obtain the routing updates anyway
1879 * - if there are no other authorised routers on-link, RIP can
1880 * easily be disabled for the link to prevent giving out information
1881 * on state of this routers RIP routing table..
1883 * I.e. if RIPv1 has any place anymore these days, it's as a very
1884 * simple way to distribute routing information (e.g. to embedded
1885 * hosts / appliances) and the ability to give out RIPv1
1886 * routing-information freely, while still requiring RIPv2
1887 * authentication for any RESPONSEs might be vaguely useful.
1889 if (ri
->auth_type
!= RIP_NO_AUTH
&& packet
->version
== RIPv1
) {
1890 /* Discard RIPv1 messages other than REQUESTs */
1891 if (packet
->command
!= RIP_REQUEST
) {
1892 if (IS_RIP_DEBUG_PACKET
)
1894 "RIPv1 dropped because authentication enabled");
1895 ripd_notif_send_auth_type_failure(ifp
->name
);
1896 rip_peer_bad_packet(rip
, &from
);
1899 } else if (ri
->auth_type
!= RIP_NO_AUTH
) {
1900 const char *auth_desc
;
1903 /* There definitely is no authentication in the packet.
1905 if (IS_RIP_DEBUG_PACKET
)
1907 "RIPv2 authentication failed: no auth RTE in packet");
1908 ripd_notif_send_auth_type_failure(ifp
->name
);
1909 rip_peer_bad_packet(rip
, &from
);
1913 /* First RTE must be an Authentication Family RTE */
1914 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
)) {
1915 if (IS_RIP_DEBUG_PACKET
)
1917 "RIPv2 dropped because authentication enabled");
1918 ripd_notif_send_auth_type_failure(ifp
->name
);
1919 rip_peer_bad_packet(rip
, &from
);
1923 /* Check RIPv2 authentication. */
1924 switch (ntohs(packet
->rte
->tag
)) {
1925 case RIP_AUTH_SIMPLE_PASSWORD
:
1926 auth_desc
= "simple";
1927 ret
= rip_auth_simple_password(packet
->rte
, &from
, ifp
);
1932 ret
= rip_auth_md5(packet
, &from
, len
, ifp
);
1933 /* Reset RIP packet length to trim MD5 data. */
1939 auth_desc
= "unknown type";
1940 if (IS_RIP_DEBUG_PACKET
)
1942 "RIPv2 Unknown authentication type %d",
1943 ntohs(packet
->rte
->tag
));
1947 if (IS_RIP_DEBUG_PACKET
)
1948 zlog_debug("RIPv2 %s authentication success",
1951 if (IS_RIP_DEBUG_PACKET
)
1952 zlog_debug("RIPv2 %s authentication failure",
1954 ripd_notif_send_auth_failure(ifp
->name
);
1955 rip_peer_bad_packet(rip
, &from
);
1960 /* Process each command. */
1961 switch (packet
->command
) {
1963 rip_response_process(packet
, len
, &from
, ifc
);
1967 rip_request_process(packet
, len
, &from
, ifc
);
1972 "Obsolete command %s received, please sent it to routed",
1973 lookup_msg(rip_msg
, packet
->command
, NULL
));
1974 rip_peer_bad_packet(rip
, &from
);
1976 case RIP_POLL_ENTRY
:
1977 zlog_info("Obsolete command %s received",
1978 lookup_msg(rip_msg
, packet
->command
, NULL
));
1979 rip_peer_bad_packet(rip
, &from
);
1982 zlog_info("Unknown RIP command %d received", packet
->command
);
1983 rip_peer_bad_packet(rip
, &from
);
1988 /* Write routing table entry to the stream and return next index of
1989 the routing table entry in the stream. */
1990 static int rip_write_rte(int num
, struct stream
*s
, struct prefix_ipv4
*p
,
1991 uint8_t version
, struct rip_info
*rinfo
)
1993 struct in_addr mask
;
1995 /* Write routing table entry. */
1996 if (version
== RIPv1
) {
1997 stream_putw(s
, AF_INET
);
1999 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2000 stream_put_ipv4(s
, 0);
2001 stream_put_ipv4(s
, 0);
2002 stream_putl(s
, rinfo
->metric_out
);
2004 masklen2ip(p
->prefixlen
, &mask
);
2006 stream_putw(s
, AF_INET
);
2007 stream_putw(s
, rinfo
->tag_out
);
2008 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2009 stream_put_ipv4(s
, mask
.s_addr
);
2010 stream_put_ipv4(s
, rinfo
->nexthop_out
.s_addr
);
2011 stream_putl(s
, rinfo
->metric_out
);
2017 /* Send update to the ifp or spcified neighbor. */
2018 void rip_output_process(struct connected
*ifc
, struct sockaddr_in
*to
,
2019 int route_type
, uint8_t version
)
2024 struct route_node
*rp
;
2025 struct rip_info
*rinfo
;
2026 struct rip_interface
*ri
;
2027 struct prefix_ipv4
*p
;
2028 struct prefix_ipv4 classfull
;
2029 struct prefix_ipv4 ifaddrclass
;
2030 struct key
*key
= NULL
;
2031 /* this might need to made dynamic if RIP ever supported auth methods
2032 with larger key string sizes */
2033 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2034 size_t doff
= 0; /* offset of digest offset field */
2038 struct list
*list
= NULL
;
2039 struct listnode
*listnode
= NULL
;
2041 /* Logging output event. */
2042 if (IS_RIP_DEBUG_EVENT
) {
2044 zlog_debug("update routes to neighbor %pI4",
2047 zlog_debug("update routes on interface %s ifindex %d",
2048 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2051 /* Get RIP interface. */
2052 ri
= ifc
->ifp
->info
;
2055 /* Set output stream. */
2058 /* Reset stream and RTE counter. */
2060 rtemax
= RIP_MAX_RTE
;
2062 /* If output interface is in simple password authentication mode, we
2063 need space for authentication data. */
2064 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2067 /* If output interface is in MD5 authentication mode, we need space
2068 for authentication header and data. */
2069 if (ri
->auth_type
== RIP_AUTH_MD5
)
2072 /* If output interface is in simple password authentication mode
2073 and string or keychain is specified we need space for auth. data */
2074 if (ri
->auth_type
!= RIP_NO_AUTH
) {
2075 if (ri
->key_chain
) {
2076 struct keychain
*keychain
;
2078 keychain
= keychain_lookup(ri
->key_chain
);
2080 key
= key_lookup_for_send(keychain
);
2082 /* to be passed to auth functions later */
2083 rip_auth_prepare_str_send(ri
, key
, auth_str
, sizeof(auth_str
));
2084 if (strlen(auth_str
) == 0)
2088 if (version
== RIPv1
) {
2089 memcpy(&ifaddrclass
, ifc
->address
, sizeof(ifaddrclass
));
2090 apply_classful_mask_ipv4(&ifaddrclass
);
2092 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2096 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2102 if (listcount(list
) == 0)
2105 rinfo
= listgetdata(listhead(list
));
2107 * For RIPv1, if we are subnetted, output subnets in our
2108 * network that have the same mask as the output "interface".
2109 * For other networks, only the classfull version is output.
2111 if (version
== RIPv1
) {
2112 p
= (struct prefix_ipv4
*)&rp
->p
;
2114 if (IS_RIP_DEBUG_PACKET
)
2116 "RIPv1 mask check, %pFX considered for output",
2120 prefix_match((struct prefix
*)&ifaddrclass
,
2122 if ((ifc
->address
->prefixlen
!=
2124 (rp
->p
.prefixlen
!= IPV4_MAX_BITLEN
))
2127 memcpy(&classfull
, &rp
->p
,
2128 sizeof(struct prefix_ipv4
));
2129 apply_classful_mask_ipv4(&classfull
);
2130 if (rp
->p
.u
.prefix4
.s_addr
!= INADDR_ANY
&&
2131 classfull
.prefixlen
!= rp
->p
.prefixlen
)
2134 if (IS_RIP_DEBUG_PACKET
)
2136 "RIPv1 mask check, %pFX made it through",
2139 p
= (struct prefix_ipv4
*)&rp
->p
;
2141 /* Apply output filters. */
2142 ret
= rip_filter(RIP_FILTER_OUT
, p
, ri
);
2146 /* Changed route only output. */
2147 if (route_type
== rip_changed_route
&&
2148 (!(rinfo
->flags
& RIP_RTF_CHANGED
)))
2151 /* Split horizon. */
2152 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
) {
2154 * We perform split horizon for RIP and connected
2155 * route. For rip routes, we want to suppress the
2156 * route if we would end up sending the route back on
2157 * the interface that we learned it from, with a
2158 * higher metric. For connected routes, we suppress
2159 * the route if the prefix is a subset of the source
2160 * address that we are going to use for the packet
2161 * (in order to handle the case when multiple subnets
2162 * are configured on the same interface).
2165 struct rip_info
*tmp_rinfo
= NULL
;
2166 struct connected
*tmp_ifc
= NULL
;
2168 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2169 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2170 tmp_rinfo
->nh
.ifindex
==
2171 ifc
->ifp
->ifindex
) {
2176 if (!suppress
&& rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2177 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2179 if (prefix_match((struct prefix
*)p
,
2180 tmp_ifc
->address
)) {
2190 /* Preparation for route-map. */
2191 rinfo
->metric_set
= 0;
2192 rinfo
->nexthop_out
.s_addr
= 0;
2193 rinfo
->metric_out
= rinfo
->metric
;
2194 rinfo
->tag_out
= rinfo
->tag
;
2195 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2197 /* In order to avoid some local loops, if the RIP route has
2198 * a nexthop via this interface, keep the nexthop, otherwise
2199 * set it to 0. The nexthop should not be propagated beyond
2200 * the local broadcast/multicast area in order to avoid an
2201 * IGP multi-level recursive look-up. see (4.4)
2203 if (rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2204 rinfo
->nexthop_out
= rinfo
->nh
.gate
.ipv4
;
2206 /* Interface route-map */
2207 if (ri
->routemap
[RIP_FILTER_OUT
]) {
2208 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_OUT
],
2209 (struct prefix
*)p
, rinfo
);
2211 if (ret
== RMAP_DENYMATCH
) {
2212 if (IS_RIP_DEBUG_PACKET
)
2214 "RIP %pFX is filtered by route-map out",
2220 /* Apply redistribute route map - continue, if deny */
2221 if (rip
->redist
[rinfo
->type
].route_map
.name
&&
2222 rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2223 ret
= route_map_apply(
2224 rip
->redist
[rinfo
->type
].route_map
.map
,
2225 (struct prefix
*)p
, rinfo
);
2227 if (ret
== RMAP_DENYMATCH
) {
2228 if (IS_RIP_DEBUG_PACKET
)
2230 "%pFX is filtered by route-map",
2236 /* When route-map does not set metric. */
2237 if (!rinfo
->metric_set
) {
2238 /* If redistribute metric is set. */
2239 if (rip
->redist
[rinfo
->type
].metric_config
&&
2240 rinfo
->metric
!= RIP_METRIC_INFINITY
) {
2242 rip
->redist
[rinfo
->type
].metric
;
2244 /* If the route is not connected or localy
2245 * generated one, use default-metric value
2247 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&&
2248 rinfo
->type
!= ZEBRA_ROUTE_CONNECT
&&
2249 rinfo
->metric
!= RIP_METRIC_INFINITY
)
2250 rinfo
->metric_out
= rip
->default_metric
;
2254 /* Apply offset-list */
2255 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2256 rip_offset_list_apply_out(p
, ifc
->ifp
,
2257 &rinfo
->metric_out
);
2259 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2260 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2262 /* Perform split-horizon with poisoned reverse
2263 * for RIP and connected routes.
2265 if (ri
->split_horizon
== RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2267 * We perform split horizon for RIP and connected
2268 * route. For rip routes, we want to suppress the
2269 * route if we would end up sending the route back
2270 * on the interface that we learned it from, with a
2271 * higher metric. For connected routes, we suppress
2272 * the route if the prefix is a subset of the source
2273 * address that we are going to use for the packet
2274 * (in order to handle the case when multiple
2275 * subnets are configured on the same interface).
2277 struct rip_info
*tmp_rinfo
= NULL
;
2278 struct connected
*tmp_ifc
= NULL
;
2280 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2281 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2282 tmp_rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2283 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2285 if (rinfo
->metric_out
!= RIP_METRIC_INFINITY
&&
2286 rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2287 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2289 if (prefix_match((struct prefix
*)p
,
2290 tmp_ifc
->address
)) {
2292 RIP_METRIC_INFINITY
;
2298 /* Prepare preamble, auth headers, if needs be */
2300 stream_putc(s
, RIP_RESPONSE
);
2301 stream_putc(s
, version
);
2304 /* auth header for !v1 && !no_auth */
2305 if ((ri
->auth_type
!= RIP_NO_AUTH
) &&
2307 doff
= rip_auth_header_write(
2308 s
, ri
, key
, auth_str
,
2309 RIP_AUTH_SIMPLE_SIZE
);
2312 /* Write RTE to the stream. */
2313 num
= rip_write_rte(num
, s
, p
, version
, rinfo
);
2314 if (num
== rtemax
) {
2315 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2316 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2317 RIP_AUTH_SIMPLE_SIZE
);
2319 ret
= rip_send_packet(STREAM_DATA(s
),
2320 stream_get_endp(s
), to
, ifc
);
2322 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2324 (struct rip_packet
*)STREAM_DATA(s
),
2325 stream_get_endp(s
), "SEND");
2331 /* Flush unwritten RTE. */
2333 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2334 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2335 RIP_AUTH_SIMPLE_SIZE
);
2337 ret
= rip_send_packet(STREAM_DATA(s
), stream_get_endp(s
), to
,
2340 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2341 rip_packet_dump((struct rip_packet
*)STREAM_DATA(s
),
2342 stream_get_endp(s
), "SEND");
2346 /* Statistics updates. */
2350 /* Send RIP packet to the interface. */
2351 static void rip_update_interface(struct connected
*ifc
, uint8_t version
,
2354 struct interface
*ifp
= ifc
->ifp
;
2355 struct rip_interface
*ri
= ifp
->info
;
2356 struct sockaddr_in to
;
2358 /* When RIP version is 2 and multicast enable interface. */
2359 if (version
== RIPv2
&& !ri
->v2_broadcast
&& if_is_multicast(ifp
)) {
2360 if (IS_RIP_DEBUG_EVENT
)
2361 zlog_debug("multicast announce on %s ", ifp
->name
);
2363 rip_output_process(ifc
, NULL
, route_type
, version
);
2367 /* If we can't send multicast packet, send it with unicast. */
2368 if (if_is_broadcast(ifp
) || if_is_pointopoint(ifp
)) {
2369 if (ifc
->address
->family
== AF_INET
) {
2370 /* Destination address and port setting. */
2371 memset(&to
, 0, sizeof(to
));
2372 if (ifc
->destination
)
2373 /* use specified broadcast or peer destination
2375 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2376 else if (ifc
->address
->prefixlen
< IPV4_MAX_BITLEN
)
2377 /* calculate the appropriate broadcast address
2379 to
.sin_addr
.s_addr
= ipv4_broadcast_addr(
2380 ifc
->address
->u
.prefix4
.s_addr
,
2381 ifc
->address
->prefixlen
);
2383 /* do not know where to send the packet */
2385 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2387 if (IS_RIP_DEBUG_EVENT
)
2388 zlog_debug("%s announce to %pI4 on %s",
2389 CONNECTED_PEER(ifc
) ? "unicast"
2391 &to
.sin_addr
, ifp
->name
);
2393 rip_output_process(ifc
, &to
, route_type
, version
);
2398 /* Update send to all interface and neighbor. */
2399 static void rip_update_process(struct rip
*rip
, int route_type
)
2401 struct listnode
*ifnode
, *ifnnode
;
2402 struct connected
*connected
;
2403 struct interface
*ifp
;
2404 struct rip_interface
*ri
;
2405 struct route_node
*rp
;
2406 struct sockaddr_in to
;
2409 /* Send RIP update to each interface. */
2410 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
2411 if (if_is_loopback(ifp
))
2414 if (!if_is_operative(ifp
))
2417 /* Fetch RIP interface information. */
2420 /* When passive interface is specified, suppress announce to the
2429 * If there is no version configuration in the
2430 * interface, use rip's version setting.
2432 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
) ? rip
->version_send
2435 if (IS_RIP_DEBUG_EVENT
)
2436 zlog_debug("SEND UPDATE to %s ifindex %d", ifp
->name
,
2439 /* send update on each connected network */
2440 for (ALL_LIST_ELEMENTS(ifp
->connected
, ifnode
, ifnnode
,
2442 if (connected
->address
->family
== AF_INET
) {
2444 rip_update_interface(connected
, RIPv1
,
2446 if ((vsend
& RIPv2
) && if_is_multicast(ifp
))
2447 rip_update_interface(connected
, RIPv2
,
2453 /* RIP send updates to each neighbor. */
2454 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
)) {
2455 if (rp
->info
== NULL
)
2460 connected
= if_lookup_address(&p
->u
.prefix4
, AF_INET
,
2464 "Neighbor %pI4 doesn't have connected interface!",
2469 /* Set destination address and port */
2470 memset(&to
, 0, sizeof(struct sockaddr_in
));
2471 to
.sin_addr
= p
->u
.prefix4
;
2472 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2474 /* RIP version is rip's configuration. */
2475 rip_output_process(connected
, &to
, route_type
,
2480 /* RIP's periodical timer. */
2481 static void rip_update(struct event
*t
)
2483 struct rip
*rip
= THREAD_ARG(t
);
2485 if (IS_RIP_DEBUG_EVENT
)
2486 zlog_debug("update timer fire!");
2488 /* Process update output. */
2489 rip_update_process(rip
, rip_all_route
);
2491 /* Triggered updates may be suppressed if a regular update is due by
2492 the time the triggered update would be sent. */
2493 THREAD_OFF(rip
->t_triggered_interval
);
2496 /* Register myself. */
2497 rip_event(rip
, RIP_UPDATE_EVENT
, 0);
2500 /* Walk down the RIP routing table then clear changed flag. */
2501 static void rip_clear_changed_flag(struct rip
*rip
)
2503 struct route_node
*rp
;
2504 struct rip_info
*rinfo
= NULL
;
2505 struct list
*list
= NULL
;
2506 struct listnode
*listnode
= NULL
;
2508 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2514 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
2515 UNSET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2516 /* This flag can be set only on the first entry. */
2522 /* Triggered update interval timer. */
2523 static void rip_triggered_interval(struct event
*t
)
2525 struct rip
*rip
= THREAD_ARG(t
);
2529 rip_triggered_update(t
);
2533 /* Execute triggered update. */
2534 static void rip_triggered_update(struct event
*t
)
2536 struct rip
*rip
= THREAD_ARG(t
);
2539 /* Cancel interval timer. */
2540 THREAD_OFF(rip
->t_triggered_interval
);
2543 /* Logging triggered update. */
2544 if (IS_RIP_DEBUG_EVENT
)
2545 zlog_debug("triggered update!");
2547 /* Split Horizon processing is done when generating triggered
2548 updates as well as normal updates (see section 2.6). */
2549 rip_update_process(rip
, rip_changed_route
);
2551 /* Once all of the triggered updates have been generated, the route
2552 change flags should be cleared. */
2553 rip_clear_changed_flag(rip
);
2555 /* After a triggered update is sent, a timer should be set for a
2556 random interval between 1 and 5 seconds. If other changes that
2557 would trigger updates occur before the timer expires, a single
2558 update is triggered when the timer expires. */
2559 interval
= (frr_weak_random() % 5) + 1;
2561 event_add_timer(master
, rip_triggered_interval
, rip
, interval
,
2562 &rip
->t_triggered_interval
);
2565 /* Withdraw redistributed route. */
2566 void rip_redistribute_withdraw(struct rip
*rip
, int type
)
2568 struct route_node
*rp
;
2569 struct rip_info
*rinfo
= NULL
;
2570 struct list
*list
= NULL
;
2572 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2578 rinfo
= listgetdata(listhead(list
));
2580 if (rinfo
->type
!= type
)
2583 if (rinfo
->sub_type
== RIP_ROUTE_INTERFACE
)
2586 /* Perform poisoned reverse. */
2587 rinfo
->metric
= RIP_METRIC_INFINITY
;
2588 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
2590 THREAD_OFF(rinfo
->t_timeout
);
2591 rinfo
->flags
|= RIP_RTF_CHANGED
;
2593 if (IS_RIP_DEBUG_EVENT
) {
2594 struct prefix_ipv4
*p
= (struct prefix_ipv4
*)&rp
->p
;
2597 "Poisone %pFX on the interface %s with an infinity metric [withdraw]",
2599 ifindex2ifname(rinfo
->nh
.ifindex
,
2603 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2607 struct rip
*rip_lookup_by_vrf_id(vrf_id_t vrf_id
)
2611 vrf
= vrf_lookup_by_id(vrf_id
);
2618 struct rip
*rip_lookup_by_vrf_name(const char *vrf_name
)
2622 rip
.vrf_name
= (char *)vrf_name
;
2624 return RB_FIND(rip_instance_head
, &rip_instances
, &rip
);
2627 /* Create new RIP instance and set it to global variable. */
2628 struct rip
*rip_create(const char *vrf_name
, struct vrf
*vrf
, int socket
)
2632 rip
= XCALLOC(MTYPE_RIP
, sizeof(struct rip
));
2633 rip
->vrf_name
= XSTRDUP(MTYPE_RIP_VRF_NAME
, vrf_name
);
2635 /* Set initial value. */
2636 rip
->ecmp
= yang_get_default_bool("%s/allow-ecmp", RIP_INSTANCE
);
2637 rip
->default_metric
=
2638 yang_get_default_uint8("%s/default-metric", RIP_INSTANCE
);
2640 yang_get_default_uint8("%s/distance/default", RIP_INSTANCE
);
2641 rip
->passive_default
=
2642 yang_get_default_bool("%s/passive-default", RIP_INSTANCE
);
2643 rip
->garbage_time
= yang_get_default_uint32("%s/timers/flush-interval",
2645 rip
->timeout_time
= yang_get_default_uint32(
2646 "%s/timers/holddown-interval", RIP_INSTANCE
);
2647 rip
->update_time
= yang_get_default_uint32("%s/timers/update-interval",
2650 yang_get_default_enum("%s/version/send", RIP_INSTANCE
);
2652 yang_get_default_enum("%s/version/receive", RIP_INSTANCE
);
2654 /* Initialize RIP data structures. */
2655 rip
->table
= route_table_init();
2656 route_table_set_info(rip
->table
, rip
);
2657 rip
->neighbor
= route_table_init();
2658 rip
->peer_list
= list_new();
2659 rip
->peer_list
->cmp
= (int (*)(void *, void *))rip_peer_list_cmp
;
2660 rip
->peer_list
->del
= rip_peer_list_del
;
2661 rip
->distance_table
= route_table_init();
2662 rip
->distance_table
->cleanup
= rip_distance_table_node_cleanup
;
2663 rip
->enable_interface
= vector_init(1);
2664 rip
->enable_network
= route_table_init();
2665 rip
->passive_nondefault
= vector_init(1);
2666 rip
->offset_list_master
= list_new();
2667 rip
->offset_list_master
->cmp
= (int (*)(void *, void *))offset_list_cmp
;
2668 rip
->offset_list_master
->del
= (void (*)(void *))offset_list_free
;
2670 /* Distribute list install. */
2671 rip
->distribute_ctx
= distribute_list_ctx_create(vrf
);
2672 distribute_list_add_hook(rip
->distribute_ctx
, rip_distribute_update
);
2673 distribute_list_delete_hook(rip
->distribute_ctx
, rip_distribute_update
);
2675 /* if rmap install. */
2676 rip
->if_rmap_ctx
= if_rmap_ctx_create(vrf_name
);
2677 if_rmap_hook_add(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2678 if_rmap_hook_delete(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2680 /* Make output stream. */
2681 rip
->obuf
= stream_new(1500);
2683 /* Enable the routing instance if possible. */
2684 if (vrf
&& vrf_is_enabled(vrf
))
2685 rip_instance_enable(rip
, vrf
, socket
);
2691 RB_INSERT(rip_instance_head
, &rip_instances
, rip
);
2696 /* Sned RIP request to the destination. */
2697 int rip_request_send(struct sockaddr_in
*to
, struct interface
*ifp
,
2698 uint8_t version
, struct connected
*connected
)
2701 struct rip_packet rip_packet
;
2702 struct listnode
*node
, *nnode
;
2704 memset(&rip_packet
, 0, sizeof(rip_packet
));
2706 rip_packet
.command
= RIP_REQUEST
;
2707 rip_packet
.version
= version
;
2708 rte
= rip_packet
.rte
;
2709 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
2713 * connected is only sent for ripv1 case, or when
2714 * interface does not support multicast. Caller loops
2715 * over each connected address for this case.
2717 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2719 != sizeof(rip_packet
))
2722 return sizeof(rip_packet
);
2725 /* send request on each connected network */
2726 for (ALL_LIST_ELEMENTS(ifp
->connected
, node
, nnode
, connected
)) {
2727 struct prefix_ipv4
*p
;
2729 p
= (struct prefix_ipv4
*)connected
->address
;
2731 if (p
->family
!= AF_INET
)
2734 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2736 != sizeof(rip_packet
))
2739 return sizeof(rip_packet
);
2742 static int rip_update_jitter(unsigned long time
)
2744 #define JITTER_BOUND 4
2745 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2746 Given that, we cannot let time be less than JITTER_BOUND seconds.
2747 The RIPv2 RFC says jitter should be small compared to
2748 update_time. We consider 1/JITTER_BOUND to be small.
2751 int jitter_input
= time
;
2754 if (jitter_input
< JITTER_BOUND
)
2755 jitter_input
= JITTER_BOUND
;
2757 jitter
= (((frr_weak_random() % ((jitter_input
* 2) + 1))
2760 return jitter
/ JITTER_BOUND
;
2763 void rip_event(struct rip
*rip
, enum rip_event event
, int sock
)
2769 event_add_read(master
, rip_read
, rip
, sock
, &rip
->t_read
);
2771 case RIP_UPDATE_EVENT
:
2772 THREAD_OFF(rip
->t_update
);
2773 jitter
= rip_update_jitter(rip
->update_time
);
2774 event_add_timer(master
, rip_update
, rip
,
2775 sock
? 2 : rip
->update_time
+ jitter
,
2778 case RIP_TRIGGERED_UPDATE
:
2779 if (rip
->t_triggered_interval
)
2782 event_add_event(master
, rip_triggered_update
, rip
, 0,
2783 &rip
->t_triggered_update
);
2790 struct rip_distance
*rip_distance_new(void)
2792 return XCALLOC(MTYPE_RIP_DISTANCE
, sizeof(struct rip_distance
));
2795 void rip_distance_free(struct rip_distance
*rdistance
)
2797 if (rdistance
->access_list
)
2798 free(rdistance
->access_list
);
2799 XFREE(MTYPE_RIP_DISTANCE
, rdistance
);
2802 static void rip_distance_table_node_cleanup(struct route_table
*table
,
2803 struct route_node
*node
)
2805 struct rip_distance
*rdistance
;
2807 rdistance
= node
->info
;
2809 rip_distance_free(rdistance
);
2812 /* Apply RIP information to distance method. */
2813 uint8_t rip_distance_apply(struct rip
*rip
, struct rip_info
*rinfo
)
2815 struct route_node
*rn
;
2816 struct prefix_ipv4 p
;
2817 struct rip_distance
*rdistance
;
2818 struct access_list
*alist
;
2820 memset(&p
, 0, sizeof(p
));
2822 p
.prefix
= rinfo
->from
;
2823 p
.prefixlen
= IPV4_MAX_BITLEN
;
2825 /* Check source address. */
2826 rn
= route_node_match(rip
->distance_table
, (struct prefix
*)&p
);
2828 rdistance
= rn
->info
;
2829 route_unlock_node(rn
);
2831 if (rdistance
->access_list
) {
2832 alist
= access_list_lookup(AFI_IP
,
2833 rdistance
->access_list
);
2836 if (access_list_apply(alist
, &rinfo
->rp
->p
)
2840 return rdistance
->distance
;
2842 return rdistance
->distance
;
2846 return rip
->distance
;
2851 static void rip_distance_show(struct vty
*vty
, struct rip
*rip
)
2853 struct route_node
*rn
;
2854 struct rip_distance
*rdistance
;
2858 vty_out(vty
, " Distance: (default is %u)\n",
2859 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
2861 for (rn
= route_top(rip
->distance_table
); rn
; rn
= route_next(rn
)) {
2862 rdistance
= rn
->info
;
2864 if (rdistance
== NULL
)
2868 vty_out(vty
, " Address Distance List\n");
2871 snprintfrr(buf
, sizeof(buf
), "%pFX", &rn
->p
);
2872 vty_out(vty
, " %-20s %4d %s\n", buf
, rdistance
->distance
,
2873 rdistance
->access_list
? rdistance
->access_list
: "");
2877 /* Update ECMP routes to zebra when ECMP is disabled. */
2878 void rip_ecmp_disable(struct rip
*rip
)
2880 struct route_node
*rp
;
2881 struct rip_info
*rinfo
, *tmp_rinfo
;
2883 struct listnode
*node
, *nextnode
;
2885 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2890 if (listcount(list
) == 0)
2893 rinfo
= listgetdata(listhead(list
));
2894 if (!rip_route_rte(rinfo
))
2897 /* Drop all other entries, except the first one. */
2898 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
2899 if (tmp_rinfo
== rinfo
)
2902 THREAD_OFF(tmp_rinfo
->t_timeout
);
2903 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
2904 list_delete_node(list
, node
);
2905 rip_info_free(tmp_rinfo
);
2909 rip_zebra_ipv4_add(rip
, rp
);
2911 /* Set the route change flag. */
2912 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2914 /* Signal the output process to trigger an update. */
2915 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2919 /* Print out routes update time. */
2920 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
2925 char timebuf
[TIME_BUF
];
2926 struct event
*thread
;
2928 if ((thread
= rinfo
->t_timeout
) != NULL
) {
2929 clock
= thread_timer_remain_second(thread
);
2930 gmtime_r(&clock
, &tm
);
2931 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2932 vty_out(vty
, "%5s", timebuf
);
2933 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
2934 clock
= thread_timer_remain_second(thread
);
2935 gmtime_r(&clock
, &tm
);
2936 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2937 vty_out(vty
, "%5s", timebuf
);
2941 static const char *rip_route_type_print(int sub_type
)
2946 case RIP_ROUTE_STATIC
:
2948 case RIP_ROUTE_DEFAULT
:
2950 case RIP_ROUTE_REDISTRIBUTE
:
2952 case RIP_ROUTE_INTERFACE
:
2961 "show ip rip [vrf NAME]",
2968 struct route_node
*np
;
2969 struct rip_info
*rinfo
= NULL
;
2970 struct list
*list
= NULL
;
2971 struct listnode
*listnode
= NULL
;
2972 const char *vrf_name
;
2975 if (argv_find(argv
, argc
, "vrf", &idx
))
2976 vrf_name
= argv
[idx
+ 1]->arg
;
2978 vrf_name
= VRF_DEFAULT_NAME
;
2980 rip
= rip_lookup_by_vrf_name(vrf_name
);
2982 vty_out(vty
, "%% RIP instance not found\n");
2985 if (!rip
->enabled
) {
2986 vty_out(vty
, "%% RIP instance is disabled\n");
2991 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
2993 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
2994 " (i) - interface\n\n"
2995 " Network Next Hop Metric From Tag Time\n");
2997 for (np
= route_top(rip
->table
); np
; np
= route_next(np
)) {
3003 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3006 len
= vty_out(vty
, "%c(%s) %pFX",
3007 /* np->lock, For debugging. */
3008 zebra_route_char(rinfo
->type
),
3009 rip_route_type_print(rinfo
->sub_type
),
3015 vty_out(vty
, "%*s", len
, " ");
3017 switch (rinfo
->nh
.type
) {
3018 case NEXTHOP_TYPE_IPV4
:
3019 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3020 vty_out(vty
, "%-20pI4 %2d ",
3021 &rinfo
->nh
.gate
.ipv4
, rinfo
->metric
);
3023 case NEXTHOP_TYPE_IFINDEX
:
3024 vty_out(vty
, "0.0.0.0 %2d ",
3027 case NEXTHOP_TYPE_BLACKHOLE
:
3028 vty_out(vty
, "blackhole %2d ",
3031 case NEXTHOP_TYPE_IPV6
:
3032 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3033 vty_out(vty
, "V6 Address Hidden %2d ",
3038 /* Route which exist in kernel routing table. */
3039 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3040 (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3041 vty_out(vty
, "%-15pI4 ", &rinfo
->from
);
3042 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3043 (route_tag_t
)rinfo
->tag
);
3044 rip_vty_out_uptime(vty
, rinfo
);
3045 } else if (rinfo
->metric
== RIP_METRIC_INFINITY
) {
3046 vty_out(vty
, "self ");
3047 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3048 (route_tag_t
)rinfo
->tag
);
3049 rip_vty_out_uptime(vty
, rinfo
);
3051 if (rinfo
->external_metric
) {
3053 vty
, "self (%s:%d)",
3054 zebra_route_string(rinfo
->type
),
3055 rinfo
->external_metric
);
3058 vty_out(vty
, "%*s", len
, " ");
3060 vty_out(vty
, "self ");
3061 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3062 (route_tag_t
)rinfo
->tag
);
3071 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3072 DEFUN (show_ip_rip_status
,
3073 show_ip_rip_status_cmd
,
3074 "show ip rip [vrf NAME] status",
3079 "IP routing protocol process parameters and statistics\n")
3082 struct interface
*ifp
;
3083 struct rip_interface
*ri
;
3084 extern const struct message ri_version_msg
[];
3085 const char *send_version
;
3086 const char *receive_version
;
3087 const char *vrf_name
;
3090 if (argv_find(argv
, argc
, "vrf", &idx
))
3091 vrf_name
= argv
[idx
+ 1]->arg
;
3093 vrf_name
= VRF_DEFAULT_NAME
;
3095 rip
= rip_lookup_by_vrf_name(vrf_name
);
3097 vty_out(vty
, "%% RIP instance not found\n");
3100 if (!rip
->enabled
) {
3101 vty_out(vty
, "%% RIP instance is disabled\n");
3105 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3106 vty_out(vty
, " Sending updates every %u seconds with +/-50%%,",
3108 vty_out(vty
, " next due in %lu seconds\n",
3109 thread_timer_remain_second(rip
->t_update
));
3110 vty_out(vty
, " Timeout after %u seconds,", rip
->timeout_time
);
3111 vty_out(vty
, " garbage collect after %u seconds\n", rip
->garbage_time
);
3113 /* Filtering status show. */
3114 config_show_distribute(vty
, rip
->distribute_ctx
);
3116 /* Default metric information. */
3117 vty_out(vty
, " Default redistribution metric is %u\n",
3118 rip
->default_metric
);
3120 /* Redistribute information. */
3121 vty_out(vty
, " Redistributing:");
3122 rip_show_redistribute_config(vty
, rip
);
3125 vty_out(vty
, " Default version control: send version %s,",
3126 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3127 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3128 vty_out(vty
, " receive any version \n");
3130 vty_out(vty
, " receive version %s \n",
3131 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3133 vty_out(vty
, " Interface Send Recv Key-chain\n");
3135 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3141 if (ri
->enable_network
|| ri
->enable_interface
) {
3142 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3144 lookup_msg(ri_version_msg
,
3145 rip
->version_send
, NULL
);
3147 send_version
= lookup_msg(ri_version_msg
,
3150 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3152 lookup_msg(ri_version_msg
,
3153 rip
->version_recv
, NULL
);
3155 receive_version
= lookup_msg(
3156 ri_version_msg
, ri
->ri_receive
, NULL
);
3158 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3159 send_version
, receive_version
,
3160 ri
->key_chain
? ri
->key_chain
: "");
3164 vty_out(vty
, " Routing for Networks:\n");
3165 rip_show_network_config(vty
, rip
);
3167 int found_passive
= 0;
3168 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3171 if ((ri
->enable_network
|| ri
->enable_interface
) &&
3173 if (!found_passive
) {
3174 vty_out(vty
, " Passive Interface(s):\n");
3177 vty_out(vty
, " %s\n", ifp
->name
);
3181 vty_out(vty
, " Routing Information Sources:\n");
3183 " Gateway BadPackets BadRoutes Distance Last Update\n");
3184 rip_peer_display(vty
, rip
);
3186 rip_distance_show(vty
, rip
);
3191 /* RIP configuration write function. */
3192 static int config_write_rip(struct vty
*vty
)
3197 RB_FOREACH(rip
, rip_instance_head
, &rip_instances
) {
3198 char xpath
[XPATH_MAXLEN
];
3199 struct lyd_node
*dnode
;
3201 snprintf(xpath
, sizeof(xpath
),
3202 "/frr-ripd:ripd/instance[vrf='%s']", rip
->vrf_name
);
3204 dnode
= yang_dnode_get(running_config
->dnode
, xpath
);
3207 nb_cli_show_dnode_cmds(vty
, dnode
, false);
3209 /* Distribute configuration. */
3210 config_write_distribute(vty
, rip
->distribute_ctx
);
3212 /* Interface routemap configuration */
3213 config_write_if_rmap(vty
, rip
->if_rmap_ctx
);
3215 vty_out(vty
, "exit\n");
3223 static int config_write_rip(struct vty
*vty
);
3224 /* RIP node structure. */
3225 static struct cmd_node rip_node
= {
3228 .parent_node
= CONFIG_NODE
,
3229 .prompt
= "%s(config-router)# ",
3230 .config_write
= config_write_rip
,
3233 /* Distribute-list update functions. */
3234 static void rip_distribute_update(struct distribute_ctx
*ctx
,
3235 struct distribute
*dist
)
3237 struct interface
*ifp
;
3238 struct rip_interface
*ri
;
3239 struct access_list
*alist
;
3240 struct prefix_list
*plist
;
3242 if (!ctx
->vrf
|| !dist
->ifname
)
3245 ifp
= if_lookup_by_name(dist
->ifname
, ctx
->vrf
->vrf_id
);
3251 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3252 alist
= access_list_lookup(AFI_IP
,
3253 dist
->list
[DISTRIBUTE_V4_IN
]);
3255 ri
->list
[RIP_FILTER_IN
] = alist
;
3257 ri
->list
[RIP_FILTER_IN
] = NULL
;
3259 ri
->list
[RIP_FILTER_IN
] = NULL
;
3261 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3262 alist
= access_list_lookup(AFI_IP
,
3263 dist
->list
[DISTRIBUTE_V4_OUT
]);
3265 ri
->list
[RIP_FILTER_OUT
] = alist
;
3267 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3269 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3271 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3272 plist
= prefix_list_lookup(AFI_IP
,
3273 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3275 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3277 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3279 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3281 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3282 plist
= prefix_list_lookup(AFI_IP
,
3283 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3285 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3287 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3289 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3292 void rip_distribute_update_interface(struct interface
*ifp
)
3294 struct rip_interface
*ri
= ifp
->info
;
3295 struct rip
*rip
= ri
->rip
;
3296 struct distribute
*dist
;
3300 dist
= distribute_lookup(rip
->distribute_ctx
, ifp
->name
);
3302 rip_distribute_update(rip
->distribute_ctx
, dist
);
3305 /* Update all interface's distribute list. */
3307 static void rip_distribute_update_all(struct prefix_list
*notused
)
3309 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3310 struct interface
*ifp
;
3312 FOR_ALL_INTERFACES (vrf
, ifp
)
3313 rip_distribute_update_interface(ifp
);
3316 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3318 rip_distribute_update_all(NULL
);
3321 /* Delete all added rip route. */
3322 void rip_clean(struct rip
*rip
)
3324 rip_interfaces_clean(rip
);
3327 rip_instance_disable(rip
);
3329 stream_free(rip
->obuf
);
3331 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3332 if (rip
->redist
[i
].route_map
.name
)
3333 free(rip
->redist
[i
].route_map
.name
);
3335 route_table_finish(rip
->table
);
3336 route_table_finish(rip
->neighbor
);
3337 list_delete(&rip
->peer_list
);
3338 distribute_list_delete(&rip
->distribute_ctx
);
3339 if_rmap_ctx_delete(rip
->if_rmap_ctx
);
3341 rip_clean_network(rip
);
3342 rip_passive_nondefault_clean(rip
);
3343 vector_free(rip
->enable_interface
);
3344 route_table_finish(rip
->enable_network
);
3345 vector_free(rip
->passive_nondefault
);
3346 list_delete(&rip
->offset_list_master
);
3347 route_table_finish(rip
->distance_table
);
3349 RB_REMOVE(rip_instance_head
, &rip_instances
, rip
);
3350 XFREE(MTYPE_RIP_VRF_NAME
, rip
->vrf_name
);
3351 XFREE(MTYPE_RIP
, rip
);
3354 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
3355 struct if_rmap
*if_rmap
)
3357 struct interface
*ifp
= NULL
;
3358 struct rip_interface
*ri
;
3359 struct route_map
*rmap
;
3360 struct vrf
*vrf
= NULL
;
3363 vrf
= vrf_lookup_by_name(ctx
->name
);
3365 ifp
= if_lookup_by_name(if_rmap
->ifname
, vrf
->vrf_id
);
3370 if (if_rmap
->routemap
[IF_RMAP_IN
]) {
3371 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_IN
]);
3373 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3375 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3377 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3379 if (if_rmap
->routemap
[IF_RMAP_OUT
]) {
3380 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_OUT
]);
3382 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3384 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3386 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3389 void rip_if_rmap_update_interface(struct interface
*ifp
)
3391 struct rip_interface
*ri
= ifp
->info
;
3392 struct rip
*rip
= ri
->rip
;
3393 struct if_rmap
*if_rmap
;
3394 struct if_rmap_ctx
*ctx
;
3398 ctx
= rip
->if_rmap_ctx
;
3401 if_rmap
= if_rmap_lookup(ctx
, ifp
->name
);
3403 rip_if_rmap_update(ctx
, if_rmap
);
3406 static void rip_routemap_update_redistribute(struct rip
*rip
)
3408 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3409 if (rip
->redist
[i
].route_map
.name
) {
3410 rip
->redist
[i
].route_map
.map
= route_map_lookup_by_name(
3411 rip
->redist
[i
].route_map
.name
);
3412 route_map_counter_increment(
3413 rip
->redist
[i
].route_map
.map
);
3419 static void rip_routemap_update(const char *notused
)
3421 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3423 struct interface
*ifp
;
3425 FOR_ALL_INTERFACES (vrf
, ifp
)
3426 rip_if_rmap_update_interface(ifp
);
3430 rip_routemap_update_redistribute(rip
);
3433 /* Link RIP instance to VRF. */
3434 static void rip_vrf_link(struct rip
*rip
, struct vrf
*vrf
)
3436 struct interface
*ifp
;
3439 rip
->distribute_ctx
->vrf
= vrf
;
3442 FOR_ALL_INTERFACES (vrf
, ifp
)
3443 rip_interface_sync(ifp
);
3446 /* Unlink RIP instance from VRF. */
3447 static void rip_vrf_unlink(struct rip
*rip
, struct vrf
*vrf
)
3449 struct interface
*ifp
;
3452 rip
->distribute_ctx
->vrf
= NULL
;
3455 FOR_ALL_INTERFACES (vrf
, ifp
)
3456 rip_interface_sync(ifp
);
3459 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
)
3463 rip_vrf_link(rip
, vrf
);
3464 rip
->enabled
= true;
3466 /* Resend all redistribute requests. */
3467 rip_redistribute_enable(rip
);
3469 /* Create read and timer thread. */
3470 rip_event(rip
, RIP_READ
, rip
->sock
);
3471 rip_event(rip
, RIP_UPDATE_EVENT
, 1);
3473 rip_zebra_vrf_register(vrf
);
3476 static void rip_instance_disable(struct rip
*rip
)
3478 struct vrf
*vrf
= rip
->vrf
;
3479 struct route_node
*rp
;
3481 /* Clear RIP routes */
3482 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
3483 struct rip_info
*rinfo
;
3485 struct listnode
*listnode
;
3487 if ((list
= rp
->info
) == NULL
)
3490 rinfo
= listgetdata(listhead(list
));
3491 if (rip_route_rte(rinfo
))
3492 rip_zebra_ipv4_delete(rip
, rp
);
3494 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3495 THREAD_OFF(rinfo
->t_timeout
);
3496 THREAD_OFF(rinfo
->t_garbage_collect
);
3497 rip_info_free(rinfo
);
3501 route_unlock_node(rp
);
3504 /* Flush all redistribute requests. */
3505 rip_redistribute_disable(rip
);
3507 /* Cancel RIP related timers. */
3508 THREAD_OFF(rip
->t_update
);
3509 THREAD_OFF(rip
->t_triggered_update
);
3510 THREAD_OFF(rip
->t_triggered_interval
);
3512 /* Cancel read thread. */
3513 THREAD_OFF(rip
->t_read
);
3515 /* Close RIP socket. */
3519 /* Clear existing peers. */
3520 list_delete_all_node(rip
->peer_list
);
3522 rip_zebra_vrf_deregister(vrf
);
3524 rip_vrf_unlink(rip
, vrf
);
3525 rip
->enabled
= false;
3528 static int rip_vrf_new(struct vrf
*vrf
)
3530 if (IS_RIP_DEBUG_EVENT
)
3531 zlog_debug("%s: VRF created: %s(%u)", __func__
, vrf
->name
,
3537 static int rip_vrf_delete(struct vrf
*vrf
)
3541 if (IS_RIP_DEBUG_EVENT
)
3542 zlog_debug("%s: VRF deleted: %s(%u)", __func__
, vrf
->name
,
3545 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3554 static int rip_vrf_enable(struct vrf
*vrf
)
3559 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3560 if (!rip
|| rip
->enabled
)
3563 if (IS_RIP_DEBUG_EVENT
)
3564 zlog_debug("%s: VRF %s(%u) enabled", __func__
, vrf
->name
,
3567 /* Activate the VRF RIP instance. */
3568 if (!rip
->enabled
) {
3569 socket
= rip_create_socket(vrf
);
3573 rip_instance_enable(rip
, vrf
, socket
);
3579 static int rip_vrf_disable(struct vrf
*vrf
)
3583 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3584 if (!rip
|| !rip
->enabled
)
3587 if (IS_RIP_DEBUG_EVENT
)
3588 zlog_debug("%s: VRF %s(%u) disabled", __func__
, vrf
->name
,
3591 /* Deactivate the VRF RIP instance. */
3593 rip_instance_disable(rip
);
3598 void rip_vrf_init(void)
3600 vrf_init(rip_vrf_new
, rip_vrf_enable
, rip_vrf_disable
, rip_vrf_delete
);
3605 void rip_vrf_terminate(void)
3610 /* Allocate new rip structure and set default value. */
3613 /* Install top nodes. */
3614 install_node(&rip_node
);
3616 /* Install rip commands. */
3617 install_element(VIEW_NODE
, &show_ip_rip_cmd
);
3618 install_element(VIEW_NODE
, &show_ip_rip_status_cmd
);
3620 install_default(RIP_NODE
);
3622 /* Debug related init. */
3625 /* Access list install. */
3627 access_list_add_hook(rip_distribute_update_all_wrapper
);
3628 access_list_delete_hook(rip_distribute_update_all_wrapper
);
3630 /* Prefix list initialize.*/
3632 prefix_list_add_hook(rip_distribute_update_all
);
3633 prefix_list_delete_hook(rip_distribute_update_all
);
3636 rip_route_map_init();
3638 route_map_add_hook(rip_routemap_update
);
3639 route_map_delete_hook(rip_routemap_update
);
3641 if_rmap_init(RIP_NODE
);