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
18 * along with GNU Zebra; see the file COPYING. If not, write to the Free
19 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
34 #include "sockunion.h"
39 #include "distribute.h"
44 #include "ripd/ripd.h"
45 #include "ripd/rip_debug.h"
47 /* UDP receive buffer size */
48 #define RIP_UDP_RCV_BUF 41600
50 /* privileges global */
51 extern struct zebra_privs_t ripd_privs
;
54 struct rip
*rip
= NULL
;
56 /* RIP neighbor address table. */
57 struct route_table
*rip_neighbor_table
;
59 /* RIP route changes. */
60 long rip_global_route_changes
= 0;
63 long rip_global_queries
= 0;
66 static void rip_event (enum rip_event
, int);
67 static void rip_output_process (struct connected
*, struct sockaddr_in
*, int, u_char
);
68 static int rip_triggered_update (struct thread
*);
69 static int rip_update_jitter (unsigned long);
71 /* RIP output routes type. */
78 /* RIP command strings. */
79 static const struct message rip_msg
[] =
81 {RIP_REQUEST
, "REQUEST"},
82 {RIP_RESPONSE
, "RESPONSE"},
83 {RIP_TRACEON
, "TRACEON"},
84 {RIP_TRACEOFF
, "TRACEOFF"},
86 {RIP_POLL_ENTRY
, "POLL ENTRY"},
90 /* Utility function to set boradcast option to the socket. */
92 sockopt_broadcast (int sock
)
97 ret
= setsockopt (sock
, SOL_SOCKET
, SO_BROADCAST
, (char *) &on
, sizeof on
);
100 zlog_warn ("can't set sockopt SO_BROADCAST to socket %d", sock
);
107 rip_route_rte (struct rip_info
*rinfo
)
109 return (rinfo
->type
== ZEBRA_ROUTE_RIP
&& rinfo
->sub_type
== RIP_ROUTE_RTE
);
112 static struct rip_info
*
115 return XCALLOC (MTYPE_RIP_INFO
, sizeof (struct rip_info
));
119 rip_info_free (struct rip_info
*rinfo
)
121 XFREE (MTYPE_RIP_INFO
, rinfo
);
124 /* RIP route garbage collect timer. */
126 rip_garbage_collect (struct thread
*t
)
128 struct rip_info
*rinfo
;
129 struct route_node
*rp
;
131 rinfo
= THREAD_ARG (t
);
132 rinfo
->t_garbage_collect
= NULL
;
134 /* Off timeout timer. */
135 RIP_TIMER_OFF (rinfo
->t_timeout
);
137 /* Get route_node pointer. */
140 /* Unlock route_node. */
142 route_unlock_node (rp
);
144 /* Free RIP routing information. */
145 rip_info_free (rinfo
);
150 /* Timeout RIP routes. */
152 rip_timeout (struct thread
*t
)
154 struct rip_info
*rinfo
;
155 struct route_node
*rn
;
157 rinfo
= THREAD_ARG (t
);
158 rinfo
->t_timeout
= NULL
;
162 /* - The garbage-collection timer is set for 120 seconds. */
163 RIP_TIMER_ON (rinfo
->t_garbage_collect
, rip_garbage_collect
,
166 rip_zebra_ipv4_delete ((struct prefix_ipv4
*)&rn
->p
, &rinfo
->nexthop
,
168 /* - The metric for the route is set to 16 (infinity). This causes
169 the route to be removed from service. */
170 rinfo
->metric
= RIP_METRIC_INFINITY
;
171 rinfo
->flags
&= ~RIP_RTF_FIB
;
173 /* - The route change flag is to indicate that this entry has been
175 rinfo
->flags
|= RIP_RTF_CHANGED
;
177 /* - The output process is signalled to trigger a response. */
178 rip_event (RIP_TRIGGERED_UPDATE
, 0);
184 rip_timeout_update (struct rip_info
*rinfo
)
186 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
188 RIP_TIMER_OFF (rinfo
->t_timeout
);
189 RIP_TIMER_ON (rinfo
->t_timeout
, rip_timeout
, rip
->timeout_time
);
194 rip_incoming_filter (struct prefix_ipv4
*p
, struct rip_interface
*ri
)
196 struct distribute
*dist
;
197 struct access_list
*alist
;
198 struct prefix_list
*plist
;
200 /* Input distribute-list filtering. */
201 if (ri
->list
[RIP_FILTER_IN
])
203 if (access_list_apply (ri
->list
[RIP_FILTER_IN
],
204 (struct prefix
*) p
) == FILTER_DENY
)
206 if (IS_RIP_DEBUG_PACKET
)
207 zlog_debug ("%s/%d filtered by distribute in",
208 inet_ntoa (p
->prefix
), p
->prefixlen
);
212 if (ri
->prefix
[RIP_FILTER_IN
])
214 if (prefix_list_apply (ri
->prefix
[RIP_FILTER_IN
],
215 (struct prefix
*) p
) == PREFIX_DENY
)
217 if (IS_RIP_DEBUG_PACKET
)
218 zlog_debug ("%s/%d filtered by prefix-list in",
219 inet_ntoa (p
->prefix
), p
->prefixlen
);
224 /* All interface filter check. */
225 dist
= distribute_lookup (NULL
);
228 if (dist
->list
[DISTRIBUTE_IN
])
230 alist
= access_list_lookup (AFI_IP
, dist
->list
[DISTRIBUTE_IN
]);
234 if (access_list_apply (alist
,
235 (struct prefix
*) p
) == FILTER_DENY
)
237 if (IS_RIP_DEBUG_PACKET
)
238 zlog_debug ("%s/%d filtered by distribute in",
239 inet_ntoa (p
->prefix
), p
->prefixlen
);
244 if (dist
->prefix
[DISTRIBUTE_IN
])
246 plist
= prefix_list_lookup (AFI_IP
, dist
->prefix
[DISTRIBUTE_IN
]);
250 if (prefix_list_apply (plist
,
251 (struct prefix
*) p
) == PREFIX_DENY
)
253 if (IS_RIP_DEBUG_PACKET
)
254 zlog_debug ("%s/%d filtered by prefix-list in",
255 inet_ntoa (p
->prefix
), p
->prefixlen
);
265 rip_outgoing_filter (struct prefix_ipv4
*p
, struct rip_interface
*ri
)
267 struct distribute
*dist
;
268 struct access_list
*alist
;
269 struct prefix_list
*plist
;
271 if (ri
->list
[RIP_FILTER_OUT
])
273 if (access_list_apply (ri
->list
[RIP_FILTER_OUT
],
274 (struct prefix
*) p
) == FILTER_DENY
)
276 if (IS_RIP_DEBUG_PACKET
)
277 zlog_debug ("%s/%d is filtered by distribute out",
278 inet_ntoa (p
->prefix
), p
->prefixlen
);
282 if (ri
->prefix
[RIP_FILTER_OUT
])
284 if (prefix_list_apply (ri
->prefix
[RIP_FILTER_OUT
],
285 (struct prefix
*) p
) == PREFIX_DENY
)
287 if (IS_RIP_DEBUG_PACKET
)
288 zlog_debug ("%s/%d is filtered by prefix-list out",
289 inet_ntoa (p
->prefix
), p
->prefixlen
);
294 /* All interface filter check. */
295 dist
= distribute_lookup (NULL
);
298 if (dist
->list
[DISTRIBUTE_OUT
])
300 alist
= access_list_lookup (AFI_IP
, dist
->list
[DISTRIBUTE_OUT
]);
304 if (access_list_apply (alist
,
305 (struct prefix
*) p
) == FILTER_DENY
)
307 if (IS_RIP_DEBUG_PACKET
)
308 zlog_debug ("%s/%d filtered by distribute out",
309 inet_ntoa (p
->prefix
), p
->prefixlen
);
314 if (dist
->prefix
[DISTRIBUTE_OUT
])
316 plist
= prefix_list_lookup (AFI_IP
, dist
->prefix
[DISTRIBUTE_OUT
]);
320 if (prefix_list_apply (plist
,
321 (struct prefix
*) p
) == PREFIX_DENY
)
323 if (IS_RIP_DEBUG_PACKET
)
324 zlog_debug ("%s/%d filtered by prefix-list out",
325 inet_ntoa (p
->prefix
), p
->prefixlen
);
334 /* Check nexthop address validity. */
336 rip_nexthop_check (struct in_addr
*addr
)
338 struct listnode
*node
;
339 struct listnode
*cnode
;
340 struct interface
*ifp
;
341 struct connected
*ifc
;
344 /* If nexthop address matches local configured address then it is
346 for (ALL_LIST_ELEMENTS_RO (iflist
, node
, ifp
))
348 for (ALL_LIST_ELEMENTS_RO (ifp
->connected
, cnode
, ifc
))
352 if (p
->family
== AF_INET
353 && IPV4_ADDR_SAME (&p
->u
.prefix4
, addr
))
360 /* RIP add route to routing table. */
362 rip_rte_process (struct rte
*rte
, struct sockaddr_in
*from
,
363 struct interface
*ifp
)
366 struct prefix_ipv4 p
;
367 struct route_node
*rp
;
368 struct rip_info
*rinfo
, rinfotmp
;
369 struct rip_interface
*ri
;
370 struct in_addr
*nexthop
;
374 unsigned char old_dist
, new_dist
;
376 /* Make prefix structure. */
377 memset (&p
, 0, sizeof (struct prefix_ipv4
));
379 p
.prefix
= rte
->prefix
;
380 p
.prefixlen
= ip_masklen (rte
->mask
);
382 /* Make sure mask is applied. */
383 apply_mask_ipv4 (&p
);
385 /* Apply input filters. */
388 ret
= rip_incoming_filter (&p
, ri
);
392 /* Modify entry according to the interface routemap. */
393 if (ri
->routemap
[RIP_FILTER_IN
])
396 struct rip_info newinfo
;
398 memset (&newinfo
, 0, sizeof (newinfo
));
399 newinfo
.type
= ZEBRA_ROUTE_RIP
;
400 newinfo
.sub_type
= RIP_ROUTE_RTE
;
401 newinfo
.nexthop
= rte
->nexthop
;
402 newinfo
.from
= from
->sin_addr
;
403 newinfo
.ifindex
= ifp
->ifindex
;
404 newinfo
.metric
= rte
->metric
;
405 newinfo
.metric_out
= rte
->metric
; /* XXX */
406 newinfo
.tag
= ntohs (rte
->tag
); /* XXX */
408 /* The object should be of the type of rip_info */
409 ret
= route_map_apply (ri
->routemap
[RIP_FILTER_IN
],
410 (struct prefix
*) &p
, RMAP_RIP
, &newinfo
);
412 if (ret
== RMAP_DENYMATCH
)
414 if (IS_RIP_DEBUG_PACKET
)
415 zlog_debug ("RIP %s/%d is filtered by route-map in",
416 inet_ntoa (p
.prefix
), p
.prefixlen
);
420 /* Get back the object */
421 rte
->nexthop
= newinfo
.nexthop_out
;
422 rte
->tag
= htons (newinfo
.tag_out
); /* XXX */
423 rte
->metric
= newinfo
.metric_out
; /* XXX: the routemap uses the metric_out field */
426 /* Once the entry has been validated, update the metric by
427 adding the cost of the network on wich the message
428 arrived. If the result is greater than infinity, use infinity
429 (RFC2453 Sec. 3.9.2) */
430 /* Zebra ripd can handle offset-list in. */
431 ret
= rip_offset_list_apply_in (&p
, ifp
, &rte
->metric
);
433 /* If offset-list does not modify the metric use interface's
436 rte
->metric
+= ifp
->metric
;
438 if (rte
->metric
> RIP_METRIC_INFINITY
)
439 rte
->metric
= RIP_METRIC_INFINITY
;
441 /* Set nexthop pointer. */
442 if (rte
->nexthop
.s_addr
== 0)
443 nexthop
= &from
->sin_addr
;
445 nexthop
= &rte
->nexthop
;
447 /* Check if nexthop address is myself, then do nothing. */
448 if (rip_nexthop_check (nexthop
) < 0)
450 if (IS_RIP_DEBUG_PACKET
)
451 zlog_debug ("Nexthop address %s is myself", inet_ntoa (*nexthop
));
455 /* Get index for the prefix. */
456 rp
= route_node_get (rip
->table
, (struct prefix
*) &p
);
458 /* Check to see whether there is already RIP route on the table. */
463 /* Local static route. */
464 if (rinfo
->type
== ZEBRA_ROUTE_RIP
465 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
) ||
466 (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
))
467 && rinfo
->metric
!= RIP_METRIC_INFINITY
)
469 route_unlock_node (rp
);
473 /* Redistributed route check. */
474 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
475 && rinfo
->metric
!= RIP_METRIC_INFINITY
)
477 /* Fill in a minimaly temporary rip_info structure, for a future
478 rip_distance_apply() use) */
479 memset (&rinfotmp
, 0, sizeof (rinfotmp
));
480 IPV4_ADDR_COPY (&rinfotmp
.from
, &from
->sin_addr
);
481 rinfotmp
.rp
= rinfo
->rp
;
482 new_dist
= rip_distance_apply (&rinfotmp
);
483 new_dist
= new_dist
? new_dist
: ZEBRA_RIP_DISTANCE_DEFAULT
;
484 old_dist
= rinfo
->distance
;
485 /* Only connected routes may have a valid NULL distance */
486 if (rinfo
->type
!= ZEBRA_ROUTE_CONNECT
)
487 old_dist
= old_dist
? old_dist
: ZEBRA_RIP_DISTANCE_DEFAULT
;
488 /* If imported route does not have STRICT precedence,
489 mark it as a ghost */
490 if (new_dist
> old_dist
491 || rte
->metric
== RIP_METRIC_INFINITY
)
493 route_unlock_node (rp
);
498 RIP_TIMER_OFF (rinfo
->t_timeout
);
499 RIP_TIMER_OFF (rinfo
->t_garbage_collect
);
502 if (rip_route_rte (rinfo
))
503 rip_zebra_ipv4_delete ((struct prefix_ipv4
*)&rp
->p
,
504 &rinfo
->nexthop
, rinfo
->metric
);
505 rip_info_free (rinfo
);
514 /* Now, check to see whether there is already an explicit route
515 for the destination prefix. If there is no such route, add
516 this route to the routing table, unless the metric is
517 infinity (there is no point in adding a route which
519 if (rte
->metric
!= RIP_METRIC_INFINITY
)
521 rinfo
= rip_info_new ();
523 /* - Setting the destination prefix and length to those in
527 /* - Setting the metric to the newly calculated metric (as
529 rinfo
->metric
= rte
->metric
;
530 rinfo
->tag
= ntohs (rte
->tag
);
532 /* - Set the next hop address to be the address of the router
533 from which the datagram came or the next hop address
534 specified by a next hop RTE. */
535 IPV4_ADDR_COPY (&rinfo
->nexthop
, nexthop
);
536 IPV4_ADDR_COPY (&rinfo
->from
, &from
->sin_addr
);
537 rinfo
->ifindex
= ifp
->ifindex
;
539 /* - Initialize the timeout for the route. If the
540 garbage-collection timer is running for this route, stop it
541 (see section 2.3 for a discussion of the timers). */
542 rip_timeout_update (rinfo
);
544 /* - Set the route change flag. */
545 rinfo
->flags
|= RIP_RTF_CHANGED
;
547 /* - Signal the output process to trigger an update (see section
549 rip_event (RIP_TRIGGERED_UPDATE
, 0);
551 /* Finally, route goes into the kernel. */
552 rinfo
->type
= ZEBRA_ROUTE_RIP
;
553 rinfo
->sub_type
= RIP_ROUTE_RTE
;
555 /* Set distance value. */
556 rinfo
->distance
= rip_distance_apply (rinfo
);
559 rip_zebra_ipv4_add (&p
, &rinfo
->nexthop
, rinfo
->metric
,
561 rinfo
->flags
|= RIP_RTF_FIB
;
564 /* Unlock temporary lock, i.e. same behaviour */
566 route_unlock_node (rp
);
570 /* Route is there but we are not sure the route is RIP or not. */
573 /* If there is an existing route, compare the next hop address
574 to the address of the router from which the datagram came.
575 If this datagram is from the same router as the existing
576 route, reinitialize the timeout. */
577 same
= (IPV4_ADDR_SAME (&rinfo
->from
, &from
->sin_addr
)
578 && (rinfo
->ifindex
== ifp
->ifindex
));
581 rip_timeout_update (rinfo
);
584 /* Fill in a minimaly temporary rip_info structure, for a future
585 rip_distance_apply() use) */
586 memset (&rinfotmp
, 0, sizeof (rinfotmp
));
587 IPV4_ADDR_COPY (&rinfotmp
.from
, &from
->sin_addr
);
588 rinfotmp
.rp
= rinfo
->rp
;
591 /* Next, compare the metrics. If the datagram is from the same
592 router as the existing route, and the new metric is different
593 than the old one; or, if the new metric is lower than the old
594 one, or if the tag has been changed; or if there is a route
595 with a lower administrave distance; or an update of the
596 distance on the actual route; do the following actions: */
597 if ((same
&& rinfo
->metric
!= rte
->metric
)
598 || (rte
->metric
< rinfo
->metric
)
600 && (rinfo
->metric
== rte
->metric
)
601 && ntohs (rte
->tag
) != rinfo
->tag
)
602 || (rinfo
->distance
> rip_distance_apply (&rinfotmp
))
603 || ((rinfo
->distance
!= rip_distance_apply (rinfo
)) && same
))
605 /* - Adopt the route from the datagram. That is, put the
606 new metric in, and adjust the next hop address (if
608 oldmetric
= rinfo
->metric
;
609 rinfo
->metric
= rte
->metric
;
610 rinfo
->tag
= ntohs (rte
->tag
);
611 IPV4_ADDR_COPY (&rinfo
->from
, &from
->sin_addr
);
612 rinfo
->ifindex
= ifp
->ifindex
;
613 rinfo
->distance
= rip_distance_apply (rinfo
);
615 /* Should a new route to this network be established
616 while the garbage-collection timer is running, the
617 new route will replace the one that is about to be
618 deleted. In this case the garbage-collection timer
621 if (oldmetric
== RIP_METRIC_INFINITY
&&
622 rinfo
->metric
< RIP_METRIC_INFINITY
)
624 rinfo
->type
= ZEBRA_ROUTE_RIP
;
625 rinfo
->sub_type
= RIP_ROUTE_RTE
;
627 RIP_TIMER_OFF (rinfo
->t_garbage_collect
);
629 if (!IPV4_ADDR_SAME (&rinfo
->nexthop
, nexthop
))
630 IPV4_ADDR_COPY (&rinfo
->nexthop
, nexthop
);
632 rip_zebra_ipv4_add (&p
, nexthop
, rinfo
->metric
,
634 rinfo
->flags
|= RIP_RTF_FIB
;
637 /* Update nexthop and/or metric value. */
638 if (oldmetric
!= RIP_METRIC_INFINITY
)
640 rip_zebra_ipv4_delete (&p
, &rinfo
->nexthop
, oldmetric
);
641 rip_zebra_ipv4_add (&p
, nexthop
, rinfo
->metric
,
643 rinfo
->flags
|= RIP_RTF_FIB
;
645 if (!IPV4_ADDR_SAME (&rinfo
->nexthop
, nexthop
))
646 IPV4_ADDR_COPY (&rinfo
->nexthop
, nexthop
);
649 /* - Set the route change flag and signal the output process
650 to trigger an update. */
651 rinfo
->flags
|= RIP_RTF_CHANGED
;
652 rip_event (RIP_TRIGGERED_UPDATE
, 0);
654 /* - If the new metric is infinity, start the deletion
655 process (described above); */
656 if (rinfo
->metric
== RIP_METRIC_INFINITY
)
658 /* If the new metric is infinity, the deletion process
659 begins for the route, which is no longer used for
660 routing packets. Note that the deletion process is
661 started only when the metric is first set to
662 infinity. If the metric was already infinity, then a
663 new deletion process is not started. */
664 if (oldmetric
!= RIP_METRIC_INFINITY
)
666 /* - The garbage-collection timer is set for 120 seconds. */
667 RIP_TIMER_ON (rinfo
->t_garbage_collect
,
668 rip_garbage_collect
, rip
->garbage_time
);
669 RIP_TIMER_OFF (rinfo
->t_timeout
);
671 /* - The metric for the route is set to 16
672 (infinity). This causes the route to be removed
674 rip_zebra_ipv4_delete (&p
, &rinfo
->nexthop
, oldmetric
);
675 rinfo
->flags
&= ~RIP_RTF_FIB
;
677 /* - The route change flag is to indicate that this
678 entry has been changed. */
679 /* - The output process is signalled to trigger a
681 ; /* Above processes are already done previously. */
686 /* otherwise, re-initialize the timeout. */
687 rip_timeout_update (rinfo
);
690 /* Unlock tempolary lock of the route. */
691 route_unlock_node (rp
);
695 /* Dump RIP packet */
697 rip_packet_dump (struct rip_packet
*packet
, int size
, const char *sndrcv
)
701 const char *command_str
;
702 char pbuf
[BUFSIZ
], nbuf
[BUFSIZ
];
706 /* Set command string. */
707 if (packet
->command
> 0 && packet
->command
< RIP_COMMAND_MAX
)
708 command_str
= lookup (rip_msg
, packet
->command
);
710 command_str
= "unknown";
712 /* Dump packet header. */
713 zlog_debug ("%s %s version %d packet size %d",
714 sndrcv
, command_str
, packet
->version
, size
);
716 /* Dump each routing table entry. */
719 for (lim
= (caddr_t
) packet
+ size
; (caddr_t
) rte
< lim
; rte
++)
721 if (packet
->version
== RIPv2
)
723 netmask
= ip_masklen (rte
->mask
);
725 if (rte
->family
== htons (RIP_FAMILY_AUTH
))
727 if (rte
->tag
== htons (RIP_AUTH_SIMPLE_PASSWORD
))
729 p
= (u_char
*)&rte
->prefix
;
731 zlog_debug (" family 0x%X type %d auth string: %s",
732 ntohs (rte
->family
), ntohs (rte
->tag
), p
);
734 else if (rte
->tag
== htons (RIP_AUTH_MD5
))
736 struct rip_md5_info
*md5
;
738 md5
= (struct rip_md5_info
*) &packet
->rte
;
740 zlog_debug (" family 0x%X type %d (MD5 authentication)",
741 ntohs (md5
->family
), ntohs (md5
->type
));
742 zlog_debug (" RIP-2 packet len %d Key ID %d"
744 ntohs (md5
->packet_len
), md5
->keyid
,
746 zlog_debug (" Sequence Number %ld",
747 (u_long
) ntohl (md5
->sequence
));
749 else if (rte
->tag
== htons (RIP_AUTH_DATA
))
751 p
= (u_char
*)&rte
->prefix
;
753 zlog_debug (" family 0x%X type %d (MD5 data)",
754 ntohs (rte
->family
), ntohs (rte
->tag
));
755 zlog_debug (" MD5: %02X%02X%02X%02X%02X%02X%02X%02X"
756 "%02X%02X%02X%02X%02X%02X%02X",
757 p
[0], p
[1], p
[2], p
[3], p
[4], p
[5], p
[6],
758 p
[7], p
[9], p
[10], p
[11], p
[12], p
[13],
763 zlog_debug (" family 0x%X type %d (Unknown auth type)",
764 ntohs (rte
->family
), ntohs (rte
->tag
));
768 zlog_debug (" %s/%d -> %s family %d tag %d metric %ld",
769 inet_ntop (AF_INET
, &rte
->prefix
, pbuf
, BUFSIZ
),
770 netmask
, inet_ntop (AF_INET
, &rte
->nexthop
, nbuf
,
771 BUFSIZ
), ntohs (rte
->family
),
772 ntohs (rte
->tag
), (u_long
) ntohl (rte
->metric
));
776 zlog_debug (" %s family %d tag %d metric %ld",
777 inet_ntop (AF_INET
, &rte
->prefix
, pbuf
, BUFSIZ
),
778 ntohs (rte
->family
), ntohs (rte
->tag
),
779 (u_long
)ntohl (rte
->metric
));
784 /* Check if the destination address is valid (unicast; not net 0
785 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
786 check net 0 because we accept default route. */
788 rip_destination_check (struct in_addr addr
)
790 u_int32_t destination
;
792 /* Convert to host byte order. */
793 destination
= ntohl (addr
.s_addr
);
795 if (IPV4_NET127 (destination
))
798 /* Net 0 may match to the default route. */
799 if (IPV4_NET0 (destination
) && destination
!= 0)
802 /* Unicast address must belong to class A, B, C. */
803 if (IN_CLASSA (destination
))
805 if (IN_CLASSB (destination
))
807 if (IN_CLASSC (destination
))
813 /* RIP version 2 authentication. */
815 rip_auth_simple_password (struct rte
*rte
, struct sockaddr_in
*from
,
816 struct interface
*ifp
)
818 struct rip_interface
*ri
;
821 if (IS_RIP_DEBUG_EVENT
)
822 zlog_debug ("RIPv2 simple password authentication from %s",
823 inet_ntoa (from
->sin_addr
));
827 if (ri
->auth_type
!= RIP_AUTH_SIMPLE_PASSWORD
828 || rte
->tag
!= htons(RIP_AUTH_SIMPLE_PASSWORD
))
831 /* Simple password authentication. */
834 auth_str
= (char *) &rte
->prefix
;
836 if (strncmp (auth_str
, ri
->auth_str
, 16) == 0)
841 struct keychain
*keychain
;
844 keychain
= keychain_lookup (ri
->key_chain
);
845 if (keychain
== NULL
)
848 key
= key_match_for_accept (keychain
, (char *) &rte
->prefix
);
855 /* RIP version 2 authentication with MD5. */
857 rip_auth_md5 (struct rip_packet
*packet
, struct sockaddr_in
*from
,
858 int length
, struct interface
*ifp
)
860 struct rip_interface
*ri
;
861 struct rip_md5_info
*md5
;
862 struct rip_md5_data
*md5data
;
863 struct keychain
*keychain
;
866 u_char digest
[RIP_AUTH_MD5_SIZE
];
867 u_int16_t packet_len
;
868 char auth_str
[RIP_AUTH_MD5_SIZE
];
870 if (IS_RIP_DEBUG_EVENT
)
871 zlog_debug ("RIPv2 MD5 authentication from %s",
872 inet_ntoa (from
->sin_addr
));
875 md5
= (struct rip_md5_info
*) &packet
->rte
;
877 /* Check auth type. */
878 if (ri
->auth_type
!= RIP_AUTH_MD5
|| md5
->type
!= htons(RIP_AUTH_MD5
))
881 /* If the authentication length is less than 16, then it must be wrong for
882 * any interpretation of rfc2082. Some implementations also interpret
883 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka RIP_AUTH_MD5_COMPAT_SIZE.
885 if ( !((md5
->auth_len
== RIP_AUTH_MD5_SIZE
)
886 || (md5
->auth_len
== RIP_AUTH_MD5_COMPAT_SIZE
)))
888 if (IS_RIP_DEBUG_EVENT
)
889 zlog_debug ("RIPv2 MD5 authentication, strange authentication "
890 "length field %d", md5
->auth_len
);
894 /* grab and verify check packet length */
895 packet_len
= ntohs (md5
->packet_len
);
897 if (packet_len
> (length
- RIP_HEADER_SIZE
- RIP_AUTH_MD5_SIZE
))
899 if (IS_RIP_DEBUG_EVENT
)
900 zlog_debug ("RIPv2 MD5 authentication, packet length field %d "
901 "greater than received length %d!",
902 md5
->packet_len
, length
);
906 /* retrieve authentication data */
907 md5data
= (struct rip_md5_data
*) (((u_char
*) packet
) + packet_len
);
909 memset (auth_str
, 0, RIP_AUTH_MD5_SIZE
);
913 keychain
= keychain_lookup (ri
->key_chain
);
914 if (keychain
== NULL
)
917 key
= key_lookup_for_accept (keychain
, md5
->keyid
);
921 strncpy (auth_str
, key
->string
, RIP_AUTH_MD5_SIZE
);
923 else if (ri
->auth_str
)
924 strncpy (auth_str
, ri
->auth_str
, RIP_AUTH_MD5_SIZE
);
926 if (auth_str
[0] == 0)
929 /* MD5 digest authentication. */
930 memset (&ctx
, 0, sizeof(ctx
));
932 MD5Update(&ctx
, packet
, packet_len
+ RIP_HEADER_SIZE
);
933 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
934 MD5Final(digest
, &ctx
);
936 if (memcmp (md5data
->digest
, digest
, RIP_AUTH_MD5_SIZE
) == 0)
942 /* Pick correct auth string for sends, prepare auth_str buffer for use.
943 * (left justified and padded).
945 * presumes one of ri or key is valid, and that the auth strings they point
946 * to are nul terminated. If neither are present, auth_str will be fully
951 rip_auth_prepare_str_send (struct rip_interface
*ri
, struct key
*key
,
952 char *auth_str
, int len
)
956 memset (auth_str
, 0, len
);
957 if (key
&& key
->string
)
958 strncpy (auth_str
, key
->string
, len
);
959 else if (ri
->auth_str
)
960 strncpy (auth_str
, ri
->auth_str
, len
);
965 /* Write RIPv2 simple password authentication information
967 * auth_str is presumed to be 2 bytes and correctly prepared
968 * (left justified and zero padded).
971 rip_auth_simple_write (struct stream
*s
, char *auth_str
, int len
)
973 assert (s
&& len
== RIP_AUTH_SIMPLE_SIZE
);
975 stream_putw (s
, RIP_FAMILY_AUTH
);
976 stream_putw (s
, RIP_AUTH_SIMPLE_PASSWORD
);
977 stream_put (s
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
982 /* write RIPv2 MD5 "authentication header"
983 * (uses the auth key data field)
985 * Digest offset field is set to 0.
987 * returns: offset of the digest offset field, which must be set when
988 * length to the auth-data MD5 digest is known.
991 rip_auth_md5_ah_write (struct stream
*s
, struct rip_interface
*ri
,
996 assert (s
&& ri
&& ri
->auth_type
== RIP_AUTH_MD5
);
998 /* MD5 authentication. */
999 stream_putw (s
, RIP_FAMILY_AUTH
);
1000 stream_putw (s
, RIP_AUTH_MD5
);
1002 /* MD5 AH digest offset field.
1004 * Set to placeholder value here, to true value when RIP-2 Packet length
1005 * is known. Actual value is set in .....().
1007 doff
= stream_get_endp(s
);
1012 stream_putc (s
, key
->index
% 256);
1016 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1017 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for this
1018 * to be configurable.
1020 stream_putc (s
, ri
->md5_auth_len
);
1022 /* Sequence Number (non-decreasing). */
1023 /* RFC2080: The value used in the sequence number is
1024 arbitrary, but two suggestions are the time of the
1025 message's creation or a simple message counter. */
1026 stream_putl (s
, time (NULL
));
1028 /* Reserved field must be zero. */
1035 /* If authentication is in used, write the appropriate header
1036 * returns stream offset to which length must later be written
1037 * or 0 if this is not required
1040 rip_auth_header_write (struct stream
*s
, struct rip_interface
*ri
,
1041 struct key
*key
, char *auth_str
, int len
)
1043 assert (ri
->auth_type
!= RIP_NO_AUTH
);
1045 switch (ri
->auth_type
)
1047 case RIP_AUTH_SIMPLE_PASSWORD
:
1048 rip_auth_prepare_str_send (ri
, key
, auth_str
, len
);
1049 rip_auth_simple_write (s
, auth_str
, len
);
1052 return rip_auth_md5_ah_write (s
, ri
, key
);
1058 /* Write RIPv2 MD5 authentication data trailer */
1060 rip_auth_md5_set (struct stream
*s
, struct rip_interface
*ri
, size_t doff
,
1061 char *auth_str
, int authlen
)
1065 unsigned char digest
[RIP_AUTH_MD5_SIZE
];
1067 /* Make it sure this interface is configured as MD5
1069 assert ((ri
->auth_type
== RIP_AUTH_MD5
) && (authlen
== RIP_AUTH_MD5_SIZE
));
1072 /* Get packet length. */
1073 len
= stream_get_endp(s
);
1075 /* Check packet length. */
1076 if (len
< (RIP_HEADER_SIZE
+ RIP_RTE_SIZE
))
1078 zlog_err ("rip_auth_md5_set(): packet length %ld is less than minimum length.", len
);
1082 /* Set the digest offset length in the header */
1083 stream_putw_at (s
, doff
, len
);
1085 /* Set authentication data. */
1086 stream_putw (s
, RIP_FAMILY_AUTH
);
1087 stream_putw (s
, RIP_AUTH_DATA
);
1089 /* Generate a digest for the RIP packet. */
1090 memset(&ctx
, 0, sizeof(ctx
));
1092 MD5Update(&ctx
, STREAM_DATA (s
), stream_get_endp (s
));
1093 MD5Update(&ctx
, auth_str
, RIP_AUTH_MD5_SIZE
);
1094 MD5Final(digest
, &ctx
);
1096 /* Copy the digest to the packet. */
1097 stream_write (s
, digest
, RIP_AUTH_MD5_SIZE
);
1100 /* RIP routing information. */
1102 rip_response_process (struct rip_packet
*packet
, int size
,
1103 struct sockaddr_in
*from
, struct connected
*ifc
)
1107 struct prefix_ipv4 ifaddr
;
1108 struct prefix_ipv4 ifaddrclass
;
1111 /* We don't know yet. */
1114 /* The Response must be ignored if it is not from the RIP
1115 port. (RFC2453 - Sec. 3.9.2)*/
1116 if (from
->sin_port
!= htons(RIP_PORT_DEFAULT
))
1118 zlog_info ("response doesn't come from RIP port: %d",
1120 rip_peer_bad_packet (from
);
1124 /* The datagram's IPv4 source address should be checked to see
1125 whether the datagram is from a valid neighbor; the source of the
1126 datagram must be on a directly connected network (RFC2453 - Sec. 3.9.2) */
1127 if (if_lookup_address(from
->sin_addr
) == NULL
)
1129 zlog_info ("This datagram doesn't came from a valid neighbor: %s",
1130 inet_ntoa (from
->sin_addr
));
1131 rip_peer_bad_packet (from
);
1135 /* It is also worth checking to see whether the response is from one
1136 of the router's own addresses. */
1138 ; /* Alredy done in rip_read () */
1140 /* Update RIP peer. */
1141 rip_peer_update (from
, packet
->version
);
1143 /* Set RTE pointer. */
1146 for (lim
= (caddr_t
) packet
+ size
; (caddr_t
) rte
< lim
; rte
++)
1148 /* RIPv2 authentication check. */
1149 /* If the Address Family Identifier of the first (and only the
1150 first) entry in the message is 0xFFFF, then the remainder of
1151 the entry contains the authentication. */
1152 /* If the packet gets here it means authentication enabled */
1153 /* Check is done in rip_read(). So, just skipping it */
1154 if (packet
->version
== RIPv2
&&
1155 rte
== packet
->rte
&&
1156 rte
->family
== htons(RIP_FAMILY_AUTH
))
1159 if (rte
->family
!= htons(AF_INET
))
1161 /* Address family check. RIP only supports AF_INET. */
1162 zlog_info ("Unsupported family %d from %s.",
1163 ntohs (rte
->family
), inet_ntoa (from
->sin_addr
));
1167 /* - is the destination address valid (e.g., unicast; not net 0
1169 if (! rip_destination_check (rte
->prefix
))
1171 zlog_info ("Network is net 0 or net 127 or it is not unicast network");
1172 rip_peer_bad_route (from
);
1176 /* Convert metric value to host byte order. */
1177 rte
->metric
= ntohl (rte
->metric
);
1179 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1180 if (! (rte
->metric
>= 1 && rte
->metric
<= 16))
1182 zlog_info ("Route's metric is not in the 1-16 range.");
1183 rip_peer_bad_route (from
);
1187 /* RIPv1 does not have nexthop value. */
1188 if (packet
->version
== RIPv1
&& rte
->nexthop
.s_addr
!= 0)
1190 zlog_info ("RIPv1 packet with nexthop value %s",
1191 inet_ntoa (rte
->nexthop
));
1192 rip_peer_bad_route (from
);
1196 /* That is, if the provided information is ignored, a possibly
1197 sub-optimal, but absolutely valid, route may be taken. If
1198 the received Next Hop is not directly reachable, it should be
1199 treated as 0.0.0.0. */
1200 if (packet
->version
== RIPv2
&& rte
->nexthop
.s_addr
!= 0)
1204 /* Multicast address check. */
1205 addrval
= ntohl (rte
->nexthop
.s_addr
);
1206 if (IN_CLASSD (addrval
))
1208 zlog_info ("Nexthop %s is multicast address, skip this rte",
1209 inet_ntoa (rte
->nexthop
));
1213 if (! if_lookup_address (rte
->nexthop
))
1215 struct route_node
*rn
;
1216 struct rip_info
*rinfo
;
1218 rn
= route_node_match_ipv4 (rip
->table
, &rte
->nexthop
);
1224 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1225 && rinfo
->sub_type
== RIP_ROUTE_RTE
)
1227 if (IS_RIP_DEBUG_EVENT
)
1228 zlog_debug ("Next hop %s is on RIP network. Set nexthop to the packet's originator", inet_ntoa (rte
->nexthop
));
1229 rte
->nexthop
= rinfo
->from
;
1233 if (IS_RIP_DEBUG_EVENT
)
1234 zlog_debug ("Next hop %s is not directly reachable. Treat it as 0.0.0.0", inet_ntoa (rte
->nexthop
));
1235 rte
->nexthop
.s_addr
= 0;
1238 route_unlock_node (rn
);
1242 if (IS_RIP_DEBUG_EVENT
)
1243 zlog_debug ("Next hop %s is not directly reachable. Treat it as 0.0.0.0", inet_ntoa (rte
->nexthop
));
1244 rte
->nexthop
.s_addr
= 0;
1250 /* For RIPv1, there won't be a valid netmask.
1252 This is a best guess at the masks. If everyone was using old
1253 Ciscos before the 'ip subnet zero' option, it would be almost
1256 Cisco summarize ripv1 advertisments to the classful boundary
1257 (/16 for class B's) except when the RIP packet does to inside
1258 the classful network in question. */
1260 if ((packet
->version
== RIPv1
&& rte
->prefix
.s_addr
!= 0)
1261 || (packet
->version
== RIPv2
1262 && (rte
->prefix
.s_addr
!= 0 && rte
->mask
.s_addr
== 0)))
1264 u_int32_t destination
;
1266 if (subnetted
== -1)
1268 memcpy (&ifaddr
, ifc
->address
, sizeof (struct prefix_ipv4
));
1269 memcpy (&ifaddrclass
, &ifaddr
, sizeof (struct prefix_ipv4
));
1270 apply_classful_mask_ipv4 (&ifaddrclass
);
1272 if (ifaddr
.prefixlen
> ifaddrclass
.prefixlen
)
1276 destination
= ntohl (rte
->prefix
.s_addr
);
1278 if (IN_CLASSA (destination
))
1279 masklen2ip (8, &rte
->mask
);
1280 else if (IN_CLASSB (destination
))
1281 masklen2ip (16, &rte
->mask
);
1282 else if (IN_CLASSC (destination
))
1283 masklen2ip (24, &rte
->mask
);
1286 masklen2ip (ifaddrclass
.prefixlen
,
1287 (struct in_addr
*) &destination
);
1288 if ((subnetted
== 1) && ((rte
->prefix
.s_addr
& destination
) ==
1289 ifaddrclass
.prefix
.s_addr
))
1291 masklen2ip (ifaddr
.prefixlen
, &rte
->mask
);
1292 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
) != rte
->prefix
.s_addr
)
1293 masklen2ip (32, &rte
->mask
);
1294 if (IS_RIP_DEBUG_EVENT
)
1295 zlog_debug ("Subnetted route %s", inet_ntoa (rte
->prefix
));
1299 if ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
) != rte
->prefix
.s_addr
)
1303 if (IS_RIP_DEBUG_EVENT
)
1305 zlog_debug ("Resultant route %s", inet_ntoa (rte
->prefix
));
1306 zlog_debug ("Resultant mask %s", inet_ntoa (rte
->mask
));
1310 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1311 ignore the entry. */
1312 if ((packet
->version
== RIPv2
)
1313 && (rte
->mask
.s_addr
!= 0)
1314 && ((rte
->prefix
.s_addr
& rte
->mask
.s_addr
) != rte
->prefix
.s_addr
))
1316 zlog_warn ("RIPv2 address %s is not mask /%d applied one",
1317 inet_ntoa (rte
->prefix
), ip_masklen (rte
->mask
));
1318 rip_peer_bad_route (from
);
1322 /* Default route's netmask is ignored. */
1323 if (packet
->version
== RIPv2
1324 && (rte
->prefix
.s_addr
== 0)
1325 && (rte
->mask
.s_addr
!= 0))
1327 if (IS_RIP_DEBUG_EVENT
)
1328 zlog_debug ("Default route with non-zero netmask. Set zero to netmask");
1329 rte
->mask
.s_addr
= 0;
1332 /* Routing table updates. */
1333 rip_rte_process (rte
, from
, ifc
->ifp
);
1337 /* Make socket for RIP protocol. */
1339 rip_create_socket (struct sockaddr_in
*from
)
1343 struct sockaddr_in addr
;
1345 memset (&addr
, 0, sizeof (struct sockaddr_in
));
1349 addr
.sin_family
= AF_INET
;
1350 addr
.sin_addr
.s_addr
= INADDR_ANY
;
1351 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1352 addr
.sin_len
= sizeof (struct sockaddr_in
);
1353 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1355 memcpy(&addr
, from
, sizeof(addr
));
1358 /* sending port must always be the RIP port */
1359 addr
.sin_port
= htons (RIP_PORT_DEFAULT
);
1361 /* Make datagram socket. */
1362 sock
= socket (AF_INET
, SOCK_DGRAM
, 0);
1365 zlog_err("Cannot create UDP socket: %s", safe_strerror(errno
));
1369 sockopt_broadcast (sock
);
1370 sockopt_reuseaddr (sock
);
1371 sockopt_reuseport (sock
);
1373 setsockopt_pktinfo (sock
);
1374 #endif /* RIP_RECVMSG */
1376 if (ripd_privs
.change (ZPRIVS_RAISE
))
1377 zlog_err ("rip_create_socket: could not raise privs");
1378 setsockopt_so_recvbuf (sock
, RIP_UDP_RCV_BUF
);
1379 if ( (ret
= bind (sock
, (struct sockaddr
*) & addr
, sizeof (addr
))) < 0)
1382 int save_errno
= errno
;
1383 if (ripd_privs
.change (ZPRIVS_LOWER
))
1384 zlog_err ("rip_create_socket: could not lower privs");
1386 zlog_err("%s: Can't bind socket %d to %s port %d: %s", __func__
,
1387 sock
, inet_ntoa(addr
.sin_addr
),
1388 (int) ntohs(addr
.sin_port
),
1389 safe_strerror(save_errno
));
1395 if (ripd_privs
.change (ZPRIVS_LOWER
))
1396 zlog_err ("rip_create_socket: could not lower privs");
1401 /* RIP packet send to destination address, on interface denoted by
1402 * by connected argument. NULL to argument denotes destination should be
1403 * should be RIP multicast group
1406 rip_send_packet (u_char
* buf
, int size
, struct sockaddr_in
*to
,
1407 struct connected
*ifc
)
1410 struct sockaddr_in sin
;
1412 assert (ifc
!= NULL
);
1414 if (IS_RIP_DEBUG_PACKET
)
1416 #define ADDRESS_SIZE 20
1417 char dst
[ADDRESS_SIZE
];
1418 dst
[ADDRESS_SIZE
- 1] = '\0';
1422 strncpy (dst
, inet_ntoa(to
->sin_addr
), ADDRESS_SIZE
- 1);
1426 sin
.sin_addr
.s_addr
= htonl (INADDR_RIP_GROUP
);
1427 strncpy (dst
, inet_ntoa(sin
.sin_addr
), ADDRESS_SIZE
- 1);
1430 zlog_debug("rip_send_packet %s > %s (%s)",
1431 inet_ntoa(ifc
->address
->u
.prefix4
),
1432 dst
, ifc
->ifp
->name
);
1435 if ( CHECK_FLAG (ifc
->flags
, ZEBRA_IFA_SECONDARY
) )
1438 * ZEBRA_IFA_SECONDARY is set on linux when an interface is configured
1439 * with multiple addresses on the same subnet: the first address
1440 * on the subnet is configured "primary", and all subsequent addresses
1441 * on that subnet are treated as "secondary" addresses.
1442 * In order to avoid routing-table bloat on other rip listeners,
1443 * we do not send out RIP packets with ZEBRA_IFA_SECONDARY source addrs.
1444 * XXX Since Linux is the only system for which the ZEBRA_IFA_SECONDARY
1445 * flag is set, we would end up sending a packet for a "secondary"
1446 * source address on non-linux systems.
1448 if (IS_RIP_DEBUG_PACKET
)
1449 zlog_debug("duplicate dropped");
1453 /* Make destination address. */
1454 memset (&sin
, 0, sizeof (struct sockaddr_in
));
1455 sin
.sin_family
= AF_INET
;
1456 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1457 sin
.sin_len
= sizeof (struct sockaddr_in
);
1458 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1460 /* When destination is specified, use it's port and address. */
1463 sin
.sin_port
= to
->sin_port
;
1464 sin
.sin_addr
= to
->sin_addr
;
1465 send_sock
= rip
->sock
;
1469 struct sockaddr_in from
;
1471 sin
.sin_port
= htons (RIP_PORT_DEFAULT
);
1472 sin
.sin_addr
.s_addr
= htonl (INADDR_RIP_GROUP
);
1474 /* multicast send should bind to local interface address */
1475 from
.sin_family
= AF_INET
;
1476 from
.sin_port
= htons (RIP_PORT_DEFAULT
);
1477 from
.sin_addr
= ifc
->address
->u
.prefix4
;
1478 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1479 from
.sin_len
= sizeof (struct sockaddr_in
);
1480 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1483 * we have to open a new socket for each packet because this
1484 * is the most portable way to bind to a different source
1485 * ipv4 address for each packet.
1487 if ( (send_sock
= rip_create_socket (&from
)) < 0)
1489 zlog_warn("rip_send_packet could not create socket.");
1492 rip_interface_multicast_set (send_sock
, ifc
);
1495 ret
= sendto (send_sock
, buf
, size
, 0, (struct sockaddr
*)&sin
,
1496 sizeof (struct sockaddr_in
));
1498 if (IS_RIP_DEBUG_EVENT
)
1499 zlog_debug ("SEND to %s.%d", inet_ntoa(sin
.sin_addr
),
1500 ntohs (sin
.sin_port
));
1503 zlog_warn ("can't send packet : %s", safe_strerror (errno
));
1511 /* Add redistributed route to RIP table. */
1513 rip_redistribute_add (int type
, int sub_type
, struct prefix_ipv4
*p
,
1514 unsigned int ifindex
, struct in_addr
*nexthop
,
1515 unsigned int metric
, unsigned char distance
)
1518 struct route_node
*rp
;
1519 struct rip_info
*rinfo
;
1521 /* Redistribute route */
1522 ret
= rip_destination_check (p
->prefix
);
1526 rp
= route_node_get (rip
->table
, (struct prefix
*) p
);
1532 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
1533 && rinfo
->sub_type
== RIP_ROUTE_INTERFACE
1534 && rinfo
->metric
!= RIP_METRIC_INFINITY
)
1536 route_unlock_node (rp
);
1540 /* Manually configured RIP route check. */
1541 if (rinfo
->type
== ZEBRA_ROUTE_RIP
1542 && ((rinfo
->sub_type
== RIP_ROUTE_STATIC
) ||
1543 (rinfo
->sub_type
== RIP_ROUTE_DEFAULT
)) )
1545 if (type
!= ZEBRA_ROUTE_RIP
|| ((sub_type
!= RIP_ROUTE_STATIC
) &&
1546 (sub_type
!= RIP_ROUTE_DEFAULT
)))
1548 route_unlock_node (rp
);
1553 RIP_TIMER_OFF (rinfo
->t_timeout
);
1554 RIP_TIMER_OFF (rinfo
->t_garbage_collect
);
1556 if (rip_route_rte (rinfo
))
1557 rip_zebra_ipv4_delete ((struct prefix_ipv4
*)&rp
->p
, &rinfo
->nexthop
,
1560 rip_info_free (rinfo
);
1562 route_unlock_node (rp
);
1565 rinfo
= rip_info_new ();
1568 rinfo
->sub_type
= sub_type
;
1569 rinfo
->ifindex
= ifindex
;
1571 rinfo
->external_metric
= metric
;
1572 rinfo
->distance
= distance
;
1576 rinfo
->nexthop
= *nexthop
;
1578 rinfo
->flags
|= RIP_RTF_FIB
;
1581 rinfo
->flags
|= RIP_RTF_CHANGED
;
1583 if (IS_RIP_DEBUG_EVENT
) {
1585 zlog_debug ("Redistribute new prefix %s/%d on the interface %s",
1586 inet_ntoa(p
->prefix
), p
->prefixlen
,
1587 ifindex2ifname(ifindex
));
1589 zlog_debug ("Redistribute new prefix %s/%d with nexthop %s on the interface %s",
1590 inet_ntoa(p
->prefix
), p
->prefixlen
, inet_ntoa(rinfo
->nexthop
),
1591 ifindex2ifname(ifindex
));
1595 rip_event (RIP_TRIGGERED_UPDATE
, 0);
1598 /* Delete redistributed route from RIP table. */
1600 rip_redistribute_delete (int type
, int sub_type
, struct prefix_ipv4
*p
,
1601 unsigned int ifindex
)
1604 struct route_node
*rp
;
1605 struct rip_info
*rinfo
;
1607 ret
= rip_destination_check (p
->prefix
);
1611 rp
= route_node_lookup (rip
->table
, (struct prefix
*) p
);
1617 && rinfo
->type
== type
1618 && rinfo
->sub_type
== sub_type
1619 && rinfo
->ifindex
== ifindex
)
1621 /* Perform poisoned reverse. */
1622 rinfo
->metric
= RIP_METRIC_INFINITY
;
1623 RIP_TIMER_ON (rinfo
->t_garbage_collect
,
1624 rip_garbage_collect
, rip
->garbage_time
);
1625 RIP_TIMER_OFF (rinfo
->t_timeout
);
1626 rinfo
->flags
|= RIP_RTF_CHANGED
;
1628 if (IS_RIP_DEBUG_EVENT
)
1629 zlog_debug ("Poisone %s/%d on the interface %s with an infinity metric [delete]",
1630 inet_ntoa(p
->prefix
), p
->prefixlen
,
1631 ifindex2ifname(ifindex
));
1633 rip_event (RIP_TRIGGERED_UPDATE
, 0);
1638 /* Response to request called from rip_read ().*/
1640 rip_request_process (struct rip_packet
*packet
, int size
,
1641 struct sockaddr_in
*from
, struct connected
*ifc
)
1645 struct prefix_ipv4 p
;
1646 struct route_node
*rp
;
1647 struct rip_info
*rinfo
;
1648 struct rip_interface
*ri
;
1650 /* Does not reponse to the requests on the loopback interfaces */
1651 if (if_is_loopback (ifc
->ifp
))
1654 /* Check RIP process is enabled on this interface. */
1655 ri
= ifc
->ifp
->info
;
1659 /* When passive interface is specified, suppress responses */
1663 /* RIP peer update. */
1664 rip_peer_update (from
, packet
->version
);
1666 lim
= ((caddr_t
) packet
) + size
;
1669 /* The Request is processed entry by entry. If there are no
1670 entries, no response is given. */
1671 if (lim
== (caddr_t
) rte
)
1674 /* There is one special case. If there is exactly one entry in the
1675 request, and it has an address family identifier of zero and a
1676 metric of infinity (i.e., 16), then this is a request to send the
1677 entire routing table. */
1678 if (lim
== ((caddr_t
) (rte
+ 1)) &&
1679 ntohs (rte
->family
) == 0 &&
1680 ntohl (rte
->metric
) == RIP_METRIC_INFINITY
)
1682 struct prefix_ipv4 saddr
;
1684 /* saddr will be used for determining which routes to split-horizon.
1685 Since the source address we'll pick will be on the same subnet as the
1686 destination, for the purpose of split-horizoning, we'll
1687 pretend that "from" is our source address. */
1688 saddr
.family
= AF_INET
;
1689 saddr
.prefixlen
= IPV4_MAX_BITLEN
;
1690 saddr
.prefix
= from
->sin_addr
;
1692 /* All route with split horizon */
1693 rip_output_process (ifc
, from
, rip_all_route
, packet
->version
);
1697 /* Examine the list of RTEs in the Request one by one. For each
1698 entry, look up the destination in the router's routing
1699 database and, if there is a route, put that route's metric in
1700 the metric field of the RTE. If there is no explicit route
1701 to the specified destination, put infinity in the metric
1702 field. Once all the entries have been filled in, change the
1703 command from Request to Response and send the datagram back
1704 to the requestor. */
1707 for (; ((caddr_t
) rte
) < lim
; rte
++)
1709 p
.prefix
= rte
->prefix
;
1710 p
.prefixlen
= ip_masklen (rte
->mask
);
1711 apply_mask_ipv4 (&p
);
1713 rp
= route_node_lookup (rip
->table
, (struct prefix
*) &p
);
1717 rte
->metric
= htonl (rinfo
->metric
);
1718 route_unlock_node (rp
);
1721 rte
->metric
= htonl (RIP_METRIC_INFINITY
);
1723 packet
->command
= RIP_RESPONSE
;
1725 rip_send_packet ((u_char
*)packet
, size
, from
, ifc
);
1727 rip_global_queries
++;
1731 /* Set IPv6 packet info to the socket. */
1733 setsockopt_pktinfo (int sock
)
1738 ret
= setsockopt(sock
, IPPROTO_IP
, IP_PKTINFO
, &val
, sizeof(val
));
1740 zlog_warn ("Can't setsockopt IP_PKTINFO : %s", safe_strerror (errno
));
1744 /* Read RIP packet by recvmsg function. */
1746 rip_recvmsg (int sock
, u_char
*buf
, int size
, struct sockaddr_in
*from
,
1752 struct cmsghdr
*ptr
;
1755 msg
.msg_name
= (void *) from
;
1756 msg
.msg_namelen
= sizeof (struct sockaddr_in
);
1759 msg
.msg_control
= (void *) adata
;
1760 msg
.msg_controllen
= sizeof adata
;
1764 ret
= recvmsg (sock
, &msg
, 0);
1768 for (ptr
= ZCMSG_FIRSTHDR(&msg
); ptr
!= NULL
; ptr
= CMSG_NXTHDR(&msg
, ptr
))
1769 if (ptr
->cmsg_level
== IPPROTO_IP
&& ptr
->cmsg_type
== IP_PKTINFO
)
1771 struct in_pktinfo
*pktinfo
;
1774 pktinfo
= (struct in_pktinfo
*) CMSG_DATA (ptr
);
1775 i
= pktinfo
->ipi_ifindex
;
1780 /* RIP packet read function. */
1782 rip_read_new (struct thread
*t
)
1786 char buf
[RIP_PACKET_MAXSIZ
];
1787 struct sockaddr_in from
;
1788 unsigned int ifindex
;
1790 /* Fetch socket then register myself. */
1791 sock
= THREAD_FD (t
);
1792 rip_event (RIP_READ
, sock
);
1794 /* Read RIP packet. */
1795 ret
= rip_recvmsg (sock
, buf
, RIP_PACKET_MAXSIZ
, &from
, (int *)&ifindex
);
1798 zlog_warn ("Can't read RIP packet: %s", safe_strerror (errno
));
1804 #endif /* RIP_RECVMSG */
1806 /* First entry point of RIP packet. */
1808 rip_read (struct thread
*t
)
1813 union rip_buf rip_buf
;
1814 struct rip_packet
*packet
;
1815 struct sockaddr_in from
;
1819 struct interface
*ifp
;
1820 struct connected
*ifc
;
1821 struct rip_interface
*ri
;
1823 /* Fetch socket then register myself. */
1824 sock
= THREAD_FD (t
);
1827 /* Add myself to tne next event */
1828 rip_event (RIP_READ
, sock
);
1830 /* RIPd manages only IPv4. */
1831 memset (&from
, 0, sizeof (struct sockaddr_in
));
1832 fromlen
= sizeof (struct sockaddr_in
);
1834 len
= recvfrom (sock
, (char *)&rip_buf
.buf
, sizeof (rip_buf
.buf
), 0,
1835 (struct sockaddr
*) &from
, &fromlen
);
1838 zlog_info ("recvfrom failed: %s", safe_strerror (errno
));
1842 /* Check is this packet comming from myself? */
1843 if (if_check_address (from
.sin_addr
))
1845 if (IS_RIP_DEBUG_PACKET
)
1846 zlog_debug ("ignore packet comes from myself");
1850 /* Which interface is this packet comes from. */
1851 ifp
= if_lookup_address (from
.sin_addr
);
1853 /* RIP packet received */
1854 if (IS_RIP_DEBUG_EVENT
)
1855 zlog_debug ("RECV packet from %s port %d on %s",
1856 inet_ntoa (from
.sin_addr
), ntohs (from
.sin_port
),
1857 ifp
? ifp
->name
: "unknown");
1859 /* If this packet come from unknown interface, ignore it. */
1862 zlog_info ("rip_read: cannot find interface for packet from %s port %d",
1863 inet_ntoa(from
.sin_addr
), ntohs (from
.sin_port
));
1867 ifc
= connected_lookup_address (ifp
, from
.sin_addr
);
1871 zlog_info ("rip_read: cannot find connected address for packet from %s "
1872 "port %d on interface %s",
1873 inet_ntoa(from
.sin_addr
), ntohs (from
.sin_port
), ifp
->name
);
1877 /* Packet length check. */
1878 if (len
< RIP_PACKET_MINSIZ
)
1880 zlog_warn ("packet size %d is smaller than minimum size %d",
1881 len
, RIP_PACKET_MINSIZ
);
1882 rip_peer_bad_packet (&from
);
1885 if (len
> RIP_PACKET_MAXSIZ
)
1887 zlog_warn ("packet size %d is larger than max size %d",
1888 len
, RIP_PACKET_MAXSIZ
);
1889 rip_peer_bad_packet (&from
);
1893 /* Packet alignment check. */
1894 if ((len
- RIP_PACKET_MINSIZ
) % 20)
1896 zlog_warn ("packet size %d is wrong for RIP packet alignment", len
);
1897 rip_peer_bad_packet (&from
);
1901 /* Set RTE number. */
1902 rtenum
= ((len
- RIP_PACKET_MINSIZ
) / 20);
1904 /* For easy to handle. */
1905 packet
= &rip_buf
.rip_packet
;
1907 /* RIP version check. */
1908 if (packet
->version
== 0)
1910 zlog_info ("version 0 with command %d received.", packet
->command
);
1911 rip_peer_bad_packet (&from
);
1915 /* Dump RIP packet. */
1916 if (IS_RIP_DEBUG_RECV
)
1917 rip_packet_dump (packet
, len
, "RECV");
1919 /* RIP version adjust. This code should rethink now. RFC1058 says
1920 that "Version 1 implementations are to ignore this extra data and
1921 process only the fields specified in this document.". So RIPv3
1922 packet should be treated as RIPv1 ignoring must be zero field. */
1923 if (packet
->version
> RIPv2
)
1924 packet
->version
= RIPv2
;
1926 /* Is RIP running or is this RIP neighbor ?*/
1928 if (! ri
->running
&& ! rip_neighbor_lookup (&from
))
1930 if (IS_RIP_DEBUG_EVENT
)
1931 zlog_debug ("RIP is not enabled on interface %s.", ifp
->name
);
1932 rip_peer_bad_packet (&from
);
1936 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1937 vrecv
= ((ri
->ri_receive
== RI_RIP_UNSPEC
) ?
1938 rip
->version_recv
: ri
->ri_receive
);
1939 if ((packet
->version
== RIPv1
) && !(vrecv
& RIPv1
))
1941 if (IS_RIP_DEBUG_PACKET
)
1942 zlog_debug (" packet's v%d doesn't fit to if version spec",
1944 rip_peer_bad_packet (&from
);
1947 if ((packet
->version
== RIPv2
) && !(vrecv
& RIPv2
))
1949 if (IS_RIP_DEBUG_PACKET
)
1950 zlog_debug (" packet's v%d doesn't fit to if version spec",
1952 rip_peer_bad_packet (&from
);
1956 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1957 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1958 accepted; authenticated RIP-2 messages shall be discarded. */
1959 if ((ri
->auth_type
== RIP_NO_AUTH
)
1961 && (packet
->version
== RIPv2
)
1962 && (packet
->rte
->family
== htons(RIP_FAMILY_AUTH
)))
1964 if (IS_RIP_DEBUG_EVENT
)
1965 zlog_debug ("packet RIPv%d is dropped because authentication disabled",
1967 rip_peer_bad_packet (&from
);
1972 If the router is configured to authenticate RIP-2 messages, then
1973 RIP-1 messages and RIP-2 messages which pass authentication
1974 testing shall be accepted; unauthenticated and failed
1975 authentication RIP-2 messages shall be discarded. For maximum
1976 security, RIP-1 messages should be ignored when authentication is
1977 in use (see section 4.1); otherwise, the routing information from
1978 authenticated messages will be propagated by RIP-1 routers in an
1979 unauthenticated manner.
1981 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1982 * always reply regardless of authentication settings, because:
1984 * - if there other authorised routers on-link, the REQUESTor can
1985 * passively obtain the routing updates anyway
1986 * - if there are no other authorised routers on-link, RIP can
1987 * easily be disabled for the link to prevent giving out information
1988 * on state of this routers RIP routing table..
1990 * I.e. if RIPv1 has any place anymore these days, it's as a very
1991 * simple way to distribute routing information (e.g. to embedded
1992 * hosts / appliances) and the ability to give out RIPv1
1993 * routing-information freely, while still requiring RIPv2
1994 * authentication for any RESPONSEs might be vaguely useful.
1996 if (ri
->auth_type
!= RIP_NO_AUTH
1997 && packet
->version
== RIPv1
)
1999 /* Discard RIPv1 messages other than REQUESTs */
2000 if (packet
->command
!= RIP_REQUEST
)
2002 if (IS_RIP_DEBUG_PACKET
)
2003 zlog_debug ("RIPv1" " dropped because authentication enabled");
2004 rip_peer_bad_packet (&from
);
2008 else if (ri
->auth_type
!= RIP_NO_AUTH
)
2010 const char *auth_desc
;
2014 /* There definitely is no authentication in the packet. */
2015 if (IS_RIP_DEBUG_PACKET
)
2016 zlog_debug ("RIPv2 authentication failed: no auth RTE in packet");
2017 rip_peer_bad_packet (&from
);
2021 /* First RTE must be an Authentication Family RTE */
2022 if (packet
->rte
->family
!= htons(RIP_FAMILY_AUTH
))
2024 if (IS_RIP_DEBUG_PACKET
)
2025 zlog_debug ("RIPv2" " dropped because authentication enabled");
2026 rip_peer_bad_packet (&from
);
2030 /* Check RIPv2 authentication. */
2031 switch (ntohs(packet
->rte
->tag
))
2033 case RIP_AUTH_SIMPLE_PASSWORD
:
2034 auth_desc
= "simple";
2035 ret
= rip_auth_simple_password (packet
->rte
, &from
, ifp
);
2040 ret
= rip_auth_md5 (packet
, &from
, len
, ifp
);
2041 /* Reset RIP packet length to trim MD5 data. */
2047 auth_desc
= "unknown type";
2048 if (IS_RIP_DEBUG_PACKET
)
2049 zlog_debug ("RIPv2 Unknown authentication type %d",
2050 ntohs (packet
->rte
->tag
));
2055 if (IS_RIP_DEBUG_PACKET
)
2056 zlog_debug ("RIPv2 %s authentication success", auth_desc
);
2060 if (IS_RIP_DEBUG_PACKET
)
2061 zlog_debug ("RIPv2 %s authentication failure", auth_desc
);
2062 rip_peer_bad_packet (&from
);
2067 /* Process each command. */
2068 switch (packet
->command
)
2071 rip_response_process (packet
, len
, &from
, ifc
);
2075 rip_request_process (packet
, len
, &from
, ifc
);
2079 zlog_info ("Obsolete command %s received, please sent it to routed",
2080 lookup (rip_msg
, packet
->command
));
2081 rip_peer_bad_packet (&from
);
2083 case RIP_POLL_ENTRY
:
2084 zlog_info ("Obsolete command %s received",
2085 lookup (rip_msg
, packet
->command
));
2086 rip_peer_bad_packet (&from
);
2089 zlog_info ("Unknown RIP command %d received", packet
->command
);
2090 rip_peer_bad_packet (&from
);
2097 /* Write routing table entry to the stream and return next index of
2098 the routing table entry in the stream. */
2100 rip_write_rte (int num
, struct stream
*s
, struct prefix_ipv4
*p
,
2101 u_char version
, struct rip_info
*rinfo
)
2103 struct in_addr mask
;
2105 /* Write routing table entry. */
2106 if (version
== RIPv1
)
2108 stream_putw (s
, AF_INET
);
2110 stream_put_ipv4 (s
, p
->prefix
.s_addr
);
2111 stream_put_ipv4 (s
, 0);
2112 stream_put_ipv4 (s
, 0);
2113 stream_putl (s
, rinfo
->metric_out
);
2117 masklen2ip (p
->prefixlen
, &mask
);
2119 stream_putw (s
, AF_INET
);
2120 stream_putw (s
, rinfo
->tag_out
);
2121 stream_put_ipv4 (s
, p
->prefix
.s_addr
);
2122 stream_put_ipv4 (s
, mask
.s_addr
);
2123 stream_put_ipv4 (s
, rinfo
->nexthop_out
.s_addr
);
2124 stream_putl (s
, rinfo
->metric_out
);
2130 /* Send update to the ifp or spcified neighbor. */
2132 rip_output_process (struct connected
*ifc
, struct sockaddr_in
*to
,
2133 int route_type
, u_char version
)
2137 struct route_node
*rp
;
2138 struct rip_info
*rinfo
;
2139 struct rip_interface
*ri
;
2140 struct prefix_ipv4
*p
;
2141 struct prefix_ipv4 classfull
;
2142 struct prefix_ipv4 ifaddrclass
;
2143 struct key
*key
= NULL
;
2144 /* this might need to made dynamic if RIP ever supported auth methods
2145 with larger key string sizes */
2146 char auth_str
[RIP_AUTH_SIMPLE_SIZE
];
2147 size_t doff
= 0; /* offset of digest offset field */
2152 /* Logging output event. */
2153 if (IS_RIP_DEBUG_EVENT
)
2156 zlog_debug ("update routes to neighbor %s", inet_ntoa (to
->sin_addr
));
2158 zlog_debug ("update routes on interface %s ifindex %d",
2159 ifc
->ifp
->name
, ifc
->ifp
->ifindex
);
2162 /* Set output stream. */
2165 /* Reset stream and RTE counter. */
2167 rtemax
= (RIP_PACKET_MAXSIZ
- 4) / 20;
2169 /* Get RIP interface. */
2170 ri
= ifc
->ifp
->info
;
2172 /* If output interface is in simple password authentication mode, we
2173 need space for authentication data. */
2174 if (ri
->auth_type
== RIP_AUTH_SIMPLE_PASSWORD
)
2177 /* If output interface is in MD5 authentication mode, we need space
2178 for authentication header and data. */
2179 if (ri
->auth_type
== RIP_AUTH_MD5
)
2182 /* If output interface is in simple password authentication mode
2183 and string or keychain is specified we need space for auth. data */
2184 if (ri
->auth_type
!= RIP_NO_AUTH
)
2188 struct keychain
*keychain
;
2190 keychain
= keychain_lookup (ri
->key_chain
);
2192 key
= key_lookup_for_send (keychain
);
2194 /* to be passed to auth functions later */
2195 rip_auth_prepare_str_send (ri
, key
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
2198 if (version
== RIPv1
)
2200 memcpy (&ifaddrclass
, ifc
->address
, sizeof (struct prefix_ipv4
));
2201 apply_classful_mask_ipv4 (&ifaddrclass
);
2203 if (ifc
->address
->prefixlen
> ifaddrclass
.prefixlen
)
2207 for (rp
= route_top (rip
->table
); rp
; rp
= route_next (rp
))
2208 if ((rinfo
= rp
->info
) != NULL
)
2210 /* For RIPv1, if we are subnetted, output subnets in our network */
2211 /* that have the same mask as the output "interface". For other */
2212 /* networks, only the classfull version is output. */
2214 if (version
== RIPv1
)
2216 p
= (struct prefix_ipv4
*) &rp
->p
;
2218 if (IS_RIP_DEBUG_PACKET
)
2219 zlog_debug("RIPv1 mask check, %s/%d considered for output",
2220 inet_ntoa (rp
->p
.u
.prefix4
), rp
->p
.prefixlen
);
2223 prefix_match ((struct prefix
*) &ifaddrclass
, &rp
->p
))
2225 if ((ifc
->address
->prefixlen
!= rp
->p
.prefixlen
) &&
2226 (rp
->p
.prefixlen
!= 32))
2231 memcpy (&classfull
, &rp
->p
, sizeof(struct prefix_ipv4
));
2232 apply_classful_mask_ipv4(&classfull
);
2233 if (rp
->p
.u
.prefix4
.s_addr
!= 0 &&
2234 classfull
.prefixlen
!= rp
->p
.prefixlen
)
2237 if (IS_RIP_DEBUG_PACKET
)
2238 zlog_debug("RIPv1 mask check, %s/%d made it through",
2239 inet_ntoa (rp
->p
.u
.prefix4
), rp
->p
.prefixlen
);
2242 p
= (struct prefix_ipv4
*) &rp
->p
;
2244 /* Apply output filters. */
2245 ret
= rip_outgoing_filter (p
, ri
);
2249 /* Changed route only output. */
2250 if (route_type
== rip_changed_route
&&
2251 (! (rinfo
->flags
& RIP_RTF_CHANGED
)))
2254 /* Split horizon. */
2255 /* if (split_horizon == rip_split_horizon) */
2256 if (ri
->split_horizon
== RIP_SPLIT_HORIZON
)
2259 * We perform split horizon for RIP and connected route.
2260 * For rip routes, we want to suppress the route if we would
2261 * end up sending the route back on the interface that we
2262 * learned it from, with a higher metric. For connected routes,
2263 * we suppress the route if the prefix is a subset of the
2264 * source address that we are going to use for the packet
2265 * (in order to handle the case when multiple subnets are
2266 * configured on the same interface).
2268 if (rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2269 rinfo
->ifindex
== ifc
->ifp
->ifindex
)
2271 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
&&
2272 prefix_match((struct prefix
*)p
, ifc
->address
))
2276 /* Preparation for route-map. */
2277 rinfo
->metric_set
= 0;
2278 rinfo
->nexthop_out
.s_addr
= 0;
2279 rinfo
->metric_out
= rinfo
->metric
;
2280 rinfo
->tag_out
= rinfo
->tag
;
2281 rinfo
->ifindex_out
= ifc
->ifp
->ifindex
;
2283 /* In order to avoid some local loops,
2284 * if the RIP route has a nexthop via this interface, keep the nexthop,
2285 * otherwise set it to 0. The nexthop should not be propagated
2286 * beyond the local broadcast/multicast area in order
2287 * to avoid an IGP multi-level recursive look-up.
2290 if (rinfo
->ifindex
== ifc
->ifp
->ifindex
)
2291 rinfo
->nexthop_out
= rinfo
->nexthop
;
2293 /* Interface route-map */
2294 if (ri
->routemap
[RIP_FILTER_OUT
])
2296 ret
= route_map_apply (ri
->routemap
[RIP_FILTER_OUT
],
2297 (struct prefix
*) p
, RMAP_RIP
,
2300 if (ret
== RMAP_DENYMATCH
)
2302 if (IS_RIP_DEBUG_PACKET
)
2303 zlog_debug ("RIP %s/%d is filtered by route-map out",
2304 inet_ntoa (p
->prefix
), p
->prefixlen
);
2309 /* Apply redistribute route map - continue, if deny */
2310 if (rip
->route_map
[rinfo
->type
].name
2311 && rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
)
2313 ret
= route_map_apply (rip
->route_map
[rinfo
->type
].map
,
2314 (struct prefix
*)p
, RMAP_RIP
, rinfo
);
2316 if (ret
== RMAP_DENYMATCH
)
2318 if (IS_RIP_DEBUG_PACKET
)
2319 zlog_debug ("%s/%d is filtered by route-map",
2320 inet_ntoa (p
->prefix
), p
->prefixlen
);
2325 /* When route-map does not set metric. */
2326 if (! rinfo
->metric_set
)
2328 /* If redistribute metric is set. */
2329 if (rip
->route_map
[rinfo
->type
].metric_config
2330 && rinfo
->metric
!= RIP_METRIC_INFINITY
)
2332 rinfo
->metric_out
= rip
->route_map
[rinfo
->type
].metric
;
2336 /* If the route is not connected or localy generated
2337 one, use default-metric value*/
2338 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
2339 && rinfo
->type
!= ZEBRA_ROUTE_CONNECT
2340 && rinfo
->metric
!= RIP_METRIC_INFINITY
)
2341 rinfo
->metric_out
= rip
->default_metric
;
2345 /* Apply offset-list */
2346 if (rinfo
->metric
!= RIP_METRIC_INFINITY
)
2347 rip_offset_list_apply_out (p
, ifc
->ifp
, &rinfo
->metric_out
);
2349 if (rinfo
->metric_out
> RIP_METRIC_INFINITY
)
2350 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2352 /* Perform split-horizon with poisoned reverse
2353 * for RIP and connected routes.
2355 if (ri
->split_horizon
== RIP_SPLIT_HORIZON_POISONED_REVERSE
) {
2357 * We perform split horizon for RIP and connected route.
2358 * For rip routes, we want to suppress the route if we would
2359 * end up sending the route back on the interface that we
2360 * learned it from, with a higher metric. For connected routes,
2361 * we suppress the route if the prefix is a subset of the
2362 * source address that we are going to use for the packet
2363 * (in order to handle the case when multiple subnets are
2364 * configured on the same interface).
2366 if (rinfo
->type
== ZEBRA_ROUTE_RIP
&&
2367 rinfo
->ifindex
== ifc
->ifp
->ifindex
)
2368 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2369 if (rinfo
->type
== ZEBRA_ROUTE_CONNECT
&&
2370 prefix_match((struct prefix
*)p
, ifc
->address
))
2371 rinfo
->metric_out
= RIP_METRIC_INFINITY
;
2374 /* Prepare preamble, auth headers, if needs be */
2377 stream_putc (s
, RIP_RESPONSE
);
2378 stream_putc (s
, version
);
2381 /* auth header for !v1 && !no_auth */
2382 if ( (ri
->auth_type
!= RIP_NO_AUTH
) && (version
!= RIPv1
) )
2383 doff
= rip_auth_header_write (s
, ri
, key
, auth_str
,
2384 RIP_AUTH_SIMPLE_SIZE
);
2387 /* Write RTE to the stream. */
2388 num
= rip_write_rte (num
, s
, p
, version
, rinfo
);
2391 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2392 rip_auth_md5_set (s
, ri
, doff
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
2394 ret
= rip_send_packet (STREAM_DATA (s
), stream_get_endp (s
),
2397 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2398 rip_packet_dump ((struct rip_packet
*)STREAM_DATA (s
),
2399 stream_get_endp(s
), "SEND");
2405 /* Flush unwritten RTE. */
2408 if (version
== RIPv2
&& ri
->auth_type
== RIP_AUTH_MD5
)
2409 rip_auth_md5_set (s
, ri
, doff
, auth_str
, RIP_AUTH_SIMPLE_SIZE
);
2411 ret
= rip_send_packet (STREAM_DATA (s
), stream_get_endp (s
), to
, ifc
);
2413 if (ret
>= 0 && IS_RIP_DEBUG_SEND
)
2414 rip_packet_dump ((struct rip_packet
*)STREAM_DATA (s
),
2415 stream_get_endp (s
), "SEND");
2420 /* Statistics updates. */
2424 /* Send RIP packet to the interface. */
2426 rip_update_interface (struct connected
*ifc
, u_char version
, int route_type
)
2428 struct sockaddr_in to
;
2430 /* When RIP version is 2 and multicast enable interface. */
2431 if (version
== RIPv2
&& if_is_multicast (ifc
->ifp
))
2433 if (IS_RIP_DEBUG_EVENT
)
2434 zlog_debug ("multicast announce on %s ", ifc
->ifp
->name
);
2436 rip_output_process (ifc
, NULL
, route_type
, version
);
2440 /* If we can't send multicast packet, send it with unicast. */
2441 if (if_is_broadcast (ifc
->ifp
) || if_is_pointopoint (ifc
->ifp
))
2443 if (ifc
->address
->family
== AF_INET
)
2445 /* Destination address and port setting. */
2446 memset (&to
, 0, sizeof (struct sockaddr_in
));
2447 if (ifc
->destination
)
2448 /* use specified broadcast or peer destination addr */
2449 to
.sin_addr
= ifc
->destination
->u
.prefix4
;
2450 else if (ifc
->address
->prefixlen
< IPV4_MAX_PREFIXLEN
)
2451 /* calculate the appropriate broadcast address */
2452 to
.sin_addr
.s_addr
=
2453 ipv4_broadcast_addr(ifc
->address
->u
.prefix4
.s_addr
,
2454 ifc
->address
->prefixlen
);
2456 /* do not know where to send the packet */
2458 to
.sin_port
= htons (RIP_PORT_DEFAULT
);
2460 if (IS_RIP_DEBUG_EVENT
)
2461 zlog_debug("%s announce to %s on %s",
2462 CONNECTED_PEER(ifc
) ? "unicast" : "broadcast",
2463 inet_ntoa (to
.sin_addr
), ifc
->ifp
->name
);
2465 rip_output_process (ifc
, &to
, route_type
, version
);
2470 /* Update send to all interface and neighbor. */
2472 rip_update_process (int route_type
)
2474 struct listnode
*node
;
2475 struct listnode
*ifnode
, *ifnnode
;
2476 struct connected
*connected
;
2477 struct interface
*ifp
;
2478 struct rip_interface
*ri
;
2479 struct route_node
*rp
;
2480 struct sockaddr_in to
;
2481 struct prefix_ipv4
*p
;
2483 /* Send RIP update to each interface. */
2484 for (ALL_LIST_ELEMENTS_RO (iflist
, node
, ifp
))
2486 if (if_is_loopback (ifp
))
2489 if (! if_is_operative (ifp
))
2492 /* Fetch RIP interface information. */
2495 /* When passive interface is specified, suppress announce to the
2503 * If there is no version configuration in the interface,
2504 * use rip's version setting.
2506 int vsend
= ((ri
->ri_send
== RI_RIP_UNSPEC
) ?
2507 rip
->version_send
: ri
->ri_send
);
2509 if (IS_RIP_DEBUG_EVENT
)
2510 zlog_debug("SEND UPDATE to %s ifindex %d",
2511 (ifp
->name
? ifp
->name
: "_unknown_"), ifp
->ifindex
);
2513 /* send update on each connected network */
2514 for (ALL_LIST_ELEMENTS (ifp
->connected
, ifnode
, ifnnode
, connected
))
2516 if (connected
->address
->family
== AF_INET
)
2519 rip_update_interface (connected
, RIPv1
, route_type
);
2520 if ((vsend
& RIPv2
) && if_is_multicast(ifp
))
2521 rip_update_interface (connected
, RIPv2
, route_type
);
2527 /* RIP send updates to each neighbor. */
2528 for (rp
= route_top (rip
->neighbor
); rp
; rp
= route_next (rp
))
2529 if (rp
->info
!= NULL
)
2531 p
= (struct prefix_ipv4
*) &rp
->p
;
2533 ifp
= if_lookup_address (p
->prefix
);
2536 zlog_warn ("Neighbor %s doesnt have connected interface!",
2537 inet_ntoa (p
->prefix
));
2541 if ( (connected
= connected_lookup_address (ifp
, p
->prefix
)) == NULL
)
2543 zlog_warn ("Neighbor %s doesnt have connected network",
2544 inet_ntoa (p
->prefix
));
2548 /* Set destination address and port */
2549 memset (&to
, 0, sizeof (struct sockaddr_in
));
2550 to
.sin_addr
= p
->prefix
;
2551 to
.sin_port
= htons (RIP_PORT_DEFAULT
);
2553 /* RIP version is rip's configuration. */
2554 rip_output_process (connected
, &to
, route_type
, rip
->version_send
);
2558 /* RIP's periodical timer. */
2560 rip_update (struct thread
*t
)
2562 /* Clear timer pointer. */
2563 rip
->t_update
= NULL
;
2565 if (IS_RIP_DEBUG_EVENT
)
2566 zlog_debug ("update timer fire!");
2568 /* Process update output. */
2569 rip_update_process (rip_all_route
);
2571 /* Triggered updates may be suppressed if a regular update is due by
2572 the time the triggered update would be sent. */
2573 if (rip
->t_triggered_interval
)
2575 thread_cancel (rip
->t_triggered_interval
);
2576 rip
->t_triggered_interval
= NULL
;
2580 /* Register myself. */
2581 rip_event (RIP_UPDATE_EVENT
, 0);
2586 /* Walk down the RIP routing table then clear changed flag. */
2588 rip_clear_changed_flag (void)
2590 struct route_node
*rp
;
2591 struct rip_info
*rinfo
;
2593 for (rp
= route_top (rip
->table
); rp
; rp
= route_next (rp
))
2594 if ((rinfo
= rp
->info
) != NULL
)
2595 if (rinfo
->flags
& RIP_RTF_CHANGED
)
2596 rinfo
->flags
&= ~RIP_RTF_CHANGED
;
2599 /* Triggered update interval timer. */
2601 rip_triggered_interval (struct thread
*t
)
2603 int rip_triggered_update (struct thread
*);
2605 rip
->t_triggered_interval
= NULL
;
2610 rip_triggered_update (t
);
2615 /* Execute triggered update. */
2617 rip_triggered_update (struct thread
*t
)
2621 /* Clear thred pointer. */
2622 rip
->t_triggered_update
= NULL
;
2624 /* Cancel interval timer. */
2625 if (rip
->t_triggered_interval
)
2627 thread_cancel (rip
->t_triggered_interval
);
2628 rip
->t_triggered_interval
= NULL
;
2632 /* Logging triggered update. */
2633 if (IS_RIP_DEBUG_EVENT
)
2634 zlog_debug ("triggered update!");
2636 /* Split Horizon processing is done when generating triggered
2637 updates as well as normal updates (see section 2.6). */
2638 rip_update_process (rip_changed_route
);
2640 /* Once all of the triggered updates have been generated, the route
2641 change flags should be cleared. */
2642 rip_clear_changed_flag ();
2644 /* After a triggered update is sent, a timer should be set for a
2645 random interval between 1 and 5 seconds. If other changes that
2646 would trigger updates occur before the timer expires, a single
2647 update is triggered when the timer expires. */
2648 interval
= (random () % 5) + 1;
2650 rip
->t_triggered_interval
=
2651 thread_add_timer (master
, rip_triggered_interval
, NULL
, interval
);
2656 /* Withdraw redistributed route. */
2658 rip_redistribute_withdraw (int type
)
2660 struct route_node
*rp
;
2661 struct rip_info
*rinfo
;
2666 for (rp
= route_top (rip
->table
); rp
; rp
= route_next (rp
))
2667 if ((rinfo
= rp
->info
) != NULL
)
2669 if (rinfo
->type
== type
2670 && rinfo
->sub_type
!= RIP_ROUTE_INTERFACE
)
2672 /* Perform poisoned reverse. */
2673 rinfo
->metric
= RIP_METRIC_INFINITY
;
2674 RIP_TIMER_ON (rinfo
->t_garbage_collect
,
2675 rip_garbage_collect
, rip
->garbage_time
);
2676 RIP_TIMER_OFF (rinfo
->t_timeout
);
2677 rinfo
->flags
|= RIP_RTF_CHANGED
;
2679 if (IS_RIP_DEBUG_EVENT
) {
2680 struct prefix_ipv4
*p
= (struct prefix_ipv4
*) &rp
->p
;
2682 zlog_debug ("Poisone %s/%d on the interface %s with an infinity metric [withdraw]",
2683 inet_ntoa(p
->prefix
), p
->prefixlen
,
2684 ifindex2ifname(rinfo
->ifindex
));
2687 rip_event (RIP_TRIGGERED_UPDATE
, 0);
2692 /* Create new RIP instance and set it to global variable. */
2696 rip
= XCALLOC (MTYPE_RIP
, sizeof (struct rip
));
2698 /* Set initial value. */
2699 rip
->version_send
= RI_RIP_VERSION_2
;
2700 rip
->version_recv
= RI_RIP_VERSION_1_AND_2
;
2701 rip
->update_time
= RIP_UPDATE_TIMER_DEFAULT
;
2702 rip
->timeout_time
= RIP_TIMEOUT_TIMER_DEFAULT
;
2703 rip
->garbage_time
= RIP_GARBAGE_TIMER_DEFAULT
;
2704 rip
->default_metric
= RIP_DEFAULT_METRIC_DEFAULT
;
2706 /* Initialize RIP routig table. */
2707 rip
->table
= route_table_init ();
2708 rip
->route
= route_table_init ();
2709 rip
->neighbor
= route_table_init ();
2711 /* Make output stream. */
2712 rip
->obuf
= stream_new (1500);
2715 rip
->sock
= rip_create_socket (NULL
);
2719 /* Create read and timer thread. */
2720 rip_event (RIP_READ
, rip
->sock
);
2721 rip_event (RIP_UPDATE_EVENT
, 1);
2726 /* Sned RIP request to the destination. */
2728 rip_request_send (struct sockaddr_in
*to
, struct interface
*ifp
,
2729 u_char version
, struct connected
*connected
)
2732 struct rip_packet rip_packet
;
2733 struct listnode
*node
, *nnode
;
2735 memset (&rip_packet
, 0, sizeof (rip_packet
));
2737 rip_packet
.command
= RIP_REQUEST
;
2738 rip_packet
.version
= version
;
2739 rte
= rip_packet
.rte
;
2740 rte
->metric
= htonl (RIP_METRIC_INFINITY
);
2745 * connected is only sent for ripv1 case, or when
2746 * interface does not support multicast. Caller loops
2747 * over each connected address for this case.
2749 if (rip_send_packet ((u_char
*) &rip_packet
, sizeof (rip_packet
),
2750 to
, connected
) != sizeof (rip_packet
))
2753 return sizeof (rip_packet
);
2756 /* send request on each connected network */
2757 for (ALL_LIST_ELEMENTS (ifp
->connected
, node
, nnode
, connected
))
2759 struct prefix_ipv4
*p
;
2761 p
= (struct prefix_ipv4
*) connected
->address
;
2763 if (p
->family
!= AF_INET
)
2766 if (rip_send_packet ((u_char
*) &rip_packet
, sizeof (rip_packet
),
2767 to
, connected
) != sizeof (rip_packet
))
2770 return sizeof (rip_packet
);
2774 rip_update_jitter (unsigned long time
)
2776 #define JITTER_BOUND 4
2777 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2778 Given that, we cannot let time be less than JITTER_BOUND seconds.
2779 The RIPv2 RFC says jitter should be small compared to
2780 update_time. We consider 1/JITTER_BOUND to be small.
2783 int jitter_input
= time
;
2786 if (jitter_input
< JITTER_BOUND
)
2787 jitter_input
= JITTER_BOUND
;
2789 jitter
= (((rand () % ((jitter_input
* 2) + 1)) - jitter_input
));
2791 return jitter
/JITTER_BOUND
;
2795 rip_event (enum rip_event event
, int sock
)
2802 rip
->t_read
= thread_add_read (master
, rip_read
, NULL
, sock
);
2804 case RIP_UPDATE_EVENT
:
2807 thread_cancel (rip
->t_update
);
2808 rip
->t_update
= NULL
;
2810 jitter
= rip_update_jitter (rip
->update_time
);
2812 thread_add_timer (master
, rip_update
, NULL
,
2813 sock
? 2 : rip
->update_time
+ jitter
);
2815 case RIP_TRIGGERED_UPDATE
:
2816 if (rip
->t_triggered_interval
)
2818 else if (! rip
->t_triggered_update
)
2819 rip
->t_triggered_update
=
2820 thread_add_event (master
, rip_triggered_update
, NULL
, 0);
2830 "Enable a routing process\n"
2831 "Routing Information Protocol (RIP)\n")
2835 /* If rip is not enabled before. */
2838 ret
= rip_create ();
2841 zlog_info ("Can't create RIP");
2845 vty
->node
= RIP_NODE
;
2851 DEFUN (no_router_rip
,
2855 "Enable a routing process\n"
2856 "Routing Information Protocol (RIP)\n")
2866 "Set routing protocol version\n"
2871 version
= atoi (argv
[0]);
2872 if (version
!= RIPv1
&& version
!= RIPv2
)
2874 vty_out (vty
, "invalid rip version %d%s", version
,
2878 rip
->version_send
= version
;
2879 rip
->version_recv
= version
;
2884 DEFUN (no_rip_version
,
2888 "Set routing protocol version\n")
2890 /* Set RIP version to the default. */
2891 rip
->version_send
= RI_RIP_VERSION_2
;
2892 rip
->version_recv
= RI_RIP_VERSION_1_AND_2
;
2897 ALIAS (no_rip_version
,
2898 no_rip_version_val_cmd
,
2901 "Set routing protocol version\n"
2907 "RIP static route configuration\n"
2908 "IP prefix <network>/<length>\n")
2911 struct prefix_ipv4 p
;
2912 struct route_node
*node
;
2914 ret
= str2prefix_ipv4 (argv
[0], &p
);
2917 vty_out (vty
, "Malformed address%s", VTY_NEWLINE
);
2920 apply_mask_ipv4 (&p
);
2922 /* For router rip configuration. */
2923 node
= route_node_get (rip
->route
, (struct prefix
*) &p
);
2927 vty_out (vty
, "There is already same static route.%s", VTY_NEWLINE
);
2928 route_unlock_node (node
);
2932 node
->info
= (char *)"static";
2934 rip_redistribute_add (ZEBRA_ROUTE_RIP
, RIP_ROUTE_STATIC
, &p
, 0, NULL
, 0, 0);
2939 DEFUN (no_rip_route
,
2941 "no route A.B.C.D/M",
2943 "RIP static route configuration\n"
2944 "IP prefix <network>/<length>\n")
2947 struct prefix_ipv4 p
;
2948 struct route_node
*node
;
2950 ret
= str2prefix_ipv4 (argv
[0], &p
);
2953 vty_out (vty
, "Malformed address%s", VTY_NEWLINE
);
2956 apply_mask_ipv4 (&p
);
2958 /* For router rip configuration. */
2959 node
= route_node_lookup (rip
->route
, (struct prefix
*) &p
);
2962 vty_out (vty
, "Can't find route %s.%s", argv
[0],
2967 rip_redistribute_delete (ZEBRA_ROUTE_RIP
, RIP_ROUTE_STATIC
, &p
, 0);
2968 route_unlock_node (node
);
2971 route_unlock_node (node
);
2977 rip_update_default_metric (void)
2979 struct route_node
*np
;
2980 struct rip_info
*rinfo
;
2982 for (np
= route_top (rip
->table
); np
; np
= route_next (np
))
2983 if ((rinfo
= np
->info
) != NULL
)
2984 if (rinfo
->type
!= ZEBRA_ROUTE_RIP
&& rinfo
->type
!= ZEBRA_ROUTE_CONNECT
)
2985 rinfo
->metric
= rip
->default_metric
;
2988 DEFUN (rip_default_metric
,
2989 rip_default_metric_cmd
,
2990 "default-metric <1-16>",
2991 "Set a metric of redistribute routes\n"
2996 rip
->default_metric
= atoi (argv
[0]);
2997 /* rip_update_default_metric (); */
3002 DEFUN (no_rip_default_metric
,
3003 no_rip_default_metric_cmd
,
3004 "no default-metric",
3006 "Set a metric of redistribute routes\n"
3011 rip
->default_metric
= RIP_DEFAULT_METRIC_DEFAULT
;
3012 /* rip_update_default_metric (); */
3017 ALIAS (no_rip_default_metric
,
3018 no_rip_default_metric_val_cmd
,
3019 "no default-metric <1-16>",
3021 "Set a metric of redistribute routes\n"
3026 "timers basic <5-2147483647> <5-2147483647> <5-2147483647>",
3027 "Adjust routing timers\n"
3028 "Basic routing protocol update timers\n"
3029 "Routing table update timer value in second. Default is 30.\n"
3030 "Routing information timeout timer. Default is 180.\n"
3031 "Garbage collection timer. Default is 120.\n")
3033 unsigned long update
;
3034 unsigned long timeout
;
3035 unsigned long garbage
;
3036 char *endptr
= NULL
;
3037 unsigned long RIP_TIMER_MAX
= 2147483647;
3038 unsigned long RIP_TIMER_MIN
= 5;
3040 update
= strtoul (argv
[0], &endptr
, 10);
3041 if (update
> RIP_TIMER_MAX
|| update
< RIP_TIMER_MIN
|| *endptr
!= '\0')
3043 vty_out (vty
, "update timer value error%s", VTY_NEWLINE
);
3047 timeout
= strtoul (argv
[1], &endptr
, 10);
3048 if (timeout
> RIP_TIMER_MAX
|| timeout
< RIP_TIMER_MIN
|| *endptr
!= '\0')
3050 vty_out (vty
, "timeout timer value error%s", VTY_NEWLINE
);
3054 garbage
= strtoul (argv
[2], &endptr
, 10);
3055 if (garbage
> RIP_TIMER_MAX
|| garbage
< RIP_TIMER_MIN
|| *endptr
!= '\0')
3057 vty_out (vty
, "garbage timer value error%s", VTY_NEWLINE
);
3061 /* Set each timer value. */
3062 rip
->update_time
= update
;
3063 rip
->timeout_time
= timeout
;
3064 rip
->garbage_time
= garbage
;
3066 /* Reset update timer thread. */
3067 rip_event (RIP_UPDATE_EVENT
, 0);
3072 DEFUN (no_rip_timers
,
3076 "Adjust routing timers\n"
3077 "Basic routing protocol update timers\n")
3079 /* Set each timer value to the default. */
3080 rip
->update_time
= RIP_UPDATE_TIMER_DEFAULT
;
3081 rip
->timeout_time
= RIP_TIMEOUT_TIMER_DEFAULT
;
3082 rip
->garbage_time
= RIP_GARBAGE_TIMER_DEFAULT
;
3084 /* Reset update timer thread. */
3085 rip_event (RIP_UPDATE_EVENT
, 0);
3090 ALIAS (no_rip_timers
,
3091 no_rip_timers_val_cmd
,
3092 "no timers basic <0-65535> <0-65535> <0-65535>",
3094 "Adjust routing timers\n"
3095 "Basic routing protocol update timers\n"
3096 "Routing table update timer value in second. Default is 30.\n"
3097 "Routing information timeout timer. Default is 180.\n"
3098 "Garbage collection timer. Default is 120.\n")
3101 struct route_table
*rip_distance_table
;
3105 /* Distance value for the IP source prefix. */
3108 /* Name of the access-list to be matched. */
3112 static struct rip_distance
*
3113 rip_distance_new (void)
3115 return XCALLOC (MTYPE_RIP_DISTANCE
, sizeof (struct rip_distance
));
3119 rip_distance_free (struct rip_distance
*rdistance
)
3121 XFREE (MTYPE_RIP_DISTANCE
, rdistance
);
3125 rip_distance_set (struct vty
*vty
, const char *distance_str
, const char *ip_str
,
3126 const char *access_list_str
)
3129 struct prefix_ipv4 p
;
3131 struct route_node
*rn
;
3132 struct rip_distance
*rdistance
;
3134 ret
= str2prefix_ipv4 (ip_str
, &p
);
3137 vty_out (vty
, "Malformed prefix%s", VTY_NEWLINE
);
3141 distance
= atoi (distance_str
);
3143 /* Get RIP distance node. */
3144 rn
= route_node_get (rip_distance_table
, (struct prefix
*) &p
);
3147 rdistance
= rn
->info
;
3148 route_unlock_node (rn
);
3152 rdistance
= rip_distance_new ();
3153 rn
->info
= rdistance
;
3156 /* Set distance value. */
3157 rdistance
->distance
= distance
;
3159 /* Reset access-list configuration. */
3160 if (rdistance
->access_list
)
3162 free (rdistance
->access_list
);
3163 rdistance
->access_list
= NULL
;
3165 if (access_list_str
)
3166 rdistance
->access_list
= strdup (access_list_str
);
3172 rip_distance_unset (struct vty
*vty
, const char *distance_str
,
3173 const char *ip_str
, const char *access_list_str
)
3176 struct prefix_ipv4 p
;
3178 struct route_node
*rn
;
3179 struct rip_distance
*rdistance
;
3181 ret
= str2prefix_ipv4 (ip_str
, &p
);
3184 vty_out (vty
, "Malformed prefix%s", VTY_NEWLINE
);
3188 distance
= atoi (distance_str
);
3190 rn
= route_node_lookup (rip_distance_table
, (struct prefix
*)&p
);
3193 vty_out (vty
, "Can't find specified prefix%s", VTY_NEWLINE
);
3197 rdistance
= rn
->info
;
3199 if (rdistance
->access_list
)
3200 free (rdistance
->access_list
);
3201 rip_distance_free (rdistance
);
3204 route_unlock_node (rn
);
3205 route_unlock_node (rn
);
3211 rip_distance_reset (void)
3213 struct route_node
*rn
;
3214 struct rip_distance
*rdistance
;
3216 for (rn
= route_top (rip_distance_table
); rn
; rn
= route_next (rn
))
3217 if ((rdistance
= rn
->info
) != NULL
)
3219 if (rdistance
->access_list
)
3220 free (rdistance
->access_list
);
3221 rip_distance_free (rdistance
);
3223 route_unlock_node (rn
);
3227 /* Apply RIP information to distance method. */
3229 rip_distance_apply (struct rip_info
*rinfo
)
3231 struct route_node
*rn
;
3232 struct prefix_ipv4 p
;
3233 struct rip_distance
*rdistance
;
3234 struct access_list
*alist
;
3239 memset (&p
, 0, sizeof (struct prefix_ipv4
));
3241 p
.prefix
= rinfo
->from
;
3242 p
.prefixlen
= IPV4_MAX_BITLEN
;
3244 /* Check source address. */
3245 rn
= route_node_match (rip_distance_table
, (struct prefix
*) &p
);
3248 rdistance
= rn
->info
;
3249 route_unlock_node (rn
);
3251 if (rdistance
->access_list
)
3253 alist
= access_list_lookup (AFI_IP
, rdistance
->access_list
);
3256 if (access_list_apply (alist
, &rinfo
->rp
->p
) == FILTER_DENY
)
3259 return rdistance
->distance
;
3262 return rdistance
->distance
;
3266 return rip
->distance
;
3272 rip_distance_show (struct vty
*vty
)
3274 struct route_node
*rn
;
3275 struct rip_distance
*rdistance
;
3279 vty_out (vty
, " Distance: (default is %d)%s",
3280 rip
->distance
? rip
->distance
:ZEBRA_RIP_DISTANCE_DEFAULT
,
3283 for (rn
= route_top (rip_distance_table
); rn
; rn
= route_next (rn
))
3284 if ((rdistance
= rn
->info
) != NULL
)
3288 vty_out (vty
, " Address Distance List%s",
3292 sprintf (buf
, "%s/%d", inet_ntoa (rn
->p
.u
.prefix4
), rn
->p
.prefixlen
);
3293 vty_out (vty
, " %-20s %4d %s%s",
3294 buf
, rdistance
->distance
,
3295 rdistance
->access_list
? rdistance
->access_list
: "",
3300 DEFUN (rip_distance
,
3303 "Administrative distance\n"
3306 rip
->distance
= atoi (argv
[0]);
3310 DEFUN (no_rip_distance
,
3311 no_rip_distance_cmd
,
3312 "no distance <1-255>",
3314 "Administrative distance\n"
3321 DEFUN (rip_distance_source
,
3322 rip_distance_source_cmd
,
3323 "distance <1-255> A.B.C.D/M",
3324 "Administrative distance\n"
3326 "IP source prefix\n")
3328 rip_distance_set (vty
, argv
[0], argv
[1], NULL
);
3332 DEFUN (no_rip_distance_source
,
3333 no_rip_distance_source_cmd
,
3334 "no distance <1-255> A.B.C.D/M",
3336 "Administrative distance\n"
3338 "IP source prefix\n")
3340 rip_distance_unset (vty
, argv
[0], argv
[1], NULL
);
3344 DEFUN (rip_distance_source_access_list
,
3345 rip_distance_source_access_list_cmd
,
3346 "distance <1-255> A.B.C.D/M WORD",
3347 "Administrative distance\n"
3349 "IP source prefix\n"
3350 "Access list name\n")
3352 rip_distance_set (vty
, argv
[0], argv
[1], argv
[2]);
3356 DEFUN (no_rip_distance_source_access_list
,
3357 no_rip_distance_source_access_list_cmd
,
3358 "no distance <1-255> A.B.C.D/M WORD",
3360 "Administrative distance\n"
3362 "IP source prefix\n"
3363 "Access list name\n")
3365 rip_distance_unset (vty
, argv
[0], argv
[1], argv
[2]);
3369 /* Print out routes update time. */
3371 rip_vty_out_uptime (struct vty
*vty
, struct rip_info
*rinfo
)
3376 char timebuf
[TIME_BUF
];
3377 struct thread
*thread
;
3379 if ((thread
= rinfo
->t_timeout
) != NULL
)
3381 clock
= thread_timer_remain_second (thread
);
3382 tm
= gmtime (&clock
);
3383 strftime (timebuf
, TIME_BUF
, "%M:%S", tm
);
3384 vty_out (vty
, "%5s", timebuf
);
3386 else if ((thread
= rinfo
->t_garbage_collect
) != NULL
)
3388 clock
= thread_timer_remain_second (thread
);
3389 tm
= gmtime (&clock
);
3390 strftime (timebuf
, TIME_BUF
, "%M:%S", tm
);
3391 vty_out (vty
, "%5s", timebuf
);
3396 rip_route_type_print (int sub_type
)
3402 case RIP_ROUTE_STATIC
:
3404 case RIP_ROUTE_DEFAULT
:
3406 case RIP_ROUTE_REDISTRIBUTE
:
3408 case RIP_ROUTE_INTERFACE
:
3420 "Show RIP routes\n")
3422 struct route_node
*np
;
3423 struct rip_info
*rinfo
;
3428 vty_out (vty
, "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP%s"
3430 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,%s"
3431 " (i) - interface%s%s"
3432 " Network Next Hop Metric From Tag Time%s",
3433 VTY_NEWLINE
, VTY_NEWLINE
, VTY_NEWLINE
, VTY_NEWLINE
, VTY_NEWLINE
, VTY_NEWLINE
);
3435 for (np
= route_top (rip
->table
); np
; np
= route_next (np
))
3436 if ((rinfo
= np
->info
) != NULL
)
3440 len
= vty_out (vty
, "%c(%s) %s/%d",
3441 /* np->lock, For debugging. */
3442 zebra_route_char(rinfo
->type
),
3443 rip_route_type_print (rinfo
->sub_type
),
3444 inet_ntoa (np
->p
.u
.prefix4
), np
->p
.prefixlen
);
3449 vty_out (vty
, "%*s", len
, " ");
3451 if (rinfo
->nexthop
.s_addr
)
3452 vty_out (vty
, "%-20s %2d ", inet_ntoa (rinfo
->nexthop
),
3455 vty_out (vty
, "0.0.0.0 %2d ", rinfo
->metric
);
3457 /* Route which exist in kernel routing table. */
3458 if ((rinfo
->type
== ZEBRA_ROUTE_RIP
) &&
3459 (rinfo
->sub_type
== RIP_ROUTE_RTE
))
3461 vty_out (vty
, "%-15s ", inet_ntoa (rinfo
->from
));
3462 vty_out (vty
, "%3d ", rinfo
->tag
);
3463 rip_vty_out_uptime (vty
, rinfo
);
3465 else if (rinfo
->metric
== RIP_METRIC_INFINITY
)
3467 vty_out (vty
, "self ");
3468 vty_out (vty
, "%3d ", rinfo
->tag
);
3469 rip_vty_out_uptime (vty
, rinfo
);
3473 if (rinfo
->external_metric
)
3475 len
= vty_out (vty
, "self (%s:%d)",
3476 zebra_route_string(rinfo
->type
),
3477 rinfo
->external_metric
);
3480 vty_out (vty
, "%*s", len
, " ");
3483 vty_out (vty
, "self ");
3484 vty_out (vty
, "%3d", rinfo
->tag
);
3487 vty_out (vty
, "%s", VTY_NEWLINE
);
3492 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3493 DEFUN (show_ip_rip_status
,
3494 show_ip_rip_status_cmd
,
3495 "show ip rip status",
3499 "IP routing protocol process parameters and statistics\n")
3501 struct listnode
*node
;
3502 struct interface
*ifp
;
3503 struct rip_interface
*ri
;
3504 extern const struct message ri_version_msg
[];
3505 const char *send_version
;
3506 const char *receive_version
;
3511 vty_out (vty
, "Routing Protocol is \"rip\"%s", VTY_NEWLINE
);
3512 vty_out (vty
, " Sending updates every %ld seconds with +/-50%%,",
3514 vty_out (vty
, " next due in %lu seconds%s",
3515 thread_timer_remain_second(rip
->t_update
),
3517 vty_out (vty
, " Timeout after %ld seconds,", rip
->timeout_time
);
3518 vty_out (vty
, " garbage collect after %ld seconds%s", rip
->garbage_time
,
3521 /* Filtering status show. */
3522 config_show_distribute (vty
);
3524 /* Default metric information. */
3525 vty_out (vty
, " Default redistribution metric is %d%s",
3526 rip
->default_metric
, VTY_NEWLINE
);
3528 /* Redistribute information. */
3529 vty_out (vty
, " Redistributing:");
3530 config_write_rip_redistribute (vty
, 0);
3531 vty_out (vty
, "%s", VTY_NEWLINE
);
3533 vty_out (vty
, " Default version control: send version %s,",
3534 lookup(ri_version_msg
,rip
->version_send
));
3535 if (rip
->version_recv
== RI_RIP_VERSION_1_AND_2
)
3536 vty_out (vty
, " receive any version %s", VTY_NEWLINE
);
3538 vty_out (vty
, " receive version %s %s",
3539 lookup(ri_version_msg
,rip
->version_recv
), VTY_NEWLINE
);
3541 vty_out (vty
, " Interface Send Recv Key-chain%s", VTY_NEWLINE
);
3543 for (ALL_LIST_ELEMENTS_RO (iflist
, node
, ifp
))
3547 if (ri
->enable_network
|| ri
->enable_interface
)
3549 if (ri
->ri_send
== RI_RIP_UNSPEC
)
3550 send_version
= lookup (ri_version_msg
, rip
->version_send
);
3552 send_version
= lookup (ri_version_msg
, ri
->ri_send
);
3554 if (ri
->ri_receive
== RI_RIP_UNSPEC
)
3555 receive_version
= lookup (ri_version_msg
, rip
->version_recv
);
3557 receive_version
= lookup (ri_version_msg
, ri
->ri_receive
);
3559 vty_out (vty
, " %-17s%-3s %-3s %s%s", ifp
->name
,
3562 ri
->key_chain
? ri
->key_chain
: "",
3567 vty_out (vty
, " Routing for Networks:%s", VTY_NEWLINE
);
3568 config_write_rip_network (vty
, 0);
3571 int found_passive
= 0;
3572 for (ALL_LIST_ELEMENTS_RO (iflist
, node
, ifp
))
3576 if ((ri
->enable_network
|| ri
->enable_interface
) && ri
->passive
)
3580 vty_out (vty
, " Passive Interface(s):%s", VTY_NEWLINE
);
3583 vty_out (vty
, " %s%s", ifp
->name
, VTY_NEWLINE
);
3588 vty_out (vty
, " Routing Information Sources:%s", VTY_NEWLINE
);
3589 vty_out (vty
, " Gateway BadPackets BadRoutes Distance Last Update%s", VTY_NEWLINE
);
3590 rip_peer_display (vty
);
3592 rip_distance_show (vty
);
3597 /* RIP configuration write function. */
3599 config_write_rip (struct vty
*vty
)
3602 struct route_node
*rn
;
3603 struct rip_distance
*rdistance
;
3607 /* Router RIP statement. */
3608 vty_out (vty
, "router rip%s", VTY_NEWLINE
);
3611 /* RIP version statement. Default is RIP version 2. */
3612 if (rip
->version_send
!= RI_RIP_VERSION_2
3613 || rip
->version_recv
!= RI_RIP_VERSION_1_AND_2
)
3614 vty_out (vty
, " version %d%s", rip
->version_send
,
3617 /* RIP timer configuration. */
3618 if (rip
->update_time
!= RIP_UPDATE_TIMER_DEFAULT
3619 || rip
->timeout_time
!= RIP_TIMEOUT_TIMER_DEFAULT
3620 || rip
->garbage_time
!= RIP_GARBAGE_TIMER_DEFAULT
)
3621 vty_out (vty
, " timers basic %lu %lu %lu%s",
3627 /* Default information configuration. */
3628 if (rip
->default_information
)
3630 if (rip
->default_information_route_map
)
3631 vty_out (vty
, " default-information originate route-map %s%s",
3632 rip
->default_information_route_map
, VTY_NEWLINE
);
3634 vty_out (vty
, " default-information originate%s",
3638 /* Redistribute configuration. */
3639 config_write_rip_redistribute (vty
, 1);
3641 /* RIP offset-list configuration. */
3642 config_write_rip_offset_list (vty
);
3644 /* RIP enabled network and interface configuration. */
3645 config_write_rip_network (vty
, 1);
3647 /* RIP default metric configuration */
3648 if (rip
->default_metric
!= RIP_DEFAULT_METRIC_DEFAULT
)
3649 vty_out (vty
, " default-metric %d%s",
3650 rip
->default_metric
, VTY_NEWLINE
);
3652 /* Distribute configuration. */
3653 write
+= config_write_distribute (vty
);
3655 /* Interface routemap configuration */
3656 write
+= config_write_if_rmap (vty
);
3658 /* Distance configuration. */
3660 vty_out (vty
, " distance %d%s", rip
->distance
, VTY_NEWLINE
);
3662 /* RIP source IP prefix distance configuration. */
3663 for (rn
= route_top (rip_distance_table
); rn
; rn
= route_next (rn
))
3664 if ((rdistance
= rn
->info
) != NULL
)
3665 vty_out (vty
, " distance %d %s/%d %s%s", rdistance
->distance
,
3666 inet_ntoa (rn
->p
.u
.prefix4
), rn
->p
.prefixlen
,
3667 rdistance
->access_list
? rdistance
->access_list
: "",
3670 /* RIP static route configuration. */
3671 for (rn
= route_top (rip
->route
); rn
; rn
= route_next (rn
))
3673 vty_out (vty
, " route %s/%d%s",
3674 inet_ntoa (rn
->p
.u
.prefix4
),
3682 /* RIP node structure. */
3683 static struct cmd_node rip_node
=
3686 "%s(config-router)# ",
3690 /* Distribute-list update functions. */
3692 rip_distribute_update (struct distribute
*dist
)
3694 struct interface
*ifp
;
3695 struct rip_interface
*ri
;
3696 struct access_list
*alist
;
3697 struct prefix_list
*plist
;
3702 ifp
= if_lookup_by_name (dist
->ifname
);
3708 if (dist
->list
[DISTRIBUTE_IN
])
3710 alist
= access_list_lookup (AFI_IP
, dist
->list
[DISTRIBUTE_IN
]);
3712 ri
->list
[RIP_FILTER_IN
] = alist
;
3714 ri
->list
[RIP_FILTER_IN
] = NULL
;
3717 ri
->list
[RIP_FILTER_IN
] = NULL
;
3719 if (dist
->list
[DISTRIBUTE_OUT
])
3721 alist
= access_list_lookup (AFI_IP
, dist
->list
[DISTRIBUTE_OUT
]);
3723 ri
->list
[RIP_FILTER_OUT
] = alist
;
3725 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3728 ri
->list
[RIP_FILTER_OUT
] = NULL
;
3730 if (dist
->prefix
[DISTRIBUTE_IN
])
3732 plist
= prefix_list_lookup (AFI_IP
, dist
->prefix
[DISTRIBUTE_IN
]);
3734 ri
->prefix
[RIP_FILTER_IN
] = plist
;
3736 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3739 ri
->prefix
[RIP_FILTER_IN
] = NULL
;
3741 if (dist
->prefix
[DISTRIBUTE_OUT
])
3743 plist
= prefix_list_lookup (AFI_IP
, dist
->prefix
[DISTRIBUTE_OUT
]);
3745 ri
->prefix
[RIP_FILTER_OUT
] = plist
;
3747 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3750 ri
->prefix
[RIP_FILTER_OUT
] = NULL
;
3754 rip_distribute_update_interface (struct interface
*ifp
)
3756 struct distribute
*dist
;
3758 dist
= distribute_lookup (ifp
->name
);
3760 rip_distribute_update (dist
);
3763 /* Update all interface's distribute list. */
3766 rip_distribute_update_all (struct prefix_list
*notused
)
3768 struct interface
*ifp
;
3769 struct listnode
*node
, *nnode
;
3771 for (ALL_LIST_ELEMENTS (iflist
, node
, nnode
, ifp
))
3772 rip_distribute_update_interface (ifp
);
3776 rip_distribute_update_all_wrapper(struct access_list
*notused
)
3778 rip_distribute_update_all(NULL
);
3781 /* Delete all added rip route. */
3786 struct route_node
*rp
;
3787 struct rip_info
*rinfo
;
3791 /* Clear RIP routes */
3792 for (rp
= route_top (rip
->table
); rp
; rp
= route_next (rp
))
3793 if ((rinfo
= rp
->info
) != NULL
)
3795 if (rinfo
->type
== ZEBRA_ROUTE_RIP
&&
3796 rinfo
->sub_type
== RIP_ROUTE_RTE
)
3797 rip_zebra_ipv4_delete ((struct prefix_ipv4
*)&rp
->p
,
3798 &rinfo
->nexthop
, rinfo
->metric
);
3800 RIP_TIMER_OFF (rinfo
->t_timeout
);
3801 RIP_TIMER_OFF (rinfo
->t_garbage_collect
);
3804 route_unlock_node (rp
);
3806 rip_info_free (rinfo
);
3809 /* Cancel RIP related timers. */
3810 RIP_TIMER_OFF (rip
->t_update
);
3811 RIP_TIMER_OFF (rip
->t_triggered_update
);
3812 RIP_TIMER_OFF (rip
->t_triggered_interval
);
3814 /* Cancel read thread. */
3817 thread_cancel (rip
->t_read
);
3821 /* Close RIP socket. */
3828 /* Static RIP route configuration. */
3829 for (rp
= route_top (rip
->route
); rp
; rp
= route_next (rp
))
3833 route_unlock_node (rp
);
3836 /* RIP neighbor configuration. */
3837 for (rp
= route_top (rip
->neighbor
); rp
; rp
= route_next (rp
))
3841 route_unlock_node (rp
);
3844 /* Redistribute related clear. */
3845 if (rip
->default_information_route_map
)
3846 free (rip
->default_information_route_map
);
3848 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3849 if (rip
->route_map
[i
].name
)
3850 free (rip
->route_map
[i
].name
);
3852 XFREE (MTYPE_ROUTE_TABLE
, rip
->table
);
3853 XFREE (MTYPE_ROUTE_TABLE
, rip
->route
);
3854 XFREE (MTYPE_ROUTE_TABLE
, rip
->neighbor
);
3856 XFREE (MTYPE_RIP
, rip
);
3860 rip_clean_network ();
3861 rip_passive_nondefault_clean ();
3862 rip_offset_clean ();
3863 rip_interface_clean ();
3864 rip_distance_reset ();
3865 rip_redistribute_clean ();
3868 /* Reset all values to the default settings. */
3872 /* Reset global counters. */
3873 rip_global_route_changes
= 0;
3874 rip_global_queries
= 0;
3876 /* Call ripd related reset functions. */
3878 rip_route_map_reset ();
3880 /* Call library reset functions. */
3882 access_list_reset ();
3883 prefix_list_reset ();
3885 distribute_list_reset ();
3887 rip_interface_reset ();
3888 rip_distance_reset ();
3890 rip_zclient_reset ();
3894 rip_if_rmap_update (struct if_rmap
*if_rmap
)
3896 struct interface
*ifp
;
3897 struct rip_interface
*ri
;
3898 struct route_map
*rmap
;
3900 ifp
= if_lookup_by_name (if_rmap
->ifname
);
3906 if (if_rmap
->routemap
[IF_RMAP_IN
])
3908 rmap
= route_map_lookup_by_name (if_rmap
->routemap
[IF_RMAP_IN
]);
3910 ri
->routemap
[IF_RMAP_IN
] = rmap
;
3912 ri
->routemap
[IF_RMAP_IN
] = NULL
;
3915 ri
->routemap
[RIP_FILTER_IN
] = NULL
;
3917 if (if_rmap
->routemap
[IF_RMAP_OUT
])
3919 rmap
= route_map_lookup_by_name (if_rmap
->routemap
[IF_RMAP_OUT
]);
3921 ri
->routemap
[IF_RMAP_OUT
] = rmap
;
3923 ri
->routemap
[IF_RMAP_OUT
] = NULL
;
3926 ri
->routemap
[RIP_FILTER_OUT
] = NULL
;
3930 rip_if_rmap_update_interface (struct interface
*ifp
)
3932 struct if_rmap
*if_rmap
;
3934 if_rmap
= if_rmap_lookup (ifp
->name
);
3936 rip_if_rmap_update (if_rmap
);
3940 rip_routemap_update_redistribute (void)
3946 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3948 if (rip
->route_map
[i
].name
)
3949 rip
->route_map
[i
].map
=
3950 route_map_lookup_by_name (rip
->route_map
[i
].name
);
3957 rip_routemap_update (const char *notused
)
3959 struct interface
*ifp
;
3960 struct listnode
*node
, *nnode
;
3962 for (ALL_LIST_ELEMENTS (iflist
, node
, nnode
, ifp
))
3963 rip_if_rmap_update_interface (ifp
);
3965 rip_routemap_update_redistribute ();
3968 /* Allocate new rip structure and set default value. */
3972 /* Randomize for triggered update random(). */
3973 srand (time (NULL
));
3975 /* Install top nodes. */
3976 install_node (&rip_node
, config_write_rip
);
3978 /* Install rip commands. */
3979 install_element (VIEW_NODE
, &show_ip_rip_cmd
);
3980 install_element (VIEW_NODE
, &show_ip_rip_status_cmd
);
3981 install_element (ENABLE_NODE
, &show_ip_rip_cmd
);
3982 install_element (ENABLE_NODE
, &show_ip_rip_status_cmd
);
3983 install_element (CONFIG_NODE
, &router_rip_cmd
);
3984 install_element (CONFIG_NODE
, &no_router_rip_cmd
);
3986 install_default (RIP_NODE
);
3987 install_element (RIP_NODE
, &rip_version_cmd
);
3988 install_element (RIP_NODE
, &no_rip_version_cmd
);
3989 install_element (RIP_NODE
, &no_rip_version_val_cmd
);
3990 install_element (RIP_NODE
, &rip_default_metric_cmd
);
3991 install_element (RIP_NODE
, &no_rip_default_metric_cmd
);
3992 install_element (RIP_NODE
, &no_rip_default_metric_val_cmd
);
3993 install_element (RIP_NODE
, &rip_timers_cmd
);
3994 install_element (RIP_NODE
, &no_rip_timers_cmd
);
3995 install_element (RIP_NODE
, &no_rip_timers_val_cmd
);
3996 install_element (RIP_NODE
, &rip_route_cmd
);
3997 install_element (RIP_NODE
, &no_rip_route_cmd
);
3998 install_element (RIP_NODE
, &rip_distance_cmd
);
3999 install_element (RIP_NODE
, &no_rip_distance_cmd
);
4000 install_element (RIP_NODE
, &rip_distance_source_cmd
);
4001 install_element (RIP_NODE
, &no_rip_distance_source_cmd
);
4002 install_element (RIP_NODE
, &rip_distance_source_access_list_cmd
);
4003 install_element (RIP_NODE
, &no_rip_distance_source_access_list_cmd
);
4005 /* Debug related init. */
4011 #endif /* HAVE_SNMP */
4013 /* Access list install. */
4014 access_list_init ();
4015 access_list_add_hook (rip_distribute_update_all_wrapper
);
4016 access_list_delete_hook (rip_distribute_update_all_wrapper
);
4018 /* Prefix list initialize.*/
4019 prefix_list_init ();
4020 prefix_list_add_hook (rip_distribute_update_all
);
4021 prefix_list_delete_hook (rip_distribute_update_all
);
4023 /* Distribute list install. */
4024 distribute_list_init (RIP_NODE
);
4025 distribute_list_add_hook (rip_distribute_update
);
4026 distribute_list_delete_hook (rip_distribute_update
);
4029 rip_route_map_init ();
4032 route_map_add_hook (rip_routemap_update
);
4033 route_map_delete_hook (rip_routemap_update
);
4035 if_rmap_init (RIP_NODE
);
4036 if_rmap_hook_add (rip_if_rmap_update
);
4037 if_rmap_hook_delete (rip_if_rmap_update
);
4039 /* Distance control. */
4040 rip_distance_table
= route_table_init ();