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