Initial revision
diff --git a/bgpd/bgp_dump.c b/bgpd/bgp_dump.c
new file mode 100644
index 0000000..fca51ed
--- /dev/null
+++ b/bgpd/bgp_dump.c
@@ -0,0 +1,741 @@
+/* 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 GNU Zebra; see the file COPYING. If not, write to the Free
+Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
+
+#include <zebra.h>
+
+#include "log.h"
+#include "stream.h"
+#include "sockunion.h"
+#include "command.h"
+#include "prefix.h"
+#include "thread.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"
+
+enum bgp_dump_type
+{
+ BGP_DUMP_ALL,
+ BGP_DUMP_UPDATES,
+ BGP_DUMP_ROUTES
+};
+
+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 */
+};
+
+struct bgp_dump
+{
+ enum bgp_dump_type type;
+
+ char *filename;
+
+ FILE *fp;
+
+ unsigned int interval;
+
+ char *interval_str;
+
+ struct thread *t_interval;
+};
+
+/* 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;
+
+/* Dump whole BGP table is very heavy process. */
+struct thread *t_bgp_dump_routes;
+
+/* Some define for BGP packet dump. */
+FILE *
+bgp_dump_open_file (struct bgp_dump *bgp_dump)
+{
+ int ret;
+ time_t clock;
+ struct tm *tm;
+ char fullpath[MAXPATHLEN];
+ char realpath[MAXPATHLEN];
+
+ time (&clock);
+ tm = localtime (&clock);
+
+ if (bgp_dump->filename[0] != DIRECTORY_SEP)
+ {
+ sprintf (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)
+ {
+ zlog_warn ("bgp_dump_open_file: strftime error");
+ return NULL;
+ }
+
+ if (bgp_dump->fp)
+ fclose (bgp_dump->fp);
+
+
+ bgp_dump->fp = fopen (realpath, "w");
+
+ if (bgp_dump->fp == NULL)
+ return NULL;
+
+ return bgp_dump->fp;
+}
+
+int
+bgp_dump_interval_add (struct bgp_dump *bgp_dump, int interval)
+{
+ int bgp_dump_interval_func (struct thread *);
+
+ bgp_dump->t_interval = thread_add_timer (master, bgp_dump_interval_func,
+ bgp_dump, interval);
+ return 0;
+}
+
+/* Dump common header. */
+void
+bgp_dump_header (struct stream *obuf, int type, int subtype)
+{
+ time_t now;
+
+ /* Set header. */
+ time (&now);
+
+ /* Put dump packet header. */
+ stream_putl (obuf, now);
+ stream_putw (obuf, type);
+ stream_putw (obuf, subtype);
+
+ stream_putl (obuf, 0); /* len */
+}
+
+void
+bgp_dump_set_size (struct stream *s, int type)
+{
+ stream_putl_at (s, 8, stream_get_putp (s) - BGP_DUMP_HEADER_SIZE);
+}
+
+void
+bgp_dump_routes_entry (struct prefix *p, struct bgp_info *info, int afi,
+ int type, unsigned int seq)
+{
+ struct stream *obuf;
+ struct attr *attr;
+ struct peer *peer;
+ int plen;
+ int safi = 0;
+
+ /* Make dump stream. */
+ obuf = bgp_dump_obuf;
+ stream_reset (obuf);
+
+ attr = info->attr;
+ peer = info->peer;
+
+ /* We support MRT's old format. */
+ if (type == MSG_TABLE_DUMP)
+ {
+ bgp_dump_header (obuf, MSG_TABLE_DUMP, afi);
+ stream_putw (obuf, 0); /* View # */
+ stream_putw (obuf, seq); /* Sequence number. */
+ }
+ else
+ {
+ bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_ENTRY);
+
+ stream_putl (obuf, info->uptime); /* Time Last Change */
+ stream_putw (obuf, afi); /* Address Family */
+ stream_putc (obuf, safi); /* SAFI */
+ }
+
+ if (afi == AFI_IP)
+ {
+ if (type == MSG_TABLE_DUMP)
+ {
+ /* Prefix */
+ stream_put_in_addr (obuf, &p->u.prefix4);
+ stream_putc (obuf, p->prefixlen);
+
+ /* Status */
+ stream_putc (obuf, 1);
+
+ /* Originated */
+ stream_putl (obuf, info->uptime);
+
+ /* Peer's IP address */
+ stream_put_in_addr (obuf, &peer->su.sin.sin_addr);
+
+ /* Peer's AS number. */
+ stream_putw (obuf, peer->as);
+
+ /* Dump attribute. */
+ bgp_dump_routes_attr (obuf, attr);
+ }
+ else
+ {
+ /* Next-Hop-Len */
+ stream_putc (obuf, IPV4_MAX_BYTELEN);
+ stream_put_in_addr (obuf, &attr->nexthop);
+ stream_putc (obuf, p->prefixlen);
+ plen = PSIZE (p->prefixlen);
+ stream_put (obuf, &p->u.prefix4, plen);
+ bgp_dump_routes_attr (obuf, attr);
+ }
+ }
+#ifdef HAVE_IPV6
+ else if (afi == AFI_IP6)
+ {
+ if (type == MSG_TABLE_DUMP)
+ {
+ /* Prefix */
+ stream_write (obuf, (u_char *)&p->u.prefix6, IPV6_MAX_BYTELEN);
+ stream_putc (obuf, p->prefixlen);
+
+ /* Status */
+ stream_putc (obuf, 1);
+
+ /* Originated */
+ stream_putl (obuf, info->uptime);
+
+ /* Peer's IP address */
+ stream_write (obuf, (u_char *)&peer->su.sin6.sin6_addr,
+ IPV6_MAX_BYTELEN);
+
+ /* Peer's AS number. */
+ stream_putw (obuf, peer->as);
+
+ /* Dump attribute. */
+ bgp_dump_routes_attr (obuf, attr);
+ }
+ else
+ {
+ ;
+ }
+ }
+#endif /* HAVE_IPV6 */
+
+ /* Set length. */
+ bgp_dump_set_size (obuf, type);
+
+ fwrite (STREAM_DATA (obuf), stream_get_putp (obuf), 1, bgp_dump_routes.fp);
+ fflush (bgp_dump_routes.fp);
+}
+
+/* Runs under child process. */
+void
+bgp_dump_routes_func (int afi)
+{
+ struct stream *obuf;
+ struct bgp_node *rn;
+ struct bgp_info *info;
+ struct bgp *bgp;
+ struct bgp_table *table;
+ unsigned int seq = 0;
+
+ obuf = bgp_dump_obuf;
+
+ bgp = bgp_get_default ();
+ if (!bgp)
+ return;
+
+ if (bgp_dump_routes.fp == NULL)
+ return;
+
+ /* Walk down each BGP route. */
+ table = bgp->rib[afi][SAFI_UNICAST];
+
+ for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn))
+ for (info = rn->info; info; info = info->next)
+ bgp_dump_routes_entry (&rn->p, info, afi, MSG_TABLE_DUMP, seq++);
+}
+
+int
+bgp_dump_interval_func (struct thread *t)
+{
+ struct bgp_dump *bgp_dump;
+
+ bgp_dump = THREAD_ARG (t);
+ bgp_dump->t_interval = NULL;
+
+ if (bgp_dump_open_file (bgp_dump) == NULL)
+ return 0;
+
+ /* In case of bgp_dump_routes, we need special route dump function. */
+ if (bgp_dump->type == BGP_DUMP_ROUTES)
+ {
+ bgp_dump_routes_func (AFI_IP);
+ bgp_dump_routes_func (AFI_IP6);
+ }
+
+ bgp_dump_interval_add (bgp_dump, bgp_dump->interval);
+
+ return 0;
+}
+
+/* Dump common information. */
+void
+bgp_dump_common (struct stream *obuf, struct peer *peer)
+{
+ 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. */
+ stream_putw (obuf, peer->as);
+ stream_putw (obuf, peer->local_as);
+
+ if (peer->afc[AFI_IP][SAFI_UNICAST])
+ {
+ stream_putw (obuf, peer->ifindex);
+ 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);
+ }
+#ifdef HAVE_IPV6
+ else if (peer->afc[AFI_IP6][SAFI_UNICAST])
+ {
+ /* Interface Index and Address family. */
+ stream_putw (obuf, peer->ifindex);
+ 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);
+ }
+#endif /* HAVE_IPV6 */
+}
+
+/* Dump BGP status change. */
+void
+bgp_dump_state (struct peer *peer, int status_old, int status_new)
+{
+ struct stream *obuf;
+
+ /* If dump file pointer is disabled return immediately. */
+ if (bgp_dump_all.fp == NULL)
+ return;
+
+ /* Make dump stream. */
+ obuf = bgp_dump_obuf;
+ stream_reset (obuf);
+
+ bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_STATE_CHANGE);
+ bgp_dump_common (obuf, peer);
+
+ stream_putw (obuf, status_old);
+ stream_putw (obuf, status_new);
+
+ /* Set length. */
+ bgp_dump_set_size (obuf, MSG_PROTOCOL_BGP4MP);
+
+ /* Write to the stream. */
+ fwrite (STREAM_DATA (obuf), stream_get_putp (obuf), 1, bgp_dump_all.fp);
+ fflush (bgp_dump_all.fp);
+}
+
+void
+bgp_dump_packet_func (struct bgp_dump *bgp_dump, struct peer *peer,
+ struct stream *packet)
+{
+ struct stream *obuf;
+
+ /* If dump file pointer is disabled return immediately. */
+ if (bgp_dump->fp == NULL)
+ return;
+
+ /* Make dump stream. */
+ obuf = bgp_dump_obuf;
+ stream_reset (obuf);
+
+ /* Dump header and common part. */
+ bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE);
+ bgp_dump_common (obuf, peer);
+
+ /* 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_putp (obuf), 1, bgp_dump->fp);
+ fflush (bgp_dump->fp);
+}
+
+/* Called from bgp_packet.c when BGP packet is received. */
+void
+bgp_dump_packet (struct peer *peer, int type, 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);
+}
+
+unsigned int
+bgp_dump_parse_time (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 ((int) 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_h = 1;
+ }
+ else
+ return 0;
+ }
+ return total + time;
+}
+
+int
+bgp_dump_set (struct vty *vty, struct bgp_dump *bgp_dump, int type,
+ char *path, char *interval_str)
+{
+ if (interval_str)
+ {
+ unsigned int interval;
+
+ /* Check interval string. */
+ interval = bgp_dump_parse_time (interval_str);
+ if (interval == 0)
+ {
+ vty_out (vty, "Malformed interval string%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+ /* Set interval. */
+ bgp_dump->interval = interval;
+ if (bgp_dump->interval_str)
+ free (bgp_dump->interval_str);
+ bgp_dump->interval_str = strdup (interval_str);
+
+ /* Create interval thread. */
+ bgp_dump_interval_add (bgp_dump, interval);
+ }
+
+ /* Set type. */
+ bgp_dump->type = type;
+
+ /* Set file name. */
+ if (bgp_dump->filename)
+ free (bgp_dump->filename);
+ bgp_dump->filename = strdup (path);
+
+ /* This should be called when interval is expired. */
+ bgp_dump_open_file (bgp_dump);
+
+ return CMD_SUCCESS;
+}
+
+int
+bgp_dump_unset (struct vty *vty, struct bgp_dump *bgp_dump)
+{
+ /* Set file name. */
+ if (bgp_dump->filename)
+ {
+ free (bgp_dump->filename);
+ bgp_dump->filename = NULL;
+ }
+
+ /* This should be called when interval is expired. */
+ if (bgp_dump->fp)
+ {
+ fclose (bgp_dump->fp);
+ bgp_dump->fp = NULL;
+ }
+
+ /* Create interval thread. */
+ if (bgp_dump->t_interval)
+ {
+ thread_cancel (bgp_dump->t_interval);
+ bgp_dump->t_interval = NULL;
+ }
+
+ bgp_dump->interval = 0;
+
+ if (bgp_dump->interval_str)
+ {
+ free (bgp_dump->interval_str);
+ bgp_dump->interval_str = NULL;
+ }
+
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (dump_bgp_all,
+ dump_bgp_all_cmd,
+ "dump bgp all PATH",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump all BGP packets\n"
+ "Output filename\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_all, BGP_DUMP_ALL, argv[0], NULL);
+}
+
+DEFUN (dump_bgp_all_interval,
+ dump_bgp_all_interval_cmd,
+ "dump bgp all PATH INTERVAL",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump all BGP packets\n"
+ "Output filename\n"
+ "Interval of output\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_all, BGP_DUMP_ALL, argv[0], argv[1]);
+}
+
+DEFUN (no_dump_bgp_all,
+ no_dump_bgp_all_cmd,
+ "no dump bgp all [PATH] [INTERVAL]",
+ NO_STR
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump all BGP packets\n")
+{
+ return bgp_dump_unset (vty, &bgp_dump_all);
+}
+
+DEFUN (dump_bgp_updates,
+ dump_bgp_updates_cmd,
+ "dump bgp updates PATH",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump BGP updates only\n"
+ "Output filename\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_updates, BGP_DUMP_UPDATES, argv[0], NULL);
+}
+
+DEFUN (dump_bgp_updates_interval,
+ dump_bgp_updates_interval_cmd,
+ "dump bgp updates PATH INTERVAL",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump BGP updates only\n"
+ "Output filename\n"
+ "Interval of output\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_updates, BGP_DUMP_UPDATES, argv[0], argv[1]);
+}
+
+DEFUN (no_dump_bgp_updates,
+ no_dump_bgp_updates_cmd,
+ "no dump bgp updates [PATH] [INTERVAL]",
+ NO_STR
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump BGP updates only\n")
+{
+ return bgp_dump_unset (vty, &bgp_dump_updates);
+}
+
+DEFUN (dump_bgp_routes,
+ dump_bgp_routes_cmd,
+ "dump bgp routes-mrt PATH",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump whole BGP routing table\n"
+ "Output filename\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_routes, BGP_DUMP_ROUTES, argv[0], NULL);
+}
+
+DEFUN (dump_bgp_routes_interval,
+ dump_bgp_routes_interval_cmd,
+ "dump bgp routes-mrt PATH INTERVAL",
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump whole BGP routing table\n"
+ "Output filename\n"
+ "Interval of output\n")
+{
+ return bgp_dump_set (vty, &bgp_dump_routes, BGP_DUMP_ROUTES, argv[0], argv[1]);
+}
+
+DEFUN (no_dump_bgp_routes,
+ no_dump_bgp_routes_cmd,
+ "no dump bgp routes-mrt [PATH] [INTERVAL]",
+ NO_STR
+ "Dump packet\n"
+ "BGP packet dump\n"
+ "Dump whole BGP routing table\n")
+{
+ return bgp_dump_unset (vty, &bgp_dump_routes);
+}
+
+/* BGP node structure. */
+struct cmd_node bgp_dump_node =
+{
+ DUMP_NODE,
+ "",
+};
+
+#if 0
+char *
+config_time2str (unsigned int interval)
+{
+ static char buf[BUFSIZ];
+
+ buf[0] = '\0';
+
+ if (interval / 3600)
+ {
+ sprintf (buf, "%dh", interval / 3600);
+ interval %= 3600;
+ }
+ if (interval / 60)
+ {
+ sprintf (buf + strlen (buf), "%dm", interval /60);
+ interval %= 60;
+ }
+ if (interval)
+ {
+ sprintf (buf + strlen (buf), "%d", interval);
+ }
+ return buf;
+}
+#endif
+
+int
+config_write_bgp_dump (struct vty *vty)
+{
+ if (bgp_dump_all.filename)
+ {
+ if (bgp_dump_all.interval_str)
+ vty_out (vty, "dump bgp all %s %s%s",
+ bgp_dump_all.filename, bgp_dump_all.interval_str,
+ VTY_NEWLINE);
+ else
+ vty_out (vty, "dump bgp all %s%s",
+ bgp_dump_all.filename, VTY_NEWLINE);
+ }
+ if (bgp_dump_updates.filename)
+ {
+ if (bgp_dump_updates.interval_str)
+ vty_out (vty, "dump bgp updates %s %s%s",
+ bgp_dump_updates.filename, bgp_dump_updates.interval_str,
+ VTY_NEWLINE);
+ else
+ vty_out (vty, "dump bgp updates %s%s",
+ bgp_dump_updates.filename, VTY_NEWLINE);
+ }
+ if (bgp_dump_routes.filename)
+ {
+ if (bgp_dump_routes.interval_str)
+ vty_out (vty, "dump bgp routes-mrt %s %s%s",
+ bgp_dump_routes.filename, bgp_dump_routes.interval_str,
+ VTY_NEWLINE);
+ else
+ vty_out (vty, "dump bgp routes-mrt %s%s",
+ bgp_dump_routes.filename, VTY_NEWLINE);
+ }
+ return 0;
+}
+
+/* Initialize BGP packet dump functionality. */
+void
+bgp_dump_init ()
+{
+ memset (&bgp_dump_all, 0, sizeof (struct bgp_dump));
+ memset (&bgp_dump_updates, 0, sizeof (struct bgp_dump));
+ memset (&bgp_dump_routes, 0, sizeof (struct bgp_dump));
+
+ bgp_dump_obuf = stream_new (BGP_MAX_PACKET_SIZE + BGP_DUMP_HEADER_SIZE);
+
+ install_node (&bgp_dump_node, config_write_bgp_dump);
+
+ install_element (CONFIG_NODE, &dump_bgp_all_cmd);
+ install_element (CONFIG_NODE, &dump_bgp_all_interval_cmd);
+ install_element (CONFIG_NODE, &no_dump_bgp_all_cmd);
+ install_element (CONFIG_NODE, &dump_bgp_updates_cmd);
+ install_element (CONFIG_NODE, &dump_bgp_updates_interval_cmd);
+ install_element (CONFIG_NODE, &no_dump_bgp_updates_cmd);
+ install_element (CONFIG_NODE, &dump_bgp_routes_cmd);
+ install_element (CONFIG_NODE, &dump_bgp_routes_interval_cmd);
+ install_element (CONFIG_NODE, &no_dump_bgp_routes_cmd);
+}