Annotation of embedaddon/bird/nest/rt-table.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Routing Tables
3: *
4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: /**
10: * DOC: Routing tables
11: *
12: * Routing tables are probably the most important structures BIRD uses. They
13: * hold all the information about known networks, the associated routes and
14: * their attributes.
15: *
16: * There are multiple routing tables (a primary one together with any
17: * number of secondary ones if requested by the configuration). Each table
18: * is basically a FIB containing entries describing the individual
19: * destination networks. For each network (represented by structure &net),
20: * there is a one-way linked list of route entries (&rte), the first entry
21: * on the list being the best one (i.e., the one we currently use
22: * for routing), the order of the other ones is undetermined.
23: *
24: * The &rte contains information specific to the route (preference, protocol
25: * metrics, time of last modification etc.) and a pointer to a &rta structure
26: * (see the route attribute module for a precise explanation) holding the
27: * remaining route attributes which are expected to be shared by multiple
28: * routes in order to conserve memory.
29: */
30:
31: #undef LOCAL_DEBUG
32:
33: #include "nest/bird.h"
34: #include "nest/route.h"
35: #include "nest/protocol.h"
36: #include "nest/cli.h"
37: #include "nest/iface.h"
38: #include "lib/resource.h"
39: #include "lib/event.h"
40: #include "lib/string.h"
41: #include "conf/conf.h"
42: #include "filter/filter.h"
43: #include "lib/string.h"
44: #include "lib/alloca.h"
45:
46: pool *rt_table_pool;
47:
48: static slab *rte_slab;
49: static linpool *rte_update_pool;
50:
51: static list routing_tables;
52:
53: static byte *rt_format_via(rte *e);
54: static void rt_free_hostcache(rtable *tab);
55: static void rt_notify_hostcache(rtable *tab, net *net);
56: static void rt_update_hostcache(rtable *tab);
57: static void rt_next_hop_update(rtable *tab);
58: static inline int rt_prune_table(rtable *tab);
59: static inline void rt_schedule_gc(rtable *tab);
60: static inline void rt_schedule_prune(rtable *tab);
61:
62:
63: static inline struct ea_list *
64: make_tmp_attrs(struct rte *rt, struct linpool *pool)
65: {
66: struct ea_list *(*mta)(struct rte *rt, struct linpool *pool);
67: mta = rt->attrs->src->proto->make_tmp_attrs;
68: return mta ? mta(rt, pool) : NULL;
69: }
70:
71: /* Like fib_route(), but skips empty net entries */
72: static net *
73: net_route(rtable *tab, ip_addr a, int len)
74: {
75: ip_addr a0;
76: net *n;
77:
78: while (len >= 0)
79: {
80: a0 = ipa_and(a, ipa_mkmask(len));
81: n = fib_find(&tab->fib, &a0, len);
82: if (n && rte_is_valid(n->routes))
83: return n;
84: len--;
85: }
86: return NULL;
87: }
88:
89: static void
90: rte_init(struct fib_node *N)
91: {
92: net *n = (net *) N;
93:
94: N->flags = 0;
95: n->routes = NULL;
96: }
97:
98: /**
99: * rte_find - find a route
100: * @net: network node
101: * @src: route source
102: *
103: * The rte_find() function returns a route for destination @net
104: * which is from route source @src.
105: */
106: rte *
107: rte_find(net *net, struct rte_src *src)
108: {
109: rte *e = net->routes;
110:
111: while (e && e->attrs->src != src)
112: e = e->next;
113: return e;
114: }
115:
116: /**
117: * rte_get_temp - get a temporary &rte
118: * @a: attributes to assign to the new route (a &rta; in case it's
119: * un-cached, rte_update() will create a cached copy automatically)
120: *
121: * Create a temporary &rte and bind it with the attributes @a.
122: * Also set route preference to the default preference set for
123: * the protocol.
124: */
125: rte *
126: rte_get_temp(rta *a)
127: {
128: rte *e = sl_alloc(rte_slab);
129:
130: e->attrs = a;
131: e->flags = 0;
132: e->pref = a->src->proto->preference;
133: return e;
134: }
135:
136: rte *
137: rte_do_cow(rte *r)
138: {
139: rte *e = sl_alloc(rte_slab);
140:
141: memcpy(e, r, sizeof(rte));
142: e->attrs = rta_clone(r->attrs);
143: e->flags = 0;
144: return e;
145: }
146:
147: /**
148: * rte_cow_rta - get a private writable copy of &rte with writable &rta
149: * @r: a route entry to be copied
150: * @lp: a linpool from which to allocate &rta
151: *
152: * rte_cow_rta() takes a &rte and prepares it and associated &rta for
153: * modification. There are three possibilities: First, both &rte and &rta are
154: * private copies, in that case they are returned unchanged. Second, &rte is
155: * private copy, but &rta is cached, in that case &rta is duplicated using
156: * rta_do_cow(). Third, both &rte is shared and &rta is cached, in that case
157: * both structures are duplicated by rte_do_cow() and rta_do_cow().
158: *
159: * Note that in the second case, cached &rta loses one reference, while private
160: * copy created by rta_do_cow() is a shallow copy sharing indirect data (eattrs,
161: * nexthops, ...) with it. To work properly, original shared &rta should have
162: * another reference during the life of created private copy.
163: *
164: * Result: a pointer to the new writable &rte with writable &rta.
165: */
166: rte *
167: rte_cow_rta(rte *r, linpool *lp)
168: {
169: if (!rta_is_cached(r->attrs))
170: return r;
171:
172: rte *e = rte_cow(r);
173: rta *a = rta_do_cow(r->attrs, lp);
174: rta_free(e->attrs);
175: e->attrs = a;
176: return e;
177: }
178:
179: static int /* Actually better or at least as good as */
180: rte_better(rte *new, rte *old)
181: {
182: int (*better)(rte *, rte *);
183:
184: if (!rte_is_valid(old))
185: return 1;
186: if (!rte_is_valid(new))
187: return 0;
188:
189: if (new->pref > old->pref)
190: return 1;
191: if (new->pref < old->pref)
192: return 0;
193: if (new->attrs->src->proto->proto != old->attrs->src->proto->proto)
194: {
195: /*
196: * If the user has configured protocol preferences, so that two different protocols
197: * have the same preference, try to break the tie by comparing addresses. Not too
198: * useful, but keeps the ordering of routes unambiguous.
199: */
200: return new->attrs->src->proto->proto > old->attrs->src->proto->proto;
201: }
202: if (better = new->attrs->src->proto->rte_better)
203: return better(new, old);
204: return 0;
205: }
206:
207: static int
208: rte_mergable(rte *pri, rte *sec)
209: {
210: int (*mergable)(rte *, rte *);
211:
212: if (!rte_is_valid(pri) || !rte_is_valid(sec))
213: return 0;
214:
215: if (pri->pref != sec->pref)
216: return 0;
217:
218: if (pri->attrs->src->proto->proto != sec->attrs->src->proto->proto)
219: return 0;
220:
221: if (mergable = pri->attrs->src->proto->rte_mergable)
222: return mergable(pri, sec);
223:
224: return 0;
225: }
226:
227: static void
228: rte_trace(struct proto *p, rte *e, int dir, char *msg)
229: {
230: log(L_TRACE "%s %c %s %I/%d %s", p->name, dir, msg, e->net->n.prefix, e->net->n.pxlen, rt_format_via(e));
231: }
232:
233: static inline void
234: rte_trace_in(uint flag, struct proto *p, rte *e, char *msg)
235: {
236: if (p->debug & flag)
237: rte_trace(p, e, '>', msg);
238: }
239:
240: static inline void
241: rte_trace_out(uint flag, struct proto *p, rte *e, char *msg)
242: {
243: if (p->debug & flag)
244: rte_trace(p, e, '<', msg);
245: }
246:
247: static rte *
248: export_filter_(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, linpool *pool, int silent)
249: {
250: struct proto *p = ah->proto;
251: struct filter *filter = ah->out_filter;
252: struct proto_stats *stats = ah->stats;
253: ea_list *tmpb = NULL;
254: rte *rt;
255: int v;
256:
257: rt = rt0;
258: *rt_free = NULL;
259:
260: if (!tmpa)
261: tmpa = &tmpb;
262:
263: *tmpa = make_tmp_attrs(rt, pool);
264:
265: v = p->import_control ? p->import_control(p, &rt, tmpa, pool) : 0;
266: if (v < 0)
267: {
268: if (silent)
269: goto reject;
270:
271: stats->exp_updates_rejected++;
272: if (v == RIC_REJECT)
273: rte_trace_out(D_FILTERS, p, rt, "rejected by protocol");
274: goto reject;
275: }
276: if (v > 0)
277: {
278: if (!silent)
279: rte_trace_out(D_FILTERS, p, rt, "forced accept by protocol");
280: goto accept;
281: }
282:
283: v = filter && ((filter == FILTER_REJECT) ||
284: (f_run(filter, &rt, tmpa, pool, FF_FORCE_TMPATTR) > F_ACCEPT));
285: if (v)
286: {
287: if (silent)
288: goto reject;
289:
290: stats->exp_updates_filtered++;
291: rte_trace_out(D_FILTERS, p, rt, "filtered out");
292: goto reject;
293: }
294:
295: accept:
296: if (rt != rt0)
297: *rt_free = rt;
298: return rt;
299:
300: reject:
301: /* Discard temporary rte */
302: if (rt != rt0)
303: rte_free(rt);
304: return NULL;
305: }
306:
307: static inline rte *
308: export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, int silent)
309: {
310: return export_filter_(ah, rt0, rt_free, tmpa, rte_update_pool, silent);
311: }
312:
313: static void
314: do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tmpa, int refeed)
315: {
316: struct proto *p = ah->proto;
317: struct proto_stats *stats = ah->stats;
318:
319:
320: /*
321: * First, apply export limit.
322: *
323: * Export route limits has several problems. Because exp_routes
324: * counter is reset before refeed, we don't really know whether
325: * limit is breached and whether the update is new or not. Therefore
326: * the number of really exported routes may exceed the limit
327: * temporarily (routes exported before and new routes in refeed).
328: *
329: * Minor advantage is that if the limit is decreased and refeed is
330: * requested, the number of exported routes really decrease.
331: *
332: * Second problem is that with export limits, we don't know whether
333: * old was really exported (it might be blocked by limit). When a
334: * withdraw is exported, we announce it even when the previous
335: * update was blocked. This is not a big issue, but the same problem
336: * is in updating exp_routes counter. Therefore, to be consistent in
337: * increases and decreases of exp_routes, we count exported routes
338: * regardless of blocking by limits.
339: *
340: * Similar problem is in handling updates - when a new route is
341: * received and blocking is active, the route would be blocked, but
342: * when an update for the route will be received later, the update
343: * would be propagated (as old != NULL). Therefore, we have to block
344: * also non-new updates (contrary to import blocking).
345: */
346:
347: struct proto_limit *l = ah->out_limit;
348: if (l && new)
349: {
350: if ((!old || refeed) && (stats->exp_routes >= l->limit))
351: proto_notify_limit(ah, l, PLD_OUT, stats->exp_routes);
352:
353: if (l->state == PLS_BLOCKED)
354: {
355: stats->exp_routes++; /* see note above */
356: stats->exp_updates_rejected++;
357: rte_trace_out(D_FILTERS, p, new, "rejected [limit]");
358: new = NULL;
359:
360: if (!old)
361: return;
362: }
363: }
364:
365:
366: if (new)
367: stats->exp_updates_accepted++;
368: else
369: stats->exp_withdraws_accepted++;
370:
371: /* Hack: We do not decrease exp_routes during refeed, we instead
372: reset exp_routes at the start of refeed. */
373: if (new)
374: stats->exp_routes++;
375: if (old && !refeed)
376: stats->exp_routes--;
377:
378: if (p->debug & D_ROUTES)
379: {
380: if (new && old)
381: rte_trace_out(D_ROUTES, p, new, "replaced");
382: else if (new)
383: rte_trace_out(D_ROUTES, p, new, "added");
384: else if (old)
385: rte_trace_out(D_ROUTES, p, old, "removed");
386: }
387: if (!new)
388: p->rt_notify(p, ah->table, net, NULL, old, NULL);
389: else if (tmpa)
390: {
391: ea_list *t = tmpa;
392: while (t->next)
393: t = t->next;
394: t->next = new->attrs->eattrs;
395: p->rt_notify(p, ah->table, net, new, old, tmpa);
396: t->next = NULL;
397: }
398: else
399: p->rt_notify(p, ah->table, net, new, old, new->attrs->eattrs);
400: }
401:
402: static void
403: rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int refeed)
404: {
405: struct proto *p = ah->proto;
406: struct proto_stats *stats = ah->stats;
407:
408: rte *new = new0;
409: rte *old = old0;
410: rte *new_free = NULL;
411: rte *old_free = NULL;
412: ea_list *tmpa = NULL;
413:
414: if (new)
415: stats->exp_updates_received++;
416: else
417: stats->exp_withdraws_received++;
418:
419: /*
420: * This is a tricky part - we don't know whether route 'old' was
421: * exported to protocol 'p' or was filtered by the export filter.
422: * We try to run the export filter to know this to have a correct
423: * value in 'old' argument of rte_update (and proper filter value)
424: *
425: * FIXME - this is broken because 'configure soft' may change
426: * filters but keep routes. Refeed is expected to be called after
427: * change of the filters and with old == new, therefore we do not
428: * even try to run the filter on an old route, This may lead to
429: * 'spurious withdraws' but ensure that there are no 'missing
430: * withdraws'.
431: *
432: * This is not completely safe as there is a window between
433: * reconfiguration and the end of refeed - if a newly filtered
434: * route disappears during this period, proper withdraw is not
435: * sent (because old would be also filtered) and the route is
436: * not refeeded (because it disappeared before that).
437: */
438:
439: if (new)
440: new = export_filter(ah, new, &new_free, &tmpa, 0);
441:
442: if (old && !refeed)
443: old = export_filter(ah, old, &old_free, NULL, 1);
444:
445: if (!new && !old)
446: {
447: /*
448: * As mentioned above, 'old' value may be incorrect in some race conditions.
449: * We generally ignore it with the exception of withdraw to pipe protocol.
450: * In that case we rather propagate unfiltered withdraws regardless of
451: * export filters to ensure that when a protocol is flushed, its routes are
452: * removed from all tables. Possible spurious unfiltered withdraws are not
453: * problem here as they are ignored if there is no corresponding route at
454: * the other end of the pipe. We directly call rt_notify() hook instead of
455: * do_rt_notify() to avoid logging and stat counters.
456: */
457:
458: #ifdef CONFIG_PIPE
459: if ((p->proto == &proto_pipe) && !new0 && (p != old0->sender->proto))
460: p->rt_notify(p, ah->table, net, NULL, old0, NULL);
461: #endif
462:
463: return;
464: }
465:
466: do_rt_notify(ah, net, new, old, tmpa, refeed);
467:
468: /* Discard temporary rte's */
469: if (new_free)
470: rte_free(new_free);
471: if (old_free)
472: rte_free(old_free);
473: }
474:
475: static void
476: rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed, rte *before_old, int feed)
477: {
478: // struct proto *p = ah->proto;
479: struct proto_stats *stats = ah->stats;
480:
481: rte *r;
482: rte *new_best = NULL;
483: rte *old_best = NULL;
484: rte *new_free = NULL;
485: rte *old_free = NULL;
486: ea_list *tmpa = NULL;
487:
488: /* Used to track whether we met old_changed position. If before_old is NULL
489: old_changed was the first and we met it implicitly before current best route. */
490: int old_meet = old_changed && !before_old;
491:
492: /* Note that before_old is either NULL or valid (not rejected) route.
493: If old_changed is valid, before_old have to be too. If old changed route
494: was not valid, caller must use NULL for both old_changed and before_old. */
495:
496: if (new_changed)
497: stats->exp_updates_received++;
498: else
499: stats->exp_withdraws_received++;
500:
501: /* First, find the new_best route - first accepted by filters */
502: for (r=net->routes; rte_is_valid(r); r=r->next)
503: {
504: if (new_best = export_filter(ah, r, &new_free, &tmpa, 0))
505: break;
506:
507: /* Note if we walked around the position of old_changed route */
508: if (r == before_old)
509: old_meet = 1;
510: }
511:
512: /*
513: * Second, handle the feed case. That means we do not care for
514: * old_best. It is NULL for feed, and the new_best for refeed.
515: * For refeed, there is a hack similar to one in rt_notify_basic()
516: * to ensure withdraws in case of changed filters
517: */
518: if (feed)
519: {
520: if (feed == 2) /* refeed */
521: old_best = new_best ? new_best :
522: (rte_is_valid(net->routes) ? net->routes : NULL);
523: else
524: old_best = NULL;
525:
526: if (!new_best && !old_best)
527: return;
528:
529: goto found;
530: }
531:
532: /*
533: * Now, we find the old_best route. Generally, it is the same as the
534: * new_best, unless new_best is the same as new_changed or
535: * old_changed is accepted before new_best.
536: *
537: * There are four cases:
538: *
539: * - We would find and accept old_changed before new_best, therefore
540: * old_changed is old_best. In remaining cases we suppose this
541: * is not true.
542: *
543: * - We found no new_best, therefore there is also no old_best and
544: * we ignore this withdraw.
545: *
546: * - We found new_best different than new_changed, therefore
547: * old_best is the same as new_best and we ignore this update.
548: *
549: * - We found new_best the same as new_changed, therefore it cannot
550: * be old_best and we have to continue search for old_best.
551: */
552:
553: /* First case */
554: if (old_meet)
555: if (old_best = export_filter(ah, old_changed, &old_free, NULL, 1))
556: goto found;
557:
558: /* Second case */
559: if (!new_best)
560: return;
561:
562: /* Third case, we use r instead of new_best, because export_filter() could change it */
563: if (r != new_changed)
564: {
565: if (new_free)
566: rte_free(new_free);
567: return;
568: }
569:
570: /* Fourth case */
571: for (r=r->next; rte_is_valid(r); r=r->next)
572: {
573: if (old_best = export_filter(ah, r, &old_free, NULL, 1))
574: goto found;
575:
576: if (r == before_old)
577: if (old_best = export_filter(ah, old_changed, &old_free, NULL, 1))
578: goto found;
579: }
580:
581: /* Implicitly, old_best is NULL and new_best is non-NULL */
582:
583: found:
584: do_rt_notify(ah, net, new_best, old_best, tmpa, (feed == 2));
585:
586: /* Discard temporary rte's */
587: if (new_free)
588: rte_free(new_free);
589: if (old_free)
590: rte_free(old_free);
591: }
592:
593:
594: static struct mpnh *
595: mpnh_merge_rta(struct mpnh *nhs, rta *a, linpool *pool, int max)
596: {
597: struct mpnh nh = { .gw = a->gw, .iface = a->iface };
598: struct mpnh *nh2 = (a->dest == RTD_MULTIPATH) ? a->nexthops : &nh;
599: return mpnh_merge(nhs, nh2, 1, 0, max, pool);
600: }
601:
602: rte *
603: rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tmpa, linpool *pool, int silent)
604: {
605: // struct proto *p = ah->proto;
606: struct mpnh *nhs = NULL;
607: rte *best0, *best, *rt0, *rt, *tmp;
608:
609: best0 = net->routes;
610: *rt_free = NULL;
611:
612: if (!rte_is_valid(best0))
613: return NULL;
614:
615: best = export_filter_(ah, best0, rt_free, tmpa, pool, silent);
616:
617: if (!best || !rte_is_reachable(best))
618: return best;
619:
620: for (rt0 = best0->next; rt0; rt0 = rt0->next)
621: {
622: if (!rte_mergable(best0, rt0))
623: continue;
624:
625: rt = export_filter_(ah, rt0, &tmp, NULL, pool, 1);
626:
627: if (!rt)
628: continue;
629:
630: if (rte_is_reachable(rt))
631: nhs = mpnh_merge_rta(nhs, rt->attrs, pool, ah->proto->merge_limit);
632:
633: if (tmp)
634: rte_free(tmp);
635: }
636:
637: if (nhs)
638: {
639: nhs = mpnh_merge_rta(nhs, best->attrs, pool, ah->proto->merge_limit);
640:
641: if (nhs->next)
642: {
643: best = rte_cow_rta(best, pool);
644: best->attrs->dest = RTD_MULTIPATH;
645: best->attrs->nexthops = nhs;
646: }
647: }
648:
649: if (best != best0)
650: *rt_free = best;
651:
652: return best;
653: }
654:
655:
656: static void
657: rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed,
658: rte *new_best, rte*old_best, int refeed)
659: {
660: // struct proto *p = ah->proto;
661:
662: rte *new_best_free = NULL;
663: rte *old_best_free = NULL;
664: rte *new_changed_free = NULL;
665: rte *old_changed_free = NULL;
666: ea_list *tmpa = NULL;
667:
668: /* We assume that all rte arguments are either NULL or rte_is_valid() */
669:
670: /* This check should be done by the caller */
671: if (!new_best && !old_best)
672: return;
673:
674: /* Check whether the change is relevant to the merged route */
675: if ((new_best == old_best) && !refeed)
676: {
677: new_changed = rte_mergable(new_best, new_changed) ?
678: export_filter(ah, new_changed, &new_changed_free, NULL, 1) : NULL;
679:
680: old_changed = rte_mergable(old_best, old_changed) ?
681: export_filter(ah, old_changed, &old_changed_free, NULL, 1) : NULL;
682:
683: if (!new_changed && !old_changed)
684: return;
685: }
686:
687: if (new_best)
688: ah->stats->exp_updates_received++;
689: else
690: ah->stats->exp_withdraws_received++;
691:
692: /* Prepare new merged route */
693: if (new_best)
694: new_best = rt_export_merged(ah, net, &new_best_free, &tmpa, rte_update_pool, 0);
695:
696: /* Prepare old merged route (without proper merged next hops) */
697: /* There are some issues with running filter on old route - see rt_notify_basic() */
698: if (old_best && !refeed)
699: old_best = export_filter(ah, old_best, &old_best_free, NULL, 1);
700:
701: if (new_best || old_best)
702: do_rt_notify(ah, net, new_best, old_best, tmpa, refeed);
703:
704: /* Discard temporary rte's */
705: if (new_best_free)
706: rte_free(new_best_free);
707: if (old_best_free)
708: rte_free(old_best_free);
709: if (new_changed_free)
710: rte_free(new_changed_free);
711: if (old_changed_free)
712: rte_free(old_changed_free);
713: }
714:
715:
716: /**
717: * rte_announce - announce a routing table change
718: * @tab: table the route has been added to
719: * @type: type of route announcement (RA_OPTIMAL or RA_ANY)
720: * @net: network in question
721: * @new: the new route to be announced
722: * @old: the previous route for the same network
723: * @new_best: the new best route for the same network
724: * @old_best: the previous best route for the same network
725: * @before_old: The previous route before @old for the same network.
726: * If @before_old is NULL @old was the first.
727: *
728: * This function gets a routing table update and announces it
729: * to all protocols that acccepts given type of route announcement
730: * and are connected to the same table by their announcement hooks.
731: *
732: * Route announcement of type %RA_OPTIMAL si generated when optimal
733: * route (in routing table @tab) changes. In that case @old stores the
734: * old optimal route.
735: *
736: * Route announcement of type %RA_ANY si generated when any route (in
737: * routing table @tab) changes In that case @old stores the old route
738: * from the same protocol.
739: *
740: * For each appropriate protocol, we first call its import_control()
741: * hook which performs basic checks on the route (each protocol has a
742: * right to veto or force accept of the route before any filter is
743: * asked) and adds default values of attributes specific to the new
744: * protocol (metrics, tags etc.). Then it consults the protocol's
745: * export filter and if it accepts the route, the rt_notify() hook of
746: * the protocol gets called.
747: */
748: static void
749: rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old,
750: rte *new_best, rte *old_best, rte *before_old)
751: {
752: if (!rte_is_valid(new))
753: new = NULL;
754:
755: if (!rte_is_valid(old))
756: old = before_old = NULL;
757:
758: if (!rte_is_valid(new_best))
759: new_best = NULL;
760:
761: if (!rte_is_valid(old_best))
762: old_best = NULL;
763:
764: if (!old && !new)
765: return;
766:
767: if (type == RA_OPTIMAL)
768: {
769: if (new)
770: new->attrs->src->proto->stats.pref_routes++;
771: if (old)
772: old->attrs->src->proto->stats.pref_routes--;
773:
774: if (tab->hostcache)
775: rt_notify_hostcache(tab, net);
776: }
777:
778: struct announce_hook *a;
779: WALK_LIST(a, tab->hooks)
780: {
781: ASSERT(a->proto->export_state != ES_DOWN);
782: if (a->proto->accept_ra_types == type)
783: if (type == RA_ACCEPTED)
784: rt_notify_accepted(a, net, new, old, before_old, 0);
785: else if (type == RA_MERGED)
786: rt_notify_merged(a, net, new, old, new_best, old_best, 0);
787: else
788: rt_notify_basic(a, net, new, old, 0);
789: }
790: }
791:
792: static inline int
793: rte_validate(rte *e)
794: {
795: int c;
796: net *n = e->net;
797:
798: if ((n->n.pxlen > BITS_PER_IP_ADDRESS) || !ip_is_prefix(n->n.prefix,n->n.pxlen))
799: {
800: log(L_WARN "Ignoring bogus prefix %I/%d received via %s",
801: n->n.prefix, n->n.pxlen, e->sender->proto->name);
802: return 0;
803: }
804:
805: c = ipa_classify_net(n->n.prefix);
806: if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
807: {
808: log(L_WARN "Ignoring bogus route %I/%d received via %s",
809: n->n.prefix, n->n.pxlen, e->sender->proto->name);
810: return 0;
811: }
812:
813: if ((e->attrs->dest == RTD_MULTIPATH) && !mpnh_is_sorted(e->attrs->nexthops))
814: {
815: log(L_WARN "Ignoring unsorted multipath route %I/%d received via %s",
816: n->n.prefix, n->n.pxlen, e->sender->proto->name);
817: return 0;
818: }
819:
820: return 1;
821: }
822:
823: /**
824: * rte_free - delete a &rte
825: * @e: &rte to be deleted
826: *
827: * rte_free() deletes the given &rte from the routing table it's linked to.
828: */
829: void
830: rte_free(rte *e)
831: {
832: if (rta_is_cached(e->attrs))
833: rta_free(e->attrs);
834: sl_free(rte_slab, e);
835: }
836:
837: static inline void
838: rte_free_quick(rte *e)
839: {
840: rta_free(e->attrs);
841: sl_free(rte_slab, e);
842: }
843:
844: static int
845: rte_same(rte *x, rte *y)
846: {
847: return
848: x->attrs == y->attrs &&
849: x->flags == y->flags &&
850: x->pflags == y->pflags &&
851: x->pref == y->pref &&
852: (!x->attrs->src->proto->rte_same || x->attrs->src->proto->rte_same(x, y));
853: }
854:
855: static inline int rte_is_ok(rte *e) { return e && !rte_is_filtered(e); }
856:
857: static void
858: rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
859: {
860: struct proto *p = ah->proto;
861: struct rtable *table = ah->table;
862: struct proto_stats *stats = ah->stats;
863: static struct tbf rl_pipe = TBF_DEFAULT_LOG_LIMITS;
864: rte *before_old = NULL;
865: rte *old_best = net->routes;
866: rte *old = NULL;
867: rte **k;
868:
869: k = &net->routes; /* Find and remove original route from the same protocol */
870: while (old = *k)
871: {
872: if (old->attrs->src == src)
873: {
874: /* If there is the same route in the routing table but from
875: * a different sender, then there are two paths from the
876: * source protocol to this routing table through transparent
877: * pipes, which is not allowed.
878: *
879: * We log that and ignore the route. If it is withdraw, we
880: * ignore it completely (there might be 'spurious withdraws',
881: * see FIXME in do_rte_announce())
882: */
883: if (old->sender->proto != p)
884: {
885: if (new)
886: {
887: log_rl(&rl_pipe, L_ERR "Pipe collision detected when sending %I/%d to table %s",
888: net->n.prefix, net->n.pxlen, table->name);
889: rte_free_quick(new);
890: }
891: return;
892: }
893:
894: if (new && rte_same(old, new))
895: {
896: /* No changes, ignore the new route */
897:
898: if (!rte_is_filtered(new))
899: {
900: stats->imp_updates_ignored++;
901: rte_trace_in(D_ROUTES, p, new, "ignored");
902: }
903:
904: rte_free_quick(new);
905: return;
906: }
907: *k = old->next;
908: break;
909: }
910: k = &old->next;
911: before_old = old;
912: }
913:
914: if (!old)
915: before_old = NULL;
916:
917: if (!old && !new)
918: {
919: stats->imp_withdraws_ignored++;
920: return;
921: }
922:
923: int new_ok = rte_is_ok(new);
924: int old_ok = rte_is_ok(old);
925:
926: struct proto_limit *l = ah->rx_limit;
927: if (l && !old && new)
928: {
929: u32 all_routes = stats->imp_routes + stats->filt_routes;
930:
931: if (all_routes >= l->limit)
932: proto_notify_limit(ah, l, PLD_RX, all_routes);
933:
934: if (l->state == PLS_BLOCKED)
935: {
936: /* In receive limit the situation is simple, old is NULL so
937: we just free new and exit like nothing happened */
938:
939: stats->imp_updates_ignored++;
940: rte_trace_in(D_FILTERS, p, new, "ignored [limit]");
941: rte_free_quick(new);
942: return;
943: }
944: }
945:
946: l = ah->in_limit;
947: if (l && !old_ok && new_ok)
948: {
949: if (stats->imp_routes >= l->limit)
950: proto_notify_limit(ah, l, PLD_IN, stats->imp_routes);
951:
952: if (l->state == PLS_BLOCKED)
953: {
954: /* In import limit the situation is more complicated. We
955: shouldn't just drop the route, we should handle it like
956: it was filtered. We also have to continue the route
957: processing if old or new is non-NULL, but we should exit
958: if both are NULL as this case is probably assumed to be
959: already handled. */
960:
961: stats->imp_updates_ignored++;
962: rte_trace_in(D_FILTERS, p, new, "ignored [limit]");
963:
964: if (ah->in_keep_filtered)
965: new->flags |= REF_FILTERED;
966: else
967: { rte_free_quick(new); new = NULL; }
968:
969: /* Note that old && !new could be possible when
970: ah->in_keep_filtered changed in the recent past. */
971:
972: if (!old && !new)
973: return;
974:
975: new_ok = 0;
976: goto skip_stats1;
977: }
978: }
979:
980: if (new_ok)
981: stats->imp_updates_accepted++;
982: else if (old_ok)
983: stats->imp_withdraws_accepted++;
984: else
985: stats->imp_withdraws_ignored++;
986:
987: skip_stats1:
988:
989: if (new)
990: rte_is_filtered(new) ? stats->filt_routes++ : stats->imp_routes++;
991: if (old)
992: rte_is_filtered(old) ? stats->filt_routes-- : stats->imp_routes--;
993:
994: if (table->config->sorted)
995: {
996: /* If routes are sorted, just insert new route to appropriate position */
997: if (new)
998: {
999: if (before_old && !rte_better(new, before_old))
1000: k = &before_old->next;
1001: else
1002: k = &net->routes;
1003:
1004: for (; *k; k=&(*k)->next)
1005: if (rte_better(new, *k))
1006: break;
1007:
1008: new->next = *k;
1009: *k = new;
1010: }
1011: }
1012: else
1013: {
1014: /* If routes are not sorted, find the best route and move it on
1015: the first position. There are several optimized cases. */
1016:
1017: if (src->proto->rte_recalculate && src->proto->rte_recalculate(table, net, new, old, old_best))
1018: goto do_recalculate;
1019:
1020: if (new && rte_better(new, old_best))
1021: {
1022: /* The first case - the new route is cleary optimal,
1023: we link it at the first position */
1024:
1025: new->next = net->routes;
1026: net->routes = new;
1027: }
1028: else if (old == old_best)
1029: {
1030: /* The second case - the old best route disappeared, we add the
1031: new route (if we have any) to the list (we don't care about
1032: position) and then we elect the new optimal route and relink
1033: that route at the first position and announce it. New optimal
1034: route might be NULL if there is no more routes */
1035:
1036: do_recalculate:
1037: /* Add the new route to the list */
1038: if (new)
1039: {
1040: new->next = net->routes;
1041: net->routes = new;
1042: }
1043:
1044: /* Find a new optimal route (if there is any) */
1045: if (net->routes)
1046: {
1047: rte **bp = &net->routes;
1048: for (k=&(*bp)->next; *k; k=&(*k)->next)
1049: if (rte_better(*k, *bp))
1050: bp = k;
1051:
1052: /* And relink it */
1053: rte *best = *bp;
1054: *bp = best->next;
1055: best->next = net->routes;
1056: net->routes = best;
1057: }
1058: }
1059: else if (new)
1060: {
1061: /* The third case - the new route is not better than the old
1062: best route (therefore old_best != NULL) and the old best
1063: route was not removed (therefore old_best == net->routes).
1064: We just link the new route after the old best route. */
1065:
1066: ASSERT(net->routes != NULL);
1067: new->next = net->routes->next;
1068: net->routes->next = new;
1069: }
1070: /* The fourth (empty) case - suboptimal route was removed, nothing to do */
1071: }
1072:
1073: if (new)
1074: new->lastmod = now;
1075:
1076: /* Log the route change */
1077: if (p->debug & D_ROUTES)
1078: {
1079: if (new_ok)
1080: rte_trace(p, new, '>', new == net->routes ? "added [best]" : "added");
1081: else if (old_ok)
1082: {
1083: if (old != old_best)
1084: rte_trace(p, old, '>', "removed");
1085: else if (rte_is_ok(net->routes))
1086: rte_trace(p, old, '>', "removed [replaced]");
1087: else
1088: rte_trace(p, old, '>', "removed [sole]");
1089: }
1090: }
1091:
1092: /* Propagate the route change */
1093: rte_announce(table, RA_ANY, net, new, old, NULL, NULL, NULL);
1094: if (net->routes != old_best)
1095: rte_announce(table, RA_OPTIMAL, net, net->routes, old_best, NULL, NULL, NULL);
1096: if (table->config->sorted)
1097: rte_announce(table, RA_ACCEPTED, net, new, old, NULL, NULL, before_old);
1098: rte_announce(table, RA_MERGED, net, new, old, net->routes, old_best, NULL);
1099:
1100: if (!net->routes &&
1101: (table->gc_counter++ >= table->config->gc_max_ops) &&
1102: (table->gc_time + table->config->gc_min_time <= now))
1103: rt_schedule_gc(table);
1104:
1105: if (old_ok && p->rte_remove)
1106: p->rte_remove(net, old);
1107: if (new_ok && p->rte_insert)
1108: p->rte_insert(net, new);
1109:
1110: if (old)
1111: rte_free_quick(old);
1112: }
1113:
1114: static int rte_update_nest_cnt; /* Nesting counter to allow recursive updates */
1115:
1116: static inline void
1117: rte_update_lock(void)
1118: {
1119: rte_update_nest_cnt++;
1120: }
1121:
1122: static inline void
1123: rte_update_unlock(void)
1124: {
1125: if (!--rte_update_nest_cnt)
1126: lp_flush(rte_update_pool);
1127: }
1128:
1129: static inline void
1130: rte_hide_dummy_routes(net *net, rte **dummy)
1131: {
1132: if (net->routes && net->routes->attrs->source == RTS_DUMMY)
1133: {
1134: *dummy = net->routes;
1135: net->routes = (*dummy)->next;
1136: }
1137: }
1138:
1139: static inline void
1140: rte_unhide_dummy_routes(net *net, rte **dummy)
1141: {
1142: if (*dummy)
1143: {
1144: (*dummy)->next = net->routes;
1145: net->routes = *dummy;
1146: }
1147: }
1148:
1149: /**
1150: * rte_update - enter a new update to a routing table
1151: * @table: table to be updated
1152: * @ah: pointer to table announce hook
1153: * @net: network node
1154: * @p: protocol submitting the update
1155: * @src: protocol originating the update
1156: * @new: a &rte representing the new route or %NULL for route removal.
1157: *
1158: * This function is called by the routing protocols whenever they discover
1159: * a new route or wish to update/remove an existing route. The right announcement
1160: * sequence is to build route attributes first (either un-cached with @aflags set
1161: * to zero or a cached one using rta_lookup(); in this case please note that
1162: * you need to increase the use count of the attributes yourself by calling
1163: * rta_clone()), call rte_get_temp() to obtain a temporary &rte, fill in all
1164: * the appropriate data and finally submit the new &rte by calling rte_update().
1165: *
1166: * @src specifies the protocol that originally created the route and the meaning
1167: * of protocol-dependent data of @new. If @new is not %NULL, @src have to be the
1168: * same value as @new->attrs->proto. @p specifies the protocol that called
1169: * rte_update(). In most cases it is the same protocol as @src. rte_update()
1170: * stores @p in @new->sender;
1171: *
1172: * When rte_update() gets any route, it automatically validates it (checks,
1173: * whether the network and next hop address are valid IP addresses and also
1174: * whether a normal routing protocol doesn't try to smuggle a host or link
1175: * scope route to the table), converts all protocol dependent attributes stored
1176: * in the &rte to temporary extended attributes, consults import filters of the
1177: * protocol to see if the route should be accepted and/or its attributes modified,
1178: * stores the temporary attributes back to the &rte.
1179: *
1180: * Now, having a "public" version of the route, we
1181: * automatically find any old route defined by the protocol @src
1182: * for network @n, replace it by the new one (or removing it if @new is %NULL),
1183: * recalculate the optimal route for this destination and finally broadcast
1184: * the change (if any) to all routing protocols by calling rte_announce().
1185: *
1186: * All memory used for attribute lists and other temporary allocations is taken
1187: * from a special linear pool @rte_update_pool and freed when rte_update()
1188: * finishes.
1189: */
1190:
1191: void
1192: rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
1193: {
1194: struct proto *p = ah->proto;
1195: struct proto_stats *stats = ah->stats;
1196: struct filter *filter = ah->in_filter;
1197: ea_list *tmpa = NULL;
1198: rte *dummy = NULL;
1199:
1200: rte_update_lock();
1201: if (new)
1202: {
1203: new->sender = ah;
1204:
1205: stats->imp_updates_received++;
1206: if (!rte_validate(new))
1207: {
1208: rte_trace_in(D_FILTERS, p, new, "invalid");
1209: stats->imp_updates_invalid++;
1210: goto drop;
1211: }
1212:
1213: if (filter == FILTER_REJECT)
1214: {
1215: stats->imp_updates_filtered++;
1216: rte_trace_in(D_FILTERS, p, new, "filtered out");
1217:
1218: if (! ah->in_keep_filtered)
1219: goto drop;
1220:
1221: /* new is a private copy, i could modify it */
1222: new->flags |= REF_FILTERED;
1223: }
1224: else
1225: {
1226: tmpa = make_tmp_attrs(new, rte_update_pool);
1227: if (filter && (filter != FILTER_REJECT))
1228: {
1229: ea_list *old_tmpa = tmpa;
1230: int fr = f_run(filter, &new, &tmpa, rte_update_pool, 0);
1231: if (fr > F_ACCEPT)
1232: {
1233: stats->imp_updates_filtered++;
1234: rte_trace_in(D_FILTERS, p, new, "filtered out");
1235:
1236: if (! ah->in_keep_filtered)
1237: goto drop;
1238:
1239: new->flags |= REF_FILTERED;
1240: }
1241: if (tmpa != old_tmpa && src->proto->store_tmp_attrs)
1242: src->proto->store_tmp_attrs(new, tmpa);
1243: }
1244: }
1245: if (!rta_is_cached(new->attrs)) /* Need to copy attributes */
1246: new->attrs = rta_lookup(new->attrs);
1247: new->flags |= REF_COW;
1248: }
1249: else
1250: {
1251: stats->imp_withdraws_received++;
1252:
1253: if (!net || !src)
1254: {
1255: stats->imp_withdraws_ignored++;
1256: rte_update_unlock();
1257: return;
1258: }
1259: }
1260:
1261: recalc:
1262: rte_hide_dummy_routes(net, &dummy);
1263: rte_recalculate(ah, net, new, src);
1264: rte_unhide_dummy_routes(net, &dummy);
1265: rte_update_unlock();
1266: return;
1267:
1268: drop:
1269: rte_free(new);
1270: new = NULL;
1271: goto recalc;
1272: }
1273:
1274: /* Independent call to rte_announce(), used from next hop
1275: recalculation, outside of rte_update(). new must be non-NULL */
1276: static inline void
1277: rte_announce_i(rtable *tab, unsigned type, net *net, rte *new, rte *old,
1278: rte *new_best, rte *old_best)
1279: {
1280: rte_update_lock();
1281: rte_announce(tab, type, net, new, old, new_best, old_best, NULL);
1282: rte_update_unlock();
1283: }
1284:
1285: static inline void
1286: rte_discard(rte *old) /* Non-filtered route deletion, used during garbage collection */
1287: {
1288: rte_update_lock();
1289: rte_recalculate(old->sender, old->net, NULL, old->attrs->src);
1290: rte_update_unlock();
1291: }
1292:
1293: /* Check rtable for best route to given net whether it would be exported do p */
1294: int
1295: rt_examine(rtable *t, ip_addr prefix, int pxlen, struct proto *p, struct filter *filter)
1296: {
1297: net *n = net_find(t, prefix, pxlen);
1298: rte *rt = n ? n->routes : NULL;
1299:
1300: if (!rte_is_valid(rt))
1301: return 0;
1302:
1303: rte_update_lock();
1304:
1305: /* Rest is stripped down export_filter() */
1306: ea_list *tmpa = make_tmp_attrs(rt, rte_update_pool);
1307: int v = p->import_control ? p->import_control(p, &rt, &tmpa, rte_update_pool) : 0;
1308: if (v == RIC_PROCESS)
1309: v = (f_run(filter, &rt, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) <= F_ACCEPT);
1310:
1311: /* Discard temporary rte */
1312: if (rt != n->routes)
1313: rte_free(rt);
1314:
1315: rte_update_unlock();
1316:
1317: return v > 0;
1318: }
1319:
1320:
1321: /**
1322: * rt_refresh_begin - start a refresh cycle
1323: * @t: related routing table
1324: * @ah: related announce hook
1325: *
1326: * This function starts a refresh cycle for given routing table and announce
1327: * hook. The refresh cycle is a sequence where the protocol sends all its valid
1328: * routes to the routing table (by rte_update()). After that, all protocol
1329: * routes (more precisely routes with @ah as @sender) not sent during the
1330: * refresh cycle but still in the table from the past are pruned. This is
1331: * implemented by marking all related routes as stale by REF_STALE flag in
1332: * rt_refresh_begin(), then marking all related stale routes with REF_DISCARD
1333: * flag in rt_refresh_end() and then removing such routes in the prune loop.
1334: */
1335: void
1336: rt_refresh_begin(rtable *t, struct announce_hook *ah)
1337: {
1338: net *n;
1339: rte *e;
1340:
1341: FIB_WALK(&t->fib, fn)
1342: {
1343: n = (net *) fn;
1344: for (e = n->routes; e; e = e->next)
1345: if (e->sender == ah)
1346: e->flags |= REF_STALE;
1347: }
1348: FIB_WALK_END;
1349: }
1350:
1351: /**
1352: * rt_refresh_end - end a refresh cycle
1353: * @t: related routing table
1354: * @ah: related announce hook
1355: *
1356: * This function starts a refresh cycle for given routing table and announce
1357: * hook. See rt_refresh_begin() for description of refresh cycles.
1358: */
1359: void
1360: rt_refresh_end(rtable *t, struct announce_hook *ah)
1361: {
1362: int prune = 0;
1363: net *n;
1364: rte *e;
1365:
1366: FIB_WALK(&t->fib, fn)
1367: {
1368: n = (net *) fn;
1369: for (e = n->routes; e; e = e->next)
1370: if ((e->sender == ah) && (e->flags & REF_STALE))
1371: {
1372: e->flags |= REF_DISCARD;
1373: prune = 1;
1374: }
1375: }
1376: FIB_WALK_END;
1377:
1378: if (prune)
1379: rt_schedule_prune(t);
1380: }
1381:
1382:
1383: /**
1384: * rte_dump - dump a route
1385: * @e: &rte to be dumped
1386: *
1387: * This functions dumps contents of a &rte to debug output.
1388: */
1389: void
1390: rte_dump(rte *e)
1391: {
1392: net *n = e->net;
1393: debug("%-1I/%2d ", n->n.prefix, n->n.pxlen);
1394: debug("KF=%02x PF=%02x pref=%d lm=%d ", n->n.flags, e->pflags, e->pref, now-e->lastmod);
1395: rta_dump(e->attrs);
1396: if (e->attrs->src->proto->proto->dump_attrs)
1397: e->attrs->src->proto->proto->dump_attrs(e);
1398: debug("\n");
1399: }
1400:
1401: /**
1402: * rt_dump - dump a routing table
1403: * @t: routing table to be dumped
1404: *
1405: * This function dumps contents of a given routing table to debug output.
1406: */
1407: void
1408: rt_dump(rtable *t)
1409: {
1410: rte *e;
1411: net *n;
1412: struct announce_hook *a;
1413:
1414: debug("Dump of routing table <%s>\n", t->name);
1415: #ifdef DEBUGGING
1416: fib_check(&t->fib);
1417: #endif
1418: FIB_WALK(&t->fib, fn)
1419: {
1420: n = (net *) fn;
1421: for(e=n->routes; e; e=e->next)
1422: rte_dump(e);
1423: }
1424: FIB_WALK_END;
1425: WALK_LIST(a, t->hooks)
1426: debug("\tAnnounces routes to protocol %s\n", a->proto->name);
1427: debug("\n");
1428: }
1429:
1430: /**
1431: * rt_dump_all - dump all routing tables
1432: *
1433: * This function dumps contents of all routing tables to debug output.
1434: */
1435: void
1436: rt_dump_all(void)
1437: {
1438: rtable *t;
1439:
1440: WALK_LIST(t, routing_tables)
1441: rt_dump(t);
1442: }
1443:
1444: static inline void
1445: rt_schedule_prune(rtable *tab)
1446: {
1447: rt_mark_for_prune(tab);
1448: ev_schedule(tab->rt_event);
1449: }
1450:
1451: static inline void
1452: rt_schedule_gc(rtable *tab)
1453: {
1454: if (tab->gc_scheduled)
1455: return;
1456:
1457: tab->gc_scheduled = 1;
1458: ev_schedule(tab->rt_event);
1459: }
1460:
1461: static inline void
1462: rt_schedule_hcu(rtable *tab)
1463: {
1464: if (tab->hcu_scheduled)
1465: return;
1466:
1467: tab->hcu_scheduled = 1;
1468: ev_schedule(tab->rt_event);
1469: }
1470:
1471: static inline void
1472: rt_schedule_nhu(rtable *tab)
1473: {
1474: if (tab->nhu_state == 0)
1475: ev_schedule(tab->rt_event);
1476:
1477: /* state change 0->1, 2->3 */
1478: tab->nhu_state |= 1;
1479: }
1480:
1481:
1482: static void
1483: rt_prune_nets(rtable *tab)
1484: {
1485: struct fib_iterator fit;
1486: int ncnt = 0, ndel = 0;
1487:
1488: #ifdef DEBUGGING
1489: fib_check(&tab->fib);
1490: #endif
1491:
1492: FIB_ITERATE_INIT(&fit, &tab->fib);
1493: again:
1494: FIB_ITERATE_START(&tab->fib, &fit, f)
1495: {
1496: net *n = (net *) f;
1497: ncnt++;
1498: if (!n->routes) /* Orphaned FIB entry */
1499: {
1500: FIB_ITERATE_PUT(&fit, f);
1501: fib_delete(&tab->fib, f);
1502: ndel++;
1503: goto again;
1504: }
1505: }
1506: FIB_ITERATE_END(f);
1507: DBG("Pruned %d of %d networks\n", ndel, ncnt);
1508:
1509: tab->gc_counter = 0;
1510: tab->gc_time = now;
1511: tab->gc_scheduled = 0;
1512: }
1513:
1514: static void
1515: rt_event(void *ptr)
1516: {
1517: rtable *tab = ptr;
1518:
1519: if (tab->hcu_scheduled)
1520: rt_update_hostcache(tab);
1521:
1522: if (tab->nhu_state)
1523: rt_next_hop_update(tab);
1524:
1525: if (tab->prune_state)
1526: if (!rt_prune_table(tab))
1527: {
1528: /* Table prune unfinished */
1529: ev_schedule(tab->rt_event);
1530: return;
1531: }
1532:
1533: if (tab->gc_scheduled)
1534: {
1535: rt_prune_nets(tab);
1536: rt_prune_sources(); // FIXME this should be moved to independent event
1537: }
1538: }
1539:
1540: void
1541: rt_setup(pool *p, rtable *t, char *name, struct rtable_config *cf)
1542: {
1543: bzero(t, sizeof(*t));
1544: fib_init(&t->fib, p, sizeof(net), 0, rte_init);
1545: t->name = name;
1546: t->config = cf;
1547: init_list(&t->hooks);
1548: if (cf)
1549: {
1550: t->rt_event = ev_new(p);
1551: t->rt_event->hook = rt_event;
1552: t->rt_event->data = t;
1553: t->gc_time = now;
1554: }
1555: }
1556:
1557: /**
1558: * rt_init - initialize routing tables
1559: *
1560: * This function is called during BIRD startup. It initializes the
1561: * routing table module.
1562: */
1563: void
1564: rt_init(void)
1565: {
1566: rta_init();
1567: rt_table_pool = rp_new(&root_pool, "Routing tables");
1568: rte_update_pool = lp_new(rt_table_pool, 4080);
1569: rte_slab = sl_new(rt_table_pool, sizeof(rte));
1570: init_list(&routing_tables);
1571: }
1572:
1573:
1574: static int
1575: rt_prune_step(rtable *tab, int *limit)
1576: {
1577: struct fib_iterator *fit = &tab->prune_fit;
1578:
1579: DBG("Pruning route table %s\n", tab->name);
1580: #ifdef DEBUGGING
1581: fib_check(&tab->fib);
1582: #endif
1583:
1584: if (tab->prune_state == RPS_NONE)
1585: return 1;
1586:
1587: if (tab->prune_state == RPS_SCHEDULED)
1588: {
1589: FIB_ITERATE_INIT(fit, &tab->fib);
1590: tab->prune_state = RPS_RUNNING;
1591: }
1592:
1593: again:
1594: FIB_ITERATE_START(&tab->fib, fit, fn)
1595: {
1596: net *n = (net *) fn;
1597: rte *e;
1598:
1599: rescan:
1600: for (e=n->routes; e; e=e->next)
1601: if (e->sender->proto->flushing || (e->flags & REF_DISCARD))
1602: {
1603: if (*limit <= 0)
1604: {
1605: FIB_ITERATE_PUT(fit, fn);
1606: return 0;
1607: }
1608:
1609: rte_discard(e);
1610: (*limit)--;
1611:
1612: goto rescan;
1613: }
1614: if (!n->routes) /* Orphaned FIB entry */
1615: {
1616: FIB_ITERATE_PUT(fit, fn);
1617: fib_delete(&tab->fib, fn);
1618: goto again;
1619: }
1620: }
1621: FIB_ITERATE_END(fn);
1622:
1623: #ifdef DEBUGGING
1624: fib_check(&tab->fib);
1625: #endif
1626:
1627: tab->prune_state = RPS_NONE;
1628: return 1;
1629: }
1630:
1631: /**
1632: * rt_prune_table - prune a routing table
1633: * @tab: a routing table for pruning
1634: *
1635: * This function scans the routing table @tab and removes routes belonging to
1636: * flushing protocols, discarded routes and also stale network entries, in a
1637: * similar fashion like rt_prune_loop(). Returns 1 when all such routes are
1638: * pruned. Contrary to rt_prune_loop(), this function is not a part of the
1639: * protocol flushing loop, but it is called from rt_event() for just one routing
1640: * table.
1641: *
1642: * Note that rt_prune_table() and rt_prune_loop() share (for each table) the
1643: * prune state (@prune_state) and also the pruning iterator (@prune_fit).
1644: */
1645: static inline int
1646: rt_prune_table(rtable *tab)
1647: {
1648: int limit = 512;
1649: return rt_prune_step(tab, &limit);
1650: }
1651:
1652: /**
1653: * rt_prune_loop - prune routing tables
1654: *
1655: * The prune loop scans routing tables and removes routes belonging to flushing
1656: * protocols, discarded routes and also stale network entries. Returns 1 when
1657: * all such routes are pruned. It is a part of the protocol flushing loop.
1658: */
1659: int
1660: rt_prune_loop(void)
1661: {
1662: int limit = 512;
1663: rtable *t;
1664:
1665: WALK_LIST(t, routing_tables)
1666: if (! rt_prune_step(t, &limit))
1667: return 0;
1668:
1669: return 1;
1670: }
1671:
1672: void
1673: rt_preconfig(struct config *c)
1674: {
1675: struct symbol *s = cf_get_symbol("master");
1676:
1677: init_list(&c->tables);
1678: c->master_rtc = rt_new_table(s);
1679: }
1680:
1681:
1682: /*
1683: * Some functions for handing internal next hop updates
1684: * triggered by rt_schedule_nhu().
1685: */
1686:
1687: static inline int
1688: rta_next_hop_outdated(rta *a)
1689: {
1690: struct hostentry *he = a->hostentry;
1691:
1692: if (!he)
1693: return 0;
1694:
1695: if (!he->src)
1696: return a->dest != RTD_UNREACHABLE;
1697:
1698: return (a->iface != he->src->iface) || !ipa_equal(a->gw, he->gw) ||
1699: (a->dest != he->dest) || (a->igp_metric != he->igp_metric) ||
1700: !mpnh_same(a->nexthops, he->src->nexthops);
1701: }
1702:
1703: static inline void
1704: rta_apply_hostentry(rta *a, struct hostentry *he)
1705: {
1706: a->hostentry = he;
1707: a->iface = he->src ? he->src->iface : NULL;
1708: a->gw = he->gw;
1709: a->dest = he->dest;
1710: a->igp_metric = he->igp_metric;
1711: a->nexthops = he->src ? he->src->nexthops : NULL;
1712: }
1713:
1714: static inline rte *
1715: rt_next_hop_update_rte(rtable *tab UNUSED, rte *old)
1716: {
1717: rta a;
1718: memcpy(&a, old->attrs, sizeof(rta));
1719: rta_apply_hostentry(&a, old->attrs->hostentry);
1720: a.aflags = 0;
1721:
1722: rte *e = sl_alloc(rte_slab);
1723: memcpy(e, old, sizeof(rte));
1724: e->attrs = rta_lookup(&a);
1725:
1726: return e;
1727: }
1728:
1729: static inline int
1730: rt_next_hop_update_net(rtable *tab, net *n)
1731: {
1732: rte **k, *e, *new, *old_best, **new_best;
1733: int count = 0;
1734: int free_old_best = 0;
1735:
1736: old_best = n->routes;
1737: if (!old_best)
1738: return 0;
1739:
1740: for (k = &n->routes; e = *k; k = &e->next)
1741: if (rta_next_hop_outdated(e->attrs))
1742: {
1743: new = rt_next_hop_update_rte(tab, e);
1744: *k = new;
1745:
1746: rte_announce_i(tab, RA_ANY, n, new, e, NULL, NULL);
1747: rte_trace_in(D_ROUTES, new->sender->proto, new, "updated");
1748:
1749: /* Call a pre-comparison hook */
1750: /* Not really an efficient way to compute this */
1751: if (e->attrs->src->proto->rte_recalculate)
1752: e->attrs->src->proto->rte_recalculate(tab, n, new, e, NULL);
1753:
1754: if (e != old_best)
1755: rte_free_quick(e);
1756: else /* Freeing of the old best rte is postponed */
1757: free_old_best = 1;
1758:
1759: e = new;
1760: count++;
1761: }
1762:
1763: if (!count)
1764: return 0;
1765:
1766: /* Find the new best route */
1767: new_best = NULL;
1768: for (k = &n->routes; e = *k; k = &e->next)
1769: {
1770: if (!new_best || rte_better(e, *new_best))
1771: new_best = k;
1772: }
1773:
1774: /* Relink the new best route to the first position */
1775: new = *new_best;
1776: if (new != n->routes)
1777: {
1778: *new_best = new->next;
1779: new->next = n->routes;
1780: n->routes = new;
1781: }
1782:
1783: /* Announce the new best route */
1784: if (new != old_best)
1785: {
1786: rte_announce_i(tab, RA_OPTIMAL, n, new, old_best, NULL, NULL);
1787: rte_trace_in(D_ROUTES, new->sender->proto, new, "updated [best]");
1788: }
1789:
1790: /* FIXME: Better announcement of merged routes */
1791: rte_announce_i(tab, RA_MERGED, n, new, old_best, new, old_best);
1792:
1793: if (free_old_best)
1794: rte_free_quick(old_best);
1795:
1796: return count;
1797: }
1798:
1799: static void
1800: rt_next_hop_update(rtable *tab)
1801: {
1802: struct fib_iterator *fit = &tab->nhu_fit;
1803: int max_feed = 32;
1804:
1805: if (tab->nhu_state == 0)
1806: return;
1807:
1808: if (tab->nhu_state == 1)
1809: {
1810: FIB_ITERATE_INIT(fit, &tab->fib);
1811: tab->nhu_state = 2;
1812: }
1813:
1814: FIB_ITERATE_START(&tab->fib, fit, fn)
1815: {
1816: if (max_feed <= 0)
1817: {
1818: FIB_ITERATE_PUT(fit, fn);
1819: ev_schedule(tab->rt_event);
1820: return;
1821: }
1822: max_feed -= rt_next_hop_update_net(tab, (net *) fn);
1823: }
1824: FIB_ITERATE_END(fn);
1825:
1826: /* state change 2->0, 3->1 */
1827: tab->nhu_state &= 1;
1828:
1829: if (tab->nhu_state > 0)
1830: ev_schedule(tab->rt_event);
1831: }
1832:
1833:
1834: struct rtable_config *
1835: rt_new_table(struct symbol *s)
1836: {
1837: /* Hack that allows to 'redefine' the master table */
1838: if ((s->class == SYM_TABLE) && (s->def == new_config->master_rtc))
1839: return s->def;
1840:
1841: struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config));
1842:
1843: cf_define_symbol(s, SYM_TABLE, c);
1844: c->name = s->name;
1845: add_tail(&new_config->tables, &c->n);
1846: c->gc_max_ops = 1000;
1847: c->gc_min_time = 5;
1848: return c;
1849: }
1850:
1851: /**
1852: * rt_lock_table - lock a routing table
1853: * @r: routing table to be locked
1854: *
1855: * Lock a routing table, because it's in use by a protocol,
1856: * preventing it from being freed when it gets undefined in a new
1857: * configuration.
1858: */
1859: void
1860: rt_lock_table(rtable *r)
1861: {
1862: r->use_count++;
1863: }
1864:
1865: /**
1866: * rt_unlock_table - unlock a routing table
1867: * @r: routing table to be unlocked
1868: *
1869: * Unlock a routing table formerly locked by rt_lock_table(),
1870: * that is decrease its use count and delete it if it's scheduled
1871: * for deletion by configuration changes.
1872: */
1873: void
1874: rt_unlock_table(rtable *r)
1875: {
1876: if (!--r->use_count && r->deleted)
1877: {
1878: struct config *conf = r->deleted;
1879: DBG("Deleting routing table %s\n", r->name);
1880: r->config->table = NULL;
1881: if (r->hostcache)
1882: rt_free_hostcache(r);
1883: rem_node(&r->n);
1884: fib_free(&r->fib);
1885: rfree(r->rt_event);
1886: mb_free(r);
1887: config_del_obstacle(conf);
1888: }
1889: }
1890:
1891: /**
1892: * rt_commit - commit new routing table configuration
1893: * @new: new configuration
1894: * @old: original configuration or %NULL if it's boot time config
1895: *
1896: * Scan differences between @old and @new configuration and modify
1897: * the routing tables according to these changes. If @new defines a
1898: * previously unknown table, create it, if it omits a table existing
1899: * in @old, schedule it for deletion (it gets deleted when all protocols
1900: * disconnect from it by calling rt_unlock_table()), if it exists
1901: * in both configurations, leave it unchanged.
1902: */
1903: void
1904: rt_commit(struct config *new, struct config *old)
1905: {
1906: struct rtable_config *o, *r;
1907:
1908: DBG("rt_commit:\n");
1909: if (old)
1910: {
1911: WALK_LIST(o, old->tables)
1912: {
1913: rtable *ot = o->table;
1914: if (!ot->deleted)
1915: {
1916: struct symbol *sym = cf_find_symbol(new, o->name);
1917: if (sym && sym->class == SYM_TABLE && !new->shutdown)
1918: {
1919: DBG("\t%s: same\n", o->name);
1920: r = sym->def;
1921: r->table = ot;
1922: ot->name = r->name;
1923: ot->config = r;
1924: if (o->sorted != r->sorted)
1925: log(L_WARN "Reconfiguration of rtable sorted flag not implemented");
1926: }
1927: else
1928: {
1929: DBG("\t%s: deleted\n", o->name);
1930: ot->deleted = old;
1931: config_add_obstacle(old);
1932: rt_lock_table(ot);
1933: rt_unlock_table(ot);
1934: }
1935: }
1936: }
1937: }
1938:
1939: WALK_LIST(r, new->tables)
1940: if (!r->table)
1941: {
1942: rtable *t = mb_alloc(rt_table_pool, sizeof(struct rtable));
1943: DBG("\t%s: created\n", r->name);
1944: rt_setup(rt_table_pool, t, r->name, r);
1945: add_tail(&routing_tables, &t->n);
1946: r->table = t;
1947: }
1948: DBG("\tdone\n");
1949: }
1950:
1951: static inline void
1952: do_feed_baby(struct proto *p, int type, struct announce_hook *h, net *n, rte *e)
1953: {
1954: rte_update_lock();
1955: if (type == RA_ACCEPTED)
1956: rt_notify_accepted(h, n, e, NULL, NULL, p->refeeding ? 2 : 1);
1957: else if (type == RA_MERGED)
1958: rt_notify_merged(h, n, NULL, NULL, e, p->refeeding ? e : NULL, p->refeeding);
1959: else
1960: rt_notify_basic(h, n, e, p->refeeding ? e : NULL, p->refeeding);
1961: rte_update_unlock();
1962: }
1963:
1964: /**
1965: * rt_feed_baby - advertise routes to a new protocol
1966: * @p: protocol to be fed
1967: *
1968: * This function performs one pass of advertisement of routes to a newly
1969: * initialized protocol. It's called by the protocol code as long as it
1970: * has something to do. (We avoid transferring all the routes in single
1971: * pass in order not to monopolize CPU time.)
1972: */
1973: int
1974: rt_feed_baby(struct proto *p)
1975: {
1976: struct announce_hook *h;
1977: struct fib_iterator *fit;
1978: int max_feed = 256;
1979:
1980: if (!p->feed_ahook) /* Need to initialize first */
1981: {
1982: if (!p->ahooks)
1983: return 1;
1984: DBG("Announcing routes to new protocol %s\n", p->name);
1985: p->feed_ahook = p->ahooks;
1986: fit = p->feed_iterator = mb_alloc(p->pool, sizeof(struct fib_iterator));
1987: goto next_hook;
1988: }
1989: fit = p->feed_iterator;
1990:
1991: again:
1992: h = p->feed_ahook;
1993: FIB_ITERATE_START(&h->table->fib, fit, fn)
1994: {
1995: net *n = (net *) fn;
1996: rte *e = n->routes;
1997: if (max_feed <= 0)
1998: {
1999: FIB_ITERATE_PUT(fit, fn);
2000: return 0;
2001: }
2002:
2003: /* XXXX perhaps we should change feed for RA_ACCEPTED to not use 'new' */
2004:
2005: if ((p->accept_ra_types == RA_OPTIMAL) ||
2006: (p->accept_ra_types == RA_ACCEPTED) ||
2007: (p->accept_ra_types == RA_MERGED))
2008: if (rte_is_valid(e))
2009: {
2010: if (p->export_state != ES_FEEDING)
2011: return 1; /* In the meantime, the protocol fell down. */
2012:
2013: do_feed_baby(p, p->accept_ra_types, h, n, e);
2014: max_feed--;
2015: }
2016:
2017: if (p->accept_ra_types == RA_ANY)
2018: for(e = n->routes; e; e = e->next)
2019: {
2020: if (p->export_state != ES_FEEDING)
2021: return 1; /* In the meantime, the protocol fell down. */
2022:
2023: if (!rte_is_valid(e))
2024: continue;
2025:
2026: do_feed_baby(p, RA_ANY, h, n, e);
2027: max_feed--;
2028: }
2029: }
2030: FIB_ITERATE_END(fn);
2031: p->feed_ahook = h->next;
2032: if (!p->feed_ahook)
2033: {
2034: mb_free(p->feed_iterator);
2035: p->feed_iterator = NULL;
2036: return 1;
2037: }
2038:
2039: next_hook:
2040: h = p->feed_ahook;
2041: FIB_ITERATE_INIT(fit, &h->table->fib);
2042: goto again;
2043: }
2044:
2045: /**
2046: * rt_feed_baby_abort - abort protocol feeding
2047: * @p: protocol
2048: *
2049: * This function is called by the protocol code when the protocol
2050: * stops or ceases to exist before the last iteration of rt_feed_baby()
2051: * has finished.
2052: */
2053: void
2054: rt_feed_baby_abort(struct proto *p)
2055: {
2056: if (p->feed_ahook)
2057: {
2058: /* Unlink the iterator and exit */
2059: fit_get(&p->feed_ahook->table->fib, p->feed_iterator);
2060: p->feed_ahook = NULL;
2061: }
2062: }
2063:
2064:
2065: static inline unsigned
2066: ptr_hash(void *ptr)
2067: {
2068: uintptr_t p = (uintptr_t) ptr;
2069: return p ^ (p << 8) ^ (p >> 16);
2070: }
2071:
2072: static inline unsigned
2073: hc_hash(ip_addr a, rtable *dep)
2074: {
2075: return (ipa_hash(a) ^ ptr_hash(dep)) & 0xffff;
2076: }
2077:
2078: static inline void
2079: hc_insert(struct hostcache *hc, struct hostentry *he)
2080: {
2081: uint k = he->hash_key >> hc->hash_shift;
2082: he->next = hc->hash_table[k];
2083: hc->hash_table[k] = he;
2084: }
2085:
2086: static inline void
2087: hc_remove(struct hostcache *hc, struct hostentry *he)
2088: {
2089: struct hostentry **hep;
2090: uint k = he->hash_key >> hc->hash_shift;
2091:
2092: for (hep = &hc->hash_table[k]; *hep != he; hep = &(*hep)->next);
2093: *hep = he->next;
2094: }
2095:
2096: #define HC_DEF_ORDER 10
2097: #define HC_HI_MARK *4
2098: #define HC_HI_STEP 2
2099: #define HC_HI_ORDER 16 /* Must be at most 16 */
2100: #define HC_LO_MARK /5
2101: #define HC_LO_STEP 2
2102: #define HC_LO_ORDER 10
2103:
2104: static void
2105: hc_alloc_table(struct hostcache *hc, unsigned order)
2106: {
2107: uint hsize = 1 << order;
2108: hc->hash_order = order;
2109: hc->hash_shift = 16 - order;
2110: hc->hash_max = (order >= HC_HI_ORDER) ? ~0U : (hsize HC_HI_MARK);
2111: hc->hash_min = (order <= HC_LO_ORDER) ? 0U : (hsize HC_LO_MARK);
2112:
2113: hc->hash_table = mb_allocz(rt_table_pool, hsize * sizeof(struct hostentry *));
2114: }
2115:
2116: static void
2117: hc_resize(struct hostcache *hc, unsigned new_order)
2118: {
2119: struct hostentry **old_table = hc->hash_table;
2120: struct hostentry *he, *hen;
2121: uint old_size = 1 << hc->hash_order;
2122: uint i;
2123:
2124: hc_alloc_table(hc, new_order);
2125: for (i = 0; i < old_size; i++)
2126: for (he = old_table[i]; he != NULL; he=hen)
2127: {
2128: hen = he->next;
2129: hc_insert(hc, he);
2130: }
2131: mb_free(old_table);
2132: }
2133:
2134: static struct hostentry *
2135: hc_new_hostentry(struct hostcache *hc, ip_addr a, ip_addr ll, rtable *dep, unsigned k)
2136: {
2137: struct hostentry *he = sl_alloc(hc->slab);
2138:
2139: he->addr = a;
2140: he->link = ll;
2141: he->tab = dep;
2142: he->hash_key = k;
2143: he->uc = 0;
2144: he->src = NULL;
2145:
2146: add_tail(&hc->hostentries, &he->ln);
2147: hc_insert(hc, he);
2148:
2149: hc->hash_items++;
2150: if (hc->hash_items > hc->hash_max)
2151: hc_resize(hc, hc->hash_order + HC_HI_STEP);
2152:
2153: return he;
2154: }
2155:
2156: static void
2157: hc_delete_hostentry(struct hostcache *hc, struct hostentry *he)
2158: {
2159: rta_free(he->src);
2160:
2161: rem_node(&he->ln);
2162: hc_remove(hc, he);
2163: sl_free(hc->slab, he);
2164:
2165: hc->hash_items--;
2166: if (hc->hash_items < hc->hash_min)
2167: hc_resize(hc, hc->hash_order - HC_LO_STEP);
2168: }
2169:
2170: static void
2171: rt_init_hostcache(rtable *tab)
2172: {
2173: struct hostcache *hc = mb_allocz(rt_table_pool, sizeof(struct hostcache));
2174: init_list(&hc->hostentries);
2175:
2176: hc->hash_items = 0;
2177: hc_alloc_table(hc, HC_DEF_ORDER);
2178: hc->slab = sl_new(rt_table_pool, sizeof(struct hostentry));
2179:
2180: hc->lp = lp_new(rt_table_pool, 1008);
2181: hc->trie = f_new_trie(hc->lp, sizeof(struct f_trie_node));
2182:
2183: tab->hostcache = hc;
2184: }
2185:
2186: static void
2187: rt_free_hostcache(rtable *tab)
2188: {
2189: struct hostcache *hc = tab->hostcache;
2190:
2191: node *n;
2192: WALK_LIST(n, hc->hostentries)
2193: {
2194: struct hostentry *he = SKIP_BACK(struct hostentry, ln, n);
2195: rta_free(he->src);
2196:
2197: if (he->uc)
2198: log(L_ERR "Hostcache is not empty in table %s", tab->name);
2199: }
2200:
2201: rfree(hc->slab);
2202: rfree(hc->lp);
2203: mb_free(hc->hash_table);
2204: mb_free(hc);
2205: }
2206:
2207: static void
2208: rt_notify_hostcache(rtable *tab, net *net)
2209: {
2210: struct hostcache *hc = tab->hostcache;
2211:
2212: if (tab->hcu_scheduled)
2213: return;
2214:
2215: if (trie_match_prefix(hc->trie, net->n.prefix, net->n.pxlen))
2216: rt_schedule_hcu(tab);
2217: }
2218:
2219: static int
2220: if_local_addr(ip_addr a, struct iface *i)
2221: {
2222: struct ifa *b;
2223:
2224: WALK_LIST(b, i->addrs)
2225: if (ipa_equal(a, b->ip))
2226: return 1;
2227:
2228: return 0;
2229: }
2230:
2231: static u32
2232: rt_get_igp_metric(rte *rt)
2233: {
2234: eattr *ea = ea_find(rt->attrs->eattrs, EA_GEN_IGP_METRIC);
2235:
2236: if (ea)
2237: return ea->u.data;
2238:
2239: rta *a = rt->attrs;
2240:
2241: #ifdef CONFIG_OSPF
2242: if ((a->source == RTS_OSPF) ||
2243: (a->source == RTS_OSPF_IA) ||
2244: (a->source == RTS_OSPF_EXT1))
2245: return rt->u.ospf.metric1;
2246: #endif
2247:
2248: #ifdef CONFIG_RIP
2249: if (a->source == RTS_RIP)
2250: return rt->u.rip.metric;
2251: #endif
2252:
2253: /* Device routes */
2254: if ((a->dest != RTD_ROUTER) && (a->dest != RTD_MULTIPATH))
2255: return 0;
2256:
2257: return IGP_METRIC_UNKNOWN;
2258: }
2259:
2260: static int
2261: rt_update_hostentry(rtable *tab, struct hostentry *he)
2262: {
2263: rta *old_src = he->src;
2264: int pxlen = 0;
2265:
2266: /* Reset the hostentry */
2267: he->src = NULL;
2268: he->gw = IPA_NONE;
2269: he->dest = RTD_UNREACHABLE;
2270: he->igp_metric = 0;
2271:
2272: net *n = net_route(tab, he->addr, MAX_PREFIX_LENGTH);
2273: if (n)
2274: {
2275: rte *e = n->routes;
2276: rta *a = e->attrs;
2277: pxlen = n->n.pxlen;
2278:
2279: if (a->hostentry)
2280: {
2281: /* Recursive route should not depend on another recursive route */
2282: log(L_WARN "Next hop address %I resolvable through recursive route for %I/%d",
2283: he->addr, n->n.prefix, pxlen);
2284: goto done;
2285: }
2286:
2287: if (a->dest == RTD_DEVICE)
2288: {
2289: if (if_local_addr(he->addr, a->iface))
2290: {
2291: /* The host address is a local address, this is not valid */
2292: log(L_WARN "Next hop address %I is a local address of iface %s",
2293: he->addr, a->iface->name);
2294: goto done;
2295: }
2296:
2297: /* The host is directly reachable, use link as a gateway */
2298: he->gw = he->link;
2299: he->dest = RTD_ROUTER;
2300: }
2301: else
2302: {
2303: /* The host is reachable through some route entry */
2304: he->gw = a->gw;
2305: he->dest = a->dest;
2306: }
2307:
2308: he->src = rta_clone(a);
2309: he->igp_metric = rt_get_igp_metric(e);
2310: }
2311:
2312: done:
2313: /* Add a prefix range to the trie */
2314: trie_add_prefix(tab->hostcache->trie, he->addr, MAX_PREFIX_LENGTH, pxlen, MAX_PREFIX_LENGTH);
2315:
2316: rta_free(old_src);
2317: return old_src != he->src;
2318: }
2319:
2320: static void
2321: rt_update_hostcache(rtable *tab)
2322: {
2323: struct hostcache *hc = tab->hostcache;
2324: struct hostentry *he;
2325: node *n, *x;
2326:
2327: /* Reset the trie */
2328: lp_flush(hc->lp);
2329: hc->trie = f_new_trie(hc->lp, sizeof(struct f_trie_node));
2330:
2331: WALK_LIST_DELSAFE(n, x, hc->hostentries)
2332: {
2333: he = SKIP_BACK(struct hostentry, ln, n);
2334: if (!he->uc)
2335: {
2336: hc_delete_hostentry(hc, he);
2337: continue;
2338: }
2339:
2340: if (rt_update_hostentry(tab, he))
2341: rt_schedule_nhu(he->tab);
2342: }
2343:
2344: tab->hcu_scheduled = 0;
2345: }
2346:
2347: static struct hostentry *
2348: rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep)
2349: {
2350: struct hostentry *he;
2351:
2352: if (!tab->hostcache)
2353: rt_init_hostcache(tab);
2354:
2355: uint k = hc_hash(a, dep);
2356: struct hostcache *hc = tab->hostcache;
2357: for (he = hc->hash_table[k >> hc->hash_shift]; he != NULL; he = he->next)
2358: if (ipa_equal(he->addr, a) && (he->tab == dep))
2359: return he;
2360:
2361: he = hc_new_hostentry(hc, a, ll, dep, k);
2362: rt_update_hostentry(tab, he);
2363: return he;
2364: }
2365:
2366: void
2367: rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr *gw, ip_addr *ll)
2368: {
2369: rta_apply_hostentry(a, rt_get_hostentry(tab, *gw, *ll, dep));
2370: }
2371:
2372:
2373: /*
2374: * CLI commands
2375: */
2376:
2377: static byte *
2378: rt_format_via(rte *e)
2379: {
2380: rta *a = e->attrs;
2381:
2382: /* Max text length w/o IP addr and interface name is 16 */
2383: static byte via[STD_ADDRESS_P_LENGTH+sizeof(a->iface->name)+16];
2384:
2385: switch (a->dest)
2386: {
2387: case RTD_ROUTER: bsprintf(via, "via %I on %s", a->gw, a->iface->name); break;
2388: case RTD_DEVICE: bsprintf(via, "dev %s", a->iface->name); break;
2389: case RTD_BLACKHOLE: bsprintf(via, "blackhole"); break;
2390: case RTD_UNREACHABLE: bsprintf(via, "unreachable"); break;
2391: case RTD_PROHIBIT: bsprintf(via, "prohibited"); break;
2392: case RTD_MULTIPATH: bsprintf(via, "multipath"); break;
2393: default: bsprintf(via, "???");
2394: }
2395: return via;
2396: }
2397:
2398: static void
2399: rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, ea_list *tmpa)
2400: {
2401: byte from[STD_ADDRESS_P_LENGTH+8];
2402: byte tm[TM_DATETIME_BUFFER_SIZE], info[256];
2403: rta *a = e->attrs;
2404: int primary = (e->net->routes == e);
2405: int sync_error = (e->net->n.flags & KRF_SYNC_ERROR);
2406: void (*get_route_info)(struct rte *, byte *buf, struct ea_list *attrs);
2407: struct mpnh *nh;
2408:
2409: tm_format_datetime(tm, &config->tf_route, e->lastmod);
2410: if (ipa_nonzero(a->from) && !ipa_equal(a->from, a->gw))
2411: bsprintf(from, " from %I", a->from);
2412: else
2413: from[0] = 0;
2414:
2415: get_route_info = a->src->proto->proto->get_route_info;
2416: if (get_route_info || d->verbose)
2417: {
2418: /* Need to normalize the extended attributes */
2419: ea_list *t = tmpa;
2420: t = ea_append(t, a->eattrs);
2421: tmpa = alloca(ea_scan(t));
2422: ea_merge(t, tmpa);
2423: ea_sort(tmpa);
2424: }
2425: if (get_route_info)
2426: get_route_info(e, info, tmpa);
2427: else
2428: bsprintf(info, " (%d)", e->pref);
2429: cli_printf(c, -1007, "%-18s %s [%s %s%s]%s%s", ia, rt_format_via(e), a->src->proto->name,
2430: tm, from, primary ? (sync_error ? " !" : " *") : "", info);
2431: for (nh = a->nexthops; nh; nh = nh->next)
2432: cli_printf(c, -1007, "\tvia %I on %s weight %d", nh->gw, nh->iface->name, nh->weight + 1);
2433: if (d->verbose)
2434: rta_show(c, a, tmpa);
2435: }
2436:
2437: static void
2438: rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
2439: {
2440: rte *e, *ee;
2441: byte ia[STD_ADDRESS_P_LENGTH+8];
2442: struct ea_list *tmpa;
2443: struct announce_hook *a = NULL;
2444: int first = 1;
2445: int pass = 0;
2446:
2447: bsprintf(ia, "%I/%d", n->n.prefix, n->n.pxlen);
2448:
2449: if (d->export_mode)
2450: {
2451: if (! d->export_protocol->rt_notify)
2452: return;
2453:
2454: a = proto_find_announce_hook(d->export_protocol, d->table);
2455: if (!a)
2456: return;
2457: }
2458:
2459: for (e = n->routes; e; e = e->next)
2460: {
2461: if (rte_is_filtered(e) != d->filtered)
2462: continue;
2463:
2464: d->rt_counter++;
2465: d->net_counter += first;
2466: first = 0;
2467:
2468: if (pass)
2469: continue;
2470:
2471: ee = e;
2472: rte_update_lock(); /* We use the update buffer for filtering */
2473: tmpa = make_tmp_attrs(e, rte_update_pool);
2474:
2475: /* Special case for merged export */
2476: if ((d->export_mode == RSEM_EXPORT) && (d->export_protocol->accept_ra_types == RA_MERGED))
2477: {
2478: rte *rt_free;
2479: e = rt_export_merged(a, n, &rt_free, &tmpa, rte_update_pool, 1);
2480: pass = 1;
2481:
2482: if (!e)
2483: { e = ee; goto skip; }
2484: }
2485: else if (d->export_mode)
2486: {
2487: struct proto *ep = d->export_protocol;
2488: int ic = ep->import_control ? ep->import_control(ep, &e, &tmpa, rte_update_pool) : 0;
2489:
2490: if (ep->accept_ra_types == RA_OPTIMAL || ep->accept_ra_types == RA_MERGED)
2491: pass = 1;
2492:
2493: if (ic < 0)
2494: goto skip;
2495:
2496: if (d->export_mode > RSEM_PREEXPORT)
2497: {
2498: /*
2499: * FIXME - This shows what should be exported according to current
2500: * filters, but not what was really exported. 'configure soft'
2501: * command may change the export filter and do not update routes.
2502: */
2503: int do_export = (ic > 0) ||
2504: (f_run(a->out_filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) <= F_ACCEPT);
2505:
2506: if (do_export != (d->export_mode == RSEM_EXPORT))
2507: goto skip;
2508:
2509: if ((d->export_mode == RSEM_EXPORT) && (ep->accept_ra_types == RA_ACCEPTED))
2510: pass = 1;
2511: }
2512: }
2513:
2514: if (d->show_protocol && (d->show_protocol != e->attrs->src->proto))
2515: goto skip;
2516:
2517: if (f_run(d->filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) > F_ACCEPT)
2518: goto skip;
2519:
2520: d->show_counter++;
2521: if (d->stats < 2)
2522: rt_show_rte(c, ia, e, d, tmpa);
2523: ia[0] = 0;
2524:
2525: skip:
2526: if (e != ee)
2527: {
2528: rte_free(e);
2529: e = ee;
2530: }
2531: rte_update_unlock();
2532:
2533: if (d->primary_only)
2534: break;
2535: }
2536: }
2537:
2538: static void
2539: rt_show_cont(struct cli *c)
2540: {
2541: struct rt_show_data *d = c->rover;
2542: #ifdef DEBUGGING
2543: unsigned max = 4;
2544: #else
2545: unsigned max = 64;
2546: #endif
2547: struct fib *fib = &d->table->fib;
2548: struct fib_iterator *it = &d->fit;
2549:
2550: FIB_ITERATE_START(fib, it, f)
2551: {
2552: net *n = (net *) f;
2553: if (d->running_on_config && d->running_on_config != config)
2554: {
2555: cli_printf(c, 8004, "Stopped due to reconfiguration");
2556: goto done;
2557: }
2558: if (d->export_protocol && (d->export_protocol->export_state == ES_DOWN))
2559: {
2560: cli_printf(c, 8005, "Protocol is down");
2561: goto done;
2562: }
2563: if (!max--)
2564: {
2565: FIB_ITERATE_PUT(it, f);
2566: return;
2567: }
2568: rt_show_net(c, n, d);
2569: }
2570: FIB_ITERATE_END(f);
2571: if (d->stats)
2572: cli_printf(c, 14, "%d of %d routes for %d networks", d->show_counter, d->rt_counter, d->net_counter);
2573: else
2574: cli_printf(c, 0, "");
2575: done:
2576: c->cont = c->cleanup = NULL;
2577: }
2578:
2579: static void
2580: rt_show_cleanup(struct cli *c)
2581: {
2582: struct rt_show_data *d = c->rover;
2583:
2584: /* Unlink the iterator */
2585: fit_get(&d->table->fib, &d->fit);
2586: }
2587:
2588: void
2589: rt_show(struct rt_show_data *d)
2590: {
2591: net *n;
2592:
2593: /* Default is either a master table or a table related to a respective protocol */
2594: if (!d->table && d->export_protocol) d->table = d->export_protocol->table;
2595: if (!d->table && d->show_protocol) d->table = d->show_protocol->table;
2596: if (!d->table) d->table = config->master_rtc->table;
2597:
2598: /* Filtered routes are neither exported nor have sensible ordering */
2599: if (d->filtered && (d->export_mode || d->primary_only))
2600: cli_msg(0, "");
2601:
2602: if (d->pxlen == 256)
2603: {
2604: FIB_ITERATE_INIT(&d->fit, &d->table->fib);
2605: this_cli->cont = rt_show_cont;
2606: this_cli->cleanup = rt_show_cleanup;
2607: this_cli->rover = d;
2608: }
2609: else
2610: {
2611: if (d->show_for)
2612: n = net_route(d->table, d->prefix, d->pxlen);
2613: else
2614: n = net_find(d->table, d->prefix, d->pxlen);
2615:
2616: if (n)
2617: rt_show_net(this_cli, n, d);
2618:
2619: if (d->rt_counter)
2620: cli_msg(0, "");
2621: else
2622: cli_msg(8001, "Network not in table");
2623: }
2624: }
2625:
2626: /*
2627: * Documentation for functions declared inline in route.h
2628: */
2629: #if 0
2630:
2631: /**
2632: * net_find - find a network entry
2633: * @tab: a routing table
2634: * @addr: address of the network
2635: * @len: length of the network prefix
2636: *
2637: * net_find() looks up the given network in routing table @tab and
2638: * returns a pointer to its &net entry or %NULL if no such network
2639: * exists.
2640: */
2641: static inline net *net_find(rtable *tab, ip_addr addr, unsigned len)
2642: { DUMMY; }
2643:
2644: /**
2645: * net_get - obtain a network entry
2646: * @tab: a routing table
2647: * @addr: address of the network
2648: * @len: length of the network prefix
2649: *
2650: * net_get() looks up the given network in routing table @tab and
2651: * returns a pointer to its &net entry. If no such entry exists, it's
2652: * created.
2653: */
2654: static inline net *net_get(rtable *tab, ip_addr addr, unsigned len)
2655: { DUMMY; }
2656:
2657: /**
2658: * rte_cow - copy a route for writing
2659: * @r: a route entry to be copied
2660: *
2661: * rte_cow() takes a &rte and prepares it for modification. The exact action
2662: * taken depends on the flags of the &rte -- if it's a temporary entry, it's
2663: * just returned unchanged, else a new temporary entry with the same contents
2664: * is created.
2665: *
2666: * The primary use of this function is inside the filter machinery -- when
2667: * a filter wants to modify &rte contents (to change the preference or to
2668: * attach another set of attributes), it must ensure that the &rte is not
2669: * shared with anyone else (and especially that it isn't stored in any routing
2670: * table).
2671: *
2672: * Result: a pointer to the new writable &rte.
2673: */
2674: static inline rte * rte_cow(rte *r)
2675: { DUMMY; }
2676:
2677: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rt-table.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 / nest