Annotation of embedaddon/bird/proto/rip/rip.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Routing Information Protocol (RIP)
3: *
4: * (c) 1998--1999 Pavel Machek <pavel@ucw.cz>
5: * (c) 2004--2013 Ondrej Filip <feela@network.cz>
6: * (c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
7: * (c) 2009--2015 CZ.NIC z.s.p.o.
8: *
9: * Can be freely distributed and used under the terms of the GNU GPL.
10: */
11:
12: /**
13: * DOC: Routing Information Protocol (RIP)
14: *
15: * The RIP protocol is implemented in two files: |rip.c| containing the protocol
16: * logic, route management and the protocol glue with BIRD core, and |packets.c|
17: * handling RIP packet processing, RX, TX and protocol sockets.
18: *
19: * Each instance of RIP is described by a structure &rip_proto, which contains
20: * an internal RIP routing table, a list of protocol interfaces and the main
21: * timer responsible for RIP routing table cleanup.
22: *
23: * RIP internal routing table contains incoming and outgoing routes. For each
24: * network (represented by structure &rip_entry) there is one outgoing route
25: * stored directly in &rip_entry and an one-way linked list of incoming routes
26: * (structures &rip_rte). The list contains incoming routes from different RIP
27: * neighbors, but only routes with the lowest metric are stored (i.e., all
28: * stored incoming routes have the same metric).
29: *
30: * Note that RIP itself does not select outgoing route, that is done by the core
31: * routing table. When a new incoming route is received, it is propagated to the
32: * RIP table by rip_update_rte() and possibly stored in the list of incoming
33: * routes. Then the change may be propagated to the core by rip_announce_rte().
34: * The core selects the best route and propagate it to RIP by rip_rt_notify(),
35: * which updates outgoing route part of &rip_entry and possibly triggers route
36: * propagation by rip_trigger_update().
37: *
38: * RIP interfaces are represented by structures &rip_iface. A RIP interface
39: * contains a per-interface socket, a list of associated neighbors, interface
40: * configuration, and state information related to scheduled interface events
41: * and running update sessions. RIP interfaces are added and removed based on
42: * core interface notifications.
43: *
44: * There are two RIP interface events - regular updates and triggered updates.
45: * Both are managed from the RIP interface timer (rip_iface_timer()). Regular
46: * updates are called at fixed interval and propagate the whole routing table,
47: * while triggered updates are scheduled by rip_trigger_update() due to some
48: * routing table change and propagate only the routes modified since the time
49: * they were scheduled. There are also unicast-destined requested updates, but
50: * these are sent directly as a reaction to received RIP request message. The
51: * update session is started by rip_send_table(). There may be at most one
52: * active update session per interface, as the associated state (including the
53: * fib iterator) is stored directly in &rip_iface structure.
54: *
55: * RIP neighbors are represented by structures &rip_neighbor. Compared to
56: * neighbor handling in other routing protocols, RIP does not have explicit
57: * neighbor discovery and adjacency maintenance, which makes the &rip_neighbor
58: * related code a bit peculiar. RIP neighbors are interlinked with core neighbor
59: * structures (&neighbor) and use core neighbor notifications to ensure that RIP
60: * neighbors are timely removed. RIP neighbors are added based on received route
61: * notifications and removed based on core neighbor and RIP interface events.
62: *
63: * RIP neighbors are linked by RIP routes and use counter to track the number of
64: * associated routes, but when these RIP routes timeout, associated RIP neighbor
65: * is still alive (with zero counter). When RIP neighbor is removed but still
66: * has some associated routes, it is not freed, just changed to detached state
67: * (core neighbors and RIP ifaces are unlinked), then during the main timer
68: * cleanup phase the associated routes are removed and the &rip_neighbor
69: * structure is finally freed.
70: *
71: * Supported standards:
72: * - RFC 1058 - RIPv1
73: * - RFC 2453 - RIPv2
74: * - RFC 2080 - RIPng
75: * - RFC 4822 - RIP cryptographic authentication
76: */
77:
78: #include <stdlib.h>
79: #include "rip.h"
80:
81:
82: static inline void rip_lock_neighbor(struct rip_neighbor *n);
83: static inline void rip_unlock_neighbor(struct rip_neighbor *n);
84: static inline int rip_iface_link_up(struct rip_iface *ifa);
85: static inline void rip_kick_timer(struct rip_proto *p);
86: static inline void rip_iface_kick_timer(struct rip_iface *ifa);
87: static void rip_iface_timer(timer *timer);
88: static void rip_trigger_update(struct rip_proto *p);
89:
90:
91: /*
92: * RIP routes
93: */
94:
95: static void
96: rip_init_entry(struct fib_node *fn)
97: {
98: // struct rip_entry *en = (void) *fn;
99:
100: const uint offset = OFFSETOF(struct rip_entry, routes);
101: memset((byte *)fn + offset, 0, sizeof(struct rip_entry) - offset);
102: }
103:
104: static struct rip_rte *
105: rip_add_rte(struct rip_proto *p, struct rip_rte **rp, struct rip_rte *src)
106: {
107: struct rip_rte *rt = sl_alloc(p->rte_slab);
108:
109: memcpy(rt, src, sizeof(struct rip_rte));
110: rt->next = *rp;
111: *rp = rt;
112:
113: rip_lock_neighbor(rt->from);
114:
115: return rt;
116: }
117:
118: static inline void
119: rip_remove_rte(struct rip_proto *p, struct rip_rte **rp)
120: {
121: struct rip_rte *rt = *rp;
122:
123: rip_unlock_neighbor(rt->from);
124:
125: *rp = rt->next;
126: sl_free(p->rte_slab, rt);
127: }
128:
129: static inline int rip_same_rte(struct rip_rte *a, struct rip_rte *b)
130: { return a->metric == b->metric && a->tag == b->tag && ipa_equal(a->next_hop, b->next_hop); }
131:
132: static inline int rip_valid_rte(struct rip_rte *rt)
133: { return rt->from->ifa != NULL; }
134:
135: /**
136: * rip_announce_rte - announce route from RIP routing table to the core
137: * @p: RIP instance
138: * @en: related network
139: *
140: * The function takes a list of incoming routes from @en, prepare appropriate
141: * &rte for the core and propagate it by rte_update().
142: */
143: static void
144: rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
145: {
146: struct rip_rte *rt = en->routes;
147:
148: /* Find first valid rte */
149: while (rt && !rip_valid_rte(rt))
150: rt = rt->next;
151:
152: if (rt)
153: {
154: /* Update */
155: net *n = net_get(p->p.table, en->n.prefix, en->n.pxlen);
156:
157: rta a0 = {
158: .src = p->p.main_source,
159: .source = RTS_RIP,
160: .scope = SCOPE_UNIVERSE,
161: .cast = RTC_UNICAST
162: };
163:
164: u8 rt_metric = rt->metric;
165: u16 rt_tag = rt->tag;
166: struct rip_rte *rt2 = rt->next;
167:
168: /* Find second valid rte */
169: while (rt2 && !rip_valid_rte(rt2))
170: rt2 = rt2->next;
171:
172: if (p->ecmp && rt2)
173: {
174: /* ECMP route */
175: struct mpnh *nhs = NULL;
176: int num = 0;
177:
178: for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
179: {
180: if (!rip_valid_rte(rt))
181: continue;
182:
183: struct mpnh *nh = alloca(sizeof(struct mpnh));
184: nh->gw = rt->next_hop;
185: nh->iface = rt->from->nbr->iface;
186: nh->weight = rt->from->ifa->cf->ecmp_weight;
187: mpnh_insert(&nhs, nh);
188: num++;
189:
190: if (rt->tag != rt_tag)
191: rt_tag = 0;
192: }
193:
194: a0.dest = RTD_MULTIPATH;
195: a0.nexthops = nhs;
196: }
197: else
198: {
199: /* Unipath route */
200: a0.dest = RTD_ROUTER;
201: a0.gw = rt->next_hop;
202: a0.iface = rt->from->nbr->iface;
203: a0.from = rt->from->nbr->addr;
204: }
205:
206: rta *a = rta_lookup(&a0);
207: rte *e = rte_get_temp(a);
208:
209: e->u.rip.from = a0.iface;
210: e->u.rip.metric = rt_metric;
211: e->u.rip.tag = rt_tag;
212:
213: e->net = n;
214: e->pflags = 0;
215:
216: rte_update(&p->p, n, e);
217: }
218: else
219: {
220: /* Withdraw */
221: net *n = net_find(p->p.table, en->n.prefix, en->n.pxlen);
222: rte_update(&p->p, n, NULL);
223: }
224: }
225:
226: /**
227: * rip_update_rte - enter a route update to RIP routing table
228: * @p: RIP instance
229: * @prefix: network prefix
230: * @pxlen: network prefix length
231: * @new: a &rip_rte representing the new route
232: *
233: * The function is called by the RIP packet processing code whenever it receives
234: * a reachable route. The appropriate routing table entry is found and the list
235: * of incoming routes is updated. Eventually, the change is also propagated to
236: * the core by rip_announce_rte(). Note that for unreachable routes,
237: * rip_withdraw_rte() should be called instead of rip_update_rte().
238: */
239: void
240: rip_update_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_rte *new)
241: {
242: struct rip_entry *en = fib_get(&p->rtable, prefix, pxlen);
243: struct rip_rte *rt, **rp;
244: int changed = 0;
245:
246: /* If the new route is better, remove all current routes */
247: if (en->routes && new->metric < en->routes->metric)
248: while (en->routes)
249: rip_remove_rte(p, &en->routes);
250:
251: /* Find the old route (also set rp for later) */
252: for (rp = &en->routes; rt = *rp; rp = &rt->next)
253: if (rt->from == new->from)
254: {
255: if (rip_same_rte(rt, new))
256: {
257: rt->expires = new->expires;
258: return;
259: }
260:
261: /* Remove the old route */
262: rip_remove_rte(p, rp);
263: changed = 1;
264: break;
265: }
266:
267: /* If the new route is optimal, add it to the list */
268: if (!en->routes || new->metric == en->routes->metric)
269: {
270: rt = rip_add_rte(p, rp, new);
271: changed = 1;
272: }
273:
274: /* Announce change if on relevant position (the first or any for ECMP) */
275: if (changed && (rp == &en->routes || p->ecmp))
276: rip_announce_rte(p, en);
277: }
278:
279: /**
280: * rip_withdraw_rte - enter a route withdraw to RIP routing table
281: * @p: RIP instance
282: * @prefix: network prefix
283: * @pxlen: network prefix length
284: * @from: a &rip_neighbor propagating the withdraw
285: *
286: * The function is called by the RIP packet processing code whenever it receives
287: * an unreachable route. The incoming route for given network from nbr @from is
288: * removed. Eventually, the change is also propagated by rip_announce_rte().
289: */
290: void
291: rip_withdraw_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_neighbor *from)
292: {
293: struct rip_entry *en = fib_find(&p->rtable, prefix, pxlen);
294: struct rip_rte *rt, **rp;
295:
296: if (!en)
297: return;
298:
299: /* Find the old route */
300: for (rp = &en->routes; rt = *rp; rp = &rt->next)
301: if (rt->from == from)
302: break;
303:
304: if (!rt)
305: return;
306:
307: /* Remove the old route */
308: rip_remove_rte(p, rp);
309:
310: /* Announce change if on relevant position */
311: if (rp == &en->routes || p->ecmp)
312: rip_announce_rte(p, en);
313: }
314:
315: /*
316: * rip_rt_notify - core tells us about new route, so store
317: * it into our data structures.
318: */
319: static void
320: rip_rt_notify(struct proto *P, struct rtable *table UNUSED, struct network *net, struct rte *new,
321: struct rte *old UNUSED, struct ea_list *attrs)
322: {
323: struct rip_proto *p = (struct rip_proto *) P;
324: struct rip_entry *en;
325: int old_metric;
326:
327: if (new)
328: {
329: /* Update */
330: u32 rt_metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
331: u32 rt_tag = ea_get_int(attrs, EA_RIP_TAG, 0);
332:
333: if (rt_metric > p->infinity)
334: {
335: log(L_WARN "%s: Invalid rip_metric value %u for route %I/%d",
336: p->p.name, rt_metric, net->n.prefix, net->n.pxlen);
337: rt_metric = p->infinity;
338: }
339:
340: if (rt_tag > 0xffff)
341: {
342: log(L_WARN "%s: Invalid rip_tag value %u for route %I/%d",
343: p->p.name, rt_tag, net->n.prefix, net->n.pxlen);
344: rt_metric = p->infinity;
345: rt_tag = 0;
346: }
347:
348: /*
349: * Note that we accept exported routes with infinity metric (this could
350: * happen if rip_metric is modified in filters). Such entry has infinity
351: * metric but is RIP_ENTRY_VALID and therefore is not subject to garbage
352: * collection.
353: */
354:
355: en = fib_get(&p->rtable, &net->n.prefix, net->n.pxlen);
356:
357: old_metric = en->valid ? en->metric : -1;
358:
359: en->valid = RIP_ENTRY_VALID;
360: en->metric = rt_metric;
361: en->tag = rt_tag;
362: en->from = (new->attrs->src->proto == P) ? new->u.rip.from : NULL;
363: en->iface = new->attrs->iface;
364: en->next_hop = new->attrs->gw;
365: }
366: else
367: {
368: /* Withdraw */
369: en = fib_find(&p->rtable, &net->n.prefix, net->n.pxlen);
370:
371: if (!en || en->valid != RIP_ENTRY_VALID)
372: return;
373:
374: old_metric = en->metric;
375:
376: en->valid = RIP_ENTRY_STALE;
377: en->metric = p->infinity;
378: en->tag = 0;
379: en->from = NULL;
380: en->iface = NULL;
381: en->next_hop = IPA_NONE;
382: }
383:
384: /* Activate triggered updates */
385: if (en->metric != old_metric)
386: {
387: en->changed = now;
388: rip_trigger_update(p);
389: }
390: }
391:
392:
393: /*
394: * RIP neighbors
395: */
396:
397: struct rip_neighbor *
398: rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa)
399: {
400: neighbor *nbr = neigh_find2(&p->p, a, ifa->iface, 0);
401:
402: if (!nbr || (nbr->scope == SCOPE_HOST) || !rip_iface_link_up(ifa))
403: return NULL;
404:
405: if (nbr->data)
406: return nbr->data;
407:
408: TRACE(D_EVENTS, "New neighbor %I on %s", *a, ifa->iface->name);
409:
410: struct rip_neighbor *n = mb_allocz(p->p.pool, sizeof(struct rip_neighbor));
411: n->ifa = ifa;
412: n->nbr = nbr;
413: nbr->data = n;
414: n->csn = nbr->aux;
415:
416: add_tail(&ifa->neigh_list, NODE n);
417:
418: return n;
419: }
420:
421: static void
422: rip_remove_neighbor(struct rip_proto *p, struct rip_neighbor *n)
423: {
424: neighbor *nbr = n->nbr;
425:
426: TRACE(D_EVENTS, "Removing neighbor %I on %s", nbr->addr, nbr->iface->name);
427:
428: rem_node(NODE n);
429: n->ifa = NULL;
430: n->nbr = NULL;
431: nbr->data = NULL;
432: nbr->aux = n->csn;
433:
434: rfree(n->bfd_req);
435: n->bfd_req = NULL;
436: n->last_seen = 0;
437:
438: if (!n->uc)
439: mb_free(n);
440:
441: /* Related routes are removed in rip_timer() */
442: rip_kick_timer(p);
443: }
444:
445: static inline void
446: rip_lock_neighbor(struct rip_neighbor *n)
447: {
448: n->uc++;
449: }
450:
451: static inline void
452: rip_unlock_neighbor(struct rip_neighbor *n)
453: {
454: n->uc--;
455:
456: if (!n->nbr && !n->uc)
457: mb_free(n);
458: }
459:
460: static void
461: rip_neigh_notify(struct neighbor *nbr)
462: {
463: struct rip_proto *p = (struct rip_proto *) nbr->proto;
464: struct rip_neighbor *n = nbr->data;
465:
466: if (!n)
467: return;
468:
469: /*
470: * We assume that rip_neigh_notify() is called before rip_if_notify() for
471: * IF_CHANGE_DOWN and therefore n->ifa is still valid. We have no such
472: * ordering assumption for IF_CHANGE_LINK, so we test link state of the
473: * underlying iface instead of just rip_iface state.
474: */
475: if ((nbr->scope <= 0) || !rip_iface_link_up(n->ifa))
476: rip_remove_neighbor(p, n);
477: }
478:
479: static void
480: rip_bfd_notify(struct bfd_request *req)
481: {
482: struct rip_neighbor *n = req->data;
483: struct rip_proto *p = n->ifa->rip;
484:
485: if (req->down)
486: {
487: TRACE(D_EVENTS, "BFD session down for nbr %I on %s",
488: n->nbr->addr, n->ifa->iface->name);
489: rip_remove_neighbor(p, n);
490: }
491: }
492:
493: void
494: rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n)
495: {
496: int use_bfd = n->ifa->cf->bfd && n->last_seen;
497:
498: if (use_bfd && !n->bfd_req)
499: {
500: /*
501: * For RIPv2, use the same address as rip_open_socket(). For RIPng, neighbor
502: * should contain an address from the same prefix, thus also link-local. It
503: * may cause problems if two link-local addresses are assigned to one iface.
504: */
505: ip_addr saddr = rip_is_v2(p) ? n->ifa->sk->saddr : n->nbr->ifa->ip;
506: n->bfd_req = bfd_request_session(p->p.pool, n->nbr->addr, saddr,
507: n->nbr->iface, rip_bfd_notify, n);
508: }
509:
510: if (!use_bfd && n->bfd_req)
511: {
512: rfree(n->bfd_req);
513: n->bfd_req = NULL;
514: }
515: }
516:
517:
518: /*
519: * RIP interfaces
520: */
521:
522: static void
523: rip_iface_start(struct rip_iface *ifa)
524: {
525: struct rip_proto *p = ifa->rip;
526:
527: TRACE(D_EVENTS, "Starting interface %s", ifa->iface->name);
528:
529: ifa->next_regular = now + (random() % ifa->cf->update_time) + 1;
530: ifa->next_triggered = now; /* Available immediately */
531: ifa->want_triggered = 1; /* All routes in triggered update */
532: tm_start(ifa->timer, 1); /* Or 100 ms */
533: ifa->up = 1;
534:
535: if (!ifa->cf->passive)
536: rip_send_request(ifa->rip, ifa);
537: }
538:
539: static void
540: rip_iface_stop(struct rip_iface *ifa)
541: {
542: struct rip_proto *p = ifa->rip;
543: struct rip_neighbor *n;
544:
545: TRACE(D_EVENTS, "Stopping interface %s", ifa->iface->name);
546:
547: rip_reset_tx_session(p, ifa);
548:
549: WALK_LIST_FIRST(n, ifa->neigh_list)
550: rip_remove_neighbor(p, n);
551:
552: tm_stop(ifa->timer);
553: ifa->up = 0;
554: }
555:
556: static inline int
557: rip_iface_link_up(struct rip_iface *ifa)
558: {
559: return !ifa->cf->check_link || (ifa->iface->flags & IF_LINK_UP);
560: }
561:
562: static void
563: rip_iface_update_state(struct rip_iface *ifa)
564: {
565: int up = ifa->sk && rip_iface_link_up(ifa);
566:
567: if (up == ifa->up)
568: return;
569:
570: if (up)
571: rip_iface_start(ifa);
572: else
573: rip_iface_stop(ifa);
574: }
575:
576: static void
577: rip_iface_update_buffers(struct rip_iface *ifa)
578: {
579: if (!ifa->sk)
580: return;
581:
582: uint rbsize = ifa->cf->rx_buffer ?: ifa->iface->mtu;
583: uint tbsize = ifa->cf->tx_length ?: ifa->iface->mtu;
584: rbsize = MAX(rbsize, tbsize);
585:
586: sk_set_rbsize(ifa->sk, rbsize);
587: sk_set_tbsize(ifa->sk, tbsize);
588:
589: uint headers = (rip_is_v2(ifa->rip) ? IP4_HEADER_LENGTH : IP6_HEADER_LENGTH) + UDP_HEADER_LENGTH;
590: ifa->tx_plen = tbsize - headers;
591:
592: if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
593: ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH + max_mac_length(ifa->cf->passwords);
594: }
595:
596: static inline void
597: rip_iface_update_bfd(struct rip_iface *ifa)
598: {
599: struct rip_proto *p = ifa->rip;
600: struct rip_neighbor *n;
601:
602: WALK_LIST(n, ifa->neigh_list)
603: rip_update_bfd(p, n);
604: }
605:
606:
607: static void
608: rip_iface_locked(struct object_lock *lock)
609: {
610: struct rip_iface *ifa = lock->data;
611: struct rip_proto *p = ifa->rip;
612:
613: if (!rip_open_socket(ifa))
614: {
615: log(L_ERR "%s: Cannot open socket for %s", p->p.name, ifa->iface->name);
616: return;
617: }
618:
619: rip_iface_update_buffers(ifa);
620: rip_iface_update_state(ifa);
621: }
622:
623:
624: static struct rip_iface *
625: rip_find_iface(struct rip_proto *p, struct iface *what)
626: {
627: struct rip_iface *ifa;
628:
629: WALK_LIST(ifa, p->iface_list)
630: if (ifa->iface == what)
631: return ifa;
632:
633: return NULL;
634: }
635:
636: static void
637: rip_add_iface(struct rip_proto *p, struct iface *iface, struct rip_iface_config *ic)
638: {
639: struct rip_iface *ifa;
640:
641: TRACE(D_EVENTS, "Adding interface %s", iface->name);
642:
643: ifa = mb_allocz(p->p.pool, sizeof(struct rip_iface));
644: ifa->rip = p;
645: ifa->iface = iface;
646: ifa->cf = ic;
647:
648: if (ipa_nonzero(ic->address))
649: ifa->addr = ic->address;
650: else if (ic->mode == RIP_IM_MULTICAST)
651: ifa->addr = rip_is_v2(p) ? IP4_RIP_ROUTERS : IP6_RIP_ROUTERS;
652: else /* Broadcast */
653: ifa->addr = iface->addr->brd;
654:
655: init_list(&ifa->neigh_list);
656:
657: add_tail(&p->iface_list, NODE ifa);
658:
659: ifa->timer = tm_new_set(p->p.pool, rip_iface_timer, ifa, 0, 0);
660:
661: struct object_lock *lock = olock_new(p->p.pool);
662: lock->type = OBJLOCK_UDP;
663: lock->port = ic->port;
664: lock->iface = iface;
665: lock->data = ifa;
666: lock->hook = rip_iface_locked;
667: ifa->lock = lock;
668:
669: olock_acquire(lock);
670: }
671:
672: static void
673: rip_remove_iface(struct rip_proto *p, struct rip_iface *ifa)
674: {
675: rip_iface_stop(ifa);
676:
677: TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
678:
679: rem_node(NODE ifa);
680:
681: rfree(ifa->sk);
682: rfree(ifa->lock);
683: rfree(ifa->timer);
684:
685: mb_free(ifa);
686: }
687:
688: static int
689: rip_reconfigure_iface(struct rip_proto *p, struct rip_iface *ifa, struct rip_iface_config *new)
690: {
691: struct rip_iface_config *old = ifa->cf;
692:
693: /* Change of these options would require to reset the iface socket */
694: if ((new->mode != old->mode) ||
695: (new->port != old->port) ||
696: (new->tx_tos != old->tx_tos) ||
697: (new->tx_priority != old->tx_priority) ||
698: (new->ttl_security != old->ttl_security))
699: return 0;
700:
701: TRACE(D_EVENTS, "Reconfiguring interface %s", ifa->iface->name);
702:
703: ifa->cf = new;
704:
705: rip_iface_update_buffers(ifa);
706:
707: if (ifa->next_regular > (now + new->update_time))
708: ifa->next_regular = now + (random() % new->update_time) + 1;
709:
710: if (new->check_link != old->check_link)
711: rip_iface_update_state(ifa);
712:
713: if (new->bfd != old->bfd)
714: rip_iface_update_bfd(ifa);
715:
716: if (ifa->up)
717: rip_iface_kick_timer(ifa);
718:
719: return 1;
720: }
721:
722: static void
723: rip_reconfigure_ifaces(struct rip_proto *p, struct rip_config *cf)
724: {
725: struct iface *iface;
726:
727: WALK_LIST(iface, iface_list)
728: {
729: if (! (iface->flags & IF_UP))
730: continue;
731:
732: struct rip_iface *ifa = rip_find_iface(p, iface);
733: struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
734:
735: if (ifa && ic)
736: {
737: if (rip_reconfigure_iface(p, ifa, ic))
738: continue;
739:
740: /* Hard restart */
741: log(L_INFO "%s: Restarting interface %s", p->p.name, ifa->iface->name);
742: rip_remove_iface(p, ifa);
743: rip_add_iface(p, iface, ic);
744: }
745:
746: if (ifa && !ic)
747: rip_remove_iface(p, ifa);
748:
749: if (!ifa && ic)
750: rip_add_iface(p, iface, ic);
751: }
752: }
753:
754: static void
755: rip_if_notify(struct proto *P, unsigned flags, struct iface *iface)
756: {
757: struct rip_proto *p = (void *) P;
758: struct rip_config *cf = (void *) P->cf;
759:
760: if (iface->flags & IF_IGNORE)
761: return;
762:
763: if (flags & IF_CHANGE_UP)
764: {
765: struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
766:
767: if (ic)
768: rip_add_iface(p, iface, ic);
769:
770: return;
771: }
772:
773: struct rip_iface *ifa = rip_find_iface(p, iface);
774:
775: if (!ifa)
776: return;
777:
778: if (flags & IF_CHANGE_DOWN)
779: {
780: rip_remove_iface(p, ifa);
781: return;
782: }
783:
784: if (flags & IF_CHANGE_MTU)
785: rip_iface_update_buffers(ifa);
786:
787: if (flags & IF_CHANGE_LINK)
788: rip_iface_update_state(ifa);
789: }
790:
791:
792: /*
793: * RIP timer events
794: */
795:
796: /**
797: * rip_timer - RIP main timer hook
798: * @t: timer
799: *
800: * The RIP main timer is responsible for routing table maintenance. Invalid or
801: * expired routes (&rip_rte) are removed and garbage collection of stale routing
802: * table entries (&rip_entry) is done. Changes are propagated to core tables,
803: * route reload is also done here. Note that garbage collection uses a maximal
804: * GC time, while interfaces maintain an illusion of per-interface GC times in
805: * rip_send_response().
806: *
807: * Keeping incoming routes and the selected outgoing route are two independent
808: * functions, therefore after garbage collection some entries now considered
809: * invalid (RIP_ENTRY_DUMMY) still may have non-empty list of incoming routes,
810: * while some valid entries (representing an outgoing route) may have that list
811: * empty.
812: *
813: * The main timer is not scheduled periodically but it uses the time of the
814: * current next event and the minimal interval of any possible event to compute
815: * the time of the next run.
816: */
817: static void
818: rip_timer(timer *t)
819: {
820: struct rip_proto *p = t->data;
821: struct rip_config *cf = (void *) (p->p.cf);
822: struct rip_iface *ifa;
823: struct rip_neighbor *n, *nn;
824: struct fib_iterator fit;
825: bird_clock_t next = now + MIN(cf->min_timeout_time, cf->max_garbage_time);
826: bird_clock_t expires = 0;
827:
828: TRACE(D_EVENTS, "Main timer fired");
829:
830: FIB_ITERATE_INIT(&fit, &p->rtable);
831:
832: loop:
833: FIB_ITERATE_START(&p->rtable, &fit, node)
834: {
835: struct rip_entry *en = (struct rip_entry *) node;
836: struct rip_rte *rt, **rp;
837: int changed = 0;
838:
839: /* Checking received routes for timeout and for dead neighbors */
840: for (rp = &en->routes; rt = *rp; /* rp = &rt->next */)
841: {
842: if (!rip_valid_rte(rt) || (rt->expires <= now))
843: {
844: rip_remove_rte(p, rp);
845: changed = 1;
846: continue;
847: }
848:
849: next = MIN(next, rt->expires);
850: rp = &rt->next;
851: }
852:
853: /* Propagating eventual change */
854: if (changed || p->rt_reload)
855: {
856: /*
857: * We have to restart the iteration because there may be a cascade of
858: * synchronous events rip_announce_rte() -> nest table change ->
859: * rip_rt_notify() -> p->rtable change, invalidating hidden variables.
860: */
861:
862: FIB_ITERATE_PUT_NEXT(&fit, &p->rtable, node);
863: rip_announce_rte(p, en);
864: goto loop;
865: }
866:
867: /* Checking stale entries for garbage collection timeout */
868: if (en->valid == RIP_ENTRY_STALE)
869: {
870: expires = en->changed + cf->max_garbage_time;
871:
872: if (expires <= now)
873: {
874: // TRACE(D_EVENTS, "entry is too old: %I/%d", en->n.prefix, en->n.pxlen);
875: en->valid = 0;
876: }
877: else
878: next = MIN(next, expires);
879: }
880:
881: /* Remove empty nodes */
882: if (!en->valid && !en->routes)
883: {
884: FIB_ITERATE_PUT(&fit, node);
885: fib_delete(&p->rtable, node);
886: goto loop;
887: }
888: }
889: FIB_ITERATE_END(node);
890:
891: p->rt_reload = 0;
892:
893: /* Handling neighbor expiration */
894: WALK_LIST(ifa, p->iface_list)
895: WALK_LIST_DELSAFE(n, nn, ifa->neigh_list)
896: if (n->last_seen)
897: {
898: expires = n->last_seen + n->ifa->cf->timeout_time;
899:
900: if (expires <= now)
901: rip_remove_neighbor(p, n);
902: else
903: next = MIN(next, expires);
904: }
905:
906: tm_start(p->timer, MAX(next - now, 1));
907: }
908:
909: static inline void
910: rip_kick_timer(struct rip_proto *p)
911: {
912: if (p->timer->expires > (now + 1))
913: tm_start(p->timer, 1); /* Or 100 ms */
914: }
915:
916: /**
917: * rip_iface_timer - RIP interface timer hook
918: * @t: timer
919: *
920: * RIP interface timers are responsible for scheduling both regular and
921: * triggered updates. Fixed, delay-independent period is used for regular
922: * updates, while minimal separating interval is enforced for triggered updates.
923: * The function also ensures that a new update is not started when the old one
924: * is still running.
925: */
926: static void
927: rip_iface_timer(timer *t)
928: {
929: struct rip_iface *ifa = t->data;
930: struct rip_proto *p = ifa->rip;
931: bird_clock_t period = ifa->cf->update_time;
932:
933: if (ifa->cf->passive)
934: return;
935:
936: TRACE(D_EVENTS, "Interface timer fired for %s", ifa->iface->name);
937:
938: if (ifa->tx_active)
939: {
940: if (now < (ifa->next_regular + period))
941: { tm_start(ifa->timer, 1); return; }
942:
943: /* We are too late, reset is done by rip_send_table() */
944: log(L_WARN "%s: Too slow update on %s, resetting", p->p.name, ifa->iface->name);
945: }
946:
947: if (now >= ifa->next_regular)
948: {
949: /* Send regular update, set timer for next period (or following one if necessay) */
950: TRACE(D_EVENTS, "Sending regular updates for %s", ifa->iface->name);
951: rip_send_table(p, ifa, ifa->addr, 0);
952: ifa->next_regular += period * (1 + ((now - ifa->next_regular) / period));
953: ifa->want_triggered = 0;
954: p->triggered = 0;
955: }
956: else if (ifa->want_triggered && (now >= ifa->next_triggered))
957: {
958: /* Send triggered update, enforce interval between triggered updates */
959: TRACE(D_EVENTS, "Sending triggered updates for %s", ifa->iface->name);
960: rip_send_table(p, ifa, ifa->addr, ifa->want_triggered);
961: ifa->next_triggered = now + MIN(5, period / 2 + 1);
962: ifa->want_triggered = 0;
963: p->triggered = 0;
964: }
965:
966: tm_start(ifa->timer, ifa->want_triggered ? 1 : (ifa->next_regular - now));
967: }
968:
969: static inline void
970: rip_iface_kick_timer(struct rip_iface *ifa)
971: {
972: if (ifa->timer->expires > (now + 1))
973: tm_start(ifa->timer, 1); /* Or 100 ms */
974: }
975:
976: static void
977: rip_trigger_update(struct rip_proto *p)
978: {
979: if (p->triggered)
980: return;
981:
982: struct rip_iface *ifa;
983: WALK_LIST(ifa, p->iface_list)
984: {
985: /* Interface not active */
986: if (! ifa->up)
987: continue;
988:
989: /* Already scheduled */
990: if (ifa->want_triggered)
991: continue;
992:
993: TRACE(D_EVENTS, "Scheduling triggered updates for %s", ifa->iface->name);
994: ifa->want_triggered = now;
995: rip_iface_kick_timer(ifa);
996: }
997:
998: p->triggered = 1;
999: }
1000:
1001:
1002: /*
1003: * RIP protocol glue
1004: */
1005:
1006: static struct ea_list *
1007: rip_prepare_attrs(struct linpool *pool, ea_list *next, u8 metric, u16 tag)
1008: {
1009: struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2 * sizeof(eattr));
1010:
1011: l->next = next;
1012: l->flags = EALF_SORTED;
1013: l->count = 2;
1014:
1015: l->attrs[0].id = EA_RIP_METRIC;
1016: l->attrs[0].flags = 0;
1017: l->attrs[0].type = EAF_TYPE_INT | EAF_TEMP;
1018: l->attrs[0].u.data = metric;
1019:
1020: l->attrs[1].id = EA_RIP_TAG;
1021: l->attrs[1].flags = 0;
1022: l->attrs[1].type = EAF_TYPE_INT | EAF_TEMP;
1023: l->attrs[1].u.data = tag;
1024:
1025: return l;
1026: }
1027:
1028: static int
1029: rip_import_control(struct proto *P UNUSED, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
1030: {
1031: /* Prepare attributes with initial values */
1032: if ((*rt)->attrs->source != RTS_RIP)
1033: *attrs = rip_prepare_attrs(pool, *attrs, 1, 0);
1034:
1035: return 0;
1036: }
1037:
1038: static int
1039: rip_reload_routes(struct proto *P)
1040: {
1041: struct rip_proto *p = (struct rip_proto *) P;
1042:
1043: if (p->rt_reload)
1044: return 1;
1045:
1046: TRACE(D_EVENTS, "Scheduling route reload");
1047: p->rt_reload = 1;
1048: rip_kick_timer(p);
1049:
1050: return 1;
1051: }
1052:
1053: static struct ea_list *
1054: rip_make_tmp_attrs(struct rte *rt, struct linpool *pool)
1055: {
1056: return rip_prepare_attrs(pool, NULL, rt->u.rip.metric, rt->u.rip.tag);
1057: }
1058:
1059: static void
1060: rip_store_tmp_attrs(struct rte *rt, struct ea_list *attrs)
1061: {
1062: rt->u.rip.metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
1063: rt->u.rip.tag = ea_get_int(attrs, EA_RIP_TAG, 0);
1064: }
1065:
1066: static int
1067: rip_rte_better(struct rte *new, struct rte *old)
1068: {
1069: return new->u.rip.metric < old->u.rip.metric;
1070: }
1071:
1072: static int
1073: rip_rte_same(struct rte *new, struct rte *old)
1074: {
1075: return ((new->u.rip.metric == old->u.rip.metric) &&
1076: (new->u.rip.tag == old->u.rip.tag) &&
1077: (new->u.rip.from == old->u.rip.from));
1078: }
1079:
1080:
1081: static struct proto *
1082: rip_init(struct proto_config *cfg)
1083: {
1084: struct proto *P = proto_new(cfg, sizeof(struct rip_proto));
1085:
1086: P->accept_ra_types = RA_OPTIMAL;
1087: P->if_notify = rip_if_notify;
1088: P->rt_notify = rip_rt_notify;
1089: P->neigh_notify = rip_neigh_notify;
1090: P->import_control = rip_import_control;
1091: P->reload_routes = rip_reload_routes;
1092: P->make_tmp_attrs = rip_make_tmp_attrs;
1093: P->store_tmp_attrs = rip_store_tmp_attrs;
1094: P->rte_better = rip_rte_better;
1095: P->rte_same = rip_rte_same;
1096:
1097: return P;
1098: }
1099:
1100: static int
1101: rip_start(struct proto *P)
1102: {
1103: struct rip_proto *p = (void *) P;
1104: struct rip_config *cf = (void *) (P->cf);
1105:
1106: init_list(&p->iface_list);
1107: fib_init(&p->rtable, P->pool, sizeof(struct rip_entry), 0, rip_init_entry);
1108: p->rte_slab = sl_new(P->pool, sizeof(struct rip_rte));
1109: p->timer = tm_new_set(P->pool, rip_timer, p, 0, 0);
1110:
1111: p->ecmp = cf->ecmp;
1112: p->infinity = cf->infinity;
1113: p->triggered = 0;
1114:
1115: p->log_pkt_tbf = (struct tbf){ .rate = 1, .burst = 5 };
1116: p->log_rte_tbf = (struct tbf){ .rate = 4, .burst = 20 };
1117:
1118: tm_start(p->timer, MIN(cf->min_timeout_time, cf->max_garbage_time));
1119:
1120: return PS_UP;
1121: }
1122:
1123: static int
1124: rip_reconfigure(struct proto *P, struct proto_config *c)
1125: {
1126: struct rip_proto *p = (void *) P;
1127: struct rip_config *new = (void *) c;
1128: // struct rip_config *old = (void *) (P->cf);
1129:
1130: if (new->infinity != p->infinity)
1131: return 0;
1132:
1133: TRACE(D_EVENTS, "Reconfiguring");
1134:
1135: p->p.cf = c;
1136: p->ecmp = new->ecmp;
1137: rip_reconfigure_ifaces(p, new);
1138:
1139: p->rt_reload = 1;
1140: rip_kick_timer(p);
1141:
1142: return 1;
1143: }
1144:
1145: static void
1146: rip_get_route_info(rte *rte, byte *buf, ea_list *attrs UNUSED)
1147: {
1148: buf += bsprintf(buf, " (%d/%d)", rte->pref, rte->u.rip.metric);
1149:
1150: if (rte->u.rip.tag)
1151: bsprintf(buf, " [%04x]", rte->u.rip.tag);
1152: }
1153:
1154: static int
1155: rip_get_attr(eattr *a, byte *buf, int buflen UNUSED)
1156: {
1157: switch (a->id)
1158: {
1159: case EA_RIP_METRIC:
1160: bsprintf(buf, "metric: %d", a->u.data);
1161: return GA_FULL;
1162:
1163: case EA_RIP_TAG:
1164: bsprintf(buf, "tag: %04x", a->u.data);
1165: return GA_FULL;
1166:
1167: default:
1168: return GA_UNKNOWN;
1169: }
1170: }
1171:
1172: void
1173: rip_show_interfaces(struct proto *P, char *iff)
1174: {
1175: struct rip_proto *p = (void *) P;
1176: struct rip_iface *ifa = NULL;
1177: struct rip_neighbor *n = NULL;
1178:
1179: if (p->p.proto_state != PS_UP)
1180: {
1181: cli_msg(-1021, "%s: is not up", p->p.name);
1182: cli_msg(0, "");
1183: return;
1184: }
1185:
1186: cli_msg(-1021, "%s:", p->p.name);
1187: cli_msg(-1021, "%-10s %-6s %6s %6s %6s",
1188: "Interface", "State", "Metric", "Nbrs", "Timer");
1189:
1190: WALK_LIST(ifa, p->iface_list)
1191: {
1192: if (iff && !patmatch(iff, ifa->iface->name))
1193: continue;
1194:
1195: int nbrs = 0;
1196: WALK_LIST(n, ifa->neigh_list)
1197: if (n->last_seen)
1198: nbrs++;
1199:
1200: int timer = MAX(ifa->next_regular - now, 0);
1201: cli_msg(-1021, "%-10s %-6s %6u %6u %6u",
1202: ifa->iface->name, (ifa->up ? "Up" : "Down"), ifa->cf->metric, nbrs, timer);
1203: }
1204:
1205: cli_msg(0, "");
1206: }
1207:
1208: void
1209: rip_show_neighbors(struct proto *P, char *iff)
1210: {
1211: struct rip_proto *p = (void *) P;
1212: struct rip_iface *ifa = NULL;
1213: struct rip_neighbor *n = NULL;
1214:
1215: if (p->p.proto_state != PS_UP)
1216: {
1217: cli_msg(-1022, "%s: is not up", p->p.name);
1218: cli_msg(0, "");
1219: return;
1220: }
1221:
1222: cli_msg(-1022, "%s:", p->p.name);
1223: cli_msg(-1022, "%-25s %-10s %6s %6s %6s",
1224: "IP address", "Interface", "Metric", "Routes", "Seen");
1225:
1226: WALK_LIST(ifa, p->iface_list)
1227: {
1228: if (iff && !patmatch(iff, ifa->iface->name))
1229: continue;
1230:
1231: WALK_LIST(n, ifa->neigh_list)
1232: {
1233: if (!n->last_seen)
1234: continue;
1235:
1236: int timer = now - n->last_seen;
1237: cli_msg(-1022, "%-25I %-10s %6u %6u %6u",
1238: n->nbr->addr, ifa->iface->name, ifa->cf->metric, n->uc, timer);
1239: }
1240: }
1241:
1242: cli_msg(0, "");
1243: }
1244:
1245: static void
1246: rip_dump(struct proto *P)
1247: {
1248: struct rip_proto *p = (struct rip_proto *) P;
1249: struct rip_iface *ifa;
1250: int i;
1251:
1252: i = 0;
1253: FIB_WALK(&p->rtable, e)
1254: {
1255: struct rip_entry *en = (struct rip_entry *) e;
1256: debug("RIP: entry #%d: %I/%d via %I dev %s valid %d metric %d age %d s\n",
1257: i++, en->n.prefix, en->n.pxlen, en->next_hop, en->iface->name,
1258: en->valid, en->metric, now - en->changed);
1259: }
1260: FIB_WALK_END;
1261:
1262: i = 0;
1263: WALK_LIST(ifa, p->iface_list)
1264: {
1265: debug("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
1266: i++, ifa->iface->name, ifa->sk ? ifa->sk->daddr : IPA_NONE,
1267: ifa->up, ifa->tx_active);
1268: }
1269: }
1270:
1271:
1272: struct protocol proto_rip = {
1273: .name = "RIP",
1274: .template = "rip%d",
1275: .attr_class = EAP_RIP,
1276: .preference = DEF_PREF_RIP,
1277: .config_size = sizeof(struct rip_config),
1278: .init = rip_init,
1279: .dump = rip_dump,
1280: .start = rip_start,
1281: .reconfigure = rip_reconfigure,
1282: .get_route_info = rip_get_route_info,
1283: .get_attr = rip_get_attr
1284: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rip.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / proto / rip