1 /* RIP version 1 and 2.
2 * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
3 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro <kunihiro@zebra.org>
5 * This file is part of GNU Zebra.
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "sockunion.h"
39 #include "distribute.h"
40 #ifdef CRYPTO_INTERNAL
45 #include "lib_errors.h"
46 #include "northbound_cli.h"
48 #include "lib/printfrr.h"
50 #include "ripd/ripd.h"
51 #include "ripd/rip_nb.h"
52 #include "ripd/rip_debug.h"
53 #include "ripd/rip_errors.h"
54 #include "ripd/rip_interface.h"
56 /* UDP receive buffer size */
57 #define RIP_UDP_RCV_BUF 41600
59 DEFINE_MGROUP(RIPD
, "ripd");
60 DEFINE_MTYPE_STATIC(RIPD
, RIP
, "RIP structure");
61 DEFINE_MTYPE_STATIC(RIPD
, RIP_VRF_NAME
, "RIP VRF name");
62 DEFINE_MTYPE_STATIC(RIPD
, RIP_INFO
, "RIP route info");
63 DEFINE_MTYPE_STATIC(RIPD
, RIP_DISTANCE
, "RIP distance");
66 static void rip_output_process(struct connected
*, struct sockaddr_in
*, int,
68 static void rip_triggered_update(struct thread
*);
69 static int rip_update_jitter(unsigned long);
70 static void rip_distance_table_node_cleanup(struct route_table
*table
,
71 struct route_node
*node
);
72 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
);
73 static void rip_instance_disable(struct rip
*rip
);
75 static void rip_distribute_update(struct distribute_ctx
*ctx
,
76 struct distribute
*dist
);
78 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
79 struct if_rmap
*if_rmap
);
81 /* RIP output routes type. */
82 enum { rip_all_route
, rip_changed_route
};
84 /* RIP command strings. */
85 static const struct message rip_msg
[] = {{RIP_REQUEST
, "REQUEST"},
86 {RIP_RESPONSE
, "RESPONSE"},
87 {RIP_TRACEON
, "TRACEON"},
88 {RIP_TRACEOFF
, "TRACEOFF"},
90 {RIP_POLL_ENTRY
, "POLL ENTRY"},
93 /* Generate rb-tree of RIP instances. */
94 static inline int rip_instance_compare(const struct rip
*a
, const struct rip
*b
)
96 return strcmp(a
->vrf_name
, b
->vrf_name
);
98 RB_GENERATE(rip_instance_head
, rip
, entry
, rip_instance_compare
)
100 struct rip_instance_head rip_instances
= RB_INITIALIZER(&rip_instances
);
102 /* Utility function to set broadcast option to the socket. */
103 static int sockopt_broadcast(int sock
)
108 ret
= setsockopt(sock
, SOL_SOCKET
, SO_BROADCAST
, (char *)&on
,
111 zlog_warn("can't set sockopt SO_BROADCAST to socket %d", sock
);
117 int rip_route_rte(struct rip_info
*rinfo
)
119 return (rinfo
->type
== ZEBRA_ROUTE_RIP
120 && rinfo
->sub_type
== RIP_ROUTE_RTE
);
123 static struct rip_info
*rip_info_new(void)
125 return XCALLOC(MTYPE_RIP_INFO
, sizeof(struct rip_info
));
128 void rip_info_free(struct rip_info
*rinfo
)
130 XFREE(MTYPE_RIP_INFO
, rinfo
);
133 struct rip
*rip_info_get_instance(const struct rip_info
*rinfo
)
135 return route_table_get_info(rinfo
->rp
->table
);
138 /* RIP route garbage collect timer. */
139 static void rip_garbage_collect(struct thread
*t
)
141 struct rip_info
*rinfo
;
142 struct route_node
*rp
;
144 rinfo
= THREAD_ARG(t
);
146 /* Off timeout timer. */
147 THREAD_OFF(rinfo
->t_timeout
);
149 /* Get route_node pointer. */
152 /* Unlock route_node. */
153 listnode_delete(rp
->info
, rinfo
);
154 if (list_isempty((struct list
*)rp
->info
)) {
155 list_delete((struct list
**)&rp
->info
);
156 route_unlock_node(rp
);
159 /* Free RIP routing information. */
160 rip_info_free(rinfo
);
163 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
);
165 /* Add new route to the ECMP list.
166 * RETURN: the new entry added in the list, or NULL if it is not the first
167 * entry and ECMP is not allowed.
169 struct rip_info
*rip_ecmp_add(struct rip
*rip
, struct rip_info
*rinfo_new
)
171 struct route_node
*rp
= rinfo_new
->rp
;
172 struct rip_info
*rinfo
= NULL
;
173 struct list
*list
= NULL
;
175 if (rp
->info
== NULL
)
176 rp
->info
= list_new();
177 list
= (struct list
*)rp
->info
;
179 /* If ECMP is not allowed and some entry already exists in the list,
181 if (listcount(list
) && !rip
->ecmp
)
184 rinfo
= rip_info_new();
185 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
186 listnode_add(list
, rinfo
);
188 if (rip_route_rte(rinfo
)) {
189 rip_timeout_update(rip
, rinfo
);
190 rip_zebra_ipv4_add(rip
, rp
);
193 /* Set the route change flag on the first entry. */
194 rinfo
= listgetdata(listhead(list
));
195 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
197 /* Signal the output process to trigger an update (see section 2.5). */
198 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
203 /* Replace the ECMP list with the new route.
204 * RETURN: the new entry added in the list
206 struct rip_info
*rip_ecmp_replace(struct rip
*rip
, struct rip_info
*rinfo_new
)
208 struct route_node
*rp
= rinfo_new
->rp
;
209 struct list
*list
= (struct list
*)rp
->info
;
210 struct rip_info
*rinfo
= NULL
, *tmp_rinfo
= NULL
;
211 struct listnode
*node
= NULL
, *nextnode
= NULL
;
213 if (list
== NULL
|| listcount(list
) == 0)
214 return rip_ecmp_add(rip
, rinfo_new
);
216 /* Get the first entry */
217 rinfo
= listgetdata(listhead(list
));
219 /* Learnt route replaced by a local one. Delete it from zebra. */
220 if (rip_route_rte(rinfo
) && !rip_route_rte(rinfo_new
))
221 if (CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
222 rip_zebra_ipv4_delete(rip
, rp
);
224 /* Re-use the first entry, and delete the others. */
225 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
226 if (tmp_rinfo
== rinfo
)
229 THREAD_OFF(tmp_rinfo
->t_timeout
);
230 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
231 list_delete_node(list
, node
);
232 rip_info_free(tmp_rinfo
);
235 THREAD_OFF(rinfo
->t_timeout
);
236 THREAD_OFF(rinfo
->t_garbage_collect
);
237 memcpy(rinfo
, rinfo_new
, sizeof(struct rip_info
));
239 if (rip_route_rte(rinfo
)) {
240 rip_timeout_update(rip
, rinfo
);
241 /* The ADD message implies an update. */
242 rip_zebra_ipv4_add(rip
, rp
);
245 /* Set the route change flag. */
246 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
248 /* Signal the output process to trigger an update (see section 2.5). */
249 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
254 /* Delete one route from the ECMP list.
256 * null - the entry is freed, and other entries exist in the list
257 * the entry - the entry is the last one in the list; its metric is set
258 * to INFINITY, and the garbage collector is started for it
260 struct rip_info
*rip_ecmp_delete(struct rip
*rip
, struct rip_info
*rinfo
)
262 struct route_node
*rp
= rinfo
->rp
;
263 struct list
*list
= (struct list
*)rp
->info
;
265 THREAD_OFF(rinfo
->t_timeout
);
267 if (listcount(list
) > 1) {
268 /* Some other ECMP entries still exist. Just delete this entry.
270 THREAD_OFF(rinfo
->t_garbage_collect
);
271 listnode_delete(list
, rinfo
);
272 if (rip_route_rte(rinfo
)
273 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
274 /* The ADD message implies the update. */
275 rip_zebra_ipv4_add(rip
, rp
);
276 rip_info_free(rinfo
);
279 assert(rinfo
== listgetdata(listhead(list
)));
281 /* This is the only entry left in the list. We must keep it in
282 * the list for garbage collection time, with INFINITY metric.
285 rinfo
->metric
= RIP_METRIC_INFINITY
;
286 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
289 if (rip_route_rte(rinfo
)
290 && CHECK_FLAG(rinfo
->flags
, RIP_RTF_FIB
))
291 rip_zebra_ipv4_delete(rip
, rp
);
294 /* Set the route change flag on the first entry. */
295 rinfo
= listgetdata(listhead(list
));
296 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
298 /* Signal the output process to trigger an update (see section 2.5). */
299 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
304 /* Timeout RIP routes. */
305 static void rip_timeout(struct thread
*t
)
307 struct rip_info
*rinfo
= THREAD_ARG(t
);
308 struct rip
*rip
= rip_info_get_instance(rinfo
);
310 rip_ecmp_delete(rip
, rinfo
);
313 static void rip_timeout_update(struct rip
*rip
, struct rip_info
*rinfo
)
315 if (rinfo
->metric
!= RIP_METRIC_INFINITY
) {
316 THREAD_OFF(rinfo
->t_timeout
);
317 thread_add_timer(master
, rip_timeout
, rinfo
, rip
->timeout_time
,
322 static int rip_filter(int rip_distribute
, struct prefix_ipv4
*p
,
323 struct rip_interface
*ri
)
325 struct distribute
*dist
;
326 struct access_list
*alist
;
327 struct prefix_list
*plist
;
328 int distribute
= rip_distribute
== RIP_FILTER_OUT
? DISTRIBUTE_V4_OUT
330 const char *inout
= rip_distribute
== RIP_FILTER_OUT
? "out" : "in";
332 /* Input distribute-list filtering. */
333 if (ri
->list
[rip_distribute
] &&
334 access_list_apply(ri
->list
[rip_distribute
], (struct prefix
*)p
) ==
336 if (IS_RIP_DEBUG_PACKET
)
337 zlog_debug("%pFX filtered by distribute %s", p
, inout
);
341 if (ri
->prefix
[rip_distribute
] &&
342 prefix_list_apply(ri
->prefix
[rip_distribute
], (struct prefix
*)p
) ==
344 if (IS_RIP_DEBUG_PACKET
)
345 zlog_debug("%pFX filtered by prefix-list %s", p
, inout
);
349 /* All interface filter check. */
350 dist
= distribute_lookup(ri
->rip
->distribute_ctx
, NULL
);
354 if (dist
->list
[distribute
]) {
355 alist
= access_list_lookup(AFI_IP
, dist
->list
[distribute
]);
358 if (access_list_apply(alist
, (struct prefix
*)p
) ==
360 if (IS_RIP_DEBUG_PACKET
)
362 "%pFX filtered by distribute %s",
368 if (dist
->prefix
[distribute
]) {
369 plist
= prefix_list_lookup(AFI_IP
, dist
->prefix
[distribute
]);
372 if (prefix_list_apply(plist
, (struct prefix
*)p
) ==
374 if (IS_RIP_DEBUG_PACKET
)
376 "%pFX filtered by prefix-list %s",
386 /* Check nexthop address validity. */
387 static int rip_nexthop_check(struct rip
*rip
, struct in_addr
*addr
)
389 struct interface
*ifp
;
390 struct listnode
*cnode
;
391 struct connected
*ifc
;
394 /* If nexthop address matches local configured address then it is
397 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
398 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, cnode
, ifc
)) {
401 if (p
->family
== AF_INET
402 && IPV4_ADDR_SAME(&p
->u
.prefix4
, addr
))
409 /* RIP add route to routing table. */
410 static void rip_rte_process(struct rte
*rte
, struct sockaddr_in
*from
,
411 struct interface
*ifp
)
415 struct prefix_ipv4 p
;
416 struct route_node
*rp
;
417 struct rip_info
*rinfo
= NULL
, newinfo
;
418 struct rip_interface
*ri
;
419 struct in_addr
*nexthop
;
421 unsigned char old_dist
, new_dist
;
422 struct list
*list
= NULL
;
423 struct listnode
*node
= NULL
;
425 /* Make prefix structure. */
426 memset(&p
, 0, sizeof(struct prefix_ipv4
));
428 p
.prefix
= rte
->prefix
;
429 p
.prefixlen
= ip_masklen(rte
->mask
);
431 /* Make sure mask is applied. */
437 /* Apply input filters. */
438 ret
= rip_filter(RIP_FILTER_IN
, &p
, ri
);
442 memset(&newinfo
, 0, sizeof(newinfo
));
443 newinfo
.type
= ZEBRA_ROUTE_RIP
;
444 newinfo
.sub_type
= RIP_ROUTE_RTE
;
445 newinfo
.nh
.gate
.ipv4
= rte
->nexthop
;
446 newinfo
.from
= from
->sin_addr
;
447 newinfo
.nh
.ifindex
= ifp
->ifindex
;
448 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4_IFINDEX
;
449 newinfo
.metric
= rte
->metric
;
450 newinfo
.metric_out
= rte
->metric
; /* XXX */
451 newinfo
.tag
= ntohs(rte
->tag
); /* XXX */
453 /* Modify entry according to the interface routemap. */
454 if (ri
->routemap
[RIP_FILTER_IN
]) {
455 /* The object should be of the type of rip_info */
456 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_IN
],
457 (struct prefix
*)&p
, &newinfo
);
459 if (ret
== RMAP_DENYMATCH
) {
460 if (IS_RIP_DEBUG_PACKET
)
462 "RIP %pFX is filtered by route-map in",
467 /* Get back the object */
468 rte
->nexthop
= newinfo
.nexthop_out
;
469 rte
->tag
= htons(newinfo
.tag_out
); /* XXX */
470 rte
->metric
= newinfo
.metric_out
; /* XXX: the routemap uses the
474 /* Once the entry has been validated, update the metric by
475 adding the cost of the network on which the message
476 arrived. If the result is greater than infinity, use infinity
477 (RFC2453 Sec. 3.9.2) */
478 /* Zebra ripd can handle offset-list in. */
479 ret
= rip_offset_list_apply_in(&p
, ifp
, &rte
->metric
);
481 /* If offset-list does not modify the metric use interface's
484 rte
->metric
+= ifp
->metric
? ifp
->metric
: 1;
486 if (rte
->metric
> RIP_METRIC_INFINITY
)
487 rte
->metric
= RIP_METRIC_INFINITY
;
489 /* Set nexthop pointer. */
490 if (rte
->nexthop
.s_addr
== INADDR_ANY
)
491 nexthop
= &from
->sin_addr
;
493 nexthop
= &rte
->nexthop
;
495 /* Check if nexthop address is myself, then do nothing. */
496 if (rip_nexthop_check(rip
, nexthop
) < 0) {
497 if (IS_RIP_DEBUG_PACKET
)
498 zlog_debug("Nexthop address %pI4 is myself",
503 /* Get index for the prefix. */
504 rp
= route_node_get(rip
->table
, (struct prefix
*)&p
);
507 newinfo
.nh
.gate
.ipv4
= *nexthop
;
508 newinfo
.nh
.type
= NEXTHOP_TYPE_IPV4
;
509 newinfo
.metric
= rte
->metric
;
510 newinfo
.tag
= ntohs(rte
->tag
);
511 newinfo
.distance
= rip_distance_apply(rip
, &newinfo
);
513 new_dist
= newinfo
.distance
? newinfo
.distance
514 : ZEBRA_RIP_DISTANCE_DEFAULT
;
516 /* Check to see whether there is already RIP route on the table. */
517 if ((list
= rp
->info
) != NULL
)
518 for (ALL_LIST_ELEMENTS_RO(list
, node
, rinfo
)) {
519 /* Need to compare with redistributed entry or local
521 if (!rip_route_rte(rinfo
))
524 if (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
525 && IPV4_ADDR_SAME(&rinfo
->nh
.gate
.ipv4
, nexthop
))
528 if (listnextnode(node
))
531 /* Not found in the list */
533 if (rte
->metric
> rinfo
->metric
) {
534 /* New route has a greater metric.
536 route_unlock_node(rp
);
540 if (rte
->metric
< rinfo
->metric
)
541 /* New route has a smaller metric.
542 * Replace the ECMP list
543 * with the new one in below. */
546 /* Metrics are same. We compare the distances.
548 old_dist
= rinfo
->distance
? rinfo
->distance
549 : ZEBRA_RIP_DISTANCE_DEFAULT
;
551 if (new_dist
> old_dist
) {
552 /* New route has a greater distance.
554 route_unlock_node(rp
);
558 if (new_dist
< old_dist
)
559 /* New route has a smaller distance.
560 * Replace the ECMP list
561 * with the new one in below. */
564 /* Metrics and distances are both same. Keep
566 * the new route is added in the ECMP list in
571 /* Local static route. */
572 if (rinfo
->type
== ZEBRA_ROUTE_RIP
573 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
574 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))
575 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
576 route_unlock_node(rp
);
580 /* Redistributed route check. */
581 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
582 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
583 old_dist
= rinfo
->distance
;
584 /* Only routes directly connected to an interface
586 * may have a valid NULL distance */
587 if (rinfo
->nh
.gate
.ipv4
.s_addr
!= INADDR_ANY
)
590 : ZEBRA_RIP_DISTANCE_DEFAULT
;
591 /* If imported route does not have STRICT precedence,
592 mark it as a ghost */
593 if (new_dist
<= old_dist
594 && rte
->metric
!= RIP_METRIC_INFINITY
)
595 rip_ecmp_replace(rip
, &newinfo
);
597 route_unlock_node(rp
);
604 route_unlock_node(rp
);
606 /* Now, check to see whether there is already an explicit route
607 for the destination prefix. If there is no such route, add
608 this route to the routing table, unless the metric is
609 infinity (there is no point in adding a route which
611 if (rte
->metric
!= RIP_METRIC_INFINITY
)
612 rip_ecmp_add(rip
, &newinfo
);
614 /* Route is there but we are not sure the route is RIP or not.
617 /* If there is an existing route, compare the next hop address
618 to the address of the router from which the datagram came.
619 If this datagram is from the same router as the existing
620 route, reinitialize the timeout. */
621 same
= (IPV4_ADDR_SAME(&rinfo
->from
, &from
->sin_addr
)
622 && (rinfo
->nh
.ifindex
== ifp
->ifindex
));
624 old_dist
= rinfo
->distance
? rinfo
->distance
625 : ZEBRA_RIP_DISTANCE_DEFAULT
;
627 /* Next, compare the metrics. If the datagram is from the same
628 router as the existing route, and the new metric is different
629 than the old one; or, if the new metric is lower than the old
630 one, or if the tag has been changed; or if there is a route
631 with a lower administrave distance; or an update of the
632 distance on the actual route; do the following actions: */
633 if ((same
&& rinfo
->metric
!= rte
->metric
)
634 || (rte
->metric
< rinfo
->metric
)
635 || ((same
) && (rinfo
->metric
== rte
->metric
)
636 && (newinfo
.tag
!= rinfo
->tag
))
637 || (old_dist
> new_dist
)
638 || ((old_dist
!= new_dist
) && same
)) {
639 if (listcount(list
) == 1) {
640 if (newinfo
.metric
!= RIP_METRIC_INFINITY
)
641 rip_ecmp_replace(rip
, &newinfo
);
643 rip_ecmp_delete(rip
, rinfo
);
645 if (newinfo
.metric
< rinfo
->metric
)
646 rip_ecmp_replace(rip
, &newinfo
);
647 else if (newinfo
.metric
> rinfo
->metric
)
648 rip_ecmp_delete(rip
, rinfo
);
649 else if (new_dist
< old_dist
)
650 rip_ecmp_replace(rip
, &newinfo
);
651 else if (new_dist
> old_dist
)
652 rip_ecmp_delete(rip
, rinfo
);
654 int update
= CHECK_FLAG(rinfo
->flags
,
659 assert(newinfo
.metric
660 != RIP_METRIC_INFINITY
);
662 THREAD_OFF(rinfo
->t_timeout
);
663 THREAD_OFF(rinfo
->t_garbage_collect
);
664 memcpy(rinfo
, &newinfo
,
665 sizeof(struct rip_info
));
666 rip_timeout_update(rip
, rinfo
);
669 rip_zebra_ipv4_add(rip
, rp
);
671 /* - Set the route change flag on the
673 rinfo
= listgetdata(listhead(list
));
674 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
675 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
678 } else /* same & no change */
679 rip_timeout_update(rip
, rinfo
);
681 /* Unlock tempolary lock of the route. */
682 route_unlock_node(rp
);
686 /* Dump RIP packet */
687 static void rip_packet_dump(struct rip_packet
*packet
, int size
,
692 const char *command_str
;
696 /* Set command string. */
697 if (packet
->command
> 0 && packet
->command
< RIP_COMMAND_MAX
)
698 command_str
= lookup_msg(rip_msg
, packet
->command
, NULL
);
700 command_str
= "unknown";
702 /* Dump packet header. */
703 zlog_debug("%s %s version %d packet size %d", sndrcv
, command_str
,
704 packet
->version
, size
);
706 /* Dump each routing table entry. */
709 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
710 if (packet
->version
== RIPv2
) {
711 netmask
= ip_masklen(rte
->mask
);
713 if (rte
->family
== htons(RIP_FAMILY_AUTH
)) {
715 == htons(RIP_AUTH_SIMPLE_PASSWORD
)) {
716 p
= (uint8_t *)&rte
->prefix
;
719 " family 0x%X type %d auth string: %s",
722 } else if (rte
->tag
== htons(RIP_AUTH_MD5
)) {
723 struct rip_md5_info
*md5
;
725 md5
= (struct rip_md5_info
*)&packet
729 " family 0x%X type %d (MD5 authentication)",
733 " RIP-2 packet len %d Key ID %d Auth Data len %d",
734 ntohs(md5
->packet_len
),
735 md5
->keyid
, md5
->auth_len
);
736 zlog_debug(" Sequence Number %ld",
737 (unsigned long)ntohl(
739 } else if (rte
->tag
== htons(RIP_AUTH_DATA
)) {
740 p
= (uint8_t *)&rte
->prefix
;
743 " family 0x%X type %d (MD5 data)",
747 " MD5: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
748 p
[0], p
[1], p
[2], p
[3], p
[4],
749 p
[5], p
[6], p
[7], p
[8], p
[9],
750 p
[10], p
[11], p
[12], p
[13],
754 " family 0x%X type %d (Unknown auth type)",
760 " %pI4/%d -> %pI4 family %d tag %" ROUTE_TAG_PRI
762 &rte
->prefix
, netmask
, &rte
->nexthop
,
764 (route_tag_t
)ntohs(rte
->tag
),
765 (unsigned long)ntohl(rte
->metric
));
767 zlog_debug(" %pI4 family %d tag %" ROUTE_TAG_PRI
769 &rte
->prefix
, ntohs(rte
->family
),
770 (route_tag_t
)ntohs(rte
->tag
),
771 (unsigned long)ntohl(rte
->metric
));
776 /* Check if the destination address is valid (unicast; not net 0
777 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
778 check net 0 because we accept default route. */
779 static int rip_destination_check(struct in_addr addr
)
781 uint32_t destination
;
783 /* Convert to host byte order. */
784 destination
= ntohl(addr
.s_addr
);
786 if (IPV4_NET127(destination
))
789 /* Net 0 may match to the default route. */
790 if (IPV4_NET0(destination
) && destination
!= 0)
793 /* Unicast address must belong to class A, B, C. */
794 if (IN_CLASSA(destination
))
796 if (IN_CLASSB(destination
))
798 if (IN_CLASSC(destination
))
804 /* RIP version 2 authentication. */
805 static int rip_auth_simple_password(struct rte
*rte
, struct sockaddr_in
*from
,
806 struct interface
*ifp
)
808 struct rip_interface
*ri
;
809 char *auth_str
= (char *)rte
+ offsetof(struct rte
, prefix
);
812 /* reject passwords with zeros in the middle of the string */
813 for (i
= strnlen(auth_str
, 16); i
< 16; i
++) {
814 if (auth_str
[i
] != '\0')
818 if (IS_RIP_DEBUG_EVENT
)
819 zlog_debug("RIPv2 simple password authentication from %pI4",
824 if (ri
->auth_type
!= RIP_AUTH_SIMPLE_PASSWORD
825 || rte
->tag
!= htons(RIP_AUTH_SIMPLE_PASSWORD
))
828 /* Simple password authentication. */
830 if (strncmp(auth_str
, ri
->auth_str
, 16) == 0)
834 struct keychain
*keychain
;
837 keychain
= keychain_lookup(ri
->key_chain
);
838 if (keychain
== NULL
|| keychain
->key
== NULL
)
841 key
= key_match_for_accept(keychain
, auth_str
);
848 /* RIP version 2 authentication with MD5. */
849 static int rip_auth_md5(struct rip_packet
*packet
, struct sockaddr_in
*from
,
850 int length
, struct interface
*ifp
)
852 struct rip_interface
*ri
;
853 struct rip_md5_info
*md5
;
854 struct rip_md5_data
*md5data
;
855 struct keychain
*keychain
;
857 #ifdef CRYPTO_OPENSSL
859 #elif CRYPTO_INTERNAL
862 uint8_t digest
[RIP_AUTH_MD5_SIZE
];
864 char auth_str
[RIP_AUTH_MD5_SIZE
] = {};
866 if (IS_RIP_DEBUG_EVENT
)
867 zlog_debug("RIPv2 MD5 authentication from %pI4",
871 md5
= (struct rip_md5_info
*)&packet
->rte
;
873 /* Check auth type. */
874 if (ri
->auth_type
!= RIP_AUTH_MD5
|| md5
->type
!= htons(RIP_AUTH_MD5
))
877 /* If the authentication length is less than 16, then it must be wrong
879 * any interpretation of rfc2082. Some implementations also interpret
880 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka
881 * RIP_AUTH_MD5_COMPAT_SIZE.
883 if (!((md5
->auth_len
== RIP_AUTH_MD5_SIZE
)
884 || (md5
->auth_len
== RIP_AUTH_MD5_COMPAT_SIZE
))) {
885 if (IS_RIP_DEBUG_EVENT
)
887 "RIPv2 MD5 authentication, strange authentication length field %d",
892 /* grab and verify check packet length */
893 packet_len
= ntohs(md5
->packet_len
);
895 if (packet_len
> (length
- RIP_HEADER_SIZE
- RIP_AUTH_MD5_SIZE
)) {
896 if (IS_RIP_DEBUG_EVENT
)
898 "RIPv2 MD5 authentication, packet length field %d greater than received length %d!",
899 md5
->packet_len
, length
);
903 /* retrieve authentication data */
904 md5data
= (struct rip_md5_data
*)(((uint8_t *)packet
) + packet_len
);
907 keychain
= keychain_lookup(ri
->key_chain
);
908 if (keychain
== NULL
)
911 key
= key_lookup_for_accept(keychain
, md5
->keyid
);
912 if (key
== NULL
|| key
->string
== NULL
)
915 memcpy(auth_str
, key
->string
,
916 MIN(sizeof(auth_str
), strlen(key
->string
)));
917 } else if (ri
->auth_str
)
918 memcpy(auth_str
, ri
->auth_str
,
919 MIN(sizeof(auth_str
), strlen(ri
->auth_str
)));
921 if (auth_str
[0] == 0)
924 /* MD5 digest authentication. */
925 #ifdef CRYPTO_OPENSSL
926 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
927 ctx
= EVP_MD_CTX_new();
928 EVP_DigestInit(ctx
, EVP_md5());
929 EVP_DigestUpdate(ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
930 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
931 EVP_DigestFinal(ctx
, digest
, &md5_size
);
932 EVP_MD_CTX_free(ctx
);
933 #elif CRYPTO_INTERNAL
934 memset(&ctx
, 0, sizeof(ctx
));
936 MD5Update(&ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
937 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
938 MD5Final(digest
, &ctx
);
941 if (memcmp(md5data
->digest
, digest
, RIP_AUTH_MD5_SIZE
) == 0)
947 /* Pick correct auth string for sends, prepare auth_str buffer for use.
948 * (left justified and padded).
950 * presumes one of ri or key is valid, and that the auth strings they point
951 * to are nul terminated. If neither are present, auth_str will be fully
955 static void rip_auth_prepare_str_send(struct rip_interface
*ri
, struct key
*key
,
956 char *auth_str
, int len
)
960 memset(auth_str
, 0, len
);
961 if (key
&& key
->string
)
962 memcpy(auth_str
, key
->string
,
963 MIN((size_t)len
, strlen(key
->string
)));
964 else if (ri
->auth_str
)
965 memcpy(auth_str
, ri
->auth_str
,
966 MIN((size_t)len
, strlen(ri
->auth_str
)));
971 /* Write RIPv2 simple password authentication information
973 * auth_str is presumed to be 2 bytes and correctly prepared
974 * (left justified and zero padded).
976 static void rip_auth_simple_write(struct stream
*s
, char *auth_str
, int len
)
978 assert(s
&& len
== RIP_AUTH_SIMPLE_SIZE
);
980 stream_putw(s
, RIP_FAMILY_AUTH
);
981 stream_putw(s
, RIP_AUTH_SIMPLE_PASSWORD
);
982 stream_put(s
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
987 /* write RIPv2 MD5 "authentication header"
988 * (uses the auth key data field)
990 * Digest offset field is set to 0.
992 * returns: offset of the digest offset field, which must be set when
993 * length to the auth-data MD5 digest is known.
995 static size_t rip_auth_md5_ah_write(struct stream
*s
, struct rip_interface
*ri
,
999 static uint32_t seq
= 0;
1001 assert(s
&& ri
&& ri
->auth_type
== RIP_AUTH_MD5
);
1003 /* MD5 authentication. */
1004 stream_putw(s
, RIP_FAMILY_AUTH
);
1005 stream_putw(s
, RIP_AUTH_MD5
);
1007 /* MD5 AH digest offset field.
1009 * Set to placeholder value here, to true value when RIP-2 Packet length
1010 * is known. Actual value is set in .....().
1012 doff
= stream_get_endp(s
);
1017 stream_putc(s
, key
->index
% 256);
1021 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1022 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for
1024 * to be configurable.
1026 stream_putc(s
, ri
->md5_auth_len
);
1028 /* Sequence Number (non-decreasing). */
1029 /* RFC2080: The value used in the sequence number is
1030 arbitrary, but two suggestions are the time of the
1031 message's creation or a simple message counter. */
1032 stream_putl(s
, ++seq
);
1034 /* Reserved field must be zero. */
1041 /* If authentication is in used, write the appropriate header
1042 * returns stream offset to which length must later be written
1043 * or 0 if this is not required
1045 static size_t rip_auth_header_write(struct stream
*s
, struct rip_interface
*ri
,
1046 struct key
*key
, char *auth_str
, int len
)
1048 assert(ri
->auth_type
!= RIP_NO_AUTH
);
1050 switch (ri
->auth_type
) {
1051 case RIP_AUTH_SIMPLE_PASSWORD
:
1052 rip_auth_prepare_str_send(ri
, key
, auth_str
, len
);
1053 rip_auth_simple_write(s
, auth_str
, len
);
1056 return rip_auth_md5_ah_write(s
, ri
, key
);
1062 /* Write RIPv2 MD5 authentication data trailer */
1063 static void rip_auth_md5_set(struct stream
*s
, struct rip_interface
*ri
,
1064 size_t doff
, char *auth_str
, int authlen
)
1067 #ifdef CRYPTO_OPENSSL
1069 #elif CRYPTO_INTERNAL
1072 unsigned char digest
[RIP_AUTH_MD5_SIZE
];
1074 /* Make it sure this interface is configured as MD5
1076 assert((ri
->auth_type
== RIP_AUTH_MD5
)
1077 && (authlen
== RIP_AUTH_MD5_SIZE
));
1080 /* Get packet length. */
1081 len
= stream_get_endp(s
);
1083 /* Check packet length. */
1084 if (len
< (RIP_HEADER_SIZE
+ RIP_RTE_SIZE
)) {
1085 flog_err(EC_RIP_PACKET
,
1086 "%s: packet length %ld is less than minimum length.",
1091 /* Set the digest offset length in the header */
1092 stream_putw_at(s
, doff
, len
);
1094 /* Set authentication data. */
1095 stream_putw(s
, RIP_FAMILY_AUTH
);
1096 stream_putw(s
, RIP_AUTH_DATA
);
1098 /* Generate a digest for the RIP packet. */
1099 #ifdef CRYPTO_OPENSSL
1100 unsigned int md5_size
= RIP_AUTH_MD5_SIZE
;
1101 ctx
= EVP_MD_CTX_new();
1102 EVP_DigestInit(ctx
, EVP_md5());
1103 EVP_DigestUpdate(ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1104 EVP_DigestUpdate(ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1105 EVP_DigestFinal(ctx
, digest
, &md5_size
);
1106 EVP_MD_CTX_free(ctx
);
1107 #elif CRYPTO_INTERNAL
1108 memset(&ctx
, 0, sizeof(ctx
));
1110 MD5Update(&ctx
, STREAM_DATA(s
), stream_get_endp(s
));
1111 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1112 MD5Final(digest
, &ctx
);
1115 /* Copy the digest to the packet. */
1116 stream_write(s
, digest
, RIP_AUTH_MD5_SIZE
);
1119 /* RIP routing information. */
1120 static void rip_response_process(struct rip_packet
*packet
, int size
,
1121 struct sockaddr_in
*from
,
1122 struct connected
*ifc
)
1124 struct rip_interface
*ri
= ifc
->ifp
->info
;
1125 struct rip
*rip
= ri
->rip
;
1128 struct prefix_ipv4 ifaddr
;
1129 struct prefix_ipv4 ifaddrclass
;
1132 memset(&ifaddr
, 0, sizeof(ifaddr
));
1133 /* We don't know yet. */
1136 /* The Response must be ignored if it is not from the RIP
1137 port. (RFC2453 - Sec. 3.9.2)*/
1138 if (from
->sin_port
!= htons(RIP_PORT_DEFAULT
)) {
1139 zlog_info("response doesn't come from RIP port: %d",
1141 rip_peer_bad_packet(rip
, from
);
1145 /* The datagram's IPv4 source address should be checked to see
1146 whether the datagram is from a valid neighbor; the source of the
1147 datagram must be on a directly connected network (RFC2453 - Sec.
1149 if (if_lookup_address((void *)&from
->sin_addr
, AF_INET
,
1153 "This datagram doesn't come from a valid neighbor: %pI4",
1155 rip_peer_bad_packet(rip
, from
);
1159 /* It is also worth checking to see whether the response is from one
1160 of the router's own addresses. */
1162 ; /* Alredy done in rip_read () */
1164 /* Update RIP peer. */
1165 rip_peer_update(rip
, from
, packet
->version
);
1167 /* Set RTE pointer. */
1170 for (lim
= (caddr_t
)packet
+ size
; (caddr_t
)rte
< lim
; rte
++) {
1171 /* RIPv2 authentication check. */
1172 /* If the Address Family Identifier of the first (and only the
1173 first) entry in the message is 0xFFFF, then the remainder of
1174 the entry contains the authentication. */
1175 /* If the packet gets here it means authentication enabled */
1176 /* Check is done in rip_read(). So, just skipping it */
1177 if (packet
->version
== RIPv2
&& rte
== packet
->rte
1178 && rte
->family
== htons(RIP_FAMILY_AUTH
))
1181 if (rte
->family
!= htons(AF_INET
)) {
1182 /* Address family check. RIP only supports AF_INET. */
1183 zlog_info("Unsupported family %d from %pI4",
1189 /* - is the destination address valid (e.g., unicast; not net 0
1191 if (!rip_destination_check(rte
->prefix
)) {
1193 "Network is net 0 or net 127 or it is not unicast network");
1194 rip_peer_bad_route(rip
, from
);
1198 /* Convert metric value to host byte order. */
1199 rte
->metric
= ntohl(rte
->metric
);
1201 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1202 if (!(rte
->metric
>= 1 && rte
->metric
<= 16)) {
1203 zlog_info("Route's metric is not in the 1-16 range.");
1204 rip_peer_bad_route(rip
, from
);
1208 /* RIPv1 does not have nexthop value. */
1209 if (packet
->version
== RIPv1
1210 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1211 zlog_info("RIPv1 packet with nexthop value %pI4",
1213 rip_peer_bad_route(rip
, from
);
1217 /* That is, if the provided information is ignored, a possibly
1218 sub-optimal, but absolutely valid, route may be taken. If
1219 the received Next Hop is not directly reachable, it should be
1220 treated as 0.0.0.0. */
1221 if (packet
->version
== RIPv2
1222 && rte
->nexthop
.s_addr
!= INADDR_ANY
) {
1225 /* Multicast address check. */
1226 addrval
= ntohl(rte
->nexthop
.s_addr
);
1227 if (IN_CLASSD(addrval
)) {
1229 "Nexthop %pI4 is multicast address, skip this rte",
1234 if (!if_lookup_address((void *)&rte
->nexthop
, AF_INET
,
1235 rip
->vrf
->vrf_id
)) {
1236 struct route_node
*rn
;
1237 struct rip_info
*rinfo
;
1239 rn
= route_node_match_ipv4(rip
->table
,
1245 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1248 if (IS_RIP_DEBUG_EVENT
)
1250 "Next hop %pI4 is on RIP network. Set nexthop to the packet's originator",
1252 rte
->nexthop
= rinfo
->from
;
1254 if (IS_RIP_DEBUG_EVENT
)
1256 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1258 rte
->nexthop
.s_addr
=
1262 route_unlock_node(rn
);
1264 if (IS_RIP_DEBUG_EVENT
)
1266 "Next hop %pI4 is not directly reachable. Treat it as 0.0.0.0",
1268 rte
->nexthop
.s_addr
= INADDR_ANY
;
1273 /* For RIPv1, there won't be a valid netmask.
1274 * This is a best guess at the masks. If everyone was using old
1275 * Ciscos before the 'ip subnet zero' option, it would be almost
1278 * Cisco summarize ripv1 advertisements to the classful boundary
1279 * (/16 for class B's) except when the RIP packet does to inside
1280 * the classful network in question.
1282 if ((packet
->version
== RIPv1
1283 && rte
->prefix
.s_addr
!= INADDR_ANY
)
1284 || (packet
->version
== RIPv2
1285 && (rte
->prefix
.s_addr
!= INADDR_ANY
1286 && rte
->mask
.s_addr
== INADDR_ANY
))) {
1287 uint32_t destination
;
1289 if (subnetted
== -1) {
1290 memcpy(&ifaddr
, ifc
->address
, sizeof(ifaddr
));
1291 memcpy(&ifaddrclass
, &ifaddr
,
1292 sizeof(ifaddrclass
));
1293 apply_classful_mask_ipv4(&ifaddrclass
);
1295 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1299 destination
= ntohl(rte
->prefix
.s_addr
);
1301 if (IN_CLASSA(destination
))
1302 masklen2ip(8, &rte
->mask
);
1303 else if (IN_CLASSB(destination
))
1304 masklen2ip(16, &rte
->mask
);
1305 else if (IN_CLASSC(destination
))
1306 masklen2ip(24, &rte
->mask
);
1309 masklen2ip(ifaddrclass
.prefixlen
,
1310 (struct in_addr
*)&destination
);
1311 if ((subnetted
== 1)
1312 && ((rte
->prefix
.s_addr
& destination
)
1313 == ifaddrclass
.prefix
.s_addr
)) {
1314 masklen2ip(ifaddr
.prefixlen
, &rte
->mask
);
1315 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1316 != rte
->prefix
.s_addr
)
1317 masklen2ip(32, &rte
->mask
);
1318 if (IS_RIP_DEBUG_EVENT
)
1319 zlog_debug("Subnetted route %pI4",
1322 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1323 != rte
->prefix
.s_addr
)
1327 if (IS_RIP_DEBUG_EVENT
) {
1328 zlog_debug("Resultant route %pI4",
1330 zlog_debug("Resultant mask %pI4",
1335 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1336 ignore the entry. */
1337 if ((packet
->version
== RIPv2
)
1338 && (rte
->mask
.s_addr
!= INADDR_ANY
)
1339 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
)
1340 != rte
->prefix
.s_addr
)) {
1342 "RIPv2 address %pI4 is not mask /%d applied one",
1343 &rte
->prefix
, ip_masklen(rte
->mask
));
1344 rip_peer_bad_route(rip
, from
);
1348 /* Default route's netmask is ignored. */
1349 if (packet
->version
== RIPv2
1350 && (rte
->prefix
.s_addr
== INADDR_ANY
)
1351 && (rte
->mask
.s_addr
!= INADDR_ANY
)) {
1352 if (IS_RIP_DEBUG_EVENT
)
1354 "Default route with non-zero netmask. Set zero to netmask");
1355 rte
->mask
.s_addr
= INADDR_ANY
;
1358 /* Routing table updates. */
1359 rip_rte_process(rte
, from
, ifc
->ifp
);
1363 /* Make socket for RIP protocol. */
1364 int rip_create_socket(struct vrf
*vrf
)
1368 struct sockaddr_in addr
;
1369 const char *vrf_dev
= NULL
;
1371 memset(&addr
, 0, sizeof(struct sockaddr_in
));
1372 addr
.sin_family
= AF_INET
;
1373 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1374 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1375 addr
.sin_len
= sizeof(struct sockaddr_in
);
1376 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1377 /* sending port must always be the RIP port */
1378 addr
.sin_port
= htons(RIP_PORT_DEFAULT
);
1380 /* Make datagram socket. */
1381 if (vrf
->vrf_id
!= VRF_DEFAULT
)
1382 vrf_dev
= vrf
->name
;
1383 frr_with_privs(&ripd_privs
) {
1384 sock
= vrf_socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, vrf
->vrf_id
,
1387 flog_err_sys(EC_LIB_SOCKET
,
1388 "Cannot create UDP socket: %s",
1389 safe_strerror(errno
));
1394 sockopt_broadcast(sock
);
1395 sockopt_reuseaddr(sock
);
1396 sockopt_reuseport(sock
);
1397 setsockopt_ipv4_multicast_loop(sock
, 0);
1398 #ifdef IPTOS_PREC_INTERNETCONTROL
1399 setsockopt_ipv4_tos(sock
, IPTOS_PREC_INTERNETCONTROL
);
1401 setsockopt_so_recvbuf(sock
, RIP_UDP_RCV_BUF
);
1403 frr_with_privs(&ripd_privs
) {
1404 if ((ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
)))
1406 zlog_err("%s: Can't bind socket %d to %pI4 port %d: %s",
1407 __func__
, sock
, &addr
.sin_addr
,
1408 (int)ntohs(addr
.sin_port
),
1409 safe_strerror(errno
));
1419 /* RIP packet send to destination address, on interface denoted by
1420 * by connected argument. NULL to argument denotes destination should be
1421 * should be RIP multicast group
1423 static int rip_send_packet(uint8_t *buf
, int size
, struct sockaddr_in
*to
,
1424 struct connected
*ifc
)
1426 struct rip_interface
*ri
;
1429 struct sockaddr_in sin
;
1433 struct cmsghdr
*cmsgptr
;
1434 char adata
[256] = {};
1435 struct in_pktinfo
*pkt
;
1436 #endif /* GNU_LINUX */
1438 assert(ifc
!= NULL
);
1439 ri
= ifc
->ifp
->info
;
1442 if (IS_RIP_DEBUG_PACKET
) {
1443 #define ADDRESS_SIZE 20
1444 char dst
[ADDRESS_SIZE
];
1447 inet_ntop(AF_INET
, &to
->sin_addr
, dst
, sizeof(dst
));
1449 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1450 inet_ntop(AF_INET
, &sin
.sin_addr
, dst
, sizeof(dst
));
1453 zlog_debug("%s %pI4 > %s (%s)", __func__
,
1454 &ifc
->address
->u
.prefix4
, dst
, ifc
->ifp
->name
);
1457 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
)) {
1459 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1460 * configured with multiple addresses on the same
1461 * subnet: the first address on the subnet is configured
1462 * "primary", and all subsequent addresses on that subnet
1463 * are treated as "secondary" addresses. In order to avoid
1464 * routing-table bloat on other rip listeners, we do not send
1465 * out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
1466 * XXX Since Linux is the only system for which the
1467 * ZEBRA_IFA_SECONDARY flag is set, we would end up
1468 * sending a packet for a "secondary" source address on
1469 * non-linux systems.
1471 if (IS_RIP_DEBUG_PACKET
)
1472 zlog_debug("duplicate dropped");
1476 /* Make destination address. */
1477 memset(&sin
, 0, sizeof(sin
));
1478 sin
.sin_family
= AF_INET
;
1479 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1480 sin
.sin_len
= sizeof(struct sockaddr_in
);
1481 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1483 /* When destination is specified, use it's port and address. */
1485 sin
.sin_port
= to
->sin_port
;
1486 sin
.sin_addr
= to
->sin_addr
;
1488 sin
.sin_port
= htons(RIP_PORT_DEFAULT
);
1489 sin
.sin_addr
.s_addr
= htonl(INADDR_RIP_GROUP
);
1491 rip_interface_multicast_set(rip
->sock
, ifc
);
1494 memset(&msg
, 0, sizeof(msg
));
1495 msg
.msg_name
= (void *)&sin
;
1496 msg
.msg_namelen
= sizeof(struct sockaddr_in
);
1503 msg
.msg_control
= (void *)adata
;
1504 msg
.msg_controllen
= CMSG_SPACE(sizeof(struct in_pktinfo
));
1506 cmsgptr
= (struct cmsghdr
*)adata
;
1507 cmsgptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_pktinfo
));
1508 cmsgptr
->cmsg_level
= IPPROTO_IP
;
1509 cmsgptr
->cmsg_type
= IP_PKTINFO
;
1510 pkt
= (struct in_pktinfo
*)CMSG_DATA(cmsgptr
);
1511 pkt
->ipi_ifindex
= ifc
->ifp
->ifindex
;
1512 pkt
->ipi_spec_dst
.s_addr
= ifc
->address
->u
.prefix4
.s_addr
;
1513 #endif /* GNU_LINUX */
1515 ret
= sendmsg(rip
->sock
, &msg
, 0);
1517 if (IS_RIP_DEBUG_EVENT
)
1518 zlog_debug("SEND to %pI4%d", &sin
.sin_addr
,
1519 ntohs(sin
.sin_port
));
1522 zlog_warn("can't send packet : %s", safe_strerror(errno
));
1527 /* Add redistributed route to RIP table. */
1528 void rip_redistribute_add(struct rip
*rip
, int type
, int sub_type
,
1529 struct prefix_ipv4
*p
, struct nexthop
*nh
,
1530 unsigned int metric
, unsigned char distance
,
1534 struct route_node
*rp
= NULL
;
1535 struct rip_info
*rinfo
= NULL
, newinfo
;
1536 struct list
*list
= NULL
;
1538 /* Redistribute route */
1539 ret
= rip_destination_check(p
->prefix
);
1543 rp
= route_node_get(rip
->table
, (struct prefix
*)p
);
1545 memset(&newinfo
, 0, sizeof(newinfo
));
1546 newinfo
.type
= type
;
1547 newinfo
.sub_type
= sub_type
;
1549 newinfo
.external_metric
= metric
;
1550 newinfo
.distance
= distance
;
1551 if (tag
<= UINT16_MAX
) /* RIP only supports 16 bit tags */
1556 if ((list
= rp
->info
) != NULL
&& listcount(list
) != 0) {
1557 rinfo
= listgetdata(listhead(list
));
1559 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1560 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1561 && rinfo
->metric
!= RIP_METRIC_INFINITY
) {
1562 route_unlock_node(rp
);
1566 /* Manually configured RIP route check. */
1567 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1568 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
)
1569 || (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))) {
1570 if (type
!= ZEBRA_ROUTE_RIP
1571 || ((sub_type
!= RIP_ROUTE_STATIC
)
1572 && (sub_type
!= RIP_ROUTE_DEFAULT
))) {
1573 route_unlock_node(rp
);
1578 (void)rip_ecmp_replace(rip
, &newinfo
);
1579 route_unlock_node(rp
);
1581 (void)rip_ecmp_add(rip
, &newinfo
);
1583 if (IS_RIP_DEBUG_EVENT
) {
1584 zlog_debug("Redistribute new prefix %pFX", p
);
1587 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1590 /* Delete redistributed route from RIP table. */
1591 void rip_redistribute_delete(struct rip
*rip
, int type
, int sub_type
,
1592 struct prefix_ipv4
*p
, ifindex_t ifindex
)
1595 struct route_node
*rp
;
1596 struct rip_info
*rinfo
;
1598 ret
= rip_destination_check(p
->prefix
);
1602 rp
= route_node_lookup(rip
->table
, (struct prefix
*)p
);
1604 struct list
*list
= rp
->info
;
1606 if (list
!= NULL
&& listcount(list
) != 0) {
1607 rinfo
= listgetdata(listhead(list
));
1608 if (rinfo
!= NULL
&& rinfo
->type
== type
1609 && rinfo
->sub_type
== sub_type
1610 && rinfo
->nh
.ifindex
== ifindex
) {
1611 /* Perform poisoned reverse. */
1612 rinfo
->metric
= RIP_METRIC_INFINITY
;
1613 RIP_TIMER_ON(rinfo
->t_garbage_collect
,
1614 rip_garbage_collect
,
1616 THREAD_OFF(rinfo
->t_timeout
);
1617 rinfo
->flags
|= RIP_RTF_CHANGED
;
1619 if (IS_RIP_DEBUG_EVENT
)
1621 "Poison %pFX on the interface %s with an infinity metric [delete]",
1627 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
1630 route_unlock_node(rp
);
1634 /* Response to request called from rip_read ().*/
1635 static void rip_request_process(struct rip_packet
*packet
, int size
,
1636 struct sockaddr_in
*from
, struct connected
*ifc
)
1641 struct prefix_ipv4 p
;
1642 struct route_node
*rp
;
1643 struct rip_info
*rinfo
;
1644 struct rip_interface
*ri
;
1646 /* Does not reponse to the requests on the loopback interfaces */
1647 if (if_is_loopback(ifc
->ifp
))
1650 /* Check RIP process is enabled on this interface. */
1651 ri
= ifc
->ifp
->info
;
1656 /* When passive interface is specified, suppress responses */
1660 /* RIP peer update. */
1661 rip_peer_update(rip
, from
, packet
->version
);
1663 lim
= ((caddr_t
)packet
) + size
;
1666 /* The Request is processed entry by entry. If there are no
1667 entries, no response is given. */
1668 if (lim
== (caddr_t
)rte
)
1671 /* There is one special case. If there is exactly one entry in the
1672 request, and it has an address family identifier of zero and a
1673 metric of infinity (i.e., 16), then this is a request to send the
1674 entire routing table. */
1675 if (lim
== ((caddr_t
)(rte
+ 1)) && ntohs(rte
->family
) == 0
1676 && ntohl(rte
->metric
) == RIP_METRIC_INFINITY
) {
1677 /* All route with split horizon */
1678 rip_output_process(ifc
, from
, rip_all_route
, packet
->version
);
1680 if (ntohs(rte
->family
) != AF_INET
)
1683 /* Examine the list of RTEs in the Request one by one. For each
1684 entry, look up the destination in the router's routing
1685 database and, if there is a route, put that route's metric in
1686 the metric field of the RTE. If there is no explicit route
1687 to the specified destination, put infinity in the metric
1688 field. Once all the entries have been filled in, change the
1689 command from Request to Response and send the datagram back
1690 to the requestor. */
1693 for (; ((caddr_t
)rte
) < lim
; rte
++) {
1694 p
.prefix
= rte
->prefix
;
1695 p
.prefixlen
= ip_masklen(rte
->mask
);
1696 apply_mask_ipv4(&p
);
1698 rp
= route_node_lookup(rip
->table
, (struct prefix
*)&p
);
1700 rinfo
= listgetdata(
1701 listhead((struct list
*)rp
->info
));
1702 rte
->metric
= htonl(rinfo
->metric
);
1703 route_unlock_node(rp
);
1705 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
1707 packet
->command
= RIP_RESPONSE
;
1709 (void)rip_send_packet((uint8_t *)packet
, size
, from
, ifc
);
1711 rip
->counters
.queries
++;
1714 /* First entry point of RIP packet. */
1715 static void rip_read(struct thread
*t
)
1717 struct rip
*rip
= THREAD_ARG(t
);
1721 union rip_buf rip_buf
;
1722 struct rip_packet
*packet
;
1723 struct sockaddr_in from
;
1727 struct interface
*ifp
= NULL
;
1728 struct connected
*ifc
;
1729 struct rip_interface
*ri
;
1732 /* Fetch socket then register myself. */
1733 sock
= THREAD_FD(t
);
1735 /* Add myself to tne next event */
1736 rip_event(rip
, RIP_READ
, sock
);
1738 /* RIPd manages only IPv4. */
1739 memset(&from
, 0, sizeof(from
));
1740 fromlen
= sizeof(struct sockaddr_in
);
1742 len
= recvfrom(sock
, (char *)&rip_buf
.buf
, sizeof(rip_buf
.buf
), 0,
1743 (struct sockaddr
*)&from
, &fromlen
);
1745 zlog_info("recvfrom failed (VRF %s): %s", rip
->vrf_name
,
1746 safe_strerror(errno
));
1750 /* Check is this packet comming from myself? */
1751 if (if_check_address(rip
, from
.sin_addr
)) {
1752 if (IS_RIP_DEBUG_PACKET
)
1753 zlog_debug("ignore packet comes from myself (VRF %s)",
1758 /* Which interface is this packet comes from. */
1759 ifc
= if_lookup_address((void *)&from
.sin_addr
, AF_INET
,
1764 /* RIP packet received */
1765 if (IS_RIP_DEBUG_EVENT
)
1766 zlog_debug("RECV packet from %pI4 port %d on %s (VRF %s)",
1767 &from
.sin_addr
, ntohs(from
.sin_port
),
1768 ifp
? ifp
->name
: "unknown", rip
->vrf_name
);
1770 /* If this packet come from unknown interface, ignore it. */
1773 "%s: cannot find interface for packet from %pI4 port %d (VRF %s)",
1774 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1780 p
.u
.prefix4
= from
.sin_addr
;
1781 p
.prefixlen
= IPV4_MAX_BITLEN
;
1783 ifc
= connected_lookup_prefix(ifp
, &p
);
1787 "%s: cannot find connected address for packet from %pI4 port %d on interface %s (VRF %s)",
1788 __func__
, &from
.sin_addr
, ntohs(from
.sin_port
),
1789 ifp
->name
, rip
->vrf_name
);
1793 /* Packet length check. */
1794 if (len
< RIP_PACKET_MINSIZ
) {
1795 zlog_warn("packet size %d is smaller than minimum size %d", len
,
1797 rip_peer_bad_packet(rip
, &from
);
1800 if (len
> RIP_PACKET_MAXSIZ
) {
1801 zlog_warn("packet size %d is larger than max size %d", len
,
1803 rip_peer_bad_packet(rip
, &from
);
1807 /* Packet alignment check. */
1808 if ((len
- RIP_PACKET_MINSIZ
) % 20) {
1809 zlog_warn("packet size %d is wrong for RIP packet alignment",
1811 rip_peer_bad_packet(rip
, &from
);
1815 /* Set RTE number. */
1816 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1818 /* For easy to handle. */
1819 packet
= &rip_buf
.rip_packet
;
1821 /* RIP version check. */
1822 if (packet
->version
== 0) {
1823 zlog_info("version 0 with command %d received.",
1825 rip_peer_bad_packet(rip
, &from
);
1829 /* Dump RIP packet. */
1830 if (IS_RIP_DEBUG_RECV
)
1831 rip_packet_dump(packet
, len
, "RECV");
1833 /* RIP version adjust. This code should rethink now. RFC1058 says
1834 that "Version 1 implementations are to ignore this extra data and
1835 process only the fields specified in this document.". So RIPv3
1836 packet should be treated as RIPv1 ignoring must be zero field. */
1837 if (packet
->version
> RIPv2
)
1838 packet
->version
= RIPv2
;
1840 /* Is RIP running or is this RIP neighbor ?*/
1842 if (!ri
->running
&& !rip_neighbor_lookup(rip
, &from
)) {
1843 if (IS_RIP_DEBUG_EVENT
)
1844 zlog_debug("RIP is not enabled on interface %s.",
1846 rip_peer_bad_packet(rip
, &from
);
1850 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1851 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ? rip
->version_recv
1853 if (vrecv
== RI_RIP_VERSION_NONE
1854 || ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1855 || ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))) {
1856 if (IS_RIP_DEBUG_PACKET
)
1858 " packet's v%d doesn't fit to if version spec",
1860 rip_peer_bad_packet(rip
, &from
);
1864 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1865 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1866 accepted; authenticated RIP-2 messages shall be discarded. */
1867 if ((ri
->auth_type
== RIP_NO_AUTH
) && rtenum
1868 && (packet
->version
== RIPv2
)
1869 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
))) {
1870 if (IS_RIP_DEBUG_EVENT
)
1872 "packet RIPv%d is dropped because authentication disabled",
1874 ripd_notif_send_auth_type_failure(ifp
->name
);
1875 rip_peer_bad_packet(rip
, &from
);
1880 If the router is configured to authenticate RIP-2 messages, then
1881 RIP-1 messages and RIP-2 messages which pass authentication
1882 testing shall be accepted; unauthenticated and failed
1883 authentication RIP-2 messages shall be discarded. For maximum
1884 security, RIP-1 messages should be ignored when authentication is
1885 in use (see section 4.1); otherwise, the routing information from
1886 authenticated messages will be propagated by RIP-1 routers in an
1887 unauthenticated manner.
1889 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1890 * always reply regardless of authentication settings, because:
1892 * - if there other authorised routers on-link, the REQUESTor can
1893 * passively obtain the routing updates anyway
1894 * - if there are no other authorised routers on-link, RIP can
1895 * easily be disabled for the link to prevent giving out information
1896 * on state of this routers RIP routing table..
1898 * I.e. if RIPv1 has any place anymore these days, it's as a very
1899 * simple way to distribute routing information (e.g. to embedded
1900 * hosts / appliances) and the ability to give out RIPv1
1901 * routing-information freely, while still requiring RIPv2
1902 * authentication for any RESPONSEs might be vaguely useful.
1904 if (ri
->auth_type
!= RIP_NO_AUTH
&& packet
->version
== RIPv1
) {
1905 /* Discard RIPv1 messages other than REQUESTs */
1906 if (packet
->command
!= RIP_REQUEST
) {
1907 if (IS_RIP_DEBUG_PACKET
)
1909 "RIPv1 dropped because authentication enabled");
1910 ripd_notif_send_auth_type_failure(ifp
->name
);
1911 rip_peer_bad_packet(rip
, &from
);
1914 } else if (ri
->auth_type
!= RIP_NO_AUTH
) {
1915 const char *auth_desc
;
1918 /* There definitely is no authentication in the packet.
1920 if (IS_RIP_DEBUG_PACKET
)
1922 "RIPv2 authentication failed: no auth RTE in packet");
1923 ripd_notif_send_auth_type_failure(ifp
->name
);
1924 rip_peer_bad_packet(rip
, &from
);
1928 /* First RTE must be an Authentication Family RTE */
1929 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
)) {
1930 if (IS_RIP_DEBUG_PACKET
)
1932 "RIPv2 dropped because authentication enabled");
1933 ripd_notif_send_auth_type_failure(ifp
->name
);
1934 rip_peer_bad_packet(rip
, &from
);
1938 /* Check RIPv2 authentication. */
1939 switch (ntohs(packet
->rte
->tag
)) {
1940 case RIP_AUTH_SIMPLE_PASSWORD
:
1941 auth_desc
= "simple";
1942 ret
= rip_auth_simple_password(packet
->rte
, &from
, ifp
);
1947 ret
= rip_auth_md5(packet
, &from
, len
, ifp
);
1948 /* Reset RIP packet length to trim MD5 data. */
1954 auth_desc
= "unknown type";
1955 if (IS_RIP_DEBUG_PACKET
)
1957 "RIPv2 Unknown authentication type %d",
1958 ntohs(packet
->rte
->tag
));
1962 if (IS_RIP_DEBUG_PACKET
)
1963 zlog_debug("RIPv2 %s authentication success",
1966 if (IS_RIP_DEBUG_PACKET
)
1967 zlog_debug("RIPv2 %s authentication failure",
1969 ripd_notif_send_auth_failure(ifp
->name
);
1970 rip_peer_bad_packet(rip
, &from
);
1975 /* Process each command. */
1976 switch (packet
->command
) {
1978 rip_response_process(packet
, len
, &from
, ifc
);
1982 rip_request_process(packet
, len
, &from
, ifc
);
1987 "Obsolete command %s received, please sent it to routed",
1988 lookup_msg(rip_msg
, packet
->command
, NULL
));
1989 rip_peer_bad_packet(rip
, &from
);
1991 case RIP_POLL_ENTRY
:
1992 zlog_info("Obsolete command %s received",
1993 lookup_msg(rip_msg
, packet
->command
, NULL
));
1994 rip_peer_bad_packet(rip
, &from
);
1997 zlog_info("Unknown RIP command %d received", packet
->command
);
1998 rip_peer_bad_packet(rip
, &from
);
2003 /* Write routing table entry to the stream and return next index of
2004 the routing table entry in the stream. */
2005 static int rip_write_rte(int num
, struct stream
*s
, struct prefix_ipv4
*p
,
2006 uint8_t version
, struct rip_info
*rinfo
)
2008 struct in_addr mask
;
2010 /* Write routing table entry. */
2011 if (version
== RIPv1
) {
2012 stream_putw(s
, AF_INET
);
2014 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2015 stream_put_ipv4(s
, 0);
2016 stream_put_ipv4(s
, 0);
2017 stream_putl(s
, rinfo
->metric_out
);
2019 masklen2ip(p
->prefixlen
, &mask
);
2021 stream_putw(s
, AF_INET
);
2022 stream_putw(s
, rinfo
->tag_out
);
2023 stream_put_ipv4(s
, p
->prefix
.s_addr
);
2024 stream_put_ipv4(s
, mask
.s_addr
);
2025 stream_put_ipv4(s
, rinfo
->nexthop_out
.s_addr
);
2026 stream_putl(s
, rinfo
->metric_out
);
2032 /* Send update to the ifp or spcified neighbor. */
2033 void rip_output_process(struct connected
*ifc
, struct sockaddr_in
*to
,
2034 int route_type
, uint8_t version
)
2039 struct route_node
*rp
;
2040 struct rip_info
*rinfo
;
2041 struct rip_interface
*ri
;
2042 struct prefix_ipv4
*p
;
2043 struct prefix_ipv4 classfull
;
2044 struct prefix_ipv4 ifaddrclass
;
2045 struct key
*key
= NULL
;
2046 /* this might need to made dynamic if RIP ever supported auth methods
2047 with larger key string sizes */
2048 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2049 size_t doff
= 0; /* offset of digest offset field */
2053 struct list
*list
= NULL
;
2054 struct listnode
*listnode
= NULL
;
2056 /* Logging output event. */
2057 if (IS_RIP_DEBUG_EVENT
) {
2059 zlog_debug("update routes to neighbor %pI4",
2062 zlog_debug("update routes on interface %s ifindex %d",
2063 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2066 /* Get RIP interface. */
2067 ri
= ifc
->ifp
->info
;
2070 /* Set output stream. */
2073 /* Reset stream and RTE counter. */
2075 rtemax
= RIP_MAX_RTE
;
2077 /* If output interface is in simple password authentication mode, we
2078 need space for authentication data. */
2079 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2082 /* If output interface is in MD5 authentication mode, we need space
2083 for authentication header and data. */
2084 if (ri
->auth_type
== RIP_AUTH_MD5
)
2087 /* If output interface is in simple password authentication mode
2088 and string or keychain is specified we need space for auth. data */
2089 if (ri
->auth_type
!= RIP_NO_AUTH
) {
2090 if (ri
->key_chain
) {
2091 struct keychain
*keychain
;
2093 keychain
= keychain_lookup(ri
->key_chain
);
2095 key
= key_lookup_for_send(keychain
);
2097 /* to be passed to auth functions later */
2098 rip_auth_prepare_str_send(ri
, key
, auth_str
, sizeof(auth_str
));
2099 if (strlen(auth_str
) == 0)
2103 if (version
== RIPv1
) {
2104 memcpy(&ifaddrclass
, ifc
->address
, sizeof(ifaddrclass
));
2105 apply_classful_mask_ipv4(&ifaddrclass
);
2107 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2111 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2117 if (listcount(list
) == 0)
2120 rinfo
= listgetdata(listhead(list
));
2122 * For RIPv1, if we are subnetted, output subnets in our
2123 * network that have the same mask as the output "interface".
2124 * For other networks, only the classfull version is output.
2126 if (version
== RIPv1
) {
2127 p
= (struct prefix_ipv4
*)&rp
->p
;
2129 if (IS_RIP_DEBUG_PACKET
)
2131 "RIPv1 mask check, %pFX considered for output",
2135 prefix_match((struct prefix
*)&ifaddrclass
,
2137 if ((ifc
->address
->prefixlen
!=
2139 (rp
->p
.prefixlen
!= IPV4_MAX_BITLEN
))
2142 memcpy(&classfull
, &rp
->p
,
2143 sizeof(struct prefix_ipv4
));
2144 apply_classful_mask_ipv4(&classfull
);
2145 if (rp
->p
.u
.prefix4
.s_addr
!= INADDR_ANY
&&
2146 classfull
.prefixlen
!= rp
->p
.prefixlen
)
2149 if (IS_RIP_DEBUG_PACKET
)
2151 "RIPv1 mask check, %pFX made it through",
2154 p
= (struct prefix_ipv4
*)&rp
->p
;
2156 /* Apply output filters. */
2157 ret
= rip_filter(RIP_FILTER_OUT
, p
, ri
);
2161 /* Changed route only output. */
2162 if (route_type
== rip_changed_route
&&
2163 (!(rinfo
->flags
& RIP_RTF_CHANGED
)))
2166 /* Split horizon. */
2167 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
) {
2169 * We perform split horizon for RIP and connected
2170 * route. For rip routes, we want to suppress the
2171 * route if we would end up sending the route back on
2172 * the interface that we learned it from, with a
2173 * higher metric. For connected routes, we suppress
2174 * the route if the prefix is a subset of the source
2175 * address that we are going to use for the packet
2176 * (in order to handle the case when multiple subnets
2177 * are configured on the same interface).
2180 struct rip_info
*tmp_rinfo
= NULL
;
2181 struct connected
*tmp_ifc
= NULL
;
2183 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2184 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2185 tmp_rinfo
->nh
.ifindex
==
2186 ifc
->ifp
->ifindex
) {
2191 if (!suppress
&& rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2192 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2194 if (prefix_match((struct prefix
*)p
,
2195 tmp_ifc
->address
)) {
2205 /* Preparation for route-map. */
2206 rinfo
->metric_set
= 0;
2207 rinfo
->nexthop_out
.s_addr
= 0;
2208 rinfo
->metric_out
= rinfo
->metric
;
2209 rinfo
->tag_out
= rinfo
->tag
;
2210 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2212 /* In order to avoid some local loops, if the RIP route has
2213 * a nexthop via this interface, keep the nexthop, otherwise
2214 * set it to 0. The nexthop should not be propagated beyond
2215 * the local broadcast/multicast area in order to avoid an
2216 * IGP multi-level recursive look-up. see (4.4)
2218 if (rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2219 rinfo
->nexthop_out
= rinfo
->nh
.gate
.ipv4
;
2221 /* Interface route-map */
2222 if (ri
->routemap
[RIP_FILTER_OUT
]) {
2223 ret
= route_map_apply(ri
->routemap
[RIP_FILTER_OUT
],
2224 (struct prefix
*)p
, rinfo
);
2226 if (ret
== RMAP_DENYMATCH
) {
2227 if (IS_RIP_DEBUG_PACKET
)
2229 "RIP %pFX is filtered by route-map out",
2235 /* Apply redistribute route map - continue, if deny */
2236 if (rip
->redist
[rinfo
->type
].route_map
.name
&&
2237 rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
) {
2238 ret
= route_map_apply(
2239 rip
->redist
[rinfo
->type
].route_map
.map
,
2240 (struct prefix
*)p
, rinfo
);
2242 if (ret
== RMAP_DENYMATCH
) {
2243 if (IS_RIP_DEBUG_PACKET
)
2245 "%pFX is filtered by route-map",
2251 /* When route-map does not set metric. */
2252 if (!rinfo
->metric_set
) {
2253 /* If redistribute metric is set. */
2254 if (rip
->redist
[rinfo
->type
].metric_config
&&
2255 rinfo
->metric
!= RIP_METRIC_INFINITY
) {
2257 rip
->redist
[rinfo
->type
].metric
;
2259 /* If the route is not connected or localy
2260 * generated one, use default-metric value
2262 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&&
2263 rinfo
->type
!= ZEBRA_ROUTE_CONNECT
&&
2264 rinfo
->metric
!= RIP_METRIC_INFINITY
)
2265 rinfo
->metric_out
= rip
->default_metric
;
2269 /* Apply offset-list */
2270 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2271 rip_offset_list_apply_out(p
, ifc
->ifp
,
2272 &rinfo
->metric_out
);
2274 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2275 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2277 /* Perform split-horizon with poisoned reverse
2278 * for RIP and connected routes.
2280 if (ri
->split_horizon
== RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2282 * We perform split horizon for RIP and connected
2283 * route. For rip routes, we want to suppress the
2284 * route if we would end up sending the route back
2285 * on the interface that we learned it from, with a
2286 * higher metric. For connected routes, we suppress
2287 * the route if the prefix is a subset of the source
2288 * address that we are going to use for the packet
2289 * (in order to handle the case when multiple
2290 * subnets are configured on the same interface).
2292 struct rip_info
*tmp_rinfo
= NULL
;
2293 struct connected
*tmp_ifc
= NULL
;
2295 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, tmp_rinfo
))
2296 if (tmp_rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2297 tmp_rinfo
->nh
.ifindex
== ifc
->ifp
->ifindex
)
2298 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2300 if (rinfo
->metric_out
!= RIP_METRIC_INFINITY
&&
2301 rinfo
->type
== ZEBRA_ROUTE_CONNECT
) {
2302 for (ALL_LIST_ELEMENTS_RO(ifc
->ifp
->connected
,
2304 if (prefix_match((struct prefix
*)p
,
2305 tmp_ifc
->address
)) {
2307 RIP_METRIC_INFINITY
;
2313 /* Prepare preamble, auth headers, if needs be */
2315 stream_putc(s
, RIP_RESPONSE
);
2316 stream_putc(s
, version
);
2319 /* auth header for !v1 && !no_auth */
2320 if ((ri
->auth_type
!= RIP_NO_AUTH
) &&
2322 doff
= rip_auth_header_write(
2323 s
, ri
, key
, auth_str
,
2324 RIP_AUTH_SIMPLE_SIZE
);
2327 /* Write RTE to the stream. */
2328 num
= rip_write_rte(num
, s
, p
, version
, rinfo
);
2329 if (num
== rtemax
) {
2330 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2331 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2332 RIP_AUTH_SIMPLE_SIZE
);
2334 ret
= rip_send_packet(STREAM_DATA(s
),
2335 stream_get_endp(s
), to
, ifc
);
2337 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2339 (struct rip_packet
*)STREAM_DATA(s
),
2340 stream_get_endp(s
), "SEND");
2346 /* Flush unwritten RTE. */
2348 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2349 rip_auth_md5_set(s
, ri
, doff
, auth_str
,
2350 RIP_AUTH_SIMPLE_SIZE
);
2352 ret
= rip_send_packet(STREAM_DATA(s
), stream_get_endp(s
), to
,
2355 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2356 rip_packet_dump((struct rip_packet
*)STREAM_DATA(s
),
2357 stream_get_endp(s
), "SEND");
2361 /* Statistics updates. */
2365 /* Send RIP packet to the interface. */
2366 static void rip_update_interface(struct connected
*ifc
, uint8_t version
,
2369 struct interface
*ifp
= ifc
->ifp
;
2370 struct rip_interface
*ri
= ifp
->info
;
2371 struct sockaddr_in to
;
2373 /* When RIP version is 2 and multicast enable interface. */
2374 if (version
== RIPv2
&& !ri
->v2_broadcast
&& if_is_multicast(ifp
)) {
2375 if (IS_RIP_DEBUG_EVENT
)
2376 zlog_debug("multicast announce on %s ", ifp
->name
);
2378 rip_output_process(ifc
, NULL
, route_type
, version
);
2382 /* If we can't send multicast packet, send it with unicast. */
2383 if (if_is_broadcast(ifp
) || if_is_pointopoint(ifp
)) {
2384 if (ifc
->address
->family
== AF_INET
) {
2385 /* Destination address and port setting. */
2386 memset(&to
, 0, sizeof(to
));
2387 if (ifc
->destination
)
2388 /* use specified broadcast or peer destination
2390 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2391 else if (ifc
->address
->prefixlen
< IPV4_MAX_BITLEN
)
2392 /* calculate the appropriate broadcast address
2394 to
.sin_addr
.s_addr
= ipv4_broadcast_addr(
2395 ifc
->address
->u
.prefix4
.s_addr
,
2396 ifc
->address
->prefixlen
);
2398 /* do not know where to send the packet */
2400 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2402 if (IS_RIP_DEBUG_EVENT
)
2403 zlog_debug("%s announce to %pI4 on %s",
2404 CONNECTED_PEER(ifc
) ? "unicast"
2406 &to
.sin_addr
, ifp
->name
);
2408 rip_output_process(ifc
, &to
, route_type
, version
);
2413 /* Update send to all interface and neighbor. */
2414 static void rip_update_process(struct rip
*rip
, int route_type
)
2416 struct listnode
*ifnode
, *ifnnode
;
2417 struct connected
*connected
;
2418 struct interface
*ifp
;
2419 struct rip_interface
*ri
;
2420 struct route_node
*rp
;
2421 struct sockaddr_in to
;
2424 /* Send RIP update to each interface. */
2425 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
2426 if (if_is_loopback(ifp
))
2429 if (!if_is_operative(ifp
))
2432 /* Fetch RIP interface information. */
2435 /* When passive interface is specified, suppress announce to the
2444 * If there is no version configuration in the
2445 * interface, use rip's version setting.
2447 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
) ? rip
->version_send
2450 if (IS_RIP_DEBUG_EVENT
)
2451 zlog_debug("SEND UPDATE to %s ifindex %d", ifp
->name
,
2454 /* send update on each connected network */
2455 for (ALL_LIST_ELEMENTS(ifp
->connected
, ifnode
, ifnnode
,
2457 if (connected
->address
->family
== AF_INET
) {
2459 rip_update_interface(connected
, RIPv1
,
2461 if ((vsend
& RIPv2
) && if_is_multicast(ifp
))
2462 rip_update_interface(connected
, RIPv2
,
2468 /* RIP send updates to each neighbor. */
2469 for (rp
= route_top(rip
->neighbor
); rp
; rp
= route_next(rp
)) {
2470 if (rp
->info
== NULL
)
2475 connected
= if_lookup_address(&p
->u
.prefix4
, AF_INET
,
2479 "Neighbor %pI4 doesn't have connected interface!",
2484 /* Set destination address and port */
2485 memset(&to
, 0, sizeof(struct sockaddr_in
));
2486 to
.sin_addr
= p
->u
.prefix4
;
2487 to
.sin_port
= htons(RIP_PORT_DEFAULT
);
2489 /* RIP version is rip's configuration. */
2490 rip_output_process(connected
, &to
, route_type
,
2495 /* RIP's periodical timer. */
2496 static void rip_update(struct thread
*t
)
2498 struct rip
*rip
= THREAD_ARG(t
);
2500 if (IS_RIP_DEBUG_EVENT
)
2501 zlog_debug("update timer fire!");
2503 /* Process update output. */
2504 rip_update_process(rip
, rip_all_route
);
2506 /* Triggered updates may be suppressed if a regular update is due by
2507 the time the triggered update would be sent. */
2508 THREAD_OFF(rip
->t_triggered_interval
);
2511 /* Register myself. */
2512 rip_event(rip
, RIP_UPDATE_EVENT
, 0);
2515 /* Walk down the RIP routing table then clear changed flag. */
2516 static void rip_clear_changed_flag(struct rip
*rip
)
2518 struct route_node
*rp
;
2519 struct rip_info
*rinfo
= NULL
;
2520 struct list
*list
= NULL
;
2521 struct listnode
*listnode
= NULL
;
2523 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2529 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
2530 UNSET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2531 /* This flag can be set only on the first entry. */
2537 /* Triggered update interval timer. */
2538 static void rip_triggered_interval(struct thread
*t
)
2540 struct rip
*rip
= THREAD_ARG(t
);
2544 rip_triggered_update(t
);
2548 /* Execute triggered update. */
2549 static void rip_triggered_update(struct thread
*t
)
2551 struct rip
*rip
= THREAD_ARG(t
);
2554 /* Cancel interval timer. */
2555 THREAD_OFF(rip
->t_triggered_interval
);
2558 /* Logging triggered update. */
2559 if (IS_RIP_DEBUG_EVENT
)
2560 zlog_debug("triggered update!");
2562 /* Split Horizon processing is done when generating triggered
2563 updates as well as normal updates (see section 2.6). */
2564 rip_update_process(rip
, rip_changed_route
);
2566 /* Once all of the triggered updates have been generated, the route
2567 change flags should be cleared. */
2568 rip_clear_changed_flag(rip
);
2570 /* After a triggered update is sent, a timer should be set for a
2571 random interval between 1 and 5 seconds. If other changes that
2572 would trigger updates occur before the timer expires, a single
2573 update is triggered when the timer expires. */
2574 interval
= (frr_weak_random() % 5) + 1;
2576 thread_add_timer(master
, rip_triggered_interval
, rip
, interval
,
2577 &rip
->t_triggered_interval
);
2580 /* Withdraw redistributed route. */
2581 void rip_redistribute_withdraw(struct rip
*rip
, int type
)
2583 struct route_node
*rp
;
2584 struct rip_info
*rinfo
= NULL
;
2585 struct list
*list
= NULL
;
2587 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2593 rinfo
= listgetdata(listhead(list
));
2595 if (rinfo
->type
!= type
)
2598 if (rinfo
->sub_type
== RIP_ROUTE_INTERFACE
)
2601 /* Perform poisoned reverse. */
2602 rinfo
->metric
= RIP_METRIC_INFINITY
;
2603 RIP_TIMER_ON(rinfo
->t_garbage_collect
, rip_garbage_collect
,
2605 THREAD_OFF(rinfo
->t_timeout
);
2606 rinfo
->flags
|= RIP_RTF_CHANGED
;
2608 if (IS_RIP_DEBUG_EVENT
) {
2609 struct prefix_ipv4
*p
= (struct prefix_ipv4
*)&rp
->p
;
2612 "Poisone %pFX on the interface %s with an infinity metric [withdraw]",
2614 ifindex2ifname(rinfo
->nh
.ifindex
,
2618 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2622 struct rip
*rip_lookup_by_vrf_id(vrf_id_t vrf_id
)
2626 vrf
= vrf_lookup_by_id(vrf_id
);
2633 struct rip
*rip_lookup_by_vrf_name(const char *vrf_name
)
2637 rip
.vrf_name
= (char *)vrf_name
;
2639 return RB_FIND(rip_instance_head
, &rip_instances
, &rip
);
2642 /* Create new RIP instance and set it to global variable. */
2643 struct rip
*rip_create(const char *vrf_name
, struct vrf
*vrf
, int socket
)
2647 rip
= XCALLOC(MTYPE_RIP
, sizeof(struct rip
));
2648 rip
->vrf_name
= XSTRDUP(MTYPE_RIP_VRF_NAME
, vrf_name
);
2650 /* Set initial value. */
2651 rip
->ecmp
= yang_get_default_bool("%s/allow-ecmp", RIP_INSTANCE
);
2652 rip
->default_metric
=
2653 yang_get_default_uint8("%s/default-metric", RIP_INSTANCE
);
2655 yang_get_default_uint8("%s/distance/default", RIP_INSTANCE
);
2656 rip
->passive_default
=
2657 yang_get_default_bool("%s/passive-default", RIP_INSTANCE
);
2658 rip
->garbage_time
= yang_get_default_uint32("%s/timers/flush-interval",
2660 rip
->timeout_time
= yang_get_default_uint32(
2661 "%s/timers/holddown-interval", RIP_INSTANCE
);
2662 rip
->update_time
= yang_get_default_uint32("%s/timers/update-interval",
2665 yang_get_default_enum("%s/version/send", RIP_INSTANCE
);
2667 yang_get_default_enum("%s/version/receive", RIP_INSTANCE
);
2669 /* Initialize RIP data structures. */
2670 rip
->table
= route_table_init();
2671 route_table_set_info(rip
->table
, rip
);
2672 rip
->neighbor
= route_table_init();
2673 rip
->peer_list
= list_new();
2674 rip
->peer_list
->cmp
= (int (*)(void *, void *))rip_peer_list_cmp
;
2675 rip
->peer_list
->del
= rip_peer_list_del
;
2676 rip
->distance_table
= route_table_init();
2677 rip
->distance_table
->cleanup
= rip_distance_table_node_cleanup
;
2678 rip
->enable_interface
= vector_init(1);
2679 rip
->enable_network
= route_table_init();
2680 rip
->passive_nondefault
= vector_init(1);
2681 rip
->offset_list_master
= list_new();
2682 rip
->offset_list_master
->cmp
= (int (*)(void *, void *))offset_list_cmp
;
2683 rip
->offset_list_master
->del
= (void (*)(void *))offset_list_free
;
2685 /* Distribute list install. */
2686 rip
->distribute_ctx
= distribute_list_ctx_create(vrf
);
2687 distribute_list_add_hook(rip
->distribute_ctx
, rip_distribute_update
);
2688 distribute_list_delete_hook(rip
->distribute_ctx
, rip_distribute_update
);
2690 /* if rmap install. */
2691 rip
->if_rmap_ctx
= if_rmap_ctx_create(vrf_name
);
2692 if_rmap_hook_add(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2693 if_rmap_hook_delete(rip
->if_rmap_ctx
, rip_if_rmap_update
);
2695 /* Make output stream. */
2696 rip
->obuf
= stream_new(1500);
2698 /* Enable the routing instance if possible. */
2699 if (vrf
&& vrf_is_enabled(vrf
))
2700 rip_instance_enable(rip
, vrf
, socket
);
2706 RB_INSERT(rip_instance_head
, &rip_instances
, rip
);
2711 /* Sned RIP request to the destination. */
2712 int rip_request_send(struct sockaddr_in
*to
, struct interface
*ifp
,
2713 uint8_t version
, struct connected
*connected
)
2716 struct rip_packet rip_packet
;
2717 struct listnode
*node
, *nnode
;
2719 memset(&rip_packet
, 0, sizeof(rip_packet
));
2721 rip_packet
.command
= RIP_REQUEST
;
2722 rip_packet
.version
= version
;
2723 rte
= rip_packet
.rte
;
2724 rte
->metric
= htonl(RIP_METRIC_INFINITY
);
2728 * connected is only sent for ripv1 case, or when
2729 * interface does not support multicast. Caller loops
2730 * over each connected address for this case.
2732 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2734 != sizeof(rip_packet
))
2737 return sizeof(rip_packet
);
2740 /* send request on each connected network */
2741 for (ALL_LIST_ELEMENTS(ifp
->connected
, node
, nnode
, connected
)) {
2742 struct prefix_ipv4
*p
;
2744 p
= (struct prefix_ipv4
*)connected
->address
;
2746 if (p
->family
!= AF_INET
)
2749 if (rip_send_packet((uint8_t *)&rip_packet
, sizeof(rip_packet
),
2751 != sizeof(rip_packet
))
2754 return sizeof(rip_packet
);
2757 static int rip_update_jitter(unsigned long time
)
2759 #define JITTER_BOUND 4
2760 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2761 Given that, we cannot let time be less than JITTER_BOUND seconds.
2762 The RIPv2 RFC says jitter should be small compared to
2763 update_time. We consider 1/JITTER_BOUND to be small.
2766 int jitter_input
= time
;
2769 if (jitter_input
< JITTER_BOUND
)
2770 jitter_input
= JITTER_BOUND
;
2772 jitter
= (((frr_weak_random() % ((jitter_input
* 2) + 1))
2775 return jitter
/ JITTER_BOUND
;
2778 void rip_event(struct rip
*rip
, enum rip_event event
, int sock
)
2784 thread_add_read(master
, rip_read
, rip
, sock
, &rip
->t_read
);
2786 case RIP_UPDATE_EVENT
:
2787 THREAD_OFF(rip
->t_update
);
2788 jitter
= rip_update_jitter(rip
->update_time
);
2789 thread_add_timer(master
, rip_update
, rip
,
2790 sock
? 2 : rip
->update_time
+ jitter
,
2793 case RIP_TRIGGERED_UPDATE
:
2794 if (rip
->t_triggered_interval
)
2797 thread_add_event(master
, rip_triggered_update
, rip
, 0,
2798 &rip
->t_triggered_update
);
2805 struct rip_distance
*rip_distance_new(void)
2807 return XCALLOC(MTYPE_RIP_DISTANCE
, sizeof(struct rip_distance
));
2810 void rip_distance_free(struct rip_distance
*rdistance
)
2812 if (rdistance
->access_list
)
2813 free(rdistance
->access_list
);
2814 XFREE(MTYPE_RIP_DISTANCE
, rdistance
);
2817 static void rip_distance_table_node_cleanup(struct route_table
*table
,
2818 struct route_node
*node
)
2820 struct rip_distance
*rdistance
;
2822 rdistance
= node
->info
;
2824 rip_distance_free(rdistance
);
2827 /* Apply RIP information to distance method. */
2828 uint8_t rip_distance_apply(struct rip
*rip
, struct rip_info
*rinfo
)
2830 struct route_node
*rn
;
2831 struct prefix_ipv4 p
;
2832 struct rip_distance
*rdistance
;
2833 struct access_list
*alist
;
2835 memset(&p
, 0, sizeof(p
));
2837 p
.prefix
= rinfo
->from
;
2838 p
.prefixlen
= IPV4_MAX_BITLEN
;
2840 /* Check source address. */
2841 rn
= route_node_match(rip
->distance_table
, (struct prefix
*)&p
);
2843 rdistance
= rn
->info
;
2844 route_unlock_node(rn
);
2846 if (rdistance
->access_list
) {
2847 alist
= access_list_lookup(AFI_IP
,
2848 rdistance
->access_list
);
2851 if (access_list_apply(alist
, &rinfo
->rp
->p
)
2855 return rdistance
->distance
;
2857 return rdistance
->distance
;
2861 return rip
->distance
;
2866 static void rip_distance_show(struct vty
*vty
, struct rip
*rip
)
2868 struct route_node
*rn
;
2869 struct rip_distance
*rdistance
;
2873 vty_out(vty
, " Distance: (default is %u)\n",
2874 rip
->distance
? rip
->distance
: ZEBRA_RIP_DISTANCE_DEFAULT
);
2876 for (rn
= route_top(rip
->distance_table
); rn
; rn
= route_next(rn
)) {
2877 rdistance
= rn
->info
;
2879 if (rdistance
== NULL
)
2883 vty_out(vty
, " Address Distance List\n");
2886 snprintfrr(buf
, sizeof(buf
), "%pFX", &rn
->p
);
2887 vty_out(vty
, " %-20s %4d %s\n", buf
, rdistance
->distance
,
2888 rdistance
->access_list
? rdistance
->access_list
: "");
2892 /* Update ECMP routes to zebra when ECMP is disabled. */
2893 void rip_ecmp_disable(struct rip
*rip
)
2895 struct route_node
*rp
;
2896 struct rip_info
*rinfo
, *tmp_rinfo
;
2898 struct listnode
*node
, *nextnode
;
2900 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
2905 if (listcount(list
) == 0)
2908 rinfo
= listgetdata(listhead(list
));
2909 if (!rip_route_rte(rinfo
))
2912 /* Drop all other entries, except the first one. */
2913 for (ALL_LIST_ELEMENTS(list
, node
, nextnode
, tmp_rinfo
)) {
2914 if (tmp_rinfo
== rinfo
)
2917 THREAD_OFF(tmp_rinfo
->t_timeout
);
2918 THREAD_OFF(tmp_rinfo
->t_garbage_collect
);
2919 list_delete_node(list
, node
);
2920 rip_info_free(tmp_rinfo
);
2924 rip_zebra_ipv4_add(rip
, rp
);
2926 /* Set the route change flag. */
2927 SET_FLAG(rinfo
->flags
, RIP_RTF_CHANGED
);
2929 /* Signal the output process to trigger an update. */
2930 rip_event(rip
, RIP_TRIGGERED_UPDATE
, 0);
2934 /* Print out routes update time. */
2935 static void rip_vty_out_uptime(struct vty
*vty
, struct rip_info
*rinfo
)
2940 char timebuf
[TIME_BUF
];
2941 struct thread
*thread
;
2943 if ((thread
= rinfo
->t_timeout
) != NULL
) {
2944 clock
= thread_timer_remain_second(thread
);
2945 gmtime_r(&clock
, &tm
);
2946 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2947 vty_out(vty
, "%5s", timebuf
);
2948 } else if ((thread
= rinfo
->t_garbage_collect
) != NULL
) {
2949 clock
= thread_timer_remain_second(thread
);
2950 gmtime_r(&clock
, &tm
);
2951 strftime(timebuf
, TIME_BUF
, "%M:%S", &tm
);
2952 vty_out(vty
, "%5s", timebuf
);
2956 static const char *rip_route_type_print(int sub_type
)
2961 case RIP_ROUTE_STATIC
:
2963 case RIP_ROUTE_DEFAULT
:
2965 case RIP_ROUTE_REDISTRIBUTE
:
2967 case RIP_ROUTE_INTERFACE
:
2976 "show ip rip [vrf NAME]",
2983 struct route_node
*np
;
2984 struct rip_info
*rinfo
= NULL
;
2985 struct list
*list
= NULL
;
2986 struct listnode
*listnode
= NULL
;
2987 const char *vrf_name
;
2990 if (argv_find(argv
, argc
, "vrf", &idx
))
2991 vrf_name
= argv
[idx
+ 1]->arg
;
2993 vrf_name
= VRF_DEFAULT_NAME
;
2995 rip
= rip_lookup_by_vrf_name(vrf_name
);
2997 vty_out(vty
, "%% RIP instance not found\n");
3000 if (!rip
->enabled
) {
3001 vty_out(vty
, "%% RIP instance is disabled\n");
3006 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
3008 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
3009 " (i) - interface\n\n"
3010 " Network Next Hop Metric From Tag Time\n");
3012 for (np
= route_top(rip
->table
); np
; np
= route_next(np
)) {
3018 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3021 len
= vty_out(vty
, "%c(%s) %pFX",
3022 /* np->lock, For debugging. */
3023 zebra_route_char(rinfo
->type
),
3024 rip_route_type_print(rinfo
->sub_type
),
3030 vty_out(vty
, "%*s", len
, " ");
3032 switch (rinfo
->nh
.type
) {
3033 case NEXTHOP_TYPE_IPV4
:
3034 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3035 vty_out(vty
, "%-20pI4 %2d ",
3036 &rinfo
->nh
.gate
.ipv4
, rinfo
->metric
);
3038 case NEXTHOP_TYPE_IFINDEX
:
3039 vty_out(vty
, "0.0.0.0 %2d ",
3042 case NEXTHOP_TYPE_BLACKHOLE
:
3043 vty_out(vty
, "blackhole %2d ",
3046 case NEXTHOP_TYPE_IPV6
:
3047 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3048 vty_out(vty
, "V6 Address Hidden %2d ",
3053 /* Route which exist in kernel routing table. */
3054 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3055 (rinfo
->sub_type
== RIP_ROUTE_RTE
)) {
3056 vty_out(vty
, "%-15pI4 ", &rinfo
->from
);
3057 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3058 (route_tag_t
)rinfo
->tag
);
3059 rip_vty_out_uptime(vty
, rinfo
);
3060 } else if (rinfo
->metric
== RIP_METRIC_INFINITY
) {
3061 vty_out(vty
, "self ");
3062 vty_out(vty
, "%3" ROUTE_TAG_PRI
" ",
3063 (route_tag_t
)rinfo
->tag
);
3064 rip_vty_out_uptime(vty
, rinfo
);
3066 if (rinfo
->external_metric
) {
3068 vty
, "self (%s:%d)",
3069 zebra_route_string(rinfo
->type
),
3070 rinfo
->external_metric
);
3073 vty_out(vty
, "%*s", len
, " ");
3075 vty_out(vty
, "self ");
3076 vty_out(vty
, "%3" ROUTE_TAG_PRI
,
3077 (route_tag_t
)rinfo
->tag
);
3086 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3087 DEFUN (show_ip_rip_status
,
3088 show_ip_rip_status_cmd
,
3089 "show ip rip [vrf NAME] status",
3094 "IP routing protocol process parameters and statistics\n")
3097 struct interface
*ifp
;
3098 struct rip_interface
*ri
;
3099 extern const struct message ri_version_msg
[];
3100 const char *send_version
;
3101 const char *receive_version
;
3102 const char *vrf_name
;
3105 if (argv_find(argv
, argc
, "vrf", &idx
))
3106 vrf_name
= argv
[idx
+ 1]->arg
;
3108 vrf_name
= VRF_DEFAULT_NAME
;
3110 rip
= rip_lookup_by_vrf_name(vrf_name
);
3112 vty_out(vty
, "%% RIP instance not found\n");
3115 if (!rip
->enabled
) {
3116 vty_out(vty
, "%% RIP instance is disabled\n");
3120 vty_out(vty
, "Routing Protocol is \"rip\"\n");
3121 vty_out(vty
, " Sending updates every %u seconds with +/-50%%,",
3123 vty_out(vty
, " next due in %lu seconds\n",
3124 thread_timer_remain_second(rip
->t_update
));
3125 vty_out(vty
, " Timeout after %u seconds,", rip
->timeout_time
);
3126 vty_out(vty
, " garbage collect after %u seconds\n", rip
->garbage_time
);
3128 /* Filtering status show. */
3129 config_show_distribute(vty
, rip
->distribute_ctx
);
3131 /* Default metric information. */
3132 vty_out(vty
, " Default redistribution metric is %u\n",
3133 rip
->default_metric
);
3135 /* Redistribute information. */
3136 vty_out(vty
, " Redistributing:");
3137 rip_show_redistribute_config(vty
, rip
);
3140 vty_out(vty
, " Default version control: send version %s,",
3141 lookup_msg(ri_version_msg
, rip
->version_send
, NULL
));
3142 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3143 vty_out(vty
, " receive any version \n");
3145 vty_out(vty
, " receive version %s \n",
3146 lookup_msg(ri_version_msg
, rip
->version_recv
, NULL
));
3148 vty_out(vty
, " Interface Send Recv Key-chain\n");
3150 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3156 if (ri
->enable_network
|| ri
->enable_interface
) {
3157 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3159 lookup_msg(ri_version_msg
,
3160 rip
->version_send
, NULL
);
3162 send_version
= lookup_msg(ri_version_msg
,
3165 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3167 lookup_msg(ri_version_msg
,
3168 rip
->version_recv
, NULL
);
3170 receive_version
= lookup_msg(
3171 ri_version_msg
, ri
->ri_receive
, NULL
);
3173 vty_out(vty
, " %-17s%-3s %-3s %s\n", ifp
->name
,
3174 send_version
, receive_version
,
3175 ri
->key_chain
? ri
->key_chain
: "");
3179 vty_out(vty
, " Routing for Networks:\n");
3180 rip_show_network_config(vty
, rip
);
3182 int found_passive
= 0;
3183 FOR_ALL_INTERFACES (rip
->vrf
, ifp
) {
3186 if ((ri
->enable_network
|| ri
->enable_interface
) &&
3188 if (!found_passive
) {
3189 vty_out(vty
, " Passive Interface(s):\n");
3192 vty_out(vty
, " %s\n", ifp
->name
);
3196 vty_out(vty
, " Routing Information Sources:\n");
3198 " Gateway BadPackets BadRoutes Distance Last Update\n");
3199 rip_peer_display(vty
, rip
);
3201 rip_distance_show(vty
, rip
);
3206 /* RIP configuration write function. */
3207 static int config_write_rip(struct vty
*vty
)
3212 RB_FOREACH(rip
, rip_instance_head
, &rip_instances
) {
3213 char xpath
[XPATH_MAXLEN
];
3214 struct lyd_node
*dnode
;
3216 snprintf(xpath
, sizeof(xpath
),
3217 "/frr-ripd:ripd/instance[vrf='%s']", rip
->vrf_name
);
3219 dnode
= yang_dnode_get(running_config
->dnode
, xpath
);
3222 nb_cli_show_dnode_cmds(vty
, dnode
, false);
3224 /* Distribute configuration. */
3225 config_write_distribute(vty
, rip
->distribute_ctx
);
3227 /* Interface routemap configuration */
3228 config_write_if_rmap(vty
, rip
->if_rmap_ctx
);
3230 vty_out(vty
, "exit\n");
3238 static int config_write_rip(struct vty
*vty
);
3239 /* RIP node structure. */
3240 static struct cmd_node rip_node
= {
3243 .parent_node
= CONFIG_NODE
,
3244 .prompt
= "%s(config-router)# ",
3245 .config_write
= config_write_rip
,
3248 /* Distribute-list update functions. */
3249 static void rip_distribute_update(struct distribute_ctx
*ctx
,
3250 struct distribute
*dist
)
3252 struct interface
*ifp
;
3253 struct rip_interface
*ri
;
3254 struct access_list
*alist
;
3255 struct prefix_list
*plist
;
3257 if (!ctx
->vrf
|| !dist
->ifname
)
3260 ifp
= if_lookup_by_name(dist
->ifname
, ctx
->vrf
->vrf_id
);
3266 if (dist
->list
[DISTRIBUTE_V4_IN
]) {
3267 alist
= access_list_lookup(AFI_IP
,
3268 dist
->list
[DISTRIBUTE_V4_IN
]);
3270 ri
->list
[RIP_FILTER_IN
] = alist
;
3272 ri
->list
[RIP_FILTER_IN
] = NULL
;
3274 ri
->list
[RIP_FILTER_IN
] = NULL
;
3276 if (dist
->list
[DISTRIBUTE_V4_OUT
]) {
3277 alist
= access_list_lookup(AFI_IP
,
3278 dist
->list
[DISTRIBUTE_V4_OUT
]);
3280 ri
->list
[RIP_FILTER_OUT
] = alist
;
3282 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3284 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3286 if (dist
->prefix
[DISTRIBUTE_V4_IN
]) {
3287 plist
= prefix_list_lookup(AFI_IP
,
3288 dist
->prefix
[DISTRIBUTE_V4_IN
]);
3290 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3292 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3294 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3296 if (dist
->prefix
[DISTRIBUTE_V4_OUT
]) {
3297 plist
= prefix_list_lookup(AFI_IP
,
3298 dist
->prefix
[DISTRIBUTE_V4_OUT
]);
3300 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3302 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3304 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3307 void rip_distribute_update_interface(struct interface
*ifp
)
3309 struct rip_interface
*ri
= ifp
->info
;
3310 struct rip
*rip
= ri
->rip
;
3311 struct distribute
*dist
;
3315 dist
= distribute_lookup(rip
->distribute_ctx
, ifp
->name
);
3317 rip_distribute_update(rip
->distribute_ctx
, dist
);
3320 /* Update all interface's distribute list. */
3322 static void rip_distribute_update_all(struct prefix_list
*notused
)
3324 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3325 struct interface
*ifp
;
3327 FOR_ALL_INTERFACES (vrf
, ifp
)
3328 rip_distribute_update_interface(ifp
);
3331 static void rip_distribute_update_all_wrapper(struct access_list
*notused
)
3333 rip_distribute_update_all(NULL
);
3336 /* Delete all added rip route. */
3337 void rip_clean(struct rip
*rip
)
3339 rip_interfaces_clean(rip
);
3342 rip_instance_disable(rip
);
3344 stream_free(rip
->obuf
);
3346 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3347 if (rip
->redist
[i
].route_map
.name
)
3348 free(rip
->redist
[i
].route_map
.name
);
3350 route_table_finish(rip
->table
);
3351 route_table_finish(rip
->neighbor
);
3352 list_delete(&rip
->peer_list
);
3353 distribute_list_delete(&rip
->distribute_ctx
);
3354 if_rmap_ctx_delete(rip
->if_rmap_ctx
);
3356 rip_clean_network(rip
);
3357 rip_passive_nondefault_clean(rip
);
3358 vector_free(rip
->enable_interface
);
3359 route_table_finish(rip
->enable_network
);
3360 vector_free(rip
->passive_nondefault
);
3361 list_delete(&rip
->offset_list_master
);
3362 route_table_finish(rip
->distance_table
);
3364 RB_REMOVE(rip_instance_head
, &rip_instances
, rip
);
3365 XFREE(MTYPE_RIP_VRF_NAME
, rip
->vrf_name
);
3366 XFREE(MTYPE_RIP
, rip
);
3369 static void rip_if_rmap_update(struct if_rmap_ctx
*ctx
,
3370 struct if_rmap
*if_rmap
)
3372 struct interface
*ifp
= NULL
;
3373 struct rip_interface
*ri
;
3374 struct route_map
*rmap
;
3375 struct vrf
*vrf
= NULL
;
3378 vrf
= vrf_lookup_by_name(ctx
->name
);
3380 ifp
= if_lookup_by_name(if_rmap
->ifname
, vrf
->vrf_id
);
3385 if (if_rmap
->routemap
[IF_RMAP_IN
]) {
3386 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_IN
]);
3388 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3390 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3392 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3394 if (if_rmap
->routemap
[IF_RMAP_OUT
]) {
3395 rmap
= route_map_lookup_by_name(if_rmap
->routemap
[IF_RMAP_OUT
]);
3397 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3399 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3401 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3404 void rip_if_rmap_update_interface(struct interface
*ifp
)
3406 struct rip_interface
*ri
= ifp
->info
;
3407 struct rip
*rip
= ri
->rip
;
3408 struct if_rmap
*if_rmap
;
3409 struct if_rmap_ctx
*ctx
;
3413 ctx
= rip
->if_rmap_ctx
;
3416 if_rmap
= if_rmap_lookup(ctx
, ifp
->name
);
3418 rip_if_rmap_update(ctx
, if_rmap
);
3421 static void rip_routemap_update_redistribute(struct rip
*rip
)
3423 for (int i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3424 if (rip
->redist
[i
].route_map
.name
) {
3425 rip
->redist
[i
].route_map
.map
= route_map_lookup_by_name(
3426 rip
->redist
[i
].route_map
.name
);
3427 route_map_counter_increment(
3428 rip
->redist
[i
].route_map
.map
);
3434 static void rip_routemap_update(const char *notused
)
3436 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
3438 struct interface
*ifp
;
3440 FOR_ALL_INTERFACES (vrf
, ifp
)
3441 rip_if_rmap_update_interface(ifp
);
3445 rip_routemap_update_redistribute(rip
);
3448 /* Link RIP instance to VRF. */
3449 static void rip_vrf_link(struct rip
*rip
, struct vrf
*vrf
)
3451 struct interface
*ifp
;
3454 rip
->distribute_ctx
->vrf
= vrf
;
3457 FOR_ALL_INTERFACES (vrf
, ifp
)
3458 rip_interface_sync(ifp
);
3461 /* Unlink RIP instance from VRF. */
3462 static void rip_vrf_unlink(struct rip
*rip
, struct vrf
*vrf
)
3464 struct interface
*ifp
;
3467 rip
->distribute_ctx
->vrf
= NULL
;
3470 FOR_ALL_INTERFACES (vrf
, ifp
)
3471 rip_interface_sync(ifp
);
3474 static void rip_instance_enable(struct rip
*rip
, struct vrf
*vrf
, int sock
)
3478 rip_vrf_link(rip
, vrf
);
3479 rip
->enabled
= true;
3481 /* Resend all redistribute requests. */
3482 rip_redistribute_enable(rip
);
3484 /* Create read and timer thread. */
3485 rip_event(rip
, RIP_READ
, rip
->sock
);
3486 rip_event(rip
, RIP_UPDATE_EVENT
, 1);
3488 rip_zebra_vrf_register(vrf
);
3491 static void rip_instance_disable(struct rip
*rip
)
3493 struct vrf
*vrf
= rip
->vrf
;
3494 struct route_node
*rp
;
3496 /* Clear RIP routes */
3497 for (rp
= route_top(rip
->table
); rp
; rp
= route_next(rp
)) {
3498 struct rip_info
*rinfo
;
3500 struct listnode
*listnode
;
3502 if ((list
= rp
->info
) == NULL
)
3505 rinfo
= listgetdata(listhead(list
));
3506 if (rip_route_rte(rinfo
))
3507 rip_zebra_ipv4_delete(rip
, rp
);
3509 for (ALL_LIST_ELEMENTS_RO(list
, listnode
, rinfo
)) {
3510 THREAD_OFF(rinfo
->t_timeout
);
3511 THREAD_OFF(rinfo
->t_garbage_collect
);
3512 rip_info_free(rinfo
);
3516 route_unlock_node(rp
);
3519 /* Flush all redistribute requests. */
3520 rip_redistribute_disable(rip
);
3522 /* Cancel RIP related timers. */
3523 THREAD_OFF(rip
->t_update
);
3524 THREAD_OFF(rip
->t_triggered_update
);
3525 THREAD_OFF(rip
->t_triggered_interval
);
3527 /* Cancel read thread. */
3528 THREAD_OFF(rip
->t_read
);
3530 /* Close RIP socket. */
3534 /* Clear existing peers. */
3535 list_delete_all_node(rip
->peer_list
);
3537 rip_zebra_vrf_deregister(vrf
);
3539 rip_vrf_unlink(rip
, vrf
);
3540 rip
->enabled
= false;
3543 static int rip_vrf_new(struct vrf
*vrf
)
3545 if (IS_RIP_DEBUG_EVENT
)
3546 zlog_debug("%s: VRF created: %s(%u)", __func__
, vrf
->name
,
3552 static int rip_vrf_delete(struct vrf
*vrf
)
3556 if (IS_RIP_DEBUG_EVENT
)
3557 zlog_debug("%s: VRF deleted: %s(%u)", __func__
, vrf
->name
,
3560 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3569 static int rip_vrf_enable(struct vrf
*vrf
)
3574 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3575 if (!rip
|| rip
->enabled
)
3578 if (IS_RIP_DEBUG_EVENT
)
3579 zlog_debug("%s: VRF %s(%u) enabled", __func__
, vrf
->name
,
3582 /* Activate the VRF RIP instance. */
3583 if (!rip
->enabled
) {
3584 socket
= rip_create_socket(vrf
);
3588 rip_instance_enable(rip
, vrf
, socket
);
3594 static int rip_vrf_disable(struct vrf
*vrf
)
3598 rip
= rip_lookup_by_vrf_name(vrf
->name
);
3599 if (!rip
|| !rip
->enabled
)
3602 if (IS_RIP_DEBUG_EVENT
)
3603 zlog_debug("%s: VRF %s(%u) disabled", __func__
, vrf
->name
,
3606 /* Deactivate the VRF RIP instance. */
3608 rip_instance_disable(rip
);
3613 void rip_vrf_init(void)
3615 vrf_init(rip_vrf_new
, rip_vrf_enable
, rip_vrf_disable
, rip_vrf_delete
);
3620 void rip_vrf_terminate(void)
3625 /* Allocate new rip structure and set default value. */
3628 /* Install top nodes. */
3629 install_node(&rip_node
);
3631 /* Install rip commands. */
3632 install_element(VIEW_NODE
, &show_ip_rip_cmd
);
3633 install_element(VIEW_NODE
, &show_ip_rip_status_cmd
);
3635 install_default(RIP_NODE
);
3637 /* Debug related init. */
3640 /* Access list install. */
3642 access_list_add_hook(rip_distribute_update_all_wrapper
);
3643 access_list_delete_hook(rip_distribute_update_all_wrapper
);
3645 /* Prefix list initialize.*/
3647 prefix_list_add_hook(rip_distribute_update_all
);
3648 prefix_list_delete_hook(rip_distribute_update_all
);
3651 rip_route_map_init();
3653 route_map_add_hook(rip_routemap_update
);
3654 route_map_delete_hook(rip_routemap_update
);
3656 if_rmap_init(RIP_NODE
);