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
= EVENT_ARG(t
);
131 /* Off timeout timer. */
132 EVENT_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 EVENT_OFF(tmp_rinfo
->t_timeout
);
215 EVENT_OFF(tmp_rinfo
->t_garbage_collect
);
216 list_delete_node(list
, node
);
217 rip_info_free(tmp_rinfo
);
220 EVENT_OFF(rinfo
->t_timeout
);
221 EVENT_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 EVENT_OFF(rinfo
->t_timeout
);
252 if (listcount(list
) > 1) {
253 /* Some other ECMP entries still exist. Just delete this entry.
255 EVENT_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
= EVENT_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 EVENT_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 EVENT_OFF(rinfo
->t_timeout
);
648 EVENT_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 port %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 EVENT_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
= EVENT_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. */
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
= EVENT_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 EVENT_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
= EVENT_ARG(t
);
2529 rip_triggered_update(t
);
2533 /* Execute triggered update. */
2534 static void rip_triggered_update(struct event
*t
)
2536 struct rip
*rip
= EVENT_ARG(t
);
2539 /* Cancel interval timer. */
2540 EVENT_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 EVENT_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 EVENT_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
;
2843 return rip
->distance
;
2846 static void rip_distance_show(struct vty
*vty
, struct rip
*rip
)
2848 struct route_node
*rn
;
2849 struct rip_distance
*rdistance
;
2853 vty_out(vty
, " Distance: (default is %u)\n",
2854 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
2856 for (rn
= route_top(rip
->distance_table
); rn
; rn
= route_next(rn
)) {
2857 rdistance
= rn
->info
;
2859 if (rdistance
== NULL
)
2863 vty_out(vty
, " Address Distance List\n");
2866 snprintfrr(buf
, sizeof(buf
), "%pFX", &rn
->p
);
2867 vty_out(vty
, " %-20s %4d %s\n", buf
, rdistance
->distance
,
2868 rdistance
->access_list
? rdistance
->access_list
: "");
2872 /* Update ECMP routes to zebra when ECMP is disabled. */
2873 void rip_ecmp_disable(struct rip
*rip
)
2875 struct route_node
*rp
;
2876 struct rip_info
*rinfo
, *tmp_rinfo
;
2878 struct listnode
*node
, *nextnode
;
2880 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2885 if (listcount(list
) == 0)
2888 rinfo
= listgetdata(listhead(list
));
2889 if (!rip_route_rte(rinfo
))
2892 /* Drop all other entries, except the first one. */
2893 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
2894 if (tmp_rinfo
== rinfo
)
2897 EVENT_OFF(tmp_rinfo
->t_timeout
);
2898 EVENT_OFF(tmp_rinfo
->t_garbage_collect
);
2899 list_delete_node(list
, node
);
2900 rip_info_free(tmp_rinfo
);
2904 rip_zebra_ipv4_add(rip
, rp
);
2906 /* Set the route change flag. */
2907 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2909 /* Signal the output process to trigger an update. */
2910 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2914 /* Print out routes update time. */
2915 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
2920 char timebuf
[TIME_BUF
];
2921 struct event
*thread
;
2923 if ((thread
= rinfo
->t_timeout
) != NULL
) {
2924 clock
= event_timer_remain_second(thread
);
2925 gmtime_r(&clock
, &tm
);
2926 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2927 vty_out(vty
, "%5s", timebuf
);
2928 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
2929 clock
= event_timer_remain_second(thread
);
2930 gmtime_r(&clock
, &tm
);
2931 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2932 vty_out(vty
, "%5s", timebuf
);
2936 static const char *rip_route_type_print(int sub_type
)
2941 case RIP_ROUTE_STATIC
:
2943 case RIP_ROUTE_DEFAULT
:
2945 case RIP_ROUTE_REDISTRIBUTE
:
2947 case RIP_ROUTE_INTERFACE
:
2956 "show ip rip [vrf NAME]",
2963 struct route_node
*np
;
2964 struct rip_info
*rinfo
= NULL
;
2965 struct list
*list
= NULL
;
2966 struct listnode
*listnode
= NULL
;
2967 const char *vrf_name
;
2970 if (argv_find(argv
, argc
, "vrf", &idx
))
2971 vrf_name
= argv
[idx
+ 1]->arg
;
2973 vrf_name
= VRF_DEFAULT_NAME
;
2975 rip
= rip_lookup_by_vrf_name(vrf_name
);
2977 vty_out(vty
, "%% RIP instance not found\n");
2980 if (!rip
->enabled
) {
2981 vty_out(vty
, "%% RIP instance is disabled\n");
2986 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
2988 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
2989 " (i) - interface\n\n"
2990 " Network Next Hop Metric From Tag Time\n");
2992 for (np
= route_top(rip
->table
); np
; np
= route_next(np
)) {
2998 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3001 len
= vty_out(vty
, "%c(%s) %pFX",
3002 /* np->lock, For debugging. */
3003 zebra_route_char(rinfo
->type
),
3004 rip_route_type_print(rinfo
->sub_type
),
3010 vty_out(vty
, "%*s", len
, " ");
3012 switch (rinfo
->nh
.type
) {
3013 case NEXTHOP_TYPE_IPV4
:
3014 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3015 vty_out(vty
, "%-20pI4 %2d ",
3016 &rinfo
->nh
.gate
.ipv4
, rinfo
->metric
);
3018 case NEXTHOP_TYPE_IFINDEX
:
3019 vty_out(vty
, "0.0.0.0 %2d ",
3022 case NEXTHOP_TYPE_BLACKHOLE
:
3023 vty_out(vty
, "blackhole %2d ",
3026 case NEXTHOP_TYPE_IPV6
:
3027 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3028 vty_out(vty
, "V6 Address Hidden %2d ",
3033 /* Route which exist in kernel routing table. */
3034 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3035 (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3036 vty_out(vty
, "%-15pI4 ", &rinfo
->from
);
3037 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3038 (route_tag_t
)rinfo
->tag
);
3039 rip_vty_out_uptime(vty
, rinfo
);
3040 } else if (rinfo
->metric
== RIP_METRIC_INFINITY
) {
3041 vty_out(vty
, "self ");
3042 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3043 (route_tag_t
)rinfo
->tag
);
3044 rip_vty_out_uptime(vty
, rinfo
);
3046 if (rinfo
->external_metric
) {
3048 vty
, "self (%s:%d)",
3049 zebra_route_string(rinfo
->type
),
3050 rinfo
->external_metric
);
3053 vty_out(vty
, "%*s", len
, " ");
3055 vty_out(vty
, "self ");
3056 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3057 (route_tag_t
)rinfo
->tag
);
3066 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3067 DEFUN (show_ip_rip_status
,
3068 show_ip_rip_status_cmd
,
3069 "show ip rip [vrf NAME] status",
3074 "IP routing protocol process parameters and statistics\n")
3077 struct interface
*ifp
;
3078 struct rip_interface
*ri
;
3079 extern const struct message ri_version_msg
[];
3080 const char *send_version
;
3081 const char *receive_version
;
3082 const char *vrf_name
;
3085 if (argv_find(argv
, argc
, "vrf", &idx
))
3086 vrf_name
= argv
[idx
+ 1]->arg
;
3088 vrf_name
= VRF_DEFAULT_NAME
;
3090 rip
= rip_lookup_by_vrf_name(vrf_name
);
3092 vty_out(vty
, "%% RIP instance not found\n");
3095 if (!rip
->enabled
) {
3096 vty_out(vty
, "%% RIP instance is disabled\n");
3100 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3101 vty_out(vty
, " Sending updates every %u seconds with +/-50%%,",
3103 vty_out(vty
, " next due in %lu seconds\n",
3104 event_timer_remain_second(rip
->t_update
));
3105 vty_out(vty
, " Timeout after %u seconds,", rip
->timeout_time
);
3106 vty_out(vty
, " garbage collect after %u seconds\n", rip
->garbage_time
);
3108 /* Filtering status show. */
3109 config_show_distribute(vty
, rip
->distribute_ctx
);
3111 /* Default metric information. */
3112 vty_out(vty
, " Default redistribution metric is %u\n",
3113 rip
->default_metric
);
3115 /* Redistribute information. */
3116 vty_out(vty
, " Redistributing:");
3117 rip_show_redistribute_config(vty
, rip
);
3120 vty_out(vty
, " Default version control: send version %s,",
3121 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3122 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3123 vty_out(vty
, " receive any version \n");
3125 vty_out(vty
, " receive version %s \n",
3126 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3128 vty_out(vty
, " Interface Send Recv Key-chain\n");
3130 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3136 if (ri
->enable_network
|| ri
->enable_interface
) {
3137 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3139 lookup_msg(ri_version_msg
,
3140 rip
->version_send
, NULL
);
3142 send_version
= lookup_msg(ri_version_msg
,
3145 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3147 lookup_msg(ri_version_msg
,
3148 rip
->version_recv
, NULL
);
3150 receive_version
= lookup_msg(
3151 ri_version_msg
, ri
->ri_receive
, NULL
);
3153 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3154 send_version
, receive_version
,
3155 ri
->key_chain
? ri
->key_chain
: "");
3159 vty_out(vty
, " Routing for Networks:\n");
3160 rip_show_network_config(vty
, rip
);
3162 int found_passive
= 0;
3163 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3166 if ((ri
->enable_network
|| ri
->enable_interface
) &&
3168 if (!found_passive
) {
3169 vty_out(vty
, " Passive Interface(s):\n");
3172 vty_out(vty
, " %s\n", ifp
->name
);
3176 vty_out(vty
, " Routing Information Sources:\n");
3178 " Gateway BadPackets BadRoutes Distance Last Update\n");
3179 rip_peer_display(vty
, rip
);
3181 rip_distance_show(vty
, rip
);
3186 /* RIP configuration write function. */
3187 static int config_write_rip(struct vty
*vty
)
3192 RB_FOREACH(rip
, rip_instance_head
, &rip_instances
) {
3193 char xpath
[XPATH_MAXLEN
];
3194 struct lyd_node
*dnode
;
3196 snprintf(xpath
, sizeof(xpath
),
3197 "/frr-ripd:ripd/instance[vrf='%s']", rip
->vrf_name
);
3199 dnode
= yang_dnode_get(running_config
->dnode
, xpath
);
3202 nb_cli_show_dnode_cmds(vty
, dnode
, false);
3204 /* Distribute configuration. */
3205 config_write_distribute(vty
, rip
->distribute_ctx
);
3207 vty_out(vty
, "exit\n");
3215 static int config_write_rip(struct vty
*vty
);
3216 /* RIP node structure. */
3217 static struct cmd_node rip_node
= {
3220 .parent_node
= CONFIG_NODE
,
3221 .prompt
= "%s(config-router)# ",
3222 .config_write
= config_write_rip
,
3225 /* Distribute-list update functions. */
3226 static void rip_distribute_update(struct distribute_ctx
*ctx
,
3227 struct distribute
*dist
)
3229 struct interface
*ifp
;
3230 struct rip_interface
*ri
;
3231 struct access_list
*alist
;
3232 struct prefix_list
*plist
;
3234 if (!ctx
->vrf
|| !dist
->ifname
)
3237 ifp
= if_lookup_by_name(dist
->ifname
, ctx
->vrf
->vrf_id
);
3243 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3244 alist
= access_list_lookup(AFI_IP
,
3245 dist
->list
[DISTRIBUTE_V4_IN
]);
3247 ri
->list
[RIP_FILTER_IN
] = alist
;
3249 ri
->list
[RIP_FILTER_IN
] = NULL
;
3251 ri
->list
[RIP_FILTER_IN
] = NULL
;
3253 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3254 alist
= access_list_lookup(AFI_IP
,
3255 dist
->list
[DISTRIBUTE_V4_OUT
]);
3257 ri
->list
[RIP_FILTER_OUT
] = alist
;
3259 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3261 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3263 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3264 plist
= prefix_list_lookup(AFI_IP
,
3265 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3267 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3269 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3271 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3273 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3274 plist
= prefix_list_lookup(AFI_IP
,
3275 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3277 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3279 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3281 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3284 void rip_distribute_update_interface(struct interface
*ifp
)
3286 struct rip_interface
*ri
= ifp
->info
;
3287 struct rip
*rip
= ri
->rip
;
3288 struct distribute
*dist
;
3292 dist
= distribute_lookup(rip
->distribute_ctx
, ifp
->name
);
3294 rip_distribute_update(rip
->distribute_ctx
, dist
);
3297 /* Update all interface's distribute list. */
3299 static void rip_distribute_update_all(struct prefix_list
*notused
)
3301 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3302 struct interface
*ifp
;
3304 FOR_ALL_INTERFACES (vrf
, ifp
)
3305 rip_distribute_update_interface(ifp
);
3308 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3310 rip_distribute_update_all(NULL
);
3313 /* Delete all added rip route. */
3314 void rip_clean(struct rip
*rip
)
3316 rip_interfaces_clean(rip
);
3319 rip_instance_disable(rip
);
3321 stream_free(rip
->obuf
);
3323 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3324 if (rip
->redist
[i
].route_map
.name
)
3325 free(rip
->redist
[i
].route_map
.name
);
3327 route_table_finish(rip
->table
);
3328 route_table_finish(rip
->neighbor
);
3329 list_delete(&rip
->peer_list
);
3330 distribute_list_delete(&rip
->distribute_ctx
);
3331 if_rmap_ctx_delete(rip
->if_rmap_ctx
);
3333 rip_clean_network(rip
);
3334 rip_passive_nondefault_clean(rip
);
3335 vector_free(rip
->enable_interface
);
3336 route_table_finish(rip
->enable_network
);
3337 vector_free(rip
->passive_nondefault
);
3338 list_delete(&rip
->offset_list_master
);
3339 route_table_finish(rip
->distance_table
);
3341 RB_REMOVE(rip_instance_head
, &rip_instances
, rip
);
3342 XFREE(MTYPE_RIP_VRF_NAME
, rip
->vrf_name
);
3343 XFREE(MTYPE_RIP
, rip
);
3346 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
3347 struct if_rmap
*if_rmap
)
3349 struct interface
*ifp
= NULL
;
3350 struct rip_interface
*ri
;
3351 struct route_map
*rmap
;
3352 struct vrf
*vrf
= NULL
;
3355 vrf
= vrf_lookup_by_name(ctx
->name
);
3357 ifp
= if_lookup_by_name(if_rmap
->ifname
, vrf
->vrf_id
);
3362 if (if_rmap
->routemap
[IF_RMAP_IN
]) {
3363 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_IN
]);
3365 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3367 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3369 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3371 if (if_rmap
->routemap
[IF_RMAP_OUT
]) {
3372 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_OUT
]);
3374 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3376 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3378 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3381 void rip_if_rmap_update_interface(struct interface
*ifp
)
3383 struct rip_interface
*ri
= ifp
->info
;
3384 struct rip
*rip
= ri
->rip
;
3385 struct if_rmap
*if_rmap
;
3386 struct if_rmap_ctx
*ctx
;
3390 ctx
= rip
->if_rmap_ctx
;
3393 if_rmap
= if_rmap_lookup(ctx
, ifp
->name
);
3395 rip_if_rmap_update(ctx
, if_rmap
);
3398 static void rip_routemap_update_redistribute(struct rip
*rip
)
3400 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3401 if (rip
->redist
[i
].route_map
.name
) {
3402 rip
->redist
[i
].route_map
.map
= route_map_lookup_by_name(
3403 rip
->redist
[i
].route_map
.name
);
3404 route_map_counter_increment(
3405 rip
->redist
[i
].route_map
.map
);
3411 static void rip_routemap_update(const char *notused
)
3413 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3415 struct interface
*ifp
;
3417 FOR_ALL_INTERFACES (vrf
, ifp
)
3418 rip_if_rmap_update_interface(ifp
);
3422 rip_routemap_update_redistribute(rip
);
3425 /* Link RIP instance to VRF. */
3426 static void rip_vrf_link(struct rip
*rip
, struct vrf
*vrf
)
3428 struct interface
*ifp
;
3431 rip
->distribute_ctx
->vrf
= vrf
;
3434 FOR_ALL_INTERFACES (vrf
, ifp
)
3435 rip_interface_sync(ifp
);
3438 /* Unlink RIP instance from VRF. */
3439 static void rip_vrf_unlink(struct rip
*rip
, struct vrf
*vrf
)
3441 struct interface
*ifp
;
3444 rip
->distribute_ctx
->vrf
= NULL
;
3447 FOR_ALL_INTERFACES (vrf
, ifp
)
3448 rip_interface_sync(ifp
);
3451 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
)
3455 rip_vrf_link(rip
, vrf
);
3456 rip
->enabled
= true;
3458 /* Resend all redistribute requests. */
3459 rip_redistribute_enable(rip
);
3461 /* Create read and timer thread. */
3462 rip_event(rip
, RIP_READ
, rip
->sock
);
3463 rip_event(rip
, RIP_UPDATE_EVENT
, 1);
3465 rip_zebra_vrf_register(vrf
);
3468 static void rip_instance_disable(struct rip
*rip
)
3470 struct vrf
*vrf
= rip
->vrf
;
3471 struct route_node
*rp
;
3473 /* Clear RIP routes */
3474 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
3475 struct rip_info
*rinfo
;
3477 struct listnode
*listnode
;
3479 if ((list
= rp
->info
) == NULL
)
3482 rinfo
= listgetdata(listhead(list
));
3483 if (rip_route_rte(rinfo
))
3484 rip_zebra_ipv4_delete(rip
, rp
);
3486 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3487 EVENT_OFF(rinfo
->t_timeout
);
3488 EVENT_OFF(rinfo
->t_garbage_collect
);
3489 rip_info_free(rinfo
);
3493 route_unlock_node(rp
);
3496 /* Flush all redistribute requests. */
3497 rip_redistribute_disable(rip
);
3499 /* Cancel RIP related timers. */
3500 EVENT_OFF(rip
->t_update
);
3501 EVENT_OFF(rip
->t_triggered_update
);
3502 EVENT_OFF(rip
->t_triggered_interval
);
3504 /* Cancel read thread. */
3505 EVENT_OFF(rip
->t_read
);
3507 /* Close RIP socket. */
3511 /* Clear existing peers. */
3512 list_delete_all_node(rip
->peer_list
);
3514 rip_zebra_vrf_deregister(vrf
);
3516 rip_vrf_unlink(rip
, vrf
);
3517 rip
->enabled
= false;
3520 static int rip_vrf_new(struct vrf
*vrf
)
3522 if (IS_RIP_DEBUG_EVENT
)
3523 zlog_debug("%s: VRF created: %s(%u)", __func__
, vrf
->name
,
3529 static int rip_vrf_delete(struct vrf
*vrf
)
3533 if (IS_RIP_DEBUG_EVENT
)
3534 zlog_debug("%s: VRF deleted: %s(%u)", __func__
, vrf
->name
,
3537 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3546 static int rip_vrf_enable(struct vrf
*vrf
)
3551 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3552 if (!rip
|| rip
->enabled
)
3555 if (IS_RIP_DEBUG_EVENT
)
3556 zlog_debug("%s: VRF %s(%u) enabled", __func__
, vrf
->name
,
3559 /* Activate the VRF RIP instance. */
3560 if (!rip
->enabled
) {
3561 socket
= rip_create_socket(vrf
);
3565 rip_instance_enable(rip
, vrf
, socket
);
3571 static int rip_vrf_disable(struct vrf
*vrf
)
3575 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3576 if (!rip
|| !rip
->enabled
)
3579 if (IS_RIP_DEBUG_EVENT
)
3580 zlog_debug("%s: VRF %s(%u) disabled", __func__
, vrf
->name
,
3583 /* Deactivate the VRF RIP instance. */
3585 rip_instance_disable(rip
);
3590 void rip_vrf_init(void)
3592 vrf_init(rip_vrf_new
, rip_vrf_enable
, rip_vrf_disable
, rip_vrf_delete
);
3597 void rip_vrf_terminate(void)
3602 /* Allocate new rip structure and set default value. */
3605 /* Install top nodes. */
3606 install_node(&rip_node
);
3608 /* Install rip commands. */
3609 install_element(VIEW_NODE
, &show_ip_rip_cmd
);
3610 install_element(VIEW_NODE
, &show_ip_rip_status_cmd
);
3612 install_default(RIP_NODE
);
3614 /* Debug related init. */
3617 /* Access list install. */
3619 access_list_add_hook(rip_distribute_update_all_wrapper
);
3620 access_list_delete_hook(rip_distribute_update_all_wrapper
);
3622 /* Prefix list initialize.*/
3624 prefix_list_add_hook(rip_distribute_update_all
);
3625 prefix_list_delete_hook(rip_distribute_update_all
);
3628 rip_route_map_init();
3630 route_map_add_hook(rip_routemap_update
);
3631 route_map_delete_hook(rip_routemap_update
);
3633 if_rmap_init(RIP_NODE
);