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