diff options
Diffstat (limited to '')
| -rw-r--r-- | bgpd/bgp_dump.c | 880 |
1 files changed, 880 insertions, 0 deletions
diff --git a/bgpd/bgp_dump.c b/bgpd/bgp_dump.c new file mode 100644 index 0000000..68499e3 --- /dev/null +++ b/bgpd/bgp_dump.c @@ -0,0 +1,880 @@ +/* BGP-4 dump routine + * Copyright (C) 1999 Kunihiro Ishiguro + * + * This file is part of GNU Zebra. + * + * GNU Zebra is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2, or (at your option) any + * later version. + * + * GNU Zebra is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; see the file COPYING; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <zebra.h> + +#include "log.h" +#include "stream.h" +#include "sockunion.h" +#include "command.h" +#include "prefix.h" +#include "thread.h" +#include "linklist.h" +#include "queue.h" +#include "memory.h" +#include "filter.h" + +#include "bgpd/bgp_table.h" +#include "bgpd/bgpd.h" +#include "bgpd/bgp_route.h" +#include "bgpd/bgp_attr.h" +#include "bgpd/bgp_dump.h" +#include "bgpd/bgp_errors.h" +#include "bgpd/bgp_packet.h" + +enum bgp_dump_type { + BGP_DUMP_ALL, + BGP_DUMP_ALL_ET, + BGP_DUMP_UPDATES, + BGP_DUMP_UPDATES_ET, + BGP_DUMP_ROUTES +}; + +static const struct bgp_dump_type_map { + enum bgp_dump_type type; + const char *str; +} bgp_dump_type_map[] = { + {BGP_DUMP_ALL, "all"}, {BGP_DUMP_ALL_ET, "all-et"}, + {BGP_DUMP_UPDATES, "updates"}, {BGP_DUMP_UPDATES_ET, "updates-et"}, + {BGP_DUMP_ROUTES, "routes-mrt"}, {0, NULL}, +}; + +enum MRT_MSG_TYPES { + MSG_NULL, + MSG_START, /* sender is starting up */ + MSG_DIE, /* receiver should shut down */ + MSG_I_AM_DEAD, /* sender is shutting down */ + MSG_PEER_DOWN, /* sender's peer is down */ + MSG_PROTOCOL_BGP, /* msg is a BGP packet */ + MSG_PROTOCOL_RIP, /* msg is a RIP packet */ + MSG_PROTOCOL_IDRP, /* msg is an IDRP packet */ + MSG_PROTOCOL_RIPNG, /* msg is a RIPNG packet */ + MSG_PROTOCOL_BGP4PLUS, /* msg is a BGP4+ packet */ + MSG_PROTOCOL_BGP4PLUS_01, /* msg is a BGP4+ (draft 01) packet */ + MSG_PROTOCOL_OSPF, /* msg is an OSPF packet */ + MSG_TABLE_DUMP, /* routing table dump */ + MSG_TABLE_DUMP_V2 /* routing table dump, version 2 */ +}; + +struct bgp_dump { + enum bgp_dump_type type; + + char *filename; + + FILE *fp; + + unsigned int interval; + + char *interval_str; + + struct thread *t_interval; +}; + +static int bgp_dump_unset(struct bgp_dump *bgp_dump); +static void bgp_dump_interval_func(struct thread *); + +/* BGP packet dump output buffer. */ +struct stream *bgp_dump_obuf; + +/* BGP dump strucuture for 'dump bgp all' */ +struct bgp_dump bgp_dump_all; + +/* BGP dump structure for 'dump bgp updates' */ +struct bgp_dump bgp_dump_updates; + +/* BGP dump structure for 'dump bgp routes' */ +struct bgp_dump bgp_dump_routes; + +static FILE *bgp_dump_open_file(struct bgp_dump *bgp_dump) +{ + int ret; + time_t clock; + struct tm tm; + char fullpath[MAXPATHLEN]; + char realpath[MAXPATHLEN]; + mode_t oldumask; + + time(&clock); + localtime_r(&clock, &tm); + + if (bgp_dump->filename[0] != DIRECTORY_SEP) { + snprintf(fullpath, sizeof(fullpath), "%s/%s", vty_get_cwd(), + bgp_dump->filename); + ret = strftime(realpath, MAXPATHLEN, fullpath, &tm); + } else + ret = strftime(realpath, MAXPATHLEN, bgp_dump->filename, &tm); + + if (ret == 0) { + flog_warn(EC_BGP_DUMP, "%s: strftime error", __func__); + return NULL; + } + + if (bgp_dump->fp) + fclose(bgp_dump->fp); + + + oldumask = umask(0777 & ~LOGFILE_MASK); + bgp_dump->fp = fopen(realpath, "w"); + + if (bgp_dump->fp == NULL) { + flog_warn(EC_BGP_DUMP, "%s: %s: %s", __func__, realpath, + strerror(errno)); + umask(oldumask); + return NULL; + } + umask(oldumask); + + return bgp_dump->fp; +} + +static int bgp_dump_interval_add(struct bgp_dump *bgp_dump, int interval) +{ + int secs_into_day; + time_t t; + struct tm tm; + + if (interval > 0) { + /* Periodic dump every interval seconds */ + if ((interval < 86400) && ((86400 % interval) == 0)) { + /* Dump at predictable times: if a day has a whole + * number of + * intervals, dump every interval seconds starting from + * midnight + */ + (void)time(&t); + localtime_r(&t, &tm); + secs_into_day = tm.tm_sec + 60 * tm.tm_min + + 60 * 60 * tm.tm_hour; + interval = interval + - secs_into_day % interval; /* always > 0 */ + } + thread_add_timer(bm->master, bgp_dump_interval_func, bgp_dump, + interval, &bgp_dump->t_interval); + } else { + /* One-off dump: execute immediately, don't affect any scheduled + * dumps */ + thread_add_event(bm->master, bgp_dump_interval_func, bgp_dump, + 0, &bgp_dump->t_interval); + } + + return 0; +} + +/* Dump common header. */ +static void bgp_dump_header(struct stream *obuf, int type, int subtype, + int dump_type) +{ + struct timeval clock; + long msecs; + time_t secs; + + if ((dump_type == BGP_DUMP_ALL_ET || dump_type == BGP_DUMP_UPDATES_ET) + && type == MSG_PROTOCOL_BGP4MP) + type = MSG_PROTOCOL_BGP4MP_ET; + + gettimeofday(&clock, NULL); + + secs = clock.tv_sec; + msecs = clock.tv_usec; + + /* Put dump packet header. */ + stream_putl(obuf, secs); + stream_putw(obuf, type); + stream_putw(obuf, subtype); + stream_putl(obuf, 0); /* len */ + + /* Adding microseconds for the MRT Extended Header */ + if (type == MSG_PROTOCOL_BGP4MP_ET) + stream_putl(obuf, msecs); +} + +static void bgp_dump_set_size(struct stream *s, int type) +{ + /* + * The BGP_DUMP_HEADER_SIZE stay at 12 event when ET: + * "The Microsecond Timestamp is included in the computation + * of the Length field value." (RFC6396 2011) + */ + stream_putl_at(s, 8, stream_get_endp(s) - BGP_DUMP_HEADER_SIZE); +} + +static void bgp_dump_routes_index_table(struct bgp *bgp) +{ + struct peer *peer; + struct listnode *node; + uint16_t peerno = 1; + struct stream *obuf; + + obuf = bgp_dump_obuf; + stream_reset(obuf); + + /* MRT header */ + bgp_dump_header(obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_PEER_INDEX_TABLE, + BGP_DUMP_ROUTES); + + /* Collector BGP ID */ + stream_put_in_addr(obuf, &bgp->router_id); + + /* View name */ + if (bgp->name_pretty) { + stream_putw(obuf, strlen(bgp->name_pretty)); + stream_put(obuf, bgp->name_pretty, strlen(bgp->name_pretty)); + } else { + stream_putw(obuf, 0); + } + + /* Peer count ( plus one extra internal peer ) */ + stream_putw(obuf, listcount(bgp->peer) + 1); + + /* Populate fake peer at index 0, for locally originated routes */ + /* Peer type (IPv4) */ + stream_putc(obuf, + TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4 + + TABLE_DUMP_V2_PEER_INDEX_TABLE_IP); + /* Peer BGP ID (0.0.0.0) */ + stream_putl(obuf, 0); + /* Peer IP address (0.0.0.0) */ + stream_putl(obuf, 0); + /* Peer ASN (0) */ + stream_putl(obuf, 0); + + /* Walk down all peers */ + for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) { + + /* Peer's type */ + if (sockunion_family(&peer->su) == AF_INET) { + stream_putc( + obuf, + TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4 + + TABLE_DUMP_V2_PEER_INDEX_TABLE_IP); + } else if (sockunion_family(&peer->su) == AF_INET6) { + stream_putc( + obuf, + TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4 + + TABLE_DUMP_V2_PEER_INDEX_TABLE_IP6); + } + + /* Peer's BGP ID */ + stream_put_in_addr(obuf, &peer->remote_id); + + /* Peer's IP address */ + if (sockunion_family(&peer->su) == AF_INET) { + stream_put_in_addr(obuf, &peer->su.sin.sin_addr); + } else if (sockunion_family(&peer->su) == AF_INET6) { + stream_write(obuf, (uint8_t *)&peer->su.sin6.sin6_addr, + IPV6_MAX_BYTELEN); + } + + /* Peer's AS number. */ + /* Note that, as this is an AS4 compliant quagga, the RIB is + * always AS4 */ + stream_putl(obuf, peer->as); + + /* Store the peer number for this peer */ + peer->table_dump_index = peerno; + peerno++; + } + + bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2); + + fwrite(STREAM_DATA(obuf), stream_get_endp(obuf), 1, bgp_dump_routes.fp); + fflush(bgp_dump_routes.fp); +} + +static struct bgp_path_info * +bgp_dump_route_node_record(int afi, struct bgp_dest *dest, + struct bgp_path_info *path, unsigned int seq) +{ + struct stream *obuf; + size_t sizep; + size_t endp; + bool addpath_capable; + const struct prefix *p = bgp_dest_get_prefix(dest); + + obuf = bgp_dump_obuf; + stream_reset(obuf); + + addpath_capable = bgp_addpath_encode_rx(path->peer, afi, SAFI_UNICAST); + + /* MRT header */ + if (afi == AFI_IP && addpath_capable) + bgp_dump_header(obuf, MSG_TABLE_DUMP_V2, + TABLE_DUMP_V2_RIB_IPV4_UNICAST_ADDPATH, + BGP_DUMP_ROUTES); + else if (afi == AFI_IP) + bgp_dump_header(obuf, MSG_TABLE_DUMP_V2, + TABLE_DUMP_V2_RIB_IPV4_UNICAST, + BGP_DUMP_ROUTES); + else if (afi == AFI_IP6 && addpath_capable) + bgp_dump_header(obuf, MSG_TABLE_DUMP_V2, + TABLE_DUMP_V2_RIB_IPV6_UNICAST_ADDPATH, + BGP_DUMP_ROUTES); + else if (afi == AFI_IP6) + bgp_dump_header(obuf, MSG_TABLE_DUMP_V2, + TABLE_DUMP_V2_RIB_IPV6_UNICAST, + BGP_DUMP_ROUTES); + + /* Sequence number */ + stream_putl(obuf, seq); + + /* Prefix length */ + stream_putc(obuf, p->prefixlen); + + /* Prefix */ + if (afi == AFI_IP) { + /* We'll dump only the useful bits (those not 0), but have to + * align on 8 bits */ + stream_write(obuf, (uint8_t *)&p->u.prefix4, + (p->prefixlen + 7) / 8); + } else if (afi == AFI_IP6) { + /* We'll dump only the useful bits (those not 0), but have to + * align on 8 bits */ + stream_write(obuf, (uint8_t *)&p->u.prefix6, + (p->prefixlen + 7) / 8); + } + + /* Save where we are now, so we can overwride the entry count later */ + sizep = stream_get_endp(obuf); + + /* Entry count */ + uint16_t entry_count = 0; + + /* Entry count, note that this is overwritten later */ + stream_putw(obuf, 0); + + endp = stream_get_endp(obuf); + for (; path; path = path->next) { + size_t cur_endp; + + /* Peer index */ + stream_putw(obuf, path->peer->table_dump_index); + + /* Originated */ + stream_putl(obuf, time(NULL) - (monotime(NULL) - path->uptime)); + + /*Path Identifier*/ + if (addpath_capable) { + stream_putl(obuf, path->addpath_rx_id); + } + + /* Dump attribute. */ + /* Skip prefix & AFI/SAFI for MP_NLRI */ + bgp_dump_routes_attr(obuf, path->attr, p); + + cur_endp = stream_get_endp(obuf); + if (cur_endp > BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE + + BGP_DUMP_MSG_HEADER + + BGP_DUMP_HEADER_SIZE) { + stream_set_endp(obuf, endp); + break; + } + + entry_count++; + endp = cur_endp; + } + + /* Overwrite the entry count, now that we know the right number */ + stream_putw_at(obuf, sizep, entry_count); + + bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2); + fwrite(STREAM_DATA(obuf), stream_get_endp(obuf), 1, bgp_dump_routes.fp); + + return path; +} + + +/* Runs under child process. */ +static unsigned int bgp_dump_routes_func(int afi, int first_run, + unsigned int seq) +{ + struct bgp_path_info *path; + struct bgp_dest *dest; + struct bgp *bgp; + struct bgp_table *table; + + bgp = bgp_get_default(); + if (!bgp) + return seq; + + if (bgp_dump_routes.fp == NULL) + return seq; + + /* Note that bgp_dump_routes_index_table will do ipv4 and ipv6 peers, + so this should only be done on the first call to + bgp_dump_routes_func. + ( this function will be called once for ipv4 and once for ipv6 ) */ + if (first_run) + bgp_dump_routes_index_table(bgp); + + /* Walk down each BGP route. */ + table = bgp->rib[afi][SAFI_UNICAST]; + + for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) { + path = bgp_dest_get_bgp_path_info(dest); + while (path) { + path = bgp_dump_route_node_record(afi, dest, path, seq); + seq++; + } + } + + fflush(bgp_dump_routes.fp); + + return seq; +} + +static void bgp_dump_interval_func(struct thread *t) +{ + struct bgp_dump *bgp_dump; + bgp_dump = THREAD_ARG(t); + + /* Reschedule dump even if file couldn't be opened this time... */ + if (bgp_dump_open_file(bgp_dump) != NULL) { + /* In case of bgp_dump_routes, we need special route dump + * function. */ + if (bgp_dump->type == BGP_DUMP_ROUTES) { + unsigned int seq = bgp_dump_routes_func(AFI_IP, 1, 0); + bgp_dump_routes_func(AFI_IP6, 0, seq); + /* Close the file now. For a RIB dump there's no point + * in leaving + * it open until the next scheduled dump starts. */ + fclose(bgp_dump->fp); + bgp_dump->fp = NULL; + } + } + + /* if interval is set reschedule */ + if (bgp_dump->interval > 0) + bgp_dump_interval_add(bgp_dump, bgp_dump->interval); +} + +/* Dump common information. */ +static void bgp_dump_common(struct stream *obuf, struct peer *peer, + int forceas4) +{ + char empty[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + /* Source AS number and Destination AS number. */ + if (forceas4 || CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV)) { + stream_putl(obuf, peer->as); + stream_putl(obuf, peer->local_as); + } else { + stream_putw(obuf, peer->as); + stream_putw(obuf, peer->local_as); + } + + if (peer->su.sa.sa_family == AF_INET) { + stream_putw(obuf, peer->ifp ? peer->ifp->ifindex : 0); + stream_putw(obuf, AFI_IP); + + stream_put(obuf, &peer->su.sin.sin_addr, IPV4_MAX_BYTELEN); + + if (peer->su_local) + stream_put(obuf, &peer->su_local->sin.sin_addr, + IPV4_MAX_BYTELEN); + else + stream_put(obuf, empty, IPV4_MAX_BYTELEN); + } else if (peer->su.sa.sa_family == AF_INET6) { + /* Interface Index and Address family. */ + stream_putw(obuf, peer->ifp ? peer->ifp->ifindex : 0); + stream_putw(obuf, AFI_IP6); + + /* Source IP Address and Destination IP Address. */ + stream_put(obuf, &peer->su.sin6.sin6_addr, IPV6_MAX_BYTELEN); + + if (peer->su_local) + stream_put(obuf, &peer->su_local->sin6.sin6_addr, + IPV6_MAX_BYTELEN); + else + stream_put(obuf, empty, IPV6_MAX_BYTELEN); + } +} + +/* Dump BGP status change. */ +int bgp_dump_state(struct peer *peer) +{ + struct stream *obuf; + + /* If dump file pointer is disabled return immediately. */ + if (bgp_dump_all.fp == NULL) + return 0; + + /* Make dump stream. */ + obuf = bgp_dump_obuf; + stream_reset(obuf); + + bgp_dump_header(obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_STATE_CHANGE_AS4, + bgp_dump_all.type); + bgp_dump_common(obuf, peer, 1); /* force this in as4speak*/ + + stream_putw(obuf, peer->ostatus); + stream_putw(obuf, peer->status); + + /* Set length. */ + bgp_dump_set_size(obuf, MSG_PROTOCOL_BGP4MP); + + /* Write to the stream. */ + fwrite(STREAM_DATA(obuf), stream_get_endp(obuf), 1, bgp_dump_all.fp); + fflush(bgp_dump_all.fp); + return 0; +} + +static void bgp_dump_packet_func(struct bgp_dump *bgp_dump, struct peer *peer, + struct stream *packet) +{ + struct stream *obuf; + bool addpath_capable = false; + /* If dump file pointer is disabled return immediately. */ + if (bgp_dump->fp == NULL) + return; + if (peer->su.sa.sa_family == AF_INET) { + addpath_capable = + bgp_addpath_encode_rx(peer, AFI_IP, SAFI_UNICAST); + } else if (peer->su.sa.sa_family == AF_INET6) { + addpath_capable = + bgp_addpath_encode_rx(peer, AFI_IP6, SAFI_UNICAST); + } + + /* Make dump stream. */ + obuf = bgp_dump_obuf; + stream_reset(obuf); + + /* Dump header and common part. */ + if (CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV) && addpath_capable) { + bgp_dump_header(obuf, MSG_PROTOCOL_BGP4MP, + BGP4MP_MESSAGE_AS4_ADDPATH, bgp_dump->type); + } else if (CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV)) { + bgp_dump_header(obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE_AS4, + bgp_dump->type); + } else if (addpath_capable) { + bgp_dump_header(obuf, MSG_PROTOCOL_BGP4MP, + BGP4MP_MESSAGE_ADDPATH, bgp_dump->type); + } else { + bgp_dump_header(obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE, + bgp_dump->type); + } + bgp_dump_common(obuf, peer, 0); + + /* Packet contents. */ + stream_put(obuf, STREAM_DATA(packet), stream_get_endp(packet)); + + /* Set length. */ + bgp_dump_set_size(obuf, MSG_PROTOCOL_BGP4MP); + + /* Write to the stream. */ + fwrite(STREAM_DATA(obuf), stream_get_endp(obuf), 1, bgp_dump->fp); + fflush(bgp_dump->fp); +} + +/* Called from bgp_packet.c when BGP packet is received. */ +static int bgp_dump_packet(struct peer *peer, uint8_t type, bgp_size_t size, + struct stream *packet) +{ + /* bgp_dump_all. */ + bgp_dump_packet_func(&bgp_dump_all, peer, packet); + + /* bgp_dump_updates. */ + if (type == BGP_MSG_UPDATE) + bgp_dump_packet_func(&bgp_dump_updates, peer, packet); + return 0; +} + +static unsigned int bgp_dump_parse_time(const char *str) +{ + int i; + int len; + int seen_h; + int seen_m; + int time; + unsigned int total; + + time = 0; + total = 0; + seen_h = 0; + seen_m = 0; + len = strlen(str); + + for (i = 0; i < len; i++) { + if (isdigit((unsigned char)str[i])) { + time *= 10; + time += str[i] - '0'; + } else if (str[i] == 'H' || str[i] == 'h') { + if (seen_h) + return 0; + if (seen_m) + return 0; + total += time * 60 * 60; + time = 0; + seen_h = 1; + } else if (str[i] == 'M' || str[i] == 'm') { + if (seen_m) + return 0; + total += time * 60; + time = 0; + seen_m = 1; + } else + return 0; + } + return total + time; +} + +static int bgp_dump_set(struct vty *vty, struct bgp_dump *bgp_dump, + enum bgp_dump_type type, const char *path, + const char *interval_str) +{ + unsigned int interval; + + /* Don't schedule duplicate dumps if the dump command is given twice */ + if (bgp_dump->filename && strcmp(path, bgp_dump->filename) == 0 + && type == bgp_dump->type) { + if (interval_str) { + if (bgp_dump->interval_str + && strcmp(bgp_dump->interval_str, interval_str) + == 0) + return CMD_SUCCESS; + } else { + if (!bgp_dump->interval_str) + return CMD_SUCCESS; + } + } + + /* Removing previous config */ + bgp_dump_unset(bgp_dump); + + if (interval_str) { + /* Check interval string. */ + interval = bgp_dump_parse_time(interval_str); + if (interval == 0) { + vty_out(vty, "Malformed interval string\n"); + return CMD_WARNING_CONFIG_FAILED; + } + + /* Setting interval string */ + bgp_dump->interval_str = + XSTRDUP(MTYPE_BGP_DUMP_STR, interval_str); + } else { + interval = 0; + } + + /* Set type. */ + bgp_dump->type = type; + + /* Set interval */ + bgp_dump->interval = interval; + + /* Set file name. */ + bgp_dump->filename = XSTRDUP(MTYPE_BGP_DUMP_STR, path); + + /* Create interval thread. */ + bgp_dump_interval_add(bgp_dump, interval); + + /* This should be called when interval is expired. */ + bgp_dump_open_file(bgp_dump); + + return CMD_SUCCESS; +} + +static int bgp_dump_unset(struct bgp_dump *bgp_dump) +{ + /* Removing file name. */ + XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->filename); + + /* Closing file. */ + if (bgp_dump->fp) { + fclose(bgp_dump->fp); + bgp_dump->fp = NULL; + } + + /* Removing interval event. */ + THREAD_OFF(bgp_dump->t_interval); + + bgp_dump->interval = 0; + + /* Removing interval string. */ + XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->interval_str); + + return CMD_SUCCESS; +} + +DEFUN (dump_bgp_all, + dump_bgp_all_cmd, + "dump bgp <all|all-et|updates|updates-et|routes-mrt> PATH [INTERVAL]", + "Dump packet\n" + "BGP packet dump\n" + "Dump all BGP packets\nDump all BGP packets (Extended Timestamp Header)\n" + "Dump BGP updates only\nDump BGP updates only (Extended Timestamp Header)\n" + "Dump whole BGP routing table\n" + "Output filename\n" + "Interval of output\n") +{ + int idx_dump_routes = 2; + int idx_path = 3; + int idx_interval = 4; + int bgp_dump_type = 0; + const char *interval = NULL; + struct bgp_dump *bgp_dump_struct = NULL; + const struct bgp_dump_type_map *map = NULL; + + for (map = bgp_dump_type_map; map->str; map++) + if (strmatch(argv[idx_dump_routes]->text, map->str)) + bgp_dump_type = map->type; + + switch (bgp_dump_type) { + case BGP_DUMP_ALL: + case BGP_DUMP_ALL_ET: + bgp_dump_struct = &bgp_dump_all; + break; + case BGP_DUMP_UPDATES: + case BGP_DUMP_UPDATES_ET: + bgp_dump_struct = &bgp_dump_updates; + break; + case BGP_DUMP_ROUTES: + default: + bgp_dump_struct = &bgp_dump_routes; + break; + } + + /* When an interval is given */ + if (argc == idx_interval + 1) + interval = argv[idx_interval]->arg; + + return bgp_dump_set(vty, bgp_dump_struct, bgp_dump_type, + argv[idx_path]->arg, interval); +} + +DEFUN (no_dump_bgp_all, + no_dump_bgp_all_cmd, + "no dump bgp <all|all-et|updates|updates-et|routes-mrt> [PATH [INTERVAL]]", + NO_STR + "Stop dump packet\n" + "Stop BGP packet dump\n" + "Stop dump process all\n" + "Stop dump process all-et\n" + "Stop dump process updates\n" + "Stop dump process updates-et\n" + "Stop dump process route-mrt\n" + "Output filename\n" + "Interval of output\n") +{ + int idx_dump_routes = 3; + int bgp_dump_type = 0; + const struct bgp_dump_type_map *map = NULL; + struct bgp_dump *bgp_dump_struct = NULL; + + for (map = bgp_dump_type_map; map->str; map++) + if (strmatch(argv[idx_dump_routes]->text, map->str)) + bgp_dump_type = map->type; + + switch (bgp_dump_type) { + case BGP_DUMP_ALL: + case BGP_DUMP_ALL_ET: + bgp_dump_struct = &bgp_dump_all; + break; + case BGP_DUMP_UPDATES: + case BGP_DUMP_UPDATES_ET: + bgp_dump_struct = &bgp_dump_updates; + break; + case BGP_DUMP_ROUTES: + default: + bgp_dump_struct = &bgp_dump_routes; + break; + } + + return bgp_dump_unset(bgp_dump_struct); +} + +static int config_write_bgp_dump(struct vty *vty); +/* BGP node structure. */ +static struct cmd_node bgp_dump_node = { + .name = "dump", + .node = DUMP_NODE, + .prompt = "", + .config_write = config_write_bgp_dump, +}; + +static int config_write_bgp_dump(struct vty *vty) +{ + if (bgp_dump_all.filename) { + const char *type_str = "all"; + if (bgp_dump_all.type == BGP_DUMP_ALL_ET) + type_str = "all-et"; + + if (bgp_dump_all.interval_str) + vty_out(vty, "dump bgp %s %s %s\n", type_str, + bgp_dump_all.filename, + bgp_dump_all.interval_str); + else + vty_out(vty, "dump bgp %s %s\n", type_str, + bgp_dump_all.filename); + } + if (bgp_dump_updates.filename) { + const char *type_str = "updates"; + if (bgp_dump_updates.type == BGP_DUMP_UPDATES_ET) + type_str = "updates-et"; + + if (bgp_dump_updates.interval_str) + vty_out(vty, "dump bgp %s %s %s\n", type_str, + bgp_dump_updates.filename, + bgp_dump_updates.interval_str); + else + vty_out(vty, "dump bgp %s %s\n", type_str, + bgp_dump_updates.filename); + } + if (bgp_dump_routes.filename) { + if (bgp_dump_routes.interval_str) + vty_out(vty, "dump bgp routes-mrt %s %s\n", + bgp_dump_routes.filename, + bgp_dump_routes.interval_str); + else + vty_out(vty, "dump bgp routes-mrt %s\n", + bgp_dump_routes.filename); + } + return 0; +} + +/* Initialize BGP packet dump functionality. */ +void bgp_dump_init(void) +{ + memset(&bgp_dump_all, 0, sizeof(bgp_dump_all)); + memset(&bgp_dump_updates, 0, sizeof(bgp_dump_updates)); + memset(&bgp_dump_routes, 0, sizeof(bgp_dump_routes)); + + bgp_dump_obuf = + stream_new(BGP_MAX_PACKET_SIZE + BGP_MAX_PACKET_SIZE_OVERFLOW); + + install_node(&bgp_dump_node); + + install_element(CONFIG_NODE, &dump_bgp_all_cmd); + install_element(CONFIG_NODE, &no_dump_bgp_all_cmd); + + hook_register(bgp_packet_dump, bgp_dump_packet); + hook_register(peer_status_changed, bgp_dump_state); +} + +void bgp_dump_finish(void) +{ + bgp_dump_unset(&bgp_dump_all); + bgp_dump_unset(&bgp_dump_updates); + bgp_dump_unset(&bgp_dump_routes); + + stream_free(bgp_dump_obuf); + bgp_dump_obuf = NULL; + hook_unregister(bgp_packet_dump, bgp_dump_packet); + hook_unregister(peer_status_changed, bgp_dump_state); +} |