1: /*
2: * BIRD -- Static Route Generator
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: Static
11: *
12: * The Static protocol is implemented in a straightforward way. It keeps a list
13: * of static routes. Routes of dest RTD_UNICAST have associated sticky node in
14: * the neighbor cache to be notified about gaining or losing the neighbor and
15: * about interface-related events (e.g. link down). They may also have a BFD
16: * request if associated with a BFD session. When a route is notified,
17: * static_decide() is used to see whether the route activeness is changed. In
18: * such case, the route is marked as dirty and scheduled to be announced or
19: * withdrawn, which is done asynchronously from event hook. Routes of other
20: * types (e.g. black holes) are announced all the time.
21: *
22: * Multipath routes are a bit tricky. To represent additional next hops, dummy
23: * static_route nodes are used, which are chained using @mp_next field and link
24: * to the master node by @mp_head field. Each next hop has a separate neighbor
25: * entry and an activeness state, but the master node is used for most purposes.
26: * Note that most functions DO NOT accept dummy nodes as arguments.
27: *
28: * The only other thing worth mentioning is that when asked for reconfiguration,
29: * Static not only compares the two configurations, but it also calculates
30: * difference between the lists of static routes and it just inserts the newly
31: * added routes, removes the obsolete ones and reannounces changed ones.
32: */
33:
34: #undef LOCAL_DEBUG
35:
36: #include <stdlib.h>
37:
38: #include "nest/bird.h"
39: #include "nest/iface.h"
40: #include "nest/protocol.h"
41: #include "nest/route.h"
42: #include "nest/cli.h"
43: #include "conf/conf.h"
44: #include "filter/filter.h"
45: #include "lib/string.h"
46: #include "lib/alloca.h"
47:
48: #include "static.h"
49:
50: static linpool *static_lp;
51:
52: static void
53: static_announce_rte(struct static_proto *p, struct static_route *r)
54: {
55: rta *a = allocz(RTA_MAX_SIZE);
56: a->src = p->p.main_source;
57: a->source = RTS_STATIC;
58: a->scope = SCOPE_UNIVERSE;
59: a->dest = r->dest;
60:
61: if (r->dest == RTD_UNICAST)
62: {
63: struct static_route *r2;
64: struct nexthop *nhs = NULL;
65:
66: for (r2 = r; r2; r2 = r2->mp_next)
67: {
68: if (!r2->active)
69: continue;
70:
71: struct nexthop *nh = allocz(NEXTHOP_MAX_SIZE);
72: nh->gw = r2->via;
73: nh->iface = r2->neigh->iface;
74: nh->flags = r2->onlink ? RNF_ONLINK : 0;
75: nh->weight = r2->weight;
76: if (r2->mls)
77: {
78: nh->labels = r2->mls->len;
79: memcpy(nh->label, r2->mls->stack, r2->mls->len * sizeof(u32));
80: }
81:
82: nexthop_insert(&nhs, nh);
83: }
84:
85: if (!nhs)
86: goto withdraw;
87:
88: nexthop_link(a, nhs);
89: }
90:
91: if (r->dest == RTDX_RECURSIVE)
92: {
93: rtable *tab = ipa_is_ip4(r->via) ? p->igp_table_ip4 : p->igp_table_ip6;
94: rta_set_recursive_next_hop(p->p.main_channel->table, a, tab, r->via, IPA_NONE, r->mls);
95: }
96:
97: /* Already announced */
98: if (r->state == SRS_CLEAN)
99: return;
100:
101: /* We skip rta_lookup() here */
102: rte *e = rte_get_temp(a);
103: e->pflags = 0;
104:
105: if (r->cmds)
106: f_eval_rte(r->cmds, &e, static_lp);
107:
108: rte_update(&p->p, r->net, e);
109: r->state = SRS_CLEAN;
110:
111: if (r->cmds)
112: lp_flush(static_lp);
113:
114: return;
115:
116: withdraw:
117: if (r->state == SRS_DOWN)
118: return;
119:
120: rte_update(&p->p, r->net, NULL);
121: r->state = SRS_DOWN;
122: }
123:
124: static void
125: static_mark_rte(struct static_proto *p, struct static_route *r)
126: {
127: if (r->state == SRS_DIRTY)
128: return;
129:
130: r->state = SRS_DIRTY;
131: BUFFER_PUSH(p->marked) = r;
132:
133: if (!ev_active(p->event))
134: ev_schedule(p->event);
135: }
136:
137: static void
138: static_announce_marked(void *P)
139: {
140: struct static_proto *p = P;
141:
142: BUFFER_WALK(p->marked, r)
143: static_announce_rte(P, r);
144:
145: BUFFER_FLUSH(p->marked);
146: }
147:
148: static void
149: static_bfd_notify(struct bfd_request *req);
150:
151: static void
152: static_update_bfd(struct static_proto *p, struct static_route *r)
153: {
154: /* The @r is a RTD_UNICAST next hop, may be a dummy node */
155:
156: struct neighbor *nb = r->neigh;
157: int bfd_up = (nb->scope > 0) && r->use_bfd;
158:
159: if (bfd_up && !r->bfd_req)
160: {
161: // ip_addr local = ipa_nonzero(r->local) ? r->local : nb->ifa->ip;
162: r->bfd_req = bfd_request_session(p->p.pool, r->via, nb->ifa->ip,
163: nb->iface, p->p.vrf,
164: static_bfd_notify, r);
165: }
166:
167: if (!bfd_up && r->bfd_req)
168: {
169: rfree(r->bfd_req);
170: r->bfd_req = NULL;
171: }
172: }
173:
174: static int
175: static_decide(struct static_proto *p, struct static_route *r)
176: {
177: /* The @r is a RTD_UNICAST next hop, may be a dummy node */
178:
179: struct static_config *cf = (void *) p->p.cf;
180: uint old_active = r->active;
181:
182: if (r->neigh->scope < 0)
183: goto fail;
184:
185: if (cf->check_link && !(r->neigh->iface->flags & IF_LINK_UP))
186: goto fail;
187:
188: if (r->bfd_req && (r->bfd_req->state != BFD_STATE_UP))
189: goto fail;
190:
191: r->active = 1;
192: return !old_active;
193:
194: fail:
195: r->active = 0;
196: return old_active;
197: }
198:
199: static void
200: static_add_rte(struct static_proto *p, struct static_route *r)
201: {
202: if (r->dest == RTD_UNICAST)
203: {
204: struct static_route *r2;
205: struct neighbor *n;
206:
207: for (r2 = r; r2; r2 = r2->mp_next)
208: {
209: n = neigh_find(&p->p, r2->via, r2->iface, NEF_STICKY |
210: (r2->onlink ? NEF_ONLINK : 0) |
211: (ipa_zero(r2->via) ? NEF_IFACE : 0));
212:
213: if (!n)
214: {
215: log(L_WARN "Invalid next hop %I of static route %N", r2->via, r2->net);
216: continue;
217: }
218:
219: r2->neigh = n;
220: r2->chain = n->data;
221: n->data = r2;
222:
223: static_update_bfd(p, r2);
224: static_decide(p, r2);
225: }
226: }
227:
228: static_announce_rte(p, r);
229: }
230:
231: static void
232: static_reset_rte(struct static_proto *p UNUSED, struct static_route *r)
233: {
234: struct static_route *r2;
235:
236: for (r2 = r; r2; r2 = r2->mp_next)
237: {
238: r2->neigh = NULL;
239: r2->chain = NULL;
240:
241: r2->state = 0;
242: r2->active = 0;
243:
244: rfree(r2->bfd_req);
245: r2->bfd_req = NULL;
246: }
247: }
248:
249: static void
250: static_remove_rte(struct static_proto *p, struct static_route *r)
251: {
252: if (r->state)
253: rte_update(&p->p, r->net, NULL);
254:
255: static_reset_rte(p, r);
256: }
257:
258:
259: static inline int
260: static_same_dest(struct static_route *x, struct static_route *y)
261: {
262: if (x->dest != y->dest)
263: return 0;
264:
265: switch (x->dest)
266: {
267: case RTD_UNICAST:
268: for (; x && y; x = x->mp_next, y = y->mp_next)
269: {
270: if (!ipa_equal(x->via, y->via) ||
271: (x->iface != y->iface) ||
272: (x->onlink != y->onlink) ||
273: (x->weight != y->weight) ||
274: (x->use_bfd != y->use_bfd) ||
275: (!x->mls != !y->mls) ||
276: ((x->mls) && (y->mls) && (x->mls->len != y->mls->len)))
277: return 0;
278:
279: if (!x->mls)
280: continue;
281:
282: for (uint i = 0; i < x->mls->len; i++)
283: if (x->mls->stack[i] != y->mls->stack[i])
284: return 0;
285: }
286: return !x && !y;
287:
288: case RTDX_RECURSIVE:
289: if (!ipa_equal(x->via, y->via) ||
290: (!x->mls != !y->mls) ||
291: ((x->mls) && (y->mls) && (x->mls->len != y->mls->len)))
292: return 0;
293:
294: if (!x->mls)
295: return 1;
296:
297: for (uint i = 0; i < x->mls->len; i++)
298: if (x->mls->stack[i] != y->mls->stack[i])
299: return 0;
300:
301: return 1;
302:
303: default:
304: return 1;
305: }
306: }
307:
308: static inline int
309: static_same_rte(struct static_route *or, struct static_route *nr)
310: {
311: /* Note that i_same() requires arguments in (new, old) order */
312: return static_same_dest(or, nr) && f_same(nr->cmds, or->cmds);
313: }
314:
315: static void
316: static_reconfigure_rte(struct static_proto *p, struct static_route *or, struct static_route *nr)
317: {
318: if ((or->state == SRS_CLEAN) && !static_same_rte(or, nr))
319: nr->state = SRS_DIRTY;
320: else
321: nr->state = or->state;
322:
323: static_add_rte(p, nr);
324: static_reset_rte(p, or);
325: }
326:
327:
328: static void
329: static_neigh_notify(struct neighbor *n)
330: {
331: struct static_proto *p = (void *) n->proto;
332: struct static_route *r;
333:
334: DBG("Static: neighbor notify for %I: iface %p\n", n->addr, n->iface);
335: for (r = n->data; r; r = r->chain)
336: {
337: static_update_bfd(p, r);
338:
339: if (static_decide(p, r))
340: static_mark_rte(p, r->mp_head);
341: }
342: }
343:
344: static void
345: static_bfd_notify(struct bfd_request *req)
346: {
347: struct static_route *r = req->data;
348: struct static_proto *p = (void *) r->neigh->proto;
349:
350: // if (req->down) TRACE(D_EVENTS, "BFD session down for nbr %I on %s", XXXX);
351:
352: if (static_decide(p, r))
353: static_mark_rte(p, r->mp_head);
354: }
355:
356: static int
357: static_rte_mergable(rte *pri UNUSED, rte *sec UNUSED)
358: {
359: return 1;
360: }
361:
362:
363: static void
364: static_postconfig(struct proto_config *CF)
365: {
366: struct static_config *cf = (void *) CF;
367: struct static_route *r;
368:
369: if (EMPTY_LIST(CF->channels))
370: cf_error("Channel not specified");
371:
372: struct channel_config *cc = proto_cf_main_channel(CF);
373:
374: if (!cf->igp_table_ip4)
375: cf->igp_table_ip4 = (cc->table->addr_type == NET_IP4) ?
376: cc->table : cf->c.global->def_tables[NET_IP4];
377:
378: if (!cf->igp_table_ip6)
379: cf->igp_table_ip6 = (cc->table->addr_type == NET_IP6) ?
380: cc->table : cf->c.global->def_tables[NET_IP6];
381:
382: WALK_LIST(r, cf->routes)
383: if (r->net && (r->net->type != CF->net_type))
384: cf_error("Route %N incompatible with channel type", r->net);
385: }
386:
387: static struct proto *
388: static_init(struct proto_config *CF)
389: {
390: struct proto *P = proto_new(CF);
391: struct static_proto *p = (void *) P;
392: struct static_config *cf = (void *) CF;
393:
394: P->main_channel = proto_add_channel(P, proto_cf_main_channel(CF));
395:
396: P->neigh_notify = static_neigh_notify;
397: P->rte_mergable = static_rte_mergable;
398:
399: if (cf->igp_table_ip4)
400: p->igp_table_ip4 = cf->igp_table_ip4->table;
401:
402: if (cf->igp_table_ip6)
403: p->igp_table_ip6 = cf->igp_table_ip6->table;
404:
405: return P;
406: }
407:
408: static int
409: static_start(struct proto *P)
410: {
411: struct static_proto *p = (void *) P;
412: struct static_config *cf = (void *) P->cf;
413: struct static_route *r;
414:
415: if (!static_lp)
416: static_lp = lp_new(&root_pool, LP_GOOD_SIZE(1024));
417:
418: if (p->igp_table_ip4)
419: rt_lock_table(p->igp_table_ip4);
420:
421: if (p->igp_table_ip6)
422: rt_lock_table(p->igp_table_ip6);
423:
424: p->event = ev_new_init(p->p.pool, static_announce_marked, p);
425:
426: BUFFER_INIT(p->marked, p->p.pool, 4);
427:
428: /* We have to go UP before routes could be installed */
429: proto_notify_state(P, PS_UP);
430:
431: WALK_LIST(r, cf->routes)
432: static_add_rte(p, r);
433:
434: return PS_UP;
435: }
436:
437: static int
438: static_shutdown(struct proto *P)
439: {
440: struct static_proto *p = (void *) P;
441: struct static_config *cf = (void *) P->cf;
442: struct static_route *r;
443:
444: /* Just reset the flag, the routes will be flushed by the nest */
445: WALK_LIST(r, cf->routes)
446: static_reset_rte(p, r);
447:
448: return PS_DOWN;
449: }
450:
451: static void
452: static_cleanup(struct proto *P)
453: {
454: struct static_proto *p = (void *) P;
455:
456: if (p->igp_table_ip4)
457: rt_unlock_table(p->igp_table_ip4);
458:
459: if (p->igp_table_ip6)
460: rt_unlock_table(p->igp_table_ip6);
461: }
462:
463: static void
464: static_dump_rte(struct static_route *r)
465: {
466: debug("%-1N: ", r->net);
467: if (r->dest == RTD_UNICAST)
468: if (r->iface && ipa_zero(r->via))
469: debug("dev %s\n", r->iface->name);
470: else
471: debug("via %I%J\n", r->via, r->iface);
472: else
473: debug("rtd %d\n", r->dest);
474: }
475:
476: static void
477: static_dump(struct proto *P)
478: {
479: struct static_config *c = (void *) P->cf;
480: struct static_route *r;
481:
482: debug("Static routes:\n");
483: WALK_LIST(r, c->routes)
484: static_dump_rte(r);
485: }
486:
487: #define IGP_TABLE(cf, sym) ((cf)->igp_table_##sym ? (cf)->igp_table_##sym ->table : NULL )
488:
489: static inline int
490: static_cmp_rte(const void *X, const void *Y)
491: {
492: struct static_route *x = *(void **)X, *y = *(void **)Y;
493: return net_compare(x->net, y->net);
494: }
495:
496: static int
497: static_reconfigure(struct proto *P, struct proto_config *CF)
498: {
499: struct static_proto *p = (void *) P;
500: struct static_config *o = (void *) P->cf;
501: struct static_config *n = (void *) CF;
502: struct static_route *r, *r2, *or, *nr;
503:
504: /* Check change in IGP tables */
505: if ((IGP_TABLE(o, ip4) != IGP_TABLE(n, ip4)) ||
506: (IGP_TABLE(o, ip6) != IGP_TABLE(n, ip6)))
507: return 0;
508:
509: if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
510: return 0;
511:
512: p->p.cf = CF;
513:
514: /* Reset route lists in neighbor entries */
515: WALK_LIST(r, o->routes)
516: for (r2 = r; r2; r2 = r2->mp_next)
517: if (r2->neigh)
518: r2->neigh->data = NULL;
519:
520: /* Reconfigure initial matching sequence */
521: for (or = HEAD(o->routes), nr = HEAD(n->routes);
522: NODE_VALID(or) && NODE_VALID(nr) && net_equal(or->net, nr->net);
523: or = NODE_NEXT(or), nr = NODE_NEXT(nr))
524: static_reconfigure_rte(p, or, nr);
525:
526: if (!NODE_VALID(or) && !NODE_VALID(nr))
527: return 1;
528:
529: /* Reconfigure remaining routes, sort them to find matching pairs */
530: struct static_route *or2, *nr2, **orbuf, **nrbuf;
531: uint ornum = 0, nrnum = 0, orpos = 0, nrpos = 0, i;
532:
533: for (or2 = or; NODE_VALID(or2); or2 = NODE_NEXT(or2))
534: ornum++;
535:
536: for (nr2 = nr; NODE_VALID(nr2); nr2 = NODE_NEXT(nr2))
537: nrnum++;
538:
539: orbuf = xmalloc(ornum * sizeof(void *));
540: nrbuf = xmalloc(nrnum * sizeof(void *));
541:
542: for (i = 0, or2 = or; i < ornum; i++, or2 = NODE_NEXT(or2))
543: orbuf[i] = or2;
544:
545: for (i = 0, nr2 = nr; i < nrnum; i++, nr2 = NODE_NEXT(nr2))
546: nrbuf[i] = nr2;
547:
548: qsort(orbuf, ornum, sizeof(struct static_route *), static_cmp_rte);
549: qsort(nrbuf, nrnum, sizeof(struct static_route *), static_cmp_rte);
550:
551: while ((orpos < ornum) && (nrpos < nrnum))
552: {
553: int x = net_compare(orbuf[orpos]->net, nrbuf[nrpos]->net);
554: if (x < 0)
555: static_remove_rte(p, orbuf[orpos++]);
556: else if (x > 0)
557: static_add_rte(p, nrbuf[nrpos++]);
558: else
559: static_reconfigure_rte(p, orbuf[orpos++], nrbuf[nrpos++]);
560: }
561:
562: while (orpos < ornum)
563: static_remove_rte(p, orbuf[orpos++]);
564:
565: while (nrpos < nrnum)
566: static_add_rte(p, nrbuf[nrpos++]);
567:
568: xfree(orbuf);
569: xfree(nrbuf);
570:
571: return 1;
572: }
573:
574: static void
575: static_copy_config(struct proto_config *dest, struct proto_config *src)
576: {
577: struct static_config *d = (struct static_config *) dest;
578: struct static_config *s = (struct static_config *) src;
579:
580: struct static_route *srt, *snh;
581:
582: /* Copy route list */
583: init_list(&d->routes);
584: WALK_LIST(srt, s->routes)
585: {
586: struct static_route *drt = NULL, *dnh = NULL, **dnp = &drt;
587:
588: for (snh = srt; snh; snh = snh->mp_next)
589: {
590: dnh = cfg_alloc(sizeof(struct static_route));
591: memcpy(dnh, snh, sizeof(struct static_route));
592:
593: if (!drt)
594: add_tail(&d->routes, &(dnh->n));
595:
596: *dnp = dnh;
597: dnp = &(dnh->mp_next);
598:
599: if (snh->mp_head)
600: dnh->mp_head = drt;
601: }
602: }
603: }
604:
605: static void
606: static_show_rt(struct static_route *r)
607: {
608: switch (r->dest)
609: {
610: case RTD_UNICAST:
611: {
612: struct static_route *r2;
613:
614: cli_msg(-1009, "%N", r->net);
615: for (r2 = r; r2; r2 = r2->mp_next)
616: {
617: if (r2->iface && ipa_zero(r2->via))
618: cli_msg(-1009, "\tdev %s%s", r2->iface->name,
619: r2->active ? "" : " (dormant)");
620: else
621: cli_msg(-1009, "\tvia %I%J%s%s%s", r2->via, r2->iface,
622: r2->onlink ? " onlink" : "",
623: r2->bfd_req ? " (bfd)" : "",
624: r2->active ? "" : " (dormant)");
625: }
626: break;
627: }
628:
629: case RTD_NONE:
630: case RTD_BLACKHOLE:
631: case RTD_UNREACHABLE:
632: case RTD_PROHIBIT:
633: cli_msg(-1009, "%N\t%s", r->net, rta_dest_names[r->dest]);
634: break;
635:
636: case RTDX_RECURSIVE:
637: cli_msg(-1009, "%N\trecursive %I", r->net, r->via);
638: break;
639: }
640: }
641:
642: void
643: static_show(struct proto *P)
644: {
645: struct static_config *c = (void *) P->cf;
646: struct static_route *r;
647:
648: WALK_LIST(r, c->routes)
649: static_show_rt(r);
650: cli_msg(0, "");
651: }
652:
653:
654: struct protocol proto_static = {
655: .name = "Static",
656: .template = "static%d",
657: .class = PROTOCOL_STATIC,
658: .preference = DEF_PREF_STATIC,
659: .channel_mask = NB_ANY,
660: .proto_size = sizeof(struct static_proto),
661: .config_size = sizeof(struct static_config),
662: .postconfig = static_postconfig,
663: .init = static_init,
664: .dump = static_dump,
665: .start = static_start,
666: .shutdown = static_shutdown,
667: .cleanup = static_cleanup,
668: .reconfigure = static_reconfigure,
669: .copy_config = static_copy_config
670: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to static.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / proto / static