]> git.proxmox.com Git - mirror_frr.git/blob - ripd/ripd.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1860 from qlyoung/debug-mt-safe
[mirror_frr.git] / ripd / ripd.c
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>
4 *
5 * This file is part of GNU Zebra.
6 *
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
10 * later version.
11 *
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.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include "vrf.h"
25 #include "if.h"
26 #include "command.h"
27 #include "prefix.h"
28 #include "table.h"
29 #include "thread.h"
30 #include "memory.h"
31 #include "log.h"
32 #include "stream.h"
33 #include "filter.h"
34 #include "sockunion.h"
35 #include "sockopt.h"
36 #include "routemap.h"
37 #include "if_rmap.h"
38 #include "plist.h"
39 #include "distribute.h"
40 #include "md5.h"
41 #include "keychain.h"
42 #include "privs.h"
43
44 #include "ripd/ripd.h"
45 #include "ripd/rip_debug.h"
46
47 DEFINE_QOBJ_TYPE(rip)
48
49 /* UDP receive buffer size */
50 #define RIP_UDP_RCV_BUF 41600
51
52 /* RIP Structure. */
53 struct rip *rip = NULL;
54
55 /* RIP neighbor address table. */
56 struct route_table *rip_neighbor_table;
57
58 /* RIP route changes. */
59 long rip_global_route_changes = 0;
60
61 /* RIP queries. */
62 long rip_global_queries = 0;
63
64 /* Prototypes. */
65 static void rip_event(enum rip_event, int);
66 static void rip_output_process(struct connected *, struct sockaddr_in *, int,
67 u_char);
68 static int rip_triggered_update(struct thread *);
69 static int rip_update_jitter(unsigned long);
70
71 /* RIP output routes type. */
72 enum { rip_all_route, rip_changed_route };
73
74 /* RIP command strings. */
75 static const struct message rip_msg[] = {{RIP_REQUEST, "REQUEST"},
76 {RIP_RESPONSE, "RESPONSE"},
77 {RIP_TRACEON, "TRACEON"},
78 {RIP_TRACEOFF, "TRACEOFF"},
79 {RIP_POLL, "POLL"},
80 {RIP_POLL_ENTRY, "POLL ENTRY"},
81 {0}};
82
83 /* Utility function to set boradcast option to the socket. */
84 static int sockopt_broadcast(int sock)
85 {
86 int ret;
87 int on = 1;
88
89 ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&on,
90 sizeof on);
91 if (ret < 0) {
92 zlog_warn("can't set sockopt SO_BROADCAST to socket %d", sock);
93 return -1;
94 }
95 return 0;
96 }
97
98 static int rip_route_rte(struct rip_info *rinfo)
99 {
100 return (rinfo->type == ZEBRA_ROUTE_RIP
101 && rinfo->sub_type == RIP_ROUTE_RTE);
102 }
103
104 static struct rip_info *rip_info_new(void)
105 {
106 return XCALLOC(MTYPE_RIP_INFO, sizeof(struct rip_info));
107 }
108
109 void rip_info_free(struct rip_info *rinfo)
110 {
111 XFREE(MTYPE_RIP_INFO, rinfo);
112 }
113
114 /* RIP route garbage collect timer. */
115 static int rip_garbage_collect(struct thread *t)
116 {
117 struct rip_info *rinfo;
118 struct route_node *rp;
119
120 rinfo = THREAD_ARG(t);
121 rinfo->t_garbage_collect = NULL;
122
123 /* Off timeout timer. */
124 RIP_TIMER_OFF(rinfo->t_timeout);
125
126 /* Get route_node pointer. */
127 rp = rinfo->rp;
128
129 /* Unlock route_node. */
130 listnode_delete(rp->info, rinfo);
131 if (list_isempty((struct list *)rp->info)) {
132 list_delete_and_null((struct list **)&rp->info);
133 route_unlock_node(rp);
134 }
135
136 /* Free RIP routing information. */
137 rip_info_free(rinfo);
138
139 return 0;
140 }
141
142 static void rip_timeout_update(struct rip_info *rinfo);
143
144 /* Add new route to the ECMP list.
145 * RETURN: the new entry added in the list, or NULL if it is not the first
146 * entry and ECMP is not allowed.
147 */
148 struct rip_info *rip_ecmp_add(struct rip_info *rinfo_new)
149 {
150 struct route_node *rp = rinfo_new->rp;
151 struct rip_info *rinfo = NULL;
152 struct list *list = NULL;
153
154 if (rp->info == NULL)
155 rp->info = list_new();
156 list = (struct list *)rp->info;
157
158 /* If ECMP is not allowed and some entry already exists in the list,
159 * do nothing. */
160 if (listcount(list) && !rip->ecmp)
161 return NULL;
162
163 rinfo = rip_info_new();
164 memcpy(rinfo, rinfo_new, sizeof(struct rip_info));
165 listnode_add(list, rinfo);
166
167 if (rip_route_rte(rinfo)) {
168 rip_timeout_update(rinfo);
169 rip_zebra_ipv4_add(rp);
170 }
171
172 /* Set the route change flag on the first entry. */
173 rinfo = listgetdata(listhead(list));
174 SET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
175
176 /* Signal the output process to trigger an update (see section 2.5). */
177 rip_event(RIP_TRIGGERED_UPDATE, 0);
178
179 return rinfo;
180 }
181
182 /* Replace the ECMP list with the new route.
183 * RETURN: the new entry added in the list
184 */
185 struct rip_info *rip_ecmp_replace(struct rip_info *rinfo_new)
186 {
187 struct route_node *rp = rinfo_new->rp;
188 struct list *list = (struct list *)rp->info;
189 struct rip_info *rinfo = NULL, *tmp_rinfo = NULL;
190 struct listnode *node = NULL, *nextnode = NULL;
191
192 if (list == NULL || listcount(list) == 0)
193 return rip_ecmp_add(rinfo_new);
194
195 /* Get the first entry */
196 rinfo = listgetdata(listhead(list));
197
198 /* Learnt route replaced by a local one. Delete it from zebra. */
199 if (rip_route_rte(rinfo) && !rip_route_rte(rinfo_new))
200 if (CHECK_FLAG(rinfo->flags, RIP_RTF_FIB))
201 rip_zebra_ipv4_delete(rp);
202
203 /* Re-use the first entry, and delete the others. */
204 for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
205 if (tmp_rinfo != rinfo) {
206 RIP_TIMER_OFF(tmp_rinfo->t_timeout);
207 RIP_TIMER_OFF(tmp_rinfo->t_garbage_collect);
208 list_delete_node(list, node);
209 rip_info_free(tmp_rinfo);
210 }
211
212 RIP_TIMER_OFF(rinfo->t_timeout);
213 RIP_TIMER_OFF(rinfo->t_garbage_collect);
214 memcpy(rinfo, rinfo_new, sizeof(struct rip_info));
215
216 if (rip_route_rte(rinfo)) {
217 rip_timeout_update(rinfo);
218 /* The ADD message implies an update. */
219 rip_zebra_ipv4_add(rp);
220 }
221
222 /* Set the route change flag. */
223 SET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
224
225 /* Signal the output process to trigger an update (see section 2.5). */
226 rip_event(RIP_TRIGGERED_UPDATE, 0);
227
228 return rinfo;
229 }
230
231 /* Delete one route from the ECMP list.
232 * RETURN:
233 * null - the entry is freed, and other entries exist in the list
234 * the entry - the entry is the last one in the list; its metric is set
235 * to INFINITY, and the garbage collector is started for it
236 */
237 struct rip_info *rip_ecmp_delete(struct rip_info *rinfo)
238 {
239 struct route_node *rp = rinfo->rp;
240 struct list *list = (struct list *)rp->info;
241
242 RIP_TIMER_OFF(rinfo->t_timeout);
243
244 if (listcount(list) > 1) {
245 /* Some other ECMP entries still exist. Just delete this entry.
246 */
247 RIP_TIMER_OFF(rinfo->t_garbage_collect);
248 listnode_delete(list, rinfo);
249 if (rip_route_rte(rinfo)
250 && CHECK_FLAG(rinfo->flags, RIP_RTF_FIB))
251 /* The ADD message implies the update. */
252 rip_zebra_ipv4_add(rp);
253 rip_info_free(rinfo);
254 rinfo = NULL;
255 } else {
256 assert(rinfo == listgetdata(listhead(list)));
257
258 /* This is the only entry left in the list. We must keep it in
259 * the list for garbage collection time, with INFINITY metric.
260 */
261
262 rinfo->metric = RIP_METRIC_INFINITY;
263 RIP_TIMER_ON(rinfo->t_garbage_collect, rip_garbage_collect,
264 rip->garbage_time);
265
266 if (rip_route_rte(rinfo)
267 && CHECK_FLAG(rinfo->flags, RIP_RTF_FIB))
268 rip_zebra_ipv4_delete(rp);
269 }
270
271 /* Set the route change flag on the first entry. */
272 rinfo = listgetdata(listhead(list));
273 SET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
274
275 /* Signal the output process to trigger an update (see section 2.5). */
276 rip_event(RIP_TRIGGERED_UPDATE, 0);
277
278 return rinfo;
279 }
280
281 /* Timeout RIP routes. */
282 static int rip_timeout(struct thread *t)
283 {
284 rip_ecmp_delete((struct rip_info *)THREAD_ARG(t));
285 return 0;
286 }
287
288 static void rip_timeout_update(struct rip_info *rinfo)
289 {
290 if (rinfo->metric != RIP_METRIC_INFINITY) {
291 RIP_TIMER_OFF(rinfo->t_timeout);
292 RIP_TIMER_ON(rinfo->t_timeout, rip_timeout, rip->timeout_time);
293 }
294 }
295
296 static int rip_filter(int rip_distribute, struct prefix_ipv4 *p,
297 struct rip_interface *ri)
298 {
299 struct distribute *dist;
300 struct access_list *alist;
301 struct prefix_list *plist;
302 int distribute = rip_distribute == RIP_FILTER_OUT ? DISTRIBUTE_V4_OUT
303 : DISTRIBUTE_V4_IN;
304 const char *inout = rip_distribute == RIP_FILTER_OUT ? "out" : "in";
305
306 /* Input distribute-list filtering. */
307 if (ri->list[rip_distribute]) {
308 if (access_list_apply(ri->list[rip_distribute],
309 (struct prefix *)p)
310 == FILTER_DENY) {
311 if (IS_RIP_DEBUG_PACKET)
312 zlog_debug("%s/%d filtered by distribute %s",
313 inet_ntoa(p->prefix), p->prefixlen,
314 inout);
315 return -1;
316 }
317 }
318 if (ri->prefix[rip_distribute]) {
319 if (prefix_list_apply(ri->prefix[rip_distribute],
320 (struct prefix *)p)
321 == PREFIX_DENY) {
322 if (IS_RIP_DEBUG_PACKET)
323 zlog_debug("%s/%d filtered by prefix-list %s",
324 inet_ntoa(p->prefix), p->prefixlen,
325 inout);
326 return -1;
327 }
328 }
329
330 /* All interface filter check. */
331 dist = distribute_lookup(NULL);
332 if (dist) {
333 if (dist->list[distribute]) {
334 alist = access_list_lookup(AFI_IP,
335 dist->list[distribute]);
336
337 if (alist) {
338 if (access_list_apply(alist, (struct prefix *)p)
339 == FILTER_DENY) {
340 if (IS_RIP_DEBUG_PACKET)
341 zlog_debug(
342 "%s/%d filtered by distribute %s",
343 inet_ntoa(p->prefix),
344 p->prefixlen, inout);
345 return -1;
346 }
347 }
348 }
349 if (dist->prefix[distribute]) {
350 plist = prefix_list_lookup(AFI_IP,
351 dist->prefix[distribute]);
352
353 if (plist) {
354 if (prefix_list_apply(plist, (struct prefix *)p)
355 == PREFIX_DENY) {
356 if (IS_RIP_DEBUG_PACKET)
357 zlog_debug(
358 "%s/%d filtered by prefix-list %s",
359 inet_ntoa(p->prefix),
360 p->prefixlen, inout);
361 return -1;
362 }
363 }
364 }
365 }
366 return 0;
367 }
368
369 /* Check nexthop address validity. */
370 static int rip_nexthop_check(struct in_addr *addr)
371 {
372 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
373 struct interface *ifp;
374 struct listnode *cnode;
375 struct connected *ifc;
376 struct prefix *p;
377
378 /* If nexthop address matches local configured address then it is
379 invalid nexthop. */
380
381 FOR_ALL_INTERFACES (vrf, ifp) {
382 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, ifc)) {
383 p = ifc->address;
384
385 if (p->family == AF_INET
386 && IPV4_ADDR_SAME(&p->u.prefix4, addr))
387 return -1;
388 }
389 }
390 return 0;
391 }
392
393 /* RIP add route to routing table. */
394 static void rip_rte_process(struct rte *rte, struct sockaddr_in *from,
395 struct interface *ifp)
396 {
397 int ret;
398 struct prefix_ipv4 p;
399 struct route_node *rp;
400 struct rip_info *rinfo = NULL, newinfo;
401 struct rip_interface *ri;
402 struct in_addr *nexthop;
403 int same = 0;
404 unsigned char old_dist, new_dist;
405 struct list *list = NULL;
406 struct listnode *node = NULL;
407
408 /* Make prefix structure. */
409 memset(&p, 0, sizeof(struct prefix_ipv4));
410 p.family = AF_INET;
411 p.prefix = rte->prefix;
412 p.prefixlen = ip_masklen(rte->mask);
413
414 /* Make sure mask is applied. */
415 apply_mask_ipv4(&p);
416
417 /* Apply input filters. */
418 ri = ifp->info;
419
420 ret = rip_filter(RIP_FILTER_IN, &p, ri);
421 if (ret < 0)
422 return;
423
424 memset(&newinfo, 0, sizeof(newinfo));
425 newinfo.type = ZEBRA_ROUTE_RIP;
426 newinfo.sub_type = RIP_ROUTE_RTE;
427 newinfo.nh.gate.ipv4 = rte->nexthop;
428 newinfo.from = from->sin_addr;
429 newinfo.nh.ifindex = ifp->ifindex;
430 newinfo.nh.type = NEXTHOP_TYPE_IPV4_IFINDEX;
431 newinfo.metric = rte->metric;
432 newinfo.metric_out = rte->metric; /* XXX */
433 newinfo.tag = ntohs(rte->tag); /* XXX */
434
435 /* Modify entry according to the interface routemap. */
436 if (ri->routemap[RIP_FILTER_IN]) {
437 int ret;
438
439 /* The object should be of the type of rip_info */
440 ret = route_map_apply(ri->routemap[RIP_FILTER_IN],
441 (struct prefix *)&p, RMAP_RIP, &newinfo);
442
443 if (ret == RMAP_DENYMATCH) {
444 if (IS_RIP_DEBUG_PACKET)
445 zlog_debug(
446 "RIP %s/%d is filtered by route-map in",
447 inet_ntoa(p.prefix), p.prefixlen);
448 return;
449 }
450
451 /* Get back the object */
452 rte->nexthop = newinfo.nexthop_out;
453 rte->tag = htons(newinfo.tag_out); /* XXX */
454 rte->metric = newinfo.metric_out; /* XXX: the routemap uses the
455 metric_out field */
456 }
457
458 /* Once the entry has been validated, update the metric by
459 adding the cost of the network on wich the message
460 arrived. If the result is greater than infinity, use infinity
461 (RFC2453 Sec. 3.9.2) */
462 /* Zebra ripd can handle offset-list in. */
463 ret = rip_offset_list_apply_in(&p, ifp, &rte->metric);
464
465 /* If offset-list does not modify the metric use interface's
466 metric. */
467 if (!ret)
468 rte->metric += ifp->metric ? ifp->metric : 1;
469
470 if (rte->metric > RIP_METRIC_INFINITY)
471 rte->metric = RIP_METRIC_INFINITY;
472
473 /* Set nexthop pointer. */
474 if (rte->nexthop.s_addr == 0)
475 nexthop = &from->sin_addr;
476 else
477 nexthop = &rte->nexthop;
478
479 /* Check if nexthop address is myself, then do nothing. */
480 if (rip_nexthop_check(nexthop) < 0) {
481 if (IS_RIP_DEBUG_PACKET)
482 zlog_debug("Nexthop address %s is myself",
483 inet_ntoa(*nexthop));
484 return;
485 }
486
487 /* Get index for the prefix. */
488 rp = route_node_get(rip->table, (struct prefix *)&p);
489
490 newinfo.rp = rp;
491 newinfo.nh.gate.ipv4 = *nexthop;
492 newinfo.nh.type = NEXTHOP_TYPE_IPV4;
493 newinfo.metric = rte->metric;
494 newinfo.tag = ntohs(rte->tag);
495 newinfo.distance = rip_distance_apply(&newinfo);
496
497 new_dist = newinfo.distance ? newinfo.distance
498 : ZEBRA_RIP_DISTANCE_DEFAULT;
499
500 /* Check to see whether there is already RIP route on the table. */
501 if ((list = rp->info) != NULL)
502 for (ALL_LIST_ELEMENTS_RO(list, node, rinfo)) {
503 /* Need to compare with redistributed entry or local
504 * entry */
505 if (!rip_route_rte(rinfo))
506 break;
507
508 if (IPV4_ADDR_SAME(&rinfo->from, &from->sin_addr)
509 && IPV4_ADDR_SAME(&rinfo->nh.gate.ipv4, nexthop))
510 break;
511
512 if (!listnextnode(node)) {
513 /* Not found in the list */
514
515 if (rte->metric > rinfo->metric) {
516 /* New route has a greater metric.
517 * Discard it. */
518 route_unlock_node(rp);
519 return;
520 }
521
522 if (rte->metric < rinfo->metric)
523 /* New route has a smaller metric.
524 * Replace the ECMP list
525 * with the new one in below. */
526 break;
527
528 /* Metrics are same. We compare the distances.
529 */
530 old_dist = rinfo->distance
531 ? rinfo->distance
532 : ZEBRA_RIP_DISTANCE_DEFAULT;
533
534 if (new_dist > old_dist) {
535 /* New route has a greater distance.
536 * Discard it. */
537 route_unlock_node(rp);
538 return;
539 }
540
541 if (new_dist < old_dist)
542 /* New route has a smaller distance.
543 * Replace the ECMP list
544 * with the new one in below. */
545 break;
546
547 /* Metrics and distances are both same. Keep
548 * "rinfo" null and
549 * the new route is added in the ECMP list in
550 * below. */
551 }
552 }
553
554 if (rinfo) {
555 /* Local static route. */
556 if (rinfo->type == ZEBRA_ROUTE_RIP
557 && ((rinfo->sub_type == RIP_ROUTE_STATIC)
558 || (rinfo->sub_type == RIP_ROUTE_DEFAULT))
559 && rinfo->metric != RIP_METRIC_INFINITY) {
560 route_unlock_node(rp);
561 return;
562 }
563
564 /* Redistributed route check. */
565 if (rinfo->type != ZEBRA_ROUTE_RIP
566 && rinfo->metric != RIP_METRIC_INFINITY) {
567 old_dist = rinfo->distance;
568 /* Only routes directly connected to an interface
569 * (nexthop == 0)
570 * may have a valid NULL distance */
571 if (rinfo->nh.gate.ipv4.s_addr != 0)
572 old_dist = old_dist
573 ? old_dist
574 : ZEBRA_RIP_DISTANCE_DEFAULT;
575 /* If imported route does not have STRICT precedence,
576 mark it as a ghost */
577 if (new_dist <= old_dist
578 && rte->metric != RIP_METRIC_INFINITY)
579 rip_ecmp_replace(&newinfo);
580
581 route_unlock_node(rp);
582 return;
583 }
584 }
585
586 if (!rinfo) {
587 if (rp->info)
588 route_unlock_node(rp);
589
590 /* Now, check to see whether there is already an explicit route
591 for the destination prefix. If there is no such route, add
592 this route to the routing table, unless the metric is
593 infinity (there is no point in adding a route which
594 unusable). */
595 if (rte->metric != RIP_METRIC_INFINITY)
596 rip_ecmp_add(&newinfo);
597 } else {
598 /* Route is there but we are not sure the route is RIP or not.
599 */
600
601 /* If there is an existing route, compare the next hop address
602 to the address of the router from which the datagram came.
603 If this datagram is from the same router as the existing
604 route, reinitialize the timeout. */
605 same = (IPV4_ADDR_SAME(&rinfo->from, &from->sin_addr)
606 && (rinfo->nh.ifindex == ifp->ifindex));
607
608 old_dist = rinfo->distance ? rinfo->distance
609 : ZEBRA_RIP_DISTANCE_DEFAULT;
610
611 /* Next, compare the metrics. If the datagram is from the same
612 router as the existing route, and the new metric is different
613 than the old one; or, if the new metric is lower than the old
614 one, or if the tag has been changed; or if there is a route
615 with a lower administrave distance; or an update of the
616 distance on the actual route; do the following actions: */
617 if ((same && rinfo->metric != rte->metric)
618 || (rte->metric < rinfo->metric)
619 || ((same) && (rinfo->metric == rte->metric)
620 && (newinfo.tag != rinfo->tag))
621 || (old_dist > new_dist)
622 || ((old_dist != new_dist) && same)) {
623 if (listcount(list) == 1) {
624 if (newinfo.metric != RIP_METRIC_INFINITY)
625 rip_ecmp_replace(&newinfo);
626 else
627 rip_ecmp_delete(rinfo);
628 } else {
629 if (newinfo.metric < rinfo->metric)
630 rip_ecmp_replace(&newinfo);
631 else if (newinfo.metric > rinfo->metric)
632 rip_ecmp_delete(rinfo);
633 else if (new_dist < old_dist)
634 rip_ecmp_replace(&newinfo);
635 else if (new_dist > old_dist)
636 rip_ecmp_delete(rinfo);
637 else {
638 int update = CHECK_FLAG(rinfo->flags,
639 RIP_RTF_FIB)
640 ? 1
641 : 0;
642
643 assert(newinfo.metric
644 != RIP_METRIC_INFINITY);
645
646 RIP_TIMER_OFF(rinfo->t_timeout);
647 RIP_TIMER_OFF(rinfo->t_garbage_collect);
648 memcpy(rinfo, &newinfo,
649 sizeof(struct rip_info));
650 rip_timeout_update(rinfo);
651
652 if (update)
653 rip_zebra_ipv4_add(rp);
654
655 /* - Set the route change flag on the
656 * first entry. */
657 rinfo = listgetdata(listhead(list));
658 SET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
659 rip_event(RIP_TRIGGERED_UPDATE, 0);
660 }
661 }
662 } else /* same & no change */
663 rip_timeout_update(rinfo);
664
665 /* Unlock tempolary lock of the route. */
666 route_unlock_node(rp);
667 }
668 }
669
670 /* Dump RIP packet */
671 static void rip_packet_dump(struct rip_packet *packet, int size,
672 const char *sndrcv)
673 {
674 caddr_t lim;
675 struct rte *rte;
676 const char *command_str;
677 char pbuf[BUFSIZ], nbuf[BUFSIZ];
678 u_char netmask = 0;
679 u_char *p;
680
681 /* Set command string. */
682 if (packet->command > 0 && packet->command < RIP_COMMAND_MAX)
683 command_str = lookup_msg(rip_msg, packet->command, NULL);
684 else
685 command_str = "unknown";
686
687 /* Dump packet header. */
688 zlog_debug("%s %s version %d packet size %d", sndrcv, command_str,
689 packet->version, size);
690
691 /* Dump each routing table entry. */
692 rte = packet->rte;
693
694 for (lim = (caddr_t)packet + size; (caddr_t)rte < lim; rte++) {
695 if (packet->version == RIPv2) {
696 netmask = ip_masklen(rte->mask);
697
698 if (rte->family == htons(RIP_FAMILY_AUTH)) {
699 if (rte->tag
700 == htons(RIP_AUTH_SIMPLE_PASSWORD)) {
701 p = (u_char *)&rte->prefix;
702
703 zlog_debug(
704 " family 0x%X type %d auth string: %s",
705 ntohs(rte->family),
706 ntohs(rte->tag), p);
707 } else if (rte->tag == htons(RIP_AUTH_MD5)) {
708 struct rip_md5_info *md5;
709
710 md5 = (struct rip_md5_info *)&packet
711 ->rte;
712
713 zlog_debug(
714 " family 0x%X type %d (MD5 authentication)",
715 ntohs(md5->family),
716 ntohs(md5->type));
717 zlog_debug(
718 " RIP-2 packet len %d Key ID %d"
719 " Auth Data len %d",
720 ntohs(md5->packet_len),
721 md5->keyid, md5->auth_len);
722 zlog_debug(
723 " Sequence Number %ld",
724 (u_long)ntohl(md5->sequence));
725 } else if (rte->tag == htons(RIP_AUTH_DATA)) {
726 p = (u_char *)&rte->prefix;
727
728 zlog_debug(
729 " family 0x%X type %d (MD5 data)",
730 ntohs(rte->family),
731 ntohs(rte->tag));
732 zlog_debug(
733 " MD5: %02X%02X%02X%02X%02X%02X%02X%02X"
734 "%02X%02X%02X%02X%02X%02X%02X%02X",
735 p[0], p[1], p[2], p[3], p[4],
736 p[5], p[6], p[7], p[8], p[9],
737 p[10], p[11], p[12], p[13],
738 p[14], p[15]);
739 } else {
740 zlog_debug(
741 " family 0x%X type %d (Unknown auth type)",
742 ntohs(rte->family),
743 ntohs(rte->tag));
744 }
745 } else
746 zlog_debug(
747 " %s/%d -> %s family %d tag %" ROUTE_TAG_PRI
748 " metric %ld",
749 inet_ntop(AF_INET, &rte->prefix, pbuf,
750 BUFSIZ),
751 netmask,
752 inet_ntop(AF_INET, &rte->nexthop, nbuf,
753 BUFSIZ),
754 ntohs(rte->family),
755 (route_tag_t)ntohs(rte->tag),
756 (u_long)ntohl(rte->metric));
757 } else {
758 zlog_debug(
759 " %s family %d tag %" ROUTE_TAG_PRI
760 " metric %ld",
761 inet_ntop(AF_INET, &rte->prefix, pbuf, BUFSIZ),
762 ntohs(rte->family),
763 (route_tag_t)ntohs(rte->tag),
764 (u_long)ntohl(rte->metric));
765 }
766 }
767 }
768
769 /* Check if the destination address is valid (unicast; not net 0
770 or 127) (RFC2453 Section 3.9.2 - Page 26). But we don't
771 check net 0 because we accept default route. */
772 static int rip_destination_check(struct in_addr addr)
773 {
774 u_int32_t destination;
775
776 /* Convert to host byte order. */
777 destination = ntohl(addr.s_addr);
778
779 if (IPV4_NET127(destination))
780 return 0;
781
782 /* Net 0 may match to the default route. */
783 if (IPV4_NET0(destination) && destination != 0)
784 return 0;
785
786 /* Unicast address must belong to class A, B, C. */
787 if (IN_CLASSA(destination))
788 return 1;
789 if (IN_CLASSB(destination))
790 return 1;
791 if (IN_CLASSC(destination))
792 return 1;
793
794 return 0;
795 }
796
797 /* RIP version 2 authentication. */
798 static int rip_auth_simple_password(struct rte *rte, struct sockaddr_in *from,
799 struct interface *ifp)
800 {
801 struct rip_interface *ri;
802 char *auth_str = (char *)&rte->prefix;
803 int i;
804
805 /* reject passwords with zeros in the middle of the string */
806 for (i = strlen(auth_str); i < 16; i++) {
807 if (auth_str[i] != '\0')
808 return 0;
809 }
810
811 if (IS_RIP_DEBUG_EVENT)
812 zlog_debug("RIPv2 simple password authentication from %s",
813 inet_ntoa(from->sin_addr));
814
815 ri = ifp->info;
816
817 if (ri->auth_type != RIP_AUTH_SIMPLE_PASSWORD
818 || rte->tag != htons(RIP_AUTH_SIMPLE_PASSWORD))
819 return 0;
820
821 /* Simple password authentication. */
822 if (ri->auth_str) {
823 if (strncmp(auth_str, ri->auth_str, 16) == 0)
824 return 1;
825 }
826 if (ri->key_chain) {
827 struct keychain *keychain;
828 struct key *key;
829
830 keychain = keychain_lookup(ri->key_chain);
831 if (keychain == NULL)
832 return 0;
833
834 key = key_match_for_accept(keychain, auth_str);
835 if (key)
836 return 1;
837 }
838 return 0;
839 }
840
841 /* RIP version 2 authentication with MD5. */
842 static int rip_auth_md5(struct rip_packet *packet, struct sockaddr_in *from,
843 int length, struct interface *ifp)
844 {
845 struct rip_interface *ri;
846 struct rip_md5_info *md5;
847 struct rip_md5_data *md5data;
848 struct keychain *keychain;
849 struct key *key;
850 MD5_CTX ctx;
851 u_char digest[RIP_AUTH_MD5_SIZE];
852 u_int16_t packet_len;
853 char auth_str[RIP_AUTH_MD5_SIZE];
854
855 if (IS_RIP_DEBUG_EVENT)
856 zlog_debug("RIPv2 MD5 authentication from %s",
857 inet_ntoa(from->sin_addr));
858
859 ri = ifp->info;
860 md5 = (struct rip_md5_info *)&packet->rte;
861
862 /* Check auth type. */
863 if (ri->auth_type != RIP_AUTH_MD5 || md5->type != htons(RIP_AUTH_MD5))
864 return 0;
865
866 /* If the authentication length is less than 16, then it must be wrong
867 * for
868 * any interpretation of rfc2082. Some implementations also interpret
869 * this as RIP_HEADER_SIZE+ RIP_AUTH_MD5_SIZE, aka
870 * RIP_AUTH_MD5_COMPAT_SIZE.
871 */
872 if (!((md5->auth_len == RIP_AUTH_MD5_SIZE)
873 || (md5->auth_len == RIP_AUTH_MD5_COMPAT_SIZE))) {
874 if (IS_RIP_DEBUG_EVENT)
875 zlog_debug(
876 "RIPv2 MD5 authentication, strange authentication "
877 "length field %d",
878 md5->auth_len);
879 return 0;
880 }
881
882 /* grab and verify check packet length */
883 packet_len = ntohs(md5->packet_len);
884
885 if (packet_len > (length - RIP_HEADER_SIZE - RIP_AUTH_MD5_SIZE)) {
886 if (IS_RIP_DEBUG_EVENT)
887 zlog_debug(
888 "RIPv2 MD5 authentication, packet length field %d "
889 "greater than received length %d!",
890 md5->packet_len, length);
891 return 0;
892 }
893
894 /* retrieve authentication data */
895 md5data = (struct rip_md5_data *)(((u_char *)packet) + packet_len);
896
897 memset(auth_str, 0, RIP_AUTH_MD5_SIZE);
898
899 if (ri->key_chain) {
900 keychain = keychain_lookup(ri->key_chain);
901 if (keychain == NULL)
902 return 0;
903
904 key = key_lookup_for_accept(keychain, md5->keyid);
905 if (key == NULL)
906 return 0;
907
908 strncpy(auth_str, key->string, RIP_AUTH_MD5_SIZE);
909 } else if (ri->auth_str)
910 strncpy(auth_str, ri->auth_str, RIP_AUTH_MD5_SIZE);
911
912 if (auth_str[0] == 0)
913 return 0;
914
915 /* MD5 digest authentication. */
916 memset(&ctx, 0, sizeof(ctx));
917 MD5Init(&ctx);
918 MD5Update(&ctx, packet, packet_len + RIP_HEADER_SIZE);
919 MD5Update(&ctx, auth_str, RIP_AUTH_MD5_SIZE);
920 MD5Final(digest, &ctx);
921
922 if (memcmp(md5data->digest, digest, RIP_AUTH_MD5_SIZE) == 0)
923 return packet_len;
924 else
925 return 0;
926 }
927
928 /* Pick correct auth string for sends, prepare auth_str buffer for use.
929 * (left justified and padded).
930 *
931 * presumes one of ri or key is valid, and that the auth strings they point
932 * to are nul terminated. If neither are present, auth_str will be fully
933 * zero padded.
934 *
935 */
936 static void rip_auth_prepare_str_send(struct rip_interface *ri, struct key *key,
937 char *auth_str, int len)
938 {
939 assert(ri || key);
940
941 memset(auth_str, 0, len);
942 if (key && key->string)
943 strncpy(auth_str, key->string, len);
944 else if (ri->auth_str)
945 strncpy(auth_str, ri->auth_str, len);
946
947 return;
948 }
949
950 /* Write RIPv2 simple password authentication information
951 *
952 * auth_str is presumed to be 2 bytes and correctly prepared
953 * (left justified and zero padded).
954 */
955 static void rip_auth_simple_write(struct stream *s, char *auth_str, int len)
956 {
957 assert(s && len == RIP_AUTH_SIMPLE_SIZE);
958
959 stream_putw(s, RIP_FAMILY_AUTH);
960 stream_putw(s, RIP_AUTH_SIMPLE_PASSWORD);
961 stream_put(s, auth_str, RIP_AUTH_SIMPLE_SIZE);
962
963 return;
964 }
965
966 /* write RIPv2 MD5 "authentication header"
967 * (uses the auth key data field)
968 *
969 * Digest offset field is set to 0.
970 *
971 * returns: offset of the digest offset field, which must be set when
972 * length to the auth-data MD5 digest is known.
973 */
974 static size_t rip_auth_md5_ah_write(struct stream *s, struct rip_interface *ri,
975 struct key *key)
976 {
977 size_t doff = 0;
978
979 assert(s && ri && ri->auth_type == RIP_AUTH_MD5);
980
981 /* MD5 authentication. */
982 stream_putw(s, RIP_FAMILY_AUTH);
983 stream_putw(s, RIP_AUTH_MD5);
984
985 /* MD5 AH digest offset field.
986 *
987 * Set to placeholder value here, to true value when RIP-2 Packet length
988 * is known. Actual value is set in .....().
989 */
990 doff = stream_get_endp(s);
991 stream_putw(s, 0);
992
993 /* Key ID. */
994 if (key)
995 stream_putc(s, key->index % 256);
996 else
997 stream_putc(s, 1);
998
999 /* Auth Data Len. Set 16 for MD5 authentication data. Older ripds
1000 * however expect RIP_HEADER_SIZE + RIP_AUTH_MD5_SIZE so we allow for
1001 * this
1002 * to be configurable.
1003 */
1004 stream_putc(s, ri->md5_auth_len);
1005
1006 /* Sequence Number (non-decreasing). */
1007 /* RFC2080: The value used in the sequence number is
1008 arbitrary, but two suggestions are the time of the
1009 message's creation or a simple message counter. */
1010 stream_putl(s, time(NULL));
1011
1012 /* Reserved field must be zero. */
1013 stream_putl(s, 0);
1014 stream_putl(s, 0);
1015
1016 return doff;
1017 }
1018
1019 /* If authentication is in used, write the appropriate header
1020 * returns stream offset to which length must later be written
1021 * or 0 if this is not required
1022 */
1023 static size_t rip_auth_header_write(struct stream *s, struct rip_interface *ri,
1024 struct key *key, char *auth_str, int len)
1025 {
1026 assert(ri->auth_type != RIP_NO_AUTH);
1027
1028 switch (ri->auth_type) {
1029 case RIP_AUTH_SIMPLE_PASSWORD:
1030 rip_auth_prepare_str_send(ri, key, auth_str, len);
1031 rip_auth_simple_write(s, auth_str, len);
1032 return 0;
1033 case RIP_AUTH_MD5:
1034 return rip_auth_md5_ah_write(s, ri, key);
1035 }
1036 assert(1);
1037 return 0;
1038 }
1039
1040 /* Write RIPv2 MD5 authentication data trailer */
1041 static void rip_auth_md5_set(struct stream *s, struct rip_interface *ri,
1042 size_t doff, char *auth_str, int authlen)
1043 {
1044 unsigned long len;
1045 MD5_CTX ctx;
1046 unsigned char digest[RIP_AUTH_MD5_SIZE];
1047
1048 /* Make it sure this interface is configured as MD5
1049 authentication. */
1050 assert((ri->auth_type == RIP_AUTH_MD5)
1051 && (authlen == RIP_AUTH_MD5_SIZE));
1052 assert(doff > 0);
1053
1054 /* Get packet length. */
1055 len = stream_get_endp(s);
1056
1057 /* Check packet length. */
1058 if (len < (RIP_HEADER_SIZE + RIP_RTE_SIZE)) {
1059 zlog_err(
1060 "rip_auth_md5_set(): packet length %ld is less than minimum length.",
1061 len);
1062 return;
1063 }
1064
1065 /* Set the digest offset length in the header */
1066 stream_putw_at(s, doff, len);
1067
1068 /* Set authentication data. */
1069 stream_putw(s, RIP_FAMILY_AUTH);
1070 stream_putw(s, RIP_AUTH_DATA);
1071
1072 /* Generate a digest for the RIP packet. */
1073 memset(&ctx, 0, sizeof(ctx));
1074 MD5Init(&ctx);
1075 MD5Update(&ctx, STREAM_DATA(s), stream_get_endp(s));
1076 MD5Update(&ctx, auth_str, RIP_AUTH_MD5_SIZE);
1077 MD5Final(digest, &ctx);
1078
1079 /* Copy the digest to the packet. */
1080 stream_write(s, digest, RIP_AUTH_MD5_SIZE);
1081 }
1082
1083 /* RIP routing information. */
1084 static void rip_response_process(struct rip_packet *packet, int size,
1085 struct sockaddr_in *from,
1086 struct connected *ifc)
1087 {
1088 caddr_t lim;
1089 struct rte *rte;
1090 struct prefix_ipv4 ifaddr;
1091 struct prefix_ipv4 ifaddrclass;
1092 int subnetted;
1093
1094 memset(&ifaddr, 0, sizeof(ifaddr));
1095 /* We don't know yet. */
1096 subnetted = -1;
1097
1098 /* The Response must be ignored if it is not from the RIP
1099 port. (RFC2453 - Sec. 3.9.2)*/
1100 if (from->sin_port != htons(RIP_PORT_DEFAULT)) {
1101 zlog_info("response doesn't come from RIP port: %d",
1102 from->sin_port);
1103 rip_peer_bad_packet(from);
1104 return;
1105 }
1106
1107 /* The datagram's IPv4 source address should be checked to see
1108 whether the datagram is from a valid neighbor; the source of the
1109 datagram must be on a directly connected network (RFC2453 - Sec.
1110 3.9.2) */
1111 if (if_lookup_address((void *)&from->sin_addr, AF_INET, VRF_DEFAULT)
1112 == NULL) {
1113 zlog_info(
1114 "This datagram doesn't came from a valid neighbor: %s",
1115 inet_ntoa(from->sin_addr));
1116 rip_peer_bad_packet(from);
1117 return;
1118 }
1119
1120 /* It is also worth checking to see whether the response is from one
1121 of the router's own addresses. */
1122
1123 ; /* Alredy done in rip_read () */
1124
1125 /* Update RIP peer. */
1126 rip_peer_update(from, packet->version);
1127
1128 /* Set RTE pointer. */
1129 rte = packet->rte;
1130
1131 for (lim = (caddr_t)packet + size; (caddr_t)rte < lim; rte++) {
1132 /* RIPv2 authentication check. */
1133 /* If the Address Family Identifier of the first (and only the
1134 first) entry in the message is 0xFFFF, then the remainder of
1135 the entry contains the authentication. */
1136 /* If the packet gets here it means authentication enabled */
1137 /* Check is done in rip_read(). So, just skipping it */
1138 if (packet->version == RIPv2 && rte == packet->rte
1139 && rte->family == htons(RIP_FAMILY_AUTH))
1140 continue;
1141
1142 if (rte->family != htons(AF_INET)) {
1143 /* Address family check. RIP only supports AF_INET. */
1144 zlog_info("Unsupported family %d from %s.",
1145 ntohs(rte->family),
1146 inet_ntoa(from->sin_addr));
1147 continue;
1148 }
1149
1150 /* - is the destination address valid (e.g., unicast; not net 0
1151 or 127) */
1152 if (!rip_destination_check(rte->prefix)) {
1153 zlog_info(
1154 "Network is net 0 or net 127 or it is not unicast network");
1155 rip_peer_bad_route(from);
1156 continue;
1157 }
1158
1159 /* Convert metric value to host byte order. */
1160 rte->metric = ntohl(rte->metric);
1161
1162 /* - is the metric valid (i.e., between 1 and 16, inclusive) */
1163 if (!(rte->metric >= 1 && rte->metric <= 16)) {
1164 zlog_info("Route's metric is not in the 1-16 range.");
1165 rip_peer_bad_route(from);
1166 continue;
1167 }
1168
1169 /* RIPv1 does not have nexthop value. */
1170 if (packet->version == RIPv1 && rte->nexthop.s_addr != 0) {
1171 zlog_info("RIPv1 packet with nexthop value %s",
1172 inet_ntoa(rte->nexthop));
1173 rip_peer_bad_route(from);
1174 continue;
1175 }
1176
1177 /* That is, if the provided information is ignored, a possibly
1178 sub-optimal, but absolutely valid, route may be taken. If
1179 the received Next Hop is not directly reachable, it should be
1180 treated as 0.0.0.0. */
1181 if (packet->version == RIPv2 && rte->nexthop.s_addr != 0) {
1182 u_int32_t addrval;
1183
1184 /* Multicast address check. */
1185 addrval = ntohl(rte->nexthop.s_addr);
1186 if (IN_CLASSD(addrval)) {
1187 zlog_info(
1188 "Nexthop %s is multicast address, skip this rte",
1189 inet_ntoa(rte->nexthop));
1190 continue;
1191 }
1192
1193 if (!if_lookup_address((void *)&rte->nexthop, AF_INET,
1194 VRF_DEFAULT)) {
1195 struct route_node *rn;
1196 struct rip_info *rinfo;
1197
1198 rn = route_node_match_ipv4(rip->table,
1199 &rte->nexthop);
1200
1201 if (rn) {
1202 rinfo = rn->info;
1203
1204 if (rinfo->type == ZEBRA_ROUTE_RIP
1205 && rinfo->sub_type
1206 == RIP_ROUTE_RTE) {
1207 if (IS_RIP_DEBUG_EVENT)
1208 zlog_debug(
1209 "Next hop %s is on RIP network. Set nexthop to the packet's originator",
1210 inet_ntoa(
1211 rte->nexthop));
1212 rte->nexthop = rinfo->from;
1213 } else {
1214 if (IS_RIP_DEBUG_EVENT)
1215 zlog_debug(
1216 "Next hop %s is not directly reachable. Treat it as 0.0.0.0",
1217 inet_ntoa(
1218 rte->nexthop));
1219 rte->nexthop.s_addr = 0;
1220 }
1221
1222 route_unlock_node(rn);
1223 } else {
1224 if (IS_RIP_DEBUG_EVENT)
1225 zlog_debug(
1226 "Next hop %s is not directly reachable. Treat it as 0.0.0.0",
1227 inet_ntoa(
1228 rte->nexthop));
1229 rte->nexthop.s_addr = 0;
1230 }
1231 }
1232 }
1233
1234 /* For RIPv1, there won't be a valid netmask.
1235
1236 This is a best guess at the masks. If everyone was using old
1237 Ciscos before the 'ip subnet zero' option, it would be almost
1238 right too :-)
1239
1240 Cisco summarize ripv1 advertisments to the classful boundary
1241 (/16 for class B's) except when the RIP packet does to inside
1242 the classful network in question. */
1243
1244 if ((packet->version == RIPv1 && rte->prefix.s_addr != 0)
1245 || (packet->version == RIPv2
1246 && (rte->prefix.s_addr != 0
1247 && rte->mask.s_addr == 0))) {
1248 u_int32_t destination;
1249
1250 if (subnetted == -1) {
1251 memcpy(&ifaddr, ifc->address,
1252 sizeof(struct prefix_ipv4));
1253 memcpy(&ifaddrclass, &ifaddr,
1254 sizeof(struct prefix_ipv4));
1255 apply_classful_mask_ipv4(&ifaddrclass);
1256 subnetted = 0;
1257 if (ifaddr.prefixlen > ifaddrclass.prefixlen)
1258 subnetted = 1;
1259 }
1260
1261 destination = ntohl(rte->prefix.s_addr);
1262
1263 if (IN_CLASSA(destination))
1264 masklen2ip(8, &rte->mask);
1265 else if (IN_CLASSB(destination))
1266 masklen2ip(16, &rte->mask);
1267 else if (IN_CLASSC(destination))
1268 masklen2ip(24, &rte->mask);
1269
1270 if (subnetted == 1)
1271 masklen2ip(ifaddrclass.prefixlen,
1272 (struct in_addr *)&destination);
1273 if ((subnetted == 1)
1274 && ((rte->prefix.s_addr & destination)
1275 == ifaddrclass.prefix.s_addr)) {
1276 masklen2ip(ifaddr.prefixlen, &rte->mask);
1277 if ((rte->prefix.s_addr & rte->mask.s_addr)
1278 != rte->prefix.s_addr)
1279 masklen2ip(32, &rte->mask);
1280 if (IS_RIP_DEBUG_EVENT)
1281 zlog_debug("Subnetted route %s",
1282 inet_ntoa(rte->prefix));
1283 } else {
1284 if ((rte->prefix.s_addr & rte->mask.s_addr)
1285 != rte->prefix.s_addr)
1286 continue;
1287 }
1288
1289 if (IS_RIP_DEBUG_EVENT) {
1290 zlog_debug("Resultant route %s",
1291 inet_ntoa(rte->prefix));
1292 zlog_debug("Resultant mask %s",
1293 inet_ntoa(rte->mask));
1294 }
1295 }
1296
1297 /* In case of RIPv2, if prefix in RTE is not netmask applied one
1298 ignore the entry. */
1299 if ((packet->version == RIPv2) && (rte->mask.s_addr != 0)
1300 && ((rte->prefix.s_addr & rte->mask.s_addr)
1301 != rte->prefix.s_addr)) {
1302 zlog_warn(
1303 "RIPv2 address %s is not mask /%d applied one",
1304 inet_ntoa(rte->prefix), ip_masklen(rte->mask));
1305 rip_peer_bad_route(from);
1306 continue;
1307 }
1308
1309 /* Default route's netmask is ignored. */
1310 if (packet->version == RIPv2 && (rte->prefix.s_addr == 0)
1311 && (rte->mask.s_addr != 0)) {
1312 if (IS_RIP_DEBUG_EVENT)
1313 zlog_debug(
1314 "Default route with non-zero netmask. Set zero to netmask");
1315 rte->mask.s_addr = 0;
1316 }
1317
1318 /* Routing table updates. */
1319 rip_rte_process(rte, from, ifc->ifp);
1320 }
1321 }
1322
1323 /* Make socket for RIP protocol. */
1324 static int rip_create_socket(void)
1325 {
1326 int ret;
1327 int sock;
1328 struct sockaddr_in addr;
1329
1330 memset(&addr, 0, sizeof(struct sockaddr_in));
1331 addr.sin_family = AF_INET;
1332 addr.sin_addr.s_addr = INADDR_ANY;
1333 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1334 addr.sin_len = sizeof(struct sockaddr_in);
1335 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1336 /* sending port must always be the RIP port */
1337 addr.sin_port = htons(RIP_PORT_DEFAULT);
1338
1339 /* Make datagram socket. */
1340 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1341 if (sock < 0) {
1342 zlog_err("Cannot create UDP socket: %s", safe_strerror(errno));
1343 exit(1);
1344 }
1345
1346 sockopt_broadcast(sock);
1347 sockopt_reuseaddr(sock);
1348 sockopt_reuseport(sock);
1349 setsockopt_ipv4_multicast_loop(sock, 0);
1350 #ifdef RIP_RECVMSG
1351 setsockopt_pktinfo(sock);
1352 #endif /* RIP_RECVMSG */
1353 #ifdef IPTOS_PREC_INTERNETCONTROL
1354 setsockopt_ipv4_tos(sock, IPTOS_PREC_INTERNETCONTROL);
1355 #endif
1356
1357 if (ripd_privs.change(ZPRIVS_RAISE))
1358 zlog_err("rip_create_socket: could not raise privs");
1359 setsockopt_so_recvbuf(sock, RIP_UDP_RCV_BUF);
1360 if ((ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr))) < 0)
1361
1362 {
1363 int save_errno = errno;
1364 if (ripd_privs.change(ZPRIVS_LOWER))
1365 zlog_err("rip_create_socket: could not lower privs");
1366
1367 zlog_err("%s: Can't bind socket %d to %s port %d: %s", __func__,
1368 sock, inet_ntoa(addr.sin_addr),
1369 (int)ntohs(addr.sin_port), safe_strerror(save_errno));
1370
1371 close(sock);
1372 return ret;
1373 }
1374
1375 if (ripd_privs.change(ZPRIVS_LOWER))
1376 zlog_err("rip_create_socket: could not lower privs");
1377
1378 return sock;
1379 }
1380
1381 /* RIP packet send to destination address, on interface denoted by
1382 * by connected argument. NULL to argument denotes destination should be
1383 * should be RIP multicast group
1384 */
1385 static int rip_send_packet(u_char *buf, int size, struct sockaddr_in *to,
1386 struct connected *ifc)
1387 {
1388 int ret;
1389 struct sockaddr_in sin;
1390
1391 assert(ifc != NULL);
1392
1393 if (IS_RIP_DEBUG_PACKET) {
1394 #define ADDRESS_SIZE 20
1395 char dst[ADDRESS_SIZE];
1396 dst[ADDRESS_SIZE - 1] = '\0';
1397
1398 if (to) {
1399 strncpy(dst, inet_ntoa(to->sin_addr), ADDRESS_SIZE - 1);
1400 } else {
1401 sin.sin_addr.s_addr = htonl(INADDR_RIP_GROUP);
1402 strncpy(dst, inet_ntoa(sin.sin_addr), ADDRESS_SIZE - 1);
1403 }
1404 #undef ADDRESS_SIZE
1405 zlog_debug("rip_send_packet %s > %s (%s)",
1406 inet_ntoa(ifc->address->u.prefix4), dst,
1407 ifc->ifp->name);
1408 }
1409
1410 if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY)) {
1411 /*
1412 * ZEBRA_IFA_SECONDARY is set on linux when an interface is
1413 * configured
1414 * with multiple addresses on the same subnet: the first address
1415 * on the subnet is configured "primary", and all subsequent
1416 * addresses
1417 * on that subnet are treated as "secondary" addresses.
1418 * In order to avoid routing-table bloat on other rip listeners,
1419 * we do not send out RIP packets with ZEBRA_IFA_SECONDARY
1420 * source addrs.
1421 * XXX Since Linux is the only system for which the
1422 * ZEBRA_IFA_SECONDARY
1423 * flag is set, we would end up sending a packet for a
1424 * "secondary"
1425 * source address on non-linux systems.
1426 */
1427 if (IS_RIP_DEBUG_PACKET)
1428 zlog_debug("duplicate dropped");
1429 return 0;
1430 }
1431
1432 /* Make destination address. */
1433 memset(&sin, 0, sizeof(struct sockaddr_in));
1434 sin.sin_family = AF_INET;
1435 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1436 sin.sin_len = sizeof(struct sockaddr_in);
1437 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1438
1439 /* When destination is specified, use it's port and address. */
1440 if (to) {
1441 sin.sin_port = to->sin_port;
1442 sin.sin_addr = to->sin_addr;
1443 } else {
1444 sin.sin_port = htons(RIP_PORT_DEFAULT);
1445 sin.sin_addr.s_addr = htonl(INADDR_RIP_GROUP);
1446
1447 rip_interface_multicast_set(rip->sock, ifc);
1448 }
1449
1450 ret = sendto(rip->sock, buf, size, 0, (struct sockaddr *)&sin,
1451 sizeof(struct sockaddr_in));
1452
1453 if (IS_RIP_DEBUG_EVENT)
1454 zlog_debug("SEND to %s.%d", inet_ntoa(sin.sin_addr),
1455 ntohs(sin.sin_port));
1456
1457 if (ret < 0)
1458 zlog_warn("can't send packet : %s", safe_strerror(errno));
1459
1460 return ret;
1461 }
1462
1463 /* Add redistributed route to RIP table. */
1464 void rip_redistribute_add(int type, int sub_type, struct prefix_ipv4 *p,
1465 struct nexthop *nh, unsigned int metric,
1466 unsigned char distance, route_tag_t tag)
1467 {
1468 int ret;
1469 struct route_node *rp = NULL;
1470 struct rip_info *rinfo = NULL, newinfo;
1471 struct list *list = NULL;
1472
1473 /* Redistribute route */
1474 ret = rip_destination_check(p->prefix);
1475 if (!ret)
1476 return;
1477
1478 rp = route_node_get(rip->table, (struct prefix *)p);
1479
1480 memset(&newinfo, 0, sizeof(struct rip_info));
1481 newinfo.type = type;
1482 newinfo.sub_type = sub_type;
1483 newinfo.metric = 1;
1484 newinfo.external_metric = metric;
1485 newinfo.distance = distance;
1486 if (tag <= UINT16_MAX) /* RIP only supports 16 bit tags */
1487 newinfo.tag = tag;
1488 newinfo.rp = rp;
1489 newinfo.nh = *nh;
1490
1491 if ((list = rp->info) != NULL && listcount(list) != 0) {
1492 rinfo = listgetdata(listhead(list));
1493
1494 if (rinfo->type == ZEBRA_ROUTE_CONNECT
1495 && rinfo->sub_type == RIP_ROUTE_INTERFACE
1496 && rinfo->metric != RIP_METRIC_INFINITY) {
1497 route_unlock_node(rp);
1498 return;
1499 }
1500
1501 /* Manually configured RIP route check. */
1502 if (rinfo->type == ZEBRA_ROUTE_RIP
1503 && ((rinfo->sub_type == RIP_ROUTE_STATIC)
1504 || (rinfo->sub_type == RIP_ROUTE_DEFAULT))) {
1505 if (type != ZEBRA_ROUTE_RIP
1506 || ((sub_type != RIP_ROUTE_STATIC)
1507 && (sub_type != RIP_ROUTE_DEFAULT))) {
1508 route_unlock_node(rp);
1509 return;
1510 }
1511 }
1512
1513 (void)rip_ecmp_replace(&newinfo);
1514 route_unlock_node(rp);
1515 } else
1516 (void)rip_ecmp_add(&newinfo);
1517
1518 if (IS_RIP_DEBUG_EVENT) {
1519 zlog_debug("Redistribute new prefix %s/%d",
1520 inet_ntoa(p->prefix), p->prefixlen);
1521 }
1522
1523 rip_event(RIP_TRIGGERED_UPDATE, 0);
1524 }
1525
1526 /* Delete redistributed route from RIP table. */
1527 void rip_redistribute_delete(int type, int sub_type, struct prefix_ipv4 *p,
1528 ifindex_t ifindex)
1529 {
1530 int ret;
1531 struct route_node *rp;
1532 struct rip_info *rinfo;
1533
1534 ret = rip_destination_check(p->prefix);
1535 if (!ret)
1536 return;
1537
1538 rp = route_node_lookup(rip->table, (struct prefix *)p);
1539 if (rp) {
1540 struct list *list = rp->info;
1541
1542 if (list != NULL && listcount(list) != 0) {
1543 rinfo = listgetdata(listhead(list));
1544 if (rinfo != NULL && rinfo->type == type
1545 && rinfo->sub_type == sub_type
1546 && rinfo->nh.ifindex == ifindex) {
1547 /* Perform poisoned reverse. */
1548 rinfo->metric = RIP_METRIC_INFINITY;
1549 RIP_TIMER_ON(rinfo->t_garbage_collect,
1550 rip_garbage_collect,
1551 rip->garbage_time);
1552 RIP_TIMER_OFF(rinfo->t_timeout);
1553 rinfo->flags |= RIP_RTF_CHANGED;
1554
1555 if (IS_RIP_DEBUG_EVENT)
1556 zlog_debug(
1557 "Poison %s/%d on the interface %s with an "
1558 "infinity metric [delete]",
1559 inet_ntoa(p->prefix),
1560 p->prefixlen,
1561 ifindex2ifname(ifindex,
1562 VRF_DEFAULT));
1563
1564 rip_event(RIP_TRIGGERED_UPDATE, 0);
1565 }
1566 }
1567 route_unlock_node(rp);
1568 }
1569 }
1570
1571 /* Response to request called from rip_read ().*/
1572 static void rip_request_process(struct rip_packet *packet, int size,
1573 struct sockaddr_in *from, struct connected *ifc)
1574 {
1575 caddr_t lim;
1576 struct rte *rte;
1577 struct prefix_ipv4 p;
1578 struct route_node *rp;
1579 struct rip_info *rinfo;
1580 struct rip_interface *ri;
1581
1582 /* Does not reponse to the requests on the loopback interfaces */
1583 if (if_is_loopback(ifc->ifp))
1584 return;
1585
1586 /* Check RIP process is enabled on this interface. */
1587 ri = ifc->ifp->info;
1588 if (!ri->running)
1589 return;
1590
1591 /* When passive interface is specified, suppress responses */
1592 if (ri->passive)
1593 return;
1594
1595 /* RIP peer update. */
1596 rip_peer_update(from, packet->version);
1597
1598 lim = ((caddr_t)packet) + size;
1599 rte = packet->rte;
1600
1601 /* The Request is processed entry by entry. If there are no
1602 entries, no response is given. */
1603 if (lim == (caddr_t)rte)
1604 return;
1605
1606 /* There is one special case. If there is exactly one entry in the
1607 request, and it has an address family identifier of zero and a
1608 metric of infinity (i.e., 16), then this is a request to send the
1609 entire routing table. */
1610 if (lim == ((caddr_t)(rte + 1)) && ntohs(rte->family) == 0
1611 && ntohl(rte->metric) == RIP_METRIC_INFINITY) {
1612 /* All route with split horizon */
1613 rip_output_process(ifc, from, rip_all_route, packet->version);
1614 } else {
1615 if (ntohs(rte->family) != AF_INET)
1616 return;
1617
1618 /* Examine the list of RTEs in the Request one by one. For each
1619 entry, look up the destination in the router's routing
1620 database and, if there is a route, put that route's metric in
1621 the metric field of the RTE. If there is no explicit route
1622 to the specified destination, put infinity in the metric
1623 field. Once all the entries have been filled in, change the
1624 command from Request to Response and send the datagram back
1625 to the requestor. */
1626 p.family = AF_INET;
1627
1628 for (; ((caddr_t)rte) < lim; rte++) {
1629 p.prefix = rte->prefix;
1630 p.prefixlen = ip_masklen(rte->mask);
1631 apply_mask_ipv4(&p);
1632
1633 rp = route_node_lookup(rip->table, (struct prefix *)&p);
1634 if (rp) {
1635 rinfo = listgetdata(
1636 listhead((struct list *)rp->info));
1637 rte->metric = htonl(rinfo->metric);
1638 route_unlock_node(rp);
1639 } else
1640 rte->metric = htonl(RIP_METRIC_INFINITY);
1641 }
1642 packet->command = RIP_RESPONSE;
1643
1644 rip_send_packet((u_char *)packet, size, from, ifc);
1645 }
1646 rip_global_queries++;
1647 }
1648
1649 #if RIP_RECVMSG
1650 /* Set IPv6 packet info to the socket. */
1651 static int setsockopt_pktinfo(int sock)
1652 {
1653 int ret;
1654 int val = 1;
1655
1656 ret = setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &val, sizeof(val));
1657 if (ret < 0)
1658 zlog_warn("Can't setsockopt IP_PKTINFO : %s",
1659 safe_strerror(errno));
1660 return ret;
1661 }
1662
1663 /* Read RIP packet by recvmsg function. */
1664 int rip_recvmsg(int sock, u_char *buf, int size, struct sockaddr_in *from,
1665 ifindex_t *ifindex)
1666 {
1667 int ret;
1668 struct msghdr msg;
1669 struct iovec iov;
1670 struct cmsghdr *ptr;
1671 char adata[1024];
1672
1673 memset(&msg, 0, sizeof(msg));
1674 msg.msg_name = (void *)from;
1675 msg.msg_namelen = sizeof(struct sockaddr_in);
1676 msg.msg_iov = &iov;
1677 msg.msg_iovlen = 1;
1678 msg.msg_control = (void *)adata;
1679 msg.msg_controllen = sizeof adata;
1680 iov.iov_base = buf;
1681 iov.iov_len = size;
1682
1683 ret = recvmsg(sock, &msg, 0);
1684 if (ret < 0)
1685 return ret;
1686
1687 for (ptr = ZCMSG_FIRSTHDR(&msg); ptr != NULL;
1688 ptr = CMSG_NXTHDR(&msg, ptr))
1689 if (ptr->cmsg_level == IPPROTO_IP
1690 && ptr->cmsg_type == IP_PKTINFO) {
1691 struct in_pktinfo *pktinfo;
1692 int i;
1693
1694 pktinfo = (struct in_pktinfo *)CMSG_DATA(ptr);
1695 i = pktinfo->ipi_ifindex;
1696 }
1697 return ret;
1698 }
1699
1700 /* RIP packet read function. */
1701 int rip_read_new(struct thread *t)
1702 {
1703 int ret;
1704 int sock;
1705 char buf[RIP_PACKET_MAXSIZ];
1706 struct sockaddr_in from;
1707 ifindex_t ifindex;
1708
1709 /* Fetch socket then register myself. */
1710 sock = THREAD_FD(t);
1711 rip_event(RIP_READ, sock);
1712
1713 /* Read RIP packet. */
1714 ret = rip_recvmsg(sock, buf, RIP_PACKET_MAXSIZ, &from, (int *)&ifindex);
1715 if (ret < 0) {
1716 zlog_warn("Can't read RIP packet: %s", safe_strerror(errno));
1717 return ret;
1718 }
1719
1720 return ret;
1721 }
1722 #endif /* RIP_RECVMSG */
1723
1724 /* First entry point of RIP packet. */
1725 static int rip_read(struct thread *t)
1726 {
1727 int sock;
1728 int ret;
1729 int rtenum;
1730 union rip_buf rip_buf;
1731 struct rip_packet *packet;
1732 struct sockaddr_in from;
1733 int len;
1734 int vrecv;
1735 socklen_t fromlen;
1736 struct interface *ifp = NULL;
1737 struct connected *ifc;
1738 struct rip_interface *ri;
1739 struct prefix p;
1740
1741 /* Fetch socket then register myself. */
1742 sock = THREAD_FD(t);
1743 rip->t_read = NULL;
1744
1745 /* Add myself to tne next event */
1746 rip_event(RIP_READ, sock);
1747
1748 /* RIPd manages only IPv4. */
1749 memset(&from, 0, sizeof(struct sockaddr_in));
1750 fromlen = sizeof(struct sockaddr_in);
1751
1752 len = recvfrom(sock, (char *)&rip_buf.buf, sizeof(rip_buf.buf), 0,
1753 (struct sockaddr *)&from, &fromlen);
1754 if (len < 0) {
1755 zlog_info("recvfrom failed: %s", safe_strerror(errno));
1756 return len;
1757 }
1758
1759 /* Check is this packet comming from myself? */
1760 if (if_check_address(from.sin_addr)) {
1761 if (IS_RIP_DEBUG_PACKET)
1762 zlog_debug("ignore packet comes from myself");
1763 return -1;
1764 }
1765
1766 /* Which interface is this packet comes from. */
1767 ifc = if_lookup_address((void *)&from.sin_addr, AF_INET, VRF_DEFAULT);
1768 if (ifc)
1769 ifp = ifc->ifp;
1770
1771 /* RIP packet received */
1772 if (IS_RIP_DEBUG_EVENT)
1773 zlog_debug("RECV packet from %s port %d on %s",
1774 inet_ntoa(from.sin_addr), ntohs(from.sin_port),
1775 ifp ? ifp->name : "unknown");
1776
1777 /* If this packet come from unknown interface, ignore it. */
1778 if (ifp == NULL) {
1779 zlog_info(
1780 "rip_read: cannot find interface for packet from %s port %d",
1781 inet_ntoa(from.sin_addr), ntohs(from.sin_port));
1782 return -1;
1783 }
1784
1785 p.family = AF_INET;
1786 p.u.prefix4 = from.sin_addr;
1787 p.prefixlen = IPV4_MAX_BITLEN;
1788
1789 ifc = connected_lookup_prefix(ifp, &p);
1790
1791 if (ifc == NULL) {
1792 zlog_info(
1793 "rip_read: cannot find connected address for packet from %s "
1794 "port %d on interface %s",
1795 inet_ntoa(from.sin_addr), ntohs(from.sin_port),
1796 ifp->name);
1797 return -1;
1798 }
1799
1800 /* Packet length check. */
1801 if (len < RIP_PACKET_MINSIZ) {
1802 zlog_warn("packet size %d is smaller than minimum size %d", len,
1803 RIP_PACKET_MINSIZ);
1804 rip_peer_bad_packet(&from);
1805 return len;
1806 }
1807 if (len > RIP_PACKET_MAXSIZ) {
1808 zlog_warn("packet size %d is larger than max size %d", len,
1809 RIP_PACKET_MAXSIZ);
1810 rip_peer_bad_packet(&from);
1811 return len;
1812 }
1813
1814 /* Packet alignment check. */
1815 if ((len - RIP_PACKET_MINSIZ) % 20) {
1816 zlog_warn("packet size %d is wrong for RIP packet alignment",
1817 len);
1818 rip_peer_bad_packet(&from);
1819 return len;
1820 }
1821
1822 /* Set RTE number. */
1823 rtenum = ((len - RIP_PACKET_MINSIZ) / 20);
1824
1825 /* For easy to handle. */
1826 packet = &rip_buf.rip_packet;
1827
1828 /* RIP version check. */
1829 if (packet->version == 0) {
1830 zlog_info("version 0 with command %d received.",
1831 packet->command);
1832 rip_peer_bad_packet(&from);
1833 return -1;
1834 }
1835
1836 /* Dump RIP packet. */
1837 if (IS_RIP_DEBUG_RECV)
1838 rip_packet_dump(packet, len, "RECV");
1839
1840 /* RIP version adjust. This code should rethink now. RFC1058 says
1841 that "Version 1 implementations are to ignore this extra data and
1842 process only the fields specified in this document.". So RIPv3
1843 packet should be treated as RIPv1 ignoring must be zero field. */
1844 if (packet->version > RIPv2)
1845 packet->version = RIPv2;
1846
1847 /* Is RIP running or is this RIP neighbor ?*/
1848 ri = ifp->info;
1849 if (!ri->running && !rip_neighbor_lookup(&from)) {
1850 if (IS_RIP_DEBUG_EVENT)
1851 zlog_debug("RIP is not enabled on interface %s.",
1852 ifp->name);
1853 rip_peer_bad_packet(&from);
1854 return -1;
1855 }
1856
1857 /* RIP Version check. RFC2453, 4.6 and 5.1 */
1858 vrecv = ((ri->ri_receive == RI_RIP_UNSPEC) ? rip->version_recv
1859 : ri->ri_receive);
1860 if (vrecv == RI_RIP_VERSION_NONE
1861 || ((packet->version == RIPv1) && !(vrecv & RIPv1))
1862 || ((packet->version == RIPv2) && !(vrecv & RIPv2))) {
1863 if (IS_RIP_DEBUG_PACKET)
1864 zlog_debug(
1865 " packet's v%d doesn't fit to if version spec",
1866 packet->version);
1867 rip_peer_bad_packet(&from);
1868 return -1;
1869 }
1870
1871 /* RFC2453 5.2 If the router is not configured to authenticate RIP-2
1872 messages, then RIP-1 and unauthenticated RIP-2 messages will be
1873 accepted; authenticated RIP-2 messages shall be discarded. */
1874 if ((ri->auth_type == RIP_NO_AUTH) && rtenum
1875 && (packet->version == RIPv2)
1876 && (packet->rte->family == htons(RIP_FAMILY_AUTH))) {
1877 if (IS_RIP_DEBUG_EVENT)
1878 zlog_debug(
1879 "packet RIPv%d is dropped because authentication disabled",
1880 packet->version);
1881 rip_peer_bad_packet(&from);
1882 return -1;
1883 }
1884
1885 /* RFC:
1886 If the router is configured to authenticate RIP-2 messages, then
1887 RIP-1 messages and RIP-2 messages which pass authentication
1888 testing shall be accepted; unauthenticated and failed
1889 authentication RIP-2 messages shall be discarded. For maximum
1890 security, RIP-1 messages should be ignored when authentication is
1891 in use (see section 4.1); otherwise, the routing information from
1892 authenticated messages will be propagated by RIP-1 routers in an
1893 unauthenticated manner.
1894 */
1895 /* We make an exception for RIPv1 REQUEST packets, to which we'll
1896 * always reply regardless of authentication settings, because:
1897 *
1898 * - if there other authorised routers on-link, the REQUESTor can
1899 * passively obtain the routing updates anyway
1900 * - if there are no other authorised routers on-link, RIP can
1901 * easily be disabled for the link to prevent giving out information
1902 * on state of this routers RIP routing table..
1903 *
1904 * I.e. if RIPv1 has any place anymore these days, it's as a very
1905 * simple way to distribute routing information (e.g. to embedded
1906 * hosts / appliances) and the ability to give out RIPv1
1907 * routing-information freely, while still requiring RIPv2
1908 * authentication for any RESPONSEs might be vaguely useful.
1909 */
1910 if (ri->auth_type != RIP_NO_AUTH && packet->version == RIPv1) {
1911 /* Discard RIPv1 messages other than REQUESTs */
1912 if (packet->command != RIP_REQUEST) {
1913 if (IS_RIP_DEBUG_PACKET)
1914 zlog_debug(
1915 "RIPv1"
1916 " dropped because authentication enabled");
1917 rip_peer_bad_packet(&from);
1918 return -1;
1919 }
1920 } else if (ri->auth_type != RIP_NO_AUTH) {
1921 const char *auth_desc;
1922
1923 if (rtenum == 0) {
1924 /* There definitely is no authentication in the packet.
1925 */
1926 if (IS_RIP_DEBUG_PACKET)
1927 zlog_debug(
1928 "RIPv2 authentication failed: no auth RTE in packet");
1929 rip_peer_bad_packet(&from);
1930 return -1;
1931 }
1932
1933 /* First RTE must be an Authentication Family RTE */
1934 if (packet->rte->family != htons(RIP_FAMILY_AUTH)) {
1935 if (IS_RIP_DEBUG_PACKET)
1936 zlog_debug(
1937 "RIPv2"
1938 " dropped because authentication enabled");
1939 rip_peer_bad_packet(&from);
1940 return -1;
1941 }
1942
1943 /* Check RIPv2 authentication. */
1944 switch (ntohs(packet->rte->tag)) {
1945 case RIP_AUTH_SIMPLE_PASSWORD:
1946 auth_desc = "simple";
1947 ret = rip_auth_simple_password(packet->rte, &from, ifp);
1948 break;
1949
1950 case RIP_AUTH_MD5:
1951 auth_desc = "MD5";
1952 ret = rip_auth_md5(packet, &from, len, ifp);
1953 /* Reset RIP packet length to trim MD5 data. */
1954 len = ret;
1955 break;
1956
1957 default:
1958 ret = 0;
1959 auth_desc = "unknown type";
1960 if (IS_RIP_DEBUG_PACKET)
1961 zlog_debug(
1962 "RIPv2 Unknown authentication type %d",
1963 ntohs(packet->rte->tag));
1964 }
1965
1966 if (ret) {
1967 if (IS_RIP_DEBUG_PACKET)
1968 zlog_debug("RIPv2 %s authentication success",
1969 auth_desc);
1970 } else {
1971 if (IS_RIP_DEBUG_PACKET)
1972 zlog_debug("RIPv2 %s authentication failure",
1973 auth_desc);
1974 rip_peer_bad_packet(&from);
1975 return -1;
1976 }
1977 }
1978
1979 /* Process each command. */
1980 switch (packet->command) {
1981 case RIP_RESPONSE:
1982 rip_response_process(packet, len, &from, ifc);
1983 break;
1984 case RIP_REQUEST:
1985 case RIP_POLL:
1986 rip_request_process(packet, len, &from, ifc);
1987 break;
1988 case RIP_TRACEON:
1989 case RIP_TRACEOFF:
1990 zlog_info(
1991 "Obsolete command %s received, please sent it to routed",
1992 lookup_msg(rip_msg, packet->command, NULL));
1993 rip_peer_bad_packet(&from);
1994 break;
1995 case RIP_POLL_ENTRY:
1996 zlog_info("Obsolete command %s received",
1997 lookup_msg(rip_msg, packet->command, NULL));
1998 rip_peer_bad_packet(&from);
1999 break;
2000 default:
2001 zlog_info("Unknown RIP command %d received", packet->command);
2002 rip_peer_bad_packet(&from);
2003 break;
2004 }
2005
2006 return len;
2007 }
2008
2009 /* Write routing table entry to the stream and return next index of
2010 the routing table entry in the stream. */
2011 static int rip_write_rte(int num, struct stream *s, struct prefix_ipv4 *p,
2012 u_char version, struct rip_info *rinfo)
2013 {
2014 struct in_addr mask;
2015
2016 /* Write routing table entry. */
2017 if (version == RIPv1) {
2018 stream_putw(s, AF_INET);
2019 stream_putw(s, 0);
2020 stream_put_ipv4(s, p->prefix.s_addr);
2021 stream_put_ipv4(s, 0);
2022 stream_put_ipv4(s, 0);
2023 stream_putl(s, rinfo->metric_out);
2024 } else {
2025 masklen2ip(p->prefixlen, &mask);
2026
2027 stream_putw(s, AF_INET);
2028 stream_putw(s, rinfo->tag_out);
2029 stream_put_ipv4(s, p->prefix.s_addr);
2030 stream_put_ipv4(s, mask.s_addr);
2031 stream_put_ipv4(s, rinfo->nexthop_out.s_addr);
2032 stream_putl(s, rinfo->metric_out);
2033 }
2034
2035 return ++num;
2036 }
2037
2038 /* Send update to the ifp or spcified neighbor. */
2039 void rip_output_process(struct connected *ifc, struct sockaddr_in *to,
2040 int route_type, u_char version)
2041 {
2042 int ret;
2043 struct stream *s;
2044 struct route_node *rp;
2045 struct rip_info *rinfo;
2046 struct rip_interface *ri;
2047 struct prefix_ipv4 *p;
2048 struct prefix_ipv4 classfull;
2049 struct prefix_ipv4 ifaddrclass;
2050 struct key *key = NULL;
2051 /* this might need to made dynamic if RIP ever supported auth methods
2052 with larger key string sizes */
2053 char auth_str[RIP_AUTH_SIMPLE_SIZE];
2054 size_t doff = 0; /* offset of digest offset field */
2055 int num = 0;
2056 int rtemax;
2057 int subnetted = 0;
2058 struct list *list = NULL;
2059 struct listnode *listnode = NULL;
2060
2061 /* Logging output event. */
2062 if (IS_RIP_DEBUG_EVENT) {
2063 if (to)
2064 zlog_debug("update routes to neighbor %s",
2065 inet_ntoa(to->sin_addr));
2066 else
2067 zlog_debug("update routes on interface %s ifindex %d",
2068 ifc->ifp->name, ifc->ifp->ifindex);
2069 }
2070
2071 /* Set output stream. */
2072 s = rip->obuf;
2073
2074 /* Reset stream and RTE counter. */
2075 stream_reset(s);
2076 rtemax = RIP_MAX_RTE;
2077
2078 /* Get RIP interface. */
2079 ri = ifc->ifp->info;
2080
2081 /* If output interface is in simple password authentication mode, we
2082 need space for authentication data. */
2083 if (ri->auth_type == RIP_AUTH_SIMPLE_PASSWORD)
2084 rtemax -= 1;
2085
2086 /* If output interface is in MD5 authentication mode, we need space
2087 for authentication header and data. */
2088 if (ri->auth_type == RIP_AUTH_MD5)
2089 rtemax -= 2;
2090
2091 /* If output interface is in simple password authentication mode
2092 and string or keychain is specified we need space for auth. data */
2093 if (ri->auth_type != RIP_NO_AUTH) {
2094 if (ri->key_chain) {
2095 struct keychain *keychain;
2096
2097 keychain = keychain_lookup(ri->key_chain);
2098 if (keychain)
2099 key = key_lookup_for_send(keychain);
2100 }
2101 /* to be passed to auth functions later */
2102 rip_auth_prepare_str_send(ri, key, auth_str,
2103 RIP_AUTH_SIMPLE_SIZE);
2104 }
2105
2106 if (version == RIPv1) {
2107 memcpy(&ifaddrclass, ifc->address, sizeof(struct prefix_ipv4));
2108 apply_classful_mask_ipv4(&ifaddrclass);
2109 subnetted = 0;
2110 if (ifc->address->prefixlen > ifaddrclass.prefixlen)
2111 subnetted = 1;
2112 }
2113
2114 for (rp = route_top(rip->table); rp; rp = route_next(rp))
2115 if ((list = rp->info) != NULL && listcount(list) != 0) {
2116 rinfo = listgetdata(listhead(list));
2117 /* For RIPv1, if we are subnetted, output subnets in our
2118 * network */
2119 /* that have the same mask as the output "interface".
2120 * For other */
2121 /* networks, only the classfull version is output. */
2122
2123 if (version == RIPv1) {
2124 p = (struct prefix_ipv4 *)&rp->p;
2125
2126 if (IS_RIP_DEBUG_PACKET)
2127 zlog_debug(
2128 "RIPv1 mask check, %s/%d considered for output",
2129 inet_ntoa(rp->p.u.prefix4),
2130 rp->p.prefixlen);
2131
2132 if (subnetted
2133 && prefix_match(
2134 (struct prefix *)&ifaddrclass,
2135 &rp->p)) {
2136 if ((ifc->address->prefixlen
2137 != rp->p.prefixlen)
2138 && (rp->p.prefixlen != 32))
2139 continue;
2140 } else {
2141 memcpy(&classfull, &rp->p,
2142 sizeof(struct prefix_ipv4));
2143 apply_classful_mask_ipv4(&classfull);
2144 if (rp->p.u.prefix4.s_addr != 0
2145 && classfull.prefixlen
2146 != rp->p.prefixlen)
2147 continue;
2148 }
2149 if (IS_RIP_DEBUG_PACKET)
2150 zlog_debug(
2151 "RIPv1 mask check, %s/%d made it through",
2152 inet_ntoa(rp->p.u.prefix4),
2153 rp->p.prefixlen);
2154 } else
2155 p = (struct prefix_ipv4 *)&rp->p;
2156
2157 /* Apply output filters. */
2158 ret = rip_filter(RIP_FILTER_OUT, p, ri);
2159 if (ret < 0)
2160 continue;
2161
2162 /* Changed route only output. */
2163 if (route_type == rip_changed_route
2164 && (!(rinfo->flags & RIP_RTF_CHANGED)))
2165 continue;
2166
2167 /* Split horizon. */
2168 /* if (split_horizon == rip_split_horizon) */
2169 if (ri->split_horizon == RIP_SPLIT_HORIZON) {
2170 /*
2171 * We perform split horizon for RIP and
2172 * connected route.
2173 * For rip routes, we want to suppress the route
2174 * if we would
2175 * end up sending the route back on the
2176 * interface that we
2177 * learned it from, with a higher metric. For
2178 * connected routes,
2179 * we suppress the route if the prefix is a
2180 * subset of the
2181 * source address that we are going to use for
2182 * the packet
2183 * (in order to handle the case when multiple
2184 * subnets are
2185 * configured on the same interface).
2186 */
2187 int suppress = 0;
2188 struct rip_info *tmp_rinfo = NULL;
2189
2190 for (ALL_LIST_ELEMENTS_RO(list, listnode,
2191 tmp_rinfo))
2192 if (tmp_rinfo->type == ZEBRA_ROUTE_RIP
2193 && tmp_rinfo->nh.ifindex
2194 == ifc->ifp->ifindex) {
2195 suppress = 1;
2196 break;
2197 }
2198
2199 if (!suppress
2200 && rinfo->type == ZEBRA_ROUTE_CONNECT
2201 && prefix_match((struct prefix *)p,
2202 ifc->address))
2203 suppress = 1;
2204
2205 if (suppress)
2206 continue;
2207 }
2208
2209 /* Preparation for route-map. */
2210 rinfo->metric_set = 0;
2211 rinfo->nexthop_out.s_addr = 0;
2212 rinfo->metric_out = rinfo->metric;
2213 rinfo->tag_out = rinfo->tag;
2214 rinfo->ifindex_out = ifc->ifp->ifindex;
2215
2216 /* In order to avoid some local loops,
2217 * if the RIP route has a nexthop via this interface,
2218 * keep the nexthop,
2219 * otherwise set it to 0. The nexthop should not be
2220 * propagated
2221 * beyond the local broadcast/multicast area in order
2222 * to avoid an IGP multi-level recursive look-up.
2223 * see (4.4)
2224 */
2225 if (rinfo->nh.ifindex == ifc->ifp->ifindex)
2226 rinfo->nexthop_out = rinfo->nh.gate.ipv4;
2227
2228 /* Interface route-map */
2229 if (ri->routemap[RIP_FILTER_OUT]) {
2230 ret = route_map_apply(
2231 ri->routemap[RIP_FILTER_OUT],
2232 (struct prefix *)p, RMAP_RIP, rinfo);
2233
2234 if (ret == RMAP_DENYMATCH) {
2235 if (IS_RIP_DEBUG_PACKET)
2236 zlog_debug(
2237 "RIP %s/%d is filtered by route-map out",
2238 inet_ntoa(p->prefix),
2239 p->prefixlen);
2240 continue;
2241 }
2242 }
2243
2244 /* Apply redistribute route map - continue, if deny */
2245 if (rip->route_map[rinfo->type].name
2246 && rinfo->sub_type != RIP_ROUTE_INTERFACE) {
2247 ret = route_map_apply(
2248 rip->route_map[rinfo->type].map,
2249 (struct prefix *)p, RMAP_RIP, rinfo);
2250
2251 if (ret == RMAP_DENYMATCH) {
2252 if (IS_RIP_DEBUG_PACKET)
2253 zlog_debug(
2254 "%s/%d is filtered by route-map",
2255 inet_ntoa(p->prefix),
2256 p->prefixlen);
2257 continue;
2258 }
2259 }
2260
2261 /* When route-map does not set metric. */
2262 if (!rinfo->metric_set) {
2263 /* If redistribute metric is set. */
2264 if (rip->route_map[rinfo->type].metric_config
2265 && rinfo->metric != RIP_METRIC_INFINITY) {
2266 rinfo->metric_out =
2267 rip->route_map[rinfo->type]
2268 .metric;
2269 } else {
2270 /* If the route is not connected or
2271 localy generated
2272 one, use default-metric value*/
2273 if (rinfo->type != ZEBRA_ROUTE_RIP
2274 && rinfo->type
2275 != ZEBRA_ROUTE_CONNECT
2276 && rinfo->metric
2277 != RIP_METRIC_INFINITY)
2278 rinfo->metric_out =
2279 rip->default_metric;
2280 }
2281 }
2282
2283 /* Apply offset-list */
2284 if (rinfo->metric != RIP_METRIC_INFINITY)
2285 rip_offset_list_apply_out(p, ifc->ifp,
2286 &rinfo->metric_out);
2287
2288 if (rinfo->metric_out > RIP_METRIC_INFINITY)
2289 rinfo->metric_out = RIP_METRIC_INFINITY;
2290
2291 /* Perform split-horizon with poisoned reverse
2292 * for RIP and connected routes.
2293 **/
2294 if (ri->split_horizon
2295 == RIP_SPLIT_HORIZON_POISONED_REVERSE) {
2296 /*
2297 * We perform split horizon for RIP and
2298 * connected route.
2299 * For rip routes, we want to suppress the route
2300 * if we would
2301 * end up sending the route back on the
2302 * interface that we
2303 * learned it from, with a higher metric. For
2304 * connected routes,
2305 * we suppress the route if the prefix is a
2306 * subset of the
2307 * source address that we are going to use for
2308 * the packet
2309 * (in order to handle the case when multiple
2310 * subnets are
2311 * configured on the same interface).
2312 */
2313 struct rip_info *tmp_rinfo = NULL;
2314
2315 for (ALL_LIST_ELEMENTS_RO(list, listnode,
2316 tmp_rinfo))
2317 if (tmp_rinfo->type == ZEBRA_ROUTE_RIP
2318 && tmp_rinfo->nh.ifindex
2319 == ifc->ifp->ifindex)
2320 tmp_rinfo->metric_out =
2321 RIP_METRIC_INFINITY;
2322
2323 if (rinfo->type == ZEBRA_ROUTE_CONNECT
2324 && prefix_match((struct prefix *)p,
2325 ifc->address))
2326 rinfo->metric_out = RIP_METRIC_INFINITY;
2327 }
2328
2329 /* Prepare preamble, auth headers, if needs be */
2330 if (num == 0) {
2331 stream_putc(s, RIP_RESPONSE);
2332 stream_putc(s, version);
2333 stream_putw(s, 0);
2334
2335 /* auth header for !v1 && !no_auth */
2336 if ((ri->auth_type != RIP_NO_AUTH)
2337 && (version != RIPv1))
2338 doff = rip_auth_header_write(
2339 s, ri, key, auth_str,
2340 RIP_AUTH_SIMPLE_SIZE);
2341 }
2342
2343 /* Write RTE to the stream. */
2344 num = rip_write_rte(num, s, p, version, rinfo);
2345 if (num == rtemax) {
2346 if (version == RIPv2
2347 && ri->auth_type == RIP_AUTH_MD5)
2348 rip_auth_md5_set(s, ri, doff, auth_str,
2349 RIP_AUTH_SIMPLE_SIZE);
2350
2351 ret = rip_send_packet(STREAM_DATA(s),
2352 stream_get_endp(s), to,
2353 ifc);
2354
2355 if (ret >= 0 && IS_RIP_DEBUG_SEND)
2356 rip_packet_dump((struct rip_packet *)
2357 STREAM_DATA(s),
2358 stream_get_endp(s),
2359 "SEND");
2360 num = 0;
2361 stream_reset(s);
2362 }
2363 }
2364
2365 /* Flush unwritten RTE. */
2366 if (num != 0) {
2367 if (version == RIPv2 && ri->auth_type == RIP_AUTH_MD5)
2368 rip_auth_md5_set(s, ri, doff, auth_str,
2369 RIP_AUTH_SIMPLE_SIZE);
2370
2371 ret = rip_send_packet(STREAM_DATA(s), stream_get_endp(s), to,
2372 ifc);
2373
2374 if (ret >= 0 && IS_RIP_DEBUG_SEND)
2375 rip_packet_dump((struct rip_packet *)STREAM_DATA(s),
2376 stream_get_endp(s), "SEND");
2377 stream_reset(s);
2378 }
2379
2380 /* Statistics updates. */
2381 ri->sent_updates++;
2382 }
2383
2384 /* Send RIP packet to the interface. */
2385 static void rip_update_interface(struct connected *ifc, u_char version,
2386 int route_type)
2387 {
2388 struct interface *ifp = ifc->ifp;
2389 struct rip_interface *ri = ifp->info;
2390 struct sockaddr_in to;
2391
2392 /* When RIP version is 2 and multicast enable interface. */
2393 if (version == RIPv2 && !ri->v2_broadcast && if_is_multicast(ifp)) {
2394 if (IS_RIP_DEBUG_EVENT)
2395 zlog_debug("multicast announce on %s ", ifp->name);
2396
2397 rip_output_process(ifc, NULL, route_type, version);
2398 return;
2399 }
2400
2401 /* If we can't send multicast packet, send it with unicast. */
2402 if (if_is_broadcast(ifp) || if_is_pointopoint(ifp)) {
2403 if (ifc->address->family == AF_INET) {
2404 /* Destination address and port setting. */
2405 memset(&to, 0, sizeof(struct sockaddr_in));
2406 if (ifc->destination)
2407 /* use specified broadcast or peer destination
2408 * addr */
2409 to.sin_addr = ifc->destination->u.prefix4;
2410 else if (ifc->address->prefixlen < IPV4_MAX_PREFIXLEN)
2411 /* calculate the appropriate broadcast address
2412 */
2413 to.sin_addr.s_addr = ipv4_broadcast_addr(
2414 ifc->address->u.prefix4.s_addr,
2415 ifc->address->prefixlen);
2416 else
2417 /* do not know where to send the packet */
2418 return;
2419 to.sin_port = htons(RIP_PORT_DEFAULT);
2420
2421 if (IS_RIP_DEBUG_EVENT)
2422 zlog_debug("%s announce to %s on %s",
2423 CONNECTED_PEER(ifc) ? "unicast"
2424 : "broadcast",
2425 inet_ntoa(to.sin_addr), ifp->name);
2426
2427 rip_output_process(ifc, &to, route_type, version);
2428 }
2429 }
2430 }
2431
2432 /* Update send to all interface and neighbor. */
2433 static void rip_update_process(int route_type)
2434 {
2435 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
2436 struct listnode *ifnode, *ifnnode;
2437 struct connected *connected;
2438 struct interface *ifp;
2439 struct rip_interface *ri;
2440 struct route_node *rp;
2441 struct sockaddr_in to;
2442 struct prefix *p;
2443
2444 /* Send RIP update to each interface. */
2445 FOR_ALL_INTERFACES (vrf, ifp) {
2446 if (if_is_loopback(ifp))
2447 continue;
2448
2449 if (!if_is_operative(ifp))
2450 continue;
2451
2452 /* Fetch RIP interface information. */
2453 ri = ifp->info;
2454
2455 /* When passive interface is specified, suppress announce to the
2456 interface. */
2457 if (ri->passive)
2458 continue;
2459
2460 if (ri->running) {
2461 /*
2462 * If there is no version configuration in the
2463 * interface,
2464 * use rip's version setting.
2465 */
2466 int vsend = ((ri->ri_send == RI_RIP_UNSPEC)
2467 ? rip->version_send
2468 : ri->ri_send);
2469
2470 if (IS_RIP_DEBUG_EVENT)
2471 zlog_debug("SEND UPDATE to %s ifindex %d",
2472 ifp->name, ifp->ifindex);
2473
2474 /* send update on each connected network */
2475 for (ALL_LIST_ELEMENTS(ifp->connected, ifnode, ifnnode,
2476 connected)) {
2477 if (connected->address->family == AF_INET) {
2478 if (vsend & RIPv1)
2479 rip_update_interface(
2480 connected, RIPv1,
2481 route_type);
2482 if ((vsend & RIPv2)
2483 && if_is_multicast(ifp))
2484 rip_update_interface(
2485 connected, RIPv2,
2486 route_type);
2487 }
2488 }
2489 }
2490 }
2491
2492 /* RIP send updates to each neighbor. */
2493 for (rp = route_top(rip->neighbor); rp; rp = route_next(rp))
2494 if (rp->info != NULL) {
2495 p = &rp->p;
2496
2497 connected = if_lookup_address(&p->u.prefix4, AF_INET,
2498 VRF_DEFAULT);
2499 if (!connected) {
2500 zlog_warn(
2501 "Neighbor %s doesnt have connected interface!",
2502 inet_ntoa(p->u.prefix4));
2503 continue;
2504 }
2505
2506 /* Set destination address and port */
2507 memset(&to, 0, sizeof(struct sockaddr_in));
2508 to.sin_addr = p->u.prefix4;
2509 to.sin_port = htons(RIP_PORT_DEFAULT);
2510
2511 /* RIP version is rip's configuration. */
2512 rip_output_process(connected, &to, route_type,
2513 rip->version_send);
2514 }
2515 }
2516
2517 /* RIP's periodical timer. */
2518 static int rip_update(struct thread *t)
2519 {
2520 /* Clear timer pointer. */
2521 rip->t_update = NULL;
2522
2523 if (IS_RIP_DEBUG_EVENT)
2524 zlog_debug("update timer fire!");
2525
2526 /* Process update output. */
2527 rip_update_process(rip_all_route);
2528
2529 /* Triggered updates may be suppressed if a regular update is due by
2530 the time the triggered update would be sent. */
2531 RIP_TIMER_OFF(rip->t_triggered_interval);
2532 rip->trigger = 0;
2533
2534 /* Register myself. */
2535 rip_event(RIP_UPDATE_EVENT, 0);
2536
2537 return 0;
2538 }
2539
2540 /* Walk down the RIP routing table then clear changed flag. */
2541 static void rip_clear_changed_flag(void)
2542 {
2543 struct route_node *rp;
2544 struct rip_info *rinfo = NULL;
2545 struct list *list = NULL;
2546 struct listnode *listnode = NULL;
2547
2548 for (rp = route_top(rip->table); rp; rp = route_next(rp))
2549 if ((list = rp->info) != NULL)
2550 for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
2551 UNSET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
2552 /* This flag can be set only on the first entry.
2553 */
2554 break;
2555 }
2556 }
2557
2558 /* Triggered update interval timer. */
2559 static int rip_triggered_interval(struct thread *t)
2560 {
2561 int rip_triggered_update(struct thread *);
2562
2563 rip->t_triggered_interval = NULL;
2564
2565 if (rip->trigger) {
2566 rip->trigger = 0;
2567 rip_triggered_update(t);
2568 }
2569 return 0;
2570 }
2571
2572 /* Execute triggered update. */
2573 static int rip_triggered_update(struct thread *t)
2574 {
2575 int interval;
2576
2577 /* Clear thred pointer. */
2578 rip->t_triggered_update = NULL;
2579
2580 /* Cancel interval timer. */
2581 RIP_TIMER_OFF(rip->t_triggered_interval);
2582 rip->trigger = 0;
2583
2584 /* Logging triggered update. */
2585 if (IS_RIP_DEBUG_EVENT)
2586 zlog_debug("triggered update!");
2587
2588 /* Split Horizon processing is done when generating triggered
2589 updates as well as normal updates (see section 2.6). */
2590 rip_update_process(rip_changed_route);
2591
2592 /* Once all of the triggered updates have been generated, the route
2593 change flags should be cleared. */
2594 rip_clear_changed_flag();
2595
2596 /* After a triggered update is sent, a timer should be set for a
2597 random interval between 1 and 5 seconds. If other changes that
2598 would trigger updates occur before the timer expires, a single
2599 update is triggered when the timer expires. */
2600 interval = (random() % 5) + 1;
2601
2602 rip->t_triggered_interval = NULL;
2603 thread_add_timer(master, rip_triggered_interval, NULL, interval,
2604 &rip->t_triggered_interval);
2605
2606 return 0;
2607 }
2608
2609 /* Withdraw redistributed route. */
2610 void rip_redistribute_withdraw(int type)
2611 {
2612 struct route_node *rp;
2613 struct rip_info *rinfo = NULL;
2614 struct list *list = NULL;
2615
2616 if (!rip)
2617 return;
2618
2619 for (rp = route_top(rip->table); rp; rp = route_next(rp))
2620 if ((list = rp->info) != NULL) {
2621 rinfo = listgetdata(listhead(list));
2622 if (rinfo->type == type
2623 && rinfo->sub_type != RIP_ROUTE_INTERFACE) {
2624 /* Perform poisoned reverse. */
2625 rinfo->metric = RIP_METRIC_INFINITY;
2626 RIP_TIMER_ON(rinfo->t_garbage_collect,
2627 rip_garbage_collect,
2628 rip->garbage_time);
2629 RIP_TIMER_OFF(rinfo->t_timeout);
2630 rinfo->flags |= RIP_RTF_CHANGED;
2631
2632 if (IS_RIP_DEBUG_EVENT) {
2633 struct prefix_ipv4 *p =
2634 (struct prefix_ipv4 *)&rp->p;
2635
2636 zlog_debug(
2637 "Poisone %s/%d on the interface %s with an infinity metric [withdraw]",
2638 inet_ntoa(p->prefix),
2639 p->prefixlen,
2640 ifindex2ifname(
2641 rinfo->nh.ifindex,
2642 VRF_DEFAULT));
2643 }
2644
2645 rip_event(RIP_TRIGGERED_UPDATE, 0);
2646 }
2647 }
2648 }
2649
2650 /* Create new RIP instance and set it to global variable. */
2651 static int rip_create(void)
2652 {
2653 rip = XCALLOC(MTYPE_RIP, sizeof(struct rip));
2654
2655 /* Set initial value. */
2656 rip->version_send = RI_RIP_VERSION_2;
2657 rip->version_recv = RI_RIP_VERSION_1_AND_2;
2658 rip->update_time = RIP_UPDATE_TIMER_DEFAULT;
2659 rip->timeout_time = RIP_TIMEOUT_TIMER_DEFAULT;
2660 rip->garbage_time = RIP_GARBAGE_TIMER_DEFAULT;
2661 rip->default_metric = RIP_DEFAULT_METRIC_DEFAULT;
2662
2663 /* Initialize RIP routig table. */
2664 rip->table = route_table_init();
2665 rip->route = route_table_init();
2666 rip->neighbor = route_table_init();
2667
2668 /* Make output stream. */
2669 rip->obuf = stream_new(1500);
2670
2671 /* Make socket. */
2672 rip->sock = rip_create_socket();
2673 if (rip->sock < 0)
2674 return rip->sock;
2675
2676 /* Create read and timer thread. */
2677 rip_event(RIP_READ, rip->sock);
2678 rip_event(RIP_UPDATE_EVENT, 1);
2679
2680 QOBJ_REG(rip, rip);
2681
2682 return 0;
2683 }
2684
2685 /* Sned RIP request to the destination. */
2686 int rip_request_send(struct sockaddr_in *to, struct interface *ifp,
2687 u_char version, struct connected *connected)
2688 {
2689 struct rte *rte;
2690 struct rip_packet rip_packet;
2691 struct listnode *node, *nnode;
2692
2693 memset(&rip_packet, 0, sizeof(rip_packet));
2694
2695 rip_packet.command = RIP_REQUEST;
2696 rip_packet.version = version;
2697 rte = rip_packet.rte;
2698 rte->metric = htonl(RIP_METRIC_INFINITY);
2699
2700 if (connected) {
2701 /*
2702 * connected is only sent for ripv1 case, or when
2703 * interface does not support multicast. Caller loops
2704 * over each connected address for this case.
2705 */
2706 if (rip_send_packet((u_char *)&rip_packet, sizeof(rip_packet),
2707 to, connected)
2708 != sizeof(rip_packet))
2709 return -1;
2710 else
2711 return sizeof(rip_packet);
2712 }
2713
2714 /* send request on each connected network */
2715 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
2716 struct prefix_ipv4 *p;
2717
2718 p = (struct prefix_ipv4 *)connected->address;
2719
2720 if (p->family != AF_INET)
2721 continue;
2722
2723 if (rip_send_packet((u_char *)&rip_packet, sizeof(rip_packet),
2724 to, connected)
2725 != sizeof(rip_packet))
2726 return -1;
2727 }
2728 return sizeof(rip_packet);
2729 }
2730
2731 static int rip_update_jitter(unsigned long time)
2732 {
2733 #define JITTER_BOUND 4
2734 /* We want to get the jitter to +/- 1/JITTER_BOUND the interval.
2735 Given that, we cannot let time be less than JITTER_BOUND seconds.
2736 The RIPv2 RFC says jitter should be small compared to
2737 update_time. We consider 1/JITTER_BOUND to be small.
2738 */
2739
2740 int jitter_input = time;
2741 int jitter;
2742
2743 if (jitter_input < JITTER_BOUND)
2744 jitter_input = JITTER_BOUND;
2745
2746 jitter = (((random() % ((jitter_input * 2) + 1)) - jitter_input));
2747
2748 return jitter / JITTER_BOUND;
2749 }
2750
2751 void rip_event(enum rip_event event, int sock)
2752 {
2753 int jitter = 0;
2754
2755 switch (event) {
2756 case RIP_READ:
2757 rip->t_read = NULL;
2758 thread_add_read(master, rip_read, NULL, sock, &rip->t_read);
2759 break;
2760 case RIP_UPDATE_EVENT:
2761 RIP_TIMER_OFF(rip->t_update);
2762 jitter = rip_update_jitter(rip->update_time);
2763 thread_add_timer(master, rip_update, NULL,
2764 sock ? 2 : rip->update_time + jitter,
2765 &rip->t_update);
2766 break;
2767 case RIP_TRIGGERED_UPDATE:
2768 if (rip->t_triggered_interval)
2769 rip->trigger = 1;
2770 else
2771 thread_add_event(master, rip_triggered_update, NULL, 0,
2772 &rip->t_triggered_update);
2773 break;
2774 default:
2775 break;
2776 }
2777 }
2778
2779 DEFUN_NOSH (router_rip,
2780 router_rip_cmd,
2781 "router rip",
2782 "Enable a routing process\n"
2783 "Routing Information Protocol (RIP)\n")
2784 {
2785 int ret;
2786
2787 /* If rip is not enabled before. */
2788 if (!rip) {
2789 ret = rip_create();
2790 if (ret < 0) {
2791 zlog_info("Can't create RIP");
2792 return CMD_WARNING_CONFIG_FAILED;
2793 }
2794 }
2795 VTY_PUSH_CONTEXT(RIP_NODE, rip);
2796
2797 return CMD_SUCCESS;
2798 }
2799
2800 DEFUN (no_router_rip,
2801 no_router_rip_cmd,
2802 "no router rip",
2803 NO_STR
2804 "Enable a routing process\n"
2805 "Routing Information Protocol (RIP)\n")
2806 {
2807 if (rip)
2808 rip_clean();
2809 return CMD_SUCCESS;
2810 }
2811
2812 DEFUN (rip_version,
2813 rip_version_cmd,
2814 "version (1-2)",
2815 "Set routing protocol version\n"
2816 "version\n")
2817 {
2818 int idx_number = 1;
2819 int version;
2820
2821 version = atoi(argv[idx_number]->arg);
2822 if (version != RIPv1 && version != RIPv2) {
2823 vty_out(vty, "invalid rip version %d\n", version);
2824 return CMD_WARNING_CONFIG_FAILED;
2825 }
2826 rip->version_send = version;
2827 rip->version_recv = version;
2828
2829 return CMD_SUCCESS;
2830 }
2831
2832 DEFUN (no_rip_version,
2833 no_rip_version_cmd,
2834 "no version [(1-2)]",
2835 NO_STR
2836 "Set routing protocol version\n"
2837 "Version\n")
2838 {
2839 /* Set RIP version to the default. */
2840 rip->version_send = RI_RIP_VERSION_2;
2841 rip->version_recv = RI_RIP_VERSION_1_AND_2;
2842
2843 return CMD_SUCCESS;
2844 }
2845
2846
2847 DEFUN (rip_route,
2848 rip_route_cmd,
2849 "route A.B.C.D/M",
2850 "RIP static route configuration\n"
2851 "IP prefix <network>/<length>\n")
2852 {
2853 int idx_ipv4_prefixlen = 1;
2854 int ret;
2855 struct nexthop nh;
2856 struct prefix_ipv4 p;
2857 struct route_node *node;
2858
2859 memset(&nh, 0, sizeof(nh));
2860 nh.type = NEXTHOP_TYPE_IPV4;
2861
2862 ret = str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
2863 if (ret < 0) {
2864 vty_out(vty, "Malformed address\n");
2865 return CMD_WARNING_CONFIG_FAILED;
2866 }
2867 apply_mask_ipv4(&p);
2868
2869 /* For router rip configuration. */
2870 node = route_node_get(rip->route, (struct prefix *)&p);
2871
2872 if (node->info) {
2873 vty_out(vty, "There is already same static route.\n");
2874 route_unlock_node(node);
2875 return CMD_WARNING;
2876 }
2877
2878 node->info = (void *)1;
2879
2880 rip_redistribute_add(ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, &nh, 0, 0,
2881 0);
2882
2883 return CMD_SUCCESS;
2884 }
2885
2886 DEFUN (no_rip_route,
2887 no_rip_route_cmd,
2888 "no route A.B.C.D/M",
2889 NO_STR
2890 "RIP static route configuration\n"
2891 "IP prefix <network>/<length>\n")
2892 {
2893 int idx_ipv4_prefixlen = 2;
2894 int ret;
2895 struct prefix_ipv4 p;
2896 struct route_node *node;
2897
2898 ret = str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
2899 if (ret < 0) {
2900 vty_out(vty, "Malformed address\n");
2901 return CMD_WARNING_CONFIG_FAILED;
2902 }
2903 apply_mask_ipv4(&p);
2904
2905 /* For router rip configuration. */
2906 node = route_node_lookup(rip->route, (struct prefix *)&p);
2907 if (!node) {
2908 vty_out(vty, "Can't find route %s.\n",
2909 argv[idx_ipv4_prefixlen]->arg);
2910 return CMD_WARNING_CONFIG_FAILED;
2911 }
2912
2913 rip_redistribute_delete(ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, 0);
2914 route_unlock_node(node);
2915
2916 node->info = NULL;
2917 route_unlock_node(node);
2918
2919 return CMD_SUCCESS;
2920 }
2921
2922 #if 0
2923 static void
2924 rip_update_default_metric (void)
2925 {
2926 struct route_node *np;
2927 struct rip_info *rinfo = NULL;
2928 struct list *list = NULL;
2929 struct listnode *listnode = NULL;
2930
2931 for (np = route_top (rip->table); np; np = route_next (np))
2932 if ((list = np->info) != NULL)
2933 for (ALL_LIST_ELEMENTS_RO (list, listnode, rinfo))
2934 if (rinfo->type != ZEBRA_ROUTE_RIP && rinfo->type != ZEBRA_ROUTE_CONNECT)
2935 rinfo->metric = rip->default_metric;
2936 }
2937 #endif
2938
2939 DEFUN (rip_default_metric,
2940 rip_default_metric_cmd,
2941 "default-metric (1-16)",
2942 "Set a metric of redistribute routes\n"
2943 "Default metric\n")
2944 {
2945 int idx_number = 1;
2946 if (rip) {
2947 rip->default_metric = atoi(argv[idx_number]->arg);
2948 /* rip_update_default_metric (); */
2949 }
2950 return CMD_SUCCESS;
2951 }
2952
2953 DEFUN (no_rip_default_metric,
2954 no_rip_default_metric_cmd,
2955 "no default-metric [(1-16)]",
2956 NO_STR
2957 "Set a metric of redistribute routes\n"
2958 "Default metric\n")
2959 {
2960 if (rip) {
2961 rip->default_metric = RIP_DEFAULT_METRIC_DEFAULT;
2962 /* rip_update_default_metric (); */
2963 }
2964 return CMD_SUCCESS;
2965 }
2966
2967
2968 DEFUN (rip_timers,
2969 rip_timers_cmd,
2970 "timers basic (5-2147483647) (5-2147483647) (5-2147483647)",
2971 "Adjust routing timers\n"
2972 "Basic routing protocol update timers\n"
2973 "Routing table update timer value in second. Default is 30.\n"
2974 "Routing information timeout timer. Default is 180.\n"
2975 "Garbage collection timer. Default is 120.\n")
2976 {
2977 int idx_number = 2;
2978 int idx_number_2 = 3;
2979 int idx_number_3 = 4;
2980 unsigned long update;
2981 unsigned long timeout;
2982 unsigned long garbage;
2983 char *endptr = NULL;
2984 unsigned long RIP_TIMER_MAX = 2147483647;
2985 unsigned long RIP_TIMER_MIN = 5;
2986
2987 update = strtoul(argv[idx_number]->arg, &endptr, 10);
2988 if (update > RIP_TIMER_MAX || update < RIP_TIMER_MIN
2989 || *endptr != '\0') {
2990 vty_out(vty, "update timer value error\n");
2991 return CMD_WARNING_CONFIG_FAILED;
2992 }
2993
2994 timeout = strtoul(argv[idx_number_2]->arg, &endptr, 10);
2995 if (timeout > RIP_TIMER_MAX || timeout < RIP_TIMER_MIN
2996 || *endptr != '\0') {
2997 vty_out(vty, "timeout timer value error\n");
2998 return CMD_WARNING_CONFIG_FAILED;
2999 }
3000
3001 garbage = strtoul(argv[idx_number_3]->arg, &endptr, 10);
3002 if (garbage > RIP_TIMER_MAX || garbage < RIP_TIMER_MIN
3003 || *endptr != '\0') {
3004 vty_out(vty, "garbage timer value error\n");
3005 return CMD_WARNING_CONFIG_FAILED;
3006 }
3007
3008 /* Set each timer value. */
3009 rip->update_time = update;
3010 rip->timeout_time = timeout;
3011 rip->garbage_time = garbage;
3012
3013 /* Reset update timer thread. */
3014 rip_event(RIP_UPDATE_EVENT, 0);
3015
3016 return CMD_SUCCESS;
3017 }
3018
3019 DEFUN (no_rip_timers,
3020 no_rip_timers_cmd,
3021 "no timers basic [(0-65535) (0-65535) (0-65535)]",
3022 NO_STR
3023 "Adjust routing timers\n"
3024 "Basic routing protocol update timers\n"
3025 "Routing table update timer value in second. Default is 30.\n"
3026 "Routing information timeout timer. Default is 180.\n"
3027 "Garbage collection timer. Default is 120.\n")
3028 {
3029 /* Set each timer value to the default. */
3030 rip->update_time = RIP_UPDATE_TIMER_DEFAULT;
3031 rip->timeout_time = RIP_TIMEOUT_TIMER_DEFAULT;
3032 rip->garbage_time = RIP_GARBAGE_TIMER_DEFAULT;
3033
3034 /* Reset update timer thread. */
3035 rip_event(RIP_UPDATE_EVENT, 0);
3036
3037 return CMD_SUCCESS;
3038 }
3039
3040
3041 struct route_table *rip_distance_table;
3042
3043 struct rip_distance {
3044 /* Distance value for the IP source prefix. */
3045 u_char distance;
3046
3047 /* Name of the access-list to be matched. */
3048 char *access_list;
3049 };
3050
3051 static struct rip_distance *rip_distance_new(void)
3052 {
3053 return XCALLOC(MTYPE_RIP_DISTANCE, sizeof(struct rip_distance));
3054 }
3055
3056 static void rip_distance_free(struct rip_distance *rdistance)
3057 {
3058 XFREE(MTYPE_RIP_DISTANCE, rdistance);
3059 }
3060
3061 static int rip_distance_set(struct vty *vty, const char *distance_str,
3062 const char *ip_str, const char *access_list_str)
3063 {
3064 int ret;
3065 struct prefix_ipv4 p;
3066 u_char distance;
3067 struct route_node *rn;
3068 struct rip_distance *rdistance;
3069
3070 ret = str2prefix_ipv4(ip_str, &p);
3071 if (ret == 0) {
3072 vty_out(vty, "Malformed prefix\n");
3073 return CMD_WARNING_CONFIG_FAILED;
3074 }
3075
3076 distance = atoi(distance_str);
3077
3078 /* Get RIP distance node. */
3079 rn = route_node_get(rip_distance_table, (struct prefix *)&p);
3080 if (rn->info) {
3081 rdistance = rn->info;
3082 route_unlock_node(rn);
3083 } else {
3084 rdistance = rip_distance_new();
3085 rn->info = rdistance;
3086 }
3087
3088 /* Set distance value. */
3089 rdistance->distance = distance;
3090
3091 /* Reset access-list configuration. */
3092 if (rdistance->access_list) {
3093 free(rdistance->access_list);
3094 rdistance->access_list = NULL;
3095 }
3096 if (access_list_str)
3097 rdistance->access_list = strdup(access_list_str);
3098
3099 return CMD_SUCCESS;
3100 }
3101
3102 static int rip_distance_unset(struct vty *vty, const char *distance_str,
3103 const char *ip_str, const char *access_list_str)
3104 {
3105 int ret;
3106 struct prefix_ipv4 p;
3107 struct route_node *rn;
3108 struct rip_distance *rdistance;
3109
3110 ret = str2prefix_ipv4(ip_str, &p);
3111 if (ret == 0) {
3112 vty_out(vty, "Malformed prefix\n");
3113 return CMD_WARNING_CONFIG_FAILED;
3114 }
3115
3116 rn = route_node_lookup(rip_distance_table, (struct prefix *)&p);
3117 if (!rn) {
3118 vty_out(vty, "Can't find specified prefix\n");
3119 return CMD_WARNING_CONFIG_FAILED;
3120 }
3121
3122 rdistance = rn->info;
3123
3124 if (rdistance->access_list)
3125 free(rdistance->access_list);
3126 rip_distance_free(rdistance);
3127
3128 rn->info = NULL;
3129 route_unlock_node(rn);
3130 route_unlock_node(rn);
3131
3132 return CMD_SUCCESS;
3133 }
3134
3135 static void rip_distance_reset(void)
3136 {
3137 struct route_node *rn;
3138 struct rip_distance *rdistance;
3139
3140 for (rn = route_top(rip_distance_table); rn; rn = route_next(rn))
3141 if ((rdistance = rn->info) != NULL) {
3142 if (rdistance->access_list)
3143 free(rdistance->access_list);
3144 rip_distance_free(rdistance);
3145 rn->info = NULL;
3146 route_unlock_node(rn);
3147 }
3148 }
3149
3150 /* Apply RIP information to distance method. */
3151 u_char rip_distance_apply(struct rip_info *rinfo)
3152 {
3153 struct route_node *rn;
3154 struct prefix_ipv4 p;
3155 struct rip_distance *rdistance;
3156 struct access_list *alist;
3157
3158 if (!rip)
3159 return 0;
3160
3161 memset(&p, 0, sizeof(struct prefix_ipv4));
3162 p.family = AF_INET;
3163 p.prefix = rinfo->from;
3164 p.prefixlen = IPV4_MAX_BITLEN;
3165
3166 /* Check source address. */
3167 rn = route_node_match(rip_distance_table, (struct prefix *)&p);
3168 if (rn) {
3169 rdistance = rn->info;
3170 route_unlock_node(rn);
3171
3172 if (rdistance->access_list) {
3173 alist = access_list_lookup(AFI_IP,
3174 rdistance->access_list);
3175 if (alist == NULL)
3176 return 0;
3177 if (access_list_apply(alist, &rinfo->rp->p)
3178 == FILTER_DENY)
3179 return 0;
3180
3181 return rdistance->distance;
3182 } else
3183 return rdistance->distance;
3184 }
3185
3186 if (rip->distance)
3187 return rip->distance;
3188
3189 return 0;
3190 }
3191
3192 static void rip_distance_show(struct vty *vty)
3193 {
3194 struct route_node *rn;
3195 struct rip_distance *rdistance;
3196 int header = 1;
3197 char buf[BUFSIZ];
3198
3199 vty_out(vty, " Distance: (default is %d)\n",
3200 rip->distance ? rip->distance : ZEBRA_RIP_DISTANCE_DEFAULT);
3201
3202 for (rn = route_top(rip_distance_table); rn; rn = route_next(rn))
3203 if ((rdistance = rn->info) != NULL) {
3204 if (header) {
3205 vty_out(vty,
3206 " Address Distance List\n");
3207 header = 0;
3208 }
3209 sprintf(buf, "%s/%d", inet_ntoa(rn->p.u.prefix4),
3210 rn->p.prefixlen);
3211 vty_out(vty, " %-20s %4d %s\n", buf,
3212 rdistance->distance,
3213 rdistance->access_list ? rdistance->access_list
3214 : "");
3215 }
3216 }
3217
3218 DEFUN (rip_distance,
3219 rip_distance_cmd,
3220 "distance (1-255)",
3221 "Administrative distance\n"
3222 "Distance value\n")
3223 {
3224 int idx_number = 1;
3225 rip->distance = atoi(argv[idx_number]->arg);
3226 return CMD_SUCCESS;
3227 }
3228
3229 DEFUN (no_rip_distance,
3230 no_rip_distance_cmd,
3231 "no distance (1-255)",
3232 NO_STR
3233 "Administrative distance\n"
3234 "Distance value\n")
3235 {
3236 rip->distance = 0;
3237 return CMD_SUCCESS;
3238 }
3239
3240 DEFUN (rip_distance_source,
3241 rip_distance_source_cmd,
3242 "distance (1-255) A.B.C.D/M",
3243 "Administrative distance\n"
3244 "Distance value\n"
3245 "IP source prefix\n")
3246 {
3247 int idx_number = 1;
3248 int idx_ipv4_prefixlen = 2;
3249 rip_distance_set(vty, argv[idx_number]->arg,
3250 argv[idx_ipv4_prefixlen]->arg, NULL);
3251 return CMD_SUCCESS;
3252 }
3253
3254 DEFUN (no_rip_distance_source,
3255 no_rip_distance_source_cmd,
3256 "no distance (1-255) A.B.C.D/M",
3257 NO_STR
3258 "Administrative distance\n"
3259 "Distance value\n"
3260 "IP source prefix\n")
3261 {
3262 int idx_number = 2;
3263 int idx_ipv4_prefixlen = 3;
3264 rip_distance_unset(vty, argv[idx_number]->arg,
3265 argv[idx_ipv4_prefixlen]->arg, NULL);
3266 return CMD_SUCCESS;
3267 }
3268
3269 DEFUN (rip_distance_source_access_list,
3270 rip_distance_source_access_list_cmd,
3271 "distance (1-255) A.B.C.D/M WORD",
3272 "Administrative distance\n"
3273 "Distance value\n"
3274 "IP source prefix\n"
3275 "Access list name\n")
3276 {
3277 int idx_number = 1;
3278 int idx_ipv4_prefixlen = 2;
3279 int idx_word = 3;
3280 rip_distance_set(vty, argv[idx_number]->arg,
3281 argv[idx_ipv4_prefixlen]->arg, argv[idx_word]->arg);
3282 return CMD_SUCCESS;
3283 }
3284
3285 DEFUN (no_rip_distance_source_access_list,
3286 no_rip_distance_source_access_list_cmd,
3287 "no distance (1-255) A.B.C.D/M WORD",
3288 NO_STR
3289 "Administrative distance\n"
3290 "Distance value\n"
3291 "IP source prefix\n"
3292 "Access list name\n")
3293 {
3294 int idx_number = 2;
3295 int idx_ipv4_prefixlen = 3;
3296 int idx_word = 4;
3297 rip_distance_unset(vty, argv[idx_number]->arg,
3298 argv[idx_ipv4_prefixlen]->arg, argv[idx_word]->arg);
3299 return CMD_SUCCESS;
3300 }
3301
3302 /* Update ECMP routes to zebra when ECMP is disabled. */
3303 static void rip_ecmp_disable(void)
3304 {
3305 struct route_node *rp;
3306 struct rip_info *rinfo, *tmp_rinfo;
3307 struct list *list;
3308 struct listnode *node, *nextnode;
3309
3310 if (!rip)
3311 return;
3312
3313 for (rp = route_top(rip->table); rp; rp = route_next(rp))
3314 if ((list = rp->info) != NULL && listcount(list) > 1) {
3315 rinfo = listgetdata(listhead(list));
3316 if (!rip_route_rte(rinfo))
3317 continue;
3318
3319 /* Drop all other entries, except the first one. */
3320 for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
3321 if (tmp_rinfo != rinfo) {
3322 RIP_TIMER_OFF(tmp_rinfo->t_timeout);
3323 RIP_TIMER_OFF(
3324 tmp_rinfo->t_garbage_collect);
3325 list_delete_node(list, node);
3326 rip_info_free(tmp_rinfo);
3327 }
3328
3329 /* Update zebra. */
3330 rip_zebra_ipv4_add(rp);
3331
3332 /* Set the route change flag. */
3333 SET_FLAG(rinfo->flags, RIP_RTF_CHANGED);
3334
3335 /* Signal the output process to trigger an update. */
3336 rip_event(RIP_TRIGGERED_UPDATE, 0);
3337 }
3338 }
3339
3340 DEFUN (rip_allow_ecmp,
3341 rip_allow_ecmp_cmd,
3342 "allow-ecmp",
3343 "Allow Equal Cost MultiPath\n")
3344 {
3345 if (rip->ecmp) {
3346 vty_out(vty, "ECMP is already enabled.\n");
3347 return CMD_WARNING;
3348 }
3349
3350 rip->ecmp = 1;
3351 zlog_info("ECMP is enabled.");
3352 return CMD_SUCCESS;
3353 }
3354
3355 DEFUN (no_rip_allow_ecmp,
3356 no_rip_allow_ecmp_cmd,
3357 "no allow-ecmp",
3358 NO_STR
3359 "Allow Equal Cost MultiPath\n")
3360 {
3361 if (!rip->ecmp) {
3362 vty_out(vty, "ECMP is already disabled.\n");
3363 return CMD_WARNING;
3364 }
3365
3366 rip->ecmp = 0;
3367 zlog_info("ECMP is disabled.");
3368 rip_ecmp_disable();
3369 return CMD_SUCCESS;
3370 }
3371
3372 /* Print out routes update time. */
3373 static void rip_vty_out_uptime(struct vty *vty, struct rip_info *rinfo)
3374 {
3375 time_t clock;
3376 struct tm *tm;
3377 #define TIME_BUF 25
3378 char timebuf[TIME_BUF];
3379 struct thread *thread;
3380
3381 if ((thread = rinfo->t_timeout) != NULL) {
3382 clock = thread_timer_remain_second(thread);
3383 tm = gmtime(&clock);
3384 strftime(timebuf, TIME_BUF, "%M:%S", tm);
3385 vty_out(vty, "%5s", timebuf);
3386 } else if ((thread = rinfo->t_garbage_collect) != NULL) {
3387 clock = thread_timer_remain_second(thread);
3388 tm = gmtime(&clock);
3389 strftime(timebuf, TIME_BUF, "%M:%S", tm);
3390 vty_out(vty, "%5s", timebuf);
3391 }
3392 }
3393
3394 static const char *rip_route_type_print(int sub_type)
3395 {
3396 switch (sub_type) {
3397 case RIP_ROUTE_RTE:
3398 return "n";
3399 case RIP_ROUTE_STATIC:
3400 return "s";
3401 case RIP_ROUTE_DEFAULT:
3402 return "d";
3403 case RIP_ROUTE_REDISTRIBUTE:
3404 return "r";
3405 case RIP_ROUTE_INTERFACE:
3406 return "i";
3407 default:
3408 return "?";
3409 }
3410 }
3411
3412 DEFUN (show_ip_rip,
3413 show_ip_rip_cmd,
3414 "show ip rip",
3415 SHOW_STR
3416 IP_STR
3417 "Show RIP routes\n")
3418 {
3419 struct route_node *np;
3420 struct rip_info *rinfo = NULL;
3421 struct list *list = NULL;
3422 struct listnode *listnode = NULL;
3423
3424 if (!rip)
3425 return CMD_SUCCESS;
3426
3427 vty_out(vty,
3428 "Codes: R - RIP, C - connected, S - Static, O - OSPF, B - BGP\n"
3429 "Sub-codes:\n"
3430 " (n) - normal, (s) - static, (d) - default, (r) - redistribute,\n"
3431 " (i) - interface\n\n"
3432 " Network Next Hop Metric From Tag Time\n");
3433
3434 for (np = route_top(rip->table); np; np = route_next(np))
3435 if ((list = np->info) != NULL)
3436 for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
3437 int len;
3438
3439 len = vty_out(
3440 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),
3445 np->p.prefixlen);
3446
3447 len = 24 - len;
3448
3449 if (len > 0)
3450 vty_out(vty, "%*s", len, " ");
3451
3452 switch (rinfo->nh.type) {
3453 case NEXTHOP_TYPE_IPV4:
3454 case NEXTHOP_TYPE_IPV4_IFINDEX:
3455 vty_out(vty, "%-20s %2d ",
3456 inet_ntoa(rinfo->nh.gate.ipv4),
3457 rinfo->metric);
3458 break;
3459 case NEXTHOP_TYPE_IFINDEX:
3460 vty_out(vty,
3461 "0.0.0.0 %2d ",
3462 rinfo->metric);
3463 break;
3464 case NEXTHOP_TYPE_BLACKHOLE:
3465 vty_out(vty,
3466 "blackhole %2d ",
3467 rinfo->metric);
3468 break;
3469 case NEXTHOP_TYPE_IPV6:
3470 case NEXTHOP_TYPE_IPV6_IFINDEX:
3471 vty_out(vty,
3472 "V6 Address Hidden %2d ",
3473 rinfo->metric);
3474 break;
3475 }
3476
3477 /* Route which exist in kernel routing table. */
3478 if ((rinfo->type == ZEBRA_ROUTE_RIP)
3479 && (rinfo->sub_type == RIP_ROUTE_RTE)) {
3480 vty_out(vty, "%-15s ",
3481 inet_ntoa(rinfo->from));
3482 vty_out(vty, "%3" ROUTE_TAG_PRI " ",
3483 (route_tag_t)rinfo->tag);
3484 rip_vty_out_uptime(vty, rinfo);
3485 } else if (rinfo->metric
3486 == RIP_METRIC_INFINITY) {
3487 vty_out(vty, "self ");
3488 vty_out(vty, "%3" ROUTE_TAG_PRI " ",
3489 (route_tag_t)rinfo->tag);
3490 rip_vty_out_uptime(vty, rinfo);
3491 } else {
3492 if (rinfo->external_metric) {
3493 len = vty_out(
3494 vty, "self (%s:%d)",
3495 zebra_route_string(
3496 rinfo->type),
3497 rinfo->external_metric);
3498 len = 16 - len;
3499 if (len > 0)
3500 vty_out(vty, "%*s", len,
3501 " ");
3502 } else
3503 vty_out(vty,
3504 "self ");
3505 vty_out(vty, "%3" ROUTE_TAG_PRI,
3506 (route_tag_t)rinfo->tag);
3507 }
3508
3509 vty_out(vty, "\n");
3510 }
3511 return CMD_SUCCESS;
3512 }
3513
3514 /* Vincent: formerly, it was show_ip_protocols_rip: "show ip protocols" */
3515 DEFUN (show_ip_rip_status,
3516 show_ip_rip_status_cmd,
3517 "show ip rip status",
3518 SHOW_STR
3519 IP_STR
3520 "Show RIP routes\n"
3521 "IP routing protocol process parameters and statistics\n")
3522 {
3523 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
3524 struct interface *ifp;
3525 struct rip_interface *ri;
3526 extern const struct message ri_version_msg[];
3527 const char *send_version;
3528 const char *receive_version;
3529
3530 if (!rip)
3531 return CMD_SUCCESS;
3532
3533 vty_out(vty, "Routing Protocol is \"rip\"\n");
3534 vty_out(vty, " Sending updates every %ld seconds with +/-50%%,",
3535 rip->update_time);
3536 vty_out(vty, " next due in %lu seconds\n",
3537 thread_timer_remain_second(rip->t_update));
3538 vty_out(vty, " Timeout after %ld seconds,", rip->timeout_time);
3539 vty_out(vty, " garbage collect after %ld seconds\n", rip->garbage_time);
3540
3541 /* Filtering status show. */
3542 config_show_distribute(vty);
3543
3544 /* Default metric information. */
3545 vty_out(vty, " Default redistribution metric is %d\n",
3546 rip->default_metric);
3547
3548 /* Redistribute information. */
3549 vty_out(vty, " Redistributing:");
3550 config_write_rip_redistribute(vty, 0);
3551 vty_out(vty, "\n");
3552
3553 vty_out(vty, " Default version control: send version %s,",
3554 lookup_msg(ri_version_msg, rip->version_send, NULL));
3555 if (rip->version_recv == RI_RIP_VERSION_1_AND_2)
3556 vty_out(vty, " receive any version \n");
3557 else
3558 vty_out(vty, " receive version %s \n",
3559 lookup_msg(ri_version_msg, rip->version_recv, NULL));
3560
3561 vty_out(vty, " Interface Send Recv Key-chain\n");
3562
3563 FOR_ALL_INTERFACES (vrf, ifp) {
3564 ri = ifp->info;
3565
3566 if (!ri->running)
3567 continue;
3568
3569 if (ri->enable_network || ri->enable_interface) {
3570 if (ri->ri_send == RI_RIP_UNSPEC)
3571 send_version =
3572 lookup_msg(ri_version_msg,
3573 rip->version_send, NULL);
3574 else
3575 send_version = lookup_msg(ri_version_msg,
3576 ri->ri_send, NULL);
3577
3578 if (ri->ri_receive == RI_RIP_UNSPEC)
3579 receive_version =
3580 lookup_msg(ri_version_msg,
3581 rip->version_recv, NULL);
3582 else
3583 receive_version = lookup_msg(
3584 ri_version_msg, ri->ri_receive, NULL);
3585
3586 vty_out(vty, " %-17s%-3s %-3s %s\n", ifp->name,
3587 send_version, receive_version,
3588 ri->key_chain ? ri->key_chain : "");
3589 }
3590 }
3591
3592 vty_out(vty, " Routing for Networks:\n");
3593 config_write_rip_network(vty, 0);
3594
3595 {
3596 int found_passive = 0;
3597 FOR_ALL_INTERFACES (vrf, ifp) {
3598 ri = ifp->info;
3599
3600 if ((ri->enable_network || ri->enable_interface)
3601 && ri->passive) {
3602 if (!found_passive) {
3603 vty_out(vty,
3604 " Passive Interface(s):\n");
3605 found_passive = 1;
3606 }
3607 vty_out(vty, " %s\n", ifp->name);
3608 }
3609 }
3610 }
3611
3612 vty_out(vty, " Routing Information Sources:\n");
3613 vty_out(vty,
3614 " Gateway BadPackets BadRoutes Distance Last Update\n");
3615 rip_peer_display(vty);
3616
3617 rip_distance_show(vty);
3618
3619 return CMD_SUCCESS;
3620 }
3621
3622 /* RIP configuration write function. */
3623 static int config_write_rip(struct vty *vty)
3624 {
3625 int write = 0;
3626 struct route_node *rn;
3627 struct rip_distance *rdistance;
3628
3629 if (rip) {
3630 /* Router RIP statement. */
3631 vty_out(vty, "router rip\n");
3632 write++;
3633
3634 /* RIP version statement. Default is RIP version 2. */
3635 if (rip->version_send != RI_RIP_VERSION_2
3636 || rip->version_recv != RI_RIP_VERSION_1_AND_2)
3637 vty_out(vty, " version %d\n", rip->version_send);
3638
3639 /* RIP timer configuration. */
3640 if (rip->update_time != RIP_UPDATE_TIMER_DEFAULT
3641 || rip->timeout_time != RIP_TIMEOUT_TIMER_DEFAULT
3642 || rip->garbage_time != RIP_GARBAGE_TIMER_DEFAULT)
3643 vty_out(vty, " timers basic %lu %lu %lu\n",
3644 rip->update_time, rip->timeout_time,
3645 rip->garbage_time);
3646
3647 /* Default information configuration. */
3648 if (rip->default_information) {
3649 if (rip->default_information_route_map)
3650 vty_out(vty,
3651 " default-information originate route-map %s\n",
3652 rip->default_information_route_map);
3653 else
3654 vty_out(vty,
3655 " default-information originate\n");
3656 }
3657
3658 /* Redistribute configuration. */
3659 config_write_rip_redistribute(vty, 1);
3660
3661 /* RIP offset-list configuration. */
3662 config_write_rip_offset_list(vty);
3663
3664 /* RIP enabled network and interface configuration. */
3665 config_write_rip_network(vty, 1);
3666
3667 /* RIP default metric configuration */
3668 if (rip->default_metric != RIP_DEFAULT_METRIC_DEFAULT)
3669 vty_out(vty, " default-metric %d\n",
3670 rip->default_metric);
3671
3672 /* Distribute configuration. */
3673 write += config_write_distribute(vty);
3674
3675 /* Interface routemap configuration */
3676 write += config_write_if_rmap(vty);
3677
3678 /* Distance configuration. */
3679 if (rip->distance)
3680 vty_out(vty, " distance %d\n", rip->distance);
3681
3682 /* RIP source IP prefix distance configuration. */
3683 for (rn = route_top(rip_distance_table); rn;
3684 rn = route_next(rn))
3685 if ((rdistance = rn->info) != NULL)
3686 vty_out(vty, " distance %d %s/%d %s\n",
3687 rdistance->distance,
3688 inet_ntoa(rn->p.u.prefix4),
3689 rn->p.prefixlen,
3690 rdistance->access_list
3691 ? rdistance->access_list
3692 : "");
3693
3694 /* ECMP configuration. */
3695 if (rip->ecmp)
3696 vty_out(vty, " allow-ecmp\n");
3697
3698 /* RIP static route configuration. */
3699 for (rn = route_top(rip->route); rn; rn = route_next(rn))
3700 if (rn->info)
3701 vty_out(vty, " route %s/%d\n",
3702 inet_ntoa(rn->p.u.prefix4),
3703 rn->p.prefixlen);
3704 }
3705 return write;
3706 }
3707
3708 /* RIP node structure. */
3709 static struct cmd_node rip_node = {RIP_NODE, "%s(config-router)# ", 1};
3710
3711 /* Distribute-list update functions. */
3712 static void rip_distribute_update(struct distribute *dist)
3713 {
3714 struct interface *ifp;
3715 struct rip_interface *ri;
3716 struct access_list *alist;
3717 struct prefix_list *plist;
3718
3719 if (!dist->ifname)
3720 return;
3721
3722 ifp = if_lookup_by_name(dist->ifname, VRF_DEFAULT);
3723 if (ifp == NULL)
3724 return;
3725
3726 ri = ifp->info;
3727
3728 if (dist->list[DISTRIBUTE_V4_IN]) {
3729 alist = access_list_lookup(AFI_IP,
3730 dist->list[DISTRIBUTE_V4_IN]);
3731 if (alist)
3732 ri->list[RIP_FILTER_IN] = alist;
3733 else
3734 ri->list[RIP_FILTER_IN] = NULL;
3735 } else
3736 ri->list[RIP_FILTER_IN] = NULL;
3737
3738 if (dist->list[DISTRIBUTE_V4_OUT]) {
3739 alist = access_list_lookup(AFI_IP,
3740 dist->list[DISTRIBUTE_V4_OUT]);
3741 if (alist)
3742 ri->list[RIP_FILTER_OUT] = alist;
3743 else
3744 ri->list[RIP_FILTER_OUT] = NULL;
3745 } else
3746 ri->list[RIP_FILTER_OUT] = NULL;
3747
3748 if (dist->prefix[DISTRIBUTE_V4_IN]) {
3749 plist = prefix_list_lookup(AFI_IP,
3750 dist->prefix[DISTRIBUTE_V4_IN]);
3751 if (plist)
3752 ri->prefix[RIP_FILTER_IN] = plist;
3753 else
3754 ri->prefix[RIP_FILTER_IN] = NULL;
3755 } else
3756 ri->prefix[RIP_FILTER_IN] = NULL;
3757
3758 if (dist->prefix[DISTRIBUTE_V4_OUT]) {
3759 plist = prefix_list_lookup(AFI_IP,
3760 dist->prefix[DISTRIBUTE_V4_OUT]);
3761 if (plist)
3762 ri->prefix[RIP_FILTER_OUT] = plist;
3763 else
3764 ri->prefix[RIP_FILTER_OUT] = NULL;
3765 } else
3766 ri->prefix[RIP_FILTER_OUT] = NULL;
3767 }
3768
3769 void rip_distribute_update_interface(struct interface *ifp)
3770 {
3771 struct distribute *dist;
3772
3773 dist = distribute_lookup(ifp->name);
3774 if (dist)
3775 rip_distribute_update(dist);
3776 }
3777
3778 /* Update all interface's distribute list. */
3779 /* ARGSUSED */
3780 static void rip_distribute_update_all(struct prefix_list *notused)
3781 {
3782 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
3783 struct interface *ifp;
3784
3785 FOR_ALL_INTERFACES (vrf, ifp)
3786 rip_distribute_update_interface(ifp);
3787 }
3788 /* ARGSUSED */
3789 static void rip_distribute_update_all_wrapper(struct access_list *notused)
3790 {
3791 rip_distribute_update_all(NULL);
3792 }
3793
3794 /* Delete all added rip route. */
3795 void rip_clean(void)
3796 {
3797 int i;
3798 struct route_node *rp;
3799 struct rip_info *rinfo = NULL;
3800 struct list *list = NULL;
3801 struct listnode *listnode = NULL;
3802
3803 if (rip) {
3804 QOBJ_UNREG(rip);
3805
3806 /* Clear RIP routes */
3807 for (rp = route_top(rip->table); rp; rp = route_next(rp))
3808 if ((list = rp->info) != NULL) {
3809 rinfo = listgetdata(listhead(list));
3810 if (rip_route_rte(rinfo))
3811 rip_zebra_ipv4_delete(rp);
3812
3813 for (ALL_LIST_ELEMENTS_RO(list, listnode,
3814 rinfo)) {
3815 RIP_TIMER_OFF(rinfo->t_timeout);
3816 RIP_TIMER_OFF(rinfo->t_garbage_collect);
3817 rip_info_free(rinfo);
3818 }
3819 list_delete_and_null(&list);
3820 rp->info = NULL;
3821 route_unlock_node(rp);
3822 }
3823
3824 /* Cancel RIP related timers. */
3825 RIP_TIMER_OFF(rip->t_update);
3826 RIP_TIMER_OFF(rip->t_triggered_update);
3827 RIP_TIMER_OFF(rip->t_triggered_interval);
3828
3829 /* Cancel read thread. */
3830 THREAD_READ_OFF(rip->t_read);
3831
3832 /* Close RIP socket. */
3833 if (rip->sock >= 0) {
3834 close(rip->sock);
3835 rip->sock = -1;
3836 }
3837
3838 stream_free(rip->obuf);
3839 /* Static RIP route configuration. */
3840 for (rp = route_top(rip->route); rp; rp = route_next(rp))
3841 if (rp->info) {
3842 rp->info = NULL;
3843 route_unlock_node(rp);
3844 }
3845
3846 /* RIP neighbor configuration. */
3847 for (rp = route_top(rip->neighbor); rp; rp = route_next(rp))
3848 if (rp->info) {
3849 rp->info = NULL;
3850 route_unlock_node(rp);
3851 }
3852
3853 /* Redistribute related clear. */
3854 if (rip->default_information_route_map)
3855 free(rip->default_information_route_map);
3856
3857 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
3858 if (rip->route_map[i].name)
3859 free(rip->route_map[i].name);
3860
3861 XFREE(MTYPE_ROUTE_TABLE, rip->table);
3862 XFREE(MTYPE_ROUTE_TABLE, rip->route);
3863 XFREE(MTYPE_ROUTE_TABLE, rip->neighbor);
3864
3865 XFREE(MTYPE_RIP, rip);
3866 rip = NULL;
3867 }
3868
3869 rip_clean_network();
3870 rip_passive_nondefault_clean();
3871 rip_offset_clean();
3872 rip_interfaces_clean();
3873 rip_distance_reset();
3874 rip_redistribute_clean();
3875 }
3876
3877 /* Reset all values to the default settings. */
3878 void rip_reset(void)
3879 {
3880 /* Reset global counters. */
3881 rip_global_route_changes = 0;
3882 rip_global_queries = 0;
3883
3884 /* Call ripd related reset functions. */
3885 rip_debug_reset();
3886 rip_route_map_reset();
3887
3888 /* Call library reset functions. */
3889 vty_reset();
3890 access_list_reset();
3891 prefix_list_reset();
3892
3893 distribute_list_reset();
3894
3895 rip_interfaces_reset();
3896 rip_distance_reset();
3897
3898 rip_zclient_reset();
3899 }
3900
3901 static void rip_if_rmap_update(struct if_rmap *if_rmap)
3902 {
3903 struct interface *ifp;
3904 struct rip_interface *ri;
3905 struct route_map *rmap;
3906
3907 ifp = if_lookup_by_name(if_rmap->ifname, VRF_DEFAULT);
3908 if (ifp == NULL)
3909 return;
3910
3911 ri = ifp->info;
3912
3913 if (if_rmap->routemap[IF_RMAP_IN]) {
3914 rmap = route_map_lookup_by_name(if_rmap->routemap[IF_RMAP_IN]);
3915 if (rmap)
3916 ri->routemap[IF_RMAP_IN] = rmap;
3917 else
3918 ri->routemap[IF_RMAP_IN] = NULL;
3919 } else
3920 ri->routemap[RIP_FILTER_IN] = NULL;
3921
3922 if (if_rmap->routemap[IF_RMAP_OUT]) {
3923 rmap = route_map_lookup_by_name(if_rmap->routemap[IF_RMAP_OUT]);
3924 if (rmap)
3925 ri->routemap[IF_RMAP_OUT] = rmap;
3926 else
3927 ri->routemap[IF_RMAP_OUT] = NULL;
3928 } else
3929 ri->routemap[RIP_FILTER_OUT] = NULL;
3930 }
3931
3932 void rip_if_rmap_update_interface(struct interface *ifp)
3933 {
3934 struct if_rmap *if_rmap;
3935
3936 if_rmap = if_rmap_lookup(ifp->name);
3937 if (if_rmap)
3938 rip_if_rmap_update(if_rmap);
3939 }
3940
3941 static void rip_routemap_update_redistribute(void)
3942 {
3943 int i;
3944
3945 if (rip) {
3946 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
3947 if (rip->route_map[i].name)
3948 rip->route_map[i].map =
3949 route_map_lookup_by_name(
3950 rip->route_map[i].name);
3951 }
3952 }
3953 }
3954
3955 /* ARGSUSED */
3956 static void rip_routemap_update(const char *notused)
3957 {
3958 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
3959 struct interface *ifp;
3960
3961 FOR_ALL_INTERFACES (vrf, ifp)
3962 rip_if_rmap_update_interface(ifp);
3963
3964 rip_routemap_update_redistribute();
3965 }
3966
3967 /* Allocate new rip structure and set default value. */
3968 void rip_init(void)
3969 {
3970 /* Install top nodes. */
3971 install_node(&rip_node, config_write_rip);
3972
3973 /* Install rip commands. */
3974 install_element(VIEW_NODE, &show_ip_rip_cmd);
3975 install_element(VIEW_NODE, &show_ip_rip_status_cmd);
3976 install_element(CONFIG_NODE, &router_rip_cmd);
3977 install_element(CONFIG_NODE, &no_router_rip_cmd);
3978
3979 install_default(RIP_NODE);
3980 install_element(RIP_NODE, &rip_version_cmd);
3981 install_element(RIP_NODE, &no_rip_version_cmd);
3982 install_element(RIP_NODE, &rip_default_metric_cmd);
3983 install_element(RIP_NODE, &no_rip_default_metric_cmd);
3984 install_element(RIP_NODE, &rip_timers_cmd);
3985 install_element(RIP_NODE, &no_rip_timers_cmd);
3986 install_element(RIP_NODE, &rip_route_cmd);
3987 install_element(RIP_NODE, &no_rip_route_cmd);
3988 install_element(RIP_NODE, &rip_distance_cmd);
3989 install_element(RIP_NODE, &no_rip_distance_cmd);
3990 install_element(RIP_NODE, &rip_distance_source_cmd);
3991 install_element(RIP_NODE, &no_rip_distance_source_cmd);
3992 install_element(RIP_NODE, &rip_distance_source_access_list_cmd);
3993 install_element(RIP_NODE, &no_rip_distance_source_access_list_cmd);
3994 install_element(RIP_NODE, &rip_allow_ecmp_cmd);
3995 install_element(RIP_NODE, &no_rip_allow_ecmp_cmd);
3996
3997 /* Debug related init. */
3998 rip_debug_init();
3999
4000 /* Access list install. */
4001 access_list_init();
4002 access_list_add_hook(rip_distribute_update_all_wrapper);
4003 access_list_delete_hook(rip_distribute_update_all_wrapper);
4004
4005 /* Prefix list initialize.*/
4006 prefix_list_init();
4007 prefix_list_add_hook(rip_distribute_update_all);
4008 prefix_list_delete_hook(rip_distribute_update_all);
4009
4010 /* Distribute list install. */
4011 distribute_list_init(RIP_NODE);
4012 distribute_list_add_hook(rip_distribute_update);
4013 distribute_list_delete_hook(rip_distribute_update);
4014
4015 /* Route-map */
4016 rip_route_map_init();
4017 rip_offset_init();
4018
4019 route_map_add_hook(rip_routemap_update);
4020 route_map_delete_hook(rip_routemap_update);
4021
4022 if_rmap_init(RIP_NODE);
4023 if_rmap_hook_add(rip_if_rmap_update);
4024 if_rmap_hook_delete(rip_if_rmap_update);
4025
4026 /* Distance control. */
4027 rip_distance_table = route_table_init();
4028 }
FRRouting mirror