Annotation of embedaddon/bird/proto/mrt/mrt.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- Multi-Threaded Routing Toolkit (MRT) Protocol
! 3: *
! 4: * (c) 2017--2018 Ondrej Zajicek <santiago@crfreenet.org>
! 5: * (c) 2017--2018 CZ.NIC z.s.p.o.
! 6: *
! 7: * Can be freely distributed and used under the terms of the GNU GPL.
! 8: */
! 9:
! 10: /**
! 11: * DOC: Multi-Threaded Routing Toolkit (MRT) protocol
! 12: *
! 13: * The MRT protocol is implemented in just one file: |mrt.c|. It contains of
! 14: * several parts: Generic functions for preparing MRT messages in a buffer,
! 15: * functions for MRT table dump (called from timer or CLI), functions for MRT
! 16: * BGP4MP dump (called from BGP), and the usual protocol glue. For the MRT table
! 17: * dump, the key structure is struct mrt_table_dump_state, which contains all
! 18: * necessary data and created when the MRT dump cycle is started for the
! 19: * duration of the MRT dump. The MBGP4MP dump is currently not bound to MRT
! 20: * protocol instance and uses the config->mrtdump_file fd.
! 21: *
! 22: * The protocol is simple, just periodically scans routing table and export it
! 23: * to a file. It does not use the regular update mechanism, but a direct access
! 24: * in order to handle iteration through multiple routing tables. The table dump
! 25: * needs to dump all peers first and then use indexes to address the peers, we
! 26: * use a hash table (@peer_hash) to find peer index based on BGP protocol key
! 27: * attributes.
! 28: *
! 29: * One thing worth documenting is the locking. During processing, the currently
! 30: * processed table (@table field in the state structure) is locked and also the
! 31: * explicitly named table is locked (@table_ptr field in the state structure) if
! 32: * specified. Between dumps no table is locked. Also the current config is
! 33: * locked (by config_add_obstacle()) during table dumps as some data (strings,
! 34: * filters) are shared from the config and the running table dump may be
! 35: * interrupted by reconfiguration.
! 36: *
! 37: * Supported standards:
! 38: * - RFC 6396 - MRT format standard
! 39: * - RFC 8050 - ADD_PATH extension
! 40: */
! 41:
! 42: #include <unistd.h>
! 43: #include <limits.h>
! 44: #include <errno.h>
! 45:
! 46: #include "mrt.h"
! 47:
! 48: #include "nest/cli.h"
! 49: #include "filter/filter.h"
! 50: #include "proto/bgp/bgp.h"
! 51: #include "sysdep/unix/unix.h"
! 52:
! 53:
! 54: #ifdef PATH_MAX
! 55: #define BIRD_PATH_MAX PATH_MAX
! 56: #else
! 57: #define BIRD_PATH_MAX 4096
! 58: #endif
! 59:
! 60: #define mrt_log(s, msg, args...) \
! 61: ({ \
! 62: if (s->cli) \
! 63: cli_printf(s->cli, -8009, msg, ## args); \
! 64: if (s->proto) \
! 65: log(L_ERR "%s: " msg, s->proto->p.name, ## args); \
! 66: })
! 67:
! 68:
! 69: /*
! 70: * MRT buffer code
! 71: */
! 72:
! 73: static void
! 74: mrt_buffer_init(buffer *b, pool *pool, size_t n)
! 75: {
! 76: b->start = mb_alloc(pool, n);
! 77: b->pos = b->start;
! 78: b->end = b->start + n;
! 79: }
! 80:
! 81: static void
! 82: mrt_buffer_grow(buffer *b, size_t n)
! 83: {
! 84: size_t used = b->pos - b->start;
! 85: size_t size = b->end - b->start;
! 86: size_t req = used + n;
! 87:
! 88: while (size < req)
! 89: size = size * 3 / 2;
! 90:
! 91: b->start = mb_realloc(b->start, size);
! 92: b->pos = b->start + used;
! 93: b->end = b->start + size;
! 94: }
! 95:
! 96: static inline void
! 97: mrt_buffer_need(buffer *b, size_t n)
! 98: {
! 99: if (b->pos + n > b->end)
! 100: mrt_buffer_grow(b, n);
! 101: }
! 102:
! 103: static inline uint
! 104: mrt_buffer_pos(buffer *b)
! 105: {
! 106: return b->pos - b->start;
! 107: }
! 108:
! 109: static inline void
! 110: mrt_buffer_flush(buffer *b)
! 111: {
! 112: b->pos = b->start;
! 113: }
! 114:
! 115: #define MRT_DEFINE_TYPE(S, T) \
! 116: static inline void mrt_put_##S##_(buffer *b, T x) \
! 117: { \
! 118: put_##S(b->pos, x); \
! 119: b->pos += sizeof(T); \
! 120: } \
! 121: \
! 122: static inline void mrt_put_##S(buffer *b, T x) \
! 123: { \
! 124: mrt_buffer_need(b, sizeof(T)); \
! 125: put_##S(b->pos, x); \
! 126: b->pos += sizeof(T); \
! 127: }
! 128:
! 129: MRT_DEFINE_TYPE(u8, u8)
! 130: MRT_DEFINE_TYPE(u16, u16)
! 131: MRT_DEFINE_TYPE(u32, u32)
! 132: MRT_DEFINE_TYPE(u64, u64)
! 133: MRT_DEFINE_TYPE(ip4, ip4_addr)
! 134: MRT_DEFINE_TYPE(ip6, ip6_addr)
! 135:
! 136: static inline void
! 137: mrt_put_ipa(buffer *b, ip_addr x)
! 138: {
! 139: if (ipa_is_ip4(x))
! 140: mrt_put_ip4(b, ipa_to_ip4(x));
! 141: else
! 142: mrt_put_ip6(b, ipa_to_ip6(x));
! 143: }
! 144:
! 145: static inline void
! 146: mrt_put_data(buffer *b, const void *src, size_t n)
! 147: {
! 148: if (!n)
! 149: return;
! 150:
! 151: mrt_buffer_need(b, n);
! 152: memcpy(b->pos, src, n);
! 153: b->pos += n;
! 154: }
! 155:
! 156: static void
! 157: mrt_init_message(buffer *b, u16 type, u16 subtype)
! 158: {
! 159: /* Reset buffer */
! 160: mrt_buffer_flush(b);
! 161: mrt_buffer_need(b, MRT_HDR_LENGTH);
! 162:
! 163: /* Prepare header */
! 164: mrt_put_u32_(b, now_real);
! 165: mrt_put_u16_(b, type);
! 166: mrt_put_u16_(b, subtype);
! 167:
! 168: /* Message length, will be fixed later */
! 169: mrt_put_u32_(b, 0);
! 170: }
! 171:
! 172: static void
! 173: mrt_dump_message(buffer *b, int fd)
! 174: {
! 175: uint len = mrt_buffer_pos(b);
! 176:
! 177: /* Fix message length */
! 178: ASSERT(len >= MRT_HDR_LENGTH);
! 179: put_u32(b->start + 8, len - MRT_HDR_LENGTH);
! 180:
! 181: if (fd < 0)
! 182: return;
! 183:
! 184: if (write(fd, b->start, len) < 0)
! 185: log(L_ERR "Write to MRT file failed: %m"); /* TODO: name of file */
! 186: }
! 187:
! 188: static int
! 189: bstrsub(char *dst, size_t n, const char *src, const char *key, const char *val)
! 190: {
! 191: const char *last, *next;
! 192: char *pos = dst;
! 193: size_t step, klen = strlen(key), vlen = strlen(val);
! 194:
! 195: for (last = src; next = strstr(last, key); last = next + klen)
! 196: {
! 197: step = next - last;
! 198: if (n <= step + vlen)
! 199: return 0;
! 200:
! 201: memcpy(pos, last, step);
! 202: ADVANCE(pos, n, step);
! 203:
! 204: memcpy(pos, val, vlen);
! 205: ADVANCE(pos, n, vlen);
! 206: }
! 207:
! 208: step = strlen(last);
! 209: if (n <= step)
! 210: return 0;
! 211:
! 212: memcpy(pos, last, step);
! 213: ADVANCE(pos, n, step);
! 214:
! 215: pos[0] = 0;
! 216: return 1;
! 217: }
! 218:
! 219: static inline rtable *
! 220: mrt_next_table_(rtable *tab, rtable *tab_ptr, const char *pattern)
! 221: {
! 222: /* Handle explicit table, return it in the first pass */
! 223: if (tab_ptr)
! 224: return !tab ? tab_ptr : NULL;
! 225:
! 226: /* Walk routing_tables list, starting after tab (if non-NULL) */
! 227: for (tab = !tab ? HEAD(routing_tables) : NODE_NEXT(tab);
! 228: NODE_VALID(tab);
! 229: tab = NODE_NEXT(tab))
! 230: if (patmatch(pattern, tab->name))
! 231: return tab;
! 232:
! 233: return NULL;
! 234: }
! 235:
! 236: static rtable *
! 237: mrt_next_table(struct mrt_table_dump_state *s)
! 238: {
! 239: rtable *tab = mrt_next_table_(s->table, s->table_ptr, s->table_expr);
! 240:
! 241: if (s->table)
! 242: rt_unlock_table(s->table);
! 243:
! 244: s->table = tab;
! 245:
! 246: if (s->table)
! 247: rt_lock_table(s->table);
! 248:
! 249: return s->table;
! 250: }
! 251:
! 252: static int
! 253: mrt_open_file(struct mrt_table_dump_state *s)
! 254: {
! 255: char fmt1[BIRD_PATH_MAX];
! 256: char name[BIRD_PATH_MAX];
! 257:
! 258: if (!bstrsub(fmt1, sizeof(fmt1), s->filename, "%N", s->table->name) ||
! 259: !tm_format_real_time(name, sizeof(name), fmt1, now_real))
! 260: {
! 261: mrt_log(s, "Invalid filename '%s'", s->filename);
! 262: return 0;
! 263: }
! 264:
! 265: s->file = rf_open(s->pool, name, "a");
! 266: if (!s->file)
! 267: {
! 268: mrt_log(s, "Unable to open MRT file '%s': %m", name);
! 269: return 0;
! 270: }
! 271:
! 272: s->fd = rf_fileno(s->file);
! 273: s->time_offset = now_real - now;
! 274:
! 275: return 1;
! 276: }
! 277:
! 278: static void
! 279: mrt_close_file(struct mrt_table_dump_state *s)
! 280: {
! 281: rfree(s->file);
! 282: s->file = NULL;
! 283: s->fd = -1;
! 284: }
! 285:
! 286:
! 287: /*
! 288: * MRT Table Dump: Peer Index Table
! 289: */
! 290:
! 291: #define PEER_KEY(n) n->peer_id, n->peer_as, n->peer_ip
! 292: #define PEER_NEXT(n) n->next
! 293: #define PEER_EQ(id1,as1,ip1,id2,as2,ip2) \
! 294: id1 == id2 && as1 == as2 && ipa_equal(ip1, ip2)
! 295: #define PEER_FN(id,as,ip) ipa_hash(ip)
! 296:
! 297: static void
! 298: mrt_peer_table_header(struct mrt_table_dump_state *s, u32 router_id, const char *name)
! 299: {
! 300: buffer *b = &s->buf;
! 301:
! 302: /* Collector BGP ID */
! 303: mrt_put_u32(b, router_id);
! 304:
! 305: /* View Name */
! 306: uint name_length = name ? strlen(name) : 0;
! 307: name_length = MIN(name_length, 65535);
! 308: mrt_put_u16(b, name_length);
! 309: mrt_put_data(b, name, name_length);
! 310:
! 311: /* Peer Count, will be fixed later */
! 312: s->peer_count = 0;
! 313: s->peer_count_offset = mrt_buffer_pos(b);
! 314: mrt_put_u16(b, 0);
! 315:
! 316: HASH_INIT(s->peer_hash, s->pool, 10);
! 317: }
! 318:
! 319: static void
! 320: mrt_peer_table_entry(struct mrt_table_dump_state *s, u32 peer_id, u32 peer_as, ip_addr peer_ip)
! 321: {
! 322: buffer *b = &s->buf;
! 323:
! 324: uint type = MRT_PEER_TYPE_32BIT_ASN;
! 325: if (ipa_is_ip6(peer_ip))
! 326: type |= MRT_PEER_TYPE_IPV6;
! 327:
! 328: /* Dump peer to buffer */
! 329: mrt_put_u8(b, type);
! 330: mrt_put_u32(b, peer_id);
! 331: mrt_put_ipa(b, peer_ip);
! 332: mrt_put_u32(b, peer_as);
! 333:
! 334: /* Add peer to hash table */
! 335: struct mrt_peer_entry *n = lp_allocz(s->peer_lp, sizeof(struct mrt_peer_entry));
! 336: n->peer_id = peer_id;
! 337: n->peer_as = peer_as;
! 338: n->peer_ip = peer_ip;
! 339: n->index = s->peer_count++;
! 340:
! 341: HASH_INSERT(s->peer_hash, PEER, n);
! 342: }
! 343:
! 344: static void
! 345: mrt_peer_table_dump(struct mrt_table_dump_state *s)
! 346: {
! 347: mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, MRT_PEER_INDEX_TABLE);
! 348: mrt_peer_table_header(s, config->router_id, s->table->name);
! 349:
! 350: /* 0 is fake peer for non-BGP routes */
! 351: mrt_peer_table_entry(s, 0, 0, IPA_NONE);
! 352:
! 353: #ifdef CONFIG_BGP
! 354: struct proto *P;
! 355: WALK_LIST(P, active_proto_list)
! 356: if (P->proto == &proto_bgp)
! 357: {
! 358: struct bgp_proto *p = (void *) P;
! 359: mrt_peer_table_entry(s, p->remote_id, p->remote_as, p->cf->remote_ip);
! 360: }
! 361: #endif
! 362:
! 363: /* Fix Peer Count */
! 364: put_u16(s->buf.start + s->peer_count_offset, s->peer_count);
! 365:
! 366: mrt_dump_message(&s->buf, s->fd);
! 367: }
! 368:
! 369: static void
! 370: mrt_peer_table_flush(struct mrt_table_dump_state *s)
! 371: {
! 372: lp_flush(s->peer_lp);
! 373: HASH_FREE(s->peer_hash);
! 374: }
! 375:
! 376:
! 377: /*
! 378: * MRT Table Dump: RIB Table
! 379: */
! 380:
! 381: static void
! 382: mrt_rib_table_header(struct mrt_table_dump_state *s, net *n)
! 383: {
! 384: buffer *b = &s->buf;
! 385:
! 386: /* Sequence Number */
! 387: mrt_put_u32(b, s->seqnum);
! 388:
! 389: /* Network Prefix */
! 390: ip_addr a = n->n.prefix;
! 391: ipa_hton(a);
! 392:
! 393: mrt_put_u8(b, n->n.pxlen);
! 394: mrt_put_data(b, &a, BYTES(n->n.pxlen));
! 395:
! 396: /* Entry Count, will be fixed later */
! 397: s->entry_count = 0;
! 398: s->entry_count_offset = mrt_buffer_pos(b);
! 399: mrt_put_u16(b, 0);
! 400: }
! 401:
! 402: static void
! 403: mrt_rib_table_entry(struct mrt_table_dump_state *s, rte *r, struct ea_list *tmpa)
! 404: {
! 405: buffer *b = &s->buf;
! 406: uint peer = 0;
! 407:
! 408: #ifdef CONFIG_BGP
! 409: /* Find peer index */
! 410: if (r->attrs->src->proto->proto == &proto_bgp)
! 411: {
! 412: struct bgp_proto *p = (void *) r->attrs->src->proto;
! 413: struct mrt_peer_entry *n =
! 414: HASH_FIND(s->peer_hash, PEER, p->remote_id, p->remote_as, p->cf->remote_ip);
! 415:
! 416: peer = n ? n->index : 0;
! 417: }
! 418: #endif
! 419:
! 420: /* Peer Index and Originated Time */
! 421: mrt_put_u16(b, peer);
! 422: mrt_put_u32(b, r->lastmod + s->time_offset);
! 423:
! 424: /* Path Identifier */
! 425: if (s->add_path)
! 426: mrt_put_u32(b, r->attrs->src->private_id);
! 427:
! 428: /* Route Attributes */
! 429: mrt_put_u16(b, 0);
! 430:
! 431: #ifdef CONFIG_BGP
! 432: if (r->attrs->eattrs || tmpa)
! 433: {
! 434: struct ea_list *eattrs = r->attrs->eattrs;
! 435:
! 436: if (!rta_is_cached(r->attrs) || tmpa)
! 437: {
! 438: /* Attributes must be merged and sorted for bgp_encode_attrs() */
! 439: tmpa = ea_append(tmpa, eattrs);
! 440: eattrs = alloca(ea_scan(tmpa));
! 441: ea_merge(tmpa, eattrs);
! 442: ea_sort(eattrs);
! 443: }
! 444:
! 445: mrt_buffer_need(b, MRT_ATTR_BUFFER_SIZE);
! 446: int alen = bgp_encode_attrs(NULL, b->pos, eattrs, MRT_ATTR_BUFFER_SIZE);
! 447:
! 448: if (alen < 0)
! 449: {
! 450: mrt_log(s, "Attribute list too long for %I/%d",
! 451: r->net->n.prefix, r->net->n.pxlen);
! 452: alen = 0;
! 453: }
! 454:
! 455: put_u16(b->pos - 2, alen);
! 456: b->pos += alen;
! 457: }
! 458: #endif
! 459:
! 460: s->entry_count++;
! 461: }
! 462:
! 463: static void
! 464: mrt_rib_table_dump(struct mrt_table_dump_state *s, net *n, int add_path)
! 465: {
! 466: rte *rt, *rt0;
! 467: int subtype;
! 468:
! 469: s->add_path = add_path;
! 470:
! 471: #ifndef IPV6
! 472: subtype = !add_path ? MRT_RIB_IPV4_UNICAST : MRT_RIB_IPV4_UNICAST_ADDPATH;
! 473: #else
! 474: subtype = !add_path ? MRT_RIB_IPV6_UNICAST : MRT_RIB_IPV6_UNICAST_ADDPATH;
! 475: #endif
! 476:
! 477: mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, subtype);
! 478: mrt_rib_table_header(s, n);
! 479:
! 480: for (rt0 = n->routes; rt = rt0; rt0 = rt0->next)
! 481: {
! 482: if (rte_is_filtered(rt))
! 483: continue;
! 484:
! 485: /* Skip routes that should be reported in the other phase */
! 486: if (!s->always_add_path && (!rt->attrs->src->private_id != !s->add_path))
! 487: {
! 488: s->want_add_path = 1;
! 489: continue;
! 490: }
! 491:
! 492: struct ea_list *tmp_attrs = rte_make_tmp_attrs(rt, s->linpool);
! 493:
! 494: if (f_run(s->filter, &rt, &tmp_attrs, s->linpool, 0) <= F_ACCEPT)
! 495: mrt_rib_table_entry(s, rt, tmp_attrs);
! 496:
! 497: if (rt != rt0)
! 498: rte_free(rt);
! 499:
! 500: lp_flush(s->linpool);
! 501: }
! 502:
! 503: /* Fix Entry Count */
! 504: put_u16(s->buf.start + s->entry_count_offset, s->entry_count);
! 505:
! 506: /* Update max counter */
! 507: s->max -= 1 + s->entry_count;
! 508:
! 509: /* Skip empty entries */
! 510: if (!s->entry_count)
! 511: return;
! 512:
! 513: s->seqnum++;
! 514: mrt_dump_message(&s->buf, s->fd);
! 515: }
! 516:
! 517:
! 518: /*
! 519: * MRT Table Dump: main logic
! 520: */
! 521:
! 522: static struct mrt_table_dump_state *
! 523: mrt_table_dump_init(pool *pp)
! 524: {
! 525: pool *pool = rp_new(pp, "MRT Table Dump");
! 526: struct mrt_table_dump_state *s = mb_allocz(pool, sizeof(struct mrt_table_dump_state));
! 527:
! 528: s->pool = pool;
! 529: s->linpool = lp_new(pool, 4080);
! 530: s->peer_lp = lp_new(pool, 4080);
! 531: mrt_buffer_init(&s->buf, pool, 2 * MRT_ATTR_BUFFER_SIZE);
! 532:
! 533: /* We lock the current config as we may reference it indirectly by filter */
! 534: s->config = config;
! 535: config_add_obstacle(s->config);
! 536:
! 537: s->fd = -1;
! 538:
! 539: return s;
! 540: }
! 541:
! 542: static void
! 543: mrt_table_dump_free(struct mrt_table_dump_state *s)
! 544: {
! 545: if (s->table_open)
! 546: FIB_ITERATE_UNLINK(&s->fit, &s->table->fib);
! 547:
! 548: if (s->table)
! 549: rt_unlock_table(s->table);
! 550:
! 551: if (s->table_ptr)
! 552: rt_unlock_table(s->table_ptr);
! 553:
! 554: config_del_obstacle(s->config);
! 555:
! 556: rfree(s->pool);
! 557: }
! 558:
! 559:
! 560: static int
! 561: mrt_table_dump_step(struct mrt_table_dump_state *s)
! 562: {
! 563: s->max = 2048;
! 564:
! 565: if (s->table_open)
! 566: goto step;
! 567:
! 568: while (mrt_next_table(s))
! 569: {
! 570: if (!mrt_open_file(s))
! 571: continue;
! 572:
! 573: mrt_peer_table_dump(s);
! 574:
! 575: FIB_ITERATE_INIT(&s->fit, &s->table->fib);
! 576: s->table_open = 1;
! 577:
! 578: step:
! 579: FIB_ITERATE_START(&s->table->fib, &s->fit, fn)
! 580: {
! 581: if (s->max < 0)
! 582: {
! 583: FIB_ITERATE_PUT(&s->fit, fn);
! 584: return 0;
! 585: }
! 586:
! 587: /* With Always ADD_PATH option, we jump directly to second phase */
! 588: s->want_add_path = s->always_add_path;
! 589:
! 590: if (s->want_add_path == 0)
! 591: mrt_rib_table_dump(s, (net *) fn, 0);
! 592:
! 593: if (s->want_add_path == 1)
! 594: mrt_rib_table_dump(s, (net *) fn, 1);
! 595: }
! 596: FIB_ITERATE_END(fn);
! 597: s->table_open = 0;
! 598:
! 599: mrt_close_file(s);
! 600: mrt_peer_table_flush(s);
! 601: }
! 602:
! 603: return 1;
! 604: }
! 605:
! 606: static void
! 607: mrt_timer(timer *t)
! 608: {
! 609: struct mrt_proto *p = t->data;
! 610: struct mrt_config *cf = (void *) (p->p.cf);
! 611:
! 612: if (p->table_dump)
! 613: {
! 614: log(L_WARN "%s: Earlier RIB table dump still not finished, skipping next one", p->p.name);
! 615: return;
! 616: }
! 617:
! 618: TRACE(D_EVENTS, "RIB table dump started");
! 619:
! 620: struct mrt_table_dump_state *s = mrt_table_dump_init(p->p.pool);
! 621:
! 622: s->proto = p;
! 623: s->table_expr = cf->table_expr;
! 624: s->table_ptr = cf->table_cf ? cf->table_cf->table : NULL;
! 625: s->filter = cf->filter;
! 626: s->filename = cf->filename;
! 627: s->always_add_path = cf->always_add_path;
! 628:
! 629: if (s->table_ptr)
! 630: rt_lock_table(s->table_ptr);
! 631:
! 632: p->table_dump = s;
! 633: ev_schedule(p->event);
! 634: }
! 635:
! 636: static void
! 637: mrt_event(void *P)
! 638: {
! 639: struct mrt_proto *p = P;
! 640:
! 641: if (!p->table_dump)
! 642: return;
! 643:
! 644: if (!mrt_table_dump_step(p->table_dump))
! 645: {
! 646: ev_schedule(p->event);
! 647: return;
! 648: }
! 649:
! 650: mrt_table_dump_free(p->table_dump);
! 651: p->table_dump = NULL;
! 652:
! 653: TRACE(D_EVENTS, "RIB table dump done");
! 654:
! 655: if (p->p.proto_state == PS_STOP)
! 656: proto_notify_state(&p->p, PS_DOWN);
! 657: }
! 658:
! 659:
! 660: /*
! 661: * MRT Table Dump: CLI command
! 662: */
! 663:
! 664: static void
! 665: mrt_dump_cont(struct cli *c)
! 666: {
! 667: if (!mrt_table_dump_step(c->rover))
! 668: return;
! 669:
! 670: cli_printf(c, 0, "");
! 671: mrt_table_dump_free(c->rover);
! 672: c->cont = c->cleanup = c->rover = NULL;
! 673: }
! 674:
! 675: static void
! 676: mrt_dump_cleanup(struct cli *c)
! 677: {
! 678: mrt_table_dump_free(c->rover);
! 679: c->rover = NULL;
! 680: }
! 681:
! 682: void
! 683: mrt_dump_cmd(struct mrt_dump_data *d)
! 684: {
! 685: if (cli_access_restricted())
! 686: return;
! 687:
! 688: if (!d->table_expr && !d->table_ptr)
! 689: cf_error("Table not specified");
! 690:
! 691: if (!d->filename)
! 692: cf_error("File not specified");
! 693:
! 694: struct mrt_table_dump_state *s = mrt_table_dump_init(this_cli->pool);
! 695:
! 696: s->cli = this_cli;
! 697: s->table_expr = d->table_expr;
! 698: s->table_ptr = d->table_ptr;
! 699: s->filter = d->filter;
! 700: s->filename = d->filename;
! 701:
! 702: if (s->table_ptr)
! 703: rt_lock_table(s->table_ptr);
! 704:
! 705: this_cli->cont = mrt_dump_cont;
! 706: this_cli->cleanup = mrt_dump_cleanup;
! 707: this_cli->rover = s;
! 708: }
! 709:
! 710:
! 711: /*
! 712: * MRT BGP4MP dump
! 713: */
! 714:
! 715: static buffer *
! 716: mrt_bgp_buffer(void)
! 717: {
! 718: /* Static buffer for BGP4MP dump, TODO: change to use MRT protocol */
! 719: static buffer b;
! 720:
! 721: if (!b.start)
! 722: mrt_buffer_init(&b, &root_pool, 1024);
! 723:
! 724: return &b;
! 725: }
! 726:
! 727: static void
! 728: mrt_bgp_header(buffer *b, struct mrt_bgp_data *d)
! 729: {
! 730: if (d->as4)
! 731: {
! 732: mrt_put_u32(b, d->peer_as);
! 733: mrt_put_u32(b, d->local_as);
! 734: }
! 735: else
! 736: {
! 737: mrt_put_u16(b, (d->peer_as <= 0xFFFF) ? d->peer_as : AS_TRANS);
! 738: mrt_put_u16(b, (d->local_as <= 0xFFFF) ? d->local_as : AS_TRANS);
! 739: }
! 740:
! 741: mrt_put_u16(b, (d->index <= 0xFFFF) ? d->index : 0);
! 742: mrt_put_u16(b, d->af);
! 743:
! 744: if (d->af == BGP_AF_IPV4)
! 745: {
! 746: mrt_put_ip4(b, ipa_to_ip4(d->peer_ip));
! 747: mrt_put_ip4(b, ipa_to_ip4(d->local_ip));
! 748: }
! 749: else
! 750: {
! 751: mrt_put_ip6(b, ipa_to_ip6(d->peer_ip));
! 752: mrt_put_ip6(b, ipa_to_ip6(d->local_ip));
! 753: }
! 754: }
! 755:
! 756: void
! 757: mrt_dump_bgp_message(struct mrt_bgp_data *d)
! 758: {
! 759: const u16 subtypes[] = {
! 760: MRT_BGP4MP_MESSAGE, MRT_BGP4MP_MESSAGE_AS4,
! 761: MRT_BGP4MP_MESSAGE_LOCAL, MRT_BGP4MP_MESSAGE_AS4_LOCAL,
! 762: MRT_BGP4MP_MESSAGE_ADDPATH, MRT_BGP4MP_MESSAGE_AS4_ADDPATH,
! 763: MRT_BGP4MP_MESSAGE_LOCAL_ADDPATH, MRT_BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH,
! 764: };
! 765:
! 766: buffer *b = mrt_bgp_buffer();
! 767: mrt_init_message(b, MRT_BGP4MP, subtypes[d->as4 + 4*d->add_path]);
! 768: mrt_bgp_header(b, d);
! 769: mrt_put_data(b, d->message, d->msg_len);
! 770: mrt_dump_message(b, config->mrtdump_file);
! 771: }
! 772:
! 773: void
! 774: mrt_dump_bgp_state_change(struct mrt_bgp_data *d)
! 775: {
! 776: /* Convert state from our BS_* values to values used in MRTDump */
! 777: const u16 states[BS_MAX] = {1, 2, 3, 4, 5, 6, 1};
! 778:
! 779: if (states[d->old_state] == states[d->new_state])
! 780: return;
! 781:
! 782: /* Always use AS4 mode for STATE_CHANGE */
! 783: d->as4 = 1;
! 784:
! 785: buffer *b = mrt_bgp_buffer();
! 786: mrt_init_message(b, MRT_BGP4MP, MRT_BGP4MP_STATE_CHANGE_AS4);
! 787: mrt_bgp_header(b, d);
! 788: mrt_put_u16(b, states[d->old_state]);
! 789: mrt_put_u16(b, states[d->new_state]);
! 790: mrt_dump_message(b, config->mrtdump_file);
! 791: }
! 792:
! 793:
! 794: /*
! 795: * MRT protocol glue
! 796: */
! 797:
! 798: void
! 799: mrt_check_config(struct proto_config *C)
! 800: {
! 801: struct mrt_config *cf = (void *) C;
! 802:
! 803: /* c.table must be always defined, but it is relevant only if table_expr is not set */
! 804: if (!cf->table_expr)
! 805: cf->table_cf = cf->c.table;
! 806:
! 807: if (!cf->table_expr && !cf->table_cf)
! 808: cf_error("Table not specified");
! 809:
! 810: if (!cf->filename)
! 811: cf_error("File not specified");
! 812:
! 813: if (!cf->period)
! 814: cf_error("Period not specified");
! 815: }
! 816:
! 817: static struct proto *
! 818: mrt_init(struct proto_config *C)
! 819: {
! 820: struct proto *P = proto_new(C, sizeof(struct mrt_proto));
! 821:
! 822: return P;
! 823: }
! 824:
! 825: static int
! 826: mrt_start(struct proto *P)
! 827: {
! 828: struct mrt_proto *p = (void *) P;
! 829: struct mrt_config *cf = (void *) (P->cf);
! 830:
! 831: p->timer = tm_new_set(P->pool, mrt_timer, p, 0, cf->period);
! 832: p->event = ev_new_set(P->pool, mrt_event, p);
! 833:
! 834: tm_start(p->timer, cf->period);
! 835:
! 836: return PS_UP;
! 837: }
! 838:
! 839: static int
! 840: mrt_shutdown(struct proto *P)
! 841: {
! 842: struct mrt_proto *p = (void *) P;
! 843:
! 844: return p->table_dump ? PS_STOP : PS_DOWN;
! 845: }
! 846:
! 847: static int
! 848: mrt_reconfigure(struct proto *P, struct proto_config *CF)
! 849: {
! 850: struct mrt_proto *p = (void *) P;
! 851: struct mrt_config *old = (void *) (P->cf);
! 852: struct mrt_config *new = (void *) CF;
! 853:
! 854: if (new->period != old->period)
! 855: {
! 856: TRACE(D_EVENTS, "Changing period from %d to %d s", old->period, new->period);
! 857:
! 858: bird_clock_t new_time = p->timer->expires - old->period + new->period;
! 859: tm_start(p->timer, (new_time > now) ? (new_time - now) : 0);
! 860: p->timer->recurrent = new->period;
! 861: }
! 862:
! 863: return 1;
! 864: }
! 865:
! 866: static void
! 867: mrt_copy_config(struct proto_config *dest, struct proto_config *src)
! 868: {
! 869: /* Just a shallow copy, not many items here */
! 870: proto_copy_rest(dest, src, sizeof(struct mrt_config));
! 871: }
! 872:
! 873:
! 874: struct protocol proto_mrt = {
! 875: .name = "MRT",
! 876: .template = "mrt%d",
! 877: .config_size = sizeof(struct mrt_config),
! 878: .init = mrt_init,
! 879: .start = mrt_start,
! 880: .shutdown = mrt_shutdown,
! 881: .reconfigure = mrt_reconfigure,
! 882: .copy_config = mrt_copy_config,
! 883: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mrt.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / proto / mrt