1: /* BGP-4 dump routine
2: Copyright (C) 1999 Kunihiro Ishiguro
3:
4: This file is part of GNU Zebra.
5:
6: GNU Zebra is free software; you can redistribute it and/or modify it
7: under the terms of the GNU General Public License as published by the
8: Free Software Foundation; either version 2, or (at your option) any
9: later version.
10:
11: GNU Zebra is distributed in the hope that it will be useful, but
12: WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Zebra; see the file COPYING. If not, write to the Free
18: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "log.h"
24: #include "stream.h"
25: #include "sockunion.h"
26: #include "command.h"
27: #include "prefix.h"
28: #include "thread.h"
29: #include "linklist.h"
30: #include "bgpd/bgp_table.h"
31:
32: #include "bgpd/bgpd.h"
33: #include "bgpd/bgp_route.h"
34: #include "bgpd/bgp_attr.h"
35: #include "bgpd/bgp_dump.h"
36:
37: enum bgp_dump_type
38: {
39: BGP_DUMP_ALL,
40: BGP_DUMP_UPDATES,
41: BGP_DUMP_ROUTES
42: };
43:
44: enum MRT_MSG_TYPES {
45: MSG_NULL,
46: MSG_START, /* sender is starting up */
47: MSG_DIE, /* receiver should shut down */
48: MSG_I_AM_DEAD, /* sender is shutting down */
49: MSG_PEER_DOWN, /* sender's peer is down */
50: MSG_PROTOCOL_BGP, /* msg is a BGP packet */
51: MSG_PROTOCOL_RIP, /* msg is a RIP packet */
52: MSG_PROTOCOL_IDRP, /* msg is an IDRP packet */
53: MSG_PROTOCOL_RIPNG, /* msg is a RIPNG packet */
54: MSG_PROTOCOL_BGP4PLUS, /* msg is a BGP4+ packet */
55: MSG_PROTOCOL_BGP4PLUS_01, /* msg is a BGP4+ (draft 01) packet */
56: MSG_PROTOCOL_OSPF, /* msg is an OSPF packet */
57: MSG_TABLE_DUMP, /* routing table dump */
58: MSG_TABLE_DUMP_V2 /* routing table dump, version 2 */
59: };
60:
61: static int bgp_dump_interval_func (struct thread *);
62:
63: struct bgp_dump
64: {
65: enum bgp_dump_type type;
66:
67: char *filename;
68:
69: FILE *fp;
70:
71: unsigned int interval;
72:
73: char *interval_str;
74:
75: struct thread *t_interval;
76: };
77:
78: /* BGP packet dump output buffer. */
79: struct stream *bgp_dump_obuf;
80:
81: /* BGP dump strucuture for 'dump bgp all' */
82: struct bgp_dump bgp_dump_all;
83:
84: /* BGP dump structure for 'dump bgp updates' */
85: struct bgp_dump bgp_dump_updates;
86:
87: /* BGP dump structure for 'dump bgp routes' */
88: struct bgp_dump bgp_dump_routes;
89:
90: /* Dump whole BGP table is very heavy process. */
91: struct thread *t_bgp_dump_routes;
92:
93: /* Some define for BGP packet dump. */
94: static FILE *
95: bgp_dump_open_file (struct bgp_dump *bgp_dump)
96: {
97: int ret;
98: time_t clock;
99: struct tm *tm;
100: char fullpath[MAXPATHLEN];
101: char realpath[MAXPATHLEN];
102: mode_t oldumask;
103:
104: time (&clock);
105: tm = localtime (&clock);
106:
107: if (bgp_dump->filename[0] != DIRECTORY_SEP)
108: {
109: sprintf (fullpath, "%s/%s", vty_get_cwd (), bgp_dump->filename);
110: ret = strftime (realpath, MAXPATHLEN, fullpath, tm);
111: }
112: else
113: ret = strftime (realpath, MAXPATHLEN, bgp_dump->filename, tm);
114:
115: if (ret == 0)
116: {
117: zlog_warn ("bgp_dump_open_file: strftime error");
118: return NULL;
119: }
120:
121: if (bgp_dump->fp)
122: fclose (bgp_dump->fp);
123:
124:
125: oldumask = umask(0777 & ~LOGFILE_MASK);
126: bgp_dump->fp = fopen (realpath, "w");
127:
128: if (bgp_dump->fp == NULL)
129: {
130: zlog_warn ("bgp_dump_open_file: %s: %s", realpath, strerror (errno));
131: umask(oldumask);
132: return NULL;
133: }
134: umask(oldumask);
135:
136: return bgp_dump->fp;
137: }
138:
139: static int
140: bgp_dump_interval_add (struct bgp_dump *bgp_dump, int interval)
141: {
142: int secs_into_day;
143: time_t t;
144: struct tm *tm;
145:
146: if (interval > 0)
147: {
148: /* Periodic dump every interval seconds */
149: if ((interval < 86400) && ((86400 % interval) == 0))
150: {
151: /* Dump at predictable times: if a day has a whole number of
152: * intervals, dump every interval seconds starting from midnight
153: */
154: (void) time(&t);
155: tm = localtime(&t);
156: secs_into_day = tm->tm_sec + 60*tm->tm_min + 60*60*tm->tm_hour;
157: interval = interval - secs_into_day % interval; /* always > 0 */
158: }
159: bgp_dump->t_interval = thread_add_timer (master, bgp_dump_interval_func,
160: bgp_dump, interval);
161: }
162: else
163: {
164: /* One-off dump: execute immediately, don't affect any scheduled dumps */
165: bgp_dump->t_interval = thread_add_event (master, bgp_dump_interval_func,
166: bgp_dump, 0);
167: }
168:
169: return 0;
170: }
171:
172: /* Dump common header. */
173: static void
174: bgp_dump_header (struct stream *obuf, int type, int subtype)
175: {
176: time_t now;
177:
178: /* Set header. */
179: time (&now);
180:
181: /* Put dump packet header. */
182: stream_putl (obuf, now);
183: stream_putw (obuf, type);
184: stream_putw (obuf, subtype);
185:
186: stream_putl (obuf, 0); /* len */
187: }
188:
189: static void
190: bgp_dump_set_size (struct stream *s, int type)
191: {
192: stream_putl_at (s, 8, stream_get_endp (s) - BGP_DUMP_HEADER_SIZE);
193: }
194:
195: static void
196: bgp_dump_routes_index_table(struct bgp *bgp)
197: {
198: struct peer *peer;
199: struct listnode *node;
200: uint16_t peerno = 0;
201: struct stream *obuf;
202:
203: obuf = bgp_dump_obuf;
204: stream_reset (obuf);
205:
206: /* MRT header */
207: bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_PEER_INDEX_TABLE);
208:
209: /* Collector BGP ID */
210: stream_put_in_addr (obuf, &bgp->router_id);
211:
212: /* View name */
213: if(bgp->name)
214: {
215: stream_putw (obuf, strlen(bgp->name));
216: stream_put(obuf, bgp->name, strlen(bgp->name));
217: }
218: else
219: {
220: stream_putw(obuf, 0);
221: }
222:
223: /* Peer count */
224: stream_putw (obuf, listcount(bgp->peer));
225:
226: /* Walk down all peers */
227: for(ALL_LIST_ELEMENTS_RO (bgp->peer, node, peer))
228: {
229:
230: /* Peer's type */
231: if (sockunion_family(&peer->su) == AF_INET)
232: {
233: stream_putc (obuf, TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4+TABLE_DUMP_V2_PEER_INDEX_TABLE_IP);
234: }
235: #ifdef HAVE_IPV6
236: else if (sockunion_family(&peer->su) == AF_INET6)
237: {
238: stream_putc (obuf, TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4+TABLE_DUMP_V2_PEER_INDEX_TABLE_IP6);
239: }
240: #endif /* HAVE_IPV6 */
241:
242: /* Peer's BGP ID */
243: stream_put_in_addr (obuf, &peer->remote_id);
244:
245: /* Peer's IP address */
246: if (sockunion_family(&peer->su) == AF_INET)
247: {
248: stream_put_in_addr (obuf, &peer->su.sin.sin_addr);
249: }
250: #ifdef HAVE_IPV6
251: else if (sockunion_family(&peer->su) == AF_INET6)
252: {
253: stream_write (obuf, (u_char *)&peer->su.sin6.sin6_addr,
254: IPV6_MAX_BYTELEN);
255: }
256: #endif /* HAVE_IPV6 */
257:
258: /* Peer's AS number. */
259: /* Note that, as this is an AS4 compliant quagga, the RIB is always AS4 */
260: stream_putl (obuf, peer->as);
261:
262: /* Store the peer number for this peer */
263: peer->table_dump_index = peerno;
264: peerno++;
265: }
266:
267: bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2);
268:
269: fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump_routes.fp);
270: fflush (bgp_dump_routes.fp);
271: }
272:
273:
274: /* Runs under child process. */
275: static unsigned int
276: bgp_dump_routes_func (int afi, int first_run, unsigned int seq)
277: {
278: struct stream *obuf;
279: struct bgp_info *info;
280: struct bgp_node *rn;
281: struct bgp *bgp;
282: struct bgp_table *table;
283:
284: bgp = bgp_get_default ();
285: if (!bgp)
286: return seq;
287:
288: if (bgp_dump_routes.fp == NULL)
289: return seq;
290:
291: /* Note that bgp_dump_routes_index_table will do ipv4 and ipv6 peers,
292: so this should only be done on the first call to bgp_dump_routes_func.
293: ( this function will be called once for ipv4 and once for ipv6 ) */
294: if(first_run)
295: bgp_dump_routes_index_table(bgp);
296:
297: obuf = bgp_dump_obuf;
298: stream_reset(obuf);
299:
300: /* Walk down each BGP route. */
301: table = bgp->rib[afi][SAFI_UNICAST];
302:
303: for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn))
304: {
305: if(!rn->info)
306: continue;
307:
308: stream_reset(obuf);
309:
310: /* MRT header */
311: if (afi == AFI_IP)
312: {
313: bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_RIB_IPV4_UNICAST);
314: }
315: #ifdef HAVE_IPV6
316: else if (afi == AFI_IP6)
317: {
318: bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_RIB_IPV6_UNICAST);
319: }
320: #endif /* HAVE_IPV6 */
321:
322: /* Sequence number */
323: stream_putl(obuf, seq);
324:
325: /* Prefix length */
326: stream_putc (obuf, rn->p.prefixlen);
327:
328: /* Prefix */
329: if (afi == AFI_IP)
330: {
331: /* We'll dump only the useful bits (those not 0), but have to align on 8 bits */
332: stream_write(obuf, (u_char *)&rn->p.u.prefix4, (rn->p.prefixlen+7)/8);
333: }
334: #ifdef HAVE_IPV6
335: else if (afi == AFI_IP6)
336: {
337: /* We'll dump only the useful bits (those not 0), but have to align on 8 bits */
338: stream_write (obuf, (u_char *)&rn->p.u.prefix6, (rn->p.prefixlen+7)/8);
339: }
340: #endif /* HAVE_IPV6 */
341:
342: /* Save where we are now, so we can overwride the entry count later */
343: int sizep = stream_get_endp(obuf);
344:
345: /* Entry count */
346: uint16_t entry_count = 0;
347:
348: /* Entry count, note that this is overwritten later */
349: stream_putw(obuf, 0);
350:
351: for (info = rn->info; info; info = info->next)
352: {
353: entry_count++;
354:
355: /* Peer index */
356: stream_putw(obuf, info->peer->table_dump_index);
357:
358: /* Originated */
359: #ifdef HAVE_CLOCK_MONOTONIC
360: stream_putl (obuf, time(NULL) - (bgp_clock() - info->uptime));
361: #else
362: stream_putl (obuf, info->uptime);
363: #endif /* HAVE_CLOCK_MONOTONIC */
364:
365: /* Dump attribute. */
366: /* Skip prefix & AFI/SAFI for MP_NLRI */
367: bgp_dump_routes_attr (obuf, info->attr, &rn->p);
368: }
369:
370: /* Overwrite the entry count, now that we know the right number */
371: stream_putw_at (obuf, sizep, entry_count);
372:
373: seq++;
374:
375: bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2);
376: fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump_routes.fp);
377:
378: }
379:
380: fflush (bgp_dump_routes.fp);
381:
382: return seq;
383: }
384:
385: static int
386: bgp_dump_interval_func (struct thread *t)
387: {
388: struct bgp_dump *bgp_dump;
389: bgp_dump = THREAD_ARG (t);
390: bgp_dump->t_interval = NULL;
391:
392: /* Reschedule dump even if file couldn't be opened this time... */
393: if (bgp_dump_open_file (bgp_dump) != NULL)
394: {
395: /* In case of bgp_dump_routes, we need special route dump function. */
396: if (bgp_dump->type == BGP_DUMP_ROUTES)
397: {
398: unsigned int seq = bgp_dump_routes_func (AFI_IP, 1, 0);
399: #ifdef HAVE_IPV6
400: bgp_dump_routes_func (AFI_IP6, 0, seq);
401: #endif /* HAVE_IPV6 */
402: /* Close the file now. For a RIB dump there's no point in leaving
403: * it open until the next scheduled dump starts. */
404: fclose(bgp_dump->fp); bgp_dump->fp = NULL;
405: }
406: }
407:
408: /* if interval is set reschedule */
409: if (bgp_dump->interval > 0)
410: bgp_dump_interval_add (bgp_dump, bgp_dump->interval);
411:
412: return 0;
413: }
414:
415: /* Dump common information. */
416: static void
417: bgp_dump_common (struct stream *obuf, struct peer *peer, int forceas4)
418: {
419: char empty[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
420:
421: /* Source AS number and Destination AS number. */
422: if (forceas4 || CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) )
423: {
424: stream_putl (obuf, peer->as);
425: stream_putl (obuf, peer->local_as);
426: }
427: else
428: {
429: stream_putw (obuf, peer->as);
430: stream_putw (obuf, peer->local_as);
431: }
432:
433: if (peer->su.sa.sa_family == AF_INET)
434: {
435: stream_putw (obuf, peer->ifindex);
436: stream_putw (obuf, AFI_IP);
437:
438: stream_put (obuf, &peer->su.sin.sin_addr, IPV4_MAX_BYTELEN);
439:
440: if (peer->su_local)
441: stream_put (obuf, &peer->su_local->sin.sin_addr, IPV4_MAX_BYTELEN);
442: else
443: stream_put (obuf, empty, IPV4_MAX_BYTELEN);
444: }
445: #ifdef HAVE_IPV6
446: else if (peer->su.sa.sa_family == AF_INET6)
447: {
448: /* Interface Index and Address family. */
449: stream_putw (obuf, peer->ifindex);
450: stream_putw (obuf, AFI_IP6);
451:
452: /* Source IP Address and Destination IP Address. */
453: stream_put (obuf, &peer->su.sin6.sin6_addr, IPV6_MAX_BYTELEN);
454:
455: if (peer->su_local)
456: stream_put (obuf, &peer->su_local->sin6.sin6_addr, IPV6_MAX_BYTELEN);
457: else
458: stream_put (obuf, empty, IPV6_MAX_BYTELEN);
459: }
460: #endif /* HAVE_IPV6 */
461: }
462:
463: /* Dump BGP status change. */
464: void
465: bgp_dump_state (struct peer *peer, int status_old, int status_new)
466: {
467: struct stream *obuf;
468:
469: /* If dump file pointer is disabled return immediately. */
470: if (bgp_dump_all.fp == NULL)
471: return;
472:
473: /* Make dump stream. */
474: obuf = bgp_dump_obuf;
475: stream_reset (obuf);
476:
477: bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_STATE_CHANGE_AS4);
478: bgp_dump_common (obuf, peer, 1);/* force this in as4speak*/
479:
480: stream_putw (obuf, status_old);
481: stream_putw (obuf, status_new);
482:
483: /* Set length. */
484: bgp_dump_set_size (obuf, MSG_PROTOCOL_BGP4MP);
485:
486: /* Write to the stream. */
487: fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump_all.fp);
488: fflush (bgp_dump_all.fp);
489: }
490:
491: static void
492: bgp_dump_packet_func (struct bgp_dump *bgp_dump, struct peer *peer,
493: struct stream *packet)
494: {
495: struct stream *obuf;
496:
497: /* If dump file pointer is disabled return immediately. */
498: if (bgp_dump->fp == NULL)
499: return;
500:
501: /* Make dump stream. */
502: obuf = bgp_dump_obuf;
503: stream_reset (obuf);
504:
505: /* Dump header and common part. */
506: if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) )
507: {
508: bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE_AS4);
509: }
510: else
511: {
512: bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE);
513: }
514: bgp_dump_common (obuf, peer, 0);
515:
516: /* Packet contents. */
517: stream_put (obuf, STREAM_DATA (packet), stream_get_endp (packet));
518:
519: /* Set length. */
520: bgp_dump_set_size (obuf, MSG_PROTOCOL_BGP4MP);
521:
522: /* Write to the stream. */
523: fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump->fp);
524: fflush (bgp_dump->fp);
525: }
526:
527: /* Called from bgp_packet.c when BGP packet is received. */
528: void
529: bgp_dump_packet (struct peer *peer, int type, struct stream *packet)
530: {
531: /* bgp_dump_all. */
532: bgp_dump_packet_func (&bgp_dump_all, peer, packet);
533:
534: /* bgp_dump_updates. */
535: if (type == BGP_MSG_UPDATE)
536: bgp_dump_packet_func (&bgp_dump_updates, peer, packet);
537: }
538:
539: static unsigned int
540: bgp_dump_parse_time (const char *str)
541: {
542: int i;
543: int len;
544: int seen_h;
545: int seen_m;
546: int time;
547: unsigned int total;
548:
549: time = 0;
550: total = 0;
551: seen_h = 0;
552: seen_m = 0;
553: len = strlen (str);
554:
555: for (i = 0; i < len; i++)
556: {
557: if (isdigit ((int) str[i]))
558: {
559: time *= 10;
560: time += str[i] - '0';
561: }
562: else if (str[i] == 'H' || str[i] == 'h')
563: {
564: if (seen_h)
565: return 0;
566: if (seen_m)
567: return 0;
568: total += time * 60 *60;
569: time = 0;
570: seen_h = 1;
571: }
572: else if (str[i] == 'M' || str[i] == 'm')
573: {
574: if (seen_m)
575: return 0;
576: total += time * 60;
577: time = 0;
578: seen_h = 1;
579: }
580: else
581: return 0;
582: }
583: return total + time;
584: }
585:
586: static int
587: bgp_dump_set (struct vty *vty, struct bgp_dump *bgp_dump,
588: enum bgp_dump_type type, const char *path,
589: const char *interval_str)
590: {
591: unsigned int interval;
592:
593: if (interval_str)
594: {
595:
596: /* Check interval string. */
597: interval = bgp_dump_parse_time (interval_str);
598: if (interval == 0)
599: {
600: vty_out (vty, "Malformed interval string%s", VTY_NEWLINE);
601: return CMD_WARNING;
602: }
603:
604: /* Don't schedule duplicate dumps if the dump command is given twice */
605: if (interval == bgp_dump->interval &&
606: type == bgp_dump->type &&
607: path && bgp_dump->filename && !strcmp (path, bgp_dump->filename))
608: {
609: return CMD_SUCCESS;
610: }
611:
612: /* Set interval. */
613: bgp_dump->interval = interval;
614: if (bgp_dump->interval_str)
615: free (bgp_dump->interval_str);
616: bgp_dump->interval_str = strdup (interval_str);
617:
618: }
619: else
620: {
621: interval = 0;
622: }
623:
624: /* Create interval thread. */
625: bgp_dump_interval_add (bgp_dump, interval);
626:
627: /* Set type. */
628: bgp_dump->type = type;
629:
630: /* Set file name. */
631: if (bgp_dump->filename)
632: free (bgp_dump->filename);
633: bgp_dump->filename = strdup (path);
634:
635: /* This should be called when interval is expired. */
636: bgp_dump_open_file (bgp_dump);
637:
638: return CMD_SUCCESS;
639: }
640:
641: static int
642: bgp_dump_unset (struct vty *vty, struct bgp_dump *bgp_dump)
643: {
644: /* Set file name. */
645: if (bgp_dump->filename)
646: {
647: free (bgp_dump->filename);
648: bgp_dump->filename = NULL;
649: }
650:
651: /* This should be called when interval is expired. */
652: if (bgp_dump->fp)
653: {
654: fclose (bgp_dump->fp);
655: bgp_dump->fp = NULL;
656: }
657:
658: /* Create interval thread. */
659: if (bgp_dump->t_interval)
660: {
661: thread_cancel (bgp_dump->t_interval);
662: bgp_dump->t_interval = NULL;
663: }
664:
665: bgp_dump->interval = 0;
666:
667: if (bgp_dump->interval_str)
668: {
669: free (bgp_dump->interval_str);
670: bgp_dump->interval_str = NULL;
671: }
672:
673:
674: return CMD_SUCCESS;
675: }
676:
677: DEFUN (dump_bgp_all,
678: dump_bgp_all_cmd,
679: "dump bgp all PATH",
680: "Dump packet\n"
681: "BGP packet dump\n"
682: "Dump all BGP packets\n"
683: "Output filename\n")
684: {
685: return bgp_dump_set (vty, &bgp_dump_all, BGP_DUMP_ALL, argv[0], NULL);
686: }
687:
688: DEFUN (dump_bgp_all_interval,
689: dump_bgp_all_interval_cmd,
690: "dump bgp all PATH INTERVAL",
691: "Dump packet\n"
692: "BGP packet dump\n"
693: "Dump all BGP packets\n"
694: "Output filename\n"
695: "Interval of output\n")
696: {
697: return bgp_dump_set (vty, &bgp_dump_all, BGP_DUMP_ALL, argv[0], argv[1]);
698: }
699:
700: DEFUN (no_dump_bgp_all,
701: no_dump_bgp_all_cmd,
702: "no dump bgp all [PATH] [INTERVAL]",
703: NO_STR
704: "Dump packet\n"
705: "BGP packet dump\n"
706: "Dump all BGP packets\n")
707: {
708: return bgp_dump_unset (vty, &bgp_dump_all);
709: }
710:
711: DEFUN (dump_bgp_updates,
712: dump_bgp_updates_cmd,
713: "dump bgp updates PATH",
714: "Dump packet\n"
715: "BGP packet dump\n"
716: "Dump BGP updates only\n"
717: "Output filename\n")
718: {
719: return bgp_dump_set (vty, &bgp_dump_updates, BGP_DUMP_UPDATES, argv[0], NULL);
720: }
721:
722: DEFUN (dump_bgp_updates_interval,
723: dump_bgp_updates_interval_cmd,
724: "dump bgp updates PATH INTERVAL",
725: "Dump packet\n"
726: "BGP packet dump\n"
727: "Dump BGP updates only\n"
728: "Output filename\n"
729: "Interval of output\n")
730: {
731: return bgp_dump_set (vty, &bgp_dump_updates, BGP_DUMP_UPDATES, argv[0], argv[1]);
732: }
733:
734: DEFUN (no_dump_bgp_updates,
735: no_dump_bgp_updates_cmd,
736: "no dump bgp updates [PATH] [INTERVAL]",
737: NO_STR
738: "Dump packet\n"
739: "BGP packet dump\n"
740: "Dump BGP updates only\n")
741: {
742: return bgp_dump_unset (vty, &bgp_dump_updates);
743: }
744:
745: DEFUN (dump_bgp_routes,
746: dump_bgp_routes_cmd,
747: "dump bgp routes-mrt PATH",
748: "Dump packet\n"
749: "BGP packet dump\n"
750: "Dump whole BGP routing table\n"
751: "Output filename\n")
752: {
753: return bgp_dump_set (vty, &bgp_dump_routes, BGP_DUMP_ROUTES, argv[0], NULL);
754: }
755:
756: DEFUN (dump_bgp_routes_interval,
757: dump_bgp_routes_interval_cmd,
758: "dump bgp routes-mrt PATH INTERVAL",
759: "Dump packet\n"
760: "BGP packet dump\n"
761: "Dump whole BGP routing table\n"
762: "Output filename\n"
763: "Interval of output\n")
764: {
765: return bgp_dump_set (vty, &bgp_dump_routes, BGP_DUMP_ROUTES, argv[0], argv[1]);
766: }
767:
768: DEFUN (no_dump_bgp_routes,
769: no_dump_bgp_routes_cmd,
770: "no dump bgp routes-mrt [PATH] [INTERVAL]",
771: NO_STR
772: "Dump packet\n"
773: "BGP packet dump\n"
774: "Dump whole BGP routing table\n")
775: {
776: return bgp_dump_unset (vty, &bgp_dump_routes);
777: }
778:
779: /* BGP node structure. */
780: static struct cmd_node bgp_dump_node =
781: {
782: DUMP_NODE,
783: "",
784: 1
785: };
786:
787: #if 0
788: char *
789: config_time2str (unsigned int interval)
790: {
791: static char buf[BUFSIZ];
792:
793: buf[0] = '\0';
794:
795: if (interval / 3600)
796: {
797: sprintf (buf, "%dh", interval / 3600);
798: interval %= 3600;
799: }
800: if (interval / 60)
801: {
802: sprintf (buf + strlen (buf), "%dm", interval /60);
803: interval %= 60;
804: }
805: if (interval)
806: {
807: sprintf (buf + strlen (buf), "%d", interval);
808: }
809: return buf;
810: }
811: #endif
812:
813: static int
814: config_write_bgp_dump (struct vty *vty)
815: {
816: if (bgp_dump_all.filename)
817: {
818: if (bgp_dump_all.interval_str)
819: vty_out (vty, "dump bgp all %s %s%s",
820: bgp_dump_all.filename, bgp_dump_all.interval_str,
821: VTY_NEWLINE);
822: else
823: vty_out (vty, "dump bgp all %s%s",
824: bgp_dump_all.filename, VTY_NEWLINE);
825: }
826: if (bgp_dump_updates.filename)
827: {
828: if (bgp_dump_updates.interval_str)
829: vty_out (vty, "dump bgp updates %s %s%s",
830: bgp_dump_updates.filename, bgp_dump_updates.interval_str,
831: VTY_NEWLINE);
832: else
833: vty_out (vty, "dump bgp updates %s%s",
834: bgp_dump_updates.filename, VTY_NEWLINE);
835: }
836: if (bgp_dump_routes.filename)
837: {
838: if (bgp_dump_routes.interval_str)
839: vty_out (vty, "dump bgp routes-mrt %s %s%s",
840: bgp_dump_routes.filename, bgp_dump_routes.interval_str,
841: VTY_NEWLINE);
842: else
843: vty_out (vty, "dump bgp routes-mrt %s%s",
844: bgp_dump_routes.filename, VTY_NEWLINE);
845: }
846: return 0;
847: }
848:
849: /* Initialize BGP packet dump functionality. */
850: void
851: bgp_dump_init (void)
852: {
853: memset (&bgp_dump_all, 0, sizeof (struct bgp_dump));
854: memset (&bgp_dump_updates, 0, sizeof (struct bgp_dump));
855: memset (&bgp_dump_routes, 0, sizeof (struct bgp_dump));
856:
857: bgp_dump_obuf = stream_new (BGP_MAX_PACKET_SIZE + BGP_DUMP_MSG_HEADER
858: + BGP_DUMP_HEADER_SIZE);
859:
860: install_node (&bgp_dump_node, config_write_bgp_dump);
861:
862: install_element (CONFIG_NODE, &dump_bgp_all_cmd);
863: install_element (CONFIG_NODE, &dump_bgp_all_interval_cmd);
864: install_element (CONFIG_NODE, &no_dump_bgp_all_cmd);
865: install_element (CONFIG_NODE, &dump_bgp_updates_cmd);
866: install_element (CONFIG_NODE, &dump_bgp_updates_interval_cmd);
867: install_element (CONFIG_NODE, &no_dump_bgp_updates_cmd);
868: install_element (CONFIG_NODE, &dump_bgp_routes_cmd);
869: install_element (CONFIG_NODE, &dump_bgp_routes_interval_cmd);
870: install_element (CONFIG_NODE, &no_dump_bgp_routes_cmd);
871: }
872:
873: void
874: bgp_dump_finish (void)
875: {
876: stream_free (bgp_dump_obuf);
877: bgp_dump_obuf = NULL;
878: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_dump.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd