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
, ri
, 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
, ri
, 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
, ri
, 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 if (packet
->version
== RIPv1
&& rte
->tag
!= 0) {
1175 zlog_warn("RIPv1 reserved field is nonzero: %d",
1180 /* - is the destination address valid (e.g., unicast; not net 0
1182 if (!rip_destination_check(rte
->prefix
)) {
1184 "Network is net 0 or net 127 or it is not unicast network");
1185 rip_peer_bad_route(rip
, ri
, from
);
1189 /* Convert metric value to host byte order. */
1190 rte
->metric
= ntohl(rte
->metric
);
1192 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1193 if (!(rte
->metric
>= 1 && rte
->metric
<= 16)) {
1194 zlog_info("Route's metric is not in the 1-16 range.");
1195 rip_peer_bad_route(rip
, ri
, from
);
1199 /* RIPv1 does not have nexthop value. */
1200 if (packet
->version
== RIPv1
1201 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1202 zlog_info("RIPv1 packet with nexthop value %pI4",
1204 rip_peer_bad_route(rip
, ri
, from
);
1208 /* That is, if the provided information is ignored, a possibly
1209 sub-optimal, but absolutely valid, route may be taken. If
1210 the received Next Hop is not directly reachable, it should be
1211 treated as 0.0.0.0. */
1212 if (packet
->version
== RIPv2
1213 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1216 /* Multicast address check. */
1217 addrval
= ntohl(rte
->nexthop
.s_addr
);
1218 if (IN_CLASSD(addrval
)) {
1220 "Nexthop %pI4 is multicast address, skip this rte",
1225 if (!if_lookup_address((void *)&rte
->nexthop
, AF_INET
,
1226 rip
->vrf
->vrf_id
)) {
1227 struct route_node
*rn
;
1228 struct rip_info
*rinfo
;
1230 rn
= route_node_match_ipv4(rip
->table
,
1236 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1239 if (IS_RIP_DEBUG_EVENT
)
1241 "Next hop %pI4 is on RIP network. Set nexthop to the packet's originator",
1243 rte
->nexthop
= rinfo
->from
;
1245 if (IS_RIP_DEBUG_EVENT
)
1247 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1249 rte
->nexthop
.s_addr
=
1253 route_unlock_node(rn
);
1255 if (IS_RIP_DEBUG_EVENT
)
1257 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1259 rte
->nexthop
.s_addr
= INADDR_ANY
;
1264 /* For RIPv1, there won't be a valid netmask.
1265 * This is a best guess at the masks. If everyone was using old
1266 * Ciscos before the 'ip subnet zero' option, it would be almost
1269 * Cisco summarize ripv1 advertisements to the classful boundary
1270 * (/16 for class B's) except when the RIP packet does to inside
1271 * the classful network in question.
1273 if ((packet
->version
== RIPv1
1274 && rte
->prefix
.s_addr
!= INADDR_ANY
)
1275 || (packet
->version
== RIPv2
1276 && (rte
->prefix
.s_addr
!= INADDR_ANY
1277 && rte
->mask
.s_addr
== INADDR_ANY
))) {
1278 uint32_t destination
;
1280 if (subnetted
== -1) {
1281 memcpy(&ifaddr
, ifc
->address
, sizeof(ifaddr
));
1282 memcpy(&ifaddrclass
, &ifaddr
,
1283 sizeof(ifaddrclass
));
1284 apply_classful_mask_ipv4(&ifaddrclass
);
1286 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1290 destination
= ntohl(rte
->prefix
.s_addr
);
1292 if (IN_CLASSA(destination
))
1293 masklen2ip(8, &rte
->mask
);
1294 else if (IN_CLASSB(destination
))
1295 masklen2ip(16, &rte
->mask
);
1296 else if (IN_CLASSC(destination
))
1297 masklen2ip(24, &rte
->mask
);
1300 masklen2ip(ifaddrclass
.prefixlen
,
1301 (struct in_addr
*)&destination
);
1302 if ((subnetted
== 1)
1303 && ((rte
->prefix
.s_addr
& destination
)
1304 == ifaddrclass
.prefix
.s_addr
)) {
1305 masklen2ip(ifaddr
.prefixlen
, &rte
->mask
);
1306 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1307 != rte
->prefix
.s_addr
)
1308 masklen2ip(32, &rte
->mask
);
1309 if (IS_RIP_DEBUG_EVENT
)
1310 zlog_debug("Subnetted route %pI4",
1313 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1314 != rte
->prefix
.s_addr
)
1318 if (IS_RIP_DEBUG_EVENT
) {
1319 zlog_debug("Resultant route %pI4",
1321 zlog_debug("Resultant mask %pI4",
1326 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1327 ignore the entry. */
1328 if ((packet
->version
== RIPv2
)
1329 && (rte
->mask
.s_addr
!= INADDR_ANY
)
1330 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1331 != rte
->prefix
.s_addr
)) {
1333 "RIPv2 address %pI4 is not mask /%d applied one",
1334 &rte
->prefix
, ip_masklen(rte
->mask
));
1335 rip_peer_bad_route(rip
, ri
, from
);
1339 /* Default route's netmask is ignored. */
1340 if (packet
->version
== RIPv2
1341 && (rte
->prefix
.s_addr
== INADDR_ANY
)
1342 && (rte
->mask
.s_addr
!= INADDR_ANY
)) {
1343 if (IS_RIP_DEBUG_EVENT
)
1345 "Default route with non-zero netmask. Set zero to netmask");
1346 rte
->mask
.s_addr
= INADDR_ANY
;
1349 /* Routing table updates. */
1350 rip_rte_process(rte
, from
, ifc
->ifp
);
1354 /* Make socket for RIP protocol. */
1355 int rip_create_socket(struct vrf
*vrf
)
1359 struct sockaddr_in addr
;
1360 const char *vrf_dev
= NULL
;
1362 memset(&addr
, 0, sizeof(struct sockaddr_in
));
1363 addr
.sin_family
= AF_INET
;
1364 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1365 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1366 addr
.sin_len
= sizeof(struct sockaddr_in
);
1367 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1368 /* sending port must always be the RIP port */
1369 addr
.sin_port
= htons(RIP_PORT_DEFAULT
);
1371 /* Make datagram socket. */
1372 if (vrf
->vrf_id
!= VRF_DEFAULT
)
1373 vrf_dev
= vrf
->name
;
1374 frr_with_privs(&ripd_privs
) {
1375 sock
= vrf_socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, vrf
->vrf_id
,
1378 flog_err_sys(EC_LIB_SOCKET
,
1379 "Cannot create UDP socket: %s",
1380 safe_strerror(errno
));
1385 sockopt_broadcast(sock
);
1386 sockopt_reuseaddr(sock
);
1387 sockopt_reuseport(sock
);
1388 setsockopt_ipv4_multicast_loop(sock
, 0);
1389 #ifdef IPTOS_PREC_INTERNETCONTROL
1390 setsockopt_ipv4_tos(sock
, IPTOS_PREC_INTERNETCONTROL
);
1392 setsockopt_so_recvbuf(sock
, RIP_UDP_RCV_BUF
);
1394 frr_with_privs(&ripd_privs
) {
1395 if ((ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
)))
1397 zlog_err("%s: Can't bind socket %d to %pI4 port %d: %s",
1398 __func__
, sock
, &addr
.sin_addr
,
1399 (int)ntohs(addr
.sin_port
),
1400 safe_strerror(errno
));
1410 /* RIP packet send to destination address, on interface denoted by
1411 * by connected argument. NULL to argument denotes destination should be
1412 * should be RIP multicast group
1414 static int rip_send_packet(uint8_t *buf
, int size
, struct sockaddr_in
*to
,
1415 struct connected
*ifc
)
1417 struct rip_interface
*ri
;
1420 struct sockaddr_in sin
;
1424 struct cmsghdr
*cmsgptr
;
1425 char adata
[256] = {};
1426 struct in_pktinfo
*pkt
;
1427 #endif /* GNU_LINUX */
1429 assert(ifc
!= NULL
);
1430 ri
= ifc
->ifp
->info
;
1433 if (IS_RIP_DEBUG_PACKET
) {
1434 #define ADDRESS_SIZE 20
1435 char dst
[ADDRESS_SIZE
];
1438 inet_ntop(AF_INET
, &to
->sin_addr
, dst
, sizeof(dst
));
1440 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1441 inet_ntop(AF_INET
, &sin
.sin_addr
, dst
, sizeof(dst
));
1444 zlog_debug("%s %pI4 > %s (%s)", __func__
,
1445 &ifc
->address
->u
.prefix4
, dst
, ifc
->ifp
->name
);
1448 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
)) {
1450 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1451 * configured with multiple addresses on the same
1452 * subnet: the first address on the subnet is configured
1453 * "primary", and all subsequent addresses on that subnet
1454 * are treated as "secondary" addresses. In order to avoid
1455 * routing-table bloat on other rip listeners, we do not send
1456 * out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
1457 * XXX Since Linux is the only system for which the
1458 * ZEBRA_IFA_SECONDARY flag is set, we would end up
1459 * sending a packet for a "secondary" source address on
1460 * non-linux systems.
1462 if (IS_RIP_DEBUG_PACKET
)
1463 zlog_debug("duplicate dropped");
1467 /* Make destination address. */
1468 memset(&sin
, 0, sizeof(sin
));
1469 sin
.sin_family
= AF_INET
;
1470 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1471 sin
.sin_len
= sizeof(struct sockaddr_in
);
1472 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1474 /* When destination is specified, use it's port and address. */
1476 sin
.sin_port
= to
->sin_port
;
1477 sin
.sin_addr
= to
->sin_addr
;
1479 sin
.sin_port
= htons(RIP_PORT_DEFAULT
);
1480 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1482 rip_interface_multicast_set(rip
->sock
, ifc
);
1485 memset(&msg
, 0, sizeof(msg
));
1486 msg
.msg_name
= (void *)&sin
;
1487 msg
.msg_namelen
= sizeof(struct sockaddr_in
);
1494 msg
.msg_control
= (void *)adata
;
1495 msg
.msg_controllen
= CMSG_SPACE(sizeof(struct in_pktinfo
));
1497 cmsgptr
= (struct cmsghdr
*)adata
;
1498 cmsgptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_pktinfo
));
1499 cmsgptr
->cmsg_level
= IPPROTO_IP
;
1500 cmsgptr
->cmsg_type
= IP_PKTINFO
;
1501 pkt
= (struct in_pktinfo
*)CMSG_DATA(cmsgptr
);
1502 pkt
->ipi_ifindex
= ifc
->ifp
->ifindex
;
1503 pkt
->ipi_spec_dst
.s_addr
= ifc
->address
->u
.prefix4
.s_addr
;
1504 #endif /* GNU_LINUX */
1506 ret
= sendmsg(rip
->sock
, &msg
, 0);
1508 if (IS_RIP_DEBUG_EVENT
)
1509 zlog_debug("SEND to %pI4 port %d", &sin
.sin_addr
,
1510 ntohs(sin
.sin_port
));
1513 zlog_warn("can't send packet : %s", safe_strerror(errno
));
1518 /* Add redistributed route to RIP table. */
1519 void rip_redistribute_add(struct rip
*rip
, int type
, int sub_type
,
1520 struct prefix_ipv4
*p
, struct nexthop
*nh
,
1521 unsigned int metric
, unsigned char distance
,
1525 struct route_node
*rp
= NULL
;
1526 struct rip_info
*rinfo
= NULL
, newinfo
;
1527 struct list
*list
= NULL
;
1529 /* Redistribute route */
1530 ret
= rip_destination_check(p
->prefix
);
1534 rp
= route_node_get(rip
->table
, (struct prefix
*)p
);
1536 memset(&newinfo
, 0, sizeof(newinfo
));
1537 newinfo
.type
= type
;
1538 newinfo
.sub_type
= sub_type
;
1540 newinfo
.external_metric
= metric
;
1541 newinfo
.distance
= distance
;
1542 if (tag
<= UINT16_MAX
) /* RIP only supports 16 bit tags */
1547 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
1548 rinfo
= listgetdata(listhead(list
));
1550 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1551 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1552 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
1553 route_unlock_node(rp
);
1557 /* Manually configured RIP route check. */
1558 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1559 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
1560 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))) {
1561 if (type
!= ZEBRA_ROUTE_RIP
1562 || ((sub_type
!= RIP_ROUTE_STATIC
)
1563 && (sub_type
!= RIP_ROUTE_DEFAULT
))) {
1564 route_unlock_node(rp
);
1569 (void)rip_ecmp_replace(rip
, &newinfo
);
1570 route_unlock_node(rp
);
1572 (void)rip_ecmp_add(rip
, &newinfo
);
1574 if (IS_RIP_DEBUG_EVENT
) {
1575 zlog_debug("Redistribute new prefix %pFX", p
);
1578 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1581 /* Delete redistributed route from RIP table. */
1582 void rip_redistribute_delete(struct rip
*rip
, int type
, int sub_type
,
1583 struct prefix_ipv4
*p
, ifindex_t ifindex
)
1586 struct route_node
*rp
;
1587 struct rip_info
*rinfo
;
1589 ret
= rip_destination_check(p
->prefix
);
1593 rp
= route_node_lookup(rip
->table
, (struct prefix
*)p
);
1595 struct list
*list
= rp
->info
;
1597 if (list
!= NULL
&& listcount(list
) != 0) {
1598 rinfo
= listgetdata(listhead(list
));
1599 if (rinfo
!= NULL
&& rinfo
->type
== type
1600 && rinfo
->sub_type
== sub_type
1601 && rinfo
->nh
.ifindex
== ifindex
) {
1602 /* Perform poisoned reverse. */
1603 rinfo
->metric
= RIP_METRIC_INFINITY
;
1604 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
1605 rip_garbage_collect
,
1607 EVENT_OFF(rinfo
->t_timeout
);
1608 rinfo
->flags
|= RIP_RTF_CHANGED
;
1610 if (IS_RIP_DEBUG_EVENT
)
1612 "Poison %pFX on the interface %s with an infinity metric [delete]",
1618 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1621 route_unlock_node(rp
);
1625 /* Response to request called from rip_read ().*/
1626 static void rip_request_process(struct rip_packet
*packet
, int size
,
1627 struct sockaddr_in
*from
, struct connected
*ifc
)
1632 struct prefix_ipv4 p
;
1633 struct route_node
*rp
;
1634 struct rip_info
*rinfo
;
1635 struct rip_interface
*ri
;
1637 /* Does not reponse to the requests on the loopback interfaces */
1638 if (if_is_loopback(ifc
->ifp
))
1641 /* Check RIP process is enabled on this interface. */
1642 ri
= ifc
->ifp
->info
;
1647 /* When passive interface is specified, suppress responses */
1651 /* RIP peer update. */
1652 rip_peer_update(rip
, ri
, from
, packet
->version
);
1654 lim
= ((caddr_t
)packet
) + size
;
1657 /* The Request is processed entry by entry. If there are no
1658 entries, no response is given. */
1659 if (lim
== (caddr_t
)rte
)
1662 /* There is one special case. If there is exactly one entry in the
1663 request, and it has an address family identifier of zero and a
1664 metric of infinity (i.e., 16), then this is a request to send the
1665 entire routing table. */
1666 if (lim
== ((caddr_t
)(rte
+ 1)) && ntohs(rte
->family
) == 0
1667 && ntohl(rte
->metric
) == RIP_METRIC_INFINITY
) {
1668 /* All route with split horizon */
1669 rip_output_process(ifc
, from
, rip_all_route
, packet
->version
);
1671 if (ntohs(rte
->family
) != AF_INET
)
1674 /* Examine the list of RTEs in the Request one by one. For each
1675 entry, look up the destination in the router's routing
1676 database and, if there is a route, put that route's metric in
1677 the metric field of the RTE. If there is no explicit route
1678 to the specified destination, put infinity in the metric
1679 field. Once all the entries have been filled in, change the
1680 command from Request to Response and send the datagram back
1681 to the requestor. */
1684 for (; ((caddr_t
)rte
) < lim
; rte
++) {
1685 p
.prefix
= rte
->prefix
;
1686 p
.prefixlen
= ip_masklen(rte
->mask
);
1687 apply_mask_ipv4(&p
);
1689 rp
= route_node_lookup(rip
->table
, (struct prefix
*)&p
);
1691 rinfo
= listgetdata(
1692 listhead((struct list
*)rp
->info
));
1693 rte
->metric
= htonl(rinfo
->metric
);
1694 route_unlock_node(rp
);
1696 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
1698 packet
->command
= RIP_RESPONSE
;
1700 (void)rip_send_packet((uint8_t *)packet
, size
, from
, ifc
);
1702 rip
->counters
.queries
++;
1705 /* First entry point of RIP packet. */
1706 static void rip_read(struct event
*t
)
1708 struct rip
*rip
= EVENT_ARG(t
);
1712 union rip_buf rip_buf
;
1713 struct rip_packet
*packet
;
1714 struct sockaddr_in from
;
1718 struct interface
*ifp
= NULL
;
1719 struct connected
*ifc
;
1720 struct rip_interface
*ri
= NULL
;
1723 /* Fetch socket then register myself. */
1726 /* Add myself to tne next event */
1727 rip_event(rip
, RIP_READ
, sock
);
1729 /* RIPd manages only IPv4. */
1730 memset(&from
, 0, sizeof(from
));
1731 fromlen
= sizeof(struct sockaddr_in
);
1733 len
= recvfrom(sock
, (char *)&rip_buf
.buf
, sizeof(rip_buf
.buf
), 0,
1734 (struct sockaddr
*)&from
, &fromlen
);
1736 zlog_info("recvfrom failed (VRF %s): %s", rip
->vrf_name
,
1737 safe_strerror(errno
));
1741 /* Check is this packet comming from myself? */
1742 if (if_check_address(rip
, from
.sin_addr
)) {
1743 if (IS_RIP_DEBUG_PACKET
)
1744 zlog_debug("ignore packet comes from myself (VRF %s)",
1749 /* Which interface is this packet comes from. */
1750 ifc
= if_lookup_address((void *)&from
.sin_addr
, AF_INET
,
1757 /* RIP packet received */
1758 if (IS_RIP_DEBUG_EVENT
)
1759 zlog_debug("RECV packet from %pI4 port %d on %s (VRF %s)",
1760 &from
.sin_addr
, ntohs(from
.sin_port
),
1761 ifp
? ifp
->name
: "unknown", rip
->vrf_name
);
1763 /* If this packet come from unknown interface, ignore it. */
1764 if (ifp
== NULL
|| ri
== NULL
) {
1766 "%s: cannot find interface for packet from %pI4 port %d (VRF %s)",
1767 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1773 p
.u
.prefix4
= from
.sin_addr
;
1774 p
.prefixlen
= IPV4_MAX_BITLEN
;
1776 ifc
= connected_lookup_prefix(ifp
, &p
);
1780 "%s: cannot find connected address for packet from %pI4 port %d on interface %s (VRF %s)",
1781 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1782 ifp
->name
, rip
->vrf_name
);
1786 /* Packet length check. */
1787 if (len
< RIP_PACKET_MINSIZ
) {
1788 zlog_warn("packet size %d is smaller than minimum size %d", len
,
1790 rip_peer_bad_packet(rip
, ri
, &from
);
1793 if (len
> RIP_PACKET_MAXSIZ
) {
1794 zlog_warn("packet size %d is larger than max size %d", len
,
1796 rip_peer_bad_packet(rip
, ri
, &from
);
1800 /* Packet alignment check. */
1801 if ((len
- RIP_PACKET_MINSIZ
) % 20) {
1802 zlog_warn("packet size %d is wrong for RIP packet alignment",
1804 rip_peer_bad_packet(rip
, ri
, &from
);
1808 /* Set RTE number. */
1809 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1811 /* For easy to handle. */
1812 packet
= &rip_buf
.rip_packet
;
1814 /* RIP version check. */
1815 if (packet
->version
== 0) {
1816 zlog_info("version 0 with command %d received.",
1818 rip_peer_bad_packet(rip
, ri
, &from
);
1822 /* Dump RIP packet. */
1823 if (IS_RIP_DEBUG_RECV
)
1824 rip_packet_dump(packet
, len
, "RECV");
1826 /* RIP version adjust. This code should rethink now. RFC1058 says
1827 that "Version 1 implementations are to ignore this extra data and
1828 process only the fields specified in this document.". So RIPv3
1829 packet should be treated as RIPv1 ignoring must be zero field. */
1830 if (packet
->version
> RIPv2
)
1831 packet
->version
= RIPv2
;
1833 /* Is RIP running or is this RIP neighbor ?*/
1834 if (!ri
->running
&& !rip_neighbor_lookup(rip
, &from
)) {
1835 if (IS_RIP_DEBUG_EVENT
)
1836 zlog_debug("RIP is not enabled on interface %s.",
1838 rip_peer_bad_packet(rip
, ri
, &from
);
1842 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1843 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ? rip
->version_recv
1845 if (vrecv
== RI_RIP_VERSION_NONE
1846 || ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1847 || ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))) {
1848 if (IS_RIP_DEBUG_PACKET
)
1850 " packet's v%d doesn't fit to if version spec",
1852 rip_peer_bad_packet(rip
, ri
, &from
);
1856 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1857 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1858 accepted; authenticated RIP-2 messages shall be discarded. */
1859 if ((ri
->auth_type
== RIP_NO_AUTH
) && rtenum
1860 && (packet
->version
== RIPv2
)
1861 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
))) {
1862 if (IS_RIP_DEBUG_EVENT
)
1864 "packet RIPv%d is dropped because authentication disabled",
1866 ripd_notif_send_auth_type_failure(ifp
->name
);
1867 rip_peer_bad_packet(rip
, ri
, &from
);
1872 If the router is configured to authenticate RIP-2 messages, then
1873 RIP-1 messages and RIP-2 messages which pass authentication
1874 testing shall be accepted; unauthenticated and failed
1875 authentication RIP-2 messages shall be discarded. For maximum
1876 security, RIP-1 messages should be ignored when authentication is
1877 in use (see section 4.1); otherwise, the routing information from
1878 authenticated messages will be propagated by RIP-1 routers in an
1879 unauthenticated manner.
1881 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1882 * always reply regardless of authentication settings, because:
1884 * - if there other authorised routers on-link, the REQUESTor can
1885 * passively obtain the routing updates anyway
1886 * - if there are no other authorised routers on-link, RIP can
1887 * easily be disabled for the link to prevent giving out information
1888 * on state of this routers RIP routing table..
1890 * I.e. if RIPv1 has any place anymore these days, it's as a very
1891 * simple way to distribute routing information (e.g. to embedded
1892 * hosts / appliances) and the ability to give out RIPv1
1893 * routing-information freely, while still requiring RIPv2
1894 * authentication for any RESPONSEs might be vaguely useful.
1896 if (ri
->auth_type
!= RIP_NO_AUTH
&& packet
->version
== RIPv1
) {
1897 /* Discard RIPv1 messages other than REQUESTs */
1898 if (packet
->command
!= RIP_REQUEST
) {
1899 if (IS_RIP_DEBUG_PACKET
)
1901 "RIPv1 dropped because authentication enabled");
1902 ripd_notif_send_auth_type_failure(ifp
->name
);
1903 rip_peer_bad_packet(rip
, ri
, &from
);
1906 } else if (ri
->auth_type
!= RIP_NO_AUTH
) {
1907 const char *auth_desc
;
1910 /* There definitely is no authentication in the packet.
1912 if (IS_RIP_DEBUG_PACKET
)
1914 "RIPv2 authentication failed: no auth RTE in packet");
1915 ripd_notif_send_auth_type_failure(ifp
->name
);
1916 rip_peer_bad_packet(rip
, ri
, &from
);
1920 /* First RTE must be an Authentication Family RTE */
1921 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
)) {
1922 if (IS_RIP_DEBUG_PACKET
)
1924 "RIPv2 dropped because authentication enabled");
1925 ripd_notif_send_auth_type_failure(ifp
->name
);
1926 rip_peer_bad_packet(rip
, ri
, &from
);
1930 /* Check RIPv2 authentication. */
1931 switch (ntohs(packet
->rte
->tag
)) {
1932 case RIP_AUTH_SIMPLE_PASSWORD
:
1933 auth_desc
= "simple";
1934 ret
= rip_auth_simple_password(packet
->rte
, &from
, ifp
);
1939 ret
= rip_auth_md5(packet
, &from
, len
, ifp
);
1940 /* Reset RIP packet length to trim MD5 data. */
1946 auth_desc
= "unknown type";
1947 if (IS_RIP_DEBUG_PACKET
)
1949 "RIPv2 Unknown authentication type %d",
1950 ntohs(packet
->rte
->tag
));
1954 if (IS_RIP_DEBUG_PACKET
)
1955 zlog_debug("RIPv2 %s authentication success",
1958 if (IS_RIP_DEBUG_PACKET
)
1959 zlog_debug("RIPv2 %s authentication failure",
1961 ripd_notif_send_auth_failure(ifp
->name
);
1962 rip_peer_bad_packet(rip
, ri
, &from
);
1967 /* Process each command. */
1968 switch (packet
->command
) {
1970 rip_response_process(packet
, len
, &from
, ifc
);
1974 rip_request_process(packet
, len
, &from
, ifc
);
1979 "Obsolete command %s received, please sent it to routed",
1980 lookup_msg(rip_msg
, packet
->command
, NULL
));
1981 rip_peer_bad_packet(rip
, ri
, &from
);
1983 case RIP_POLL_ENTRY
:
1984 zlog_info("Obsolete command %s received",
1985 lookup_msg(rip_msg
, packet
->command
, NULL
));
1986 rip_peer_bad_packet(rip
, ri
, &from
);
1989 zlog_info("Unknown RIP command %d received", packet
->command
);
1990 rip_peer_bad_packet(rip
, ri
, &from
);
1995 /* Write routing table entry to the stream and return next index of
1996 the routing table entry in the stream. */
1997 static int rip_write_rte(int num
, struct stream
*s
, struct prefix_ipv4
*p
,
1998 uint8_t version
, struct rip_info
*rinfo
)
2000 struct in_addr mask
;
2002 /* Write routing table entry. */
2003 if (version
== RIPv1
) {
2004 stream_putw(s
, AF_INET
);
2006 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2007 stream_put_ipv4(s
, 0);
2008 stream_put_ipv4(s
, 0);
2009 stream_putl(s
, rinfo
->metric_out
);
2011 masklen2ip(p
->prefixlen
, &mask
);
2013 stream_putw(s
, AF_INET
);
2014 stream_putw(s
, rinfo
->tag_out
);
2015 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2016 stream_put_ipv4(s
, mask
.s_addr
);
2017 stream_put_ipv4(s
, rinfo
->nexthop_out
.s_addr
);
2018 stream_putl(s
, rinfo
->metric_out
);
2024 /* Send update to the ifp or spcified neighbor. */
2025 void rip_output_process(struct connected
*ifc
, struct sockaddr_in
*to
,
2026 int route_type
, uint8_t version
)
2031 struct route_node
*rp
;
2032 struct rip_info
*rinfo
;
2033 struct rip_interface
*ri
;
2034 struct prefix_ipv4
*p
;
2035 struct prefix_ipv4 classfull
;
2036 struct prefix_ipv4 ifaddrclass
;
2037 struct key
*key
= NULL
;
2038 /* this might need to made dynamic if RIP ever supported auth methods
2039 with larger key string sizes */
2040 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2041 size_t doff
= 0; /* offset of digest offset field */
2045 struct list
*list
= NULL
;
2046 struct listnode
*listnode
= NULL
;
2048 /* Logging output event. */
2049 if (IS_RIP_DEBUG_EVENT
) {
2051 zlog_debug("update routes to neighbor %pI4",
2054 zlog_debug("update routes on interface %s ifindex %d",
2055 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2058 /* Get RIP interface. */
2059 ri
= ifc
->ifp
->info
;
2062 /* Set output stream. */
2065 /* Reset stream and RTE counter. */
2067 rtemax
= RIP_MAX_RTE
;
2069 /* If output interface is in simple password authentication mode, we
2070 need space for authentication data. */
2071 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2074 /* If output interface is in MD5 authentication mode, we need space
2075 for authentication header and data. */
2076 if (ri
->auth_type
== RIP_AUTH_MD5
)
2079 /* If output interface is in simple password authentication mode
2080 and string or keychain is specified we need space for auth. data */
2081 if (ri
->auth_type
!= RIP_NO_AUTH
) {
2082 if (ri
->key_chain
) {
2083 struct keychain
*keychain
;
2085 keychain
= keychain_lookup(ri
->key_chain
);
2087 key
= key_lookup_for_send(keychain
);
2089 /* to be passed to auth functions later */
2090 rip_auth_prepare_str_send(ri
, key
, auth_str
, sizeof(auth_str
));
2091 if (strlen(auth_str
) == 0)
2095 if (version
== RIPv1
) {
2096 memcpy(&ifaddrclass
, ifc
->address
, sizeof(ifaddrclass
));
2097 apply_classful_mask_ipv4(&ifaddrclass
);
2099 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2103 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2109 if (listcount(list
) == 0)
2112 rinfo
= listgetdata(listhead(list
));
2114 * For RIPv1, if we are subnetted, output subnets in our
2115 * network that have the same mask as the output "interface".
2116 * For other networks, only the classfull version is output.
2118 if (version
== RIPv1
) {
2119 p
= (struct prefix_ipv4
*)&rp
->p
;
2121 if (IS_RIP_DEBUG_PACKET
)
2123 "RIPv1 mask check, %pFX considered for output",
2127 prefix_match((struct prefix
*)&ifaddrclass
,
2129 if ((ifc
->address
->prefixlen
!=
2131 (rp
->p
.prefixlen
!= IPV4_MAX_BITLEN
))
2134 memcpy(&classfull
, &rp
->p
,
2135 sizeof(struct prefix_ipv4
));
2136 apply_classful_mask_ipv4(&classfull
);
2137 if (rp
->p
.u
.prefix4
.s_addr
!= INADDR_ANY
&&
2138 classfull
.prefixlen
!= rp
->p
.prefixlen
)
2141 if (IS_RIP_DEBUG_PACKET
)
2143 "RIPv1 mask check, %pFX made it through",
2146 p
= (struct prefix_ipv4
*)&rp
->p
;
2148 /* Apply output filters. */
2149 ret
= rip_filter(RIP_FILTER_OUT
, p
, ri
);
2153 /* Changed route only output. */
2154 if (route_type
== rip_changed_route
&&
2155 (!(rinfo
->flags
& RIP_RTF_CHANGED
)))
2158 /* Split horizon. */
2159 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
) {
2161 * We perform split horizon for RIP and connected
2162 * route. For rip routes, we want to suppress the
2163 * route if we would end up sending the route back on
2164 * the interface that we learned it from, with a
2165 * higher metric. For connected routes, we suppress
2166 * the route if the prefix is a subset of the source
2167 * address that we are going to use for the packet
2168 * (in order to handle the case when multiple subnets
2169 * are configured on the same interface).
2172 struct rip_info
*tmp_rinfo
= NULL
;
2173 struct connected
*tmp_ifc
= NULL
;
2175 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2176 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2177 tmp_rinfo
->nh
.ifindex
==
2178 ifc
->ifp
->ifindex
) {
2183 if (!suppress
&& rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2184 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2186 if (prefix_match((struct prefix
*)p
,
2187 tmp_ifc
->address
)) {
2197 /* Preparation for route-map. */
2198 rinfo
->metric_set
= 0;
2199 rinfo
->nexthop_out
.s_addr
= 0;
2200 rinfo
->metric_out
= rinfo
->metric
;
2201 rinfo
->tag_out
= rinfo
->tag
;
2202 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2204 /* In order to avoid some local loops, if the RIP route has
2205 * a nexthop via this interface, keep the nexthop, otherwise
2206 * set it to 0. The nexthop should not be propagated beyond
2207 * the local broadcast/multicast area in order to avoid an
2208 * IGP multi-level recursive look-up. see (4.4)
2210 if (rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2211 rinfo
->nexthop_out
= rinfo
->nh
.gate
.ipv4
;
2213 /* Interface route-map */
2214 if (ri
->routemap
[RIP_FILTER_OUT
]) {
2215 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_OUT
],
2216 (struct prefix
*)p
, rinfo
);
2218 if (ret
== RMAP_DENYMATCH
) {
2219 if (IS_RIP_DEBUG_PACKET
)
2221 "RIP %pFX is filtered by route-map out",
2227 /* Apply redistribute route map - continue, if deny */
2228 if (rip
->redist
[rinfo
->type
].route_map
.name
&&
2229 rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2230 ret
= route_map_apply(
2231 rip
->redist
[rinfo
->type
].route_map
.map
,
2232 (struct prefix
*)p
, rinfo
);
2234 if (ret
== RMAP_DENYMATCH
) {
2235 if (IS_RIP_DEBUG_PACKET
)
2237 "%pFX is filtered by route-map",
2243 /* When route-map does not set metric. */
2244 if (!rinfo
->metric_set
) {
2245 /* If redistribute metric is set. */
2246 if (rip
->redist
[rinfo
->type
].metric_config
&&
2247 rinfo
->metric
!= RIP_METRIC_INFINITY
) {
2249 rip
->redist
[rinfo
->type
].metric
;
2251 /* If the route is not connected or localy
2252 * generated one, use default-metric value
2254 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&&
2255 rinfo
->type
!= ZEBRA_ROUTE_CONNECT
&&
2256 rinfo
->metric
!= RIP_METRIC_INFINITY
)
2257 rinfo
->metric_out
= rip
->default_metric
;
2261 /* Apply offset-list */
2262 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2263 rip_offset_list_apply_out(p
, ifc
->ifp
,
2264 &rinfo
->metric_out
);
2266 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2267 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2269 /* Perform split-horizon with poisoned reverse
2270 * for RIP and connected routes.
2272 if (ri
->split_horizon
== RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2274 * We perform split horizon for RIP and connected
2275 * route. For rip routes, we want to suppress the
2276 * route if we would end up sending the route back
2277 * on the interface that we learned it from, with a
2278 * higher metric. For connected routes, we suppress
2279 * the route if the prefix is a subset of the source
2280 * address that we are going to use for the packet
2281 * (in order to handle the case when multiple
2282 * subnets are configured on the same interface).
2284 struct rip_info
*tmp_rinfo
= NULL
;
2285 struct connected
*tmp_ifc
= NULL
;
2287 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2288 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2289 tmp_rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2290 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2292 if (rinfo
->metric_out
!= RIP_METRIC_INFINITY
&&
2293 rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2294 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2296 if (prefix_match((struct prefix
*)p
,
2297 tmp_ifc
->address
)) {
2299 RIP_METRIC_INFINITY
;
2305 /* Prepare preamble, auth headers, if needs be */
2307 stream_putc(s
, RIP_RESPONSE
);
2308 stream_putc(s
, version
);
2311 /* auth header for !v1 && !no_auth */
2312 if ((ri
->auth_type
!= RIP_NO_AUTH
) &&
2314 doff
= rip_auth_header_write(
2315 s
, ri
, key
, auth_str
,
2316 RIP_AUTH_SIMPLE_SIZE
);
2319 /* Write RTE to the stream. */
2320 num
= rip_write_rte(num
, s
, p
, version
, rinfo
);
2321 if (num
== rtemax
) {
2322 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2323 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2324 RIP_AUTH_SIMPLE_SIZE
);
2326 ret
= rip_send_packet(STREAM_DATA(s
),
2327 stream_get_endp(s
), to
, ifc
);
2329 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2331 (struct rip_packet
*)STREAM_DATA(s
),
2332 stream_get_endp(s
), "SEND");
2338 /* Flush unwritten RTE. */
2340 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2341 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2342 RIP_AUTH_SIMPLE_SIZE
);
2344 ret
= rip_send_packet(STREAM_DATA(s
), stream_get_endp(s
), to
,
2347 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2348 rip_packet_dump((struct rip_packet
*)STREAM_DATA(s
),
2349 stream_get_endp(s
), "SEND");
2353 /* Statistics updates. */
2357 /* Send RIP packet to the interface. */
2358 static void rip_update_interface(struct connected
*ifc
, uint8_t version
,
2361 struct interface
*ifp
= ifc
->ifp
;
2362 struct rip_interface
*ri
= ifp
->info
;
2363 struct sockaddr_in to
;
2365 /* When RIP version is 2 and multicast enable interface. */
2366 if (version
== RIPv2
&& !ri
->v2_broadcast
&& if_is_multicast(ifp
)) {
2367 if (IS_RIP_DEBUG_EVENT
)
2368 zlog_debug("multicast announce on %s ", ifp
->name
);
2370 rip_output_process(ifc
, NULL
, route_type
, version
);
2374 /* If we can't send multicast packet, send it with unicast. */
2375 if (if_is_broadcast(ifp
) || if_is_pointopoint(ifp
)) {
2376 if (ifc
->address
->family
== AF_INET
) {
2377 /* Destination address and port setting. */
2378 memset(&to
, 0, sizeof(to
));
2379 if (ifc
->destination
)
2380 /* use specified broadcast or peer destination
2382 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2383 else if (ifc
->address
->prefixlen
< IPV4_MAX_BITLEN
)
2384 /* calculate the appropriate broadcast address
2386 to
.sin_addr
.s_addr
= ipv4_broadcast_addr(
2387 ifc
->address
->u
.prefix4
.s_addr
,
2388 ifc
->address
->prefixlen
);
2390 /* do not know where to send the packet */
2392 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2394 if (IS_RIP_DEBUG_EVENT
)
2395 zlog_debug("%s announce to %pI4 on %s",
2396 CONNECTED_PEER(ifc
) ? "unicast"
2398 &to
.sin_addr
, ifp
->name
);
2400 rip_output_process(ifc
, &to
, route_type
, version
);
2405 /* Update send to all interface and neighbor. */
2406 static void rip_update_process(struct rip
*rip
, int route_type
)
2408 struct listnode
*ifnode
, *ifnnode
;
2409 struct connected
*connected
;
2410 struct interface
*ifp
;
2411 struct rip_interface
*ri
;
2412 struct route_node
*rp
;
2413 struct sockaddr_in to
;
2416 /* Send RIP update to each interface. */
2417 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
2418 if (if_is_loopback(ifp
))
2421 if (!if_is_operative(ifp
))
2424 /* Fetch RIP interface information. */
2427 /* When passive interface is specified, suppress announce to the
2436 * If there is no version configuration in the
2437 * interface, use rip's version setting.
2439 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
) ? rip
->version_send
2442 if (IS_RIP_DEBUG_EVENT
)
2443 zlog_debug("SEND UPDATE to %s ifindex %d", ifp
->name
,
2446 /* send update on each connected network */
2447 for (ALL_LIST_ELEMENTS(ifp
->connected
, ifnode
, ifnnode
,
2449 if (connected
->address
->family
== AF_INET
) {
2451 rip_update_interface(connected
, RIPv1
,
2453 if ((vsend
& RIPv2
) && if_is_multicast(ifp
))
2454 rip_update_interface(connected
, RIPv2
,
2460 /* RIP send updates to each neighbor. */
2461 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
)) {
2462 if (rp
->info
== NULL
)
2467 connected
= if_lookup_address(&p
->u
.prefix4
, AF_INET
,
2471 "Neighbor %pI4 doesn't have connected interface!",
2476 /* Set destination address and port */
2477 memset(&to
, 0, sizeof(struct sockaddr_in
));
2478 to
.sin_addr
= p
->u
.prefix4
;
2479 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2481 /* RIP version is rip's configuration. */
2482 rip_output_process(connected
, &to
, route_type
,
2487 /* RIP's periodical timer. */
2488 static void rip_update(struct event
*t
)
2490 struct rip
*rip
= EVENT_ARG(t
);
2492 if (IS_RIP_DEBUG_EVENT
)
2493 zlog_debug("update timer fire!");
2495 /* Process update output. */
2496 rip_update_process(rip
, rip_all_route
);
2498 /* Triggered updates may be suppressed if a regular update is due by
2499 the time the triggered update would be sent. */
2500 EVENT_OFF(rip
->t_triggered_interval
);
2503 /* Register myself. */
2504 rip_event(rip
, RIP_UPDATE_EVENT
, 0);
2507 /* Walk down the RIP routing table then clear changed flag. */
2508 static void rip_clear_changed_flag(struct rip
*rip
)
2510 struct route_node
*rp
;
2511 struct rip_info
*rinfo
= NULL
;
2512 struct list
*list
= NULL
;
2513 struct listnode
*listnode
= NULL
;
2515 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2521 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
2522 UNSET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2523 /* This flag can be set only on the first entry. */
2529 /* Triggered update interval timer. */
2530 static void rip_triggered_interval(struct event
*t
)
2532 struct rip
*rip
= EVENT_ARG(t
);
2536 rip_triggered_update(t
);
2540 /* Execute triggered update. */
2541 static void rip_triggered_update(struct event
*t
)
2543 struct rip
*rip
= EVENT_ARG(t
);
2546 /* Cancel interval timer. */
2547 EVENT_OFF(rip
->t_triggered_interval
);
2550 /* Logging triggered update. */
2551 if (IS_RIP_DEBUG_EVENT
)
2552 zlog_debug("triggered update!");
2554 /* Split Horizon processing is done when generating triggered
2555 updates as well as normal updates (see section 2.6). */
2556 rip_update_process(rip
, rip_changed_route
);
2558 /* Once all of the triggered updates have been generated, the route
2559 change flags should be cleared. */
2560 rip_clear_changed_flag(rip
);
2562 /* After a triggered update is sent, a timer should be set for a
2563 random interval between 1 and 5 seconds. If other changes that
2564 would trigger updates occur before the timer expires, a single
2565 update is triggered when the timer expires. */
2566 interval
= (frr_weak_random() % 5) + 1;
2568 event_add_timer(master
, rip_triggered_interval
, rip
, interval
,
2569 &rip
->t_triggered_interval
);
2572 /* Withdraw redistributed route. */
2573 void rip_redistribute_withdraw(struct rip
*rip
, int type
)
2575 struct route_node
*rp
;
2576 struct rip_info
*rinfo
= NULL
;
2577 struct list
*list
= NULL
;
2579 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2585 rinfo
= listgetdata(listhead(list
));
2587 if (rinfo
->type
!= type
)
2590 if (rinfo
->sub_type
== RIP_ROUTE_INTERFACE
)
2593 /* Perform poisoned reverse. */
2594 rinfo
->metric
= RIP_METRIC_INFINITY
;
2595 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
2597 EVENT_OFF(rinfo
->t_timeout
);
2598 rinfo
->flags
|= RIP_RTF_CHANGED
;
2600 if (IS_RIP_DEBUG_EVENT
) {
2601 struct prefix_ipv4
*p
= (struct prefix_ipv4
*)&rp
->p
;
2604 "Poisone %pFX on the interface %s with an infinity metric [withdraw]",
2606 ifindex2ifname(rinfo
->nh
.ifindex
,
2610 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2614 struct rip
*rip_lookup_by_vrf_id(vrf_id_t vrf_id
)
2618 vrf
= vrf_lookup_by_id(vrf_id
);
2625 struct rip
*rip_lookup_by_vrf_name(const char *vrf_name
)
2629 rip
.vrf_name
= (char *)vrf_name
;
2631 return RB_FIND(rip_instance_head
, &rip_instances
, &rip
);
2634 /* Create new RIP instance and set it to global variable. */
2635 struct rip
*rip_create(const char *vrf_name
, struct vrf
*vrf
, int socket
)
2639 rip
= XCALLOC(MTYPE_RIP
, sizeof(struct rip
));
2640 rip
->vrf_name
= XSTRDUP(MTYPE_RIP_VRF_NAME
, vrf_name
);
2642 /* Set initial value. */
2643 rip
->ecmp
= yang_get_default_bool("%s/allow-ecmp", RIP_INSTANCE
);
2644 rip
->default_metric
=
2645 yang_get_default_uint8("%s/default-metric", RIP_INSTANCE
);
2647 yang_get_default_uint8("%s/distance/default", RIP_INSTANCE
);
2648 rip
->passive_default
=
2649 yang_get_default_bool("%s/passive-default", RIP_INSTANCE
);
2650 rip
->garbage_time
= yang_get_default_uint32("%s/timers/flush-interval",
2652 rip
->timeout_time
= yang_get_default_uint32(
2653 "%s/timers/holddown-interval", RIP_INSTANCE
);
2654 rip
->update_time
= yang_get_default_uint32("%s/timers/update-interval",
2657 yang_get_default_enum("%s/version/send", RIP_INSTANCE
);
2659 yang_get_default_enum("%s/version/receive", RIP_INSTANCE
);
2661 /* Initialize RIP data structures. */
2662 rip
->table
= route_table_init();
2663 route_table_set_info(rip
->table
, rip
);
2664 rip
->neighbor
= route_table_init();
2665 rip
->peer_list
= list_new();
2666 rip
->peer_list
->cmp
= (int (*)(void *, void *))rip_peer_list_cmp
;
2667 rip
->peer_list
->del
= rip_peer_list_del
;
2668 rip
->distance_table
= route_table_init();
2669 rip
->distance_table
->cleanup
= rip_distance_table_node_cleanup
;
2670 rip
->enable_interface
= vector_init(1);
2671 rip
->enable_network
= route_table_init();
2672 rip
->passive_nondefault
= vector_init(1);
2673 rip
->offset_list_master
= list_new();
2674 rip
->offset_list_master
->cmp
= (int (*)(void *, void *))offset_list_cmp
;
2675 rip
->offset_list_master
->del
= (void (*)(void *))offset_list_free
;
2677 /* Distribute list install. */
2678 rip
->distribute_ctx
= distribute_list_ctx_create(vrf
);
2679 distribute_list_add_hook(rip
->distribute_ctx
, rip_distribute_update
);
2680 distribute_list_delete_hook(rip
->distribute_ctx
, rip_distribute_update
);
2682 /* if rmap install. */
2683 rip
->if_rmap_ctx
= if_rmap_ctx_create(vrf_name
);
2684 if_rmap_hook_add(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2685 if_rmap_hook_delete(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2687 /* Make output stream. */
2688 rip
->obuf
= stream_new(1500);
2690 /* Enable the routing instance if possible. */
2691 if (vrf
&& vrf_is_enabled(vrf
))
2692 rip_instance_enable(rip
, vrf
, socket
);
2698 RB_INSERT(rip_instance_head
, &rip_instances
, rip
);
2703 /* Sned RIP request to the destination. */
2704 int rip_request_send(struct sockaddr_in
*to
, struct interface
*ifp
,
2705 uint8_t version
, struct connected
*connected
)
2708 struct rip_packet rip_packet
;
2709 struct listnode
*node
, *nnode
;
2711 memset(&rip_packet
, 0, sizeof(rip_packet
));
2713 rip_packet
.command
= RIP_REQUEST
;
2714 rip_packet
.version
= version
;
2715 rte
= rip_packet
.rte
;
2716 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
2720 * connected is only sent for ripv1 case, or when
2721 * interface does not support multicast. Caller loops
2722 * over each connected address for this case.
2724 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2726 != sizeof(rip_packet
))
2729 return sizeof(rip_packet
);
2732 /* send request on each connected network */
2733 for (ALL_LIST_ELEMENTS(ifp
->connected
, node
, nnode
, connected
)) {
2734 struct prefix_ipv4
*p
;
2736 p
= (struct prefix_ipv4
*)connected
->address
;
2738 if (p
->family
!= AF_INET
)
2741 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2743 != sizeof(rip_packet
))
2746 return sizeof(rip_packet
);
2749 static int rip_update_jitter(unsigned long time
)
2751 #define JITTER_BOUND 4
2752 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2753 Given that, we cannot let time be less than JITTER_BOUND seconds.
2754 The RIPv2 RFC says jitter should be small compared to
2755 update_time. We consider 1/JITTER_BOUND to be small.
2758 int jitter_input
= time
;
2761 if (jitter_input
< JITTER_BOUND
)
2762 jitter_input
= JITTER_BOUND
;
2764 jitter
= (((frr_weak_random() % ((jitter_input
* 2) + 1))
2767 return jitter
/ JITTER_BOUND
;
2770 void rip_event(struct rip
*rip
, enum rip_event event
, int sock
)
2776 event_add_read(master
, rip_read
, rip
, sock
, &rip
->t_read
);
2778 case RIP_UPDATE_EVENT
:
2779 EVENT_OFF(rip
->t_update
);
2780 jitter
= rip_update_jitter(rip
->update_time
);
2781 event_add_timer(master
, rip_update
, rip
,
2782 sock
? 2 : rip
->update_time
+ jitter
,
2785 case RIP_TRIGGERED_UPDATE
:
2786 if (rip
->t_triggered_interval
)
2789 event_add_event(master
, rip_triggered_update
, rip
, 0,
2790 &rip
->t_triggered_update
);
2797 struct rip_distance
*rip_distance_new(void)
2799 return XCALLOC(MTYPE_RIP_DISTANCE
, sizeof(struct rip_distance
));
2802 void rip_distance_free(struct rip_distance
*rdistance
)
2804 if (rdistance
->access_list
)
2805 free(rdistance
->access_list
);
2806 XFREE(MTYPE_RIP_DISTANCE
, rdistance
);
2809 static void rip_distance_table_node_cleanup(struct route_table
*table
,
2810 struct route_node
*node
)
2812 struct rip_distance
*rdistance
;
2814 rdistance
= node
->info
;
2816 rip_distance_free(rdistance
);
2819 /* Apply RIP information to distance method. */
2820 uint8_t rip_distance_apply(struct rip
*rip
, struct rip_info
*rinfo
)
2822 struct route_node
*rn
;
2823 struct prefix_ipv4 p
;
2824 struct rip_distance
*rdistance
;
2825 struct access_list
*alist
;
2827 memset(&p
, 0, sizeof(p
));
2829 p
.prefix
= rinfo
->from
;
2830 p
.prefixlen
= IPV4_MAX_BITLEN
;
2832 /* Check source address. */
2833 rn
= route_node_match(rip
->distance_table
, (struct prefix
*)&p
);
2835 rdistance
= rn
->info
;
2836 route_unlock_node(rn
);
2838 if (rdistance
->access_list
) {
2839 alist
= access_list_lookup(AFI_IP
,
2840 rdistance
->access_list
);
2843 if (access_list_apply(alist
, &rinfo
->rp
->p
)
2847 return rdistance
->distance
;
2850 return rip
->distance
;
2853 static void rip_distance_show(struct vty
*vty
, struct rip
*rip
)
2855 struct route_node
*rn
;
2856 struct rip_distance
*rdistance
;
2860 vty_out(vty
, " Distance: (default is %u)\n",
2861 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
2863 for (rn
= route_top(rip
->distance_table
); rn
; rn
= route_next(rn
)) {
2864 rdistance
= rn
->info
;
2866 if (rdistance
== NULL
)
2870 vty_out(vty
, " Address Distance List\n");
2873 snprintfrr(buf
, sizeof(buf
), "%pFX", &rn
->p
);
2874 vty_out(vty
, " %-20s %4d %s\n", buf
, rdistance
->distance
,
2875 rdistance
->access_list
? rdistance
->access_list
: "");
2879 /* Update ECMP routes to zebra when ECMP is disabled. */
2880 void rip_ecmp_disable(struct rip
*rip
)
2882 struct route_node
*rp
;
2883 struct rip_info
*rinfo
, *tmp_rinfo
;
2885 struct listnode
*node
, *nextnode
;
2887 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2892 if (listcount(list
) == 0)
2895 rinfo
= listgetdata(listhead(list
));
2896 if (!rip_route_rte(rinfo
))
2899 /* Drop all other entries, except the first one. */
2900 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
2901 if (tmp_rinfo
== rinfo
)
2904 EVENT_OFF(tmp_rinfo
->t_timeout
);
2905 EVENT_OFF(tmp_rinfo
->t_garbage_collect
);
2906 list_delete_node(list
, node
);
2907 rip_info_free(tmp_rinfo
);
2911 rip_zebra_ipv4_add(rip
, rp
);
2913 /* Set the route change flag. */
2914 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2916 /* Signal the output process to trigger an update. */
2917 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2921 /* Print out routes update time. */
2922 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
2927 char timebuf
[TIME_BUF
];
2928 struct event
*thread
;
2930 if ((thread
= rinfo
->t_timeout
) != NULL
) {
2931 clock
= event_timer_remain_second(thread
);
2932 gmtime_r(&clock
, &tm
);
2933 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2934 vty_out(vty
, "%5s", timebuf
);
2935 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
2936 clock
= event_timer_remain_second(thread
);
2937 gmtime_r(&clock
, &tm
);
2938 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2939 vty_out(vty
, "%5s", timebuf
);
2943 static const char *rip_route_type_print(int sub_type
)
2948 case RIP_ROUTE_STATIC
:
2950 case RIP_ROUTE_DEFAULT
:
2952 case RIP_ROUTE_REDISTRIBUTE
:
2954 case RIP_ROUTE_INTERFACE
:
2963 "show ip rip [vrf NAME]",
2970 struct route_node
*np
;
2971 struct rip_info
*rinfo
= NULL
;
2972 struct list
*list
= NULL
;
2973 struct listnode
*listnode
= NULL
;
2974 const char *vrf_name
;
2977 if (argv_find(argv
, argc
, "vrf", &idx
))
2978 vrf_name
= argv
[idx
+ 1]->arg
;
2980 vrf_name
= VRF_DEFAULT_NAME
;
2982 rip
= rip_lookup_by_vrf_name(vrf_name
);
2984 vty_out(vty
, "%% RIP instance not found\n");
2987 if (!rip
->enabled
) {
2988 vty_out(vty
, "%% RIP instance is disabled\n");
2993 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
2995 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
2996 " (i) - interface\n\n"
2997 " Network Next Hop Metric From Tag Time\n");
2999 for (np
= route_top(rip
->table
); np
; np
= route_next(np
)) {
3005 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3008 len
= vty_out(vty
, "%c(%s) %pFX",
3009 /* np->lock, For debugging. */
3010 zebra_route_char(rinfo
->type
),
3011 rip_route_type_print(rinfo
->sub_type
),
3017 vty_out(vty
, "%*s", len
, " ");
3019 switch (rinfo
->nh
.type
) {
3020 case NEXTHOP_TYPE_IPV4
:
3021 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3022 vty_out(vty
, "%-20pI4 %2d ",
3023 &rinfo
->nh
.gate
.ipv4
, rinfo
->metric
);
3025 case NEXTHOP_TYPE_IFINDEX
:
3026 vty_out(vty
, "0.0.0.0 %2d ",
3029 case NEXTHOP_TYPE_BLACKHOLE
:
3030 vty_out(vty
, "blackhole %2d ",
3033 case NEXTHOP_TYPE_IPV6
:
3034 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3035 vty_out(vty
, "V6 Address Hidden %2d ",
3040 /* Route which exist in kernel routing table. */
3041 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3042 (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3043 vty_out(vty
, "%-15pI4 ", &rinfo
->from
);
3044 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3045 (route_tag_t
)rinfo
->tag
);
3046 rip_vty_out_uptime(vty
, rinfo
);
3047 } else if (rinfo
->metric
== RIP_METRIC_INFINITY
) {
3048 vty_out(vty
, "self ");
3049 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3050 (route_tag_t
)rinfo
->tag
);
3051 rip_vty_out_uptime(vty
, rinfo
);
3053 if (rinfo
->external_metric
) {
3055 vty
, "self (%s:%d)",
3056 zebra_route_string(rinfo
->type
),
3057 rinfo
->external_metric
);
3060 vty_out(vty
, "%*s", len
, " ");
3062 vty_out(vty
, "self ");
3063 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3064 (route_tag_t
)rinfo
->tag
);
3073 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3074 DEFUN (show_ip_rip_status
,
3075 show_ip_rip_status_cmd
,
3076 "show ip rip [vrf NAME] status",
3081 "IP routing protocol process parameters and statistics\n")
3084 struct interface
*ifp
;
3085 struct rip_interface
*ri
;
3086 extern const struct message ri_version_msg
[];
3087 const char *send_version
;
3088 const char *receive_version
;
3089 const char *vrf_name
;
3092 if (argv_find(argv
, argc
, "vrf", &idx
))
3093 vrf_name
= argv
[idx
+ 1]->arg
;
3095 vrf_name
= VRF_DEFAULT_NAME
;
3097 rip
= rip_lookup_by_vrf_name(vrf_name
);
3099 vty_out(vty
, "%% RIP instance not found\n");
3102 if (!rip
->enabled
) {
3103 vty_out(vty
, "%% RIP instance is disabled\n");
3107 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3108 vty_out(vty
, " Sending updates every %u seconds with +/-50%%,",
3110 vty_out(vty
, " next due in %lu seconds\n",
3111 event_timer_remain_second(rip
->t_update
));
3112 vty_out(vty
, " Timeout after %u seconds,", rip
->timeout_time
);
3113 vty_out(vty
, " garbage collect after %u seconds\n", rip
->garbage_time
);
3115 /* Filtering status show. */
3116 config_show_distribute(vty
, rip
->distribute_ctx
);
3118 /* Default metric information. */
3119 vty_out(vty
, " Default redistribution metric is %u\n",
3120 rip
->default_metric
);
3122 /* Redistribute information. */
3123 vty_out(vty
, " Redistributing:");
3124 rip_show_redistribute_config(vty
, rip
);
3127 vty_out(vty
, " Default version control: send version %s,",
3128 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3129 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3130 vty_out(vty
, " receive any version \n");
3132 vty_out(vty
, " receive version %s \n",
3133 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3135 vty_out(vty
, " Interface Send Recv Key-chain\n");
3137 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3143 if (ri
->enable_network
|| ri
->enable_interface
) {
3144 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3146 lookup_msg(ri_version_msg
,
3147 rip
->version_send
, NULL
);
3149 send_version
= lookup_msg(ri_version_msg
,
3152 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3154 lookup_msg(ri_version_msg
,
3155 rip
->version_recv
, NULL
);
3157 receive_version
= lookup_msg(
3158 ri_version_msg
, ri
->ri_receive
, NULL
);
3160 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3161 send_version
, receive_version
,
3162 ri
->key_chain
? ri
->key_chain
: "");
3166 vty_out(vty
, " Routing for Networks:\n");
3167 rip_show_network_config(vty
, rip
);
3169 int found_passive
= 0;
3170 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3173 if ((ri
->enable_network
|| ri
->enable_interface
) &&
3175 if (!found_passive
) {
3176 vty_out(vty
, " Passive Interface(s):\n");
3179 vty_out(vty
, " %s\n", ifp
->name
);
3183 vty_out(vty
, " Routing Information Sources:\n");
3185 " Gateway BadPackets BadRoutes Distance Last Update\n");
3186 rip_peer_display(vty
, rip
);
3188 rip_distance_show(vty
, rip
);
3193 /* RIP configuration write function. */
3194 static int config_write_rip(struct vty
*vty
)
3199 RB_FOREACH(rip
, rip_instance_head
, &rip_instances
) {
3200 char xpath
[XPATH_MAXLEN
];
3201 struct lyd_node
*dnode
;
3203 snprintf(xpath
, sizeof(xpath
),
3204 "/frr-ripd:ripd/instance[vrf='%s']", rip
->vrf_name
);
3206 dnode
= yang_dnode_get(running_config
->dnode
, xpath
);
3209 nb_cli_show_dnode_cmds(vty
, dnode
, false);
3211 /* Distribute configuration. */
3212 config_write_distribute(vty
, rip
->distribute_ctx
);
3214 vty_out(vty
, "exit\n");
3222 static int config_write_rip(struct vty
*vty
);
3223 /* RIP node structure. */
3224 static struct cmd_node rip_node
= {
3227 .parent_node
= CONFIG_NODE
,
3228 .prompt
= "%s(config-router)# ",
3229 .config_write
= config_write_rip
,
3232 /* Distribute-list update functions. */
3233 static void rip_distribute_update(struct distribute_ctx
*ctx
,
3234 struct distribute
*dist
)
3236 struct interface
*ifp
;
3237 struct rip_interface
*ri
;
3238 struct access_list
*alist
;
3239 struct prefix_list
*plist
;
3241 if (!ctx
->vrf
|| !dist
->ifname
)
3244 ifp
= if_lookup_by_name(dist
->ifname
, ctx
->vrf
->vrf_id
);
3250 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3251 alist
= access_list_lookup(AFI_IP
,
3252 dist
->list
[DISTRIBUTE_V4_IN
]);
3254 ri
->list
[RIP_FILTER_IN
] = alist
;
3256 ri
->list
[RIP_FILTER_IN
] = NULL
;
3258 ri
->list
[RIP_FILTER_IN
] = NULL
;
3260 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3261 alist
= access_list_lookup(AFI_IP
,
3262 dist
->list
[DISTRIBUTE_V4_OUT
]);
3264 ri
->list
[RIP_FILTER_OUT
] = alist
;
3266 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3268 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3270 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3271 plist
= prefix_list_lookup(AFI_IP
,
3272 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3274 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3276 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3278 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3280 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3281 plist
= prefix_list_lookup(AFI_IP
,
3282 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3284 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3286 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3288 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3291 void rip_distribute_update_interface(struct interface
*ifp
)
3293 struct rip_interface
*ri
= ifp
->info
;
3294 struct rip
*rip
= ri
->rip
;
3295 struct distribute
*dist
;
3299 dist
= distribute_lookup(rip
->distribute_ctx
, ifp
->name
);
3301 rip_distribute_update(rip
->distribute_ctx
, dist
);
3304 /* Update all interface's distribute list. */
3306 static void rip_distribute_update_all(struct prefix_list
*notused
)
3308 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3309 struct interface
*ifp
;
3311 FOR_ALL_INTERFACES (vrf
, ifp
)
3312 rip_distribute_update_interface(ifp
);
3315 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3317 rip_distribute_update_all(NULL
);
3320 /* Delete all added rip route. */
3321 void rip_clean(struct rip
*rip
)
3323 rip_interfaces_clean(rip
);
3326 rip_instance_disable(rip
);
3328 stream_free(rip
->obuf
);
3330 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3331 if (rip
->redist
[i
].route_map
.name
)
3332 free(rip
->redist
[i
].route_map
.name
);
3334 route_table_finish(rip
->table
);
3335 route_table_finish(rip
->neighbor
);
3336 list_delete(&rip
->peer_list
);
3337 distribute_list_delete(&rip
->distribute_ctx
);
3338 if_rmap_ctx_delete(rip
->if_rmap_ctx
);
3340 rip_clean_network(rip
);
3341 rip_passive_nondefault_clean(rip
);
3342 vector_free(rip
->enable_interface
);
3343 route_table_finish(rip
->enable_network
);
3344 vector_free(rip
->passive_nondefault
);
3345 list_delete(&rip
->offset_list_master
);
3346 route_table_finish(rip
->distance_table
);
3348 RB_REMOVE(rip_instance_head
, &rip_instances
, rip
);
3349 XFREE(MTYPE_TMP
, rip
->default_bfd_profile
);
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 EVENT_OFF(rinfo
->t_timeout
);
3496 EVENT_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 EVENT_OFF(rip
->t_update
);
3509 EVENT_OFF(rip
->t_triggered_update
);
3510 EVENT_OFF(rip
->t_triggered_interval
);
3512 /* Cancel read thread. */
3513 EVENT_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
);