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