Annotation of embedaddon/bird2/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, current_real_time() TO_S); /* 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: ((tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6)))
! 232: return tab;
! 233:
! 234: return NULL;
! 235: }
! 236:
! 237: static rtable *
! 238: mrt_next_table(struct mrt_table_dump_state *s)
! 239: {
! 240: rtable *tab = mrt_next_table_(s->table, s->table_ptr, s->table_expr);
! 241:
! 242: if (s->table)
! 243: rt_unlock_table(s->table);
! 244:
! 245: s->table = tab;
! 246: s->ipv4 = tab ? (tab->addr_type == NET_IP4) : 0;
! 247: s->bws->mp_reach = !s->ipv4;
! 248:
! 249: if (s->table)
! 250: rt_lock_table(s->table);
! 251:
! 252: return s->table;
! 253: }
! 254:
! 255: static int
! 256: mrt_open_file(struct mrt_table_dump_state *s)
! 257: {
! 258: char fmt1[BIRD_PATH_MAX];
! 259: char name[BIRD_PATH_MAX];
! 260: btime now = current_time();
! 261: btime now_real = current_real_time();
! 262:
! 263: if (!bstrsub(fmt1, sizeof(fmt1), s->filename, "%N", s->table->name) ||
! 264: !tm_format_real_time(name, sizeof(name), fmt1, now_real))
! 265: {
! 266: mrt_log(s, "Invalid filename '%s'", s->filename);
! 267: return 0;
! 268: }
! 269:
! 270: s->file = rf_open(s->pool, name, "a");
! 271: if (!s->file)
! 272: {
! 273: mrt_log(s, "Unable to open MRT file '%s': %m", name);
! 274: return 0;
! 275: }
! 276:
! 277: s->fd = rf_fileno(s->file);
! 278: s->time_offset = now_real - now;
! 279:
! 280: return 1;
! 281: }
! 282:
! 283: static void
! 284: mrt_close_file(struct mrt_table_dump_state *s)
! 285: {
! 286: rfree(s->file);
! 287: s->file = NULL;
! 288: s->fd = -1;
! 289: }
! 290:
! 291:
! 292: /*
! 293: * MRT Table Dump: Peer Index Table
! 294: */
! 295:
! 296: #define PEER_KEY(n) n->peer_id, n->peer_as, n->peer_ip
! 297: #define PEER_NEXT(n) n->next
! 298: #define PEER_EQ(id1,as1,ip1,id2,as2,ip2) \
! 299: id1 == id2 && as1 == as2 && ipa_equal(ip1, ip2)
! 300: #define PEER_FN(id,as,ip) ipa_hash(ip)
! 301:
! 302: static void
! 303: mrt_peer_table_header(struct mrt_table_dump_state *s, u32 router_id, const char *name)
! 304: {
! 305: buffer *b = &s->buf;
! 306:
! 307: /* Collector BGP ID */
! 308: mrt_put_u32(b, router_id);
! 309:
! 310: /* View Name */
! 311: uint name_length = name ? strlen(name) : 0;
! 312: name_length = MIN(name_length, 65535);
! 313: mrt_put_u16(b, name_length);
! 314: mrt_put_data(b, name, name_length);
! 315:
! 316: /* Peer Count, will be fixed later */
! 317: s->peer_count = 0;
! 318: s->peer_count_offset = mrt_buffer_pos(b);
! 319: mrt_put_u16(b, 0);
! 320:
! 321: HASH_INIT(s->peer_hash, s->pool, 10);
! 322: }
! 323:
! 324: static void
! 325: mrt_peer_table_entry(struct mrt_table_dump_state *s, u32 peer_id, u32 peer_as, ip_addr peer_ip)
! 326: {
! 327: buffer *b = &s->buf;
! 328:
! 329: uint type = MRT_PEER_TYPE_32BIT_ASN;
! 330: if (ipa_is_ip6(peer_ip))
! 331: type |= MRT_PEER_TYPE_IPV6;
! 332:
! 333: /* Dump peer to buffer */
! 334: mrt_put_u8(b, type);
! 335: mrt_put_u32(b, peer_id);
! 336: mrt_put_ipa(b, peer_ip);
! 337: mrt_put_u32(b, peer_as);
! 338:
! 339: /* Add peer to hash table */
! 340: struct mrt_peer_entry *n = lp_allocz(s->peer_lp, sizeof(struct mrt_peer_entry));
! 341: n->peer_id = peer_id;
! 342: n->peer_as = peer_as;
! 343: n->peer_ip = peer_ip;
! 344: n->index = s->peer_count++;
! 345:
! 346: HASH_INSERT(s->peer_hash, PEER, n);
! 347: }
! 348:
! 349: static void
! 350: mrt_peer_table_dump(struct mrt_table_dump_state *s)
! 351: {
! 352: mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, MRT_PEER_INDEX_TABLE);
! 353: mrt_peer_table_header(s, config->router_id, s->table->name);
! 354:
! 355: /* 0 is fake peer for non-BGP routes */
! 356: mrt_peer_table_entry(s, 0, 0, IPA_NONE);
! 357:
! 358: #ifdef CONFIG_BGP
! 359: struct proto *P;
! 360: WALK_LIST(P, proto_list)
! 361: if ((P->proto == &proto_bgp) && (P->proto_state != PS_DOWN))
! 362: {
! 363: struct bgp_proto *p = (void *) P;
! 364: mrt_peer_table_entry(s, p->remote_id, p->remote_as, p->remote_ip);
! 365: }
! 366: #endif
! 367:
! 368: /* Fix Peer Count */
! 369: put_u16(s->buf.start + s->peer_count_offset, s->peer_count);
! 370:
! 371: mrt_dump_message(&s->buf, s->fd);
! 372: }
! 373:
! 374: static void
! 375: mrt_peer_table_flush(struct mrt_table_dump_state *s)
! 376: {
! 377: lp_flush(s->peer_lp);
! 378: HASH_FREE(s->peer_hash);
! 379: }
! 380:
! 381:
! 382: /*
! 383: * MRT Table Dump: RIB Table
! 384: */
! 385:
! 386: static void
! 387: mrt_rib_table_header(struct mrt_table_dump_state *s, net_addr *n)
! 388: {
! 389: buffer *b = &s->buf;
! 390:
! 391: /* Sequence Number */
! 392: mrt_put_u32(b, s->seqnum);
! 393:
! 394: /* Network Prefix */
! 395: if (s->ipv4)
! 396: {
! 397: ASSERT(n->type == NET_IP4);
! 398: ip4_addr a = ip4_hton(net4_prefix(n));
! 399: uint len = net4_pxlen(n);
! 400:
! 401: mrt_put_u8(b, len);
! 402: mrt_put_data(b, &a, BYTES(len));
! 403: }
! 404: else
! 405: {
! 406: ASSERT(n->type == NET_IP6);
! 407: ip6_addr a = ip6_hton(net6_prefix(n));
! 408: uint len = net6_pxlen(n);
! 409:
! 410: mrt_put_u8(b, len);
! 411: mrt_put_data(b, &a, BYTES(len));
! 412: }
! 413:
! 414: /* Entry Count, will be fixed later */
! 415: s->entry_count = 0;
! 416: s->entry_count_offset = mrt_buffer_pos(b);
! 417: mrt_put_u16(b, 0);
! 418: }
! 419:
! 420: static void
! 421: mrt_rib_table_entry(struct mrt_table_dump_state *s, rte *r)
! 422: {
! 423: buffer *b = &s->buf;
! 424: uint peer = 0;
! 425:
! 426: #ifdef CONFIG_BGP
! 427: /* Find peer index */
! 428: if (r->attrs->src->proto->proto == &proto_bgp)
! 429: {
! 430: struct bgp_proto *p = (void *) r->attrs->src->proto;
! 431: struct mrt_peer_entry *n =
! 432: HASH_FIND(s->peer_hash, PEER, p->remote_id, p->remote_as, p->remote_ip);
! 433:
! 434: peer = n ? n->index : 0;
! 435: }
! 436: #endif
! 437:
! 438: /* Peer Index and Originated Time */
! 439: mrt_put_u16(b, peer);
! 440: mrt_put_u32(b, (r->lastmod + s->time_offset) TO_S);
! 441:
! 442: /* Path Identifier */
! 443: if (s->add_path)
! 444: mrt_put_u32(b, r->attrs->src->private_id);
! 445:
! 446: /* Route Attributes */
! 447: mrt_put_u16(b, 0);
! 448:
! 449: #ifdef CONFIG_BGP
! 450: if (r->attrs->eattrs)
! 451: {
! 452: struct ea_list *eattrs = r->attrs->eattrs;
! 453:
! 454: if (!rta_is_cached(r->attrs))
! 455: ea_normalize(eattrs);
! 456:
! 457: mrt_buffer_need(b, MRT_ATTR_BUFFER_SIZE);
! 458: int alen = bgp_encode_attrs(s->bws, eattrs, b->pos, b->end);
! 459:
! 460: if (alen < 0)
! 461: {
! 462: mrt_log(s, "Attribute list too long for %N", r->net->n.addr);
! 463: alen = 0;
! 464: }
! 465:
! 466: put_u16(b->pos - 2, alen);
! 467: b->pos += alen;
! 468: }
! 469: #endif
! 470:
! 471: s->entry_count++;
! 472: }
! 473:
! 474: static void
! 475: mrt_rib_table_dump(struct mrt_table_dump_state *s, net *n, int add_path)
! 476: {
! 477: s->add_path = s->bws->add_path = add_path;
! 478:
! 479: int subtype = s->ipv4 ?
! 480: (!add_path ? MRT_RIB_IPV4_UNICAST : MRT_RIB_IPV4_UNICAST_ADDPATH) :
! 481: (!add_path ? MRT_RIB_IPV6_UNICAST : MRT_RIB_IPV6_UNICAST_ADDPATH);
! 482:
! 483: mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, subtype);
! 484: mrt_rib_table_header(s, n->n.addr);
! 485:
! 486: rte *rt, *rt0;
! 487: for (rt0 = n->routes; rt = rt0; rt0 = rt0->next)
! 488: {
! 489: if (rte_is_filtered(rt))
! 490: continue;
! 491:
! 492: /* Skip routes that should be reported in the other phase */
! 493: if (!s->always_add_path && (!rt->attrs->src->private_id != !s->add_path))
! 494: {
! 495: s->want_add_path = 1;
! 496: continue;
! 497: }
! 498:
! 499: rte_make_tmp_attrs(&rt, s->linpool, NULL);
! 500:
! 501: if (f_run(s->filter, &rt, s->linpool, 0) <= F_ACCEPT)
! 502: mrt_rib_table_entry(s, rt);
! 503:
! 504: if (rt != rt0)
! 505: rte_free(rt);
! 506:
! 507: lp_flush(s->linpool);
! 508: }
! 509:
! 510: /* Fix Entry Count */
! 511: put_u16(s->buf.start + s->entry_count_offset, s->entry_count);
! 512:
! 513: /* Update max counter */
! 514: s->max -= 1 + s->entry_count;
! 515:
! 516: /* Skip empty entries */
! 517: if (!s->entry_count)
! 518: return;
! 519:
! 520: s->seqnum++;
! 521: mrt_dump_message(&s->buf, s->fd);
! 522: }
! 523:
! 524:
! 525: /*
! 526: * MRT Table Dump: main logic
! 527: */
! 528:
! 529: static struct mrt_table_dump_state *
! 530: mrt_table_dump_init(pool *pp)
! 531: {
! 532: pool *pool = rp_new(pp, "MRT Table Dump");
! 533: struct mrt_table_dump_state *s = mb_allocz(pool, sizeof(struct mrt_table_dump_state));
! 534:
! 535: s->pool = pool;
! 536: s->linpool = lp_new(pool, 4080);
! 537: s->peer_lp = lp_new(pool, 4080);
! 538: mrt_buffer_init(&s->buf, pool, 2 * MRT_ATTR_BUFFER_SIZE);
! 539:
! 540: /* We lock the current config as we may reference it indirectly by filter */
! 541: s->config = config;
! 542: config_add_obstacle(s->config);
! 543:
! 544: s->fd = -1;
! 545:
! 546: return s;
! 547: }
! 548:
! 549: static void
! 550: mrt_table_dump_free(struct mrt_table_dump_state *s)
! 551: {
! 552: if (s->table_open)
! 553: FIB_ITERATE_UNLINK(&s->fit, &s->table->fib);
! 554:
! 555: if (s->table)
! 556: rt_unlock_table(s->table);
! 557:
! 558: if (s->table_ptr)
! 559: rt_unlock_table(s->table_ptr);
! 560:
! 561: config_del_obstacle(s->config);
! 562:
! 563: rfree(s->pool);
! 564: }
! 565:
! 566:
! 567: static int
! 568: mrt_table_dump_step(struct mrt_table_dump_state *s)
! 569: {
! 570: struct bgp_write_state bws = { .as4_session = 1 };
! 571:
! 572: s->max = 2048;
! 573: s->bws = &bws;
! 574:
! 575: if (s->table_open)
! 576: goto step;
! 577:
! 578: while (mrt_next_table(s))
! 579: {
! 580: if (!mrt_open_file(s))
! 581: continue;
! 582:
! 583: mrt_peer_table_dump(s);
! 584:
! 585: FIB_ITERATE_INIT(&s->fit, &s->table->fib);
! 586: s->table_open = 1;
! 587:
! 588: step:
! 589: FIB_ITERATE_START(&s->table->fib, &s->fit, net, n)
! 590: {
! 591: if (s->max < 0)
! 592: {
! 593: FIB_ITERATE_PUT(&s->fit);
! 594: return 0;
! 595: }
! 596:
! 597: /* With Always ADD_PATH option, we jump directly to second phase */
! 598: s->want_add_path = s->always_add_path;
! 599:
! 600: if (s->want_add_path == 0)
! 601: mrt_rib_table_dump(s, n, 0);
! 602:
! 603: if (s->want_add_path == 1)
! 604: mrt_rib_table_dump(s, n, 1);
! 605: }
! 606: FIB_ITERATE_END;
! 607: s->table_open = 0;
! 608:
! 609: mrt_close_file(s);
! 610: mrt_peer_table_flush(s);
! 611: }
! 612:
! 613: return 1;
! 614: }
! 615:
! 616: static void
! 617: mrt_timer(timer *t)
! 618: {
! 619: struct mrt_proto *p = t->data;
! 620: struct mrt_config *cf = (void *) (p->p.cf);
! 621:
! 622: if (p->table_dump)
! 623: {
! 624: log(L_WARN "%s: Earlier RIB table dump still not finished, skipping next one", p->p.name);
! 625: return;
! 626: }
! 627:
! 628: TRACE(D_EVENTS, "RIB table dump started");
! 629:
! 630: struct mrt_table_dump_state *s = mrt_table_dump_init(p->p.pool);
! 631:
! 632: s->proto = p;
! 633: s->table_expr = cf->table_expr;
! 634: s->table_ptr = cf->table_cf ? cf->table_cf->table : NULL;
! 635: s->filter = cf->filter;
! 636: s->filename = cf->filename;
! 637: s->always_add_path = cf->always_add_path;
! 638:
! 639: if (s->table_ptr)
! 640: rt_lock_table(s->table_ptr);
! 641:
! 642: p->table_dump = s;
! 643: ev_schedule(p->event);
! 644: }
! 645:
! 646: static void
! 647: mrt_event(void *P)
! 648: {
! 649: struct mrt_proto *p = P;
! 650:
! 651: if (!p->table_dump)
! 652: return;
! 653:
! 654: if (!mrt_table_dump_step(p->table_dump))
! 655: {
! 656: ev_schedule(p->event);
! 657: return;
! 658: }
! 659:
! 660: mrt_table_dump_free(p->table_dump);
! 661: p->table_dump = NULL;
! 662:
! 663: TRACE(D_EVENTS, "RIB table dump done");
! 664:
! 665: if (p->p.proto_state == PS_STOP)
! 666: proto_notify_state(&p->p, PS_DOWN);
! 667: }
! 668:
! 669:
! 670: /*
! 671: * MRT Table Dump: CLI command
! 672: */
! 673:
! 674: static void
! 675: mrt_dump_cont(struct cli *c)
! 676: {
! 677: if (!mrt_table_dump_step(c->rover))
! 678: return;
! 679:
! 680: cli_printf(c, 0, "");
! 681: mrt_table_dump_free(c->rover);
! 682: c->cont = c->cleanup = c->rover = NULL;
! 683: }
! 684:
! 685: static void
! 686: mrt_dump_cleanup(struct cli *c)
! 687: {
! 688: mrt_table_dump_free(c->rover);
! 689: c->rover = NULL;
! 690: }
! 691:
! 692: void
! 693: mrt_dump_cmd(struct mrt_dump_data *d)
! 694: {
! 695: if (cli_access_restricted())
! 696: return;
! 697:
! 698: if (!d->table_expr && !d->table_ptr)
! 699: cf_error("Table not specified");
! 700:
! 701: if (!d->filename)
! 702: cf_error("File not specified");
! 703:
! 704: struct mrt_table_dump_state *s = mrt_table_dump_init(this_cli->pool);
! 705:
! 706: s->cli = this_cli;
! 707: s->table_expr = d->table_expr;
! 708: s->table_ptr = d->table_ptr;
! 709: s->filter = d->filter;
! 710: s->filename = d->filename;
! 711:
! 712: if (s->table_ptr)
! 713: rt_lock_table(s->table_ptr);
! 714:
! 715: this_cli->cont = mrt_dump_cont;
! 716: this_cli->cleanup = mrt_dump_cleanup;
! 717: this_cli->rover = s;
! 718: }
! 719:
! 720:
! 721: /*
! 722: * MRT BGP4MP dump
! 723: */
! 724:
! 725: static buffer *
! 726: mrt_bgp_buffer(void)
! 727: {
! 728: /* Static buffer for BGP4MP dump, TODO: change to use MRT protocol */
! 729: static buffer b;
! 730:
! 731: if (!b.start)
! 732: mrt_buffer_init(&b, &root_pool, 1024);
! 733:
! 734: return &b;
! 735: }
! 736:
! 737: static void
! 738: mrt_bgp_header(buffer *b, struct mrt_bgp_data *d)
! 739: {
! 740: if (d->as4)
! 741: {
! 742: mrt_put_u32(b, d->peer_as);
! 743: mrt_put_u32(b, d->local_as);
! 744: }
! 745: else
! 746: {
! 747: mrt_put_u16(b, (d->peer_as <= 0xFFFF) ? d->peer_as : AS_TRANS);
! 748: mrt_put_u16(b, (d->local_as <= 0xFFFF) ? d->local_as : AS_TRANS);
! 749: }
! 750:
! 751: mrt_put_u16(b, (d->index <= 0xFFFF) ? d->index : 0);
! 752: mrt_put_u16(b, d->af);
! 753:
! 754: if (d->af == BGP_AFI_IPV4)
! 755: {
! 756: mrt_put_ip4(b, ipa_to_ip4(d->peer_ip));
! 757: mrt_put_ip4(b, ipa_to_ip4(d->local_ip));
! 758: }
! 759: else
! 760: {
! 761: mrt_put_ip6(b, ipa_to_ip6(d->peer_ip));
! 762: mrt_put_ip6(b, ipa_to_ip6(d->local_ip));
! 763: }
! 764: }
! 765:
! 766: void
! 767: mrt_dump_bgp_message(struct mrt_bgp_data *d)
! 768: {
! 769: const u16 subtypes[] = {
! 770: MRT_BGP4MP_MESSAGE, MRT_BGP4MP_MESSAGE_AS4,
! 771: MRT_BGP4MP_MESSAGE_LOCAL, MRT_BGP4MP_MESSAGE_AS4_LOCAL,
! 772: MRT_BGP4MP_MESSAGE_ADDPATH, MRT_BGP4MP_MESSAGE_AS4_ADDPATH,
! 773: MRT_BGP4MP_MESSAGE_LOCAL_ADDPATH, MRT_BGP4MP_MESSAGE_AS4_LOCAL_ADDPATH,
! 774: };
! 775:
! 776: buffer *b = mrt_bgp_buffer();
! 777: mrt_init_message(b, MRT_BGP4MP, subtypes[d->as4 + 4*d->add_path]);
! 778: mrt_bgp_header(b, d);
! 779: mrt_put_data(b, d->message, d->msg_len);
! 780: mrt_dump_message(b, config->mrtdump_file);
! 781: }
! 782:
! 783: void
! 784: mrt_dump_bgp_state_change(struct mrt_bgp_data *d)
! 785: {
! 786: /* Convert state from our BS_* values to values used in MRTDump */
! 787: const u16 states[BS_MAX] = {1, 2, 3, 4, 5, 6, 1};
! 788:
! 789: if (states[d->old_state] == states[d->new_state])
! 790: return;
! 791:
! 792: /* Always use AS4 mode for STATE_CHANGE */
! 793: d->as4 = 1;
! 794:
! 795: buffer *b = mrt_bgp_buffer();
! 796: mrt_init_message(b, MRT_BGP4MP, MRT_BGP4MP_STATE_CHANGE_AS4);
! 797: mrt_bgp_header(b, d);
! 798: mrt_put_u16(b, states[d->old_state]);
! 799: mrt_put_u16(b, states[d->new_state]);
! 800: mrt_dump_message(b, config->mrtdump_file);
! 801: }
! 802:
! 803:
! 804: /*
! 805: * MRT protocol glue
! 806: */
! 807:
! 808: void
! 809: mrt_check_config(struct proto_config *CF)
! 810: {
! 811: struct mrt_config *cf = (void *) CF;
! 812:
! 813: if (!cf->table_expr && !cf->table_cf)
! 814: cf_error("Table not specified");
! 815:
! 816: if (!cf->filename)
! 817: cf_error("File not specified");
! 818:
! 819: if (!cf->period)
! 820: cf_error("Period not specified");
! 821: }
! 822:
! 823: static struct proto *
! 824: mrt_init(struct proto_config *CF)
! 825: {
! 826: struct proto *P = proto_new(CF);
! 827:
! 828: return P;
! 829: }
! 830:
! 831: static int
! 832: mrt_start(struct proto *P)
! 833: {
! 834: struct mrt_proto *p = (void *) P;
! 835: struct mrt_config *cf = (void *) (P->cf);
! 836:
! 837: p->timer = tm_new_init(P->pool, mrt_timer, p, cf->period S, 0);
! 838: p->event = ev_new_init(P->pool, mrt_event, p);
! 839:
! 840: tm_start(p->timer, cf->period S);
! 841:
! 842: return PS_UP;
! 843: }
! 844:
! 845: static int
! 846: mrt_shutdown(struct proto *P)
! 847: {
! 848: struct mrt_proto *p = (void *) P;
! 849:
! 850: return p->table_dump ? PS_STOP : PS_DOWN;
! 851: }
! 852:
! 853: static int
! 854: mrt_reconfigure(struct proto *P, struct proto_config *CF)
! 855: {
! 856: struct mrt_proto *p = (void *) P;
! 857: struct mrt_config *old = (void *) (P->cf);
! 858: struct mrt_config *new = (void *) CF;
! 859:
! 860: if (new->period != old->period)
! 861: {
! 862: TRACE(D_EVENTS, "Changing period from %u to %u s", old->period, new->period);
! 863:
! 864: btime now = current_time();
! 865: btime new_time = p->timer->expires - (old->period S) + (new->period S);
! 866: p->timer->recurrent = new->period S;
! 867: tm_set(p->timer, MAX(now, new_time));
! 868: }
! 869:
! 870: return 1;
! 871: }
! 872:
! 873: static void
! 874: mrt_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUSED)
! 875: {
! 876: /* Do nothing */
! 877: }
! 878:
! 879:
! 880: struct protocol proto_mrt = {
! 881: .name = "MRT",
! 882: .template = "mrt%d",
! 883: .class = PROTOCOL_MRT,
! 884: .proto_size = sizeof(struct mrt_proto),
! 885: .config_size = sizeof(struct mrt_config),
! 886: .init = mrt_init,
! 887: .start = mrt_start,
! 888: .shutdown = mrt_shutdown,
! 889: .reconfigure = mrt_reconfigure,
! 890: .copy_config = mrt_copy_config,
! 891: };
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 / bird2 / proto / mrt