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