]> git.proxmox.com Git - mirror_frr.git/blame - bgpd/bgp_debug.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #5717 from pguibert6WIND/flowspec_issue_redistribute
[mirror_frr.git] / bgpd / bgp_debug.c
CommitLineData
718e3744 1/* BGP-4, BGP-4+ packet debug routine
896014f4
DL		 2 * Copyright (C) 1996, 97, 99 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 */
718e3744 20
21#include <zebra.h>
22
5e4fa164 23#include <lib/version.h>
718e3744 24#include "prefix.h"
25#include "linklist.h"
26#include "stream.h"
27#include "command.h"
718e3744 28#include "log.h"
29#include "sockunion.h"
16286195 30#include "memory.h"
3f9c7369 31#include "queue.h"
039f3a34 32#include "filter.h"
718e3744 33
34#include "bgpd/bgpd.h"
35#include "bgpd/bgp_aspath.h"
36#include "bgpd/bgp_route.h"
37#include "bgpd/bgp_attr.h"
38#include "bgpd/bgp_debug.h"
39#include "bgpd/bgp_community.h"
3f9c7369 40#include "bgpd/bgp_updgrp.h"
906ad49b 41#include "bgpd/bgp_mplsvpn.h"
a4638609 42#include "bgpd/bgp_ecommunity.h"
b16031a2 43#include "bgpd/bgp_label.h"
44#include "bgpd/bgp_evpn.h"
81cf0de5 45#include "bgpd/bgp_evpn_private.h"
377e3565 46#include "bgpd/bgp_evpn_vty.h"
81cf0de5 47#include "bgpd/bgp_vty.h"
268e1b9b 48#include "bgpd/bgp_flowspec.h"
718e3744 49
0b2aa3a0 50unsigned long conf_bgp_debug_as4;
16286195 51unsigned long conf_bgp_debug_neighbor_events;
718e3744 52unsigned long conf_bgp_debug_events;
53unsigned long conf_bgp_debug_packet;
54unsigned long conf_bgp_debug_filter;
55unsigned long conf_bgp_debug_keepalive;
56unsigned long conf_bgp_debug_update;
9fbdd100 57unsigned long conf_bgp_debug_bestpath;
a39275d7 58unsigned long conf_bgp_debug_zebra;
cebb7440 59unsigned long conf_bgp_debug_allow_martians;
fb018d25 60unsigned long conf_bgp_debug_nht;
3f9c7369 61unsigned long conf_bgp_debug_update_groups;
ddb5b488 62unsigned long conf_bgp_debug_vpn;
268e1b9b 63unsigned long conf_bgp_debug_flowspec;
955bfd98 64unsigned long conf_bgp_debug_labelpool;
1a80fc0f 65unsigned long conf_bgp_debug_pbr;
794b37d5 66unsigned long conf_bgp_debug_graceful_restart;
718e3744 67
0b2aa3a0 68unsigned long term_bgp_debug_as4;
16286195 69unsigned long term_bgp_debug_neighbor_events;
718e3744 70unsigned long term_bgp_debug_events;
71unsigned long term_bgp_debug_packet;
72unsigned long term_bgp_debug_filter;
73unsigned long term_bgp_debug_keepalive;
74unsigned long term_bgp_debug_update;
9fbdd100 75unsigned long term_bgp_debug_bestpath;
a39275d7 76unsigned long term_bgp_debug_zebra;
cebb7440 77unsigned long term_bgp_debug_allow_martians;
fb018d25 78unsigned long term_bgp_debug_nht;
3f9c7369 79unsigned long term_bgp_debug_update_groups;
ddb5b488 80unsigned long term_bgp_debug_vpn;
268e1b9b 81unsigned long term_bgp_debug_flowspec;
955bfd98 82unsigned long term_bgp_debug_labelpool;
1a80fc0f 83unsigned long term_bgp_debug_pbr;
794b37d5 84unsigned long term_bgp_debug_graceful_restart;
718e3744 85
16286195
DS		 86struct list *bgp_debug_neighbor_events_peers = NULL;
87struct list *bgp_debug_keepalive_peers = NULL;
88struct list *bgp_debug_update_out_peers = NULL;
89struct list *bgp_debug_update_in_peers = NULL;
90struct list *bgp_debug_update_prefixes = NULL;
9fbdd100 91struct list *bgp_debug_bestpath_prefixes = NULL;
16286195
DS		 92struct list *bgp_debug_zebra_prefixes = NULL;
93
718e3744 94/* messages for BGP-4 status */
d62a17ae 95const struct message bgp_status_msg[] = {{Idle, "Idle"},
96 {Connect, "Connect"},
97 {Active, "Active"},
98 {OpenSent, "OpenSent"},
99 {OpenConfirm, "OpenConfirm"},
100 {Established, "Established"},
101 {Clearing, "Clearing"},
102 {Deleted, "Deleted"},
103 {0}};
718e3744 104
105/* BGP message type string. */
2b64873d 106const char *const bgp_type_str[] = {NULL, "OPEN", "UPDATE",
d62a17ae 107 "NOTIFICATION", "KEEPALIVE", "ROUTE-REFRESH",
108 "CAPABILITY"};
718e3744 109
110/* message for BGP-4 Notify */
d62a17ae 111static const struct message bgp_notify_msg[] = {
112 {BGP_NOTIFY_HEADER_ERR, "Message Header Error"},
113 {BGP_NOTIFY_OPEN_ERR, "OPEN Message Error"},
114 {BGP_NOTIFY_UPDATE_ERR, "UPDATE Message Error"},
115 {BGP_NOTIFY_HOLD_ERR, "Hold Timer Expired"},
116 {BGP_NOTIFY_FSM_ERR, "Neighbor Events Error"},
117 {BGP_NOTIFY_CEASE, "Cease"},
118 {BGP_NOTIFY_CAPABILITY_ERR, "CAPABILITY Message Error"},
119 {0}};
120
121static const struct message bgp_notify_head_msg[] = {
122 {BGP_NOTIFY_HEADER_NOT_SYNC, "/Connection Not Synchronized"},
123 {BGP_NOTIFY_HEADER_BAD_MESLEN, "/Bad Message Length"},
124 {BGP_NOTIFY_HEADER_BAD_MESTYPE, "/Bad Message Type"},
125 {0}};
126
127static const struct message bgp_notify_open_msg[] = {
128 {BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
129 {BGP_NOTIFY_OPEN_UNSUP_VERSION, "/Unsupported Version Number"},
130 {BGP_NOTIFY_OPEN_BAD_PEER_AS, "/Bad Peer AS"},
131 {BGP_NOTIFY_OPEN_BAD_BGP_IDENT, "/Bad BGP Identifier"},
132 {BGP_NOTIFY_OPEN_UNSUP_PARAM, "/Unsupported Optional Parameter"},
133 {BGP_NOTIFY_OPEN_AUTH_FAILURE, "/Authentication Failure"},
134 {BGP_NOTIFY_OPEN_UNACEP_HOLDTIME, "/Unacceptable Hold Time"},
135 {BGP_NOTIFY_OPEN_UNSUP_CAPBL, "/Unsupported Capability"},
136 {0}};
137
138static const struct message bgp_notify_update_msg[] = {
139 {BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
140 {BGP_NOTIFY_UPDATE_MAL_ATTR, "/Malformed Attribute List"},
141 {BGP_NOTIFY_UPDATE_UNREC_ATTR, "/Unrecognized Well-known Attribute"},
142 {BGP_NOTIFY_UPDATE_MISS_ATTR, "/Missing Well-known Attribute"},
143 {BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR, "/Attribute Flags Error"},
144 {BGP_NOTIFY_UPDATE_ATTR_LENG_ERR, "/Attribute Length Error"},
145 {BGP_NOTIFY_UPDATE_INVAL_ORIGIN, "/Invalid ORIGIN Attribute"},
146 {BGP_NOTIFY_UPDATE_AS_ROUTE_LOOP, "/AS Routing Loop"},
147 {BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP, "/Invalid NEXT_HOP Attribute"},
148 {BGP_NOTIFY_UPDATE_OPT_ATTR_ERR, "/Optional Attribute Error"},
149 {BGP_NOTIFY_UPDATE_INVAL_NETWORK, "/Invalid Network Field"},
150 {BGP_NOTIFY_UPDATE_MAL_AS_PATH, "/Malformed AS_PATH"},
151 {0}};
152
153static const struct message bgp_notify_cease_msg[] = {
154 {BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
155 {BGP_NOTIFY_CEASE_MAX_PREFIX, "/Maximum Number of Prefixes Reached"},
156 {BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN, "/Administratively Shutdown"},
157 {BGP_NOTIFY_CEASE_PEER_UNCONFIG, "/Peer Unconfigured"},
158 {BGP_NOTIFY_CEASE_ADMIN_RESET, "/Administratively Reset"},
159 {BGP_NOTIFY_CEASE_CONNECT_REJECT, "/Connection Rejected"},
160 {BGP_NOTIFY_CEASE_CONFIG_CHANGE, "/Other Configuration Change"},
161 {BGP_NOTIFY_CEASE_COLLISION_RESOLUTION,
162 "/Connection collision resolution"},
163 {BGP_NOTIFY_CEASE_OUT_OF_RESOURCE, "/Out of Resource"},
164 {0}};
165
166static const struct message bgp_notify_capability_msg[] = {
167 {BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
168 {BGP_NOTIFY_CAPABILITY_INVALID_ACTION, "/Invalid Action Value"},
169 {BGP_NOTIFY_CAPABILITY_INVALID_LENGTH, "/Invalid Capability Length"},
170 {BGP_NOTIFY_CAPABILITY_MALFORMED_CODE, "/Malformed Capability Value"},
171 {0}};
718e3744 172
173/* Origin strings. */
2b64873d
DL		 174const char *const bgp_origin_str[] = {"i", "e", "?"};
175const char *const bgp_origin_long_str[] = {"IGP", "EGP", "incomplete"};
718e3744 176
81cf0de5
CS		 177static int bgp_debug_print_evpn_prefix(struct vty *vty, const char *desc,
178 struct prefix *p);
16286195 179/* Given a string return a pointer the corresponding peer structure */
d62a17ae 180static struct peer *bgp_find_peer(struct vty *vty, const char *peer_str)
16286195 181{
d62a17ae 182 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
183 int ret;
184 union sockunion su;
185 struct peer *peer;
186
187 if (!bgp) {
188 return NULL;
189 }
190 ret = str2sockunion(peer_str, &su);
191
192 /* 'swpX' string */
193 if (ret < 0) {
194 peer = peer_lookup_by_conf_if(bgp, peer_str);
195
196 if (!peer)
197 peer = peer_lookup_by_hostname(bgp, peer_str);
198
199 return peer;
200 } else
201 return peer_lookup(bgp, &su);
16286195
DS		 202}
203
d62a17ae 204static void bgp_debug_list_free(struct list *list)
16286195 205{
d62a17ae 206 struct bgp_debug_filter *filter;
207 struct listnode *node, *nnode;
16286195 208
d62a17ae 209 if (list)
210 for (ALL_LIST_ELEMENTS(list, node, nnode, filter)) {
211 listnode_delete(list, filter);
16286195 212
d62a17ae 213 if (filter->p)
63265b5c 214 prefix_free(&filter->p);
16286195 215
d62a17ae 216 if (filter->host)
217 XFREE(MTYPE_BGP_DEBUG_STR, filter->host);
16286195 218
d62a17ae 219 XFREE(MTYPE_BGP_DEBUG_FILTER, filter);
220 }
16286195
DS		 221}
222
29a643ca
QY		 223/*
224 * Print the desc along with a list of peers/prefixes this debug is
225 * enabled for
226 */
d62a17ae 227static void bgp_debug_list_print(struct vty *vty, const char *desc,
29a643ca 228 struct list *list)
d62a17ae 229{
230 struct bgp_debug_filter *filter;
231 struct listnode *node, *nnode;
81cf0de5 232 char buf[PREFIX2STR_BUFFER];
d62a17ae 233
234 vty_out(vty, "%s", desc);
235
236 if (list && !list_isempty(list)) {
237 vty_out(vty, " for");
238 for (ALL_LIST_ELEMENTS(list, node, nnode, filter)) {
239 if (filter->host)
240 vty_out(vty, " %s", filter->host);
241
29a643ca
QY		 242 if (filter->p && filter->p->family == AF_EVPN)
243 bgp_debug_print_evpn_prefix(vty, "", filter->p);
244 else if (filter->p) {
245 prefix2str(filter->p, buf, sizeof(buf));
246 vty_out(vty, " %s", buf);
81cf0de5 247 }
d62a17ae 248 }
249 }
250
251 vty_out(vty, "\n");
16286195
DS		 252}
253
29a643ca
QY		 254/*
255 * Print the command to enable the debug for each peer/prefix this debug is
91ba2c8b
DS		 256 * enabled for
257 */
d62a17ae 258static int bgp_debug_list_conf_print(struct vty *vty, const char *desc,
29a643ca 259 struct list *list)
d62a17ae 260{
261 struct bgp_debug_filter *filter;
262 struct listnode *node, *nnode;
81cf0de5 263 char buf[PREFIX2STR_BUFFER];
d62a17ae 264 int write = 0;
265
266 if (list && !list_isempty(list)) {
267 for (ALL_LIST_ELEMENTS(list, node, nnode, filter)) {
268 if (filter->host) {
269 vty_out(vty, "%s %s\n", desc, filter->host);
270 write++;
271 }
272
29a643ca
QY		 273 if (filter->p && filter->p->family == AF_EVPN) {
274 bgp_debug_print_evpn_prefix(vty, desc,
275 filter->p);
276 write++;
277 } else if (filter->p) {
278 prefix2str(filter->p, buf, sizeof(buf));
279 vty_out(vty, "%s %s\n", desc, buf);
280 write++;
d62a17ae 281 }
282 }
283 }
284
285 if (!write) {
286 vty_out(vty, "%s\n", desc);
287 write++;
288 }
289
290 return write;
91ba2c8b
DS		 291}
292
d62a17ae 293static void bgp_debug_list_add_entry(struct list *list, const char *host,
294 const struct prefix *p)
16286195 295{
d62a17ae 296 struct bgp_debug_filter *filter;
297
298 filter = XCALLOC(MTYPE_BGP_DEBUG_FILTER,
299 sizeof(struct bgp_debug_filter));
300
301 if (host) {
302 filter->host = XSTRDUP(MTYPE_BGP_DEBUG_STR, host);
303 filter->p = NULL;
304 } else if (p) {
305 filter->host = NULL;
306 filter->p = prefix_new();
307 prefix_copy(filter->p, p);
308 }
309
310 listnode_add(list, filter);
16286195
DS		 311}
312
d62a17ae 313static int bgp_debug_list_remove_entry(struct list *list, const char *host,
314 struct prefix *p)
315{
316 struct bgp_debug_filter *filter;
317 struct listnode *node, *nnode;
318
319 for (ALL_LIST_ELEMENTS(list, node, nnode, filter)) {
320 if (host && strcmp(filter->host, host) == 0) {
321 listnode_delete(list, filter);
322 XFREE(MTYPE_BGP_DEBUG_STR, filter->host);
323 XFREE(MTYPE_BGP_DEBUG_FILTER, filter);
324 return 1;
325 } else if (p && filter->p->prefixlen == p->prefixlen
326 && prefix_match(filter->p, p)) {
327 listnode_delete(list, filter);
63265b5c 328 prefix_free(&filter->p);
d62a17ae 329 XFREE(MTYPE_BGP_DEBUG_FILTER, filter);
330 return 1;
331 }
332 }
333
334 return 0;
16286195
DS		 335}
336
d62a17ae 337static int bgp_debug_list_has_entry(struct list *list, const char *host,
338 const struct prefix *p)
339{
340 struct bgp_debug_filter *filter;
341 struct listnode *node, *nnode;
342
343 for (ALL_LIST_ELEMENTS(list, node, nnode, filter)) {
344 if (host) {
345 if (strcmp(filter->host, host) == 0) {
346 return 1;
347 }
348 } else if (p) {
349 if (filter->p->prefixlen == p->prefixlen
350 && prefix_match(filter->p, p)) {
351 return 1;
352 }
353 }
354 }
355
356 return 0;
16286195
DS		 357}
358
d62a17ae 359int bgp_debug_peer_updout_enabled(char *host)
3f9c7369 360{
d62a17ae 361 return (bgp_debug_list_has_entry(bgp_debug_update_out_peers, host,
362 NULL));
3f9c7369
DS		 363}
364
718e3744 365/* Dump attribute. */
d62a17ae 366int bgp_dump_attr(struct attr *attr, char *buf, size_t size)
718e3744 367{
d62a17ae 368 char addrbuf[BUFSIZ];
718e3744 369
d62a17ae 370 if (!attr)
371 return 0;
372
8ba71050
NS		 373 buf[0] = '\0';
374
d62a17ae 375 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)))
376 snprintf(buf, size, "nexthop %s", inet_ntoa(attr->nexthop));
377
378 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN)))
379 snprintf(buf + strlen(buf), size - strlen(buf), ", origin %s",
380 bgp_origin_str[attr->origin]);
381
382 /* Add MP case. */
383 if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL
384 || attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
385 snprintf(buf + strlen(buf), size - strlen(buf),
386 ", mp_nexthop %s",
387 inet_ntop(AF_INET6, &attr->mp_nexthop_global, addrbuf,
388 BUFSIZ));
389
390 if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
391 snprintf(buf + strlen(buf), size - strlen(buf), "(%s)",
392 inet_ntop(AF_INET6, &attr->mp_nexthop_local, addrbuf,
393 BUFSIZ));
394
395 if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4)
396 snprintf(buf, size, "nexthop %s", inet_ntoa(attr->nexthop));
397
398 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
399 snprintf(buf + strlen(buf), size - strlen(buf),
400 ", localpref %u", attr->local_pref);
401
402 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
403 snprintf(buf + strlen(buf), size - strlen(buf), ", metric %u",
404 attr->med);
405
406 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)))
407 snprintf(buf + strlen(buf), size - strlen(buf),
a4d82a8a
PZ		 408 ", community %s",
409 community_str(attr->community, false));
d62a17ae 410
411 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
412 snprintf(buf + strlen(buf), size - strlen(buf),
413 ", extcommunity %s", ecommunity_str(attr->ecommunity));
414
415 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
416 snprintf(buf + strlen(buf), size - strlen(buf),
417 ", atomic-aggregate");
418
419 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
420 snprintf(buf + strlen(buf), size - strlen(buf),
421 ", aggregated by %u %s", attr->aggregator_as,
422 inet_ntoa(attr->aggregator_addr));
423
424 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))
425 snprintf(buf + strlen(buf), size - strlen(buf),
426 ", originator %s", inet_ntoa(attr->originator_id));
427
428 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST))) {
429 int i;
430
431 snprintf(buf + strlen(buf), size - strlen(buf),
432 ", clusterlist");
433 for (i = 0; i < attr->cluster->length / 4; i++)
434 snprintf(buf + strlen(buf), size - strlen(buf), " %s",
435 inet_ntoa(attr->cluster->list[i]));
436 }
437
7fd077aa 438 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL)))
052ea98b 439 snprintf(buf + strlen(buf), size - strlen(buf),
440 ", pmsi tnltype %u", attr->pmsi_tnl_type);
7fd077aa 441
d62a17ae 442 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH)))
443 snprintf(buf + strlen(buf), size - strlen(buf), ", path %s",
444 aspath_print(attr->aspath));
445
446 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID))) {
447 if (attr->label_index != BGP_INVALID_LABEL_INDEX)
448 snprintf(buf + strlen(buf), size - strlen(buf),
449 ", label-index %u", attr->label_index);
450 }
451
452 if (strlen(buf) > 1)
453 return 1;
454 else
455 return 0;
3a8c7ba1 456}
718e3744 457
d62a17ae 458const char *bgp_notify_code_str(char code)
3a8c7ba1 459{
d62a17ae 460 return lookup_msg(bgp_notify_msg, code, "Unrecognized Error Code");
461}
718e3744 462
d62a17ae 463const char *bgp_notify_subcode_str(char code, char subcode)
464{
465
466 switch (code) {
467 case BGP_NOTIFY_HEADER_ERR:
468 return lookup_msg(bgp_notify_head_msg, subcode,
469 "Unrecognized Error Subcode");
470 case BGP_NOTIFY_OPEN_ERR:
471 return lookup_msg(bgp_notify_open_msg, subcode,
472 "Unrecognized Error Subcode");
473 case BGP_NOTIFY_UPDATE_ERR:
474 return lookup_msg(bgp_notify_update_msg, subcode,
475 "Unrecognized Error Subcode");
476 case BGP_NOTIFY_HOLD_ERR:
477 break;
478 case BGP_NOTIFY_FSM_ERR:
479 break;
480 case BGP_NOTIFY_CEASE:
481 return lookup_msg(bgp_notify_cease_msg, subcode,
482 "Unrecognized Error Subcode");
483 case BGP_NOTIFY_CAPABILITY_ERR:
484 return lookup_msg(bgp_notify_capability_msg, subcode,
485 "Unrecognized Error Subcode");
486 }
487 return "";
3a8c7ba1
DW		 488}
489
38de8d02 490/* extract notify admin reason if correctly present */
d7c0a89a 491const char *bgp_notify_admin_message(char *buf, size_t bufsz, uint8_t *data,
d62a17ae 492 size_t datalen)
38de8d02 493{
d62a17ae 494 if (!data || datalen < 1)
495 return NULL;
38de8d02 496
d7c0a89a 497 uint8_t len = data[0];
d62a17ae 498 if (len > 128 || len > datalen - 1)
499 return NULL;
38de8d02 500
d62a17ae 501 return zlog_sanitize(buf, bufsz, data + 1, len);
38de8d02
DL		 502}
503
3a8c7ba1 504/* dump notify packet */
d62a17ae 505void bgp_notify_print(struct peer *peer, struct bgp_notify *bgp_notify,
506 const char *direct)
507{
508 const char *subcode_str;
509 const char *code_str;
510 const char *msg_str = NULL;
511 char msg_buf[1024];
512
513 if (BGP_DEBUG(neighbor_events, NEIGHBOR_EVENTS)
514 || bgp_flag_check(peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES)) {
515 code_str = bgp_notify_code_str(bgp_notify->code);
516 subcode_str = bgp_notify_subcode_str(bgp_notify->code,
517 bgp_notify->subcode);
518
519 if (bgp_notify->code == BGP_NOTIFY_CEASE
520 && (bgp_notify->subcode == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
521 || bgp_notify->subcode
522 == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
523 msg_str = bgp_notify_admin_message(
524 msg_buf, sizeof(msg_buf), bgp_notify->raw_data,
525 bgp_notify->length);
526 }
527
528 if (msg_str) {
529 zlog_info(
530 "%%NOTIFICATION: %s neighbor %s %d/%d (%s%s) \"%s\"",
531 strcmp(direct, "received") == 0
532 ? "received from"
533 : "sent to",
534 peer->host, bgp_notify->code,
535 bgp_notify->subcode, code_str, subcode_str,
536 msg_str);
537 } else {
538 msg_str = bgp_notify->data ? bgp_notify->data : "";
539 zlog_info(
540 "%%NOTIFICATION: %s neighbor %s %d/%d (%s%s) %d bytes %s",
541 strcmp(direct, "received") == 0
542 ? "received from"
543 : "sent to",
544 peer->host, bgp_notify->code,
545 bgp_notify->subcode, code_str, subcode_str,
546 bgp_notify->length, msg_str);
547 }
548 }
718e3744 549}
6b0655a2 550
d62a17ae 551static void bgp_debug_clear_updgrp_update_dbg(struct bgp *bgp)
3f9c7369 552{
d62a17ae 553 if (!bgp)
554 bgp = bgp_get_default();
555 update_group_walk(bgp, update_group_clear_update_dbg, NULL);
3f9c7369
DS		 556}
557
81cf0de5
CS		 558static int bgp_debug_print_evpn_prefix(struct vty *vty, const char *desc,
559 struct prefix *p)
560{
561 char evpn_desc[PREFIX2STR_BUFFER + INET_ADDRSTRLEN];
562 char buf[PREFIX2STR_BUFFER];
563 char buf2[ETHER_ADDR_STRLEN];
564
565 if (p->u.prefix_evpn.route_type == BGP_EVPN_MAC_IP_ROUTE) {
566 if (is_evpn_prefix_ipaddr_none((struct prefix_evpn *)p)) {
567 sprintf(evpn_desc, "l2vpn evpn type macip mac %s",
568 prefix_mac2str(
569 &p->u.prefix_evpn.macip_addr.mac,
570 buf2, sizeof(buf2)));
571 } else {
572 uint8_t family = is_evpn_prefix_ipaddr_v4(
573 (struct prefix_evpn *)p) ?
574 AF_INET : AF_INET6;
575 sprintf(evpn_desc, "l2vpn evpn type macip mac %s ip %s",
576 prefix_mac2str(
577 &p->u.prefix_evpn.macip_addr.mac,
578 buf2, sizeof(buf2)),
579 inet_ntop(family,
580 &p->u.prefix_evpn.macip_addr.ip.ip.addr,
581 buf, PREFIX2STR_BUFFER));
582 }
583 } else if (p->u.prefix_evpn.route_type == BGP_EVPN_IMET_ROUTE) {
584 sprintf(evpn_desc, "l2vpn evpn type multicast ip %s",
585 inet_ntoa(p->u.prefix_evpn.imet_addr.ip.ipaddr_v4));
586 } else if (p->u.prefix_evpn.route_type == BGP_EVPN_IP_PREFIX_ROUTE) {
587 uint8_t family = is_evpn_prefix_ipaddr_v4(
588 (struct prefix_evpn *)p) ? AF_INET
589 : AF_INET6;
590 sprintf(evpn_desc, "l2vpn evpn type prefix ip %s/%d",
591 inet_ntop(family,
592 &p->u.prefix_evpn.prefix_addr.ip.ip.addr, buf,
593 PREFIX2STR_BUFFER),
594 p->u.prefix_evpn.prefix_addr.ip_prefix_length);
595 }
596
597 vty_out(vty, "%s %s\n", desc, evpn_desc);
598
599 return 0;
600}
601
602static int bgp_debug_parse_evpn_prefix(struct vty *vty, struct cmd_token **argv,
603 int argc, struct prefix **argv_pp)
604{
605 struct prefix *argv_p;
606 struct ethaddr mac;
607 struct ipaddr ip;
608 int evpn_type;
609 int type_idx = 0;
610 int mac_idx = 0;
611 int ip_idx = 0;
612
613 argv_p = *argv_pp;
614
377e3565 615 if (argv_find(argv, argc, "macip", &type_idx))
81cf0de5 616 evpn_type = BGP_EVPN_MAC_IP_ROUTE;
377e3565 617 else if (argv_find(argv, argc, "multicast", &type_idx))
81cf0de5 618 evpn_type = BGP_EVPN_IMET_ROUTE;
377e3565 619 else if (argv_find(argv, argc, "prefix", &type_idx))
81cf0de5
CS		 620 evpn_type = BGP_EVPN_IP_PREFIX_ROUTE;
621 else
622 evpn_type = 0;
623
624 if (evpn_type == BGP_EVPN_MAC_IP_ROUTE) {
625 memset(&ip, 0, sizeof(struct ipaddr));
377e3565 626
81cf0de5 627 argv_find(argv, argc, "mac", &mac_idx);
4d840569 628 (void)prefix_str2mac(argv[mac_idx + 1]->arg, &mac);
377e3565
QY		 629
630 argv_find(argv, argc, "ip", &ip_idx);
631 str2ipaddr(argv[ip_idx + 1]->arg, &ip);
81cf0de5
CS		 632
633 build_evpn_type2_prefix((struct prefix_evpn *)argv_p,
634 &mac, &ip);
635 } else if (evpn_type == BGP_EVPN_IMET_ROUTE) {
636 memset(&ip, 0, sizeof(struct ipaddr));
377e3565
QY		 637
638 argv_find(argv, argc, "ip", &ip_idx);
639 str2ipaddr(argv[ip_idx + 1]->arg, &ip);
640
81cf0de5
CS		 641 build_evpn_type3_prefix((struct prefix_evpn *)argv_p,
642 ip.ipaddr_v4);
643 } else if (evpn_type == BGP_EVPN_IP_PREFIX_ROUTE) {
644 struct prefix ip_prefix;
645
646 memset(&ip_prefix, 0, sizeof(struct prefix));
647 if (argv_find(argv, argc, "ip", &ip_idx)) {
648 (void)str2prefix(argv[ip_idx + 1]->arg, &ip_prefix);
649 apply_mask(&ip_prefix);
650 }
651 build_type5_prefix_from_ip_prefix(
652 (struct prefix_evpn *)argv_p,
653 &ip_prefix);
654 }
655
656 return CMD_SUCCESS;
657}
3f9c7369 658
718e3744 659/* Debug option setting interface. */
660unsigned long bgp_debug_option = 0;
661
d62a17ae 662int debug(unsigned int option)
718e3744 663{
d62a17ae 664 return bgp_debug_option & option;
718e3744 665}
666
0b2aa3a0
PJ		 667DEFUN (debug_bgp_as4,
668 debug_bgp_as4_cmd,
669 "debug bgp as4",
670 DEBUG_STR
671 BGP_STR
672 "BGP AS4 actions\n")
673{
d62a17ae 674 if (vty->node == CONFIG_NODE)
675 DEBUG_ON(as4, AS4);
676 else {
677 TERM_DEBUG_ON(as4, AS4);
678 vty_out(vty, "BGP as4 debugging is on\n");
679 }
680 return CMD_SUCCESS;
0b2aa3a0
PJ		 681}
682
683DEFUN (no_debug_bgp_as4,
684 no_debug_bgp_as4_cmd,
685 "no debug bgp as4",
686 NO_STR
687 DEBUG_STR
688 BGP_STR
689 "BGP AS4 actions\n")
690{
d62a17ae 691 if (vty->node == CONFIG_NODE)
692 DEBUG_OFF(as4, AS4);
693 else {
694 TERM_DEBUG_OFF(as4, AS4);
695 vty_out(vty, "BGP as4 debugging is off\n");
696 }
697 return CMD_SUCCESS;
0b2aa3a0
PJ		 698}
699
0b2aa3a0
PJ		 700DEFUN (debug_bgp_as4_segment,
701 debug_bgp_as4_segment_cmd,
702 "debug bgp as4 segment",
703 DEBUG_STR
704 BGP_STR
6e22b901 705 "BGP AS4 actions\n"
0b2aa3a0
PJ		 706 "BGP AS4 aspath segment handling\n")
707{
d62a17ae 708 if (vty->node == CONFIG_NODE)
709 DEBUG_ON(as4, AS4_SEGMENT);
710 else {
711 TERM_DEBUG_ON(as4, AS4_SEGMENT);
712 vty_out(vty, "BGP as4 segment debugging is on\n");
713 }
714 return CMD_SUCCESS;
0b2aa3a0
PJ		 715}
716
717DEFUN (no_debug_bgp_as4_segment,
718 no_debug_bgp_as4_segment_cmd,
719 "no debug bgp as4 segment",
720 NO_STR
721 DEBUG_STR
722 BGP_STR
6e22b901 723 "BGP AS4 actions\n"
0b2aa3a0
PJ		 724 "BGP AS4 aspath segment handling\n")
725{
d62a17ae 726 if (vty->node == CONFIG_NODE)
727 DEBUG_OFF(as4, AS4_SEGMENT);
728 else {
729 TERM_DEBUG_OFF(as4, AS4_SEGMENT);
730 vty_out(vty, "BGP as4 segment debugging is off\n");
731 }
732 return CMD_SUCCESS;
0b2aa3a0
PJ		 733}
734
16286195
DS		 735/* debug bgp neighbor_events */
736DEFUN (debug_bgp_neighbor_events,
737 debug_bgp_neighbor_events_cmd,
738 "debug bgp neighbor-events",
718e3744 739 DEBUG_STR
740 BGP_STR
16286195 741 "BGP Neighbor Events\n")
718e3744 742{
d62a17ae 743 bgp_debug_list_free(bgp_debug_neighbor_events_peers);
744
745 if (vty->node == CONFIG_NODE)
746 DEBUG_ON(neighbor_events, NEIGHBOR_EVENTS);
747 else {
748 TERM_DEBUG_ON(neighbor_events, NEIGHBOR_EVENTS);
749 vty_out(vty, "BGP neighbor-events debugging is on\n");
750 }
751 return CMD_SUCCESS;
718e3744 752}
753
16286195
DS		 754DEFUN (debug_bgp_neighbor_events_peer,
755 debug_bgp_neighbor_events_peer_cmd,
6147e2c6 756 "debug bgp neighbor-events <A.B.C.D|X:X::X:X|WORD>",
718e3744 757 DEBUG_STR
758 BGP_STR
16286195
DS		 759 "BGP Neighbor Events\n"
760 "BGP neighbor IP address to debug\n"
761 "BGP IPv6 neighbor to debug\n"
762 "BGP neighbor on interface to debug\n")
718e3744 763{
d62a17ae 764 int idx_peer = 3;
765 const char *host = argv[idx_peer]->arg;
766
767 if (!bgp_debug_neighbor_events_peers)
768 bgp_debug_neighbor_events_peers = list_new();
769
770 if (bgp_debug_list_has_entry(bgp_debug_neighbor_events_peers, host,
771 NULL)) {
772 vty_out(vty,
773 "BGP neighbor-events debugging is already enabled for %s\n",
774 host);
775 return CMD_SUCCESS;
776 }
777
778 bgp_debug_list_add_entry(bgp_debug_neighbor_events_peers, host, NULL);
779
780 if (vty->node == CONFIG_NODE)
781 DEBUG_ON(neighbor_events, NEIGHBOR_EVENTS);
782 else {
783 TERM_DEBUG_ON(neighbor_events, NEIGHBOR_EVENTS);
784 vty_out(vty, "BGP neighbor-events debugging is on for %s\n",
785 host);
786 }
787 return CMD_SUCCESS;
718e3744 788}
789
16286195
DS		 790DEFUN (no_debug_bgp_neighbor_events,
791 no_debug_bgp_neighbor_events_cmd,
792 "no debug bgp neighbor-events",
793 NO_STR
718e3744 794 DEBUG_STR
795 BGP_STR
16286195 796 "Neighbor Events\n")
718e3744 797{
d62a17ae 798 bgp_debug_list_free(bgp_debug_neighbor_events_peers);
799
800 if (vty->node == CONFIG_NODE)
801 DEBUG_OFF(neighbor_events, NEIGHBOR_EVENTS);
802 else {
803 TERM_DEBUG_OFF(neighbor_events, NEIGHBOR_EVENTS);
804 vty_out(vty, "BGP neighbor-events debugging is off\n");
805 }
806 return CMD_SUCCESS;
718e3744 807}
808
16286195
DS		 809DEFUN (no_debug_bgp_neighbor_events_peer,
810 no_debug_bgp_neighbor_events_peer_cmd,
6147e2c6 811 "no debug bgp neighbor-events <A.B.C.D|X:X::X:X|WORD>",
718e3744 812 NO_STR
813 DEBUG_STR
814 BGP_STR
16286195
DS		 815 "Neighbor Events\n"
816 "BGP neighbor IP address to debug\n"
817 "BGP IPv6 neighbor to debug\n"
818 "BGP neighbor on interface to debug\n")
718e3744 819{
d62a17ae 820 int idx_peer = 4;
821 int found_peer = 0;
822 const char *host = argv[idx_peer]->arg;
823
824 if (bgp_debug_neighbor_events_peers
825 && !list_isempty(bgp_debug_neighbor_events_peers)) {
826 found_peer = bgp_debug_list_remove_entry(
827 bgp_debug_neighbor_events_peers, host, NULL);
828
829 if (list_isempty(bgp_debug_neighbor_events_peers)) {
830 if (vty->node == CONFIG_NODE)
831 DEBUG_OFF(neighbor_events, NEIGHBOR_EVENTS);
832 else
833 TERM_DEBUG_OFF(neighbor_events,
834 NEIGHBOR_EVENTS);
835 }
836 }
837
838 if (found_peer)
839 vty_out(vty, "BGP neighbor-events debugging is off for %s\n",
840 host);
841 else
842 vty_out(vty,
843 "BGP neighbor-events debugging was not enabled for %s\n",
844 host);
845
846 return CMD_SUCCESS;
718e3744 847}
848
16286195 849/* debug bgp nht */
fb018d25
DS		 850DEFUN (debug_bgp_nht,
851 debug_bgp_nht_cmd,
852 "debug bgp nht",
853 DEBUG_STR
854 BGP_STR
855 "BGP nexthop tracking events\n")
856{
d62a17ae 857 if (vty->node == CONFIG_NODE)
858 DEBUG_ON(nht, NHT);
859 else {
860 TERM_DEBUG_ON(nht, NHT);
861 vty_out(vty, "BGP nexthop tracking debugging is on\n");
862 }
863 return CMD_SUCCESS;
fb018d25
DS		 864}
865
866DEFUN (no_debug_bgp_nht,
867 no_debug_bgp_nht_cmd,
868 "no debug bgp nht",
869 NO_STR
870 DEBUG_STR
871 BGP_STR
872 "BGP nexthop tracking events\n")
873{
d62a17ae 874 if (vty->node == CONFIG_NODE)
875 DEBUG_OFF(nht, NHT);
876 else {
877 TERM_DEBUG_OFF(nht, NHT);
878 vty_out(vty, "BGP nexthop tracking debugging is off\n");
879 }
880 return CMD_SUCCESS;
fb018d25
DS		 881}
882
16286195
DS		 883/* debug bgp keepalives */
884DEFUN (debug_bgp_keepalive,
885 debug_bgp_keepalive_cmd,
886 "debug bgp keepalives",
718e3744 887 DEBUG_STR
888 BGP_STR
16286195 889 "BGP keepalives\n")
718e3744 890{
d62a17ae 891 bgp_debug_list_free(bgp_debug_keepalive_peers);
892
893 if (vty->node == CONFIG_NODE)
894 DEBUG_ON(keepalive, KEEPALIVE);
895 else {
896 TERM_DEBUG_ON(keepalive, KEEPALIVE);
897 vty_out(vty, "BGP keepalives debugging is on\n");
898 }
899 return CMD_SUCCESS;
718e3744 900}
901
16286195
DS		 902DEFUN (debug_bgp_keepalive_peer,
903 debug_bgp_keepalive_peer_cmd,
6147e2c6 904 "debug bgp keepalives <A.B.C.D|X:X::X:X|WORD>",
718e3744 905 DEBUG_STR
906 BGP_STR
16286195
DS		 907 "BGP Neighbor Events\n"
908 "BGP neighbor IP address to debug\n"
909 "BGP IPv6 neighbor to debug\n"
910 "BGP neighbor on interface to debug\n")
718e3744 911{
d62a17ae 912 int idx_peer = 3;
913 const char *host = argv[idx_peer]->arg;
914
915 if (!bgp_debug_keepalive_peers)
916 bgp_debug_keepalive_peers = list_new();
917
918 if (bgp_debug_list_has_entry(bgp_debug_keepalive_peers, host, NULL)) {
919 vty_out(vty,
920 "BGP keepalive debugging is already enabled for %s\n",
921 host);
922 return CMD_SUCCESS;
923 }
924
925 bgp_debug_list_add_entry(bgp_debug_keepalive_peers, host, NULL);
926
927 if (vty->node == CONFIG_NODE)
928 DEBUG_ON(keepalive, KEEPALIVE);
929 else {
930 TERM_DEBUG_ON(keepalive, KEEPALIVE);
931 vty_out(vty, "BGP keepalives debugging is on for %s\n", host);
932 }
933 return CMD_SUCCESS;
718e3744 934}
935
936DEFUN (no_debug_bgp_keepalive,
937 no_debug_bgp_keepalive_cmd,
938 "no debug bgp keepalives",
939 NO_STR
940 DEBUG_STR
941 BGP_STR
942 "BGP keepalives\n")
943{
d62a17ae 944 bgp_debug_list_free(bgp_debug_keepalive_peers);
945
946 if (vty->node == CONFIG_NODE)
947 DEBUG_OFF(keepalive, KEEPALIVE);
948 else {
949 TERM_DEBUG_OFF(keepalive, KEEPALIVE);
950 vty_out(vty, "BGP keepalives debugging is off\n");
951 }
952 return CMD_SUCCESS;
718e3744 953}
954
16286195
DS		 955DEFUN (no_debug_bgp_keepalive_peer,
956 no_debug_bgp_keepalive_peer_cmd,
6147e2c6 957 "no debug bgp keepalives <A.B.C.D|X:X::X:X|WORD>",
16286195
DS		 958 NO_STR
959 DEBUG_STR
718e3744 960 BGP_STR
16286195
DS		 961 "BGP keepalives\n"
962 "BGP neighbor IP address to debug\n"
963 "BGP IPv6 neighbor to debug\n"
964 "BGP neighbor on interface to debug\n")
965{
d62a17ae 966 int idx_peer = 4;
967 int found_peer = 0;
968 const char *host = argv[idx_peer]->arg;
969
970 if (bgp_debug_keepalive_peers
971 && !list_isempty(bgp_debug_keepalive_peers)) {
972 found_peer = bgp_debug_list_remove_entry(
973 bgp_debug_keepalive_peers, host, NULL);
974
975 if (list_isempty(bgp_debug_keepalive_peers)) {
976 if (vty->node == CONFIG_NODE)
977 DEBUG_OFF(keepalive, KEEPALIVE);
978 else
979 TERM_DEBUG_OFF(keepalive, KEEPALIVE);
980 }
981 }
982
983 if (found_peer)
984 vty_out(vty, "BGP keepalives debugging is off for %s\n", host);
985 else
986 vty_out(vty,
987 "BGP keepalives debugging was not enabled for %s\n",
988 host);
989
990 return CMD_SUCCESS;
16286195
DS		 991}
992
9fbdd100 993/* debug bgp bestpath */
ffd71765 994DEFUN (debug_bgp_bestpath_prefix,
9fbdd100 995 debug_bgp_bestpath_prefix_cmd,
ffd71765 996 "debug bgp bestpath <A.B.C.D/M|X:X::X:X/M>",
9fbdd100
DS		 997 DEBUG_STR
998 BGP_STR
999 "BGP bestpath\n"
0c7b1b01
QY		 1000 "IPv4 prefix\n"
1001 "IPv6 prefix\n")
9fbdd100 1002{
0be4b77c
DW		 1003 struct prefix *argv_p;
1004 int idx_ipv4_ipv6_prefixlen = 3;
1005
1006 argv_p = prefix_new();
ffd71765 1007 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c
DW		 1008 apply_mask(argv_p);
1009
d62a17ae 1010 if (!bgp_debug_bestpath_prefixes)
1011 bgp_debug_bestpath_prefixes = list_new();
1012
1013 if (bgp_debug_list_has_entry(bgp_debug_bestpath_prefixes, NULL,
ffd71765 1014 argv_p)) {
d62a17ae 1015 vty_out(vty,
1016 "BGP bestpath debugging is already enabled for %s\n",
ffd71765 1017 argv[idx_ipv4_ipv6_prefixlen]->arg);
d62a17ae 1018 return CMD_SUCCESS;
1019 }
1020
ffd71765 1021 bgp_debug_list_add_entry(bgp_debug_bestpath_prefixes, NULL, argv_p);
d62a17ae 1022
1023 if (vty->node == CONFIG_NODE) {
1024 DEBUG_ON(bestpath, BESTPATH);
1025 } else {
1026 TERM_DEBUG_ON(bestpath, BESTPATH);
1027 vty_out(vty, "BGP bestpath debugging is on for %s\n",
ffd71765 1028 argv[idx_ipv4_ipv6_prefixlen]->arg);
d62a17ae 1029 }
1030
1031 return CMD_SUCCESS;
9fbdd100
DS		 1032}
1033
1034DEFUN (no_debug_bgp_bestpath_prefix,
1035 no_debug_bgp_bestpath_prefix_cmd,
6147e2c6 1036 "no debug bgp bestpath <A.B.C.D/M|X:X::X:X/M>",
9fbdd100
DS		 1037 NO_STR
1038 DEBUG_STR
1039 BGP_STR
1040 "BGP bestpath\n"
0c7b1b01
QY		 1041 "IPv4 prefix\n"
1042 "IPv6 prefix\n")
9fbdd100 1043{
d62a17ae 1044 int idx_ipv4_ipv6_prefixlen = 4;
1045 struct prefix *argv_p;
1046 int found_prefix = 0;
d62a17ae 1047
1048 argv_p = prefix_new();
ffd71765 1049 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c 1050 apply_mask(argv_p);
d62a17ae 1051
1052 if (bgp_debug_bestpath_prefixes
1053 && !list_isempty(bgp_debug_bestpath_prefixes)) {
1054 found_prefix = bgp_debug_list_remove_entry(
1055 bgp_debug_bestpath_prefixes, NULL, argv_p);
1056
1057 if (list_isempty(bgp_debug_bestpath_prefixes)) {
1058 if (vty->node == CONFIG_NODE) {
1059 DEBUG_OFF(bestpath, BESTPATH);
1060 } else {
1061 TERM_DEBUG_OFF(bestpath, BESTPATH);
1062 vty_out(vty,
1063 "BGP bestpath debugging (per prefix) is off\n");
1064 }
1065 }
1066 }
1067
1068 if (found_prefix)
1069 vty_out(vty, "BGP bestpath debugging is off for %s\n",
1070 argv[idx_ipv4_ipv6_prefixlen]->arg);
1071 else
1072 vty_out(vty, "BGP bestpath debugging was not enabled for %s\n",
1073 argv[idx_ipv4_ipv6_prefixlen]->arg);
1074
1075 return CMD_SUCCESS;
9fbdd100
DS		 1076}
1077
1078DEFUN (no_debug_bgp_bestpath,
1079 no_debug_bgp_bestpath_cmd,
1080 "no debug bgp bestpath",
1081 NO_STR
1082 DEBUG_STR
1083 BGP_STR
1084 "BGP bestpath\n")
1085{
d62a17ae 1086 bgp_debug_list_free(bgp_debug_bestpath_prefixes);
1087
1088 if (vty->node == CONFIG_NODE)
1089 DEBUG_OFF(bestpath, BESTPATH);
1090 else {
1091 TERM_DEBUG_OFF(bestpath, BESTPATH);
1092 vty_out(vty, "BGP bestpath debugging is off\n");
1093 }
1094 return CMD_SUCCESS;
9fbdd100
DS		 1095}
1096
16286195 1097/* debug bgp updates */
718e3744 1098DEFUN (debug_bgp_update,
1099 debug_bgp_update_cmd,
1100 "debug bgp updates",
1101 DEBUG_STR
1102 BGP_STR
1103 "BGP updates\n")
1104{
d62a17ae 1105 bgp_debug_list_free(bgp_debug_update_in_peers);
1106 bgp_debug_list_free(bgp_debug_update_out_peers);
1107 bgp_debug_list_free(bgp_debug_update_prefixes);
1108
1109 if (vty->node == CONFIG_NODE) {
1110 DEBUG_ON(update, UPDATE_IN);
1111 DEBUG_ON(update, UPDATE_OUT);
1112 } else {
1113 TERM_DEBUG_ON(update, UPDATE_IN);
1114 TERM_DEBUG_ON(update, UPDATE_OUT);
1115 vty_out(vty, "BGP updates debugging is on\n");
1116 }
1117 return CMD_SUCCESS;
718e3744 1118}
1119
1120DEFUN (debug_bgp_update_direct,
1121 debug_bgp_update_direct_cmd,
6147e2c6 1122 "debug bgp updates <in|out>",
718e3744 1123 DEBUG_STR
1124 BGP_STR
1125 "BGP updates\n"
1126 "Inbound updates\n"
1127 "Outbound updates\n")
1128{
d62a17ae 1129 int idx_in_out = 3;
1130
1131 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0)
1132 bgp_debug_list_free(bgp_debug_update_in_peers);
1133 else
1134 bgp_debug_list_free(bgp_debug_update_out_peers);
1135
1136 if (vty->node == CONFIG_NODE) {
1137 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0)
1138 DEBUG_ON(update, UPDATE_IN);
1139 else
1140 DEBUG_ON(update, UPDATE_OUT);
1141 } else {
1142 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0) {
1143 TERM_DEBUG_ON(update, UPDATE_IN);
1144 vty_out(vty, "BGP updates debugging is on (inbound)\n");
1145 } else {
1146 TERM_DEBUG_ON(update, UPDATE_OUT);
1147 vty_out(vty,
1148 "BGP updates debugging is on (outbound)\n");
1149 }
1150 }
1151 return CMD_SUCCESS;
718e3744 1152}
1153
16286195
DS		 1154DEFUN (debug_bgp_update_direct_peer,
1155 debug_bgp_update_direct_peer_cmd,
6147e2c6 1156 "debug bgp updates <in|out> <A.B.C.D|X:X::X:X|WORD>",
718e3744 1157 DEBUG_STR
1158 BGP_STR
16286195
DS		 1159 "BGP updates\n"
1160 "Inbound updates\n"
1161 "Outbound updates\n"
1162 "BGP neighbor IP address to debug\n"
1163 "BGP IPv6 neighbor to debug\n"
1164 "BGP neighbor on interface to debug\n")
718e3744 1165{
d62a17ae 1166 int idx_in_out = 3;
1167 int idx_peer = 4;
1168 const char *host = argv[idx_peer]->arg;
1169 int inbound;
1170
1171 if (!bgp_debug_update_in_peers)
1172 bgp_debug_update_in_peers = list_new();
1173
1174 if (!bgp_debug_update_out_peers)
1175 bgp_debug_update_out_peers = list_new();
1176
1177 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0)
1178 inbound = 1;
1179 else
1180 inbound = 0;
1181
1182 if (inbound) {
1183 if (bgp_debug_list_has_entry(bgp_debug_update_in_peers, host,
1184 NULL)) {
1185 vty_out(vty,
1186 "BGP inbound update debugging is already enabled for %s\n",
1187 host);
1188 return CMD_SUCCESS;
1189 }
1190 }
1191
1192 else {
1193 if (bgp_debug_list_has_entry(bgp_debug_update_out_peers, host,
1194 NULL)) {
1195 vty_out(vty,
1196 "BGP outbound update debugging is already enabled for %s\n",
1197 host);
1198 return CMD_SUCCESS;
1199 }
1200 }
1201
1202 if (inbound)
1203 bgp_debug_list_add_entry(bgp_debug_update_in_peers, host, NULL);
1204 else {
1205 struct peer *peer;
1206 struct peer_af *paf;
1207 int afidx;
1208
1209 bgp_debug_list_add_entry(bgp_debug_update_out_peers, host,
1210 NULL);
1211 peer = bgp_find_peer(vty, host);
1212
1213 if (peer) {
1214 for (afidx = BGP_AF_START; afidx < BGP_AF_MAX;
1215 afidx++) {
1216 paf = peer->peer_af_array[afidx];
1217 if (paf != NULL) {
1218 if (PAF_SUBGRP(paf)) {
1219 UPDGRP_PEER_DBG_EN(
1220 PAF_SUBGRP(paf)
1221 ->update_group);
1222 }
1223 }
1224 }
1225 }
1226 }
1227
1228 if (vty->node == CONFIG_NODE) {
1229 if (inbound)
1230 DEBUG_ON(update, UPDATE_IN);
1231 else
1232 DEBUG_ON(update, UPDATE_OUT);
1233 } else {
1234 if (inbound) {
1235 TERM_DEBUG_ON(update, UPDATE_IN);
1236 vty_out(vty,
1237 "BGP updates debugging is on (inbound) for %s\n",
1238 argv[idx_peer]->arg);
1239 } else {
1240 TERM_DEBUG_ON(update, UPDATE_OUT);
1241 vty_out(vty,
1242 "BGP updates debugging is on (outbound) for %s\n",
1243 argv[idx_peer]->arg);
1244 }
1245 }
1246 return CMD_SUCCESS;
718e3744 1247}
1248
91ba2c8b
DS		 1249DEFUN (no_debug_bgp_update_direct,
1250 no_debug_bgp_update_direct_cmd,
6147e2c6 1251 "no debug bgp updates <in|out>",
91ba2c8b
DS		 1252 NO_STR
1253 DEBUG_STR
1254 BGP_STR
1255 "BGP updates\n"
1256 "Inbound updates\n"
1257 "Outbound updates\n")
1258{
d62a17ae 1259 int idx_in_out = 4;
1260 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0) {
1261 bgp_debug_list_free(bgp_debug_update_in_peers);
1262
1263 if (vty->node == CONFIG_NODE) {
1264 DEBUG_OFF(update, UPDATE_IN);
1265 } else {
1266 TERM_DEBUG_OFF(update, UPDATE_IN);
1267 vty_out(vty,
1268 "BGP updates debugging is off (inbound)\n");
1269 }
1270 } else {
1271 bgp_debug_list_free(bgp_debug_update_out_peers);
1272
1273 if (vty->node == CONFIG_NODE) {
1274 DEBUG_OFF(update, UPDATE_OUT);
1275 } else {
1276 TERM_DEBUG_OFF(update, UPDATE_OUT);
1277 vty_out(vty,
1278 "BGP updates debugging is off (outbound)\n");
1279 }
1280 }
1281
1282 return CMD_SUCCESS;
91ba2c8b
DS		 1283}
1284
16286195
DS		 1285DEFUN (no_debug_bgp_update_direct_peer,
1286 no_debug_bgp_update_direct_peer_cmd,
6147e2c6 1287 "no debug bgp updates <in|out> <A.B.C.D|X:X::X:X|WORD>",
16286195
DS		 1288 NO_STR
1289 DEBUG_STR
718e3744 1290 BGP_STR
16286195
DS		 1291 "BGP updates\n"
1292 "Inbound updates\n"
1293 "Outbound updates\n"
1294 "BGP neighbor IP address to debug\n"
1295 "BGP IPv6 neighbor to debug\n"
1296 "BGP neighbor on interface to debug\n")
1297{
d62a17ae 1298 int idx_in_out = 4;
1299 int idx_peer = 5;
1300 int inbound;
1301 int found_peer = 0;
1302 const char *host = argv[idx_peer]->arg;
1303
1304 if (strncmp("i", argv[idx_in_out]->arg, 1) == 0)
1305 inbound = 1;
1306 else
1307 inbound = 0;
1308
1309 if (inbound && bgp_debug_update_in_peers
1310 && !list_isempty(bgp_debug_update_in_peers)) {
1311 found_peer = bgp_debug_list_remove_entry(
1312 bgp_debug_update_in_peers, host, NULL);
1313
1314 if (list_isempty(bgp_debug_update_in_peers)) {
1315 if (vty->node == CONFIG_NODE)
1316 DEBUG_OFF(update, UPDATE_IN);
1317 else {
1318 TERM_DEBUG_OFF(update, UPDATE_IN);
1319 vty_out(vty,
1320 "BGP updates debugging (inbound) is off\n");
1321 }
1322 }
1323 }
1324
1325 if (!inbound && bgp_debug_update_out_peers
1326 && !list_isempty(bgp_debug_update_out_peers)) {
1327 found_peer = bgp_debug_list_remove_entry(
1328 bgp_debug_update_out_peers, host, NULL);
1329
1330 if (list_isempty(bgp_debug_update_out_peers)) {
1331 if (vty->node == CONFIG_NODE)
1332 DEBUG_OFF(update, UPDATE_OUT);
1333 else {
1334 TERM_DEBUG_OFF(update, UPDATE_OUT);
1335 vty_out(vty,
1336 "BGP updates debugging (outbound) is off\n");
1337 }
1338 }
1339
1340 struct peer *peer;
1341 struct peer_af *paf;
1342 int afidx;
1343 peer = bgp_find_peer(vty, host);
1344
1345 if (peer) {
1346 for (afidx = BGP_AF_START; afidx < BGP_AF_MAX;
1347 afidx++) {
1348 paf = peer->peer_af_array[afidx];
1349 if (paf != NULL) {
1350 if (PAF_SUBGRP(paf)) {
1351 UPDGRP_PEER_DBG_DIS(
1352 PAF_SUBGRP(paf)
1353 ->update_group);
1354 }
1355 }
1356 }
1357 }
1358 }
1359
1360 if (found_peer)
1361 if (inbound)
1362 vty_out(vty,
1363 "BGP updates debugging (inbound) is off for %s\n",
1364 host);
1365 else
1366 vty_out(vty,
1367 "BGP updates debugging (outbound) is off for %s\n",
1368 host);
1369 else if (inbound)
1370 vty_out(vty,
1371 "BGP updates debugging (inbound) was not enabled for %s\n",
1372 host);
1373 else
1374 vty_out(vty,
1375 "BGP updates debugging (outbound) was not enabled for %s\n",
1376 host);
1377
1378 return CMD_SUCCESS;
16286195
DS		 1379}
1380
81cf0de5
CS		 1381#ifndef VTYSH_EXTRACT_PL
1382#include "bgpd/bgp_debug_clippy.c"
1383#endif
1384
1385DEFPY (debug_bgp_update_prefix_afi_safi,
1386 debug_bgp_update_prefix_afi_safi_cmd,
6163c6cc 1387 "debug bgp updates prefix l2vpn$afi evpn$safi type <macip mac <X:X:X:X:X:X|X:X:X:X:X:X/M> [ip <A.B.C.D|X:X::X:X>]|multicast ip <A.B.C.D|X:X::X:X>|prefix ip <A.B.C.D/M|X:X::X:X/M>>",
81cf0de5
CS		 1388 DEBUG_STR
1389 BGP_STR
1390 "BGP updates\n"
1391 "Specify a prefix to debug\n"
377e3565
QY		 1392 L2VPN_HELP_STR
1393 EVPN_HELP_STR
81cf0de5
CS		 1394 "Specify EVPN Route type\n"
1395 "MAC-IP (Type-2) route\n"
377e3565
QY		 1396 MAC_STR MAC_STR MAC_STR
1397 IP_STR
1398 "IPv4 address\n"
1399 "IPv6 address\n"
81cf0de5 1400 "Multicast (Type-3) route\n"
377e3565
QY		 1401 IP_STR
1402 "IPv4 address\n"
1403 "IPv6 address\n"
81cf0de5 1404 "Prefix (Type-5) route\n"
377e3565
QY		 1405 IP_STR
1406 "IPv4 prefix\n"
1407 "IPv6 prefix\n")
81cf0de5 1408{
81cf0de5
CS		 1409 struct prefix *argv_p;
1410 int ret = CMD_SUCCESS;
377e3565 1411 char buf[PREFIX2STR_BUFFER];
81cf0de5
CS		 1412
1413 argv_p = prefix_new();
1414
377e3565
QY		 1415 ret = bgp_debug_parse_evpn_prefix(vty, argv, argc, &argv_p);
1416 if (ret != CMD_SUCCESS) {
63265b5c 1417 prefix_free(&argv_p);
377e3565 1418 return ret;
81cf0de5
CS		 1419 }
1420
1421 if (!bgp_debug_update_prefixes)
1422 bgp_debug_update_prefixes = list_new();
1423
377e3565
QY		 1424 prefix2str(argv_p, buf, sizeof(buf));
1425
81cf0de5
CS		 1426 if (bgp_debug_list_has_entry(bgp_debug_update_prefixes, NULL, argv_p)) {
1427 vty_out(vty,
1428 "BGP updates debugging is already enabled for %s\n",
377e3565 1429 buf);
63265b5c 1430 prefix_free(&argv_p);
377e3565 1431 return CMD_SUCCESS;
81cf0de5
CS		 1432 }
1433
1434 bgp_debug_list_add_entry(bgp_debug_update_prefixes, NULL, argv_p);
1435
1436 if (vty->node == CONFIG_NODE) {
1437 DEBUG_ON(update, UPDATE_PREFIX);
1438 } else {
1439 TERM_DEBUG_ON(update, UPDATE_PREFIX);
377e3565 1440 vty_out(vty, "BGP updates debugging is on for %s\n", buf);
81cf0de5
CS		 1441 }
1442
63265b5c 1443 prefix_free(&argv_p);
360f9703 1444
377e3565 1445 return CMD_SUCCESS;
81cf0de5
CS		 1446}
1447
1448DEFPY (no_debug_bgp_update_prefix_afi_safi,
1449 no_debug_bgp_update_prefix_afi_safi_cmd,
6163c6cc 1450 "no debug bgp updates prefix l2vpn$afi evpn$safi type <macip mac <X:X:X:X:X:X|X:X:X:X:X:X/M> [ip <A.B.C.D|X:X::X:X>]|multicast ip <A.B.C.D|X:X::X:X>|prefix ip <A.B.C.D/M|X:X::X:X/M>>",
81cf0de5
CS		 1451 NO_STR
1452 DEBUG_STR
1453 BGP_STR
1454 "BGP updates\n"
1455 "Specify a prefix to debug\n"
377e3565
QY		 1456 L2VPN_HELP_STR
1457 EVPN_HELP_STR
81cf0de5
CS		 1458 "Specify EVPN Route type\n"
1459 "MAC-IP (Type-2) route\n"
377e3565
QY		 1460 MAC_STR MAC_STR MAC_STR
1461 IP_STR
1462 "IPv4 address\n"
1463 "IPv6 address\n"
81cf0de5 1464 "Multicast (Type-3) route\n"
377e3565
QY		 1465 IP_STR
1466 "IPv4 address\n"
1467 "IPv6 address\n"
81cf0de5 1468 "Prefix (Type-5) route\n"
377e3565
QY		 1469 IP_STR
1470 "IPv4 prefix\n"
1471 "IPv6 prefix\n")
81cf0de5 1472{
81cf0de5 1473 struct prefix *argv_p;
377e3565 1474 bool found_prefix = false;
81cf0de5 1475 int ret = CMD_SUCCESS;
377e3565 1476 char buf[PREFIX2STR_BUFFER];
81cf0de5
CS		 1477
1478 argv_p = prefix_new();
1479
377e3565
QY		 1480 ret = bgp_debug_parse_evpn_prefix(vty, argv, argc, &argv_p);
1481 if (ret != CMD_SUCCESS) {
63265b5c 1482 prefix_free(&argv_p);
377e3565 1483 return ret;
81cf0de5
CS		 1484 }
1485
1486 if (bgp_debug_update_prefixes
1487 && !list_isempty(bgp_debug_update_prefixes)) {
1488 found_prefix = bgp_debug_list_remove_entry(
1489 bgp_debug_update_prefixes, NULL, argv_p);
1490
1491 if (list_isempty(bgp_debug_update_prefixes)) {
1492 if (vty->node == CONFIG_NODE) {
1493 DEBUG_OFF(update, UPDATE_PREFIX);
1494 } else {
1495 TERM_DEBUG_OFF(update, UPDATE_PREFIX);
1496 vty_out(vty,
1497 "BGP updates debugging (per prefix) is off\n");
1498 }
1499 }
1500 }
1501
377e3565
QY		 1502 prefix2str(argv_p, buf, sizeof(buf));
1503
81cf0de5 1504 if (found_prefix)
377e3565 1505 vty_out(vty, "BGP updates debugging is off for %s\n", buf);
81cf0de5
CS		 1506 else
1507 vty_out(vty, "BGP updates debugging was not enabled for %s\n",
377e3565 1508 buf);
81cf0de5 1509
63265b5c 1510 prefix_free(&argv_p);
360f9703
A		 1511
1512 return ret;
81cf0de5
CS		 1513}
1514
1515
16286195
DS		 1516DEFUN (debug_bgp_update_prefix,
1517 debug_bgp_update_prefix_cmd,
6147e2c6 1518 "debug bgp updates prefix <A.B.C.D/M|X:X::X:X/M>",
718e3744 1519 DEBUG_STR
16286195
DS		 1520 BGP_STR
1521 "BGP updates\n"
1522 "Specify a prefix to debug\n"
0c7b1b01
QY		 1523 "IPv4 prefix\n"
1524 "IPv6 prefix\n")
718e3744 1525{
d62a17ae 1526 int idx_ipv4_ipv6_prefixlen = 4;
1527 struct prefix *argv_p;
d62a17ae 1528
1529 argv_p = prefix_new();
ffd71765 1530 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c 1531 apply_mask(argv_p);
d62a17ae 1532
1533 if (!bgp_debug_update_prefixes)
1534 bgp_debug_update_prefixes = list_new();
1535
1536 if (bgp_debug_list_has_entry(bgp_debug_update_prefixes, NULL, argv_p)) {
1537 vty_out(vty,
1538 "BGP updates debugging is already enabled for %s\n",
1539 argv[idx_ipv4_ipv6_prefixlen]->arg);
1540 return CMD_SUCCESS;
1541 }
1542
1543 bgp_debug_list_add_entry(bgp_debug_update_prefixes, NULL, argv_p);
1544
1545 if (vty->node == CONFIG_NODE) {
1546 DEBUG_ON(update, UPDATE_PREFIX);
1547 } else {
1548 TERM_DEBUG_ON(update, UPDATE_PREFIX);
1549 vty_out(vty, "BGP updates debugging is on for %s\n",
1550 argv[idx_ipv4_ipv6_prefixlen]->arg);
1551 }
1552
1553 return CMD_SUCCESS;
718e3744 1554}
1555
16286195
DS		 1556DEFUN (no_debug_bgp_update_prefix,
1557 no_debug_bgp_update_prefix_cmd,
6147e2c6 1558 "no debug bgp updates prefix <A.B.C.D/M|X:X::X:X/M>",
718e3744 1559 NO_STR
1560 DEBUG_STR
16286195
DS		 1561 BGP_STR
1562 "BGP updates\n"
1563 "Specify a prefix to debug\n"
0c7b1b01
QY		 1564 "IPv4 prefix\n"
1565 "IPv6 prefix\n")
16286195 1566{
d62a17ae 1567 int idx_ipv4_ipv6_prefixlen = 5;
1568 struct prefix *argv_p;
1569 int found_prefix = 0;
d62a17ae 1570
1571 argv_p = prefix_new();
ffd71765 1572 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c 1573 apply_mask(argv_p);
d62a17ae 1574
1575 if (bgp_debug_update_prefixes
1576 && !list_isempty(bgp_debug_update_prefixes)) {
1577 found_prefix = bgp_debug_list_remove_entry(
1578 bgp_debug_update_prefixes, NULL, argv_p);
1579
1580 if (list_isempty(bgp_debug_update_prefixes)) {
1581 if (vty->node == CONFIG_NODE) {
1582 DEBUG_OFF(update, UPDATE_PREFIX);
1583 } else {
1584 TERM_DEBUG_OFF(update, UPDATE_PREFIX);
1585 vty_out(vty,
1586 "BGP updates debugging (per prefix) is off\n");
1587 }
1588 }
1589 }
1590
1591 if (found_prefix)
1592 vty_out(vty, "BGP updates debugging is off for %s\n",
1593 argv[idx_ipv4_ipv6_prefixlen]->arg);
1594 else
1595 vty_out(vty, "BGP updates debugging was not enabled for %s\n",
1596 argv[idx_ipv4_ipv6_prefixlen]->arg);
1597
1598 return CMD_SUCCESS;
16286195
DS		 1599}
1600
1601DEFUN (no_debug_bgp_update,
1602 no_debug_bgp_update_cmd,
1603 "no debug bgp updates",
1604 NO_STR
1605 DEBUG_STR
1606 BGP_STR
1607 "BGP updates\n")
718e3744 1608{
87f42c2c
QY		 1609 struct listnode *ln;
1610 struct bgp *bgp;
1611
d62a17ae 1612 bgp_debug_list_free(bgp_debug_update_in_peers);
1613 bgp_debug_list_free(bgp_debug_update_out_peers);
1614 bgp_debug_list_free(bgp_debug_update_prefixes);
1615
87f42c2c
QY		 1616 for (ALL_LIST_ELEMENTS_RO(bm->bgp, ln, bgp))
1617 bgp_debug_clear_updgrp_update_dbg(bgp);
d62a17ae 1618
1619 if (vty->node == CONFIG_NODE) {
1620 DEBUG_OFF(update, UPDATE_IN);
1621 DEBUG_OFF(update, UPDATE_OUT);
1622 DEBUG_OFF(update, UPDATE_PREFIX);
1623 } else {
1624 TERM_DEBUG_OFF(update, UPDATE_IN);
1625 TERM_DEBUG_OFF(update, UPDATE_OUT);
1626 TERM_DEBUG_OFF(update, UPDATE_PREFIX);
1627 vty_out(vty, "BGP updates debugging is off\n");
1628 }
1629 return CMD_SUCCESS;
718e3744 1630}
1631
16286195 1632/* debug bgp zebra */
a39275d7
AS		 1633DEFUN (debug_bgp_zebra,
1634 debug_bgp_zebra_cmd,
1635 "debug bgp zebra",
1636 DEBUG_STR
1637 BGP_STR
1638 "BGP Zebra messages\n")
1639{
d62a17ae 1640 if (vty->node == CONFIG_NODE)
1641 DEBUG_ON(zebra, ZEBRA);
1642 else {
1643 TERM_DEBUG_ON(zebra, ZEBRA);
1644 vty_out(vty, "BGP zebra debugging is on\n");
1645 }
1646 return CMD_SUCCESS;
a39275d7
AS		 1647}
1648
794b37d5 1649DEFUN (debug_bgp_graceful_restart,
1650 debug_bgp_graceful_restart_cmd,
1651 "debug bgp graceful-restart",
1652 DEBUG_STR
1653 BGP_STR
1654 GR_DEBUG)
1655{
1656 if (vty->node == CONFIG_NODE) {
1657 DEBUG_ON(graceful_restart, GRACEFUL_RESTART);
1658 } else {
1659 TERM_DEBUG_ON(graceful_restart, GRACEFUL_RESTART);
1660 vty_out(vty, "BGP Graceful Restart debugging is on\n");
1661 }
1662 return CMD_SUCCESS;
1663}
1664
1665
16286195
DS		 1666DEFUN (debug_bgp_zebra_prefix,
1667 debug_bgp_zebra_prefix_cmd,
6147e2c6 1668 "debug bgp zebra prefix <A.B.C.D/M|X:X::X:X/M>",
16286195
DS		 1669 DEBUG_STR
1670 BGP_STR
1671 "BGP Zebra messages\n"
1672 "Specify a prefix to debug\n"
0c7b1b01
QY		 1673 "IPv4 prefix\n"
1674 "IPv6 prefix\n")
16286195 1675{
d62a17ae 1676 int idx_ipv4_ipv6_prefixlen = 4;
1677 struct prefix *argv_p;
d62a17ae 1678
1679 argv_p = prefix_new();
ffd71765 1680 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c 1681 apply_mask(argv_p);
d62a17ae 1682
1683 if (!bgp_debug_zebra_prefixes)
1684 bgp_debug_zebra_prefixes = list_new();
1685
1686 if (bgp_debug_list_has_entry(bgp_debug_zebra_prefixes, NULL, argv_p)) {
1687 vty_out(vty, "BGP zebra debugging is already enabled for %s\n",
1688 argv[idx_ipv4_ipv6_prefixlen]->arg);
1689 return CMD_SUCCESS;
1690 }
1691
1692 bgp_debug_list_add_entry(bgp_debug_zebra_prefixes, NULL, argv_p);
1693
1694 if (vty->node == CONFIG_NODE)
1695 DEBUG_ON(zebra, ZEBRA);
1696 else {
1697 TERM_DEBUG_ON(zebra, ZEBRA);
1698 vty_out(vty, "BGP zebra debugging is on for %s\n",
1699 argv[idx_ipv4_ipv6_prefixlen]->arg);
1700 }
1701
1702 return CMD_SUCCESS;
16286195
DS		 1703}
1704
a39275d7
AS		 1705DEFUN (no_debug_bgp_zebra,
1706 no_debug_bgp_zebra_cmd,
1707 "no debug bgp zebra",
1708 NO_STR
1709 DEBUG_STR
1710 BGP_STR
1711 "BGP Zebra messages\n")
1712{
d62a17ae 1713 bgp_debug_list_free(bgp_debug_zebra_prefixes);
1714
1715 if (vty->node == CONFIG_NODE)
1716 DEBUG_OFF(zebra, ZEBRA);
1717 else {
1718 TERM_DEBUG_OFF(zebra, ZEBRA);
1719 vty_out(vty, "BGP zebra debugging is off\n");
1720 }
1721 return CMD_SUCCESS;
a39275d7
AS		 1722}
1723
794b37d5 1724DEFUN (no_debug_bgp_graceful_restart,
1725 no_debug_bgp_graceful_restart_cmd,
1726 "no debug bgp graceful-restart",
1727 DEBUG_STR
1728 BGP_STR
1729 GR_DEBUG
1730 NO_STR)
1731{
1732 if (vty->node == CONFIG_NODE) {
1733 DEBUG_OFF(graceful_restart, GRACEFUL_RESTART);
1734 } else {
1735 TERM_DEBUG_OFF(graceful_restart, GRACEFUL_RESTART);
1736 vty_out(vty, "BGP Graceful Restart debugging is off\n");
1737 }
1738 return CMD_SUCCESS;
1739}
1740
16286195
DS		 1741DEFUN (no_debug_bgp_zebra_prefix,
1742 no_debug_bgp_zebra_prefix_cmd,
6147e2c6 1743 "no debug bgp zebra prefix <A.B.C.D/M|X:X::X:X/M>",
16286195
DS		 1744 NO_STR
1745 DEBUG_STR
a39275d7 1746 BGP_STR
16286195
DS		 1747 "BGP Zebra messages\n"
1748 "Specify a prefix to debug\n"
0c7b1b01
QY		 1749 "IPv4 prefix\n"
1750 "IPv6 prefix\n")
16286195 1751{
d62a17ae 1752 int idx_ipv4_ipv6_prefixlen = 5;
1753 struct prefix *argv_p;
1754 int found_prefix = 0;
d62a17ae 1755
1756 argv_p = prefix_new();
ffd71765 1757 (void)str2prefix(argv[idx_ipv4_ipv6_prefixlen]->arg, argv_p);
0be4b77c 1758 apply_mask(argv_p);
d62a17ae 1759
1760 if (bgp_debug_zebra_prefixes
1761 && !list_isempty(bgp_debug_zebra_prefixes)) {
1762 found_prefix = bgp_debug_list_remove_entry(
1763 bgp_debug_zebra_prefixes, NULL, argv_p);
1764
1765 if (list_isempty(bgp_debug_zebra_prefixes)) {
1766 if (vty->node == CONFIG_NODE)
1767 DEBUG_OFF(zebra, ZEBRA);
1768 else {
1769 TERM_DEBUG_OFF(zebra, ZEBRA);
1770 vty_out(vty, "BGP zebra debugging is off\n");
1771 }
1772 }
1773 }
1774
1775 if (found_prefix)
1776 vty_out(vty, "BGP zebra debugging is off for %s\n",
1777 argv[idx_ipv4_ipv6_prefixlen]->arg);
1778 else
1779 vty_out(vty, "BGP zebra debugging was not enabled for %s\n",
1780 argv[idx_ipv4_ipv6_prefixlen]->arg);
1781
1782 return CMD_SUCCESS;
16286195
DS		 1783}
1784
cebb7440
LB		 1785DEFUN (debug_bgp_allow_martians,
1786 debug_bgp_allow_martians_cmd,
1787 "debug bgp allow-martians",
1788 DEBUG_STR
1789 BGP_STR
1790 "BGP allow martian next hops\n")
1791{
d62a17ae 1792 if (vty->node == CONFIG_NODE)
1793 DEBUG_ON(allow_martians, ALLOW_MARTIANS);
1794 else {
1795 TERM_DEBUG_ON(allow_martians, ALLOW_MARTIANS);
1796 vty_out(vty, "BGP allow_martian next hop debugging is on\n");
1797 }
1798 return CMD_SUCCESS;
cebb7440
LB		 1799}
1800
1801DEFUN (no_debug_bgp_allow_martians,
1802 no_debug_bgp_allow_martians_cmd,
1803 "no debug bgp allow-martians",
1804 NO_STR
1805 DEBUG_STR
1806 BGP_STR
1807 "BGP allow martian next hops\n")
1808{
d62a17ae 1809 if (vty->node == CONFIG_NODE)
1810 DEBUG_OFF(allow_martians, ALLOW_MARTIANS);
1811 else {
1812 TERM_DEBUG_OFF(allow_martians, ALLOW_MARTIANS);
1813 vty_out(vty, "BGP allow martian next hop debugging is off\n");
1814 }
1815 return CMD_SUCCESS;
cebb7440
LB		 1816}
1817
cebb7440 1818
3f9c7369
DS		 1819/* debug bgp update-groups */
1820DEFUN (debug_bgp_update_groups,
1821 debug_bgp_update_groups_cmd,
1822 "debug bgp update-groups",
1823 DEBUG_STR
1824 BGP_STR
1825 "BGP update-groups\n")
1826{
d62a17ae 1827 if (vty->node == CONFIG_NODE)
1828 DEBUG_ON(update_groups, UPDATE_GROUPS);
1829 else {
1830 TERM_DEBUG_ON(update_groups, UPDATE_GROUPS);
1831 vty_out(vty, "BGP update-groups debugging is on\n");
1832 }
1833 return CMD_SUCCESS;
3f9c7369
DS		 1834}
1835
1836DEFUN (no_debug_bgp_update_groups,
1837 no_debug_bgp_update_groups_cmd,
1838 "no debug bgp update-groups",
1839 NO_STR
1840 DEBUG_STR
1841 BGP_STR
1842 "BGP update-groups\n")
1843{
d62a17ae 1844 if (vty->node == CONFIG_NODE)
1845 DEBUG_OFF(update_groups, UPDATE_GROUPS);
1846 else {
1847 TERM_DEBUG_OFF(update_groups, UPDATE_GROUPS);
1848 vty_out(vty, "BGP update-groups debugging is off\n");
1849 }
1850 return CMD_SUCCESS;
3f9c7369
DS		 1851}
1852
ddb5b488
PZ		 1853DEFUN (debug_bgp_vpn,
1854 debug_bgp_vpn_cmd,
1855 "debug bgp vpn <leak-from-vrf|leak-to-vrf|rmap-event|label>",
1856 DEBUG_STR
1857 BGP_STR
1858 "VPN routes\n"
1859 "leaked from vrf to vpn\n"
1860 "leaked to vrf from vpn\n"
1861 "route-map updates\n"
1862 "labels\n")
1863{
1864 int idx = 3;
1865
1866 if (argv_find(argv, argc, "leak-from-vrf", &idx)) {
1867 if (vty->node == CONFIG_NODE)
1868 DEBUG_ON(vpn, VPN_LEAK_FROM_VRF);
1869 else
1870 TERM_DEBUG_ON(vpn, VPN_LEAK_FROM_VRF);
1871 } else if (argv_find(argv, argc, "leak-to-vrf", &idx)) {
1872 if (vty->node == CONFIG_NODE)
1873 DEBUG_ON(vpn, VPN_LEAK_TO_VRF);
1874 else
1875 TERM_DEBUG_ON(vpn, VPN_LEAK_TO_VRF);
1876 } else if (argv_find(argv, argc, "rmap-event", &idx)) {
1877 if (vty->node == CONFIG_NODE)
1878 DEBUG_ON(vpn, VPN_LEAK_RMAP_EVENT);
1879 else
1880 TERM_DEBUG_ON(vpn, VPN_LEAK_RMAP_EVENT);
1881 } else if (argv_find(argv, argc, "label", &idx)) {
1882 if (vty->node == CONFIG_NODE)
1883 DEBUG_ON(vpn, VPN_LEAK_LABEL);
1884 else
1885 TERM_DEBUG_ON(vpn, VPN_LEAK_LABEL);
1886 } else {
1887 vty_out(vty, "%% unknown debug bgp vpn keyword\n");
1888 return CMD_WARNING_CONFIG_FAILED;
1889 }
1890
1891 if (vty->node != CONFIG_NODE)
1892 vty_out(vty, "enabled debug bgp vpn %s\n", argv[idx]->text);
1893
1894 return CMD_SUCCESS;
1895}
1896
1897DEFUN (no_debug_bgp_vpn,
1898 no_debug_bgp_vpn_cmd,
1899 "no debug bgp vpn <leak-from-vrf|leak-to-vrf|rmap-event|label>",
1900 NO_STR
1901 DEBUG_STR
1902 BGP_STR
1903 "VPN routes\n"
1904 "leaked from vrf to vpn\n"
1905 "leaked to vrf from vpn\n"
1906 "route-map updates\n"
1907 "labels\n")
1908{
1909 int idx = 4;
1910
1911 if (argv_find(argv, argc, "leak-from-vrf", &idx)) {
1912 if (vty->node == CONFIG_NODE)
1913 DEBUG_OFF(vpn, VPN_LEAK_FROM_VRF);
1914 else
1915 TERM_DEBUG_OFF(vpn, VPN_LEAK_FROM_VRF);
1916
1917 } else if (argv_find(argv, argc, "leak-to-vrf", &idx)) {
1918 if (vty->node == CONFIG_NODE)
1919 DEBUG_OFF(vpn, VPN_LEAK_TO_VRF);
1920 else
1921 TERM_DEBUG_OFF(vpn, VPN_LEAK_TO_VRF);
1922 } else if (argv_find(argv, argc, "rmap-event", &idx)) {
1923 if (vty->node == CONFIG_NODE)
1924 DEBUG_OFF(vpn, VPN_LEAK_RMAP_EVENT);
1925 else
1926 TERM_DEBUG_OFF(vpn, VPN_LEAK_RMAP_EVENT);
1927 } else if (argv_find(argv, argc, "label", &idx)) {
1928 if (vty->node == CONFIG_NODE)
1929 DEBUG_OFF(vpn, VPN_LEAK_LABEL);
1930 else
1931 TERM_DEBUG_OFF(vpn, VPN_LEAK_LABEL);
1932 } else {
1933 vty_out(vty, "%% unknown debug bgp vpn keyword\n");
1934 return CMD_WARNING_CONFIG_FAILED;
1935 }
1936
1937 if (vty->node != CONFIG_NODE)
1938 vty_out(vty, "disabled debug bgp vpn %s\n", argv[idx]->text);
1a80fc0f
PG		 1939 return CMD_SUCCESS;
1940}
ddb5b488 1941
1a80fc0f
PG		 1942/* debug bgp pbr */
1943DEFUN (debug_bgp_pbr,
1944 debug_bgp_pbr_cmd,
e9d0aa99 1945 "debug bgp pbr [error]",
1a80fc0f
PG		 1946 DEBUG_STR
1947 BGP_STR
e9d0aa99
PG		 1948 "BGP policy based routing\n"
1949 "BGP PBR error\n")
1a80fc0f 1950{
e9d0aa99
PG		 1951 int idx = 3;
1952
1953 if (argv_find(argv, argc, "error", &idx)) {
1954 if (vty->node == CONFIG_NODE)
1955 DEBUG_ON(pbr, PBR_ERROR);
1956 else {
1957 TERM_DEBUG_ON(pbr, PBR_ERROR);
1958 vty_out(vty, "BGP policy based routing error is on\n");
1959 }
1960 return CMD_SUCCESS;
1961 }
1a80fc0f
PG		 1962 if (vty->node == CONFIG_NODE)
1963 DEBUG_ON(pbr, PBR);
1964 else {
1965 TERM_DEBUG_ON(pbr, PBR);
1966 vty_out(vty, "BGP policy based routing is on\n");
1967 }
1968 return CMD_SUCCESS;
1969}
1970
1971DEFUN (no_debug_bgp_pbr,
1972 no_debug_bgp_pbr_cmd,
e9d0aa99 1973 "no debug bgp pbr [error]",
1a80fc0f
PG		 1974 NO_STR
1975 DEBUG_STR
1976 BGP_STR
e9d0aa99
PG		 1977 "BGP policy based routing\n"
1978 "BGP PBR Error\n")
1a80fc0f 1979{
e9d0aa99
PG		 1980 int idx = 3;
1981
1982 if (argv_find(argv, argc, "error", &idx)) {
1983 if (vty->node == CONFIG_NODE)
1984 DEBUG_OFF(pbr, PBR_ERROR);
1985 else {
1986 TERM_DEBUG_OFF(pbr, PBR_ERROR);
1987 vty_out(vty, "BGP policy based routing error is off\n");
1988 }
1989 return CMD_SUCCESS;
1990 }
1a80fc0f
PG		 1991 if (vty->node == CONFIG_NODE)
1992 DEBUG_OFF(pbr, PBR);
1993 else {
1994 TERM_DEBUG_OFF(pbr, PBR);
1995 vty_out(vty, "BGP policy based routing is off\n");
1996 }
ddb5b488
PZ		 1997 return CMD_SUCCESS;
1998}
1999
955bfd98
PZ		 2000DEFUN (debug_bgp_labelpool,
2001 debug_bgp_labelpool_cmd,
2002 "debug bgp labelpool",
2003 DEBUG_STR
2004 BGP_STR
2005 "label pool\n")
2006{
2007 if (vty->node == CONFIG_NODE)
2008 DEBUG_ON(labelpool, LABELPOOL);
2009 else
2010 TERM_DEBUG_ON(labelpool, LABELPOOL);
2011
2012 if (vty->node != CONFIG_NODE)
2013 vty_out(vty, "enabled debug bgp labelpool\n");
2014
2015 return CMD_SUCCESS;
2016}
2017
2018DEFUN (no_debug_bgp_labelpool,
2019 no_debug_bgp_labelpool_cmd,
2020 "no debug bgp labelpool",
2021 NO_STR
2022 DEBUG_STR
2023 BGP_STR
2024 "label pool\n")
2025{
2026 if (vty->node == CONFIG_NODE)
2027 DEBUG_OFF(labelpool, LABELPOOL);
2028 else
2029 TERM_DEBUG_OFF(labelpool, LABELPOOL);
2030
2031
2032 if (vty->node != CONFIG_NODE)
2033 vty_out(vty, "disabled debug bgp labelpool\n");
2034
2035 return CMD_SUCCESS;
2036}
2037
16286195
DS		 2038DEFUN (no_debug_bgp,
2039 no_debug_bgp_cmd,
2040 "no debug bgp",
718e3744 2041 NO_STR
2042 DEBUG_STR
718e3744 2043 BGP_STR)
2044{
87f42c2c
QY		 2045 struct bgp *bgp;
2046 struct listnode *ln;
2047
d62a17ae 2048 bgp_debug_list_free(bgp_debug_neighbor_events_peers);
2049 bgp_debug_list_free(bgp_debug_keepalive_peers);
2050 bgp_debug_list_free(bgp_debug_update_in_peers);
2051 bgp_debug_list_free(bgp_debug_update_out_peers);
2052 bgp_debug_list_free(bgp_debug_update_prefixes);
2053 bgp_debug_list_free(bgp_debug_bestpath_prefixes);
2054 bgp_debug_list_free(bgp_debug_zebra_prefixes);
2055
87f42c2c
QY		 2056 for (ALL_LIST_ELEMENTS_RO(bm->bgp, ln, bgp))
2057 bgp_debug_clear_updgrp_update_dbg(bgp);
d62a17ae 2058
2059 TERM_DEBUG_OFF(keepalive, KEEPALIVE);
2060 TERM_DEBUG_OFF(update, UPDATE_IN);
2061 TERM_DEBUG_OFF(update, UPDATE_OUT);
2062 TERM_DEBUG_OFF(update, UPDATE_PREFIX);
2063 TERM_DEBUG_OFF(bestpath, BESTPATH);
2064 TERM_DEBUG_OFF(as4, AS4);
2065 TERM_DEBUG_OFF(as4, AS4_SEGMENT);
2066 TERM_DEBUG_OFF(neighbor_events, NEIGHBOR_EVENTS);
2067 TERM_DEBUG_OFF(zebra, ZEBRA);
2068 TERM_DEBUG_OFF(allow_martians, ALLOW_MARTIANS);
c33b83b3 2069 TERM_DEBUG_OFF(nht, NHT);
ddb5b488
PZ		 2070 TERM_DEBUG_OFF(vpn, VPN_LEAK_FROM_VRF);
2071 TERM_DEBUG_OFF(vpn, VPN_LEAK_TO_VRF);
2072 TERM_DEBUG_OFF(vpn, VPN_LEAK_RMAP_EVENT);
2073 TERM_DEBUG_OFF(vpn, VPN_LEAK_LABEL);
268e1b9b 2074 TERM_DEBUG_OFF(flowspec, FLOWSPEC);
955bfd98 2075 TERM_DEBUG_OFF(labelpool, LABELPOOL);
1a80fc0f 2076 TERM_DEBUG_OFF(pbr, PBR);
e9d0aa99 2077 TERM_DEBUG_OFF(pbr, PBR_ERROR);
794b37d5 2078 TERM_DEBUG_OFF(graceful_restart, GRACEFUL_RESTART);
2079
d62a17ae 2080 vty_out(vty, "All possible debugging has been turned off\n");
2081
2082 return CMD_SUCCESS;
718e3744 2083}
2084
87f6dc50
DS		 2085DEFUN_NOSH (show_debugging_bgp,
2086 show_debugging_bgp_cmd,
2087 "show debugging [bgp]",
2088 SHOW_STR
2089 DEBUG_STR
2090 BGP_STR)
718e3744 2091{
d62a17ae 2092 vty_out(vty, "BGP debugging status:\n");
718e3744 2093
d62a17ae 2094 if (BGP_DEBUG(as4, AS4))
2095 vty_out(vty, " BGP as4 debugging is on\n");
16286195 2096
d62a17ae 2097 if (BGP_DEBUG(as4, AS4_SEGMENT))
2098 vty_out(vty, " BGP as4 aspath segment debugging is on\n");
16286195 2099
d62a17ae 2100 if (BGP_DEBUG(bestpath, BESTPATH))
2101 bgp_debug_list_print(vty, " BGP bestpath debugging is on",
29a643ca 2102 bgp_debug_bestpath_prefixes);
16286195 2103
d62a17ae 2104 if (BGP_DEBUG(keepalive, KEEPALIVE))
2105 bgp_debug_list_print(vty, " BGP keepalives debugging is on",
29a643ca 2106 bgp_debug_keepalive_peers);
16286195 2107
d62a17ae 2108 if (BGP_DEBUG(neighbor_events, NEIGHBOR_EVENTS))
2109 bgp_debug_list_print(vty,
2110 " BGP neighbor-events debugging is on",
29a643ca 2111 bgp_debug_neighbor_events_peers);
91ba2c8b 2112
d62a17ae 2113 if (BGP_DEBUG(nht, NHT))
2114 vty_out(vty, " BGP next-hop tracking debugging is on\n");
16286195 2115
d62a17ae 2116 if (BGP_DEBUG(update_groups, UPDATE_GROUPS))
2117 vty_out(vty, " BGP update-groups debugging is on\n");
91ba2c8b 2118
d62a17ae 2119 if (BGP_DEBUG(update, UPDATE_PREFIX))
2120 bgp_debug_list_print(vty, " BGP updates debugging is on",
29a643ca 2121 bgp_debug_update_prefixes);
16286195 2122
d62a17ae 2123 if (BGP_DEBUG(update, UPDATE_IN))
2124 bgp_debug_list_print(vty,
2125 " BGP updates debugging is on (inbound)",
29a643ca 2126 bgp_debug_update_in_peers);
16286195 2127
d62a17ae 2128 if (BGP_DEBUG(update, UPDATE_OUT))
2129 bgp_debug_list_print(vty,
2130 " BGP updates debugging is on (outbound)",
29a643ca 2131 bgp_debug_update_out_peers);
16286195 2132
d62a17ae 2133 if (BGP_DEBUG(zebra, ZEBRA))
2134 bgp_debug_list_print(vty, " BGP zebra debugging is on",
794b37d5 2135 bgp_debug_zebra_prefixes);
2136
2137 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2138 vty_out(vty,
2139 " BGP graceful-restart debugging is on");
16286195 2140
d62a17ae 2141 if (BGP_DEBUG(allow_martians, ALLOW_MARTIANS))
2142 vty_out(vty, " BGP allow martian next hop debugging is on\n");
ddb5b488
PZ		 2143
2144 if (BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF))
2145 vty_out(vty,
2146 " BGP route leak from vrf to vpn debugging is on\n");
2147 if (BGP_DEBUG(vpn, VPN_LEAK_TO_VRF))
2148 vty_out(vty,
2149 " BGP route leak to vrf from vpn debugging is on\n");
2150 if (BGP_DEBUG(vpn, VPN_LEAK_RMAP_EVENT))
2151 vty_out(vty, " BGP vpn route-map event debugging is on\n");
2152 if (BGP_DEBUG(vpn, VPN_LEAK_LABEL))
2153 vty_out(vty, " BGP vpn label event debugging is on\n");
268e1b9b
PG		 2154 if (BGP_DEBUG(flowspec, FLOWSPEC))
2155 vty_out(vty, " BGP flowspec debugging is on\n");
955bfd98
PZ		 2156 if (BGP_DEBUG(labelpool, LABELPOOL))
2157 vty_out(vty, " BGP labelpool debugging is on\n");
ddb5b488 2158
1a80fc0f
PG		 2159 if (BGP_DEBUG(pbr, PBR))
2160 vty_out(vty, " BGP policy based routing debugging is on\n");
e9d0aa99
PG		 2161 if (BGP_DEBUG(pbr, PBR_ERROR))
2162 vty_out(vty, " BGP policy based routing error debugging is on\n");
1a80fc0f 2163
d62a17ae 2164 vty_out(vty, "\n");
2165 return CMD_SUCCESS;
718e3744 2166}
2167
d62a17ae 2168static int bgp_config_write_debug(struct vty *vty)
718e3744 2169{
d62a17ae 2170 int write = 0;
718e3744 2171
d62a17ae 2172 if (CONF_BGP_DEBUG(as4, AS4)) {
2173 vty_out(vty, "debug bgp as4\n");
2174 write++;
2175 }
718e3744 2176
d62a17ae 2177 if (CONF_BGP_DEBUG(as4, AS4_SEGMENT)) {
2178 vty_out(vty, "debug bgp as4 segment\n");
2179 write++;
2180 }
16286195 2181
d62a17ae 2182 if (CONF_BGP_DEBUG(bestpath, BESTPATH)) {
2183 write += bgp_debug_list_conf_print(vty, "debug bgp bestpath",
29a643ca 2184 bgp_debug_bestpath_prefixes);
d62a17ae 2185 }
2186
2187 if (CONF_BGP_DEBUG(keepalive, KEEPALIVE)) {
2188 write += bgp_debug_list_conf_print(vty, "debug bgp keepalives",
29a643ca 2189 bgp_debug_keepalive_peers);
d62a17ae 2190 }
2191
2192 if (CONF_BGP_DEBUG(neighbor_events, NEIGHBOR_EVENTS)) {
2193 write += bgp_debug_list_conf_print(
2194 vty, "debug bgp neighbor-events",
29a643ca 2195 bgp_debug_neighbor_events_peers);
d62a17ae 2196 }
2197
2198 if (CONF_BGP_DEBUG(nht, NHT)) {
2199 vty_out(vty, "debug bgp nht\n");
2200 write++;
2201 }
2202
2203 if (CONF_BGP_DEBUG(update_groups, UPDATE_GROUPS)) {
2204 vty_out(vty, "debug bgp update-groups\n");
2205 write++;
2206 }
2207
2208 if (CONF_BGP_DEBUG(update, UPDATE_PREFIX)) {
2209 write += bgp_debug_list_conf_print(vty,
2210 "debug bgp updates prefix",
29a643ca 2211 bgp_debug_update_prefixes);
d62a17ae 2212 }
2213
2214 if (CONF_BGP_DEBUG(update, UPDATE_IN)) {
2215 write += bgp_debug_list_conf_print(vty, "debug bgp updates in",
29a643ca 2216 bgp_debug_update_in_peers);
d62a17ae 2217 }
2218
2219 if (CONF_BGP_DEBUG(update, UPDATE_OUT)) {
2220 write += bgp_debug_list_conf_print(vty, "debug bgp updates out",
29a643ca 2221 bgp_debug_update_out_peers);
d62a17ae 2222 }
16286195 2223
d62a17ae 2224 if (CONF_BGP_DEBUG(zebra, ZEBRA)) {
2225 if (!bgp_debug_zebra_prefixes
2226 || list_isempty(bgp_debug_zebra_prefixes)) {
2227 vty_out(vty, "debug bgp zebra\n");
2228 write++;
2229 } else {
2230 write += bgp_debug_list_conf_print(
2231 vty, "debug bgp zebra prefix",
29a643ca 2232 bgp_debug_zebra_prefixes);
d62a17ae 2233 }
2234 }
16286195 2235
d62a17ae 2236 if (CONF_BGP_DEBUG(allow_martians, ALLOW_MARTIANS)) {
2237 vty_out(vty, "debug bgp allow-martians\n");
2238 write++;
2239 }
16286195 2240
ddb5b488
PZ		 2241 if (CONF_BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF)) {
2242 vty_out(vty, "debug bgp vpn leak-from-vrf\n");
2243 write++;
2244 }
2245 if (CONF_BGP_DEBUG(vpn, VPN_LEAK_TO_VRF)) {
2246 vty_out(vty, "debug bgp vpn leak-to-vrf\n");
2247 write++;
2248 }
2249 if (CONF_BGP_DEBUG(vpn, VPN_LEAK_RMAP_EVENT)) {
2250 vty_out(vty, "debug bgp vpn rmap-event\n");
2251 write++;
2252 }
2253 if (CONF_BGP_DEBUG(vpn, VPN_LEAK_LABEL)) {
2254 vty_out(vty, "debug bgp vpn label\n");
2255 write++;
2256 }
268e1b9b
PG		 2257 if (CONF_BGP_DEBUG(flowspec, FLOWSPEC)) {
2258 vty_out(vty, "debug bgp flowspec\n");
2259 write++;
2260 }
955bfd98
PZ		 2261 if (CONF_BGP_DEBUG(labelpool, LABELPOOL)) {
2262 vty_out(vty, "debug bgp labelpool\n");
2263 write++;
2264 }
ddb5b488 2265
1a80fc0f
PG		 2266 if (CONF_BGP_DEBUG(pbr, PBR)) {
2267 vty_out(vty, "debug bgp pbr\n");
2268 write++;
e9d0aa99
PG		 2269 }
2270 if (CONF_BGP_DEBUG(pbr, PBR_ERROR)) {
2271 vty_out(vty, "debug bgp pbr error\n");
2272 write++;
1a80fc0f 2273 }
794b37d5 2274
2275 if (CONF_BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) {
2276 vty_out(vty, "debug bgp graceful-restart\n");
2277 write++;
2278 }
d62a17ae 2279 return write;
2280}
16286195 2281
d62a17ae 2282static struct cmd_node debug_node = {DEBUG_NODE, "", 1};
2283
2284void bgp_debug_init(void)
2285{
2286 install_node(&debug_node, bgp_config_write_debug);
2287
2288 install_element(ENABLE_NODE, &show_debugging_bgp_cmd);
2289
2290 install_element(ENABLE_NODE, &debug_bgp_as4_cmd);
2291 install_element(CONFIG_NODE, &debug_bgp_as4_cmd);
2292 install_element(ENABLE_NODE, &debug_bgp_as4_segment_cmd);
2293 install_element(CONFIG_NODE, &debug_bgp_as4_segment_cmd);
2294
2295 install_element(ENABLE_NODE, &debug_bgp_neighbor_events_cmd);
2296 install_element(CONFIG_NODE, &debug_bgp_neighbor_events_cmd);
2297 install_element(ENABLE_NODE, &debug_bgp_nht_cmd);
2298 install_element(CONFIG_NODE, &debug_bgp_nht_cmd);
2299 install_element(ENABLE_NODE, &debug_bgp_keepalive_cmd);
2300 install_element(CONFIG_NODE, &debug_bgp_keepalive_cmd);
2301 install_element(ENABLE_NODE, &debug_bgp_update_cmd);
2302 install_element(CONFIG_NODE, &debug_bgp_update_cmd);
2303 install_element(ENABLE_NODE, &debug_bgp_zebra_cmd);
2304 install_element(CONFIG_NODE, &debug_bgp_zebra_cmd);
2305 install_element(ENABLE_NODE, &debug_bgp_allow_martians_cmd);
2306 install_element(CONFIG_NODE, &debug_bgp_allow_martians_cmd);
2307 install_element(ENABLE_NODE, &debug_bgp_update_groups_cmd);
2308 install_element(CONFIG_NODE, &debug_bgp_update_groups_cmd);
2309 install_element(ENABLE_NODE, &debug_bgp_bestpath_prefix_cmd);
2310 install_element(CONFIG_NODE, &debug_bgp_bestpath_prefix_cmd);
2311
794b37d5 2312 install_element(ENABLE_NODE, &debug_bgp_graceful_restart_cmd);
2313 install_element(CONFIG_NODE, &debug_bgp_graceful_restart_cmd);
2314
d62a17ae 2315 /* debug bgp updates (in|out) */
2316 install_element(ENABLE_NODE, &debug_bgp_update_direct_cmd);
2317 install_element(CONFIG_NODE, &debug_bgp_update_direct_cmd);
2318 install_element(ENABLE_NODE, &no_debug_bgp_update_direct_cmd);
2319 install_element(CONFIG_NODE, &no_debug_bgp_update_direct_cmd);
2320
2321 /* debug bgp updates (in|out) A.B.C.D */
2322 install_element(ENABLE_NODE, &debug_bgp_update_direct_peer_cmd);
2323 install_element(CONFIG_NODE, &debug_bgp_update_direct_peer_cmd);
2324 install_element(ENABLE_NODE, &no_debug_bgp_update_direct_peer_cmd);
2325 install_element(CONFIG_NODE, &no_debug_bgp_update_direct_peer_cmd);
2326
2327 /* debug bgp updates prefix A.B.C.D/M */
2328 install_element(ENABLE_NODE, &debug_bgp_update_prefix_cmd);
2329 install_element(CONFIG_NODE, &debug_bgp_update_prefix_cmd);
2330 install_element(ENABLE_NODE, &no_debug_bgp_update_prefix_cmd);
2331 install_element(CONFIG_NODE, &no_debug_bgp_update_prefix_cmd);
81cf0de5
CS		 2332 install_element(ENABLE_NODE, &debug_bgp_update_prefix_afi_safi_cmd);
2333 install_element(CONFIG_NODE, &debug_bgp_update_prefix_afi_safi_cmd);
2334 install_element(ENABLE_NODE, &no_debug_bgp_update_prefix_afi_safi_cmd);
2335 install_element(CONFIG_NODE, &no_debug_bgp_update_prefix_afi_safi_cmd);
d62a17ae 2336
2337 /* debug bgp zebra prefix A.B.C.D/M */
2338 install_element(ENABLE_NODE, &debug_bgp_zebra_prefix_cmd);
2339 install_element(CONFIG_NODE, &debug_bgp_zebra_prefix_cmd);
2340 install_element(ENABLE_NODE, &no_debug_bgp_zebra_prefix_cmd);
2341 install_element(CONFIG_NODE, &no_debug_bgp_zebra_prefix_cmd);
2342
2343 install_element(ENABLE_NODE, &no_debug_bgp_as4_cmd);
2344 install_element(CONFIG_NODE, &no_debug_bgp_as4_cmd);
2345 install_element(ENABLE_NODE, &no_debug_bgp_as4_segment_cmd);
2346 install_element(CONFIG_NODE, &no_debug_bgp_as4_segment_cmd);
2347
2348 /* debug bgp neighbor-events A.B.C.D */
2349 install_element(ENABLE_NODE, &debug_bgp_neighbor_events_peer_cmd);
2350 install_element(CONFIG_NODE, &debug_bgp_neighbor_events_peer_cmd);
2351 install_element(ENABLE_NODE, &no_debug_bgp_neighbor_events_peer_cmd);
2352 install_element(CONFIG_NODE, &no_debug_bgp_neighbor_events_peer_cmd);
2353
2354 /* debug bgp keepalive A.B.C.D */
2355 install_element(ENABLE_NODE, &debug_bgp_keepalive_peer_cmd);
2356 install_element(CONFIG_NODE, &debug_bgp_keepalive_peer_cmd);
2357 install_element(ENABLE_NODE, &no_debug_bgp_keepalive_peer_cmd);
2358 install_element(CONFIG_NODE, &no_debug_bgp_keepalive_peer_cmd);
2359
2360 install_element(ENABLE_NODE, &no_debug_bgp_neighbor_events_cmd);
2361 install_element(CONFIG_NODE, &no_debug_bgp_neighbor_events_cmd);
2362 install_element(ENABLE_NODE, &no_debug_bgp_nht_cmd);
2363 install_element(CONFIG_NODE, &no_debug_bgp_nht_cmd);
2364 install_element(ENABLE_NODE, &no_debug_bgp_keepalive_cmd);
2365 install_element(CONFIG_NODE, &no_debug_bgp_keepalive_cmd);
2366 install_element(ENABLE_NODE, &no_debug_bgp_update_cmd);
2367 install_element(CONFIG_NODE, &no_debug_bgp_update_cmd);
2368 install_element(ENABLE_NODE, &no_debug_bgp_zebra_cmd);
2369 install_element(CONFIG_NODE, &no_debug_bgp_zebra_cmd);
2370 install_element(ENABLE_NODE, &no_debug_bgp_allow_martians_cmd);
2371 install_element(CONFIG_NODE, &no_debug_bgp_allow_martians_cmd);
2372 install_element(ENABLE_NODE, &no_debug_bgp_update_groups_cmd);
2373 install_element(CONFIG_NODE, &no_debug_bgp_update_groups_cmd);
2374 install_element(ENABLE_NODE, &no_debug_bgp_cmd);
2375 install_element(ENABLE_NODE, &no_debug_bgp_bestpath_cmd);
2376 install_element(CONFIG_NODE, &no_debug_bgp_bestpath_cmd);
2377 install_element(ENABLE_NODE, &no_debug_bgp_bestpath_prefix_cmd);
2378 install_element(CONFIG_NODE, &no_debug_bgp_bestpath_prefix_cmd);
ddb5b488 2379
794b37d5 2380 install_element(ENABLE_NODE, &no_debug_bgp_graceful_restart_cmd);
2381 install_element(CONFIG_NODE, &no_debug_bgp_graceful_restart_cmd);
2382
ddb5b488
PZ		 2383 install_element(ENABLE_NODE, &debug_bgp_vpn_cmd);
2384 install_element(CONFIG_NODE, &debug_bgp_vpn_cmd);
2385 install_element(ENABLE_NODE, &no_debug_bgp_vpn_cmd);
2386 install_element(CONFIG_NODE, &no_debug_bgp_vpn_cmd);
955bfd98
PZ		 2387
2388 install_element(ENABLE_NODE, &debug_bgp_labelpool_cmd);
2389 install_element(CONFIG_NODE, &debug_bgp_labelpool_cmd);
2390 install_element(ENABLE_NODE, &no_debug_bgp_labelpool_cmd);
2391 install_element(CONFIG_NODE, &no_debug_bgp_labelpool_cmd);
1a80fc0f
PG		 2392
2393 /* debug bgp pbr */
2394 install_element(ENABLE_NODE, &debug_bgp_pbr_cmd);
2395 install_element(CONFIG_NODE, &debug_bgp_pbr_cmd);
2396 install_element(ENABLE_NODE, &no_debug_bgp_pbr_cmd);
2397 install_element(CONFIG_NODE, &no_debug_bgp_pbr_cmd);
2398
d62a17ae 2399}
16286195 2400
d62a17ae 2401/* Return true if this prefix is on the per_prefix_list of prefixes to debug
2402 * for BGP_DEBUG_TYPE
2403 */
2404static int bgp_debug_per_prefix(struct prefix *p,
2405 unsigned long term_bgp_debug_type,
2406 unsigned int BGP_DEBUG_TYPE,
2407 struct list *per_prefix_list)
2408{
2409 struct bgp_debug_filter *filter;
2410 struct listnode *node, *nnode;
2411
2412 if (term_bgp_debug_type & BGP_DEBUG_TYPE) {
2413 /* We are debugging all prefixes so return true */
2414 if (!per_prefix_list || list_isempty(per_prefix_list))
2415 return 1;
2416
2417 else {
2418 if (!p)
2419 return 0;
2420
2421 for (ALL_LIST_ELEMENTS(per_prefix_list, node, nnode,
2422 filter))
2423 if (filter->p->prefixlen == p->prefixlen
2424 && prefix_match(filter->p, p))
2425 return 1;
2426
2427 return 0;
2428 }
2429 }
2430
2431 return 0;
16286195
DS		 2432}
2433
2434/* Return true if this peer is on the per_peer_list of peers to debug
2435 * for BGP_DEBUG_TYPE
2436 */
d62a17ae 2437static int bgp_debug_per_peer(char *host, unsigned long term_bgp_debug_type,
2438 unsigned int BGP_DEBUG_TYPE,
2439 struct list *per_peer_list)
16286195 2440{
d62a17ae 2441 struct bgp_debug_filter *filter;
2442 struct listnode *node, *nnode;
16286195 2443
d62a17ae 2444 if (term_bgp_debug_type & BGP_DEBUG_TYPE) {
2445 /* We are debugging all peers so return true */
2446 if (!per_peer_list || list_isempty(per_peer_list))
2447 return 1;
16286195 2448
d62a17ae 2449 else {
2450 if (!host)
2451 return 0;
16286195 2452
d62a17ae 2453 for (ALL_LIST_ELEMENTS(per_peer_list, node, nnode,
2454 filter))
2455 if (strcmp(filter->host, host) == 0)
2456 return 1;
16286195 2457
d62a17ae 2458 return 0;
2459 }
2460 }
16286195 2461
d62a17ae 2462 return 0;
16286195
DS		 2463}
2464
d62a17ae 2465int bgp_debug_neighbor_events(struct peer *peer)
16286195 2466{
d62a17ae 2467 char *host = NULL;
167d390a 2468
d62a17ae 2469 if (peer)
2470 host = peer->host;
167d390a 2471
d62a17ae 2472 return bgp_debug_per_peer(host, term_bgp_debug_neighbor_events,
2473 BGP_DEBUG_NEIGHBOR_EVENTS,
2474 bgp_debug_neighbor_events_peers);
16286195
DS		 2475}
2476
d62a17ae 2477int bgp_debug_keepalive(struct peer *peer)
16286195 2478{
d62a17ae 2479 char *host = NULL;
167d390a 2480
d62a17ae 2481 if (peer)
2482 host = peer->host;
167d390a 2483
d62a17ae 2484 return bgp_debug_per_peer(host, term_bgp_debug_keepalive,
2485 BGP_DEBUG_KEEPALIVE,
2486 bgp_debug_keepalive_peers);
16286195
DS		 2487}
2488
d62a17ae 2489int bgp_debug_update(struct peer *peer, struct prefix *p,
2490 struct update_group *updgrp, unsigned int inbound)
16286195 2491{
d62a17ae 2492 char *host = NULL;
2493
2494 if (peer)
2495 host = peer->host;
2496
2497 if (inbound) {
2498 if (bgp_debug_per_peer(host, term_bgp_debug_update,
2499 BGP_DEBUG_UPDATE_IN,
2500 bgp_debug_update_in_peers))
2501 return 1;
2502 }
2503
2504 /* outbound */
2505 else {
2506 if (bgp_debug_per_peer(host, term_bgp_debug_update,
2507 BGP_DEBUG_UPDATE_OUT,
2508 bgp_debug_update_out_peers))
2509 return 1;
2510
2511 /* Check if update debugging implicitly enabled for the group.
2512 */
2513 if (updgrp && UPDGRP_DBG_ON(updgrp))
2514 return 1;
2515 }
2516
2517
2518 if (BGP_DEBUG(update, UPDATE_PREFIX)) {
2519 if (bgp_debug_per_prefix(p, term_bgp_debug_update,
2520 BGP_DEBUG_UPDATE_PREFIX,
2521 bgp_debug_update_prefixes))
2522 return 1;
2523 }
2524
2525 return 0;
16286195
DS		 2526}
2527
d62a17ae 2528int bgp_debug_bestpath(struct prefix *p)
9fbdd100 2529{
d62a17ae 2530 if (BGP_DEBUG(bestpath, BESTPATH)) {
2531 if (bgp_debug_per_prefix(p, term_bgp_debug_bestpath,
2532 BGP_DEBUG_BESTPATH,
2533 bgp_debug_bestpath_prefixes))
2534 return 1;
2535 }
2536
2537 return 0;
9fbdd100
DS		 2538}
2539
d62a17ae 2540int bgp_debug_zebra(struct prefix *p)
16286195 2541{
d62a17ae 2542 if (BGP_DEBUG(zebra, ZEBRA)) {
2543 if (bgp_debug_per_prefix(p, term_bgp_debug_zebra,
2544 BGP_DEBUG_ZEBRA,
2545 bgp_debug_zebra_prefixes))
2546 return 1;
2547 }
2548
2549 return 0;
718e3744 2550}
906ad49b 2551
d62a17ae 2552const char *bgp_debug_rdpfxpath2str(afi_t afi, safi_t safi,
2553 struct prefix_rd *prd,
2554 union prefixconstptr pu,
d7c0a89a
QY		 2555 mpls_label_t *label, uint32_t num_labels,
2556 int addpath_valid, uint32_t addpath_id,
b57ba6d2 2557 char *str, int size)
d62a17ae 2558{
2559 char rd_buf[RD_ADDRSTRLEN];
2560 char pfx_buf[PREFIX_STRLEN];
2561 char tag_buf[30];
2562 /* ' with addpath ID ' 17
2563 * max strlen of uint32 + 10
2564 * +/- (just in case) + 1
2565 * null terminator + 1
2566 * ============================ 29 */
2567 char pathid_buf[30];
2568
2569 if (size < BGP_PRD_PATH_STRLEN)
2570 return NULL;
2571
2572 /* Note: Path-id is created by default, but only included in update
2573 * sometimes. */
2574 pathid_buf[0] = '\0';
2575 if (addpath_valid)
2576 snprintf(pathid_buf, sizeof(pathid_buf), " with addpath ID %u",
2577 addpath_id);
2578
2579 tag_buf[0] = '\0';
b57ba6d2 2580 if (bgp_labeled_safi(safi) && num_labels) {
d62a17ae 2581
b57ba6d2
MK		 2582 if (safi == SAFI_EVPN) {
2583 char tag_buf2[20];
2584
2585 bgp_evpn_label2str(label, num_labels, tag_buf2, 20);
2586 sprintf(tag_buf, " label %s", tag_buf2);
2587 } else {
d7c0a89a 2588 uint32_t label_value;
b57ba6d2
MK		 2589
2590 label_value = decode_label(label);
2591 sprintf(tag_buf, " label %u", label_value);
2592 }
d62a17ae 2593 }
2594
2595 if (prd)
e1af3f16 2596 snprintf(str, size, "RD %s %s%s%s %s %s",
d62a17ae 2597 prefix_rd2str(prd, rd_buf, sizeof(rd_buf)),
2598 prefix2str(pu, pfx_buf, sizeof(pfx_buf)), tag_buf,
e1af3f16 2599 pathid_buf, afi2str(afi), safi2str(safi));
268e1b9b
PG		 2600 else if (safi == SAFI_FLOWSPEC) {
2601 char return_string[BGP_FLOWSPEC_NLRI_STRING_MAX];
2602 const struct prefix_fs *fs = pu.fs;
2603
2604 bgp_fs_nlri_get_string((unsigned char *)fs->prefix.ptr,
2605 fs->prefix.prefixlen,
2606 return_string,
d33fc23b 2607 NLRI_STRING_FORMAT_DEBUG, NULL);
268e1b9b
PG		 2608 snprintf(str, size, "FS %s Match{%s}", afi2str(afi),
2609 return_string);
2610 } else
e1af3f16 2611 snprintf(str, size, "%s%s%s %s %s",
d62a17ae 2612 prefix2str(pu, pfx_buf, sizeof(pfx_buf)), tag_buf,
e1af3f16 2613 pathid_buf, afi2str(afi), safi2str(safi));
d62a17ae 2614
2615 return str;
906ad49b 2616}
FRRouting mirror