Annotation of embedaddon/bird2/proto/pipe/pipe.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- Table-to-Table Routing Protocol a.k.a Pipe
! 3: *
! 4: * (c) 1999--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: Pipe
! 11: *
! 12: * The Pipe protocol is very simple. It just connects to two routing tables
! 13: * using proto_add_announce_hook() and whenever it receives a rt_notify()
! 14: * about a change in one of the tables, it converts it to a rte_update()
! 15: * in the other one.
! 16: *
! 17: * To avoid pipe loops, Pipe keeps a `being updated' flag in each routing
! 18: * table.
! 19: *
! 20: * A pipe has two announce hooks, the first connected to the main
! 21: * table, the second connected to the peer table. When a new route is
! 22: * announced on the main table, it gets checked by an export filter in
! 23: * ahook 1, and, after that, it is announced to the peer table via
! 24: * rte_update(), an import filter in ahook 2 is called. When a new
! 25: * route is announced in the peer table, an export filter in ahook2
! 26: * and an import filter in ahook 1 are used. Oviously, there is no
! 27: * need in filtering the same route twice, so both import filters are
! 28: * set to accept, while user configured 'import' and 'export' filters
! 29: * are used as export filters in ahooks 2 and 1. Route limits are
! 30: * handled similarly, but on the import side of ahooks.
! 31: */
! 32:
! 33: #undef LOCAL_DEBUG
! 34:
! 35: #include "nest/bird.h"
! 36: #include "nest/iface.h"
! 37: #include "nest/protocol.h"
! 38: #include "nest/route.h"
! 39: #include "nest/cli.h"
! 40: #include "conf/conf.h"
! 41: #include "filter/filter.h"
! 42: #include "lib/string.h"
! 43:
! 44: #include "pipe.h"
! 45:
! 46: static void
! 47: pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *old)
! 48: {
! 49: struct pipe_proto *p = (void *) P;
! 50: struct channel *dst = (src_ch == p->pri) ? p->sec : p->pri;
! 51: struct rte_src *src;
! 52:
! 53: rte *e;
! 54: rta *a;
! 55:
! 56: if (!new && !old)
! 57: return;
! 58:
! 59: if (dst->table->pipe_busy)
! 60: {
! 61: log(L_ERR "Pipe loop detected when sending %N to table %s",
! 62: n->n.addr, dst->table->name);
! 63: return;
! 64: }
! 65:
! 66: if (new)
! 67: {
! 68: a = alloca(rta_size(new->attrs));
! 69: memcpy(a, new->attrs, rta_size(new->attrs));
! 70:
! 71: a->aflags = 0;
! 72: a->hostentry = NULL;
! 73: e = rte_get_temp(a);
! 74: e->pflags = 0;
! 75:
! 76: /* Copy protocol specific embedded attributes. */
! 77: memcpy(&(e->u), &(new->u), sizeof(e->u));
! 78: e->pref = new->pref;
! 79: e->pflags = new->pflags;
! 80:
! 81: #ifdef CONFIG_BGP
! 82: /* Hack to cleanup cached value */
! 83: if (e->attrs->src->proto->proto == &proto_bgp)
! 84: e->u.bgp.stale = -1;
! 85: #endif
! 86:
! 87: src = a->src;
! 88: }
! 89: else
! 90: {
! 91: e = NULL;
! 92: src = old->attrs->src;
! 93: }
! 94:
! 95: src_ch->table->pipe_busy = 1;
! 96: rte_update2(dst, n->n.addr, e, src);
! 97: src_ch->table->pipe_busy = 0;
! 98: }
! 99:
! 100: static int
! 101: pipe_preexport(struct proto *P, rte **ee, struct linpool *p UNUSED)
! 102: {
! 103: struct proto *pp = (*ee)->sender->proto;
! 104:
! 105: if (pp == P)
! 106: return -1; /* Avoid local loops automatically */
! 107:
! 108: return 0;
! 109: }
! 110:
! 111: static void
! 112: pipe_reload_routes(struct channel *C)
! 113: {
! 114: struct pipe_proto *p = (void *) C->proto;
! 115:
! 116: /* Route reload on one channel is just refeed on the other */
! 117: channel_request_feeding((C == p->pri) ? p->sec : p->pri);
! 118: }
! 119:
! 120:
! 121: static void
! 122: pipe_postconfig(struct proto_config *CF)
! 123: {
! 124: struct pipe_config *cf = (void *) CF;
! 125: struct channel_config *cc = proto_cf_main_channel(CF);
! 126:
! 127: if (!cc->table)
! 128: cf_error("Primary routing table not specified");
! 129:
! 130: if (!cf->peer)
! 131: cf_error("Secondary routing table not specified");
! 132:
! 133: if (cc->table == cf->peer)
! 134: cf_error("Primary table and peer table must be different");
! 135:
! 136: if (cc->table->addr_type != cf->peer->addr_type)
! 137: cf_error("Primary table and peer table must have the same type");
! 138:
! 139: if (cc->rx_limit.action)
! 140: cf_error("Pipe protocol does not support receive limits");
! 141:
! 142: if (cc->in_keep_filtered)
! 143: cf_error("Pipe protocol prohibits keeping filtered routes");
! 144: }
! 145:
! 146: static int
! 147: pipe_configure_channels(struct pipe_proto *p, struct pipe_config *cf)
! 148: {
! 149: struct channel_config *cc = proto_cf_main_channel(&cf->c);
! 150:
! 151: struct channel_config pri_cf = {
! 152: .name = "pri",
! 153: .channel = cc->channel,
! 154: .table = cc->table,
! 155: .out_filter = cc->out_filter,
! 156: .in_limit = cc->in_limit,
! 157: .ra_mode = RA_ANY
! 158: };
! 159:
! 160: struct channel_config sec_cf = {
! 161: .name = "sec",
! 162: .channel = cc->channel,
! 163: .table = cf->peer,
! 164: .out_filter = cc->in_filter,
! 165: .in_limit = cc->out_limit,
! 166: .ra_mode = RA_ANY
! 167: };
! 168:
! 169: return
! 170: proto_configure_channel(&p->p, &p->pri, &pri_cf) &&
! 171: proto_configure_channel(&p->p, &p->sec, &sec_cf);
! 172: }
! 173:
! 174: static struct proto *
! 175: pipe_init(struct proto_config *CF)
! 176: {
! 177: struct proto *P = proto_new(CF);
! 178: struct pipe_proto *p = (void *) P;
! 179: struct pipe_config *cf = (void *) CF;
! 180:
! 181: P->rt_notify = pipe_rt_notify;
! 182: P->preexport = pipe_preexport;
! 183: P->reload_routes = pipe_reload_routes;
! 184:
! 185: pipe_configure_channels(p, cf);
! 186:
! 187: return P;
! 188: }
! 189:
! 190: static int
! 191: pipe_reconfigure(struct proto *P, struct proto_config *CF)
! 192: {
! 193: struct pipe_proto *p = (void *) P;
! 194: struct pipe_config *cf = (void *) CF;
! 195:
! 196: return pipe_configure_channels(p, cf);
! 197: }
! 198:
! 199: static void
! 200: pipe_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUSED)
! 201: {
! 202: /* Just a shallow copy, not many items here */
! 203: }
! 204:
! 205: static void
! 206: pipe_get_status(struct proto *P, byte *buf)
! 207: {
! 208: struct pipe_proto *p = (void *) P;
! 209:
! 210: bsprintf(buf, "%s <=> %s", p->pri->table->name, p->sec->table->name);
! 211: }
! 212:
! 213: static void
! 214: pipe_show_stats(struct pipe_proto *p)
! 215: {
! 216: struct proto_stats *s1 = &p->pri->stats;
! 217: struct proto_stats *s2 = &p->sec->stats;
! 218:
! 219: /*
! 220: * Pipe stats (as anything related to pipes) are a bit tricky. There
! 221: * are two sets of stats - s1 for ahook to the primary routing and
! 222: * s2 for the ahook to the secondary routing table. The user point
! 223: * of view is that routes going from the primary routing table to
! 224: * the secondary routing table are 'exported', while routes going in
! 225: * the other direction are 'imported'.
! 226: *
! 227: * Each route going through a pipe is, technically, first exported
! 228: * to the pipe and then imported from that pipe and such operations
! 229: * are counted in one set of stats according to the direction of the
! 230: * route propagation. Filtering is done just in the first part
! 231: * (export). Therefore, we compose stats for one directon for one
! 232: * user direction from both import and export stats, skipping
! 233: * immediate and irrelevant steps (exp_updates_accepted,
! 234: * imp_updates_received, imp_updates_filtered, ...).
! 235: *
! 236: * Rule of thumb is that stats s1 have the correct 'polarity'
! 237: * (imp/exp), while stats s2 have switched 'polarity'.
! 238: */
! 239:
! 240: cli_msg(-1006, " Routes: %u imported, %u exported",
! 241: s1->imp_routes, s2->imp_routes);
! 242: cli_msg(-1006, " Route change stats: received rejected filtered ignored accepted");
! 243: cli_msg(-1006, " Import updates: %10u %10u %10u %10u %10u",
! 244: s2->exp_updates_received, s2->exp_updates_rejected + s1->imp_updates_invalid,
! 245: s2->exp_updates_filtered, s1->imp_updates_ignored, s1->imp_updates_accepted);
! 246: cli_msg(-1006, " Import withdraws: %10u %10u --- %10u %10u",
! 247: s2->exp_withdraws_received, s1->imp_withdraws_invalid,
! 248: s1->imp_withdraws_ignored, s1->imp_withdraws_accepted);
! 249: cli_msg(-1006, " Export updates: %10u %10u %10u %10u %10u",
! 250: s1->exp_updates_received, s1->exp_updates_rejected + s2->imp_updates_invalid,
! 251: s1->exp_updates_filtered, s2->imp_updates_ignored, s2->imp_updates_accepted);
! 252: cli_msg(-1006, " Export withdraws: %10u %10u --- %10u %10u",
! 253: s1->exp_withdraws_received, s2->imp_withdraws_invalid,
! 254: s2->imp_withdraws_ignored, s2->imp_withdraws_accepted);
! 255: }
! 256:
! 257: static const char *pipe_feed_state[] = { [ES_DOWN] = "down", [ES_FEEDING] = "feed", [ES_READY] = "up" };
! 258:
! 259: static void
! 260: pipe_show_proto_info(struct proto *P)
! 261: {
! 262: struct pipe_proto *p = (void *) P;
! 263:
! 264: cli_msg(-1006, " Channel %s", "main");
! 265: cli_msg(-1006, " Table: %s", p->pri->table->name);
! 266: cli_msg(-1006, " Peer table: %s", p->sec->table->name);
! 267: cli_msg(-1006, " Import state: %s", pipe_feed_state[p->sec->export_state]);
! 268: cli_msg(-1006, " Export state: %s", pipe_feed_state[p->pri->export_state]);
! 269: cli_msg(-1006, " Import filter: %s", filter_name(p->sec->out_filter));
! 270: cli_msg(-1006, " Export filter: %s", filter_name(p->pri->out_filter));
! 271:
! 272: channel_show_limit(&p->pri->in_limit, "Import limit:");
! 273: channel_show_limit(&p->sec->in_limit, "Export limit:");
! 274:
! 275: if (P->proto_state != PS_DOWN)
! 276: pipe_show_stats(p);
! 277: }
! 278:
! 279:
! 280: struct protocol proto_pipe = {
! 281: .name = "Pipe",
! 282: .template = "pipe%d",
! 283: .class = PROTOCOL_PIPE,
! 284: .proto_size = sizeof(struct pipe_proto),
! 285: .config_size = sizeof(struct pipe_config),
! 286: .postconfig = pipe_postconfig,
! 287: .init = pipe_init,
! 288: .reconfigure = pipe_reconfigure,
! 289: .copy_config = pipe_copy_config,
! 290: .get_status = pipe_get_status,
! 291: .show_proto_info = pipe_show_proto_info
! 292: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pipe.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 / pipe