]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_vty.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12179 from LabNConsulting/working/lb/p2mp-improvements
[mirror_frr.git] / bgpd / bgp_vty.c
1 /* BGP VTY interface.
2 * Copyright (C) 1996, 97, 98, 99, 2000 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 "command.h"
24 #include "lib/json.h"
25 #include "lib/sockopt.h"
26 #include "lib_errors.h"
27 #include "lib/zclient.h"
28 #include "lib/printfrr.h"
29 #include "prefix.h"
30 #include "plist.h"
31 #include "buffer.h"
32 #include "linklist.h"
33 #include "stream.h"
34 #include "thread.h"
35 #include "log.h"
36 #include "memory.h"
37 #include "lib_vty.h"
38 #include "hash.h"
39 #include "queue.h"
40 #include "filter.h"
41 #include "frrstr.h"
42
43 #include "bgpd/bgpd.h"
44 #include "bgpd/bgp_attr_evpn.h"
45 #include "bgpd/bgp_advertise.h"
46 #include "bgpd/bgp_attr.h"
47 #include "bgpd/bgp_aspath.h"
48 #include "bgpd/bgp_community.h"
49 #include "bgpd/bgp_community_alias.h"
50 #include "bgpd/bgp_ecommunity.h"
51 #include "bgpd/bgp_lcommunity.h"
52 #include "bgpd/bgp_damp.h"
53 #include "bgpd/bgp_debug.h"
54 #include "bgpd/bgp_errors.h"
55 #include "bgpd/bgp_fsm.h"
56 #include "bgpd/bgp_nht.h"
57 #include "bgpd/bgp_nexthop.h"
58 #include "bgpd/bgp_network.h"
59 #include "bgpd/bgp_open.h"
60 #include "bgpd/bgp_regex.h"
61 #include "bgpd/bgp_route.h"
62 #include "bgpd/bgp_mplsvpn.h"
63 #include "bgpd/bgp_zebra.h"
64 #include "bgpd/bgp_table.h"
65 #include "bgpd/bgp_vty.h"
66 #include "bgpd/bgp_mpath.h"
67 #include "bgpd/bgp_packet.h"
68 #include "bgpd/bgp_updgrp.h"
69 #include "bgpd/bgp_bfd.h"
70 #include "bgpd/bgp_io.h"
71 #include "bgpd/bgp_evpn.h"
72 #include "bgpd/bgp_evpn_vty.h"
73 #include "bgpd/bgp_evpn_mh.h"
74 #include "bgpd/bgp_addpath.h"
75 #include "bgpd/bgp_mac.h"
76 #include "bgpd/bgp_flowspec.h"
77 #include "bgpd/bgp_conditional_adv.h"
78 #ifdef ENABLE_BGP_VNC
79 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
80 #endif
81 #include "bgpd/bgp_orr.h"
82
83
84 FRR_CFG_DEFAULT_BOOL(BGP_IMPORT_CHECK,
85 {
86 .val_bool = false,
87 .match_profile = "traditional",
88 .match_version = "< 7.4",
89 },
90 { .val_bool = true },
91 );
92 FRR_CFG_DEFAULT_BOOL(BGP_SHOW_HOSTNAME,
93 { .val_bool = true, .match_profile = "datacenter", },
94 { .val_bool = false },
95 );
96 FRR_CFG_DEFAULT_BOOL(BGP_SHOW_NEXTHOP_HOSTNAME,
97 { .val_bool = true, .match_profile = "datacenter", },
98 { .val_bool = false },
99 );
100 FRR_CFG_DEFAULT_BOOL(BGP_LOG_NEIGHBOR_CHANGES,
101 { .val_bool = true, .match_profile = "datacenter", },
102 { .val_bool = false },
103 );
104 FRR_CFG_DEFAULT_BOOL(BGP_DETERMINISTIC_MED,
105 { .val_bool = true, .match_profile = "datacenter", },
106 { .val_bool = false },
107 );
108 FRR_CFG_DEFAULT_ULONG(BGP_CONNECT_RETRY,
109 { .val_ulong = 10, .match_profile = "datacenter", },
110 { .val_ulong = 120 },
111 );
112 FRR_CFG_DEFAULT_ULONG(BGP_HOLDTIME,
113 { .val_ulong = 9, .match_profile = "datacenter", },
114 { .val_ulong = 180 },
115 );
116 FRR_CFG_DEFAULT_ULONG(BGP_KEEPALIVE,
117 { .val_ulong = 3, .match_profile = "datacenter", },
118 { .val_ulong = 60 },
119 );
120 FRR_CFG_DEFAULT_BOOL(BGP_EBGP_REQUIRES_POLICY,
121 { .val_bool = false, .match_profile = "datacenter", },
122 { .val_bool = false, .match_version = "< 7.4", },
123 { .val_bool = true },
124 );
125 FRR_CFG_DEFAULT_BOOL(BGP_SUPPRESS_DUPLICATES,
126 { .val_bool = false, .match_version = "< 7.6", },
127 { .val_bool = true },
128 );
129 FRR_CFG_DEFAULT_BOOL(BGP_GRACEFUL_NOTIFICATION,
130 { .val_bool = false, .match_version = "< 8.3", },
131 { .val_bool = true },
132 );
133 FRR_CFG_DEFAULT_BOOL(BGP_HARD_ADMIN_RESET,
134 { .val_bool = false, .match_version = "< 8.3", },
135 { .val_bool = true },
136 );
137
138 DEFINE_HOOK(bgp_inst_config_write,
139 (struct bgp *bgp, struct vty *vty),
140 (bgp, vty));
141 DEFINE_HOOK(bgp_snmp_update_last_changed, (struct bgp *bgp), (bgp));
142 DEFINE_HOOK(bgp_snmp_init_stats, (struct bgp *bgp), (bgp));
143
144 static struct peer_group *listen_range_exists(struct bgp *bgp,
145 struct prefix *range, int exact);
146
147 /* Show BGP peer's information. */
148 enum show_type {
149 show_all,
150 show_peer,
151 show_ipv4_all,
152 show_ipv6_all,
153 show_ipv4_peer,
154 show_ipv6_peer
155 };
156
157 static struct peer_group *listen_range_exists(struct bgp *bgp,
158 struct prefix *range, int exact);
159
160 static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
161 struct bgp *bgp,
162 bool use_json,
163 json_object *json);
164
165 static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
166 enum show_type type,
167 const char *ip_str,
168 afi_t afi, bool use_json);
169
170 static enum node_type bgp_node_type(afi_t afi, safi_t safi)
171 {
172 switch (afi) {
173 case AFI_IP:
174 switch (safi) {
175 case SAFI_UNICAST:
176 return BGP_IPV4_NODE;
177 case SAFI_MULTICAST:
178 return BGP_IPV4M_NODE;
179 case SAFI_LABELED_UNICAST:
180 return BGP_IPV4L_NODE;
181 case SAFI_MPLS_VPN:
182 return BGP_VPNV4_NODE;
183 case SAFI_FLOWSPEC:
184 return BGP_FLOWSPECV4_NODE;
185 default:
186 /* not expected */
187 return BGP_IPV4_NODE;
188 }
189 case AFI_IP6:
190 switch (safi) {
191 case SAFI_UNICAST:
192 return BGP_IPV6_NODE;
193 case SAFI_MULTICAST:
194 return BGP_IPV6M_NODE;
195 case SAFI_LABELED_UNICAST:
196 return BGP_IPV6L_NODE;
197 case SAFI_MPLS_VPN:
198 return BGP_VPNV6_NODE;
199 case SAFI_FLOWSPEC:
200 return BGP_FLOWSPECV6_NODE;
201 default:
202 /* not expected */
203 return BGP_IPV4_NODE;
204 }
205 case AFI_L2VPN:
206 return BGP_EVPN_NODE;
207 case AFI_UNSPEC:
208 case AFI_MAX:
209 // We should never be here but to clarify the switch statement..
210 return BGP_IPV4_NODE;
211 }
212
213 // Impossible to happen
214 return BGP_IPV4_NODE;
215 }
216
217 static const char *get_afi_safi_vty_str(afi_t afi, safi_t safi)
218 {
219 if (afi == AFI_IP) {
220 if (safi == SAFI_UNICAST)
221 return "IPv4 Unicast";
222 if (safi == SAFI_MULTICAST)
223 return "IPv4 Multicast";
224 if (safi == SAFI_LABELED_UNICAST)
225 return "IPv4 Labeled Unicast";
226 if (safi == SAFI_MPLS_VPN)
227 return "IPv4 VPN";
228 if (safi == SAFI_ENCAP)
229 return "IPv4 Encap";
230 if (safi == SAFI_FLOWSPEC)
231 return "IPv4 Flowspec";
232 } else if (afi == AFI_IP6) {
233 if (safi == SAFI_UNICAST)
234 return "IPv6 Unicast";
235 if (safi == SAFI_MULTICAST)
236 return "IPv6 Multicast";
237 if (safi == SAFI_LABELED_UNICAST)
238 return "IPv6 Labeled Unicast";
239 if (safi == SAFI_MPLS_VPN)
240 return "IPv6 VPN";
241 if (safi == SAFI_ENCAP)
242 return "IPv6 Encap";
243 if (safi == SAFI_FLOWSPEC)
244 return "IPv6 Flowspec";
245 } else if (afi == AFI_L2VPN) {
246 if (safi == SAFI_EVPN)
247 return "L2VPN EVPN";
248 }
249
250 return "Unknown";
251 }
252
253 /*
254 * Please note that we have intentionally camelCased
255 * the return strings here. So if you want
256 * to use this function, please ensure you
257 * are doing this within json output
258 */
259 static const char *get_afi_safi_json_str(afi_t afi, safi_t safi)
260 {
261 if (afi == AFI_IP) {
262 if (safi == SAFI_UNICAST)
263 return "ipv4Unicast";
264 if (safi == SAFI_MULTICAST)
265 return "ipv4Multicast";
266 if (safi == SAFI_LABELED_UNICAST)
267 return "ipv4LabeledUnicast";
268 if (safi == SAFI_MPLS_VPN)
269 return "ipv4Vpn";
270 if (safi == SAFI_ENCAP)
271 return "ipv4Encap";
272 if (safi == SAFI_FLOWSPEC)
273 return "ipv4Flowspec";
274 } else if (afi == AFI_IP6) {
275 if (safi == SAFI_UNICAST)
276 return "ipv6Unicast";
277 if (safi == SAFI_MULTICAST)
278 return "ipv6Multicast";
279 if (safi == SAFI_LABELED_UNICAST)
280 return "ipv6LabeledUnicast";
281 if (safi == SAFI_MPLS_VPN)
282 return "ipv6Vpn";
283 if (safi == SAFI_ENCAP)
284 return "ipv6Encap";
285 if (safi == SAFI_FLOWSPEC)
286 return "ipv6Flowspec";
287 } else if (afi == AFI_L2VPN) {
288 if (safi == SAFI_EVPN)
289 return "l2VpnEvpn";
290 }
291
292 return "Unknown";
293 }
294
295 /* unset srv6 locator */
296 static int bgp_srv6_locator_unset(struct bgp *bgp)
297 {
298 int ret;
299 struct listnode *node, *nnode;
300 struct srv6_locator_chunk *chunk, *tovpn_sid_locator;
301 struct bgp_srv6_function *func;
302 struct bgp *bgp_vrf;
303
304 /* release chunk notification via ZAPI */
305 ret = bgp_zebra_srv6_manager_release_locator_chunk(
306 bgp->srv6_locator_name);
307 if (ret < 0)
308 return -1;
309
310 /* refresh chunks */
311 for (ALL_LIST_ELEMENTS(bgp->srv6_locator_chunks, node, nnode, chunk)) {
312 listnode_delete(bgp->srv6_locator_chunks, chunk);
313 srv6_locator_chunk_free(chunk);
314 }
315
316 /* refresh functions */
317 for (ALL_LIST_ELEMENTS(bgp->srv6_functions, node, nnode, func)) {
318 listnode_delete(bgp->srv6_functions, func);
319 XFREE(MTYPE_BGP_SRV6_FUNCTION, func);
320 }
321
322 /* refresh tovpn_sid */
323 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
324 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
325 continue;
326
327 /* refresh vpnv4 tovpn_sid */
328 XFREE(MTYPE_BGP_SRV6_SID,
329 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid);
330
331 /* refresh vpnv6 tovpn_sid */
332 XFREE(MTYPE_BGP_SRV6_SID,
333 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid);
334
335 /* refresh per-vrf tovpn_sid */
336 XFREE(MTYPE_BGP_SRV6_SID, bgp_vrf->tovpn_sid);
337 }
338
339 /* update vpn bgp processes */
340 vpn_leak_postchange_all();
341
342 /* refresh tovpn_sid_locator */
343 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
344 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
345 continue;
346
347 /* refresh vpnv4 tovpn_sid_locator */
348 tovpn_sid_locator =
349 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid_locator;
350 if (tovpn_sid_locator) {
351 srv6_locator_chunk_free(tovpn_sid_locator);
352 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid_locator = NULL;
353 }
354
355 /* refresh vpnv6 tovpn_sid_locator */
356 tovpn_sid_locator =
357 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid_locator;
358 if (tovpn_sid_locator) {
359 srv6_locator_chunk_free(tovpn_sid_locator);
360 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid_locator = NULL;
361 }
362
363 /* refresh per-vrf tovpn_sid_locator */
364 srv6_locator_chunk_free(bgp_vrf->tovpn_sid_locator);
365 }
366
367 /* clear locator name */
368 memset(bgp->srv6_locator_name, 0, sizeof(bgp->srv6_locator_name));
369
370 return 0;
371 }
372
373 /* Utility function to get address family from current node. */
374 afi_t bgp_node_afi(struct vty *vty)
375 {
376 afi_t afi;
377 switch (vty->node) {
378 case BGP_IPV6_NODE:
379 case BGP_IPV6M_NODE:
380 case BGP_IPV6L_NODE:
381 case BGP_VPNV6_NODE:
382 case BGP_FLOWSPECV6_NODE:
383 afi = AFI_IP6;
384 break;
385 case BGP_EVPN_NODE:
386 afi = AFI_L2VPN;
387 break;
388 default:
389 afi = AFI_IP;
390 break;
391 }
392 return afi;
393 }
394
395 /* Utility function to get subsequent address family from current
396 node. */
397 safi_t bgp_node_safi(struct vty *vty)
398 {
399 safi_t safi;
400 switch (vty->node) {
401 case BGP_VPNV4_NODE:
402 case BGP_VPNV6_NODE:
403 safi = SAFI_MPLS_VPN;
404 break;
405 case BGP_IPV4M_NODE:
406 case BGP_IPV6M_NODE:
407 safi = SAFI_MULTICAST;
408 break;
409 case BGP_EVPN_NODE:
410 safi = SAFI_EVPN;
411 break;
412 case BGP_IPV4L_NODE:
413 case BGP_IPV6L_NODE:
414 safi = SAFI_LABELED_UNICAST;
415 break;
416 case BGP_FLOWSPECV4_NODE:
417 case BGP_FLOWSPECV6_NODE:
418 safi = SAFI_FLOWSPEC;
419 break;
420 default:
421 safi = SAFI_UNICAST;
422 break;
423 }
424 return safi;
425 }
426
427 /**
428 * Converts an AFI in string form to afi_t
429 *
430 * @param afi string, one of
431 * - "ipv4"
432 * - "ipv6"
433 * - "l2vpn"
434 * @return the corresponding afi_t
435 */
436 afi_t bgp_vty_afi_from_str(const char *afi_str)
437 {
438 afi_t afi = AFI_MAX; /* unknown */
439 if (strmatch(afi_str, "ipv4"))
440 afi = AFI_IP;
441 else if (strmatch(afi_str, "ipv6"))
442 afi = AFI_IP6;
443 else if (strmatch(afi_str, "l2vpn"))
444 afi = AFI_L2VPN;
445 return afi;
446 }
447
448 int argv_find_and_parse_afi(struct cmd_token **argv, int argc, int *index,
449 afi_t *afi)
450 {
451 int ret = 0;
452 if (argv_find(argv, argc, "ipv4", index)) {
453 ret = 1;
454 if (afi)
455 *afi = AFI_IP;
456 } else if (argv_find(argv, argc, "ipv6", index)) {
457 ret = 1;
458 if (afi)
459 *afi = AFI_IP6;
460 } else if (argv_find(argv, argc, "l2vpn", index)) {
461 ret = 1;
462 if (afi)
463 *afi = AFI_L2VPN;
464 }
465 return ret;
466 }
467
468 /* supports <unicast|multicast|vpn|labeled-unicast> */
469 safi_t bgp_vty_safi_from_str(const char *safi_str)
470 {
471 safi_t safi = SAFI_MAX; /* unknown */
472 if (strmatch(safi_str, "multicast"))
473 safi = SAFI_MULTICAST;
474 else if (strmatch(safi_str, "unicast"))
475 safi = SAFI_UNICAST;
476 else if (strmatch(safi_str, "vpn"))
477 safi = SAFI_MPLS_VPN;
478 else if (strmatch(safi_str, "evpn"))
479 safi = SAFI_EVPN;
480 else if (strmatch(safi_str, "labeled-unicast"))
481 safi = SAFI_LABELED_UNICAST;
482 else if (strmatch(safi_str, "flowspec"))
483 safi = SAFI_FLOWSPEC;
484 return safi;
485 }
486
487 int argv_find_and_parse_safi(struct cmd_token **argv, int argc, int *index,
488 safi_t *safi)
489 {
490 int ret = 0;
491 if (argv_find(argv, argc, "unicast", index)) {
492 ret = 1;
493 if (safi)
494 *safi = SAFI_UNICAST;
495 } else if (argv_find(argv, argc, "multicast", index)) {
496 ret = 1;
497 if (safi)
498 *safi = SAFI_MULTICAST;
499 } else if (argv_find(argv, argc, "labeled-unicast", index)) {
500 ret = 1;
501 if (safi)
502 *safi = SAFI_LABELED_UNICAST;
503 } else if (argv_find(argv, argc, "vpn", index)) {
504 ret = 1;
505 if (safi)
506 *safi = SAFI_MPLS_VPN;
507 } else if (argv_find(argv, argc, "evpn", index)) {
508 ret = 1;
509 if (safi)
510 *safi = SAFI_EVPN;
511 } else if (argv_find(argv, argc, "flowspec", index)) {
512 ret = 1;
513 if (safi)
514 *safi = SAFI_FLOWSPEC;
515 }
516 return ret;
517 }
518
519 /*
520 * Convert an afi_t/safi_t pair to matching BGP_DEFAULT_AF* flag.
521 *
522 * afi
523 * address-family identifier
524 *
525 * safi
526 * subsequent address-family identifier
527 *
528 * Returns:
529 * default_af string corresponding to the supplied afi/safi pair.
530 * If afi/safi is invalid or if flag for afi/safi doesn't exist,
531 * return -1.
532 */
533 static const char *get_bgp_default_af_flag(afi_t afi, safi_t safi)
534 {
535 switch (afi) {
536 case AFI_IP:
537 switch (safi) {
538 case SAFI_UNICAST:
539 return "ipv4-unicast";
540 case SAFI_MULTICAST:
541 return "ipv4-multicast";
542 case SAFI_MPLS_VPN:
543 return "ipv4-vpn";
544 case SAFI_ENCAP:
545 return "ipv4-encap";
546 case SAFI_LABELED_UNICAST:
547 return "ipv4-labeled-unicast";
548 case SAFI_FLOWSPEC:
549 return "ipv4-flowspec";
550 default:
551 return "unknown-afi/safi";
552 }
553 break;
554 case AFI_IP6:
555 switch (safi) {
556 case SAFI_UNICAST:
557 return "ipv6-unicast";
558 case SAFI_MULTICAST:
559 return "ipv6-multicast";
560 case SAFI_MPLS_VPN:
561 return "ipv6-vpn";
562 case SAFI_ENCAP:
563 return "ipv6-encap";
564 case SAFI_LABELED_UNICAST:
565 return "ipv6-labeled-unicast";
566 case SAFI_FLOWSPEC:
567 return "ipv6-flowspec";
568 default:
569 return "unknown-afi/safi";
570 }
571 break;
572 case AFI_L2VPN:
573 switch (safi) {
574 case SAFI_EVPN:
575 return "l2vpn-evpn";
576 default:
577 return "unknown-afi/safi";
578 }
579 case AFI_UNSPEC:
580 case AFI_MAX:
581 return "unknown-afi/safi";
582 }
583 /* all AFIs are accounted for above, so this shouldn't happen */
584 return "unknown-afi/safi";
585 }
586
587 int bgp_get_vty(struct bgp **bgp, as_t *as, const char *name,
588 enum bgp_instance_type inst_type)
589 {
590 int ret = bgp_get(bgp, as, name, inst_type);
591
592 if (ret == BGP_CREATED) {
593 bgp_timers_set(*bgp, DFLT_BGP_KEEPALIVE, DFLT_BGP_HOLDTIME,
594 DFLT_BGP_CONNECT_RETRY, BGP_DEFAULT_DELAYOPEN);
595
596 if (DFLT_BGP_IMPORT_CHECK)
597 SET_FLAG((*bgp)->flags, BGP_FLAG_IMPORT_CHECK);
598 if (DFLT_BGP_SHOW_HOSTNAME)
599 SET_FLAG((*bgp)->flags, BGP_FLAG_SHOW_HOSTNAME);
600 if (DFLT_BGP_SHOW_NEXTHOP_HOSTNAME)
601 SET_FLAG((*bgp)->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
602 if (DFLT_BGP_LOG_NEIGHBOR_CHANGES)
603 SET_FLAG((*bgp)->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
604 if (DFLT_BGP_DETERMINISTIC_MED)
605 SET_FLAG((*bgp)->flags, BGP_FLAG_DETERMINISTIC_MED);
606 if (DFLT_BGP_EBGP_REQUIRES_POLICY)
607 SET_FLAG((*bgp)->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
608 if (DFLT_BGP_SUPPRESS_DUPLICATES)
609 SET_FLAG((*bgp)->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
610 if (DFLT_BGP_GRACEFUL_NOTIFICATION)
611 SET_FLAG((*bgp)->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
612 if (DFLT_BGP_HARD_ADMIN_RESET)
613 SET_FLAG((*bgp)->flags, BGP_FLAG_HARD_ADMIN_RESET);
614
615 ret = BGP_SUCCESS;
616 }
617 return ret;
618 }
619
620 /*
621 * bgp_vty_find_and_parse_afi_safi_bgp
622 *
623 * For a given 'show ...' command, correctly parse the afi/safi/bgp out from it
624 * This function *assumes* that the calling function pre-sets the afi/safi/bgp
625 * to appropriate values for the calling function. This is to allow the
626 * calling function to make decisions appropriate for the show command
627 * that is being parsed.
628 *
629 * The show commands are generally of the form:
630 * "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>
631 * [<unicast|multicast|vpn|labeled-unicast>]] ..."
632 *
633 * Since we use argv_find if the show command in particular doesn't have:
634 * [ip]
635 * [<view|vrf> VIEWVRFNAME]
636 * [<ipv4|ipv6> [<unicast|multicast|vpn|labeled-unicast>]]
637 * The command parsing should still be ok.
638 *
639 * vty -> The vty for the command so we can output some useful data in
640 * the event of a parse error in the vrf.
641 * argv -> The command tokens
642 * argc -> How many command tokens we have
643 * idx -> The current place in the command, generally should be 0 for this
644 * function
645 * afi -> The parsed afi if it was included in the show command, returned here
646 * safi -> The parsed safi if it was included in the show command, returned here
647 * bgp -> Pointer to the bgp data structure we need to fill in.
648 * use_json -> json is configured or not
649 *
650 * The function returns the correct location in the parse tree for the
651 * last token found.
652 *
653 * Returns 0 for failure to parse correctly, else the idx position of where
654 * it found the last token.
655 */
656 int bgp_vty_find_and_parse_afi_safi_bgp(struct vty *vty,
657 struct cmd_token **argv, int argc,
658 int *idx, afi_t *afi, safi_t *safi,
659 struct bgp **bgp, bool use_json)
660 {
661 char *vrf_name = NULL;
662
663 assert(afi);
664 assert(safi);
665 assert(bgp);
666
667 if (argv_find(argv, argc, "ip", idx))
668 *afi = AFI_IP;
669
670 if (argv_find(argv, argc, "view", idx))
671 vrf_name = argv[*idx + 1]->arg;
672 else if (argv_find(argv, argc, "vrf", idx)) {
673 vrf_name = argv[*idx + 1]->arg;
674 if (strmatch(vrf_name, VRF_DEFAULT_NAME))
675 vrf_name = NULL;
676 }
677 if (vrf_name) {
678 if (strmatch(vrf_name, "all"))
679 *bgp = NULL;
680 else {
681 *bgp = bgp_lookup_by_name(vrf_name);
682 if (!*bgp) {
683 if (use_json) {
684 json_object *json = NULL;
685 json = json_object_new_object();
686 json_object_string_add(
687 json, "warning",
688 "View/Vrf is unknown");
689 vty_json(vty, json);
690 }
691 else
692 vty_out(vty, "View/Vrf %s is unknown\n",
693 vrf_name);
694 *idx = 0;
695 return 0;
696 }
697 }
698 } else {
699 *bgp = bgp_get_default();
700 if (!*bgp) {
701 if (use_json) {
702 json_object *json = NULL;
703 json = json_object_new_object();
704 json_object_string_add(
705 json, "warning",
706 "Default BGP instance not found");
707 vty_json(vty, json);
708 }
709 else
710 vty_out(vty,
711 "Default BGP instance not found\n");
712 *idx = 0;
713 return 0;
714 }
715 }
716
717 if (argv_find_and_parse_afi(argv, argc, idx, afi))
718 argv_find_and_parse_safi(argv, argc, idx, safi);
719
720 *idx += 1;
721 return *idx;
722 }
723
724 static bool peer_address_self_check(struct bgp *bgp, union sockunion *su)
725 {
726 struct interface *ifp = NULL;
727 struct listnode *node;
728 struct bgp_listener *listener;
729 union sockunion all_su;
730
731 if (su->sa.sa_family == AF_INET) {
732 (void)str2sockunion("0.0.0.0", &all_su);
733 ifp = if_lookup_by_ipv4_exact(&su->sin.sin_addr, bgp->vrf_id);
734 } else if (su->sa.sa_family == AF_INET6) {
735 (void)str2sockunion("::", &all_su);
736 ifp = if_lookup_by_ipv6_exact(&su->sin6.sin6_addr,
737 su->sin6.sin6_scope_id,
738 bgp->vrf_id);
739 }
740
741 if (ifp) {
742 for (ALL_LIST_ELEMENTS_RO(bm->listen_sockets, node, listener)) {
743 if (sockunion_family(su) !=
744 sockunion_family(&listener->su))
745 continue;
746
747 /* If 0.0.0.0/:: is a listener, then treat as self and
748 * reject.
749 */
750 if (!sockunion_cmp(&listener->su, su) ||
751 !sockunion_cmp(&listener->su, &all_su))
752 return true;
753 }
754 }
755
756 return false;
757 }
758
759 /* Utility function for looking up peer from VTY. */
760 /* This is used only for configuration, so disallow if attempted on
761 * a dynamic neighbor.
762 */
763 static struct peer *peer_lookup_vty(struct vty *vty, const char *ip_str)
764 {
765 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
766 int ret;
767 union sockunion su;
768 struct peer *peer;
769
770 if (!bgp) {
771 return NULL;
772 }
773
774 ret = str2sockunion(ip_str, &su);
775 if (ret < 0) {
776 peer = peer_lookup_by_conf_if(bgp, ip_str);
777 if (!peer) {
778 if ((peer = peer_lookup_by_hostname(bgp, ip_str))
779 == NULL) {
780 vty_out(vty,
781 "%% Malformed address or name: %s\n",
782 ip_str);
783 return NULL;
784 }
785 }
786 } else {
787 peer = peer_lookup(bgp, &su);
788 if (!peer) {
789 vty_out(vty,
790 "%% Specify remote-as or peer-group commands first\n");
791 return NULL;
792 }
793 if (peer_dynamic_neighbor(peer)) {
794 vty_out(vty,
795 "%% Operation not allowed on a dynamic neighbor\n");
796 return NULL;
797 }
798 }
799 return peer;
800 }
801
802 /* Utility function for looking up peer or peer group. */
803 /* This is used only for configuration, so disallow if attempted on
804 * a dynamic neighbor.
805 */
806 struct peer *peer_and_group_lookup_vty(struct vty *vty, const char *peer_str)
807 {
808 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
809 int ret;
810 union sockunion su;
811 struct peer *peer = NULL;
812 struct peer_group *group = NULL;
813
814 if (!bgp) {
815 return NULL;
816 }
817
818 ret = str2sockunion(peer_str, &su);
819 if (ret == 0) {
820 /* IP address, locate peer. */
821 peer = peer_lookup(bgp, &su);
822 } else {
823 /* Not IP, could match either peer configured on interface or a
824 * group. */
825 peer = peer_lookup_by_conf_if(bgp, peer_str);
826 if (!peer)
827 group = peer_group_lookup(bgp, peer_str);
828 }
829
830 if (peer) {
831 if (peer_dynamic_neighbor(peer)) {
832 vty_out(vty,
833 "%% Operation not allowed on a dynamic neighbor\n");
834 return NULL;
835 }
836
837 return peer;
838 }
839
840 if (group)
841 return group->conf;
842
843 vty_out(vty, "%% Specify remote-as or peer-group commands first\n");
844
845 return NULL;
846 }
847
848 int bgp_vty_return(struct vty *vty, enum bgp_create_error_code ret)
849 {
850 const char *str = NULL;
851
852 switch (ret) {
853 case BGP_SUCCESS:
854 case BGP_CREATED:
855 case BGP_GR_NO_OPERATION:
856 break;
857 case BGP_ERR_INVALID_VALUE:
858 str = "Invalid value";
859 break;
860 case BGP_ERR_INVALID_FLAG:
861 str = "Invalid flag";
862 break;
863 case BGP_ERR_PEER_GROUP_SHUTDOWN:
864 str = "Peer-group has been shutdown. Activate the peer-group first";
865 break;
866 case BGP_ERR_PEER_FLAG_CONFLICT:
867 str = "Can't set override-capability and strict-capability-match at the same time";
868 break;
869 case BGP_ERR_PEER_GROUP_NO_REMOTE_AS:
870 str = "Specify remote-as or peer-group remote AS first";
871 break;
872 case BGP_ERR_PEER_GROUP_CANT_CHANGE:
873 str = "Cannot change the peer-group. Deconfigure first";
874 break;
875 case BGP_ERR_PEER_GROUP_MISMATCH:
876 str = "Peer is not a member of this peer-group";
877 break;
878 case BGP_ERR_PEER_FILTER_CONFLICT:
879 str = "Prefix/distribute list can not co-exist";
880 break;
881 case BGP_ERR_NOT_INTERNAL_PEER:
882 str = "Invalid command. Not an internal neighbor";
883 break;
884 case BGP_ERR_REMOVE_PRIVATE_AS:
885 str = "remove-private-AS cannot be configured for IBGP peers";
886 break;
887 case BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS:
888 str = "Cannot have local-as same as BGP AS number";
889 break;
890 case BGP_ERR_TCPSIG_FAILED:
891 str = "Error while applying TCP-Sig to session(s)";
892 break;
893 case BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK:
894 str = "ebgp-multihop and ttl-security cannot be configured together";
895 break;
896 case BGP_ERR_NO_IBGP_WITH_TTLHACK:
897 str = "ttl-security only allowed for EBGP peers";
898 break;
899 case BGP_ERR_AS_OVERRIDE:
900 str = "as-override cannot be configured for IBGP peers";
901 break;
902 case BGP_ERR_INVALID_DYNAMIC_NEIGHBORS_LIMIT:
903 str = "Invalid limit for number of dynamic neighbors";
904 break;
905 case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_EXISTS:
906 str = "Dynamic neighbor listen range already exists";
907 break;
908 case BGP_ERR_INVALID_FOR_DYNAMIC_PEER:
909 str = "Operation not allowed on a dynamic neighbor";
910 break;
911 case BGP_ERR_INVALID_FOR_DIRECT_PEER:
912 str = "Operation not allowed on a directly connected neighbor";
913 break;
914 case BGP_ERR_PEER_SAFI_CONFLICT:
915 str = "Cannot activate peer for both 'ipv4 unicast' and 'ipv4 labeled-unicast'";
916 break;
917 case BGP_ERR_GR_INVALID_CMD:
918 str = "The Graceful Restart command used is not valid at this moment.";
919 break;
920 case BGP_ERR_GR_OPERATION_FAILED:
921 str = "The Graceful Restart Operation failed due to an err.";
922 break;
923 case BGP_ERR_PEER_GROUP_MEMBER:
924 str = "Peer-group member cannot override remote-as of peer-group.";
925 break;
926 case BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT:
927 str = "Peer-group members must be all internal or all external.";
928 break;
929 case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND:
930 str = "Range specified cannot be deleted because it is not part of current config.";
931 break;
932 case BGP_ERR_INSTANCE_MISMATCH:
933 str = "Instance specified does not match the current instance.";
934 break;
935 case BGP_ERR_NO_INTERFACE_CONFIG:
936 str = "Interface specified is not being used for interface based peer.";
937 break;
938 case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
939 str = "No configuration already specified for soft reconfiguration.";
940 break;
941 case BGP_ERR_AS_MISMATCH:
942 str = "BGP is already running.";
943 break;
944 case BGP_ERR_AF_UNCONFIGURED:
945 str = "AFI/SAFI specified is not currently configured.";
946 break;
947 case BGP_ERR_INVALID_AS:
948 str = "Confederation AS specified is the same AS as our AS.";
949 break;
950 case BGP_ERR_INVALID_ROLE_NAME:
951 str = "Invalid role name";
952 break;
953 case BGP_ERR_INVALID_INTERNAL_ROLE:
954 str = "External roles can be set only on eBGP session";
955 break;
956 case BGP_ERR_PEER_ORR_CONFIGURED:
957 str = "Deconfigure optimal-route-reflection on this peer first";
958 break;
959 }
960 if (str) {
961 vty_out(vty, "%% %s\n", str);
962 return CMD_WARNING_CONFIG_FAILED;
963 }
964 return CMD_SUCCESS;
965 }
966
967 /* BGP clear sort. */
968 enum clear_sort {
969 clear_all,
970 clear_peer,
971 clear_group,
972 clear_external,
973 clear_as
974 };
975
976 static void bgp_clear_vty_error(struct vty *vty, struct peer *peer, afi_t afi,
977 safi_t safi, int error)
978 {
979 switch (error) {
980 case BGP_ERR_AF_UNCONFIGURED:
981 if (vty)
982 vty_out(vty,
983 "%% BGP: Enable %s address family for the neighbor %s\n",
984 get_afi_safi_str(afi, safi, false), peer->host);
985 else
986 zlog_warn(
987 "%% BGP: Enable %s address family for the neighbor %s",
988 get_afi_safi_str(afi, safi, false), peer->host);
989 break;
990 case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
991 if (vty)
992 vty_out(vty,
993 "%% BGP: Inbound soft reconfig for %s not possible as it\n has neither refresh capability, nor inbound soft reconfig\n",
994 peer->host);
995 else
996 zlog_warn(
997 "%% BGP: Inbound soft reconfig for %s not possible as it has neither refresh capability, nor inbound soft reconfig",
998 peer->host);
999 break;
1000 default:
1001 break;
1002 }
1003 }
1004
1005 static int bgp_peer_clear(struct peer *peer, afi_t afi, safi_t safi,
1006 struct listnode **nnode, enum bgp_clear_type stype)
1007 {
1008 int ret = 0;
1009 struct peer_af *paf;
1010
1011 /* if afi/.safi not specified, spin thru all of them */
1012 if ((afi == AFI_UNSPEC) && (safi == SAFI_UNSPEC)) {
1013 afi_t tmp_afi;
1014 safi_t tmp_safi;
1015 enum bgp_af_index index;
1016
1017 for (index = BGP_AF_START; index < BGP_AF_MAX; index++) {
1018 paf = peer->peer_af_array[index];
1019 if (!paf)
1020 continue;
1021
1022 if (paf && paf->subgroup)
1023 SET_FLAG(paf->subgroup->sflags,
1024 SUBGRP_STATUS_FORCE_UPDATES);
1025
1026 tmp_afi = paf->afi;
1027 tmp_safi = paf->safi;
1028 if (!peer->afc[tmp_afi][tmp_safi])
1029 continue;
1030
1031 if (stype == BGP_CLEAR_SOFT_NONE)
1032 ret = peer_clear(peer, nnode);
1033 else
1034 ret = peer_clear_soft(peer, tmp_afi, tmp_safi,
1035 stype);
1036 }
1037 /* if afi specified and safi not, spin thru safis on this afi */
1038 } else if (safi == SAFI_UNSPEC) {
1039 safi_t tmp_safi;
1040
1041 for (tmp_safi = SAFI_UNICAST;
1042 tmp_safi < SAFI_MAX; tmp_safi++) {
1043 if (!peer->afc[afi][tmp_safi])
1044 continue;
1045
1046 paf = peer_af_find(peer, afi, tmp_safi);
1047 if (paf && paf->subgroup)
1048 SET_FLAG(paf->subgroup->sflags,
1049 SUBGRP_STATUS_FORCE_UPDATES);
1050
1051 if (stype == BGP_CLEAR_SOFT_NONE)
1052 ret = peer_clear(peer, nnode);
1053 else
1054 ret = peer_clear_soft(peer, afi,
1055 tmp_safi, stype);
1056 }
1057 /* both afi/safi specified, let the caller know if not defined */
1058 } else {
1059 if (!peer->afc[afi][safi])
1060 return 1;
1061
1062 paf = peer_af_find(peer, afi, safi);
1063 if (paf && paf->subgroup)
1064 SET_FLAG(paf->subgroup->sflags,
1065 SUBGRP_STATUS_FORCE_UPDATES);
1066
1067 if (stype == BGP_CLEAR_SOFT_NONE)
1068 ret = peer_clear(peer, nnode);
1069 else
1070 ret = peer_clear_soft(peer, afi, safi, stype);
1071 }
1072
1073 return ret;
1074 }
1075
1076 /* `clear ip bgp' functions. */
1077 static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
1078 enum clear_sort sort, enum bgp_clear_type stype,
1079 const char *arg)
1080 {
1081 int ret = 0;
1082 bool found = false;
1083 struct peer *peer;
1084
1085 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
1086
1087 /* Clear all neighbors. */
1088 /*
1089 * Pass along pointer to next node to peer_clear() when walking all
1090 * nodes on the BGP instance as that may get freed if it is a
1091 * doppelganger
1092 */
1093 if (sort == clear_all) {
1094 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1095
1096 bgp_peer_gr_flags_update(peer);
1097
1098 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1099 gr_router_detected = true;
1100
1101 ret = bgp_peer_clear(peer, afi, safi, &nnode,
1102 stype);
1103
1104 if (ret < 0)
1105 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1106 }
1107
1108 if (gr_router_detected
1109 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1110 bgp_zebra_send_capabilities(bgp, false);
1111 } else if (!gr_router_detected
1112 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1113 bgp_zebra_send_capabilities(bgp, true);
1114 }
1115
1116 /* This is to apply read-only mode on this clear. */
1117 if (stype == BGP_CLEAR_SOFT_NONE)
1118 bgp->update_delay_over = 0;
1119
1120 return CMD_SUCCESS;
1121 }
1122
1123 /* Clear specified neighbor. */
1124 if (sort == clear_peer) {
1125 union sockunion su;
1126
1127 /* Make sockunion for lookup. */
1128 ret = str2sockunion(arg, &su);
1129 if (ret < 0) {
1130 peer = peer_lookup_by_conf_if(bgp, arg);
1131 if (!peer) {
1132 peer = peer_lookup_by_hostname(bgp, arg);
1133 if (!peer) {
1134 vty_out(vty,
1135 "Malformed address or name: %s\n",
1136 arg);
1137 return CMD_WARNING;
1138 }
1139 }
1140 } else {
1141 peer = peer_lookup(bgp, &su);
1142 if (!peer) {
1143 vty_out(vty,
1144 "%% BGP: Unknown neighbor - \"%s\"\n",
1145 arg);
1146 return CMD_WARNING;
1147 }
1148 }
1149
1150 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
1151 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
1152
1153 ret = bgp_peer_clear(peer, afi, safi, NULL, stype);
1154
1155 /* if afi/safi not defined for this peer, let caller know */
1156 if (ret == 1)
1157 ret = BGP_ERR_AF_UNCONFIGURED;
1158
1159 if (ret < 0)
1160 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1161
1162 return CMD_SUCCESS;
1163 }
1164
1165 /* Clear all neighbors belonging to a specific peer-group. */
1166 if (sort == clear_group) {
1167 struct peer_group *group;
1168
1169 group = peer_group_lookup(bgp, arg);
1170 if (!group) {
1171 vty_out(vty, "%% BGP: No such peer-group %s\n", arg);
1172 return CMD_WARNING;
1173 }
1174
1175 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
1176 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1177
1178 if (ret < 0)
1179 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1180 else
1181 found = true;
1182 }
1183
1184 if (!found)
1185 vty_out(vty,
1186 "%% BGP: No %s peer belonging to peer-group %s is configured\n",
1187 get_afi_safi_str(afi, safi, false), arg);
1188
1189 return CMD_SUCCESS;
1190 }
1191
1192 /* Clear all external (eBGP) neighbors. */
1193 if (sort == clear_external) {
1194 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1195 if (peer->sort == BGP_PEER_IBGP)
1196 continue;
1197
1198 bgp_peer_gr_flags_update(peer);
1199
1200 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1201 gr_router_detected = true;
1202
1203 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1204
1205 if (ret < 0)
1206 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1207 else
1208 found = true;
1209 }
1210
1211 if (gr_router_detected
1212 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1213 bgp_zebra_send_capabilities(bgp, false);
1214 } else if (!gr_router_detected
1215 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1216 bgp_zebra_send_capabilities(bgp, true);
1217 }
1218
1219 if (!found)
1220 vty_out(vty,
1221 "%% BGP: No external %s peer is configured\n",
1222 get_afi_safi_str(afi, safi, false));
1223
1224 return CMD_SUCCESS;
1225 }
1226
1227 /* Clear all neighbors belonging to a specific AS. */
1228 if (sort == clear_as) {
1229 as_t as = strtoul(arg, NULL, 10);
1230
1231 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1232 if (peer->as != as)
1233 continue;
1234
1235 bgp_peer_gr_flags_update(peer);
1236
1237 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1238 gr_router_detected = true;
1239
1240 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1241
1242 if (ret < 0)
1243 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1244 else
1245 found = true;
1246 }
1247
1248 if (gr_router_detected
1249 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1250 bgp_zebra_send_capabilities(bgp, false);
1251 } else if (!gr_router_detected
1252 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1253 bgp_zebra_send_capabilities(bgp, true);
1254 }
1255
1256 if (!found)
1257 vty_out(vty,
1258 "%% BGP: No %s peer is configured with AS %s\n",
1259 get_afi_safi_str(afi, safi, false), arg);
1260
1261 return CMD_SUCCESS;
1262 }
1263
1264 return CMD_SUCCESS;
1265 }
1266
1267 static int bgp_clear_vty(struct vty *vty, const char *name, afi_t afi,
1268 safi_t safi, enum clear_sort sort,
1269 enum bgp_clear_type stype, const char *arg)
1270 {
1271 struct bgp *bgp;
1272
1273 /* BGP structure lookup. */
1274 if (name) {
1275 bgp = bgp_lookup_by_name(name);
1276 if (bgp == NULL) {
1277 vty_out(vty, "Can't find BGP instance %s\n", name);
1278 return CMD_WARNING;
1279 }
1280 } else {
1281 bgp = bgp_get_default();
1282 if (bgp == NULL) {
1283 vty_out(vty, "No BGP process is configured\n");
1284 return CMD_WARNING;
1285 }
1286 }
1287
1288 return bgp_clear(vty, bgp, afi, safi, sort, stype, arg);
1289 }
1290
1291 /* clear soft inbound */
1292 static void bgp_clear_star_soft_in(struct vty *vty, const char *name)
1293 {
1294 afi_t afi;
1295 safi_t safi;
1296
1297 FOREACH_AFI_SAFI (afi, safi)
1298 bgp_clear_vty(vty, name, afi, safi, clear_all,
1299 BGP_CLEAR_SOFT_IN, NULL);
1300 }
1301
1302 /* clear soft outbound */
1303 static void bgp_clear_star_soft_out(struct vty *vty, const char *name)
1304 {
1305 afi_t afi;
1306 safi_t safi;
1307
1308 FOREACH_AFI_SAFI (afi, safi)
1309 bgp_clear_vty(vty, name, afi, safi, clear_all,
1310 BGP_CLEAR_SOFT_OUT, NULL);
1311 }
1312
1313
1314 void bgp_clear_soft_in(struct bgp *bgp, afi_t afi, safi_t safi)
1315 {
1316 bgp_clear(NULL, bgp, afi, safi, clear_all, BGP_CLEAR_SOFT_IN, NULL);
1317 }
1318
1319 #ifndef VTYSH_EXTRACT_PL
1320 #include "bgpd/bgp_vty_clippy.c"
1321 #endif
1322
1323 DEFUN_HIDDEN (bgp_local_mac,
1324 bgp_local_mac_cmd,
1325 "bgp local-mac vni " CMD_VNI_RANGE " mac WORD seq (0-4294967295)",
1326 BGP_STR
1327 "Local MAC config\n"
1328 "VxLAN Network Identifier\n"
1329 "VNI number\n"
1330 "local mac\n"
1331 "mac address\n"
1332 "mac-mobility sequence\n"
1333 "seq number\n")
1334 {
1335 int rv;
1336 vni_t vni;
1337 struct ethaddr mac;
1338 struct ipaddr ip;
1339 uint32_t seq;
1340 struct bgp *bgp;
1341
1342 vni = strtoul(argv[3]->arg, NULL, 10);
1343 if (!prefix_str2mac(argv[5]->arg, &mac)) {
1344 vty_out(vty, "%% Malformed MAC address\n");
1345 return CMD_WARNING;
1346 }
1347 memset(&ip, 0, sizeof(ip));
1348 seq = strtoul(argv[7]->arg, NULL, 10);
1349
1350 bgp = bgp_get_default();
1351 if (!bgp) {
1352 vty_out(vty, "Default BGP instance is not there\n");
1353 return CMD_WARNING;
1354 }
1355
1356 rv = bgp_evpn_local_macip_add(bgp, vni, &mac, &ip, 0 /* flags */, seq,
1357 zero_esi);
1358 if (rv < 0) {
1359 vty_out(vty, "Internal error\n");
1360 return CMD_WARNING;
1361 }
1362
1363 return CMD_SUCCESS;
1364 }
1365
1366 DEFUN_HIDDEN (no_bgp_local_mac,
1367 no_bgp_local_mac_cmd,
1368 "no bgp local-mac vni " CMD_VNI_RANGE " mac WORD",
1369 NO_STR
1370 BGP_STR
1371 "Local MAC config\n"
1372 "VxLAN Network Identifier\n"
1373 "VNI number\n"
1374 "local mac\n"
1375 "mac address\n")
1376 {
1377 int rv;
1378 vni_t vni;
1379 struct ethaddr mac;
1380 struct ipaddr ip;
1381 struct bgp *bgp;
1382
1383 vni = strtoul(argv[4]->arg, NULL, 10);
1384 if (!prefix_str2mac(argv[6]->arg, &mac)) {
1385 vty_out(vty, "%% Malformed MAC address\n");
1386 return CMD_WARNING;
1387 }
1388 memset(&ip, 0, sizeof(ip));
1389
1390 bgp = bgp_get_default();
1391 if (!bgp) {
1392 vty_out(vty, "Default BGP instance is not there\n");
1393 return CMD_WARNING;
1394 }
1395
1396 rv = bgp_evpn_local_macip_del(bgp, vni, &mac, &ip, ZEBRA_NEIGH_ACTIVE);
1397 if (rv < 0) {
1398 vty_out(vty, "Internal error\n");
1399 return CMD_WARNING;
1400 }
1401
1402 return CMD_SUCCESS;
1403 }
1404
1405 DEFUN (no_synchronization,
1406 no_synchronization_cmd,
1407 "no synchronization",
1408 NO_STR
1409 "Perform IGP synchronization\n")
1410 {
1411 return CMD_SUCCESS;
1412 }
1413
1414 DEFUN (no_auto_summary,
1415 no_auto_summary_cmd,
1416 "no auto-summary",
1417 NO_STR
1418 "Enable automatic network number summarization\n")
1419 {
1420 return CMD_SUCCESS;
1421 }
1422
1423 /* "router bgp" commands. */
1424 DEFUN_NOSH (router_bgp,
1425 router_bgp_cmd,
1426 "router bgp [(1-4294967295)$instasn [<view|vrf> VIEWVRFNAME]]",
1427 ROUTER_STR
1428 BGP_STR
1429 AS_STR
1430 BGP_INSTANCE_HELP_STR)
1431 {
1432 int idx_asn = 2;
1433 int idx_view_vrf = 3;
1434 int idx_vrf = 4;
1435 int is_new_bgp = 0;
1436 int ret;
1437 as_t as;
1438 struct bgp *bgp;
1439 const char *name = NULL;
1440 enum bgp_instance_type inst_type;
1441
1442 // "router bgp" without an ASN
1443 if (argc == 2) {
1444 // Pending: Make VRF option available for ASN less config
1445 bgp = bgp_get_default();
1446
1447 if (bgp == NULL) {
1448 vty_out(vty, "%% No BGP process is configured\n");
1449 return CMD_WARNING_CONFIG_FAILED;
1450 }
1451
1452 if (listcount(bm->bgp) > 1) {
1453 vty_out(vty, "%% Please specify ASN and VRF\n");
1454 return CMD_WARNING_CONFIG_FAILED;
1455 }
1456 }
1457
1458 // "router bgp X"
1459 else {
1460 as = strtoul(argv[idx_asn]->arg, NULL, 10);
1461
1462 if (as == BGP_PRIVATE_AS_MAX || as == BGP_AS4_MAX)
1463 vty_out(vty, "Reserved AS used (%u|%u); AS is %u\n",
1464 BGP_PRIVATE_AS_MAX, BGP_AS4_MAX, as);
1465
1466 inst_type = BGP_INSTANCE_TYPE_DEFAULT;
1467 if (argc > 3) {
1468 name = argv[idx_vrf]->arg;
1469
1470 if (!strcmp(argv[idx_view_vrf]->text, "vrf")) {
1471 if (strmatch(name, VRF_DEFAULT_NAME))
1472 name = NULL;
1473 else
1474 inst_type = BGP_INSTANCE_TYPE_VRF;
1475 } else if (!strcmp(argv[idx_view_vrf]->text, "view"))
1476 inst_type = BGP_INSTANCE_TYPE_VIEW;
1477 }
1478
1479 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT)
1480 is_new_bgp = (bgp_lookup(as, name) == NULL);
1481
1482 ret = bgp_get_vty(&bgp, &as, name, inst_type);
1483 switch (ret) {
1484 case BGP_ERR_AS_MISMATCH:
1485 vty_out(vty, "BGP is already running; AS is %u\n", as);
1486 return CMD_WARNING_CONFIG_FAILED;
1487 case BGP_ERR_INSTANCE_MISMATCH:
1488 vty_out(vty,
1489 "BGP instance name and AS number mismatch\n");
1490 vty_out(vty,
1491 "BGP instance is already running; AS is %u\n",
1492 as);
1493 return CMD_WARNING_CONFIG_FAILED;
1494 }
1495
1496 /*
1497 * If we just instantiated the default instance, complete
1498 * any pending VRF-VPN leaking that was configured via
1499 * earlier "router bgp X vrf FOO" blocks.
1500 */
1501 if (is_new_bgp && inst_type == BGP_INSTANCE_TYPE_DEFAULT)
1502 vpn_leak_postchange_all();
1503
1504 if (inst_type == BGP_INSTANCE_TYPE_VRF)
1505 bgp_vpn_leak_export(bgp);
1506 /* Pending: handle when user tries to change a view to vrf n vv.
1507 */
1508 }
1509
1510 /* unset the auto created flag as the user config is now present */
1511 UNSET_FLAG(bgp->vrf_flags, BGP_VRF_AUTO);
1512 VTY_PUSH_CONTEXT(BGP_NODE, bgp);
1513
1514 return CMD_SUCCESS;
1515 }
1516
1517 /* "no router bgp" commands. */
1518 DEFUN (no_router_bgp,
1519 no_router_bgp_cmd,
1520 "no router bgp [(1-4294967295)$instasn [<view|vrf> VIEWVRFNAME]]",
1521 NO_STR
1522 ROUTER_STR
1523 BGP_STR
1524 AS_STR
1525 BGP_INSTANCE_HELP_STR)
1526 {
1527 int idx_asn = 3;
1528 int idx_vrf = 5;
1529 as_t as;
1530 struct bgp *bgp;
1531 const char *name = NULL;
1532
1533 // "no router bgp" without an ASN
1534 if (argc == 3) {
1535 // Pending: Make VRF option available for ASN less config
1536 bgp = bgp_get_default();
1537
1538 if (bgp == NULL) {
1539 vty_out(vty, "%% No BGP process is configured\n");
1540 return CMD_WARNING_CONFIG_FAILED;
1541 }
1542
1543 if (listcount(bm->bgp) > 1) {
1544 vty_out(vty, "%% Please specify ASN and VRF\n");
1545 return CMD_WARNING_CONFIG_FAILED;
1546 }
1547
1548 if (bgp->l3vni) {
1549 vty_out(vty, "%% Please unconfigure l3vni %u\n",
1550 bgp->l3vni);
1551 return CMD_WARNING_CONFIG_FAILED;
1552 }
1553 } else {
1554 as = strtoul(argv[idx_asn]->arg, NULL, 10);
1555
1556 if (argc > 4) {
1557 name = argv[idx_vrf]->arg;
1558 if (strmatch(argv[idx_vrf - 1]->text, "vrf")
1559 && strmatch(name, VRF_DEFAULT_NAME))
1560 name = NULL;
1561 }
1562
1563 /* Lookup bgp structure. */
1564 bgp = bgp_lookup(as, name);
1565 if (!bgp) {
1566 vty_out(vty, "%% Can't find BGP instance\n");
1567 return CMD_WARNING_CONFIG_FAILED;
1568 }
1569
1570 if (bgp->l3vni) {
1571 vty_out(vty, "%% Please unconfigure l3vni %u\n",
1572 bgp->l3vni);
1573 return CMD_WARNING_CONFIG_FAILED;
1574 }
1575
1576 /* Cannot delete default instance if vrf instances exist */
1577 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
1578 struct listnode *node;
1579 struct bgp *tmp_bgp;
1580
1581 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, tmp_bgp)) {
1582 if (tmp_bgp->inst_type != BGP_INSTANCE_TYPE_VRF)
1583 continue;
1584 if (CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1585 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT) ||
1586 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1587 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT) ||
1588 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1589 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT) ||
1590 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1591 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT) ||
1592 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1593 BGP_CONFIG_VRF_TO_VRF_EXPORT) ||
1594 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1595 BGP_CONFIG_VRF_TO_VRF_EXPORT) ||
1596 (bgp == bgp_get_evpn() &&
1597 (CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1598 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST) ||
1599 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1600 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP) ||
1601 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1602 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST) ||
1603 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1604 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP))) ||
1605 (hashcount(tmp_bgp->vnihash))) {
1606 vty_out(vty,
1607 "%% Cannot delete default BGP instance. Dependent VRF instances exist\n");
1608 return CMD_WARNING_CONFIG_FAILED;
1609 }
1610 }
1611 }
1612 }
1613
1614 bgp_delete(bgp);
1615
1616 return CMD_SUCCESS;
1617 }
1618
1619 /* bgp session-dscp */
1620
1621 DEFPY (bgp_session_dscp,
1622 bgp_session_dscp_cmd,
1623 "bgp session-dscp (0-63)$dscp",
1624 BGP_STR
1625 "Override default (C6) bgp TCP session DSCP value\n"
1626 "Manually configured dscp parameter\n")
1627 {
1628 bm->tcp_dscp = dscp << 2;
1629
1630 return CMD_SUCCESS;
1631 }
1632
1633 DEFPY (no_bgp_session_dscp,
1634 no_bgp_session_dscp_cmd,
1635 "no bgp session-dscp [(0-63)]",
1636 NO_STR
1637 BGP_STR
1638 "Override default (C6) bgp TCP session DSCP value\n"
1639 "Manually configured dscp parameter\n")
1640 {
1641 bm->tcp_dscp = IPTOS_PREC_INTERNETCONTROL;
1642
1643 return CMD_SUCCESS;
1644 }
1645
1646 /* BGP router-id. */
1647
1648 DEFPY (bgp_router_id,
1649 bgp_router_id_cmd,
1650 "bgp router-id A.B.C.D",
1651 BGP_STR
1652 "Override configured router identifier\n"
1653 "Manually configured router identifier\n")
1654 {
1655 VTY_DECLVAR_CONTEXT(bgp, bgp);
1656 bgp_router_id_static_set(bgp, router_id);
1657 return CMD_SUCCESS;
1658 }
1659
1660 DEFPY (no_bgp_router_id,
1661 no_bgp_router_id_cmd,
1662 "no bgp router-id [A.B.C.D]",
1663 NO_STR
1664 BGP_STR
1665 "Override configured router identifier\n"
1666 "Manually configured router identifier\n")
1667 {
1668 VTY_DECLVAR_CONTEXT(bgp, bgp);
1669
1670 if (router_id_str) {
1671 if (!IPV4_ADDR_SAME(&bgp->router_id_static, &router_id)) {
1672 vty_out(vty, "%% BGP router-id doesn't match\n");
1673 return CMD_WARNING_CONFIG_FAILED;
1674 }
1675 }
1676
1677 router_id.s_addr = 0;
1678 bgp_router_id_static_set(bgp, router_id);
1679
1680 return CMD_SUCCESS;
1681 }
1682
1683 DEFPY(bgp_community_alias, bgp_community_alias_cmd,
1684 "[no$no] bgp community alias WORD$community ALIAS_NAME$alias_name",
1685 NO_STR BGP_STR
1686 "Add community specific parameters\n"
1687 "Create an alias for a community\n"
1688 "Community (AA:BB or AA:BB:CC)\n"
1689 "Alias name\n")
1690 {
1691 struct community_alias ca = {};
1692 struct community_alias *lookup_community;
1693 struct community_alias *lookup_alias;
1694 struct community *comm;
1695 struct lcommunity *lcomm;
1696 uint8_t invalid = 0;
1697
1698 comm = community_str2com(community);
1699 if (!comm)
1700 invalid++;
1701 community_free(&comm);
1702
1703 lcomm = lcommunity_str2com(community);
1704 if (!lcomm)
1705 invalid++;
1706 lcommunity_free(&lcomm);
1707
1708 if (invalid > 1) {
1709 vty_out(vty, "Invalid community format\n");
1710 return CMD_WARNING;
1711 }
1712
1713 strlcpy(ca.community, community, sizeof(ca.community));
1714 strlcpy(ca.alias, alias_name, sizeof(ca.alias));
1715
1716 lookup_community = bgp_ca_community_lookup(&ca);
1717 lookup_alias = bgp_ca_alias_lookup(&ca);
1718
1719 if (no) {
1720 bgp_ca_alias_delete(&ca);
1721 bgp_ca_community_delete(&ca);
1722 } else {
1723 if (lookup_alias) {
1724 /* Lookup if community hash table has an item
1725 * with the same alias name.
1726 */
1727 strlcpy(ca.community, lookup_alias->community,
1728 sizeof(ca.community));
1729 if (bgp_ca_community_lookup(&ca)) {
1730 vty_out(vty,
1731 "community (%s) already has this alias (%s)\n",
1732 lookup_alias->community,
1733 lookup_alias->alias);
1734 return CMD_WARNING;
1735 }
1736 bgp_ca_alias_delete(&ca);
1737 }
1738
1739 if (lookup_community) {
1740 /* Lookup if alias hash table has an item
1741 * with the same community.
1742 */
1743 strlcpy(ca.alias, lookup_community->alias,
1744 sizeof(ca.alias));
1745 if (bgp_ca_alias_lookup(&ca)) {
1746 vty_out(vty,
1747 "alias (%s) already has this community (%s)\n",
1748 lookup_community->alias,
1749 lookup_community->community);
1750 return CMD_WARNING;
1751 }
1752 bgp_ca_community_delete(&ca);
1753 }
1754
1755 bgp_ca_alias_insert(&ca);
1756 bgp_ca_community_insert(&ca);
1757 }
1758
1759 return CMD_SUCCESS;
1760 }
1761
1762 DEFPY (bgp_global_suppress_fib_pending,
1763 bgp_global_suppress_fib_pending_cmd,
1764 "[no] bgp suppress-fib-pending",
1765 NO_STR
1766 BGP_STR
1767 "Advertise only routes that are programmed in kernel to peers globally\n")
1768 {
1769 bm_wait_for_fib_set(!no);
1770
1771 return CMD_SUCCESS;
1772 }
1773
1774 DEFPY (bgp_suppress_fib_pending,
1775 bgp_suppress_fib_pending_cmd,
1776 "[no] bgp suppress-fib-pending",
1777 NO_STR
1778 BGP_STR
1779 "Advertise only routes that are programmed in kernel to peers\n")
1780 {
1781 VTY_DECLVAR_CONTEXT(bgp, bgp);
1782
1783 bgp_suppress_fib_pending_set(bgp, !no);
1784 return CMD_SUCCESS;
1785 }
1786
1787
1788 /* BGP Cluster ID. */
1789 DEFUN (bgp_cluster_id,
1790 bgp_cluster_id_cmd,
1791 "bgp cluster-id <A.B.C.D|(1-4294967295)>",
1792 BGP_STR
1793 "Configure Route-Reflector Cluster-id\n"
1794 "Route-Reflector Cluster-id in IP address format\n"
1795 "Route-Reflector Cluster-id as 32 bit quantity\n")
1796 {
1797 VTY_DECLVAR_CONTEXT(bgp, bgp);
1798 int idx_ipv4 = 2;
1799 int ret;
1800 struct in_addr cluster;
1801
1802 ret = inet_aton(argv[idx_ipv4]->arg, &cluster);
1803 if (!ret) {
1804 vty_out(vty, "%% Malformed bgp cluster identifier\n");
1805 return CMD_WARNING_CONFIG_FAILED;
1806 }
1807
1808 bgp_cluster_id_set(bgp, &cluster);
1809 bgp_clear_star_soft_out(vty, bgp->name);
1810
1811 return CMD_SUCCESS;
1812 }
1813
1814 DEFUN (no_bgp_cluster_id,
1815 no_bgp_cluster_id_cmd,
1816 "no bgp cluster-id [<A.B.C.D|(1-4294967295)>]",
1817 NO_STR
1818 BGP_STR
1819 "Configure Route-Reflector Cluster-id\n"
1820 "Route-Reflector Cluster-id in IP address format\n"
1821 "Route-Reflector Cluster-id as 32 bit quantity\n")
1822 {
1823 VTY_DECLVAR_CONTEXT(bgp, bgp);
1824 bgp_cluster_id_unset(bgp);
1825 bgp_clear_star_soft_out(vty, bgp->name);
1826
1827 return CMD_SUCCESS;
1828 }
1829
1830 DEFPY (bgp_norib,
1831 bgp_norib_cmd,
1832 "bgp no-rib",
1833 BGP_STR
1834 "Disable BGP route installation to RIB (Zebra)\n")
1835 {
1836 if (bgp_option_check(BGP_OPT_NO_FIB)) {
1837 vty_out(vty,
1838 "%% No-RIB option is already set, nothing to do here.\n");
1839 return CMD_SUCCESS;
1840 }
1841
1842 bgp_option_norib_set_runtime();
1843
1844 return CMD_SUCCESS;
1845 }
1846
1847 DEFPY (no_bgp_norib,
1848 no_bgp_norib_cmd,
1849 "no bgp no-rib",
1850 NO_STR
1851 BGP_STR
1852 "Disable BGP route installation to RIB (Zebra)\n")
1853 {
1854 if (!bgp_option_check(BGP_OPT_NO_FIB)) {
1855 vty_out(vty,
1856 "%% No-RIB option is not set, nothing to do here.\n");
1857 return CMD_SUCCESS;
1858 }
1859
1860 bgp_option_norib_unset_runtime();
1861
1862 return CMD_SUCCESS;
1863 }
1864
1865 DEFPY (no_bgp_send_extra_data,
1866 no_bgp_send_extra_data_cmd,
1867 "[no] bgp send-extra-data zebra",
1868 NO_STR
1869 BGP_STR
1870 "Extra data to Zebra for display/use\n"
1871 "To zebra\n")
1872 {
1873 if (no)
1874 UNSET_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA);
1875 else
1876 SET_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA);
1877
1878 return CMD_SUCCESS;
1879 }
1880
1881 DEFUN (bgp_confederation_identifier,
1882 bgp_confederation_identifier_cmd,
1883 "bgp confederation identifier (1-4294967295)",
1884 BGP_STR
1885 "AS confederation parameters\n"
1886 "AS number\n"
1887 "Set routing domain confederation AS\n")
1888 {
1889 VTY_DECLVAR_CONTEXT(bgp, bgp);
1890 int idx_number = 3;
1891 as_t as;
1892
1893 as = strtoul(argv[idx_number]->arg, NULL, 10);
1894
1895 bgp_confederation_id_set(bgp, as);
1896
1897 return CMD_SUCCESS;
1898 }
1899
1900 DEFUN (no_bgp_confederation_identifier,
1901 no_bgp_confederation_identifier_cmd,
1902 "no bgp confederation identifier [(1-4294967295)]",
1903 NO_STR
1904 BGP_STR
1905 "AS confederation parameters\n"
1906 "AS number\n"
1907 "Set routing domain confederation AS\n")
1908 {
1909 VTY_DECLVAR_CONTEXT(bgp, bgp);
1910 bgp_confederation_id_unset(bgp);
1911
1912 return CMD_SUCCESS;
1913 }
1914
1915 DEFUN (bgp_confederation_peers,
1916 bgp_confederation_peers_cmd,
1917 "bgp confederation peers (1-4294967295)...",
1918 BGP_STR
1919 "AS confederation parameters\n"
1920 "Peer ASs in BGP confederation\n"
1921 AS_STR)
1922 {
1923 VTY_DECLVAR_CONTEXT(bgp, bgp);
1924 int idx_asn = 3;
1925 as_t as;
1926 int i;
1927
1928 for (i = idx_asn; i < argc; i++) {
1929 as = strtoul(argv[i]->arg, NULL, 10);
1930
1931 if (bgp->as == as) {
1932 vty_out(vty,
1933 "%% Local member-AS not allowed in confed peer list\n");
1934 continue;
1935 }
1936
1937 bgp_confederation_peers_add(bgp, as);
1938 }
1939 return CMD_SUCCESS;
1940 }
1941
1942 DEFUN (no_bgp_confederation_peers,
1943 no_bgp_confederation_peers_cmd,
1944 "no bgp confederation peers (1-4294967295)...",
1945 NO_STR
1946 BGP_STR
1947 "AS confederation parameters\n"
1948 "Peer ASs in BGP confederation\n"
1949 AS_STR)
1950 {
1951 VTY_DECLVAR_CONTEXT(bgp, bgp);
1952 int idx_asn = 4;
1953 as_t as;
1954 int i;
1955
1956 for (i = idx_asn; i < argc; i++) {
1957 as = strtoul(argv[i]->arg, NULL, 10);
1958
1959 bgp_confederation_peers_remove(bgp, as);
1960 }
1961 return CMD_SUCCESS;
1962 }
1963
1964 /**
1965 * Central routine for maximum-paths configuration.
1966 * @peer_type: BGP_PEER_EBGP or BGP_PEER_IBGP
1967 * @set: 1 for setting values, 0 for removing the max-paths config.
1968 */
1969 static int bgp_maxpaths_config_vty(struct vty *vty, int peer_type,
1970 const char *mpaths, uint16_t options,
1971 int set)
1972 {
1973 VTY_DECLVAR_CONTEXT(bgp, bgp);
1974 uint16_t maxpaths = 0;
1975 int ret;
1976 afi_t afi;
1977 safi_t safi;
1978
1979 afi = bgp_node_afi(vty);
1980 safi = bgp_node_safi(vty);
1981
1982 if (set) {
1983 maxpaths = strtol(mpaths, NULL, 10);
1984 if (maxpaths > multipath_num) {
1985 vty_out(vty,
1986 "%% Maxpaths Specified: %d is > than multipath num specified on bgp command line %d",
1987 maxpaths, multipath_num);
1988 return CMD_WARNING_CONFIG_FAILED;
1989 }
1990 ret = bgp_maximum_paths_set(bgp, afi, safi, peer_type, maxpaths,
1991 options);
1992 } else
1993 ret = bgp_maximum_paths_unset(bgp, afi, safi, peer_type);
1994
1995 if (ret < 0) {
1996 vty_out(vty,
1997 "%% Failed to %sset maximum-paths %s %u for afi %u, safi %u\n",
1998 (set == 1) ? "" : "un",
1999 (peer_type == BGP_PEER_EBGP) ? "ebgp" : "ibgp",
2000 maxpaths, afi, safi);
2001 return CMD_WARNING_CONFIG_FAILED;
2002 }
2003
2004 bgp_recalculate_all_bestpaths(bgp);
2005
2006 return CMD_SUCCESS;
2007 }
2008
2009 DEFUN (bgp_maxmed_admin,
2010 bgp_maxmed_admin_cmd,
2011 "bgp max-med administrative ",
2012 BGP_STR
2013 "Advertise routes with max-med\n"
2014 "Administratively applied, for an indefinite period\n")
2015 {
2016 VTY_DECLVAR_CONTEXT(bgp, bgp);
2017
2018 bgp->v_maxmed_admin = 1;
2019 bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
2020
2021 bgp_maxmed_update(bgp);
2022
2023 return CMD_SUCCESS;
2024 }
2025
2026 DEFUN (bgp_maxmed_admin_medv,
2027 bgp_maxmed_admin_medv_cmd,
2028 "bgp max-med administrative (0-4294967295)",
2029 BGP_STR
2030 "Advertise routes with max-med\n"
2031 "Administratively applied, for an indefinite period\n"
2032 "Max MED value to be used\n")
2033 {
2034 VTY_DECLVAR_CONTEXT(bgp, bgp);
2035 int idx_number = 3;
2036
2037 bgp->v_maxmed_admin = 1;
2038 bgp->maxmed_admin_value = strtoul(argv[idx_number]->arg, NULL, 10);
2039
2040 bgp_maxmed_update(bgp);
2041
2042 return CMD_SUCCESS;
2043 }
2044
2045 DEFUN (no_bgp_maxmed_admin,
2046 no_bgp_maxmed_admin_cmd,
2047 "no bgp max-med administrative [(0-4294967295)]",
2048 NO_STR
2049 BGP_STR
2050 "Advertise routes with max-med\n"
2051 "Administratively applied, for an indefinite period\n"
2052 "Max MED value to be used\n")
2053 {
2054 VTY_DECLVAR_CONTEXT(bgp, bgp);
2055 bgp->v_maxmed_admin = BGP_MAXMED_ADMIN_UNCONFIGURED;
2056 bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
2057 bgp_maxmed_update(bgp);
2058
2059 return CMD_SUCCESS;
2060 }
2061
2062 DEFUN (bgp_maxmed_onstartup,
2063 bgp_maxmed_onstartup_cmd,
2064 "bgp max-med on-startup (5-86400) [(0-4294967295)]",
2065 BGP_STR
2066 "Advertise routes with max-med\n"
2067 "Effective on a startup\n"
2068 "Time (seconds) period for max-med\n"
2069 "Max MED value to be used\n")
2070 {
2071 VTY_DECLVAR_CONTEXT(bgp, bgp);
2072 int idx = 0;
2073
2074 if (argv_find(argv, argc, "(5-86400)", &idx))
2075 bgp->v_maxmed_onstartup = strtoul(argv[idx]->arg, NULL, 10);
2076 if (argv_find(argv, argc, "(0-4294967295)", &idx))
2077 bgp->maxmed_onstartup_value = strtoul(argv[idx]->arg, NULL, 10);
2078 else
2079 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
2080
2081 bgp_maxmed_update(bgp);
2082
2083 return CMD_SUCCESS;
2084 }
2085
2086 DEFUN (no_bgp_maxmed_onstartup,
2087 no_bgp_maxmed_onstartup_cmd,
2088 "no bgp max-med on-startup [(5-86400) [(0-4294967295)]]",
2089 NO_STR
2090 BGP_STR
2091 "Advertise routes with max-med\n"
2092 "Effective on a startup\n"
2093 "Time (seconds) period for max-med\n"
2094 "Max MED value to be used\n")
2095 {
2096 VTY_DECLVAR_CONTEXT(bgp, bgp);
2097
2098 /* Cancel max-med onstartup if its on */
2099 if (bgp->t_maxmed_onstartup) {
2100 THREAD_OFF(bgp->t_maxmed_onstartup);
2101 bgp->maxmed_onstartup_over = 1;
2102 }
2103
2104 bgp->v_maxmed_onstartup = BGP_MAXMED_ONSTARTUP_UNCONFIGURED;
2105 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
2106
2107 bgp_maxmed_update(bgp);
2108
2109 return CMD_SUCCESS;
2110 }
2111
2112 static int bgp_global_update_delay_config_vty(struct vty *vty,
2113 uint16_t update_delay,
2114 uint16_t establish_wait)
2115 {
2116 struct listnode *node, *nnode;
2117 struct bgp *bgp;
2118 bool vrf_cfg = false;
2119
2120 /*
2121 * See if update-delay is set per-vrf and warn user to delete it
2122 * Note that we only need to check this if this is the first time
2123 * setting the global config.
2124 */
2125 if (bm->v_update_delay == BGP_UPDATE_DELAY_DEF) {
2126 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2127 if (bgp->v_update_delay != BGP_UPDATE_DELAY_DEF) {
2128 vty_out(vty,
2129 "%% update-delay configuration found in vrf %s\n",
2130 bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT
2131 ? VRF_DEFAULT_NAME
2132 : bgp->name);
2133 vrf_cfg = true;
2134 }
2135 }
2136 }
2137
2138 if (vrf_cfg) {
2139 vty_out(vty,
2140 "%%Failed: global update-delay config not permitted\n");
2141 return CMD_WARNING;
2142 }
2143
2144 if (!establish_wait) { /* update-delay <delay> */
2145 bm->v_update_delay = update_delay;
2146 bm->v_establish_wait = bm->v_update_delay;
2147 } else {
2148 /* update-delay <delay> <establish-wait> */
2149 if (update_delay < establish_wait) {
2150 vty_out(vty,
2151 "%%Failed: update-delay less than the establish-wait!\n");
2152 return CMD_WARNING_CONFIG_FAILED;
2153 }
2154
2155 bm->v_update_delay = update_delay;
2156 bm->v_establish_wait = establish_wait;
2157 }
2158
2159 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2160 bgp->v_update_delay = bm->v_update_delay;
2161 bgp->v_establish_wait = bm->v_establish_wait;
2162 }
2163
2164 return CMD_SUCCESS;
2165 }
2166
2167 static int bgp_global_update_delay_deconfig_vty(struct vty *vty)
2168 {
2169 struct listnode *node, *nnode;
2170 struct bgp *bgp;
2171
2172 bm->v_update_delay = BGP_UPDATE_DELAY_DEF;
2173 bm->v_establish_wait = bm->v_update_delay;
2174
2175 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2176 bgp->v_update_delay = bm->v_update_delay;
2177 bgp->v_establish_wait = bm->v_establish_wait;
2178 }
2179
2180 return CMD_SUCCESS;
2181 }
2182
2183 static int bgp_update_delay_config_vty(struct vty *vty, uint16_t update_delay,
2184 uint16_t establish_wait)
2185 {
2186 VTY_DECLVAR_CONTEXT(bgp, bgp);
2187
2188 /* if configured globally, per-instance config is not allowed */
2189 if (bm->v_update_delay) {
2190 vty_out(vty,
2191 "%%Failed: per-vrf update-delay config not permitted with global update-delay\n");
2192 return CMD_WARNING_CONFIG_FAILED;
2193 }
2194
2195
2196 if (!establish_wait) /* update-delay <delay> */
2197 {
2198 bgp->v_update_delay = update_delay;
2199 bgp->v_establish_wait = bgp->v_update_delay;
2200 return CMD_SUCCESS;
2201 }
2202
2203 /* update-delay <delay> <establish-wait> */
2204 if (update_delay < establish_wait) {
2205 vty_out(vty,
2206 "%%Failed: update-delay less than the establish-wait!\n");
2207 return CMD_WARNING_CONFIG_FAILED;
2208 }
2209
2210 bgp->v_update_delay = update_delay;
2211 bgp->v_establish_wait = establish_wait;
2212
2213 return CMD_SUCCESS;
2214 }
2215
2216 static int bgp_update_delay_deconfig_vty(struct vty *vty)
2217 {
2218 VTY_DECLVAR_CONTEXT(bgp, bgp);
2219
2220 /* If configured globally, cannot remove from one bgp instance */
2221 if (bm->v_update_delay) {
2222 vty_out(vty,
2223 "%%Failed: bgp update-delay configured globally. Delete per-vrf not permitted\n");
2224 return CMD_WARNING_CONFIG_FAILED;
2225 }
2226 bgp->v_update_delay = BGP_UPDATE_DELAY_DEF;
2227 bgp->v_establish_wait = bgp->v_update_delay;
2228
2229 return CMD_SUCCESS;
2230 }
2231
2232 void bgp_config_write_update_delay(struct vty *vty, struct bgp *bgp)
2233 {
2234 /* If configured globally, no need to display per-instance value */
2235 if (bgp->v_update_delay != bm->v_update_delay) {
2236 vty_out(vty, " update-delay %d", bgp->v_update_delay);
2237 if (bgp->v_update_delay != bgp->v_establish_wait)
2238 vty_out(vty, " %d", bgp->v_establish_wait);
2239 vty_out(vty, "\n");
2240 }
2241 }
2242
2243 /* Global update-delay configuration */
2244 DEFPY (bgp_global_update_delay,
2245 bgp_global_update_delay_cmd,
2246 "bgp update-delay (0-3600)$delay [(1-3600)$wait]",
2247 BGP_STR
2248 "Force initial delay for best-path and updates for all bgp instances\n"
2249 "Max delay in seconds\n"
2250 "Establish wait in seconds\n")
2251 {
2252 return bgp_global_update_delay_config_vty(vty, delay, wait);
2253 }
2254
2255 /* Global update-delay deconfiguration */
2256 DEFPY (no_bgp_global_update_delay,
2257 no_bgp_global_update_delay_cmd,
2258 "no bgp update-delay [(0-3600) [(1-3600)]]",
2259 NO_STR
2260 BGP_STR
2261 "Force initial delay for best-path and updates\n"
2262 "Max delay in seconds\n"
2263 "Establish wait in seconds\n")
2264 {
2265 return bgp_global_update_delay_deconfig_vty(vty);
2266 }
2267
2268 /* Update-delay configuration */
2269
2270 DEFPY (bgp_update_delay,
2271 bgp_update_delay_cmd,
2272 "update-delay (0-3600)$delay [(1-3600)$wait]",
2273 "Force initial delay for best-path and updates\n"
2274 "Max delay in seconds\n"
2275 "Establish wait in seconds\n")
2276 {
2277 return bgp_update_delay_config_vty(vty, delay, wait);
2278 }
2279
2280 /* Update-delay deconfiguration */
2281 DEFPY (no_bgp_update_delay,
2282 no_bgp_update_delay_cmd,
2283 "no update-delay [(0-3600) [(1-3600)]]",
2284 NO_STR
2285 "Force initial delay for best-path and updates\n"
2286 "Max delay in seconds\n"
2287 "Establish wait in seconds\n")
2288 {
2289 return bgp_update_delay_deconfig_vty(vty);
2290 }
2291
2292
2293 static int bgp_wpkt_quanta_config_vty(struct vty *vty, uint32_t quanta,
2294 bool set)
2295 {
2296 VTY_DECLVAR_CONTEXT(bgp, bgp);
2297
2298 quanta = set ? quanta : BGP_WRITE_PACKET_MAX;
2299 atomic_store_explicit(&bgp->wpkt_quanta, quanta, memory_order_relaxed);
2300
2301 return CMD_SUCCESS;
2302 }
2303
2304 static int bgp_rpkt_quanta_config_vty(struct vty *vty, uint32_t quanta,
2305 bool set)
2306 {
2307 VTY_DECLVAR_CONTEXT(bgp, bgp);
2308
2309 quanta = set ? quanta : BGP_READ_PACKET_MAX;
2310 atomic_store_explicit(&bgp->rpkt_quanta, quanta, memory_order_relaxed);
2311
2312 return CMD_SUCCESS;
2313 }
2314
2315 void bgp_config_write_wpkt_quanta(struct vty *vty, struct bgp *bgp)
2316 {
2317 uint32_t quanta =
2318 atomic_load_explicit(&bgp->wpkt_quanta, memory_order_relaxed);
2319 if (quanta != BGP_WRITE_PACKET_MAX)
2320 vty_out(vty, " write-quanta %d\n", quanta);
2321 }
2322
2323 void bgp_config_write_rpkt_quanta(struct vty *vty, struct bgp *bgp)
2324 {
2325 uint32_t quanta =
2326 atomic_load_explicit(&bgp->rpkt_quanta, memory_order_relaxed);
2327 if (quanta != BGP_READ_PACKET_MAX)
2328 vty_out(vty, " read-quanta %d\n", quanta);
2329 }
2330
2331 /* Packet quanta configuration
2332 *
2333 * XXX: The value set here controls the size of a stack buffer in the IO
2334 * thread. When changing these limits be careful to prevent stack overflow.
2335 *
2336 * Furthermore, the maximums used here should correspond to
2337 * BGP_WRITE_PACKET_MAX and BGP_READ_PACKET_MAX.
2338 */
2339 DEFPY (bgp_wpkt_quanta,
2340 bgp_wpkt_quanta_cmd,
2341 "[no] write-quanta (1-64)$quanta",
2342 NO_STR
2343 "How many packets to write to peer socket per run\n"
2344 "Number of packets\n")
2345 {
2346 return bgp_wpkt_quanta_config_vty(vty, quanta, !no);
2347 }
2348
2349 DEFPY (bgp_rpkt_quanta,
2350 bgp_rpkt_quanta_cmd,
2351 "[no] read-quanta (1-10)$quanta",
2352 NO_STR
2353 "How many packets to read from peer socket per I/O cycle\n"
2354 "Number of packets\n")
2355 {
2356 return bgp_rpkt_quanta_config_vty(vty, quanta, !no);
2357 }
2358
2359 void bgp_config_write_coalesce_time(struct vty *vty, struct bgp *bgp)
2360 {
2361 if (!bgp->heuristic_coalesce)
2362 vty_out(vty, " coalesce-time %u\n", bgp->coalesce_time);
2363 }
2364
2365 /* BGP TCP keepalive */
2366 static void bgp_config_tcp_keepalive(struct vty *vty, struct bgp *bgp)
2367 {
2368 if (bgp->tcp_keepalive_idle) {
2369 vty_out(vty, " bgp tcp-keepalive %u %u %u\n",
2370 bgp->tcp_keepalive_idle, bgp->tcp_keepalive_intvl,
2371 bgp->tcp_keepalive_probes);
2372 }
2373 }
2374
2375 DEFUN (bgp_coalesce_time,
2376 bgp_coalesce_time_cmd,
2377 "coalesce-time (0-4294967295)",
2378 "Subgroup coalesce timer\n"
2379 "Subgroup coalesce timer value (in ms)\n")
2380 {
2381 VTY_DECLVAR_CONTEXT(bgp, bgp);
2382
2383 int idx = 0;
2384
2385 bgp->heuristic_coalesce = false;
2386
2387 if (argv_find(argv, argc, "(0-4294967295)", &idx))
2388 bgp->coalesce_time = strtoul(argv[idx]->arg, NULL, 10);
2389
2390 return CMD_SUCCESS;
2391 }
2392
2393 DEFUN (no_bgp_coalesce_time,
2394 no_bgp_coalesce_time_cmd,
2395 "no coalesce-time (0-4294967295)",
2396 NO_STR
2397 "Subgroup coalesce timer\n"
2398 "Subgroup coalesce timer value (in ms)\n")
2399 {
2400 VTY_DECLVAR_CONTEXT(bgp, bgp);
2401
2402 bgp->heuristic_coalesce = true;
2403 bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
2404 return CMD_SUCCESS;
2405 }
2406
2407 /* Maximum-paths configuration */
2408 DEFUN (bgp_maxpaths,
2409 bgp_maxpaths_cmd,
2410 "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
2411 "Forward packets over multiple paths\n"
2412 "Number of paths\n")
2413 {
2414 int idx_number = 1;
2415 return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP,
2416 argv[idx_number]->arg, 0, 1);
2417 }
2418
2419 ALIAS_HIDDEN(bgp_maxpaths, bgp_maxpaths_hidden_cmd,
2420 "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
2421 "Forward packets over multiple paths\n"
2422 "Number of paths\n")
2423
2424 DEFUN (bgp_maxpaths_ibgp,
2425 bgp_maxpaths_ibgp_cmd,
2426 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
2427 "Forward packets over multiple paths\n"
2428 "iBGP-multipath\n"
2429 "Number of paths\n")
2430 {
2431 int idx_number = 2;
2432 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
2433 argv[idx_number]->arg, 0, 1);
2434 }
2435
2436 ALIAS_HIDDEN(bgp_maxpaths_ibgp, bgp_maxpaths_ibgp_hidden_cmd,
2437 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
2438 "Forward packets over multiple paths\n"
2439 "iBGP-multipath\n"
2440 "Number of paths\n")
2441
2442 DEFUN (bgp_maxpaths_ibgp_cluster,
2443 bgp_maxpaths_ibgp_cluster_cmd,
2444 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM) " equal-cluster-length",
2445 "Forward packets over multiple paths\n"
2446 "iBGP-multipath\n"
2447 "Number of paths\n"
2448 "Match the cluster length\n")
2449 {
2450 int idx_number = 2;
2451 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
2452 argv[idx_number]->arg, true, 1);
2453 }
2454
2455 ALIAS_HIDDEN(bgp_maxpaths_ibgp_cluster, bgp_maxpaths_ibgp_cluster_hidden_cmd,
2456 "maximum-paths ibgp " CMD_RANGE_STR(
2457 1, MULTIPATH_NUM) " equal-cluster-length",
2458 "Forward packets over multiple paths\n"
2459 "iBGP-multipath\n"
2460 "Number of paths\n"
2461 "Match the cluster length\n")
2462
2463 DEFUN (no_bgp_maxpaths,
2464 no_bgp_maxpaths_cmd,
2465 "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
2466 NO_STR
2467 "Forward packets over multiple paths\n"
2468 "Number of paths\n")
2469 {
2470 return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, NULL, 0, 0);
2471 }
2472
2473 ALIAS_HIDDEN(no_bgp_maxpaths, no_bgp_maxpaths_hidden_cmd,
2474 "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]", NO_STR
2475 "Forward packets over multiple paths\n"
2476 "Number of paths\n")
2477
2478 DEFUN (no_bgp_maxpaths_ibgp,
2479 no_bgp_maxpaths_ibgp_cmd,
2480 "no maximum-paths ibgp [" CMD_RANGE_STR(1, MULTIPATH_NUM) " [equal-cluster-length]]",
2481 NO_STR
2482 "Forward packets over multiple paths\n"
2483 "iBGP-multipath\n"
2484 "Number of paths\n"
2485 "Match the cluster length\n")
2486 {
2487 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, NULL, 0, 0);
2488 }
2489
2490 ALIAS_HIDDEN(no_bgp_maxpaths_ibgp, no_bgp_maxpaths_ibgp_hidden_cmd,
2491 "no maximum-paths ibgp [" CMD_RANGE_STR(
2492 1, MULTIPATH_NUM) " [equal-cluster-length]]",
2493 NO_STR
2494 "Forward packets over multiple paths\n"
2495 "iBGP-multipath\n"
2496 "Number of paths\n"
2497 "Match the cluster length\n")
2498
2499 static void bgp_config_write_maxpaths(struct vty *vty, struct bgp *bgp,
2500 afi_t afi, safi_t safi)
2501 {
2502 if (bgp->maxpaths[afi][safi].maxpaths_ebgp != multipath_num) {
2503 vty_out(vty, " maximum-paths %d\n",
2504 bgp->maxpaths[afi][safi].maxpaths_ebgp);
2505 }
2506
2507 if (bgp->maxpaths[afi][safi].maxpaths_ibgp != multipath_num) {
2508 vty_out(vty, " maximum-paths ibgp %d",
2509 bgp->maxpaths[afi][safi].maxpaths_ibgp);
2510 if (bgp->maxpaths[afi][safi].same_clusterlen)
2511 vty_out(vty, " equal-cluster-length");
2512 vty_out(vty, "\n");
2513 }
2514 }
2515
2516 /* BGP timers. */
2517
2518 DEFUN (bgp_timers,
2519 bgp_timers_cmd,
2520 "timers bgp (0-65535) (0-65535)",
2521 "Adjust routing timers\n"
2522 "BGP timers\n"
2523 "Keepalive interval\n"
2524 "Holdtime\n")
2525 {
2526 VTY_DECLVAR_CONTEXT(bgp, bgp);
2527 int idx_number = 2;
2528 int idx_number_2 = 3;
2529 unsigned long keepalive = 0;
2530 unsigned long holdtime = 0;
2531
2532 keepalive = strtoul(argv[idx_number]->arg, NULL, 10);
2533 holdtime = strtoul(argv[idx_number_2]->arg, NULL, 10);
2534
2535 /* Holdtime value check. */
2536 if (holdtime < 3 && holdtime != 0) {
2537 vty_out(vty,
2538 "%% hold time value must be either 0 or greater than 3\n");
2539 return CMD_WARNING_CONFIG_FAILED;
2540 }
2541
2542 bgp_timers_set(bgp, keepalive, holdtime, DFLT_BGP_CONNECT_RETRY,
2543 BGP_DEFAULT_DELAYOPEN);
2544
2545 return CMD_SUCCESS;
2546 }
2547
2548 DEFUN (no_bgp_timers,
2549 no_bgp_timers_cmd,
2550 "no timers bgp [(0-65535) (0-65535)]",
2551 NO_STR
2552 "Adjust routing timers\n"
2553 "BGP timers\n"
2554 "Keepalive interval\n"
2555 "Holdtime\n")
2556 {
2557 VTY_DECLVAR_CONTEXT(bgp, bgp);
2558 bgp_timers_set(bgp, DFLT_BGP_KEEPALIVE, DFLT_BGP_HOLDTIME,
2559 DFLT_BGP_CONNECT_RETRY, BGP_DEFAULT_DELAYOPEN);
2560
2561 return CMD_SUCCESS;
2562 }
2563
2564 /* BGP minimum holdtime. */
2565
2566 DEFUN(bgp_minimum_holdtime, bgp_minimum_holdtime_cmd,
2567 "bgp minimum-holdtime (1-65535)",
2568 "BGP specific commands\n"
2569 "BGP minimum holdtime\n"
2570 "Seconds\n")
2571 {
2572 VTY_DECLVAR_CONTEXT(bgp, bgp);
2573 int idx_number = 2;
2574 unsigned long min_holdtime;
2575
2576 min_holdtime = strtoul(argv[idx_number]->arg, NULL, 10);
2577
2578 bgp->default_min_holdtime = min_holdtime;
2579
2580 return CMD_SUCCESS;
2581 }
2582
2583 DEFUN(no_bgp_minimum_holdtime, no_bgp_minimum_holdtime_cmd,
2584 "no bgp minimum-holdtime [(1-65535)]",
2585 NO_STR
2586 "BGP specific commands\n"
2587 "BGP minimum holdtime\n"
2588 "Seconds\n")
2589 {
2590 VTY_DECLVAR_CONTEXT(bgp, bgp);
2591
2592 bgp->default_min_holdtime = 0;
2593
2594 return CMD_SUCCESS;
2595 }
2596
2597 DEFPY(bgp_tcp_keepalive, bgp_tcp_keepalive_cmd,
2598 "bgp tcp-keepalive (1-65535)$idle (1-65535)$intvl (1-30)$probes",
2599 BGP_STR
2600 "TCP keepalive parameters\n"
2601 "TCP keepalive idle time (seconds)\n"
2602 "TCP keepalive interval (seconds)\n"
2603 "TCP keepalive maximum probes\n")
2604 {
2605 VTY_DECLVAR_CONTEXT(bgp, bgp);
2606
2607 bgp_tcp_keepalive_set(bgp, (uint16_t)idle, (uint16_t)intvl,
2608 (uint16_t)probes);
2609
2610 return CMD_SUCCESS;
2611 }
2612
2613 DEFPY(no_bgp_tcp_keepalive, no_bgp_tcp_keepalive_cmd,
2614 "no bgp tcp-keepalive [(1-65535) (1-65535) (1-30)]",
2615 NO_STR
2616 BGP_STR
2617 "TCP keepalive parameters\n"
2618 "TCP keepalive idle time (seconds)\n"
2619 "TCP keepalive interval (seconds)\n"
2620 "TCP keepalive maximum probes\n")
2621 {
2622 VTY_DECLVAR_CONTEXT(bgp, bgp);
2623
2624 bgp_tcp_keepalive_unset(bgp);
2625
2626 return CMD_SUCCESS;
2627 }
2628
2629 DEFUN (bgp_client_to_client_reflection,
2630 bgp_client_to_client_reflection_cmd,
2631 "bgp client-to-client reflection",
2632 BGP_STR
2633 "Configure client to client route reflection\n"
2634 "reflection of routes allowed\n")
2635 {
2636 VTY_DECLVAR_CONTEXT(bgp, bgp);
2637 UNSET_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT);
2638 bgp_clear_star_soft_out(vty, bgp->name);
2639
2640 return CMD_SUCCESS;
2641 }
2642
2643 DEFUN (no_bgp_client_to_client_reflection,
2644 no_bgp_client_to_client_reflection_cmd,
2645 "no bgp client-to-client reflection",
2646 NO_STR
2647 BGP_STR
2648 "Configure client to client route reflection\n"
2649 "reflection of routes allowed\n")
2650 {
2651 VTY_DECLVAR_CONTEXT(bgp, bgp);
2652 SET_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT);
2653 bgp_clear_star_soft_out(vty, bgp->name);
2654
2655 return CMD_SUCCESS;
2656 }
2657
2658 /* "bgp always-compare-med" configuration. */
2659 DEFUN (bgp_always_compare_med,
2660 bgp_always_compare_med_cmd,
2661 "bgp always-compare-med",
2662 BGP_STR
2663 "Allow comparing MED from different neighbors\n")
2664 {
2665 VTY_DECLVAR_CONTEXT(bgp, bgp);
2666 SET_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED);
2667 bgp_recalculate_all_bestpaths(bgp);
2668
2669 return CMD_SUCCESS;
2670 }
2671
2672 DEFUN (no_bgp_always_compare_med,
2673 no_bgp_always_compare_med_cmd,
2674 "no bgp always-compare-med",
2675 NO_STR
2676 BGP_STR
2677 "Allow comparing MED from different neighbors\n")
2678 {
2679 VTY_DECLVAR_CONTEXT(bgp, bgp);
2680 UNSET_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED);
2681 bgp_recalculate_all_bestpaths(bgp);
2682
2683 return CMD_SUCCESS;
2684 }
2685
2686
2687 DEFUN(bgp_ebgp_requires_policy, bgp_ebgp_requires_policy_cmd,
2688 "bgp ebgp-requires-policy",
2689 BGP_STR
2690 "Require in and out policy for eBGP peers (RFC8212)\n")
2691 {
2692 VTY_DECLVAR_CONTEXT(bgp, bgp);
2693 SET_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
2694 return CMD_SUCCESS;
2695 }
2696
2697 DEFUN(no_bgp_ebgp_requires_policy, no_bgp_ebgp_requires_policy_cmd,
2698 "no bgp ebgp-requires-policy",
2699 NO_STR
2700 BGP_STR
2701 "Require in and out policy for eBGP peers (RFC8212)\n")
2702 {
2703 VTY_DECLVAR_CONTEXT(bgp, bgp);
2704 UNSET_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
2705 return CMD_SUCCESS;
2706 }
2707
2708 DEFUN(bgp_suppress_duplicates, bgp_suppress_duplicates_cmd,
2709 "bgp suppress-duplicates",
2710 BGP_STR
2711 "Suppress duplicate updates if the route actually not changed\n")
2712 {
2713 VTY_DECLVAR_CONTEXT(bgp, bgp);
2714 SET_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
2715 return CMD_SUCCESS;
2716 }
2717
2718 DEFUN(no_bgp_suppress_duplicates, no_bgp_suppress_duplicates_cmd,
2719 "no bgp suppress-duplicates",
2720 NO_STR
2721 BGP_STR
2722 "Suppress duplicate updates if the route actually not changed\n")
2723 {
2724 VTY_DECLVAR_CONTEXT(bgp, bgp);
2725 UNSET_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
2726 return CMD_SUCCESS;
2727 }
2728
2729 DEFUN(bgp_reject_as_sets, bgp_reject_as_sets_cmd,
2730 "bgp reject-as-sets",
2731 BGP_STR
2732 "Reject routes with AS_SET or AS_CONFED_SET flag\n")
2733 {
2734 VTY_DECLVAR_CONTEXT(bgp, bgp);
2735 struct listnode *node, *nnode;
2736 struct peer *peer;
2737
2738 bgp->reject_as_sets = true;
2739
2740 /* Reset existing BGP sessions to reject routes
2741 * with aspath containing AS_SET or AS_CONFED_SET.
2742 */
2743 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2744 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2745 peer->last_reset = PEER_DOWN_AS_SETS_REJECT;
2746 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2747 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2748 }
2749 }
2750
2751 return CMD_SUCCESS;
2752 }
2753
2754 DEFUN(no_bgp_reject_as_sets, no_bgp_reject_as_sets_cmd,
2755 "no bgp reject-as-sets",
2756 NO_STR
2757 BGP_STR
2758 "Reject routes with AS_SET or AS_CONFED_SET flag\n")
2759 {
2760 VTY_DECLVAR_CONTEXT(bgp, bgp);
2761 struct listnode *node, *nnode;
2762 struct peer *peer;
2763
2764 bgp->reject_as_sets = false;
2765
2766 /* Reset existing BGP sessions to reject routes
2767 * with aspath containing AS_SET or AS_CONFED_SET.
2768 */
2769 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2770 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2771 peer->last_reset = PEER_DOWN_AS_SETS_REJECT;
2772 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2773 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2774 }
2775 }
2776
2777 return CMD_SUCCESS;
2778 }
2779
2780 /* "bgp deterministic-med" configuration. */
2781 DEFUN (bgp_deterministic_med,
2782 bgp_deterministic_med_cmd,
2783 "bgp deterministic-med",
2784 BGP_STR
2785 "Pick the best-MED path among paths advertised from the neighboring AS\n")
2786 {
2787 VTY_DECLVAR_CONTEXT(bgp, bgp);
2788
2789 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)) {
2790 SET_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED);
2791 bgp_recalculate_all_bestpaths(bgp);
2792 }
2793
2794 return CMD_SUCCESS;
2795 }
2796
2797 DEFUN (no_bgp_deterministic_med,
2798 no_bgp_deterministic_med_cmd,
2799 "no bgp deterministic-med",
2800 NO_STR
2801 BGP_STR
2802 "Pick the best-MED path among paths advertised from the neighboring AS\n")
2803 {
2804 VTY_DECLVAR_CONTEXT(bgp, bgp);
2805 int bestpath_per_as_used;
2806 afi_t afi;
2807 safi_t safi;
2808 struct peer *peer;
2809 struct listnode *node, *nnode;
2810
2811 if (CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)) {
2812 bestpath_per_as_used = 0;
2813
2814 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2815 FOREACH_AFI_SAFI (afi, safi)
2816 if (bgp_addpath_dmed_required(
2817 peer->addpath_type[afi][safi])) {
2818 bestpath_per_as_used = 1;
2819 break;
2820 }
2821
2822 if (bestpath_per_as_used)
2823 break;
2824 }
2825
2826 if (bestpath_per_as_used) {
2827 vty_out(vty,
2828 "bgp deterministic-med cannot be disabled while addpath-tx-bestpath-per-AS is in use\n");
2829 return CMD_WARNING_CONFIG_FAILED;
2830 } else {
2831 UNSET_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED);
2832 bgp_recalculate_all_bestpaths(bgp);
2833 }
2834 }
2835
2836 return CMD_SUCCESS;
2837 }
2838
2839 /* "bgp graceful-restart mode" configuration. */
2840 DEFUN (bgp_graceful_restart,
2841 bgp_graceful_restart_cmd,
2842 "bgp graceful-restart",
2843 BGP_STR
2844 GR_CMD
2845 )
2846 {
2847 int ret = BGP_GR_FAILURE;
2848
2849 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2850 zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : START ");
2851
2852 VTY_DECLVAR_CONTEXT(bgp, bgp);
2853
2854 ret = bgp_gr_update_all(bgp, GLOBAL_GR_CMD);
2855
2856 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
2857 ret);
2858
2859 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2860 zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : END ");
2861 vty_out(vty,
2862 "Graceful restart configuration changed, reset all peers to take effect\n");
2863 return bgp_vty_return(vty, ret);
2864 }
2865
2866 DEFUN (no_bgp_graceful_restart,
2867 no_bgp_graceful_restart_cmd,
2868 "no bgp graceful-restart",
2869 NO_STR
2870 BGP_STR
2871 NO_GR_CMD
2872 )
2873 {
2874 VTY_DECLVAR_CONTEXT(bgp, bgp);
2875
2876 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2877 zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : START ");
2878
2879 int ret = BGP_GR_FAILURE;
2880
2881 ret = bgp_gr_update_all(bgp, NO_GLOBAL_GR_CMD);
2882
2883 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
2884 ret);
2885
2886 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2887 zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : END ");
2888 vty_out(vty,
2889 "Graceful restart configuration changed, reset all peers to take effect\n");
2890
2891 return bgp_vty_return(vty, ret);
2892 }
2893
2894 DEFUN (bgp_graceful_restart_stalepath_time,
2895 bgp_graceful_restart_stalepath_time_cmd,
2896 "bgp graceful-restart stalepath-time (1-4095)",
2897 BGP_STR
2898 "Graceful restart capability parameters\n"
2899 "Set the max time to hold onto restarting peer's stale paths\n"
2900 "Delay value (seconds)\n")
2901 {
2902 VTY_DECLVAR_CONTEXT(bgp, bgp);
2903 int idx_number = 3;
2904 uint32_t stalepath;
2905
2906 stalepath = strtoul(argv[idx_number]->arg, NULL, 10);
2907 bgp->stalepath_time = stalepath;
2908 return CMD_SUCCESS;
2909 }
2910
2911 DEFUN (bgp_graceful_restart_restart_time,
2912 bgp_graceful_restart_restart_time_cmd,
2913 "bgp graceful-restart restart-time (0-4095)",
2914 BGP_STR
2915 "Graceful restart capability parameters\n"
2916 "Set the time to wait to delete stale routes before a BGP open message is received\n"
2917 "Delay value (seconds)\n")
2918 {
2919 VTY_DECLVAR_CONTEXT(bgp, bgp);
2920 int idx_number = 3;
2921 uint32_t restart;
2922
2923 restart = strtoul(argv[idx_number]->arg, NULL, 10);
2924 bgp->restart_time = restart;
2925 return CMD_SUCCESS;
2926 }
2927
2928 DEFUN (bgp_graceful_restart_select_defer_time,
2929 bgp_graceful_restart_select_defer_time_cmd,
2930 "bgp graceful-restart select-defer-time (0-3600)",
2931 BGP_STR
2932 "Graceful restart capability parameters\n"
2933 "Set the time to defer the BGP route selection after restart\n"
2934 "Delay value (seconds, 0 - disable)\n")
2935 {
2936 VTY_DECLVAR_CONTEXT(bgp, bgp);
2937 int idx_number = 3;
2938 uint32_t defer_time;
2939
2940 defer_time = strtoul(argv[idx_number]->arg, NULL, 10);
2941 bgp->select_defer_time = defer_time;
2942 if (defer_time == 0)
2943 SET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
2944 else
2945 UNSET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
2946
2947 return CMD_SUCCESS;
2948 }
2949
2950 DEFUN (no_bgp_graceful_restart_stalepath_time,
2951 no_bgp_graceful_restart_stalepath_time_cmd,
2952 "no bgp graceful-restart stalepath-time [(1-4095)]",
2953 NO_STR
2954 BGP_STR
2955 "Graceful restart capability parameters\n"
2956 "Set the max time to hold onto restarting peer's stale paths\n"
2957 "Delay value (seconds)\n")
2958 {
2959 VTY_DECLVAR_CONTEXT(bgp, bgp);
2960
2961 bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
2962 return CMD_SUCCESS;
2963 }
2964
2965 DEFUN (no_bgp_graceful_restart_restart_time,
2966 no_bgp_graceful_restart_restart_time_cmd,
2967 "no bgp graceful-restart restart-time [(0-4095)]",
2968 NO_STR
2969 BGP_STR
2970 "Graceful restart capability parameters\n"
2971 "Set the time to wait to delete stale routes before a BGP open message is received\n"
2972 "Delay value (seconds)\n")
2973 {
2974 VTY_DECLVAR_CONTEXT(bgp, bgp);
2975
2976 bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
2977 return CMD_SUCCESS;
2978 }
2979
2980 DEFUN (no_bgp_graceful_restart_select_defer_time,
2981 no_bgp_graceful_restart_select_defer_time_cmd,
2982 "no bgp graceful-restart select-defer-time [(0-3600)]",
2983 NO_STR
2984 BGP_STR
2985 "Graceful restart capability parameters\n"
2986 "Set the time to defer the BGP route selection after restart\n"
2987 "Delay value (seconds)\n")
2988 {
2989 VTY_DECLVAR_CONTEXT(bgp, bgp);
2990
2991 bgp->select_defer_time = BGP_DEFAULT_SELECT_DEFERRAL_TIME;
2992 UNSET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
2993
2994 return CMD_SUCCESS;
2995 }
2996
2997 DEFUN (bgp_graceful_restart_preserve_fw,
2998 bgp_graceful_restart_preserve_fw_cmd,
2999 "bgp graceful-restart preserve-fw-state",
3000 BGP_STR
3001 "Graceful restart capability parameters\n"
3002 "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
3003 {
3004 VTY_DECLVAR_CONTEXT(bgp, bgp);
3005 SET_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD);
3006 return CMD_SUCCESS;
3007 }
3008
3009 DEFUN (no_bgp_graceful_restart_preserve_fw,
3010 no_bgp_graceful_restart_preserve_fw_cmd,
3011 "no bgp graceful-restart preserve-fw-state",
3012 NO_STR
3013 BGP_STR
3014 "Graceful restart capability parameters\n"
3015 "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
3016 {
3017 VTY_DECLVAR_CONTEXT(bgp, bgp);
3018 UNSET_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD);
3019 return CMD_SUCCESS;
3020 }
3021
3022 DEFPY (bgp_graceful_restart_notification,
3023 bgp_graceful_restart_notification_cmd,
3024 "[no$no] bgp graceful-restart notification",
3025 NO_STR
3026 BGP_STR
3027 "Graceful restart capability parameters\n"
3028 "Indicate Graceful Restart support for BGP NOTIFICATION messages\n")
3029 {
3030 VTY_DECLVAR_CONTEXT(bgp, bgp);
3031
3032 if (no)
3033 UNSET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
3034 else
3035 SET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
3036
3037 return CMD_SUCCESS;
3038 }
3039
3040 DEFPY (bgp_administrative_reset,
3041 bgp_administrative_reset_cmd,
3042 "[no$no] bgp hard-administrative-reset",
3043 NO_STR
3044 BGP_STR
3045 "Send Hard Reset CEASE Notification for 'Administrative Reset'\n")
3046 {
3047 VTY_DECLVAR_CONTEXT(bgp, bgp);
3048
3049 if (no)
3050 UNSET_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET);
3051 else
3052 SET_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET);
3053
3054 return CMD_SUCCESS;
3055 }
3056
3057 DEFUN (bgp_graceful_restart_disable,
3058 bgp_graceful_restart_disable_cmd,
3059 "bgp graceful-restart-disable",
3060 BGP_STR
3061 GR_DISABLE)
3062 {
3063 int ret = BGP_GR_FAILURE;
3064
3065 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3066 zlog_debug(
3067 "[BGP_GR] bgp_graceful_restart_disable_cmd : START ");
3068
3069 VTY_DECLVAR_CONTEXT(bgp, bgp);
3070
3071 ret = bgp_gr_update_all(bgp, GLOBAL_DISABLE_CMD);
3072
3073 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp,
3074 bgp->peer, ret);
3075
3076 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3077 zlog_debug(
3078 "[BGP_GR] bgp_graceful_restart_disable_cmd : END ");
3079 vty_out(vty,
3080 "Graceful restart configuration changed, reset all peers to take effect\n");
3081
3082 return bgp_vty_return(vty, ret);
3083 }
3084
3085 DEFUN (no_bgp_graceful_restart_disable,
3086 no_bgp_graceful_restart_disable_cmd,
3087 "no bgp graceful-restart-disable",
3088 NO_STR
3089 BGP_STR
3090 NO_GR_DISABLE
3091 )
3092 {
3093 VTY_DECLVAR_CONTEXT(bgp, bgp);
3094
3095 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3096 zlog_debug(
3097 "[BGP_GR] no_bgp_graceful_restart_disable_cmd : START ");
3098
3099 int ret = BGP_GR_FAILURE;
3100
3101 ret = bgp_gr_update_all(bgp, NO_GLOBAL_DISABLE_CMD);
3102
3103 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
3104 ret);
3105
3106 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3107 zlog_debug(
3108 "[BGP_GR] no_bgp_graceful_restart_disable_cmd : END ");
3109 vty_out(vty,
3110 "Graceful restart configuration changed, reset all peers to take effect\n");
3111
3112 return bgp_vty_return(vty, ret);
3113 }
3114
3115 DEFUN (bgp_neighbor_graceful_restart_set,
3116 bgp_neighbor_graceful_restart_set_cmd,
3117 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
3118 NEIGHBOR_STR
3119 NEIGHBOR_ADDR_STR2
3120 GR_NEIGHBOR_CMD
3121 )
3122 {
3123 int idx_peer = 1;
3124 struct peer *peer;
3125 int ret = BGP_GR_FAILURE;
3126
3127 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3128
3129 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3130 zlog_debug(
3131 "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : START ");
3132
3133 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3134 if (!peer)
3135 return CMD_WARNING_CONFIG_FAILED;
3136
3137 ret = bgp_neighbor_graceful_restart(peer, PEER_GR_CMD);
3138
3139 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3140 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3141
3142 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3143 zlog_debug(
3144 "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : END ");
3145 vty_out(vty,
3146 "Graceful restart configuration changed, reset this peer to take effect\n");
3147
3148 return bgp_vty_return(vty, ret);
3149 }
3150
3151 DEFUN (no_bgp_neighbor_graceful_restart,
3152 no_bgp_neighbor_graceful_restart_set_cmd,
3153 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
3154 NO_STR
3155 NEIGHBOR_STR
3156 NEIGHBOR_ADDR_STR2
3157 NO_GR_NEIGHBOR_CMD
3158 )
3159 {
3160 int idx_peer = 2;
3161 int ret = BGP_GR_FAILURE;
3162 struct peer *peer;
3163
3164 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3165
3166 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3167 if (!peer)
3168 return CMD_WARNING_CONFIG_FAILED;
3169
3170 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3171 zlog_debug(
3172 "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : START ");
3173
3174 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_GR_CMD);
3175
3176 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3177 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3178
3179 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3180 zlog_debug(
3181 "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : END ");
3182 vty_out(vty,
3183 "Graceful restart configuration changed, reset this peer to take effect\n");
3184
3185 return bgp_vty_return(vty, ret);
3186 }
3187
3188 DEFUN (bgp_neighbor_graceful_restart_helper_set,
3189 bgp_neighbor_graceful_restart_helper_set_cmd,
3190 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
3191 NEIGHBOR_STR
3192 NEIGHBOR_ADDR_STR2
3193 GR_NEIGHBOR_HELPER_CMD
3194 )
3195 {
3196 int idx_peer = 1;
3197 struct peer *peer;
3198 int ret = BGP_GR_FAILURE;
3199
3200 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3201
3202 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3203 zlog_debug(
3204 "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : START ");
3205
3206 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3207
3208 if (!peer)
3209 return CMD_WARNING_CONFIG_FAILED;
3210
3211
3212 ret = bgp_neighbor_graceful_restart(peer, PEER_HELPER_CMD);
3213
3214 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3215 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3216
3217 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3218 zlog_debug(
3219 "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : END ");
3220 vty_out(vty,
3221 "Graceful restart configuration changed, reset this peer to take effect\n");
3222
3223 return bgp_vty_return(vty, ret);
3224 }
3225
3226 DEFUN (no_bgp_neighbor_graceful_restart_helper,
3227 no_bgp_neighbor_graceful_restart_helper_set_cmd,
3228 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
3229 NO_STR
3230 NEIGHBOR_STR
3231 NEIGHBOR_ADDR_STR2
3232 NO_GR_NEIGHBOR_HELPER_CMD
3233 )
3234 {
3235 int idx_peer = 2;
3236 int ret = BGP_GR_FAILURE;
3237 struct peer *peer;
3238
3239 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3240
3241 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3242 if (!peer)
3243 return CMD_WARNING_CONFIG_FAILED;
3244
3245 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3246 zlog_debug(
3247 "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
3248
3249 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_HELPER_CMD);
3250
3251 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3252 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3253
3254 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3255 zlog_debug(
3256 "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
3257 vty_out(vty,
3258 "Graceful restart configuration changed, reset this peer to take effect\n");
3259
3260 return bgp_vty_return(vty, ret);
3261 }
3262
3263 DEFUN (bgp_neighbor_graceful_restart_disable_set,
3264 bgp_neighbor_graceful_restart_disable_set_cmd,
3265 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
3266 NEIGHBOR_STR
3267 NEIGHBOR_ADDR_STR2
3268 GR_NEIGHBOR_DISABLE_CMD
3269 )
3270 {
3271 int idx_peer = 1;
3272 struct peer *peer;
3273 int ret = BGP_GR_FAILURE;
3274
3275 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3276
3277 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3278 zlog_debug(
3279 "[BGP_GR] bgp_neighbor_graceful_restart_disable_set_cmd : START ");
3280
3281 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3282 if (!peer)
3283 return CMD_WARNING_CONFIG_FAILED;
3284
3285 ret = bgp_neighbor_graceful_restart(peer, PEER_DISABLE_CMD);
3286
3287 if (peer->bgp->t_startup)
3288 bgp_peer_gr_flags_update(peer);
3289
3290 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3291 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3292
3293 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3294 zlog_debug(
3295 "[BGP_GR]bgp_neighbor_graceful_restart_disable_set_cmd : END ");
3296 vty_out(vty,
3297 "Graceful restart configuration changed, reset this peer to take effect\n");
3298
3299 return bgp_vty_return(vty, ret);
3300 }
3301
3302 DEFUN (no_bgp_neighbor_graceful_restart_disable,
3303 no_bgp_neighbor_graceful_restart_disable_set_cmd,
3304 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
3305 NO_STR
3306 NEIGHBOR_STR
3307 NEIGHBOR_ADDR_STR2
3308 NO_GR_NEIGHBOR_DISABLE_CMD
3309 )
3310 {
3311 int idx_peer = 2;
3312 int ret = BGP_GR_FAILURE;
3313 struct peer *peer;
3314
3315 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3316
3317 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3318 if (!peer)
3319 return CMD_WARNING_CONFIG_FAILED;
3320
3321 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3322 zlog_debug(
3323 "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
3324
3325 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_DISABLE_CMD);
3326
3327 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3328 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3329
3330 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3331 zlog_debug(
3332 "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
3333 vty_out(vty,
3334 "Graceful restart configuration changed, reset this peer to take effect\n");
3335
3336 return bgp_vty_return(vty, ret);
3337 }
3338
3339 DEFUN_HIDDEN (bgp_graceful_restart_disable_eor,
3340 bgp_graceful_restart_disable_eor_cmd,
3341 "bgp graceful-restart disable-eor",
3342 BGP_STR
3343 "Graceful restart configuration parameters\n"
3344 "Disable EOR Check\n")
3345 {
3346 VTY_DECLVAR_CONTEXT(bgp, bgp);
3347 SET_FLAG(bgp->flags, BGP_FLAG_GR_DISABLE_EOR);
3348
3349 return CMD_SUCCESS;
3350 }
3351
3352 DEFUN_HIDDEN (no_bgp_graceful_restart_disable_eor,
3353 no_bgp_graceful_restart_disable_eor_cmd,
3354 "no bgp graceful-restart disable-eor",
3355 NO_STR
3356 BGP_STR
3357 "Graceful restart configuration parameters\n"
3358 "Disable EOR Check\n")
3359 {
3360 VTY_DECLVAR_CONTEXT(bgp, bgp);
3361 UNSET_FLAG(bgp->flags, BGP_FLAG_GR_DISABLE_EOR);
3362
3363 return CMD_SUCCESS;
3364 }
3365
3366 DEFUN (bgp_graceful_restart_rib_stale_time,
3367 bgp_graceful_restart_rib_stale_time_cmd,
3368 "bgp graceful-restart rib-stale-time (1-3600)",
3369 BGP_STR
3370 "Graceful restart configuration parameters\n"
3371 "Specify the stale route removal timer in rib\n"
3372 "Delay value (seconds)\n")
3373 {
3374 VTY_DECLVAR_CONTEXT(bgp, bgp);
3375 int idx_number = 3;
3376 uint32_t stale_time;
3377
3378 stale_time = strtoul(argv[idx_number]->arg, NULL, 10);
3379 bgp->rib_stale_time = stale_time;
3380 /* Send the stale timer update message to RIB */
3381 if (bgp_zebra_stale_timer_update(bgp))
3382 return CMD_WARNING;
3383
3384 return CMD_SUCCESS;
3385 }
3386
3387 DEFUN (no_bgp_graceful_restart_rib_stale_time,
3388 no_bgp_graceful_restart_rib_stale_time_cmd,
3389 "no bgp graceful-restart rib-stale-time [(1-3600)]",
3390 NO_STR
3391 BGP_STR
3392 "Graceful restart configuration parameters\n"
3393 "Specify the stale route removal timer in rib\n"
3394 "Delay value (seconds)\n")
3395 {
3396 VTY_DECLVAR_CONTEXT(bgp, bgp);
3397
3398 bgp->rib_stale_time = BGP_DEFAULT_RIB_STALE_TIME;
3399 /* Send the stale timer update message to RIB */
3400 if (bgp_zebra_stale_timer_update(bgp))
3401 return CMD_WARNING;
3402
3403 return CMD_SUCCESS;
3404 }
3405
3406 DEFUN(bgp_llgr_stalepath_time, bgp_llgr_stalepath_time_cmd,
3407 "bgp long-lived-graceful-restart stale-time (1-4294967295)",
3408 BGP_STR
3409 "Enable Long-lived Graceful Restart\n"
3410 "Specifies maximum time to wait before purging long-lived stale routes\n"
3411 "Stale time value (seconds)\n")
3412 {
3413 VTY_DECLVAR_CONTEXT(bgp, bgp);
3414
3415 uint32_t llgr_stale_time;
3416
3417 llgr_stale_time = strtoul(argv[3]->arg, NULL, 10);
3418 bgp->llgr_stale_time = llgr_stale_time;
3419
3420 return CMD_SUCCESS;
3421 }
3422
3423 DEFUN(no_bgp_llgr_stalepath_time, no_bgp_llgr_stalepath_time_cmd,
3424 "no bgp long-lived-graceful-restart stale-time [(1-4294967295)]",
3425 NO_STR BGP_STR
3426 "Enable Long-lived Graceful Restart\n"
3427 "Specifies maximum time to wait before purging long-lived stale routes\n"
3428 "Stale time value (seconds)\n")
3429 {
3430 VTY_DECLVAR_CONTEXT(bgp, bgp);
3431
3432 bgp->llgr_stale_time = BGP_DEFAULT_LLGR_STALE_TIME;
3433
3434 return CMD_SUCCESS;
3435 }
3436
3437 static inline void bgp_initiate_graceful_shut_unshut(struct vty *vty,
3438 struct bgp *bgp)
3439 {
3440 bgp_static_redo_import_check(bgp);
3441 bgp_redistribute_redo(bgp);
3442 bgp_clear_star_soft_out(vty, bgp->name);
3443 bgp_clear_star_soft_in(vty, bgp->name);
3444 }
3445
3446 static int bgp_global_graceful_shutdown_config_vty(struct vty *vty)
3447 {
3448 struct listnode *node, *nnode;
3449 struct bgp *bgp;
3450 bool vrf_cfg = false;
3451
3452 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
3453 return CMD_SUCCESS;
3454
3455 /* See if graceful-shutdown is set per-vrf and warn user to delete */
3456 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
3457 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3458 vty_out(vty,
3459 "%% graceful-shutdown configuration found in vrf %s\n",
3460 bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT ?
3461 VRF_DEFAULT_NAME : bgp->name);
3462 vrf_cfg = true;
3463 }
3464 }
3465
3466 if (vrf_cfg) {
3467 vty_out(vty,
3468 "%%Failed: global graceful-shutdown not permitted\n");
3469 return CMD_WARNING;
3470 }
3471
3472 /* Set flag globally */
3473 SET_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN);
3474
3475 /* Initiate processing for all BGP instances. */
3476 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3477 bgp_initiate_graceful_shut_unshut(vty, bgp);
3478
3479 return CMD_SUCCESS;
3480 }
3481
3482 static int bgp_global_graceful_shutdown_deconfig_vty(struct vty *vty)
3483 {
3484 struct listnode *node, *nnode;
3485 struct bgp *bgp;
3486
3487 if (!CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
3488 return CMD_SUCCESS;
3489
3490 /* Unset flag globally */
3491 UNSET_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN);
3492
3493 /* Initiate processing for all BGP instances. */
3494 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3495 bgp_initiate_graceful_shut_unshut(vty, bgp);
3496
3497 return CMD_SUCCESS;
3498 }
3499
3500 /* "bgp graceful-shutdown" configuration */
3501 DEFUN (bgp_graceful_shutdown,
3502 bgp_graceful_shutdown_cmd,
3503 "bgp graceful-shutdown",
3504 BGP_STR
3505 "Graceful shutdown parameters\n")
3506 {
3507 if (vty->node == CONFIG_NODE)
3508 return bgp_global_graceful_shutdown_config_vty(vty);
3509
3510 VTY_DECLVAR_CONTEXT(bgp, bgp);
3511
3512 /* if configured globally, per-instance config is not allowed */
3513 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN)) {
3514 vty_out(vty,
3515 "%%Failed: per-vrf graceful-shutdown config not permitted with global graceful-shutdown\n");
3516 return CMD_WARNING_CONFIG_FAILED;
3517 }
3518
3519 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3520 SET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN);
3521 bgp_initiate_graceful_shut_unshut(vty, bgp);
3522 }
3523
3524 return CMD_SUCCESS;
3525 }
3526
3527 DEFUN (no_bgp_graceful_shutdown,
3528 no_bgp_graceful_shutdown_cmd,
3529 "no bgp graceful-shutdown",
3530 NO_STR
3531 BGP_STR
3532 "Graceful shutdown parameters\n")
3533 {
3534 if (vty->node == CONFIG_NODE)
3535 return bgp_global_graceful_shutdown_deconfig_vty(vty);
3536
3537 VTY_DECLVAR_CONTEXT(bgp, bgp);
3538
3539 /* If configured globally, cannot remove from one bgp instance */
3540 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN)) {
3541 vty_out(vty,
3542 "%%Failed: bgp graceful-shutdown configured globally. Delete per-vrf not permitted\n");
3543 return CMD_WARNING_CONFIG_FAILED;
3544 }
3545
3546 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3547 UNSET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN);
3548 bgp_initiate_graceful_shut_unshut(vty, bgp);
3549 }
3550
3551 return CMD_SUCCESS;
3552 }
3553
3554 /* "bgp fast-external-failover" configuration. */
3555 DEFUN (bgp_fast_external_failover,
3556 bgp_fast_external_failover_cmd,
3557 "bgp fast-external-failover",
3558 BGP_STR
3559 "Immediately reset session if a link to a directly connected external peer goes down\n")
3560 {
3561 VTY_DECLVAR_CONTEXT(bgp, bgp);
3562 UNSET_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER);
3563 return CMD_SUCCESS;
3564 }
3565
3566 DEFUN (no_bgp_fast_external_failover,
3567 no_bgp_fast_external_failover_cmd,
3568 "no bgp fast-external-failover",
3569 NO_STR
3570 BGP_STR
3571 "Immediately reset session if a link to a directly connected external peer goes down\n")
3572 {
3573 VTY_DECLVAR_CONTEXT(bgp, bgp);
3574 SET_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER);
3575 return CMD_SUCCESS;
3576 }
3577
3578 /* "bgp bestpath compare-routerid" configuration. */
3579 DEFUN (bgp_bestpath_compare_router_id,
3580 bgp_bestpath_compare_router_id_cmd,
3581 "bgp bestpath compare-routerid",
3582 BGP_STR
3583 "Change the default bestpath selection\n"
3584 "Compare router-id for identical EBGP paths\n")
3585 {
3586 VTY_DECLVAR_CONTEXT(bgp, bgp);
3587 SET_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID);
3588 bgp_recalculate_all_bestpaths(bgp);
3589
3590 return CMD_SUCCESS;
3591 }
3592
3593 DEFUN (no_bgp_bestpath_compare_router_id,
3594 no_bgp_bestpath_compare_router_id_cmd,
3595 "no bgp bestpath compare-routerid",
3596 NO_STR
3597 BGP_STR
3598 "Change the default bestpath selection\n"
3599 "Compare router-id for identical EBGP paths\n")
3600 {
3601 VTY_DECLVAR_CONTEXT(bgp, bgp);
3602 UNSET_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID);
3603 bgp_recalculate_all_bestpaths(bgp);
3604
3605 return CMD_SUCCESS;
3606 }
3607
3608 /* "bgp bestpath as-path ignore" configuration. */
3609 DEFUN (bgp_bestpath_aspath_ignore,
3610 bgp_bestpath_aspath_ignore_cmd,
3611 "bgp bestpath as-path ignore",
3612 BGP_STR
3613 "Change the default bestpath selection\n"
3614 "AS-path attribute\n"
3615 "Ignore as-path length in selecting a route\n")
3616 {
3617 VTY_DECLVAR_CONTEXT(bgp, bgp);
3618 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE);
3619 bgp_recalculate_all_bestpaths(bgp);
3620
3621 return CMD_SUCCESS;
3622 }
3623
3624 DEFUN (no_bgp_bestpath_aspath_ignore,
3625 no_bgp_bestpath_aspath_ignore_cmd,
3626 "no bgp bestpath as-path ignore",
3627 NO_STR
3628 BGP_STR
3629 "Change the default bestpath selection\n"
3630 "AS-path attribute\n"
3631 "Ignore as-path length in selecting a route\n")
3632 {
3633 VTY_DECLVAR_CONTEXT(bgp, bgp);
3634 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE);
3635 bgp_recalculate_all_bestpaths(bgp);
3636
3637 return CMD_SUCCESS;
3638 }
3639
3640 /* "bgp bestpath as-path confed" configuration. */
3641 DEFUN (bgp_bestpath_aspath_confed,
3642 bgp_bestpath_aspath_confed_cmd,
3643 "bgp bestpath as-path confed",
3644 BGP_STR
3645 "Change the default bestpath selection\n"
3646 "AS-path attribute\n"
3647 "Compare path lengths including confederation sets & sequences in selecting a route\n")
3648 {
3649 VTY_DECLVAR_CONTEXT(bgp, bgp);
3650 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED);
3651 bgp_recalculate_all_bestpaths(bgp);
3652
3653 return CMD_SUCCESS;
3654 }
3655
3656 DEFUN (no_bgp_bestpath_aspath_confed,
3657 no_bgp_bestpath_aspath_confed_cmd,
3658 "no bgp bestpath as-path confed",
3659 NO_STR
3660 BGP_STR
3661 "Change the default bestpath selection\n"
3662 "AS-path attribute\n"
3663 "Compare path lengths including confederation sets & sequences in selecting a route\n")
3664 {
3665 VTY_DECLVAR_CONTEXT(bgp, bgp);
3666 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED);
3667 bgp_recalculate_all_bestpaths(bgp);
3668
3669 return CMD_SUCCESS;
3670 }
3671
3672 /* "bgp bestpath as-path multipath-relax" configuration. */
3673 DEFUN (bgp_bestpath_aspath_multipath_relax,
3674 bgp_bestpath_aspath_multipath_relax_cmd,
3675 "bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
3676 BGP_STR
3677 "Change the default bestpath selection\n"
3678 "AS-path attribute\n"
3679 "Allow load sharing across routes that have different AS paths (but same length)\n"
3680 "Generate an AS_SET\n"
3681 "Do not generate an AS_SET\n")
3682 {
3683 VTY_DECLVAR_CONTEXT(bgp, bgp);
3684 int idx = 0;
3685 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
3686
3687 /* no-as-set is now the default behavior so we can silently
3688 * ignore it */
3689 if (argv_find(argv, argc, "as-set", &idx))
3690 SET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3691 else
3692 UNSET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3693
3694 bgp_recalculate_all_bestpaths(bgp);
3695
3696 return CMD_SUCCESS;
3697 }
3698
3699 DEFUN (no_bgp_bestpath_aspath_multipath_relax,
3700 no_bgp_bestpath_aspath_multipath_relax_cmd,
3701 "no bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
3702 NO_STR
3703 BGP_STR
3704 "Change the default bestpath selection\n"
3705 "AS-path attribute\n"
3706 "Allow load sharing across routes that have different AS paths (but same length)\n"
3707 "Generate an AS_SET\n"
3708 "Do not generate an AS_SET\n")
3709 {
3710 VTY_DECLVAR_CONTEXT(bgp, bgp);
3711 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
3712 UNSET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3713 bgp_recalculate_all_bestpaths(bgp);
3714
3715 return CMD_SUCCESS;
3716 }
3717
3718 /* "bgp bestpath peer-type multipath-relax" configuration. */
3719 DEFUN(bgp_bestpath_peer_type_multipath_relax,
3720 bgp_bestpath_peer_type_multipath_relax_cmd,
3721 "bgp bestpath peer-type multipath-relax",
3722 BGP_STR
3723 "Change the default bestpath selection\n"
3724 "Peer type\n"
3725 "Allow load sharing across routes learned from different peer types\n")
3726 {
3727 VTY_DECLVAR_CONTEXT(bgp, bgp);
3728 SET_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX);
3729 bgp_recalculate_all_bestpaths(bgp);
3730
3731 return CMD_SUCCESS;
3732 }
3733
3734 DEFUN(no_bgp_bestpath_peer_type_multipath_relax,
3735 no_bgp_bestpath_peer_type_multipath_relax_cmd,
3736 "no bgp bestpath peer-type multipath-relax",
3737 NO_STR BGP_STR
3738 "Change the default bestpath selection\n"
3739 "Peer type\n"
3740 "Allow load sharing across routes learned from different peer types\n")
3741 {
3742 VTY_DECLVAR_CONTEXT(bgp, bgp);
3743 UNSET_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX);
3744 bgp_recalculate_all_bestpaths(bgp);
3745
3746 return CMD_SUCCESS;
3747 }
3748
3749 /* "bgp log-neighbor-changes" configuration. */
3750 DEFUN (bgp_log_neighbor_changes,
3751 bgp_log_neighbor_changes_cmd,
3752 "bgp log-neighbor-changes",
3753 BGP_STR
3754 "Log neighbor up/down and reset reason\n")
3755 {
3756 VTY_DECLVAR_CONTEXT(bgp, bgp);
3757 SET_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
3758 return CMD_SUCCESS;
3759 }
3760
3761 DEFUN (no_bgp_log_neighbor_changes,
3762 no_bgp_log_neighbor_changes_cmd,
3763 "no bgp log-neighbor-changes",
3764 NO_STR
3765 BGP_STR
3766 "Log neighbor up/down and reset reason\n")
3767 {
3768 VTY_DECLVAR_CONTEXT(bgp, bgp);
3769 UNSET_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
3770 return CMD_SUCCESS;
3771 }
3772
3773 /* "bgp bestpath med" configuration. */
3774 DEFUN (bgp_bestpath_med,
3775 bgp_bestpath_med_cmd,
3776 "bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
3777 BGP_STR
3778 "Change the default bestpath selection\n"
3779 "MED attribute\n"
3780 "Compare MED among confederation paths\n"
3781 "Treat missing MED as the least preferred one\n"
3782 "Treat missing MED as the least preferred one\n"
3783 "Compare MED among confederation paths\n")
3784 {
3785 VTY_DECLVAR_CONTEXT(bgp, bgp);
3786
3787 int idx = 0;
3788 if (argv_find(argv, argc, "confed", &idx))
3789 SET_FLAG(bgp->flags, BGP_FLAG_MED_CONFED);
3790 idx = 0;
3791 if (argv_find(argv, argc, "missing-as-worst", &idx))
3792 SET_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST);
3793
3794 bgp_recalculate_all_bestpaths(bgp);
3795
3796 return CMD_SUCCESS;
3797 }
3798
3799 DEFUN (no_bgp_bestpath_med,
3800 no_bgp_bestpath_med_cmd,
3801 "no bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
3802 NO_STR
3803 BGP_STR
3804 "Change the default bestpath selection\n"
3805 "MED attribute\n"
3806 "Compare MED among confederation paths\n"
3807 "Treat missing MED as the least preferred one\n"
3808 "Treat missing MED as the least preferred one\n"
3809 "Compare MED among confederation paths\n")
3810 {
3811 VTY_DECLVAR_CONTEXT(bgp, bgp);
3812
3813 int idx = 0;
3814 if (argv_find(argv, argc, "confed", &idx))
3815 UNSET_FLAG(bgp->flags, BGP_FLAG_MED_CONFED);
3816 idx = 0;
3817 if (argv_find(argv, argc, "missing-as-worst", &idx))
3818 UNSET_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST);
3819
3820 bgp_recalculate_all_bestpaths(bgp);
3821
3822 return CMD_SUCCESS;
3823 }
3824
3825 /* "bgp bestpath bandwidth" configuration. */
3826 DEFPY (bgp_bestpath_bw,
3827 bgp_bestpath_bw_cmd,
3828 "bgp bestpath bandwidth <ignore|skip-missing|default-weight-for-missing>$bw_cfg",
3829 BGP_STR
3830 "Change the default bestpath selection\n"
3831 "Link Bandwidth attribute\n"
3832 "Ignore link bandwidth (i.e., do regular ECMP, not weighted)\n"
3833 "Ignore paths without link bandwidth for ECMP (if other paths have it)\n"
3834 "Assign a low default weight (value 1) to paths not having link bandwidth\n")
3835 {
3836 VTY_DECLVAR_CONTEXT(bgp, bgp);
3837 afi_t afi;
3838 safi_t safi;
3839
3840 if (!bw_cfg) {
3841 vty_out(vty, "%% Bandwidth configuration must be specified\n");
3842 return CMD_ERR_INCOMPLETE;
3843 }
3844 if (!strcmp(bw_cfg, "ignore"))
3845 bgp->lb_handling = BGP_LINK_BW_IGNORE_BW;
3846 else if (!strcmp(bw_cfg, "skip-missing"))
3847 bgp->lb_handling = BGP_LINK_BW_SKIP_MISSING;
3848 else if (!strcmp(bw_cfg, "default-weight-for-missing"))
3849 bgp->lb_handling = BGP_LINK_BW_DEFWT_4_MISSING;
3850 else
3851 return CMD_ERR_NO_MATCH;
3852
3853 /* This config is used in route install, so redo that. */
3854 FOREACH_AFI_SAFI (afi, safi) {
3855 if (!bgp_fibupd_safi(safi))
3856 continue;
3857 bgp_zebra_announce_table(bgp, afi, safi);
3858 }
3859
3860 return CMD_SUCCESS;
3861 }
3862
3863 DEFPY (no_bgp_bestpath_bw,
3864 no_bgp_bestpath_bw_cmd,
3865 "no bgp bestpath bandwidth [<ignore|skip-missing|default-weight-for-missing>$bw_cfg]",
3866 NO_STR
3867 BGP_STR
3868 "Change the default bestpath selection\n"
3869 "Link Bandwidth attribute\n"
3870 "Ignore link bandwidth (i.e., do regular ECMP, not weighted)\n"
3871 "Ignore paths without link bandwidth for ECMP (if other paths have it)\n"
3872 "Assign a low default weight (value 1) to paths not having link bandwidth\n")
3873 {
3874 VTY_DECLVAR_CONTEXT(bgp, bgp);
3875 afi_t afi;
3876 safi_t safi;
3877
3878 bgp->lb_handling = BGP_LINK_BW_ECMP;
3879
3880 /* This config is used in route install, so redo that. */
3881 FOREACH_AFI_SAFI (afi, safi) {
3882 if (!bgp_fibupd_safi(safi))
3883 continue;
3884 bgp_zebra_announce_table(bgp, afi, safi);
3885 }
3886 return CMD_SUCCESS;
3887 }
3888
3889 DEFPY(bgp_default_afi_safi, bgp_default_afi_safi_cmd,
3890 "[no] bgp default <ipv4-unicast|"
3891 "ipv4-multicast|"
3892 "ipv4-vpn|"
3893 "ipv4-labeled-unicast|"
3894 "ipv4-flowspec|"
3895 "ipv6-unicast|"
3896 "ipv6-multicast|"
3897 "ipv6-vpn|"
3898 "ipv6-labeled-unicast|"
3899 "ipv6-flowspec|"
3900 "l2vpn-evpn>$afi_safi",
3901 NO_STR
3902 BGP_STR
3903 "Configure BGP defaults\n"
3904 "Activate ipv4-unicast for a peer by default\n"
3905 "Activate ipv4-multicast for a peer by default\n"
3906 "Activate ipv4-vpn for a peer by default\n"
3907 "Activate ipv4-labeled-unicast for a peer by default\n"
3908 "Activate ipv4-flowspec for a peer by default\n"
3909 "Activate ipv6-unicast for a peer by default\n"
3910 "Activate ipv6-multicast for a peer by default\n"
3911 "Activate ipv6-vpn for a peer by default\n"
3912 "Activate ipv6-labeled-unicast for a peer by default\n"
3913 "Activate ipv6-flowspec for a peer by default\n"
3914 "Activate l2vpn-evpn for a peer by default\n")
3915 {
3916 VTY_DECLVAR_CONTEXT(bgp, bgp);
3917 char afi_safi_str[strlen(afi_safi) + 1];
3918 char *afi_safi_str_tok;
3919
3920 strlcpy(afi_safi_str, afi_safi, sizeof(afi_safi_str));
3921 char *afi_str = strtok_r(afi_safi_str, "-", &afi_safi_str_tok);
3922 char *safi_str = strtok_r(NULL, "-", &afi_safi_str_tok);
3923 afi_t afi = bgp_vty_afi_from_str(afi_str);
3924 safi_t safi;
3925
3926 /*
3927 * Impossible situation but making coverity happy
3928 */
3929 assert(afi != AFI_MAX);
3930
3931 if (strmatch(safi_str, "labeled"))
3932 safi = bgp_vty_safi_from_str("labeled-unicast");
3933 else
3934 safi = bgp_vty_safi_from_str(safi_str);
3935
3936 assert(safi != SAFI_MAX);
3937 if (no)
3938 bgp->default_af[afi][safi] = false;
3939 else {
3940 if ((safi == SAFI_LABELED_UNICAST
3941 && bgp->default_af[afi][SAFI_UNICAST])
3942 || (safi == SAFI_UNICAST
3943 && bgp->default_af[afi][SAFI_LABELED_UNICAST]))
3944 bgp_vty_return(vty, BGP_ERR_PEER_SAFI_CONFLICT);
3945 else
3946 bgp->default_af[afi][safi] = true;
3947 }
3948
3949 return CMD_SUCCESS;
3950 }
3951
3952 /* Display hostname in certain command outputs */
3953 DEFUN (bgp_default_show_hostname,
3954 bgp_default_show_hostname_cmd,
3955 "bgp default show-hostname",
3956 BGP_STR
3957 "Configure BGP defaults\n"
3958 "Show hostname in certain command outputs\n")
3959 {
3960 VTY_DECLVAR_CONTEXT(bgp, bgp);
3961 SET_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME);
3962 return CMD_SUCCESS;
3963 }
3964
3965 DEFUN (no_bgp_default_show_hostname,
3966 no_bgp_default_show_hostname_cmd,
3967 "no bgp default show-hostname",
3968 NO_STR
3969 BGP_STR
3970 "Configure BGP defaults\n"
3971 "Show hostname in certain command outputs\n")
3972 {
3973 VTY_DECLVAR_CONTEXT(bgp, bgp);
3974 UNSET_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME);
3975 return CMD_SUCCESS;
3976 }
3977
3978 /* Display hostname in certain command outputs */
3979 DEFUN (bgp_default_show_nexthop_hostname,
3980 bgp_default_show_nexthop_hostname_cmd,
3981 "bgp default show-nexthop-hostname",
3982 BGP_STR
3983 "Configure BGP defaults\n"
3984 "Show hostname for nexthop in certain command outputs\n")
3985 {
3986 VTY_DECLVAR_CONTEXT(bgp, bgp);
3987 SET_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
3988 return CMD_SUCCESS;
3989 }
3990
3991 DEFUN (no_bgp_default_show_nexthop_hostname,
3992 no_bgp_default_show_nexthop_hostname_cmd,
3993 "no bgp default show-nexthop-hostname",
3994 NO_STR
3995 BGP_STR
3996 "Configure BGP defaults\n"
3997 "Show hostname for nexthop in certain command outputs\n")
3998 {
3999 VTY_DECLVAR_CONTEXT(bgp, bgp);
4000 UNSET_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
4001 return CMD_SUCCESS;
4002 }
4003
4004 /* "bgp network import-check" configuration. */
4005 DEFUN (bgp_network_import_check,
4006 bgp_network_import_check_cmd,
4007 "bgp network import-check",
4008 BGP_STR
4009 "BGP network command\n"
4010 "Check BGP network route exists in IGP\n")
4011 {
4012 VTY_DECLVAR_CONTEXT(bgp, bgp);
4013 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)) {
4014 SET_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK);
4015 bgp_static_redo_import_check(bgp);
4016 }
4017
4018 return CMD_SUCCESS;
4019 }
4020
4021 ALIAS_HIDDEN(bgp_network_import_check, bgp_network_import_check_exact_cmd,
4022 "bgp network import-check exact",
4023 BGP_STR
4024 "BGP network command\n"
4025 "Check BGP network route exists in IGP\n"
4026 "Match route precisely\n")
4027
4028 DEFUN (no_bgp_network_import_check,
4029 no_bgp_network_import_check_cmd,
4030 "no bgp network import-check",
4031 NO_STR
4032 BGP_STR
4033 "BGP network command\n"
4034 "Check BGP network route exists in IGP\n")
4035 {
4036 VTY_DECLVAR_CONTEXT(bgp, bgp);
4037 if (CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)) {
4038 UNSET_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK);
4039 bgp_static_redo_import_check(bgp);
4040 }
4041
4042 return CMD_SUCCESS;
4043 }
4044
4045 DEFUN (bgp_default_local_preference,
4046 bgp_default_local_preference_cmd,
4047 "bgp default local-preference (0-4294967295)",
4048 BGP_STR
4049 "Configure BGP defaults\n"
4050 "local preference (higher=more preferred)\n"
4051 "Configure default local preference value\n")
4052 {
4053 VTY_DECLVAR_CONTEXT(bgp, bgp);
4054 int idx_number = 3;
4055 uint32_t local_pref;
4056
4057 local_pref = strtoul(argv[idx_number]->arg, NULL, 10);
4058
4059 bgp_default_local_preference_set(bgp, local_pref);
4060 bgp_clear_star_soft_in(vty, bgp->name);
4061
4062 return CMD_SUCCESS;
4063 }
4064
4065 DEFUN (no_bgp_default_local_preference,
4066 no_bgp_default_local_preference_cmd,
4067 "no bgp default local-preference [(0-4294967295)]",
4068 NO_STR
4069 BGP_STR
4070 "Configure BGP defaults\n"
4071 "local preference (higher=more preferred)\n"
4072 "Configure default local preference value\n")
4073 {
4074 VTY_DECLVAR_CONTEXT(bgp, bgp);
4075 bgp_default_local_preference_unset(bgp);
4076 bgp_clear_star_soft_in(vty, bgp->name);
4077
4078 return CMD_SUCCESS;
4079 }
4080
4081
4082 DEFUN (bgp_default_subgroup_pkt_queue_max,
4083 bgp_default_subgroup_pkt_queue_max_cmd,
4084 "bgp default subgroup-pkt-queue-max (20-100)",
4085 BGP_STR
4086 "Configure BGP defaults\n"
4087 "subgroup-pkt-queue-max\n"
4088 "Configure subgroup packet queue max\n")
4089 {
4090 VTY_DECLVAR_CONTEXT(bgp, bgp);
4091 int idx_number = 3;
4092 uint32_t max_size;
4093
4094 max_size = strtoul(argv[idx_number]->arg, NULL, 10);
4095
4096 bgp_default_subgroup_pkt_queue_max_set(bgp, max_size);
4097
4098 return CMD_SUCCESS;
4099 }
4100
4101 DEFUN (no_bgp_default_subgroup_pkt_queue_max,
4102 no_bgp_default_subgroup_pkt_queue_max_cmd,
4103 "no bgp default subgroup-pkt-queue-max [(20-100)]",
4104 NO_STR
4105 BGP_STR
4106 "Configure BGP defaults\n"
4107 "subgroup-pkt-queue-max\n"
4108 "Configure subgroup packet queue max\n")
4109 {
4110 VTY_DECLVAR_CONTEXT(bgp, bgp);
4111 bgp_default_subgroup_pkt_queue_max_unset(bgp);
4112 return CMD_SUCCESS;
4113 }
4114
4115
4116 DEFUN (bgp_rr_allow_outbound_policy,
4117 bgp_rr_allow_outbound_policy_cmd,
4118 "bgp route-reflector allow-outbound-policy",
4119 BGP_STR
4120 "Allow modifications made by out route-map\n"
4121 "on ibgp neighbors\n")
4122 {
4123 VTY_DECLVAR_CONTEXT(bgp, bgp);
4124
4125 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
4126 SET_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
4127 update_group_announce_rrclients(bgp);
4128 bgp_clear_star_soft_out(vty, bgp->name);
4129 }
4130
4131 return CMD_SUCCESS;
4132 }
4133
4134 DEFUN (no_bgp_rr_allow_outbound_policy,
4135 no_bgp_rr_allow_outbound_policy_cmd,
4136 "no bgp route-reflector allow-outbound-policy",
4137 NO_STR
4138 BGP_STR
4139 "Allow modifications made by out route-map\n"
4140 "on ibgp neighbors\n")
4141 {
4142 VTY_DECLVAR_CONTEXT(bgp, bgp);
4143
4144 if (CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
4145 UNSET_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
4146 update_group_announce_rrclients(bgp);
4147 bgp_clear_star_soft_out(vty, bgp->name);
4148 }
4149
4150 return CMD_SUCCESS;
4151 }
4152
4153 DEFUN (bgp_listen_limit,
4154 bgp_listen_limit_cmd,
4155 "bgp listen limit (1-65535)",
4156 BGP_STR
4157 "BGP Dynamic Neighbors listen commands\n"
4158 "Maximum number of BGP Dynamic Neighbors that can be created\n"
4159 "Configure Dynamic Neighbors listen limit value\n")
4160 {
4161 VTY_DECLVAR_CONTEXT(bgp, bgp);
4162 int idx_number = 3;
4163 int listen_limit;
4164
4165 listen_limit = strtoul(argv[idx_number]->arg, NULL, 10);
4166
4167 bgp_listen_limit_set(bgp, listen_limit);
4168
4169 return CMD_SUCCESS;
4170 }
4171
4172 DEFUN (no_bgp_listen_limit,
4173 no_bgp_listen_limit_cmd,
4174 "no bgp listen limit [(1-65535)]",
4175 NO_STR
4176 BGP_STR
4177 "BGP Dynamic Neighbors listen commands\n"
4178 "Maximum number of BGP Dynamic Neighbors that can be created\n"
4179 "Configure Dynamic Neighbors listen limit value\n")
4180 {
4181 VTY_DECLVAR_CONTEXT(bgp, bgp);
4182 bgp_listen_limit_unset(bgp);
4183 return CMD_SUCCESS;
4184 }
4185
4186
4187 /*
4188 * Check if this listen range is already configured. Check for exact
4189 * match or overlap based on input.
4190 */
4191 static struct peer_group *listen_range_exists(struct bgp *bgp,
4192 struct prefix *range, int exact)
4193 {
4194 struct listnode *node, *nnode;
4195 struct listnode *node1, *nnode1;
4196 struct peer_group *group;
4197 struct prefix *lr;
4198 afi_t afi;
4199 int match;
4200
4201 afi = family2afi(range->family);
4202 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
4203 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node1, nnode1,
4204 lr)) {
4205 if (exact)
4206 match = prefix_same(range, lr);
4207 else
4208 match = (prefix_match(range, lr)
4209 || prefix_match(lr, range));
4210 if (match)
4211 return group;
4212 }
4213 }
4214
4215 return NULL;
4216 }
4217
4218 DEFUN (bgp_listen_range,
4219 bgp_listen_range_cmd,
4220 "bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
4221 BGP_STR
4222 "Configure BGP dynamic neighbors listen range\n"
4223 "Configure BGP dynamic neighbors listen range\n"
4224 NEIGHBOR_ADDR_STR
4225 "Member of the peer-group\n"
4226 "Peer-group name\n")
4227 {
4228 VTY_DECLVAR_CONTEXT(bgp, bgp);
4229 struct prefix range;
4230 struct peer_group *group, *existing_group;
4231 afi_t afi;
4232 int ret;
4233 int idx = 0;
4234
4235 argv_find(argv, argc, "A.B.C.D/M", &idx);
4236 argv_find(argv, argc, "X:X::X:X/M", &idx);
4237 char *prefix = argv[idx]->arg;
4238 argv_find(argv, argc, "PGNAME", &idx);
4239 char *peergroup = argv[idx]->arg;
4240
4241 /* Convert IP prefix string to struct prefix. */
4242 ret = str2prefix(prefix, &range);
4243 if (!ret) {
4244 vty_out(vty, "%% Malformed listen range\n");
4245 return CMD_WARNING_CONFIG_FAILED;
4246 }
4247
4248 afi = family2afi(range.family);
4249
4250 if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
4251 vty_out(vty,
4252 "%% Malformed listen range (link-local address)\n");
4253 return CMD_WARNING_CONFIG_FAILED;
4254 }
4255
4256 apply_mask(&range);
4257
4258 /* Check if same listen range is already configured. */
4259 existing_group = listen_range_exists(bgp, &range, 1);
4260 if (existing_group) {
4261 if (strcmp(existing_group->name, peergroup) == 0)
4262 return CMD_SUCCESS;
4263 else {
4264 vty_out(vty,
4265 "%% Same listen range is attached to peer-group %s\n",
4266 existing_group->name);
4267 return CMD_WARNING_CONFIG_FAILED;
4268 }
4269 }
4270
4271 /* Check if an overlapping listen range exists. */
4272 if (listen_range_exists(bgp, &range, 0)) {
4273 vty_out(vty,
4274 "%% Listen range overlaps with existing listen range\n");
4275 return CMD_WARNING_CONFIG_FAILED;
4276 }
4277
4278 group = peer_group_lookup(bgp, peergroup);
4279 if (!group) {
4280 vty_out(vty, "%% Configure the peer-group first\n");
4281 return CMD_WARNING_CONFIG_FAILED;
4282 }
4283
4284 ret = peer_group_listen_range_add(group, &range);
4285 return bgp_vty_return(vty, ret);
4286 }
4287
4288 DEFUN (no_bgp_listen_range,
4289 no_bgp_listen_range_cmd,
4290 "no bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
4291 NO_STR
4292 BGP_STR
4293 "Unconfigure BGP dynamic neighbors listen range\n"
4294 "Unconfigure BGP dynamic neighbors listen range\n"
4295 NEIGHBOR_ADDR_STR
4296 "Member of the peer-group\n"
4297 "Peer-group name\n")
4298 {
4299 VTY_DECLVAR_CONTEXT(bgp, bgp);
4300 struct prefix range;
4301 struct peer_group *group;
4302 afi_t afi;
4303 int ret;
4304 int idx = 0;
4305
4306 argv_find(argv, argc, "A.B.C.D/M", &idx);
4307 argv_find(argv, argc, "X:X::X:X/M", &idx);
4308 char *prefix = argv[idx]->arg;
4309 argv_find(argv, argc, "PGNAME", &idx);
4310 char *peergroup = argv[idx]->arg;
4311
4312 /* Convert IP prefix string to struct prefix. */
4313 ret = str2prefix(prefix, &range);
4314 if (!ret) {
4315 vty_out(vty, "%% Malformed listen range\n");
4316 return CMD_WARNING_CONFIG_FAILED;
4317 }
4318
4319 afi = family2afi(range.family);
4320
4321 if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
4322 vty_out(vty,
4323 "%% Malformed listen range (link-local address)\n");
4324 return CMD_WARNING_CONFIG_FAILED;
4325 }
4326
4327 apply_mask(&range);
4328
4329 group = peer_group_lookup(bgp, peergroup);
4330 if (!group) {
4331 vty_out(vty, "%% Peer-group does not exist\n");
4332 return CMD_WARNING_CONFIG_FAILED;
4333 }
4334
4335 ret = peer_group_listen_range_del(group, &range);
4336 return bgp_vty_return(vty, ret);
4337 }
4338
4339 void bgp_config_write_listen(struct vty *vty, struct bgp *bgp)
4340 {
4341 struct peer_group *group;
4342 struct listnode *node, *nnode, *rnode, *nrnode;
4343 struct prefix *range;
4344 afi_t afi;
4345
4346 if (bgp->dynamic_neighbors_limit != BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT)
4347 vty_out(vty, " bgp listen limit %d\n",
4348 bgp->dynamic_neighbors_limit);
4349
4350 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
4351 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
4352 for (ALL_LIST_ELEMENTS(group->listen_range[afi], rnode,
4353 nrnode, range)) {
4354 vty_out(vty,
4355 " bgp listen range %pFX peer-group %s\n",
4356 range, group->name);
4357 }
4358 }
4359 }
4360 }
4361
4362
4363 DEFUN (bgp_disable_connected_route_check,
4364 bgp_disable_connected_route_check_cmd,
4365 "bgp disable-ebgp-connected-route-check",
4366 BGP_STR
4367 "Disable checking if nexthop is connected on ebgp sessions\n")
4368 {
4369 VTY_DECLVAR_CONTEXT(bgp, bgp);
4370 SET_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
4371 bgp_clear_star_soft_in(vty, bgp->name);
4372
4373 return CMD_SUCCESS;
4374 }
4375
4376 DEFUN (no_bgp_disable_connected_route_check,
4377 no_bgp_disable_connected_route_check_cmd,
4378 "no bgp disable-ebgp-connected-route-check",
4379 NO_STR
4380 BGP_STR
4381 "Disable checking if nexthop is connected on ebgp sessions\n")
4382 {
4383 VTY_DECLVAR_CONTEXT(bgp, bgp);
4384 UNSET_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
4385 bgp_clear_star_soft_in(vty, bgp->name);
4386
4387 return CMD_SUCCESS;
4388 }
4389
4390
4391 static int peer_remote_as_vty(struct vty *vty, const char *peer_str,
4392 const char *as_str)
4393 {
4394 VTY_DECLVAR_CONTEXT(bgp, bgp);
4395 int ret;
4396 as_t as;
4397 int as_type = AS_SPECIFIED;
4398 union sockunion su;
4399
4400 if (as_str[0] == 'i') {
4401 as = 0;
4402 as_type = AS_INTERNAL;
4403 } else if (as_str[0] == 'e') {
4404 as = 0;
4405 as_type = AS_EXTERNAL;
4406 } else {
4407 /* Get AS number. */
4408 as = strtoul(as_str, NULL, 10);
4409 }
4410
4411 /* If peer is peer group or interface peer, call proper function. */
4412 ret = str2sockunion(peer_str, &su);
4413 if (ret < 0) {
4414 struct peer *peer;
4415
4416 /* Check if existing interface peer */
4417 peer = peer_lookup_by_conf_if(bgp, peer_str);
4418
4419 ret = peer_remote_as(bgp, NULL, peer_str, &as, as_type);
4420
4421 /* if not interface peer, check peer-group settings */
4422 if (ret < 0 && !peer) {
4423 ret = peer_group_remote_as(bgp, peer_str, &as, as_type);
4424 if (ret < 0) {
4425 vty_out(vty,
4426 "%% Create the peer-group or interface first\n");
4427 return CMD_WARNING_CONFIG_FAILED;
4428 }
4429 return CMD_SUCCESS;
4430 }
4431 } else {
4432 if (peer_address_self_check(bgp, &su)) {
4433 vty_out(vty,
4434 "%% Can not configure the local system as neighbor\n");
4435 return CMD_WARNING_CONFIG_FAILED;
4436 }
4437 ret = peer_remote_as(bgp, &su, NULL, &as, as_type);
4438 }
4439
4440 return bgp_vty_return(vty, ret);
4441 }
4442
4443 DEFUN (bgp_default_shutdown,
4444 bgp_default_shutdown_cmd,
4445 "[no] bgp default shutdown",
4446 NO_STR
4447 BGP_STR
4448 "Configure BGP defaults\n"
4449 "Apply administrative shutdown to newly configured peers\n")
4450 {
4451 VTY_DECLVAR_CONTEXT(bgp, bgp);
4452 bgp->autoshutdown = !strmatch(argv[0]->text, "no");
4453 return CMD_SUCCESS;
4454 }
4455
4456 DEFPY(bgp_shutdown_msg, bgp_shutdown_msg_cmd, "bgp shutdown message MSG...",
4457 BGP_STR
4458 "Administrative shutdown of the BGP instance\n"
4459 "Add a shutdown message (RFC 8203)\n"
4460 "Shutdown message\n")
4461 {
4462 char *msgstr = NULL;
4463
4464 VTY_DECLVAR_CONTEXT(bgp, bgp);
4465
4466 if (argc > 3)
4467 msgstr = argv_concat(argv, argc, 3);
4468
4469 if (msgstr && strlen(msgstr) > BGP_ADMIN_SHUTDOWN_MSG_LEN) {
4470 vty_out(vty, "%% Shutdown message size exceeded %d\n",
4471 BGP_ADMIN_SHUTDOWN_MSG_LEN);
4472 return CMD_WARNING_CONFIG_FAILED;
4473 }
4474
4475 bgp_shutdown_enable(bgp, msgstr);
4476 XFREE(MTYPE_TMP, msgstr);
4477
4478 return CMD_SUCCESS;
4479 }
4480
4481 DEFPY(bgp_shutdown, bgp_shutdown_cmd, "bgp shutdown",
4482 BGP_STR "Administrative shutdown of the BGP instance\n")
4483 {
4484 VTY_DECLVAR_CONTEXT(bgp, bgp);
4485
4486 bgp_shutdown_enable(bgp, NULL);
4487
4488 return CMD_SUCCESS;
4489 }
4490
4491 DEFPY(no_bgp_shutdown, no_bgp_shutdown_cmd, "no bgp shutdown",
4492 NO_STR BGP_STR "Administrative shutdown of the BGP instance\n")
4493 {
4494 VTY_DECLVAR_CONTEXT(bgp, bgp);
4495
4496 bgp_shutdown_disable(bgp);
4497
4498 return CMD_SUCCESS;
4499 }
4500
4501 ALIAS(no_bgp_shutdown, no_bgp_shutdown_msg_cmd,
4502 "no bgp shutdown message MSG...", NO_STR BGP_STR
4503 "Administrative shutdown of the BGP instance\n"
4504 "Add a shutdown message (RFC 8203)\n" "Shutdown message\n")
4505
4506 DEFUN (neighbor_remote_as,
4507 neighbor_remote_as_cmd,
4508 "neighbor <A.B.C.D|X:X::X:X|WORD> remote-as <(1-4294967295)|internal|external>",
4509 NEIGHBOR_STR
4510 NEIGHBOR_ADDR_STR2
4511 "Specify a BGP neighbor\n"
4512 AS_STR
4513 "Internal BGP peer\n"
4514 "External BGP peer\n")
4515 {
4516 int idx_peer = 1;
4517 int idx_remote_as = 3;
4518 return peer_remote_as_vty(vty, argv[idx_peer]->arg,
4519 argv[idx_remote_as]->arg);
4520 }
4521
4522 DEFPY (bgp_allow_martian,
4523 bgp_allow_martian_cmd,
4524 "[no]$no bgp allow-martian-nexthop",
4525 NO_STR
4526 BGP_STR
4527 "Allow Martian nexthops to be received in the NLRI from a peer\n")
4528 {
4529 VTY_DECLVAR_CONTEXT(bgp, bgp);
4530
4531 if (no)
4532 bgp->allow_martian = false;
4533 else
4534 bgp->allow_martian = true;
4535
4536 return CMD_SUCCESS;
4537 }
4538
4539 /* Enable fast convergence of bgp sessions. If this is enabled, bgp
4540 * sessions do not wait for hold timer expiry to bring down the sessions
4541 * when nexthop becomes unreachable
4542 */
4543 DEFUN(bgp_fast_convergence, bgp_fast_convergence_cmd, "bgp fast-convergence",
4544 BGP_STR "Fast convergence for bgp sessions\n")
4545 {
4546 VTY_DECLVAR_CONTEXT(bgp, bgp);
4547 bgp->fast_convergence = true;
4548
4549 return CMD_SUCCESS;
4550 }
4551
4552 DEFUN(no_bgp_fast_convergence, no_bgp_fast_convergence_cmd,
4553 "no bgp fast-convergence",
4554 NO_STR BGP_STR "Fast convergence for bgp sessions\n")
4555 {
4556 VTY_DECLVAR_CONTEXT(bgp, bgp);
4557 bgp->fast_convergence = false;
4558
4559 return CMD_SUCCESS;
4560 }
4561
4562 static int peer_conf_interface_get(struct vty *vty, const char *conf_if,
4563 int v6only,
4564 const char *peer_group_name,
4565 const char *as_str)
4566 {
4567 VTY_DECLVAR_CONTEXT(bgp, bgp);
4568 as_t as = 0;
4569 int as_type = AS_UNSPECIFIED;
4570 struct peer *peer;
4571 struct peer_group *group;
4572 int ret = 0;
4573
4574 group = peer_group_lookup(bgp, conf_if);
4575
4576 if (group) {
4577 vty_out(vty, "%% Name conflict with peer-group \n");
4578 return CMD_WARNING_CONFIG_FAILED;
4579 }
4580
4581 if (as_str) {
4582 if (as_str[0] == 'i') {
4583 as_type = AS_INTERNAL;
4584 } else if (as_str[0] == 'e') {
4585 as_type = AS_EXTERNAL;
4586 } else {
4587 /* Get AS number. */
4588 as = strtoul(as_str, NULL, 10);
4589 as_type = AS_SPECIFIED;
4590 }
4591 }
4592
4593 peer = peer_lookup_by_conf_if(bgp, conf_if);
4594 if (peer) {
4595 if (as_str)
4596 ret = peer_remote_as(bgp, NULL, conf_if, &as, as_type);
4597 } else {
4598 peer = peer_create(NULL, conf_if, bgp, bgp->as, as, as_type,
4599 NULL);
4600
4601 if (!peer) {
4602 vty_out(vty, "%% BGP failed to create peer\n");
4603 return CMD_WARNING_CONFIG_FAILED;
4604 }
4605
4606 if (v6only)
4607 peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
4608
4609 /* Request zebra to initiate IPv6 RAs on this interface. We do
4610 * this
4611 * any unnumbered peer in order to not worry about run-time
4612 * transitions
4613 * (e.g., peering is initially IPv4, but the IPv4 /30 or /31
4614 * address
4615 * gets deleted later etc.)
4616 */
4617 if (peer->ifp)
4618 bgp_zebra_initiate_radv(bgp, peer);
4619 }
4620
4621 if ((v6only && !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
4622 || (!v6only && CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))) {
4623 if (v6only)
4624 peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
4625 else
4626 peer_flag_unset(peer, PEER_FLAG_IFPEER_V6ONLY);
4627
4628 /* v6only flag changed. Reset bgp seesion */
4629 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4630 peer->last_reset = PEER_DOWN_V6ONLY_CHANGE;
4631 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4632 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4633 } else
4634 bgp_session_reset(peer);
4635 }
4636
4637 if (!CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE)) {
4638 SET_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE);
4639 SET_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE);
4640 SET_FLAG(peer->flags_override, PEER_FLAG_CAPABILITY_ENHE);
4641 }
4642
4643 if (peer_group_name) {
4644 group = peer_group_lookup(bgp, peer_group_name);
4645 if (!group) {
4646 vty_out(vty, "%% Configure the peer-group first\n");
4647 return CMD_WARNING_CONFIG_FAILED;
4648 }
4649
4650 ret = peer_group_bind(bgp, NULL, peer, group, &as);
4651 }
4652
4653 return bgp_vty_return(vty, ret);
4654 }
4655
4656 DEFUN (neighbor_interface_config,
4657 neighbor_interface_config_cmd,
4658 "neighbor WORD interface [peer-group PGNAME]",
4659 NEIGHBOR_STR
4660 "Interface name or neighbor tag\n"
4661 "Enable BGP on interface\n"
4662 "Member of the peer-group\n"
4663 "Peer-group name\n")
4664 {
4665 int idx_word = 1;
4666 int idx_peer_group_word = 4;
4667
4668 if (argc > idx_peer_group_word)
4669 return peer_conf_interface_get(
4670 vty, argv[idx_word]->arg, 0,
4671 argv[idx_peer_group_word]->arg, NULL);
4672 else
4673 return peer_conf_interface_get(vty, argv[idx_word]->arg, 0,
4674 NULL, NULL);
4675 }
4676
4677 DEFUN (neighbor_interface_config_v6only,
4678 neighbor_interface_config_v6only_cmd,
4679 "neighbor WORD interface v6only [peer-group PGNAME]",
4680 NEIGHBOR_STR
4681 "Interface name or neighbor tag\n"
4682 "Enable BGP on interface\n"
4683 "Enable BGP with v6 link-local only\n"
4684 "Member of the peer-group\n"
4685 "Peer-group name\n")
4686 {
4687 int idx_word = 1;
4688 int idx_peer_group_word = 5;
4689
4690 if (argc > idx_peer_group_word)
4691 return peer_conf_interface_get(
4692 vty, argv[idx_word]->arg, 1,
4693 argv[idx_peer_group_word]->arg, NULL);
4694
4695 return peer_conf_interface_get(vty, argv[idx_word]->arg, 1, NULL, NULL);
4696 }
4697
4698
4699 DEFUN (neighbor_interface_config_remote_as,
4700 neighbor_interface_config_remote_as_cmd,
4701 "neighbor WORD interface remote-as <(1-4294967295)|internal|external>",
4702 NEIGHBOR_STR
4703 "Interface name or neighbor tag\n"
4704 "Enable BGP on interface\n"
4705 "Specify a BGP neighbor\n"
4706 AS_STR
4707 "Internal BGP peer\n"
4708 "External BGP peer\n")
4709 {
4710 int idx_word = 1;
4711 int idx_remote_as = 4;
4712 return peer_conf_interface_get(vty, argv[idx_word]->arg, 0, NULL,
4713 argv[idx_remote_as]->arg);
4714 }
4715
4716 DEFUN (neighbor_interface_v6only_config_remote_as,
4717 neighbor_interface_v6only_config_remote_as_cmd,
4718 "neighbor WORD interface v6only remote-as <(1-4294967295)|internal|external>",
4719 NEIGHBOR_STR
4720 "Interface name or neighbor tag\n"
4721 "Enable BGP with v6 link-local only\n"
4722 "Enable BGP on interface\n"
4723 "Specify a BGP neighbor\n"
4724 AS_STR
4725 "Internal BGP peer\n"
4726 "External BGP peer\n")
4727 {
4728 int idx_word = 1;
4729 int idx_remote_as = 5;
4730 return peer_conf_interface_get(vty, argv[idx_word]->arg, 1, NULL,
4731 argv[idx_remote_as]->arg);
4732 }
4733
4734 DEFUN (neighbor_peer_group,
4735 neighbor_peer_group_cmd,
4736 "neighbor WORD peer-group",
4737 NEIGHBOR_STR
4738 "Interface name or neighbor tag\n"
4739 "Configure peer-group\n")
4740 {
4741 VTY_DECLVAR_CONTEXT(bgp, bgp);
4742 int idx_word = 1;
4743 struct peer *peer;
4744 struct peer_group *group;
4745
4746 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
4747 if (peer) {
4748 vty_out(vty, "%% Name conflict with interface: \n");
4749 return CMD_WARNING_CONFIG_FAILED;
4750 }
4751
4752 group = peer_group_get(bgp, argv[idx_word]->arg);
4753 if (!group) {
4754 vty_out(vty, "%% BGP failed to find or create peer-group\n");
4755 return CMD_WARNING_CONFIG_FAILED;
4756 }
4757
4758 return CMD_SUCCESS;
4759 }
4760
4761 DEFUN (no_neighbor,
4762 no_neighbor_cmd,
4763 "no neighbor <WORD|<A.B.C.D|X:X::X:X> [remote-as <(1-4294967295)|internal|external>]>",
4764 NO_STR
4765 NEIGHBOR_STR
4766 NEIGHBOR_ADDR_STR2
4767 "Specify a BGP neighbor\n"
4768 AS_STR
4769 "Internal BGP peer\n"
4770 "External BGP peer\n")
4771 {
4772 VTY_DECLVAR_CONTEXT(bgp, bgp);
4773 int idx_peer = 2;
4774 int ret;
4775 union sockunion su;
4776 struct peer_group *group;
4777 struct peer *peer;
4778 struct peer *other;
4779
4780 ret = str2sockunion(argv[idx_peer]->arg, &su);
4781 if (ret < 0) {
4782 /* look up for neighbor by interface name config. */
4783 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
4784 if (peer) {
4785 /* Request zebra to terminate IPv6 RAs on this
4786 * interface. */
4787 if (peer->ifp)
4788 bgp_zebra_terminate_radv(peer->bgp, peer);
4789 peer_notify_unconfig(peer);
4790 peer_delete(peer);
4791 return CMD_SUCCESS;
4792 }
4793
4794 group = peer_group_lookup(bgp, argv[idx_peer]->arg);
4795 if (group) {
4796 peer_group_notify_unconfig(group);
4797 peer_group_delete(group);
4798 } else {
4799 vty_out(vty, "%% Create the peer-group first\n");
4800 return CMD_WARNING_CONFIG_FAILED;
4801 }
4802 } else {
4803 peer = peer_lookup(bgp, &su);
4804 if (peer) {
4805 if (peer_dynamic_neighbor(peer)) {
4806 vty_out(vty,
4807 "%% Operation not allowed on a dynamic neighbor\n");
4808 return CMD_WARNING_CONFIG_FAILED;
4809 }
4810
4811 other = peer->doppelganger;
4812
4813 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
4814 bgp_zebra_terminate_radv(peer->bgp, peer);
4815
4816 peer_notify_unconfig(peer);
4817 peer_delete(peer);
4818 if (other && other->status != Deleted) {
4819 peer_notify_unconfig(other);
4820 peer_delete(other);
4821 }
4822 }
4823 }
4824
4825 return CMD_SUCCESS;
4826 }
4827
4828 DEFUN (no_neighbor_interface_config,
4829 no_neighbor_interface_config_cmd,
4830 "no neighbor WORD interface [v6only] [peer-group PGNAME] [remote-as <(1-4294967295)|internal|external>]",
4831 NO_STR
4832 NEIGHBOR_STR
4833 "Interface name\n"
4834 "Configure BGP on interface\n"
4835 "Enable BGP with v6 link-local only\n"
4836 "Member of the peer-group\n"
4837 "Peer-group name\n"
4838 "Specify a BGP neighbor\n"
4839 AS_STR
4840 "Internal BGP peer\n"
4841 "External BGP peer\n")
4842 {
4843 VTY_DECLVAR_CONTEXT(bgp, bgp);
4844 int idx_word = 2;
4845 struct peer *peer;
4846
4847 /* look up for neighbor by interface name config. */
4848 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
4849 if (peer) {
4850 /* Request zebra to terminate IPv6 RAs on this interface. */
4851 if (peer->ifp)
4852 bgp_zebra_terminate_radv(peer->bgp, peer);
4853 peer_notify_unconfig(peer);
4854 peer_delete(peer);
4855 } else {
4856 vty_out(vty, "%% Create the bgp interface first\n");
4857 return CMD_WARNING_CONFIG_FAILED;
4858 }
4859 return CMD_SUCCESS;
4860 }
4861
4862 DEFUN (no_neighbor_peer_group,
4863 no_neighbor_peer_group_cmd,
4864 "no neighbor WORD peer-group",
4865 NO_STR
4866 NEIGHBOR_STR
4867 "Neighbor tag\n"
4868 "Configure peer-group\n")
4869 {
4870 VTY_DECLVAR_CONTEXT(bgp, bgp);
4871 int idx_word = 2;
4872 struct peer_group *group;
4873
4874 group = peer_group_lookup(bgp, argv[idx_word]->arg);
4875 if (group) {
4876 peer_group_notify_unconfig(group);
4877 peer_group_delete(group);
4878 } else {
4879 vty_out(vty, "%% Create the peer-group first\n");
4880 return CMD_WARNING_CONFIG_FAILED;
4881 }
4882 return CMD_SUCCESS;
4883 }
4884
4885 DEFUN (no_neighbor_interface_peer_group_remote_as,
4886 no_neighbor_interface_peer_group_remote_as_cmd,
4887 "no neighbor WORD remote-as <(1-4294967295)|internal|external>",
4888 NO_STR
4889 NEIGHBOR_STR
4890 "Interface name or neighbor tag\n"
4891 "Specify a BGP neighbor\n"
4892 AS_STR
4893 "Internal BGP peer\n"
4894 "External BGP peer\n")
4895 {
4896 VTY_DECLVAR_CONTEXT(bgp, bgp);
4897 int idx_word = 2;
4898 struct peer_group *group;
4899 struct peer *peer;
4900
4901 /* look up for neighbor by interface name config. */
4902 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
4903 if (peer) {
4904 peer_as_change(peer, 0, AS_UNSPECIFIED);
4905 return CMD_SUCCESS;
4906 }
4907
4908 group = peer_group_lookup(bgp, argv[idx_word]->arg);
4909 if (group)
4910 peer_group_remote_as_delete(group);
4911 else {
4912 vty_out(vty, "%% Create the peer-group or interface first\n");
4913 return CMD_WARNING_CONFIG_FAILED;
4914 }
4915 return CMD_SUCCESS;
4916 }
4917
4918 DEFUN (neighbor_local_as,
4919 neighbor_local_as_cmd,
4920 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295)",
4921 NEIGHBOR_STR
4922 NEIGHBOR_ADDR_STR2
4923 "Specify a local-as number\n"
4924 "AS number used as local AS\n")
4925 {
4926 int idx_peer = 1;
4927 int idx_number = 3;
4928 struct peer *peer;
4929 int ret;
4930 as_t as;
4931
4932 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4933 if (!peer)
4934 return CMD_WARNING_CONFIG_FAILED;
4935
4936 as = strtoul(argv[idx_number]->arg, NULL, 10);
4937 ret = peer_local_as_set(peer, as, 0, 0);
4938 return bgp_vty_return(vty, ret);
4939 }
4940
4941 DEFUN (neighbor_local_as_no_prepend,
4942 neighbor_local_as_no_prepend_cmd,
4943 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend",
4944 NEIGHBOR_STR
4945 NEIGHBOR_ADDR_STR2
4946 "Specify a local-as number\n"
4947 "AS number used as local AS\n"
4948 "Do not prepend local-as to updates from ebgp peers\n")
4949 {
4950 int idx_peer = 1;
4951 int idx_number = 3;
4952 struct peer *peer;
4953 int ret;
4954 as_t as;
4955
4956 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4957 if (!peer)
4958 return CMD_WARNING_CONFIG_FAILED;
4959
4960 as = strtoul(argv[idx_number]->arg, NULL, 10);
4961 ret = peer_local_as_set(peer, as, 1, 0);
4962 return bgp_vty_return(vty, ret);
4963 }
4964
4965 DEFUN (neighbor_local_as_no_prepend_replace_as,
4966 neighbor_local_as_no_prepend_replace_as_cmd,
4967 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend replace-as",
4968 NEIGHBOR_STR
4969 NEIGHBOR_ADDR_STR2
4970 "Specify a local-as number\n"
4971 "AS number used as local AS\n"
4972 "Do not prepend local-as to updates from ebgp peers\n"
4973 "Do not prepend local-as to updates from ibgp peers\n")
4974 {
4975 int idx_peer = 1;
4976 int idx_number = 3;
4977 struct peer *peer;
4978 int ret;
4979 as_t as;
4980
4981 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4982 if (!peer)
4983 return CMD_WARNING_CONFIG_FAILED;
4984
4985 as = strtoul(argv[idx_number]->arg, NULL, 10);
4986 ret = peer_local_as_set(peer, as, 1, 1);
4987 return bgp_vty_return(vty, ret);
4988 }
4989
4990 DEFUN (no_neighbor_local_as,
4991 no_neighbor_local_as_cmd,
4992 "no neighbor <A.B.C.D|X:X::X:X|WORD> local-as [(1-4294967295) [no-prepend [replace-as]]]",
4993 NO_STR
4994 NEIGHBOR_STR
4995 NEIGHBOR_ADDR_STR2
4996 "Specify a local-as number\n"
4997 "AS number used as local AS\n"
4998 "Do not prepend local-as to updates from ebgp peers\n"
4999 "Do not prepend local-as to updates from ibgp peers\n")
5000 {
5001 int idx_peer = 2;
5002 struct peer *peer;
5003 int ret;
5004
5005 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5006 if (!peer)
5007 return CMD_WARNING_CONFIG_FAILED;
5008
5009 ret = peer_local_as_unset(peer);
5010 return bgp_vty_return(vty, ret);
5011 }
5012
5013
5014 DEFUN (neighbor_solo,
5015 neighbor_solo_cmd,
5016 "neighbor <A.B.C.D|X:X::X:X|WORD> solo",
5017 NEIGHBOR_STR
5018 NEIGHBOR_ADDR_STR2
5019 "Solo peer - part of its own update group\n")
5020 {
5021 int idx_peer = 1;
5022 struct peer *peer;
5023 int ret;
5024
5025 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5026 if (!peer)
5027 return CMD_WARNING_CONFIG_FAILED;
5028
5029 ret = update_group_adjust_soloness(peer, 1);
5030 return bgp_vty_return(vty, ret);
5031 }
5032
5033 DEFUN (no_neighbor_solo,
5034 no_neighbor_solo_cmd,
5035 "no neighbor <A.B.C.D|X:X::X:X|WORD> solo",
5036 NO_STR
5037 NEIGHBOR_STR
5038 NEIGHBOR_ADDR_STR2
5039 "Solo peer - part of its own update group\n")
5040 {
5041 int idx_peer = 2;
5042 struct peer *peer;
5043 int ret;
5044
5045 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5046 if (!peer)
5047 return CMD_WARNING_CONFIG_FAILED;
5048
5049 ret = update_group_adjust_soloness(peer, 0);
5050 return bgp_vty_return(vty, ret);
5051 }
5052
5053 DEFUN (neighbor_password,
5054 neighbor_password_cmd,
5055 "neighbor <A.B.C.D|X:X::X:X|WORD> password LINE",
5056 NEIGHBOR_STR
5057 NEIGHBOR_ADDR_STR2
5058 "Set a password\n"
5059 "The password\n")
5060 {
5061 int idx_peer = 1;
5062 int idx_line = 3;
5063 struct peer *peer;
5064 int ret;
5065
5066 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5067 if (!peer)
5068 return CMD_WARNING_CONFIG_FAILED;
5069
5070 ret = peer_password_set(peer, argv[idx_line]->arg);
5071 return bgp_vty_return(vty, ret);
5072 }
5073
5074 DEFUN (no_neighbor_password,
5075 no_neighbor_password_cmd,
5076 "no neighbor <A.B.C.D|X:X::X:X|WORD> password [LINE]",
5077 NO_STR
5078 NEIGHBOR_STR
5079 NEIGHBOR_ADDR_STR2
5080 "Set a password\n"
5081 "The password\n")
5082 {
5083 int idx_peer = 2;
5084 struct peer *peer;
5085 int ret;
5086
5087 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5088 if (!peer)
5089 return CMD_WARNING_CONFIG_FAILED;
5090
5091 ret = peer_password_unset(peer);
5092 return bgp_vty_return(vty, ret);
5093 }
5094
5095 DEFUN (neighbor_activate,
5096 neighbor_activate_cmd,
5097 "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5098 NEIGHBOR_STR
5099 NEIGHBOR_ADDR_STR2
5100 "Enable the Address Family for this Neighbor\n")
5101 {
5102 int idx_peer = 1;
5103 int ret;
5104 struct peer *peer;
5105
5106 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5107 if (!peer)
5108 return CMD_WARNING_CONFIG_FAILED;
5109
5110 ret = peer_activate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
5111 return bgp_vty_return(vty, ret);
5112 }
5113
5114 ALIAS_HIDDEN(neighbor_activate, neighbor_activate_hidden_cmd,
5115 "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5116 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5117 "Enable the Address Family for this Neighbor\n")
5118
5119 DEFUN (no_neighbor_activate,
5120 no_neighbor_activate_cmd,
5121 "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5122 NO_STR
5123 NEIGHBOR_STR
5124 NEIGHBOR_ADDR_STR2
5125 "Enable the Address Family for this Neighbor\n")
5126 {
5127 int idx_peer = 2;
5128 int ret;
5129 struct peer *peer;
5130
5131 /* Lookup peer. */
5132 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5133 if (!peer)
5134 return CMD_WARNING_CONFIG_FAILED;
5135
5136 ret = peer_deactivate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
5137 return bgp_vty_return(vty, ret);
5138 }
5139
5140 ALIAS_HIDDEN(no_neighbor_activate, no_neighbor_activate_hidden_cmd,
5141 "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5142 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5143 "Enable the Address Family for this Neighbor\n")
5144
5145 DEFUN (neighbor_set_peer_group,
5146 neighbor_set_peer_group_cmd,
5147 "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5148 NEIGHBOR_STR
5149 NEIGHBOR_ADDR_STR2
5150 "Member of the peer-group\n"
5151 "Peer-group name\n")
5152 {
5153 VTY_DECLVAR_CONTEXT(bgp, bgp);
5154 int idx_peer = 1;
5155 int idx_word = 3;
5156 int ret;
5157 as_t as;
5158 union sockunion su;
5159 struct peer *peer;
5160 struct peer_group *group;
5161
5162 ret = str2sockunion(argv[idx_peer]->arg, &su);
5163 if (ret < 0) {
5164 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
5165 if (!peer) {
5166 vty_out(vty, "%% Malformed address or name: %s\n",
5167 argv[idx_peer]->arg);
5168 return CMD_WARNING_CONFIG_FAILED;
5169 }
5170 } else {
5171 if (peer_address_self_check(bgp, &su)) {
5172 vty_out(vty,
5173 "%% Can not configure the local system as neighbor\n");
5174 return CMD_WARNING_CONFIG_FAILED;
5175 }
5176
5177 /* Disallow for dynamic neighbor. */
5178 peer = peer_lookup(bgp, &su);
5179 if (peer && peer_dynamic_neighbor(peer)) {
5180 vty_out(vty,
5181 "%% Operation not allowed on a dynamic neighbor\n");
5182 return CMD_WARNING_CONFIG_FAILED;
5183 }
5184 }
5185
5186 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5187 if (!group) {
5188 vty_out(vty, "%% Configure the peer-group first\n");
5189 return CMD_WARNING_CONFIG_FAILED;
5190 }
5191
5192 ret = peer_group_bind(bgp, &su, peer, group, &as);
5193
5194 return bgp_vty_return(vty, ret);
5195 }
5196
5197 ALIAS_HIDDEN(neighbor_set_peer_group, neighbor_set_peer_group_hidden_cmd,
5198 "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5199 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5200 "Member of the peer-group\n"
5201 "Peer-group name\n")
5202
5203 DEFUN (no_neighbor_set_peer_group,
5204 no_neighbor_set_peer_group_cmd,
5205 "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5206 NO_STR
5207 NEIGHBOR_STR
5208 NEIGHBOR_ADDR_STR2
5209 "Member of the peer-group\n"
5210 "Peer-group name\n")
5211 {
5212 VTY_DECLVAR_CONTEXT(bgp, bgp);
5213 int idx_peer = 2;
5214 int idx_word = 4;
5215 int ret;
5216 struct peer *peer;
5217 struct peer_group *group;
5218
5219 peer = peer_lookup_vty(vty, argv[idx_peer]->arg);
5220 if (!peer)
5221 return CMD_WARNING_CONFIG_FAILED;
5222
5223 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5224 if (!group) {
5225 vty_out(vty, "%% Configure the peer-group first\n");
5226 return CMD_WARNING_CONFIG_FAILED;
5227 }
5228
5229 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
5230 bgp_zebra_terminate_radv(peer->bgp, peer);
5231
5232 peer_notify_unconfig(peer);
5233 ret = peer_delete(peer);
5234
5235 return bgp_vty_return(vty, ret);
5236 }
5237
5238 ALIAS_HIDDEN(no_neighbor_set_peer_group, no_neighbor_set_peer_group_hidden_cmd,
5239 "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5240 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5241 "Member of the peer-group\n"
5242 "Peer-group name\n")
5243
5244 static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
5245 uint64_t flag, int set)
5246 {
5247 int ret;
5248 struct peer *peer;
5249
5250 peer = peer_and_group_lookup_vty(vty, ip_str);
5251 if (!peer)
5252 return CMD_WARNING_CONFIG_FAILED;
5253
5254 /*
5255 * If 'neighbor <interface>', then this is for directly connected peers,
5256 * we should not accept disable-connected-check.
5257 */
5258 if (peer->conf_if && (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)) {
5259 vty_out(vty,
5260 "%s is directly connected peer, cannot accept disable-connected-check\n",
5261 ip_str);
5262 return CMD_WARNING_CONFIG_FAILED;
5263 }
5264
5265 if (!set && flag == PEER_FLAG_SHUTDOWN)
5266 peer_tx_shutdown_message_unset(peer);
5267
5268 if (set)
5269 ret = peer_flag_set(peer, flag);
5270 else
5271 ret = peer_flag_unset(peer, flag);
5272
5273 return bgp_vty_return(vty, ret);
5274 }
5275
5276 static int peer_flag_set_vty(struct vty *vty, const char *ip_str, uint64_t flag)
5277 {
5278 return peer_flag_modify_vty(vty, ip_str, flag, 1);
5279 }
5280
5281 static int peer_flag_unset_vty(struct vty *vty, const char *ip_str,
5282 uint64_t flag)
5283 {
5284 return peer_flag_modify_vty(vty, ip_str, flag, 0);
5285 }
5286
5287 /* neighbor passive. */
5288 DEFUN (neighbor_passive,
5289 neighbor_passive_cmd,
5290 "neighbor <A.B.C.D|X:X::X:X|WORD> passive",
5291 NEIGHBOR_STR
5292 NEIGHBOR_ADDR_STR2
5293 "Don't send open messages to this neighbor\n")
5294 {
5295 int idx_peer = 1;
5296 return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
5297 }
5298
5299 DEFUN (no_neighbor_passive,
5300 no_neighbor_passive_cmd,
5301 "no neighbor <A.B.C.D|X:X::X:X|WORD> passive",
5302 NO_STR
5303 NEIGHBOR_STR
5304 NEIGHBOR_ADDR_STR2
5305 "Don't send open messages to this neighbor\n")
5306 {
5307 int idx_peer = 2;
5308 return peer_flag_unset_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
5309 }
5310
5311 /* neighbor shutdown. */
5312 DEFUN (neighbor_shutdown_msg,
5313 neighbor_shutdown_msg_cmd,
5314 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
5315 NEIGHBOR_STR
5316 NEIGHBOR_ADDR_STR2
5317 "Administratively shut down this neighbor\n"
5318 "Add a shutdown message (RFC 8203)\n"
5319 "Shutdown message\n")
5320 {
5321 int idx_peer = 1;
5322
5323 if (argc >= 5) {
5324 struct peer *peer =
5325 peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5326 char *message;
5327
5328 if (!peer)
5329 return CMD_WARNING_CONFIG_FAILED;
5330 message = argv_concat(argv, argc, 4);
5331 peer_tx_shutdown_message_set(peer, message);
5332 XFREE(MTYPE_TMP, message);
5333 }
5334
5335 return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
5336 }
5337
5338 ALIAS(neighbor_shutdown_msg, neighbor_shutdown_cmd,
5339 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
5340 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5341 "Administratively shut down this neighbor\n")
5342
5343 DEFUN (no_neighbor_shutdown_msg,
5344 no_neighbor_shutdown_msg_cmd,
5345 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
5346 NO_STR
5347 NEIGHBOR_STR
5348 NEIGHBOR_ADDR_STR2
5349 "Administratively shut down this neighbor\n"
5350 "Remove a shutdown message (RFC 8203)\n"
5351 "Shutdown message\n")
5352 {
5353 int idx_peer = 2;
5354
5355 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5356 PEER_FLAG_SHUTDOWN);
5357 }
5358
5359 ALIAS(no_neighbor_shutdown_msg, no_neighbor_shutdown_cmd,
5360 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
5361 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5362 "Administratively shut down this neighbor\n")
5363
5364 DEFUN(neighbor_shutdown_rtt,
5365 neighbor_shutdown_rtt_cmd,
5366 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown rtt (1-65535) [count (1-255)]",
5367 NEIGHBOR_STR
5368 NEIGHBOR_ADDR_STR2
5369 "Administratively shut down this neighbor\n"
5370 "Shutdown if round-trip-time is higher than expected\n"
5371 "Round-trip-time in milliseconds\n"
5372 "Specify the number of keepalives before shutdown\n"
5373 "The number of keepalives with higher RTT to shutdown\n")
5374 {
5375 int idx_peer = 1;
5376 int idx_rtt = 4;
5377 int idx_count = 0;
5378 struct peer *peer;
5379
5380 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5381
5382 if (!peer)
5383 return CMD_WARNING_CONFIG_FAILED;
5384
5385 peer->rtt_expected = strtol(argv[idx_rtt]->arg, NULL, 10);
5386
5387 if (argv_find(argv, argc, "count", &idx_count))
5388 peer->rtt_keepalive_conf =
5389 strtol(argv[idx_count + 1]->arg, NULL, 10);
5390
5391 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5392 PEER_FLAG_RTT_SHUTDOWN);
5393 }
5394
5395 DEFUN(no_neighbor_shutdown_rtt,
5396 no_neighbor_shutdown_rtt_cmd,
5397 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown rtt [(1-65535) [count (1-255)]]",
5398 NO_STR
5399 NEIGHBOR_STR
5400 NEIGHBOR_ADDR_STR2
5401 "Administratively shut down this neighbor\n"
5402 "Shutdown if round-trip-time is higher than expected\n"
5403 "Round-trip-time in milliseconds\n"
5404 "Specify the number of keepalives before shutdown\n"
5405 "The number of keepalives with higher RTT to shutdown\n")
5406 {
5407 int idx_peer = 2;
5408 struct peer *peer;
5409
5410 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5411
5412 if (!peer)
5413 return CMD_WARNING_CONFIG_FAILED;
5414
5415 peer->rtt_expected = 0;
5416 peer->rtt_keepalive_conf = 1;
5417
5418 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5419 PEER_FLAG_RTT_SHUTDOWN);
5420 }
5421
5422 /* neighbor capability dynamic. */
5423 DEFUN (neighbor_capability_dynamic,
5424 neighbor_capability_dynamic_cmd,
5425 "neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
5426 NEIGHBOR_STR
5427 NEIGHBOR_ADDR_STR2
5428 "Advertise capability to the peer\n"
5429 "Advertise dynamic capability to this neighbor\n")
5430 {
5431 int idx_peer = 1;
5432 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5433 PEER_FLAG_DYNAMIC_CAPABILITY);
5434 }
5435
5436 DEFUN (no_neighbor_capability_dynamic,
5437 no_neighbor_capability_dynamic_cmd,
5438 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
5439 NO_STR
5440 NEIGHBOR_STR
5441 NEIGHBOR_ADDR_STR2
5442 "Advertise capability to the peer\n"
5443 "Advertise dynamic capability to this neighbor\n")
5444 {
5445 int idx_peer = 2;
5446 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5447 PEER_FLAG_DYNAMIC_CAPABILITY);
5448 }
5449
5450 /* neighbor dont-capability-negotiate */
5451 DEFUN (neighbor_dont_capability_negotiate,
5452 neighbor_dont_capability_negotiate_cmd,
5453 "neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
5454 NEIGHBOR_STR
5455 NEIGHBOR_ADDR_STR2
5456 "Do not perform capability negotiation\n")
5457 {
5458 int idx_peer = 1;
5459 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5460 PEER_FLAG_DONT_CAPABILITY);
5461 }
5462
5463 DEFUN (no_neighbor_dont_capability_negotiate,
5464 no_neighbor_dont_capability_negotiate_cmd,
5465 "no neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
5466 NO_STR
5467 NEIGHBOR_STR
5468 NEIGHBOR_ADDR_STR2
5469 "Do not perform capability negotiation\n")
5470 {
5471 int idx_peer = 2;
5472 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5473 PEER_FLAG_DONT_CAPABILITY);
5474 }
5475
5476 /* neighbor capability extended next hop encoding */
5477 DEFUN (neighbor_capability_enhe,
5478 neighbor_capability_enhe_cmd,
5479 "neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
5480 NEIGHBOR_STR
5481 NEIGHBOR_ADDR_STR2
5482 "Advertise capability to the peer\n"
5483 "Advertise extended next-hop capability to the peer\n")
5484 {
5485 int idx_peer = 1;
5486 struct peer *peer;
5487
5488 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5489 if (peer && peer->conf_if)
5490 return CMD_SUCCESS;
5491
5492 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5493 PEER_FLAG_CAPABILITY_ENHE);
5494 }
5495
5496 DEFUN (no_neighbor_capability_enhe,
5497 no_neighbor_capability_enhe_cmd,
5498 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
5499 NO_STR
5500 NEIGHBOR_STR
5501 NEIGHBOR_ADDR_STR2
5502 "Advertise capability to the peer\n"
5503 "Advertise extended next-hop capability to the peer\n")
5504 {
5505 int idx_peer = 2;
5506 struct peer *peer;
5507
5508 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5509 if (peer && peer->conf_if) {
5510 vty_out(vty,
5511 "Peer %s cannot have capability extended-nexthop turned off\n",
5512 argv[idx_peer]->arg);
5513 return CMD_WARNING_CONFIG_FAILED;
5514 }
5515
5516 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5517 PEER_FLAG_CAPABILITY_ENHE);
5518 }
5519
5520 static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
5521 afi_t afi, safi_t safi, uint32_t flag,
5522 int set)
5523 {
5524 int ret;
5525 struct peer *peer;
5526
5527 peer = peer_and_group_lookup_vty(vty, peer_str);
5528 if (!peer)
5529 return CMD_WARNING_CONFIG_FAILED;
5530
5531 if (set)
5532 ret = peer_af_flag_set(peer, afi, safi, flag);
5533 else
5534 ret = peer_af_flag_unset(peer, afi, safi, flag);
5535
5536 return bgp_vty_return(vty, ret);
5537 }
5538
5539 static int peer_af_flag_set_vty(struct vty *vty, const char *peer_str,
5540 afi_t afi, safi_t safi, uint32_t flag)
5541 {
5542 return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 1);
5543 }
5544
5545 static int peer_af_flag_unset_vty(struct vty *vty, const char *peer_str,
5546 afi_t afi, safi_t safi, uint32_t flag)
5547 {
5548 return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 0);
5549 }
5550
5551 /* neighbor capability orf prefix-list. */
5552 DEFUN (neighbor_capability_orf_prefix,
5553 neighbor_capability_orf_prefix_cmd,
5554 "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5555 NEIGHBOR_STR
5556 NEIGHBOR_ADDR_STR2
5557 "Advertise capability to the peer\n"
5558 "Advertise ORF capability to the peer\n"
5559 "Advertise prefixlist ORF capability to this neighbor\n"
5560 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5561 "Capability to RECEIVE the ORF from this neighbor\n"
5562 "Capability to SEND the ORF to this neighbor\n")
5563 {
5564 int idx_send_recv = 5;
5565 char *peer_str = argv[1]->arg;
5566 struct peer *peer;
5567 afi_t afi = bgp_node_afi(vty);
5568 safi_t safi = bgp_node_safi(vty);
5569
5570 peer = peer_and_group_lookup_vty(vty, peer_str);
5571 if (!peer)
5572 return CMD_WARNING_CONFIG_FAILED;
5573
5574 if (strmatch(argv[idx_send_recv]->text, "send"))
5575 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5576 PEER_FLAG_ORF_PREFIX_SM);
5577
5578 if (strmatch(argv[idx_send_recv]->text, "receive"))
5579 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5580 PEER_FLAG_ORF_PREFIX_RM);
5581
5582 if (strmatch(argv[idx_send_recv]->text, "both"))
5583 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5584 PEER_FLAG_ORF_PREFIX_SM)
5585 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
5586 PEER_FLAG_ORF_PREFIX_RM);
5587
5588 return CMD_WARNING_CONFIG_FAILED;
5589 }
5590
5591 ALIAS_HIDDEN(
5592 neighbor_capability_orf_prefix,
5593 neighbor_capability_orf_prefix_hidden_cmd,
5594 "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5595 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5596 "Advertise capability to the peer\n"
5597 "Advertise ORF capability to the peer\n"
5598 "Advertise prefixlist ORF capability to this neighbor\n"
5599 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5600 "Capability to RECEIVE the ORF from this neighbor\n"
5601 "Capability to SEND the ORF to this neighbor\n")
5602
5603 DEFUN (no_neighbor_capability_orf_prefix,
5604 no_neighbor_capability_orf_prefix_cmd,
5605 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5606 NO_STR
5607 NEIGHBOR_STR
5608 NEIGHBOR_ADDR_STR2
5609 "Advertise capability to the peer\n"
5610 "Advertise ORF capability to the peer\n"
5611 "Advertise prefixlist ORF capability to this neighbor\n"
5612 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5613 "Capability to RECEIVE the ORF from this neighbor\n"
5614 "Capability to SEND the ORF to this neighbor\n")
5615 {
5616 int idx_send_recv = 6;
5617 char *peer_str = argv[2]->arg;
5618 struct peer *peer;
5619 afi_t afi = bgp_node_afi(vty);
5620 safi_t safi = bgp_node_safi(vty);
5621
5622 peer = peer_and_group_lookup_vty(vty, peer_str);
5623 if (!peer)
5624 return CMD_WARNING_CONFIG_FAILED;
5625
5626 if (strmatch(argv[idx_send_recv]->text, "send"))
5627 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5628 PEER_FLAG_ORF_PREFIX_SM);
5629
5630 if (strmatch(argv[idx_send_recv]->text, "receive"))
5631 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5632 PEER_FLAG_ORF_PREFIX_RM);
5633
5634 if (strmatch(argv[idx_send_recv]->text, "both"))
5635 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5636 PEER_FLAG_ORF_PREFIX_SM)
5637 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5638 PEER_FLAG_ORF_PREFIX_RM);
5639
5640 return CMD_WARNING_CONFIG_FAILED;
5641 }
5642
5643 ALIAS_HIDDEN(
5644 no_neighbor_capability_orf_prefix,
5645 no_neighbor_capability_orf_prefix_hidden_cmd,
5646 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5647 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5648 "Advertise capability to the peer\n"
5649 "Advertise ORF capability to the peer\n"
5650 "Advertise prefixlist ORF capability to this neighbor\n"
5651 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5652 "Capability to RECEIVE the ORF from this neighbor\n"
5653 "Capability to SEND the ORF to this neighbor\n")
5654
5655 /* neighbor next-hop-self. */
5656 DEFUN (neighbor_nexthop_self,
5657 neighbor_nexthop_self_cmd,
5658 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5659 NEIGHBOR_STR
5660 NEIGHBOR_ADDR_STR2
5661 "Disable the next hop calculation for this neighbor\n")
5662 {
5663 int idx_peer = 1;
5664 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5665 bgp_node_safi(vty), PEER_FLAG_NEXTHOP_SELF);
5666 }
5667
5668 ALIAS_HIDDEN(neighbor_nexthop_self, neighbor_nexthop_self_hidden_cmd,
5669 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5670 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5671 "Disable the next hop calculation for this neighbor\n")
5672
5673 /* neighbor next-hop-self. */
5674 DEFUN (neighbor_nexthop_self_force,
5675 neighbor_nexthop_self_force_cmd,
5676 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5677 NEIGHBOR_STR
5678 NEIGHBOR_ADDR_STR2
5679 "Disable the next hop calculation for this neighbor\n"
5680 "Set the next hop to self for reflected routes\n")
5681 {
5682 int idx_peer = 1;
5683 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5684 bgp_node_safi(vty),
5685 PEER_FLAG_FORCE_NEXTHOP_SELF);
5686 }
5687
5688 ALIAS_HIDDEN(neighbor_nexthop_self_force,
5689 neighbor_nexthop_self_force_hidden_cmd,
5690 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5691 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5692 "Disable the next hop calculation for this neighbor\n"
5693 "Set the next hop to self for reflected routes\n")
5694
5695 ALIAS_HIDDEN(neighbor_nexthop_self_force,
5696 neighbor_nexthop_self_all_hidden_cmd,
5697 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
5698 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5699 "Disable the next hop calculation for this neighbor\n"
5700 "Set the next hop to self for reflected routes\n")
5701
5702 DEFUN (no_neighbor_nexthop_self,
5703 no_neighbor_nexthop_self_cmd,
5704 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5705 NO_STR
5706 NEIGHBOR_STR
5707 NEIGHBOR_ADDR_STR2
5708 "Disable the next hop calculation for this neighbor\n")
5709 {
5710 int idx_peer = 2;
5711 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5712 bgp_node_afi(vty), bgp_node_safi(vty),
5713 PEER_FLAG_NEXTHOP_SELF);
5714 }
5715
5716 ALIAS_HIDDEN(no_neighbor_nexthop_self, no_neighbor_nexthop_self_hidden_cmd,
5717 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5718 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5719 "Disable the next hop calculation for this neighbor\n")
5720
5721 DEFUN (no_neighbor_nexthop_self_force,
5722 no_neighbor_nexthop_self_force_cmd,
5723 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5724 NO_STR
5725 NEIGHBOR_STR
5726 NEIGHBOR_ADDR_STR2
5727 "Disable the next hop calculation for this neighbor\n"
5728 "Set the next hop to self for reflected routes\n")
5729 {
5730 int idx_peer = 2;
5731 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5732 bgp_node_afi(vty), bgp_node_safi(vty),
5733 PEER_FLAG_FORCE_NEXTHOP_SELF);
5734 }
5735
5736 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
5737 no_neighbor_nexthop_self_force_hidden_cmd,
5738 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5739 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5740 "Disable the next hop calculation for this neighbor\n"
5741 "Set the next hop to self for reflected routes\n")
5742
5743 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
5744 no_neighbor_nexthop_self_all_hidden_cmd,
5745 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
5746 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5747 "Disable the next hop calculation for this neighbor\n"
5748 "Set the next hop to self for reflected routes\n")
5749
5750 /* neighbor as-override */
5751 DEFUN (neighbor_as_override,
5752 neighbor_as_override_cmd,
5753 "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5754 NEIGHBOR_STR
5755 NEIGHBOR_ADDR_STR2
5756 "Override ASNs in outbound updates if aspath equals remote-as\n")
5757 {
5758 int idx_peer = 1;
5759 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5760 bgp_node_safi(vty), PEER_FLAG_AS_OVERRIDE);
5761 }
5762
5763 ALIAS_HIDDEN(neighbor_as_override, neighbor_as_override_hidden_cmd,
5764 "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5765 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5766 "Override ASNs in outbound updates if aspath equals remote-as\n")
5767
5768 DEFUN (no_neighbor_as_override,
5769 no_neighbor_as_override_cmd,
5770 "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5771 NO_STR
5772 NEIGHBOR_STR
5773 NEIGHBOR_ADDR_STR2
5774 "Override ASNs in outbound updates if aspath equals remote-as\n")
5775 {
5776 int idx_peer = 2;
5777 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5778 bgp_node_afi(vty), bgp_node_safi(vty),
5779 PEER_FLAG_AS_OVERRIDE);
5780 }
5781
5782 ALIAS_HIDDEN(no_neighbor_as_override, no_neighbor_as_override_hidden_cmd,
5783 "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5784 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5785 "Override ASNs in outbound updates if aspath equals remote-as\n")
5786
5787 /* neighbor remove-private-AS. */
5788 DEFUN (neighbor_remove_private_as,
5789 neighbor_remove_private_as_cmd,
5790 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5791 NEIGHBOR_STR
5792 NEIGHBOR_ADDR_STR2
5793 "Remove private ASNs in outbound updates\n")
5794 {
5795 int idx_peer = 1;
5796 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5797 bgp_node_safi(vty),
5798 PEER_FLAG_REMOVE_PRIVATE_AS);
5799 }
5800
5801 ALIAS_HIDDEN(neighbor_remove_private_as, neighbor_remove_private_as_hidden_cmd,
5802 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5803 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5804 "Remove private ASNs in outbound updates\n")
5805
5806 DEFUN (neighbor_remove_private_as_all,
5807 neighbor_remove_private_as_all_cmd,
5808 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5809 NEIGHBOR_STR
5810 NEIGHBOR_ADDR_STR2
5811 "Remove private ASNs in outbound updates\n"
5812 "Apply to all AS numbers\n")
5813 {
5814 int idx_peer = 1;
5815 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5816 bgp_node_safi(vty),
5817 PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
5818 }
5819
5820 ALIAS_HIDDEN(neighbor_remove_private_as_all,
5821 neighbor_remove_private_as_all_hidden_cmd,
5822 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5823 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5824 "Remove private ASNs in outbound updates\n"
5825 "Apply to all AS numbers\n")
5826
5827 DEFUN (neighbor_remove_private_as_replace_as,
5828 neighbor_remove_private_as_replace_as_cmd,
5829 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5830 NEIGHBOR_STR
5831 NEIGHBOR_ADDR_STR2
5832 "Remove private ASNs in outbound updates\n"
5833 "Replace private ASNs with our ASN in outbound updates\n")
5834 {
5835 int idx_peer = 1;
5836 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5837 bgp_node_safi(vty),
5838 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
5839 }
5840
5841 ALIAS_HIDDEN(neighbor_remove_private_as_replace_as,
5842 neighbor_remove_private_as_replace_as_hidden_cmd,
5843 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5844 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5845 "Remove private ASNs in outbound updates\n"
5846 "Replace private ASNs with our ASN in outbound updates\n")
5847
5848 DEFUN (neighbor_remove_private_as_all_replace_as,
5849 neighbor_remove_private_as_all_replace_as_cmd,
5850 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
5851 NEIGHBOR_STR
5852 NEIGHBOR_ADDR_STR2
5853 "Remove private ASNs in outbound updates\n"
5854 "Apply to all AS numbers\n"
5855 "Replace private ASNs with our ASN in outbound updates\n")
5856 {
5857 int idx_peer = 1;
5858 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5859 bgp_node_safi(vty),
5860 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
5861 }
5862
5863 ALIAS_HIDDEN(
5864 neighbor_remove_private_as_all_replace_as,
5865 neighbor_remove_private_as_all_replace_as_hidden_cmd,
5866 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
5867 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5868 "Remove private ASNs in outbound updates\n"
5869 "Apply to all AS numbers\n"
5870 "Replace private ASNs with our ASN in outbound updates\n")
5871
5872 DEFUN (no_neighbor_remove_private_as,
5873 no_neighbor_remove_private_as_cmd,
5874 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5875 NO_STR
5876 NEIGHBOR_STR
5877 NEIGHBOR_ADDR_STR2
5878 "Remove private ASNs in outbound updates\n")
5879 {
5880 int idx_peer = 2;
5881 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5882 bgp_node_afi(vty), bgp_node_safi(vty),
5883 PEER_FLAG_REMOVE_PRIVATE_AS);
5884 }
5885
5886 ALIAS_HIDDEN(no_neighbor_remove_private_as,
5887 no_neighbor_remove_private_as_hidden_cmd,
5888 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5889 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5890 "Remove private ASNs in outbound updates\n")
5891
5892 DEFUN (no_neighbor_remove_private_as_all,
5893 no_neighbor_remove_private_as_all_cmd,
5894 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5895 NO_STR
5896 NEIGHBOR_STR
5897 NEIGHBOR_ADDR_STR2
5898 "Remove private ASNs in outbound updates\n"
5899 "Apply to all AS numbers\n")
5900 {
5901 int idx_peer = 2;
5902 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5903 bgp_node_afi(vty), bgp_node_safi(vty),
5904 PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
5905 }
5906
5907 ALIAS_HIDDEN(no_neighbor_remove_private_as_all,
5908 no_neighbor_remove_private_as_all_hidden_cmd,
5909 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5910 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5911 "Remove private ASNs in outbound updates\n"
5912 "Apply to all AS numbers\n")
5913
5914 DEFUN (no_neighbor_remove_private_as_replace_as,
5915 no_neighbor_remove_private_as_replace_as_cmd,
5916 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5917 NO_STR
5918 NEIGHBOR_STR
5919 NEIGHBOR_ADDR_STR2
5920 "Remove private ASNs in outbound updates\n"
5921 "Replace private ASNs with our ASN in outbound updates\n")
5922 {
5923 int idx_peer = 2;
5924 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5925 bgp_node_afi(vty), bgp_node_safi(vty),
5926 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
5927 }
5928
5929 ALIAS_HIDDEN(no_neighbor_remove_private_as_replace_as,
5930 no_neighbor_remove_private_as_replace_as_hidden_cmd,
5931 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5932 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5933 "Remove private ASNs in outbound updates\n"
5934 "Replace private ASNs with our ASN in outbound updates\n")
5935
5936 DEFUN (no_neighbor_remove_private_as_all_replace_as,
5937 no_neighbor_remove_private_as_all_replace_as_cmd,
5938 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
5939 NO_STR
5940 NEIGHBOR_STR
5941 NEIGHBOR_ADDR_STR2
5942 "Remove private ASNs in outbound updates\n"
5943 "Apply to all AS numbers\n"
5944 "Replace private ASNs with our ASN in outbound updates\n")
5945 {
5946 int idx_peer = 2;
5947 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5948 bgp_node_afi(vty), bgp_node_safi(vty),
5949 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
5950 }
5951
5952 ALIAS_HIDDEN(
5953 no_neighbor_remove_private_as_all_replace_as,
5954 no_neighbor_remove_private_as_all_replace_as_hidden_cmd,
5955 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
5956 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5957 "Remove private ASNs in outbound updates\n"
5958 "Apply to all AS numbers\n"
5959 "Replace private ASNs with our ASN in outbound updates\n")
5960
5961
5962 /* neighbor send-community. */
5963 DEFUN (neighbor_send_community,
5964 neighbor_send_community_cmd,
5965 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
5966 NEIGHBOR_STR
5967 NEIGHBOR_ADDR_STR2
5968 "Send Community attribute to this neighbor\n")
5969 {
5970 int idx_peer = 1;
5971
5972 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5973 bgp_node_safi(vty),
5974 PEER_FLAG_SEND_COMMUNITY);
5975 }
5976
5977 ALIAS_HIDDEN(neighbor_send_community, neighbor_send_community_hidden_cmd,
5978 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
5979 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5980 "Send Community attribute to this neighbor\n")
5981
5982 DEFUN (no_neighbor_send_community,
5983 no_neighbor_send_community_cmd,
5984 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
5985 NO_STR
5986 NEIGHBOR_STR
5987 NEIGHBOR_ADDR_STR2
5988 "Send Community attribute to this neighbor\n")
5989 {
5990 int idx_peer = 2;
5991
5992 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5993 bgp_node_afi(vty), bgp_node_safi(vty),
5994 PEER_FLAG_SEND_COMMUNITY);
5995 }
5996
5997 ALIAS_HIDDEN(no_neighbor_send_community, no_neighbor_send_community_hidden_cmd,
5998 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
5999 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6000 "Send Community attribute to this neighbor\n")
6001
6002 /* neighbor send-community extended. */
6003 DEFUN (neighbor_send_community_type,
6004 neighbor_send_community_type_cmd,
6005 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6006 NEIGHBOR_STR
6007 NEIGHBOR_ADDR_STR2
6008 "Send Community attribute to this neighbor\n"
6009 "Send Standard and Extended Community attributes\n"
6010 "Send Standard, Large and Extended Community attributes\n"
6011 "Send Extended Community attributes\n"
6012 "Send Standard Community attributes\n"
6013 "Send Large Community attributes\n")
6014 {
6015 const char *type = argv[argc - 1]->text;
6016 char *peer_str = argv[1]->arg;
6017 struct peer *peer;
6018 afi_t afi = bgp_node_afi(vty);
6019 safi_t safi = bgp_node_safi(vty);
6020
6021 peer = peer_and_group_lookup_vty(vty, peer_str);
6022 if (!peer)
6023 return CMD_WARNING_CONFIG_FAILED;
6024
6025 if (strmatch(type, "standard"))
6026 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6027 PEER_FLAG_SEND_COMMUNITY);
6028
6029 if (strmatch(type, "extended"))
6030 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6031 PEER_FLAG_SEND_EXT_COMMUNITY);
6032
6033 if (strmatch(type, "large"))
6034 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6035 PEER_FLAG_SEND_LARGE_COMMUNITY);
6036
6037 if (strmatch(type, "both")) {
6038 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6039 PEER_FLAG_SEND_COMMUNITY)
6040 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6041 PEER_FLAG_SEND_EXT_COMMUNITY);
6042 }
6043 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6044 PEER_FLAG_SEND_COMMUNITY)
6045 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6046 PEER_FLAG_SEND_EXT_COMMUNITY)
6047 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6048 PEER_FLAG_SEND_LARGE_COMMUNITY);
6049 }
6050
6051 ALIAS_HIDDEN(
6052 neighbor_send_community_type, neighbor_send_community_type_hidden_cmd,
6053 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6054 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6055 "Send Community attribute to this neighbor\n"
6056 "Send Standard and Extended Community attributes\n"
6057 "Send Standard, Large and Extended Community attributes\n"
6058 "Send Extended Community attributes\n"
6059 "Send Standard Community attributes\n"
6060 "Send Large Community attributes\n")
6061
6062 DEFUN (no_neighbor_send_community_type,
6063 no_neighbor_send_community_type_cmd,
6064 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6065 NO_STR
6066 NEIGHBOR_STR
6067 NEIGHBOR_ADDR_STR2
6068 "Send Community attribute to this neighbor\n"
6069 "Send Standard and Extended Community attributes\n"
6070 "Send Standard, Large and Extended Community attributes\n"
6071 "Send Extended Community attributes\n"
6072 "Send Standard Community attributes\n"
6073 "Send Large Community attributes\n")
6074 {
6075 const char *type = argv[argc - 1]->text;
6076 char *peer_str = argv[2]->arg;
6077 struct peer *peer;
6078 afi_t afi = bgp_node_afi(vty);
6079 safi_t safi = bgp_node_safi(vty);
6080
6081 peer = peer_and_group_lookup_vty(vty, peer_str);
6082 if (!peer)
6083 return CMD_WARNING_CONFIG_FAILED;
6084
6085 if (strmatch(type, "standard"))
6086 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6087 PEER_FLAG_SEND_COMMUNITY);
6088
6089 if (strmatch(type, "extended"))
6090 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6091 PEER_FLAG_SEND_EXT_COMMUNITY);
6092
6093 if (strmatch(type, "large"))
6094 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6095 PEER_FLAG_SEND_LARGE_COMMUNITY);
6096
6097 if (strmatch(type, "both")) {
6098
6099 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6100 PEER_FLAG_SEND_COMMUNITY)
6101 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6102 PEER_FLAG_SEND_EXT_COMMUNITY);
6103 }
6104
6105 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6106 PEER_FLAG_SEND_COMMUNITY)
6107 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6108 PEER_FLAG_SEND_EXT_COMMUNITY)
6109 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6110 PEER_FLAG_SEND_LARGE_COMMUNITY);
6111 }
6112
6113 ALIAS_HIDDEN(
6114 no_neighbor_send_community_type,
6115 no_neighbor_send_community_type_hidden_cmd,
6116 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6117 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6118 "Send Community attribute to this neighbor\n"
6119 "Send Standard and Extended Community attributes\n"
6120 "Send Standard, Large and Extended Community attributes\n"
6121 "Send Extended Community attributes\n"
6122 "Send Standard Community attributes\n"
6123 "Send Large Community attributes\n")
6124
6125 /* neighbor soft-reconfig. */
6126 DEFUN (neighbor_soft_reconfiguration,
6127 neighbor_soft_reconfiguration_cmd,
6128 "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6129 NEIGHBOR_STR
6130 NEIGHBOR_ADDR_STR2
6131 "Per neighbor soft reconfiguration\n"
6132 "Allow inbound soft reconfiguration for this neighbor\n")
6133 {
6134 int idx_peer = 1;
6135 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6136 bgp_node_safi(vty),
6137 PEER_FLAG_SOFT_RECONFIG);
6138 }
6139
6140 ALIAS_HIDDEN(neighbor_soft_reconfiguration,
6141 neighbor_soft_reconfiguration_hidden_cmd,
6142 "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6143 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6144 "Per neighbor soft reconfiguration\n"
6145 "Allow inbound soft reconfiguration for this neighbor\n")
6146
6147 DEFUN (no_neighbor_soft_reconfiguration,
6148 no_neighbor_soft_reconfiguration_cmd,
6149 "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6150 NO_STR
6151 NEIGHBOR_STR
6152 NEIGHBOR_ADDR_STR2
6153 "Per neighbor soft reconfiguration\n"
6154 "Allow inbound soft reconfiguration for this neighbor\n")
6155 {
6156 int idx_peer = 2;
6157 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6158 bgp_node_afi(vty), bgp_node_safi(vty),
6159 PEER_FLAG_SOFT_RECONFIG);
6160 }
6161
6162 ALIAS_HIDDEN(no_neighbor_soft_reconfiguration,
6163 no_neighbor_soft_reconfiguration_hidden_cmd,
6164 "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6165 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6166 "Per neighbor soft reconfiguration\n"
6167 "Allow inbound soft reconfiguration for this neighbor\n")
6168
6169 DEFUN (neighbor_route_reflector_client,
6170 neighbor_route_reflector_client_cmd,
6171 "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6172 NEIGHBOR_STR
6173 NEIGHBOR_ADDR_STR2
6174 "Configure a neighbor as Route Reflector client\n")
6175 {
6176 int idx_peer = 1;
6177 struct peer *peer;
6178
6179
6180 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6181 if (!peer)
6182 return CMD_WARNING_CONFIG_FAILED;
6183
6184 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6185 bgp_node_safi(vty),
6186 PEER_FLAG_REFLECTOR_CLIENT);
6187 }
6188
6189 ALIAS_HIDDEN(neighbor_route_reflector_client,
6190 neighbor_route_reflector_client_hidden_cmd,
6191 "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6192 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6193 "Configure a neighbor as Route Reflector client\n")
6194
6195 DEFUN (no_neighbor_route_reflector_client,
6196 no_neighbor_route_reflector_client_cmd,
6197 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6198 NO_STR
6199 NEIGHBOR_STR
6200 NEIGHBOR_ADDR_STR2
6201 "Configure a neighbor as Route Reflector client\n")
6202 {
6203 int idx_peer = 2;
6204 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6205 bgp_node_afi(vty), bgp_node_safi(vty),
6206 PEER_FLAG_REFLECTOR_CLIENT);
6207 }
6208
6209 ALIAS_HIDDEN(no_neighbor_route_reflector_client,
6210 no_neighbor_route_reflector_client_hidden_cmd,
6211 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6212 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6213 "Configure a neighbor as Route Reflector client\n")
6214
6215 /* optimal-route-reflection Root Routers configuration */
6216 DEFPY (optimal_route_reflection,
6217 optimal_route_reflection_cmd,
6218 "[no$no] optimal-route-reflection WORD$orr_group [<A.B.C.D|X:X::X:X>$primary [<A.B.C.D|X:X::X:X>$secondary [<A.B.C.D|X:X::X:X>$tertiary]]]",
6219 NO_STR
6220 "Create ORR group and assign root router(s)\n"
6221 "ORR Group name\n"
6222 "Primary Root address\n"
6223 "Primary Root IPv6 address\n"
6224 "Secondary Root address\n"
6225 "Secondary Root IPv6 address\n"
6226 "Tertiary Root address\n"
6227 "Tertiary Root IPv6 address\n")
6228 {
6229 if (!no && !primary) {
6230 vty_out(vty, "%% Specify Primary Root address\n");
6231 return CMD_WARNING_CONFIG_FAILED;
6232 }
6233 return bgp_afi_safi_orr_group_set_vty(
6234 vty, bgp_node_afi(vty), bgp_node_safi(vty), orr_group,
6235 primary_str, secondary_str, tertiary_str, !!no);
6236 }
6237
6238 /* neighbor optimal-route-reflection group*/
6239 DEFPY (neighbor_optimal_route_reflection,
6240 neighbor_optimal_route_reflection_cmd,
6241 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor optimal-route-reflection WORD$orr_group",
6242 NO_STR
6243 NEIGHBOR_STR
6244 NEIGHBOR_ADDR_STR2
6245 "Apply ORR group configuration to the neighbor\n"
6246 "ORR group name\n")
6247 {
6248 return peer_orr_group_set_vty(vty, neighbor, bgp_node_afi(vty),
6249 bgp_node_safi(vty), orr_group, !!no);
6250 }
6251
6252 /* neighbor route-server-client. */
6253 DEFUN (neighbor_route_server_client,
6254 neighbor_route_server_client_cmd,
6255 "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6256 NEIGHBOR_STR
6257 NEIGHBOR_ADDR_STR2
6258 "Configure a neighbor as Route Server client\n")
6259 {
6260 int idx_peer = 1;
6261 struct peer *peer;
6262
6263 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6264 if (!peer)
6265 return CMD_WARNING_CONFIG_FAILED;
6266 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6267 bgp_node_safi(vty),
6268 PEER_FLAG_RSERVER_CLIENT);
6269 }
6270
6271 ALIAS_HIDDEN(neighbor_route_server_client,
6272 neighbor_route_server_client_hidden_cmd,
6273 "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6274 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6275 "Configure a neighbor as Route Server client\n")
6276
6277 DEFUN (no_neighbor_route_server_client,
6278 no_neighbor_route_server_client_cmd,
6279 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6280 NO_STR
6281 NEIGHBOR_STR
6282 NEIGHBOR_ADDR_STR2
6283 "Configure a neighbor as Route Server client\n")
6284 {
6285 int idx_peer = 2;
6286 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6287 bgp_node_afi(vty), bgp_node_safi(vty),
6288 PEER_FLAG_RSERVER_CLIENT);
6289 }
6290
6291 ALIAS_HIDDEN(no_neighbor_route_server_client,
6292 no_neighbor_route_server_client_hidden_cmd,
6293 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6294 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6295 "Configure a neighbor as Route Server client\n")
6296
6297 DEFUN (neighbor_nexthop_local_unchanged,
6298 neighbor_nexthop_local_unchanged_cmd,
6299 "neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
6300 NEIGHBOR_STR
6301 NEIGHBOR_ADDR_STR2
6302 "Configure treatment of outgoing link-local nexthop attribute\n"
6303 "Leave link-local nexthop unchanged for this peer\n")
6304 {
6305 int idx_peer = 1;
6306 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6307 bgp_node_safi(vty),
6308 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
6309 }
6310
6311 DEFUN (no_neighbor_nexthop_local_unchanged,
6312 no_neighbor_nexthop_local_unchanged_cmd,
6313 "no neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
6314 NO_STR
6315 NEIGHBOR_STR
6316 NEIGHBOR_ADDR_STR2
6317 "Configure treatment of outgoing link-local-nexthop attribute\n"
6318 "Leave link-local nexthop unchanged for this peer\n")
6319 {
6320 int idx_peer = 2;
6321 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6322 bgp_node_afi(vty), bgp_node_safi(vty),
6323 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
6324 }
6325
6326 DEFUN (neighbor_attr_unchanged,
6327 neighbor_attr_unchanged_cmd,
6328 "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6329 NEIGHBOR_STR
6330 NEIGHBOR_ADDR_STR2
6331 "BGP attribute is propagated unchanged to this neighbor\n"
6332 "As-path attribute\n"
6333 "Nexthop attribute\n"
6334 "Med attribute\n")
6335 {
6336 int idx = 0;
6337 char *peer_str = argv[1]->arg;
6338 struct peer *peer;
6339 bool aspath = false;
6340 bool nexthop = false;
6341 bool med = false;
6342 afi_t afi = bgp_node_afi(vty);
6343 safi_t safi = bgp_node_safi(vty);
6344 int ret = 0;
6345
6346 peer = peer_and_group_lookup_vty(vty, peer_str);
6347 if (!peer)
6348 return CMD_WARNING_CONFIG_FAILED;
6349
6350 if (argv_find(argv, argc, "as-path", &idx))
6351 aspath = true;
6352
6353 idx = 0;
6354 if (argv_find(argv, argc, "next-hop", &idx))
6355 nexthop = true;
6356
6357 idx = 0;
6358 if (argv_find(argv, argc, "med", &idx))
6359 med = true;
6360
6361 /* no flags means all of them! */
6362 if (!aspath && !nexthop && !med) {
6363 ret = peer_af_flag_set_vty(vty, peer_str, afi, safi,
6364 PEER_FLAG_AS_PATH_UNCHANGED);
6365 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6366 PEER_FLAG_NEXTHOP_UNCHANGED);
6367 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6368 PEER_FLAG_MED_UNCHANGED);
6369 } else {
6370 if (!aspath) {
6371 if (peer_af_flag_check(peer, afi, safi,
6372 PEER_FLAG_AS_PATH_UNCHANGED)) {
6373 ret |= peer_af_flag_unset_vty(
6374 vty, peer_str, afi, safi,
6375 PEER_FLAG_AS_PATH_UNCHANGED);
6376 }
6377 } else
6378 ret |= peer_af_flag_set_vty(
6379 vty, peer_str, afi, safi,
6380 PEER_FLAG_AS_PATH_UNCHANGED);
6381
6382 if (!nexthop) {
6383 if (peer_af_flag_check(peer, afi, safi,
6384 PEER_FLAG_NEXTHOP_UNCHANGED)) {
6385 ret |= peer_af_flag_unset_vty(
6386 vty, peer_str, afi, safi,
6387 PEER_FLAG_NEXTHOP_UNCHANGED);
6388 }
6389 } else
6390 ret |= peer_af_flag_set_vty(
6391 vty, peer_str, afi, safi,
6392 PEER_FLAG_NEXTHOP_UNCHANGED);
6393
6394 if (!med) {
6395 if (peer_af_flag_check(peer, afi, safi,
6396 PEER_FLAG_MED_UNCHANGED)) {
6397 ret |= peer_af_flag_unset_vty(
6398 vty, peer_str, afi, safi,
6399 PEER_FLAG_MED_UNCHANGED);
6400 }
6401 } else
6402 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6403 PEER_FLAG_MED_UNCHANGED);
6404 }
6405
6406 return ret;
6407 }
6408
6409 ALIAS_HIDDEN(
6410 neighbor_attr_unchanged, neighbor_attr_unchanged_hidden_cmd,
6411 "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6412 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6413 "BGP attribute is propagated unchanged to this neighbor\n"
6414 "As-path attribute\n"
6415 "Nexthop attribute\n"
6416 "Med attribute\n")
6417
6418 DEFUN (no_neighbor_attr_unchanged,
6419 no_neighbor_attr_unchanged_cmd,
6420 "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6421 NO_STR
6422 NEIGHBOR_STR
6423 NEIGHBOR_ADDR_STR2
6424 "BGP attribute is propagated unchanged to this neighbor\n"
6425 "As-path attribute\n"
6426 "Nexthop attribute\n"
6427 "Med attribute\n")
6428 {
6429 int idx = 0;
6430 char *peer_str = argv[2]->arg;
6431 struct peer *peer;
6432 bool aspath = false;
6433 bool nexthop = false;
6434 bool med = false;
6435 afi_t afi = bgp_node_afi(vty);
6436 safi_t safi = bgp_node_safi(vty);
6437 int ret = 0;
6438
6439 peer = peer_and_group_lookup_vty(vty, peer_str);
6440 if (!peer)
6441 return CMD_WARNING_CONFIG_FAILED;
6442
6443 if (argv_find(argv, argc, "as-path", &idx))
6444 aspath = true;
6445
6446 idx = 0;
6447 if (argv_find(argv, argc, "next-hop", &idx))
6448 nexthop = true;
6449
6450 idx = 0;
6451 if (argv_find(argv, argc, "med", &idx))
6452 med = true;
6453
6454 if (!aspath && !nexthop && !med) // no flags means all of them!
6455 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6456 PEER_FLAG_AS_PATH_UNCHANGED)
6457 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6458 PEER_FLAG_NEXTHOP_UNCHANGED)
6459 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6460 PEER_FLAG_MED_UNCHANGED);
6461
6462 if (aspath)
6463 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6464 PEER_FLAG_AS_PATH_UNCHANGED);
6465
6466 if (nexthop)
6467 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6468 PEER_FLAG_NEXTHOP_UNCHANGED);
6469
6470 if (med)
6471 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6472 PEER_FLAG_MED_UNCHANGED);
6473
6474 return ret;
6475 }
6476
6477 ALIAS_HIDDEN(
6478 no_neighbor_attr_unchanged, no_neighbor_attr_unchanged_hidden_cmd,
6479 "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6480 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6481 "BGP attribute is propagated unchanged to this neighbor\n"
6482 "As-path attribute\n"
6483 "Nexthop attribute\n"
6484 "Med attribute\n")
6485
6486 /* EBGP multihop configuration. */
6487 static int peer_ebgp_multihop_set_vty(struct vty *vty, const char *ip_str,
6488 const char *ttl_str)
6489 {
6490 struct peer *peer;
6491 unsigned int ttl;
6492
6493 peer = peer_and_group_lookup_vty(vty, ip_str);
6494 if (!peer)
6495 return CMD_WARNING_CONFIG_FAILED;
6496
6497 if (peer->conf_if)
6498 return bgp_vty_return(vty, BGP_ERR_INVALID_FOR_DIRECT_PEER);
6499
6500 if (!ttl_str)
6501 ttl = MAXTTL;
6502 else
6503 ttl = strtoul(ttl_str, NULL, 10);
6504
6505 return bgp_vty_return(vty, peer_ebgp_multihop_set(peer, ttl));
6506 }
6507
6508 static int peer_ebgp_multihop_unset_vty(struct vty *vty, const char *ip_str)
6509 {
6510 struct peer *peer;
6511
6512 peer = peer_and_group_lookup_vty(vty, ip_str);
6513 if (!peer)
6514 return CMD_WARNING_CONFIG_FAILED;
6515
6516 return bgp_vty_return(vty, peer_ebgp_multihop_unset(peer));
6517 }
6518
6519 /* neighbor ebgp-multihop. */
6520 DEFUN (neighbor_ebgp_multihop,
6521 neighbor_ebgp_multihop_cmd,
6522 "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop",
6523 NEIGHBOR_STR
6524 NEIGHBOR_ADDR_STR2
6525 "Allow EBGP neighbors not on directly connected networks\n")
6526 {
6527 int idx_peer = 1;
6528 return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg, NULL);
6529 }
6530
6531 DEFUN (neighbor_ebgp_multihop_ttl,
6532 neighbor_ebgp_multihop_ttl_cmd,
6533 "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop (1-255)",
6534 NEIGHBOR_STR
6535 NEIGHBOR_ADDR_STR2
6536 "Allow EBGP neighbors not on directly connected networks\n"
6537 "maximum hop count\n")
6538 {
6539 int idx_peer = 1;
6540 int idx_number = 3;
6541 return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg,
6542 argv[idx_number]->arg);
6543 }
6544
6545 DEFUN (no_neighbor_ebgp_multihop,
6546 no_neighbor_ebgp_multihop_cmd,
6547 "no neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop [(1-255)]",
6548 NO_STR
6549 NEIGHBOR_STR
6550 NEIGHBOR_ADDR_STR2
6551 "Allow EBGP neighbors not on directly connected networks\n"
6552 "maximum hop count\n")
6553 {
6554 int idx_peer = 2;
6555 return peer_ebgp_multihop_unset_vty(vty, argv[idx_peer]->arg);
6556 }
6557
6558 static uint8_t get_role_by_name(const char *role_str)
6559 {
6560 if (strncmp(role_str, "peer", 2) == 0)
6561 return ROLE_PEER;
6562 if (strncmp(role_str, "provider", 2) == 0)
6563 return ROLE_PROVIDER;
6564 if (strncmp(role_str, "customer", 2) == 0)
6565 return ROLE_CUSTOMER;
6566 if (strncmp(role_str, "rs-server", 4) == 0)
6567 return ROLE_RS_SERVER;
6568 if (strncmp(role_str, "rs-client", 4) == 0)
6569 return ROLE_RS_CLIENT;
6570 return ROLE_UNDEFINED;
6571 }
6572
6573 static int peer_role_set_vty(struct vty *vty, const char *ip_str,
6574 const char *role_str, bool strict_mode)
6575 {
6576 struct peer *peer;
6577
6578 peer = peer_and_group_lookup_vty(vty, ip_str);
6579 if (!peer)
6580 return CMD_WARNING_CONFIG_FAILED;
6581 uint8_t role = get_role_by_name(role_str);
6582
6583 if (role == ROLE_UNDEFINED)
6584 return bgp_vty_return(vty, BGP_ERR_INVALID_ROLE_NAME);
6585 return bgp_vty_return(vty, peer_role_set(peer, role, strict_mode));
6586 }
6587
6588 static int peer_role_unset_vty(struct vty *vty, const char *ip_str)
6589 {
6590 struct peer *peer;
6591
6592 peer = peer_and_group_lookup_vty(vty, ip_str);
6593 if (!peer)
6594 return CMD_WARNING_CONFIG_FAILED;
6595 return bgp_vty_return(vty, peer_role_unset(peer));
6596 }
6597
6598 DEFPY(neighbor_role,
6599 neighbor_role_cmd,
6600 "neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer>",
6601 NEIGHBOR_STR
6602 NEIGHBOR_ADDR_STR2
6603 "Set session role\n"
6604 ROLE_STR)
6605 {
6606 int idx_peer = 1;
6607 int idx_role = 3;
6608
6609 return peer_role_set_vty(vty, argv[idx_peer]->arg, argv[idx_role]->arg,
6610 false);
6611 }
6612
6613 DEFPY(neighbor_role_strict,
6614 neighbor_role_strict_cmd,
6615 "neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer> strict-mode",
6616 NEIGHBOR_STR
6617 NEIGHBOR_ADDR_STR2
6618 "Set session role\n"
6619 ROLE_STR
6620 "Use additional restriction on peer\n")
6621 {
6622 int idx_peer = 1;
6623 int idx_role = 3;
6624
6625 return peer_role_set_vty(vty, argv[idx_peer]->arg, argv[idx_role]->arg,
6626 true);
6627 }
6628
6629 DEFPY(no_neighbor_role,
6630 no_neighbor_role_cmd,
6631 "no neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer> [strict-mode]",
6632 NO_STR
6633 NEIGHBOR_STR
6634 NEIGHBOR_ADDR_STR2
6635 "Set session role\n"
6636 ROLE_STR
6637 "Use additional restriction on peer\n")
6638 {
6639 int idx_peer = 2;
6640
6641 return peer_role_unset_vty(vty, argv[idx_peer]->arg);
6642 }
6643
6644 /* disable-connected-check */
6645 DEFUN (neighbor_disable_connected_check,
6646 neighbor_disable_connected_check_cmd,
6647 "neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
6648 NEIGHBOR_STR
6649 NEIGHBOR_ADDR_STR2
6650 "one-hop away EBGP peer using loopback address\n"
6651 "Enforce EBGP neighbors perform multihop\n")
6652 {
6653 int idx_peer = 1;
6654 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6655 PEER_FLAG_DISABLE_CONNECTED_CHECK);
6656 }
6657
6658 DEFUN (no_neighbor_disable_connected_check,
6659 no_neighbor_disable_connected_check_cmd,
6660 "no neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
6661 NO_STR
6662 NEIGHBOR_STR
6663 NEIGHBOR_ADDR_STR2
6664 "one-hop away EBGP peer using loopback address\n"
6665 "Enforce EBGP neighbors perform multihop\n")
6666 {
6667 int idx_peer = 2;
6668 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6669 PEER_FLAG_DISABLE_CONNECTED_CHECK);
6670 }
6671
6672 /* disable-link-bw-encoding-ieee */
6673 DEFUN(neighbor_disable_link_bw_encoding_ieee,
6674 neighbor_disable_link_bw_encoding_ieee_cmd,
6675 "neighbor <A.B.C.D|X:X::X:X|WORD> disable-link-bw-encoding-ieee",
6676 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6677 "Disable IEEE floating-point encoding for extended community bandwidth\n")
6678 {
6679 int idx_peer = 1;
6680
6681 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6682 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE);
6683 }
6684
6685 DEFUN(no_neighbor_disable_link_bw_encoding_ieee,
6686 no_neighbor_disable_link_bw_encoding_ieee_cmd,
6687 "no neighbor <A.B.C.D|X:X::X:X|WORD> disable-link-bw-encoding-ieee",
6688 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6689 "Disable IEEE floating-point encoding for extended community bandwidth\n")
6690 {
6691 int idx_peer = 2;
6692
6693 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6694 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE);
6695 }
6696
6697 /* extended-optional-parameters */
6698 DEFUN(neighbor_extended_optional_parameters,
6699 neighbor_extended_optional_parameters_cmd,
6700 "neighbor <A.B.C.D|X:X::X:X|WORD> extended-optional-parameters",
6701 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6702 "Force the extended optional parameters format for OPEN messages\n")
6703 {
6704 int idx_peer = 1;
6705
6706 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6707 PEER_FLAG_EXTENDED_OPT_PARAMS);
6708 }
6709
6710 DEFUN(no_neighbor_extended_optional_parameters,
6711 no_neighbor_extended_optional_parameters_cmd,
6712 "no neighbor <A.B.C.D|X:X::X:X|WORD> extended-optional-parameters",
6713 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6714 "Force the extended optional parameters format for OPEN messages\n")
6715 {
6716 int idx_peer = 2;
6717
6718 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6719 PEER_FLAG_EXTENDED_OPT_PARAMS);
6720 }
6721
6722 /* enforce-first-as */
6723 DEFUN (neighbor_enforce_first_as,
6724 neighbor_enforce_first_as_cmd,
6725 "neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
6726 NEIGHBOR_STR
6727 NEIGHBOR_ADDR_STR2
6728 "Enforce the first AS for EBGP routes\n")
6729 {
6730 int idx_peer = 1;
6731
6732 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6733 PEER_FLAG_ENFORCE_FIRST_AS);
6734 }
6735
6736 DEFUN (no_neighbor_enforce_first_as,
6737 no_neighbor_enforce_first_as_cmd,
6738 "no neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
6739 NO_STR
6740 NEIGHBOR_STR
6741 NEIGHBOR_ADDR_STR2
6742 "Enforce the first AS for EBGP routes\n")
6743 {
6744 int idx_peer = 2;
6745
6746 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6747 PEER_FLAG_ENFORCE_FIRST_AS);
6748 }
6749
6750
6751 DEFUN (neighbor_description,
6752 neighbor_description_cmd,
6753 "neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
6754 NEIGHBOR_STR
6755 NEIGHBOR_ADDR_STR2
6756 "Neighbor specific description\n"
6757 "Up to 80 characters describing this neighbor\n")
6758 {
6759 int idx_peer = 1;
6760 int idx_line = 3;
6761 struct peer *peer;
6762 char *str;
6763
6764 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6765 if (!peer)
6766 return CMD_WARNING_CONFIG_FAILED;
6767
6768 str = argv_concat(argv, argc, idx_line);
6769
6770 peer_description_set(peer, str);
6771
6772 XFREE(MTYPE_TMP, str);
6773
6774 return CMD_SUCCESS;
6775 }
6776
6777 DEFUN (no_neighbor_description,
6778 no_neighbor_description_cmd,
6779 "no neighbor <A.B.C.D|X:X::X:X|WORD> description",
6780 NO_STR
6781 NEIGHBOR_STR
6782 NEIGHBOR_ADDR_STR2
6783 "Neighbor specific description\n")
6784 {
6785 int idx_peer = 2;
6786 struct peer *peer;
6787
6788 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6789 if (!peer)
6790 return CMD_WARNING_CONFIG_FAILED;
6791
6792 peer_description_unset(peer);
6793
6794 return CMD_SUCCESS;
6795 }
6796
6797 ALIAS(no_neighbor_description, no_neighbor_description_comment_cmd,
6798 "no neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
6799 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6800 "Neighbor specific description\n"
6801 "Up to 80 characters describing this neighbor\n")
6802
6803 /* Neighbor update-source. */
6804 static int peer_update_source_vty(struct vty *vty, const char *peer_str,
6805 const char *source_str)
6806 {
6807 struct peer *peer;
6808 struct prefix p;
6809 union sockunion su;
6810
6811 peer = peer_and_group_lookup_vty(vty, peer_str);
6812 if (!peer)
6813 return CMD_WARNING_CONFIG_FAILED;
6814
6815 if (peer->conf_if)
6816 return CMD_WARNING;
6817
6818 if (source_str) {
6819 if (str2sockunion(source_str, &su) == 0)
6820 peer_update_source_addr_set(peer, &su);
6821 else {
6822 if (str2prefix(source_str, &p)) {
6823 vty_out(vty,
6824 "%% Invalid update-source, remove prefix length \n");
6825 return CMD_WARNING_CONFIG_FAILED;
6826 } else
6827 peer_update_source_if_set(peer, source_str);
6828 }
6829 } else
6830 peer_update_source_unset(peer);
6831
6832 return CMD_SUCCESS;
6833 }
6834
6835 #define BGP_UPDATE_SOURCE_HELP_STR \
6836 "IPv4 address\n" \
6837 "IPv6 address\n" \
6838 "Interface name (requires zebra to be running)\n"
6839
6840 DEFUN (neighbor_update_source,
6841 neighbor_update_source_cmd,
6842 "neighbor <A.B.C.D|X:X::X:X|WORD> update-source <A.B.C.D|X:X::X:X|WORD>",
6843 NEIGHBOR_STR
6844 NEIGHBOR_ADDR_STR2
6845 "Source of routing updates\n"
6846 BGP_UPDATE_SOURCE_HELP_STR)
6847 {
6848 int idx_peer = 1;
6849 int idx_peer_2 = 3;
6850 return peer_update_source_vty(vty, argv[idx_peer]->arg,
6851 argv[idx_peer_2]->arg);
6852 }
6853
6854 DEFUN (no_neighbor_update_source,
6855 no_neighbor_update_source_cmd,
6856 "no neighbor <A.B.C.D|X:X::X:X|WORD> update-source [<A.B.C.D|X:X::X:X|WORD>]",
6857 NO_STR
6858 NEIGHBOR_STR
6859 NEIGHBOR_ADDR_STR2
6860 "Source of routing updates\n"
6861 BGP_UPDATE_SOURCE_HELP_STR)
6862 {
6863 int idx_peer = 2;
6864 return peer_update_source_vty(vty, argv[idx_peer]->arg, NULL);
6865 }
6866
6867 static int peer_default_originate_set_vty(struct vty *vty, const char *peer_str,
6868 afi_t afi, safi_t safi,
6869 const char *rmap, int set)
6870 {
6871 int ret;
6872 struct peer *peer;
6873 struct route_map *route_map = NULL;
6874
6875 peer = peer_and_group_lookup_vty(vty, peer_str);
6876 if (!peer)
6877 return CMD_WARNING_CONFIG_FAILED;
6878
6879 if (set) {
6880 if (rmap)
6881 route_map = route_map_lookup_warn_noexist(vty, rmap);
6882 ret = peer_default_originate_set(peer, afi, safi,
6883 rmap, route_map);
6884 } else
6885 ret = peer_default_originate_unset(peer, afi, safi);
6886
6887 return bgp_vty_return(vty, ret);
6888 }
6889
6890 /* neighbor default-originate. */
6891 DEFUN (neighbor_default_originate,
6892 neighbor_default_originate_cmd,
6893 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
6894 NEIGHBOR_STR
6895 NEIGHBOR_ADDR_STR2
6896 "Originate default route to this neighbor\n")
6897 {
6898 int idx_peer = 1;
6899 return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
6900 bgp_node_afi(vty),
6901 bgp_node_safi(vty), NULL, 1);
6902 }
6903
6904 ALIAS_HIDDEN(neighbor_default_originate, neighbor_default_originate_hidden_cmd,
6905 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
6906 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6907 "Originate default route to this neighbor\n")
6908
6909 DEFUN (neighbor_default_originate_rmap,
6910 neighbor_default_originate_rmap_cmd,
6911 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map RMAP_NAME",
6912 NEIGHBOR_STR
6913 NEIGHBOR_ADDR_STR2
6914 "Originate default route to this neighbor\n"
6915 "Route-map to specify criteria to originate default\n"
6916 "route-map name\n")
6917 {
6918 int idx_peer = 1;
6919 int idx_word = 4;
6920 return peer_default_originate_set_vty(
6921 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
6922 argv[idx_word]->arg, 1);
6923 }
6924
6925 ALIAS_HIDDEN(
6926 neighbor_default_originate_rmap,
6927 neighbor_default_originate_rmap_hidden_cmd,
6928 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map RMAP_NAME",
6929 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6930 "Originate default route to this neighbor\n"
6931 "Route-map to specify criteria to originate default\n"
6932 "route-map name\n")
6933
6934 DEFUN (no_neighbor_default_originate,
6935 no_neighbor_default_originate_cmd,
6936 "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map RMAP_NAME]",
6937 NO_STR
6938 NEIGHBOR_STR
6939 NEIGHBOR_ADDR_STR2
6940 "Originate default route to this neighbor\n"
6941 "Route-map to specify criteria to originate default\n"
6942 "route-map name\n")
6943 {
6944 int idx_peer = 2;
6945 return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
6946 bgp_node_afi(vty),
6947 bgp_node_safi(vty), NULL, 0);
6948 }
6949
6950 ALIAS_HIDDEN(
6951 no_neighbor_default_originate, no_neighbor_default_originate_hidden_cmd,
6952 "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map RMAP_NAME]",
6953 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6954 "Originate default route to this neighbor\n"
6955 "Route-map to specify criteria to originate default\n"
6956 "route-map name\n")
6957
6958
6959 /* Set neighbor's BGP port. */
6960 static int peer_port_vty(struct vty *vty, const char *ip_str, int afi,
6961 const char *port_str)
6962 {
6963 struct peer *peer;
6964 uint16_t port;
6965 struct servent *sp;
6966
6967 peer = peer_and_group_lookup_vty(vty, ip_str);
6968 if (!peer)
6969 return CMD_WARNING_CONFIG_FAILED;
6970
6971 if (!port_str) {
6972 sp = getservbyname("bgp", "tcp");
6973 port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs(sp->s_port);
6974 } else {
6975 port = strtoul(port_str, NULL, 10);
6976 }
6977
6978 peer_port_set(peer, port);
6979
6980 return CMD_SUCCESS;
6981 }
6982
6983 /* Set specified peer's BGP port. */
6984 DEFUN (neighbor_port,
6985 neighbor_port_cmd,
6986 "neighbor <A.B.C.D|X:X::X:X|WORD> port (0-65535)",
6987 NEIGHBOR_STR
6988 NEIGHBOR_ADDR_STR2
6989 "Neighbor's BGP port\n"
6990 "TCP port number\n")
6991 {
6992 int idx_ip = 1;
6993 int idx_number = 3;
6994 return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP,
6995 argv[idx_number]->arg);
6996 }
6997
6998 DEFUN (no_neighbor_port,
6999 no_neighbor_port_cmd,
7000 "no neighbor <A.B.C.D|X:X::X:X|WORD> port [(0-65535)]",
7001 NO_STR
7002 NEIGHBOR_STR
7003 NEIGHBOR_ADDR_STR2
7004 "Neighbor's BGP port\n"
7005 "TCP port number\n")
7006 {
7007 int idx_ip = 2;
7008 return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP, NULL);
7009 }
7010
7011
7012 /* neighbor weight. */
7013 static int peer_weight_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
7014 safi_t safi, const char *weight_str)
7015 {
7016 int ret;
7017 struct peer *peer;
7018 unsigned long weight;
7019
7020 peer = peer_and_group_lookup_vty(vty, ip_str);
7021 if (!peer)
7022 return CMD_WARNING_CONFIG_FAILED;
7023
7024 weight = strtoul(weight_str, NULL, 10);
7025
7026 ret = peer_weight_set(peer, afi, safi, weight);
7027 return bgp_vty_return(vty, ret);
7028 }
7029
7030 static int peer_weight_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
7031 safi_t safi)
7032 {
7033 int ret;
7034 struct peer *peer;
7035
7036 peer = peer_and_group_lookup_vty(vty, ip_str);
7037 if (!peer)
7038 return CMD_WARNING_CONFIG_FAILED;
7039
7040 ret = peer_weight_unset(peer, afi, safi);
7041 return bgp_vty_return(vty, ret);
7042 }
7043
7044 DEFUN (neighbor_weight,
7045 neighbor_weight_cmd,
7046 "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
7047 NEIGHBOR_STR
7048 NEIGHBOR_ADDR_STR2
7049 "Set default weight for routes from this neighbor\n"
7050 "default weight\n")
7051 {
7052 int idx_peer = 1;
7053 int idx_number = 3;
7054 return peer_weight_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
7055 bgp_node_safi(vty), argv[idx_number]->arg);
7056 }
7057
7058 ALIAS_HIDDEN(neighbor_weight, neighbor_weight_hidden_cmd,
7059 "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
7060 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7061 "Set default weight for routes from this neighbor\n"
7062 "default weight\n")
7063
7064 DEFUN (no_neighbor_weight,
7065 no_neighbor_weight_cmd,
7066 "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
7067 NO_STR
7068 NEIGHBOR_STR
7069 NEIGHBOR_ADDR_STR2
7070 "Set default weight for routes from this neighbor\n"
7071 "default weight\n")
7072 {
7073 int idx_peer = 2;
7074 return peer_weight_unset_vty(vty, argv[idx_peer]->arg,
7075 bgp_node_afi(vty), bgp_node_safi(vty));
7076 }
7077
7078 ALIAS_HIDDEN(no_neighbor_weight, no_neighbor_weight_hidden_cmd,
7079 "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
7080 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7081 "Set default weight for routes from this neighbor\n"
7082 "default weight\n")
7083
7084
7085 /* Override capability negotiation. */
7086 DEFUN (neighbor_override_capability,
7087 neighbor_override_capability_cmd,
7088 "neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
7089 NEIGHBOR_STR
7090 NEIGHBOR_ADDR_STR2
7091 "Override capability negotiation result\n")
7092 {
7093 int idx_peer = 1;
7094 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
7095 PEER_FLAG_OVERRIDE_CAPABILITY);
7096 }
7097
7098 DEFUN (no_neighbor_override_capability,
7099 no_neighbor_override_capability_cmd,
7100 "no neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
7101 NO_STR
7102 NEIGHBOR_STR
7103 NEIGHBOR_ADDR_STR2
7104 "Override capability negotiation result\n")
7105 {
7106 int idx_peer = 2;
7107 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
7108 PEER_FLAG_OVERRIDE_CAPABILITY);
7109 }
7110
7111 DEFUN (neighbor_strict_capability,
7112 neighbor_strict_capability_cmd,
7113 "neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
7114 NEIGHBOR_STR
7115 NEIGHBOR_ADDR_STR2
7116 "Strict capability negotiation match\n")
7117 {
7118 int idx_peer = 1;
7119
7120 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
7121 PEER_FLAG_STRICT_CAP_MATCH);
7122 }
7123
7124 DEFUN (no_neighbor_strict_capability,
7125 no_neighbor_strict_capability_cmd,
7126 "no neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
7127 NO_STR
7128 NEIGHBOR_STR
7129 NEIGHBOR_ADDR_STR2
7130 "Strict capability negotiation match\n")
7131 {
7132 int idx_peer = 2;
7133
7134 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
7135 PEER_FLAG_STRICT_CAP_MATCH);
7136 }
7137
7138 static int peer_timers_set_vty(struct vty *vty, const char *ip_str,
7139 const char *keep_str, const char *hold_str)
7140 {
7141 int ret;
7142 struct peer *peer;
7143 uint32_t keepalive;
7144 uint32_t holdtime;
7145
7146 peer = peer_and_group_lookup_vty(vty, ip_str);
7147 if (!peer)
7148 return CMD_WARNING_CONFIG_FAILED;
7149
7150 keepalive = strtoul(keep_str, NULL, 10);
7151 holdtime = strtoul(hold_str, NULL, 10);
7152
7153 ret = peer_timers_set(peer, keepalive, holdtime);
7154
7155 return bgp_vty_return(vty, ret);
7156 }
7157
7158 static int peer_timers_unset_vty(struct vty *vty, const char *ip_str)
7159 {
7160 int ret;
7161 struct peer *peer;
7162
7163 peer = peer_and_group_lookup_vty(vty, ip_str);
7164 if (!peer)
7165 return CMD_WARNING_CONFIG_FAILED;
7166
7167 ret = peer_timers_unset(peer);
7168
7169 return bgp_vty_return(vty, ret);
7170 }
7171
7172 DEFUN (neighbor_timers,
7173 neighbor_timers_cmd,
7174 "neighbor <A.B.C.D|X:X::X:X|WORD> timers (0-65535) (0-65535)",
7175 NEIGHBOR_STR
7176 NEIGHBOR_ADDR_STR2
7177 "BGP per neighbor timers\n"
7178 "Keepalive interval\n"
7179 "Holdtime\n")
7180 {
7181 int idx_peer = 1;
7182 int idx_number = 3;
7183 int idx_number_2 = 4;
7184 return peer_timers_set_vty(vty, argv[idx_peer]->arg,
7185 argv[idx_number]->arg,
7186 argv[idx_number_2]->arg);
7187 }
7188
7189 DEFUN (no_neighbor_timers,
7190 no_neighbor_timers_cmd,
7191 "no neighbor <A.B.C.D|X:X::X:X|WORD> timers [(0-65535) (0-65535)]",
7192 NO_STR
7193 NEIGHBOR_STR
7194 NEIGHBOR_ADDR_STR2
7195 "BGP per neighbor timers\n"
7196 "Keepalive interval\n"
7197 "Holdtime\n")
7198 {
7199 int idx_peer = 2;
7200 return peer_timers_unset_vty(vty, argv[idx_peer]->arg);
7201 }
7202
7203
7204 static int peer_timers_connect_set_vty(struct vty *vty, const char *ip_str,
7205 const char *time_str)
7206 {
7207 int ret;
7208 struct peer *peer;
7209 uint32_t connect;
7210
7211 peer = peer_and_group_lookup_vty(vty, ip_str);
7212 if (!peer)
7213 return CMD_WARNING_CONFIG_FAILED;
7214
7215 connect = strtoul(time_str, NULL, 10);
7216
7217 ret = peer_timers_connect_set(peer, connect);
7218
7219 return bgp_vty_return(vty, ret);
7220 }
7221
7222 static int peer_timers_connect_unset_vty(struct vty *vty, const char *ip_str)
7223 {
7224 int ret;
7225 struct peer *peer;
7226
7227 peer = peer_and_group_lookup_vty(vty, ip_str);
7228 if (!peer)
7229 return CMD_WARNING_CONFIG_FAILED;
7230
7231 ret = peer_timers_connect_unset(peer);
7232
7233 return bgp_vty_return(vty, ret);
7234 }
7235
7236 DEFUN (neighbor_timers_connect,
7237 neighbor_timers_connect_cmd,
7238 "neighbor <A.B.C.D|X:X::X:X|WORD> timers connect (1-65535)",
7239 NEIGHBOR_STR
7240 NEIGHBOR_ADDR_STR2
7241 "BGP per neighbor timers\n"
7242 "BGP connect timer\n"
7243 "Connect timer\n")
7244 {
7245 int idx_peer = 1;
7246 int idx_number = 4;
7247 return peer_timers_connect_set_vty(vty, argv[idx_peer]->arg,
7248 argv[idx_number]->arg);
7249 }
7250
7251 DEFUN (no_neighbor_timers_connect,
7252 no_neighbor_timers_connect_cmd,
7253 "no neighbor <A.B.C.D|X:X::X:X|WORD> timers connect [(1-65535)]",
7254 NO_STR
7255 NEIGHBOR_STR
7256 NEIGHBOR_ADDR_STR2
7257 "BGP per neighbor timers\n"
7258 "BGP connect timer\n"
7259 "Connect timer\n")
7260 {
7261 int idx_peer = 2;
7262 return peer_timers_connect_unset_vty(vty, argv[idx_peer]->arg);
7263 }
7264
7265 DEFPY (neighbor_timers_delayopen,
7266 neighbor_timers_delayopen_cmd,
7267 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor timers delayopen (1-240)$interval",
7268 NEIGHBOR_STR
7269 NEIGHBOR_ADDR_STR2
7270 "BGP per neighbor timers\n"
7271 "RFC 4271 DelayOpenTimer\n"
7272 "DelayOpenTime timer interval\n")
7273 {
7274 struct peer *peer;
7275
7276 peer = peer_and_group_lookup_vty(vty, neighbor);
7277 if (!peer)
7278 return CMD_WARNING_CONFIG_FAILED;
7279
7280 if (!interval) {
7281 if (peer_timers_delayopen_unset(peer))
7282 return CMD_WARNING_CONFIG_FAILED;
7283 } else {
7284 if (peer_timers_delayopen_set(peer, interval))
7285 return CMD_WARNING_CONFIG_FAILED;
7286 }
7287
7288 return CMD_SUCCESS;
7289 }
7290
7291 DEFPY (no_neighbor_timers_delayopen,
7292 no_neighbor_timers_delayopen_cmd,
7293 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor timers delayopen [(0-65535)]",
7294 NO_STR
7295 NEIGHBOR_STR
7296 NEIGHBOR_ADDR_STR2
7297 "BGP per neighbor timers\n"
7298 "RFC 4271 DelayOpenTimer\n"
7299 "DelayOpenTime timer interval\n")
7300 {
7301 struct peer *peer;
7302
7303 peer = peer_and_group_lookup_vty(vty, neighbor);
7304 if (!peer)
7305 return CMD_WARNING_CONFIG_FAILED;
7306
7307 if (peer_timers_delayopen_unset(peer))
7308 return CMD_WARNING_CONFIG_FAILED;
7309
7310 return CMD_SUCCESS;
7311 }
7312
7313 static int peer_advertise_interval_vty(struct vty *vty, const char *ip_str,
7314 const char *time_str, int set)
7315 {
7316 int ret;
7317 struct peer *peer;
7318 uint32_t routeadv = 0;
7319
7320 peer = peer_and_group_lookup_vty(vty, ip_str);
7321 if (!peer)
7322 return CMD_WARNING_CONFIG_FAILED;
7323
7324 if (time_str)
7325 routeadv = strtoul(time_str, NULL, 10);
7326
7327 if (set)
7328 ret = peer_advertise_interval_set(peer, routeadv);
7329 else
7330 ret = peer_advertise_interval_unset(peer);
7331
7332 return bgp_vty_return(vty, ret);
7333 }
7334
7335 DEFUN (neighbor_advertise_interval,
7336 neighbor_advertise_interval_cmd,
7337 "neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval (0-600)",
7338 NEIGHBOR_STR
7339 NEIGHBOR_ADDR_STR2
7340 "Minimum interval between sending BGP routing updates\n"
7341 "time in seconds\n")
7342 {
7343 int idx_peer = 1;
7344 int idx_number = 3;
7345 return peer_advertise_interval_vty(vty, argv[idx_peer]->arg,
7346 argv[idx_number]->arg, 1);
7347 }
7348
7349 DEFUN (no_neighbor_advertise_interval,
7350 no_neighbor_advertise_interval_cmd,
7351 "no neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval [(0-600)]",
7352 NO_STR
7353 NEIGHBOR_STR
7354 NEIGHBOR_ADDR_STR2
7355 "Minimum interval between sending BGP routing updates\n"
7356 "time in seconds\n")
7357 {
7358 int idx_peer = 2;
7359 return peer_advertise_interval_vty(vty, argv[idx_peer]->arg, NULL, 0);
7360 }
7361
7362
7363 /* Time to wait before processing route-map updates */
7364 DEFUN (bgp_set_route_map_delay_timer,
7365 bgp_set_route_map_delay_timer_cmd,
7366 "bgp route-map delay-timer (0-600)",
7367 SET_STR
7368 "BGP route-map delay timer\n"
7369 "Time in secs to wait before processing route-map changes\n"
7370 "0 disables the timer, no route updates happen when route-maps change\n")
7371 {
7372 int idx_number = 3;
7373 uint32_t rmap_delay_timer;
7374
7375 if (argv[idx_number]->arg) {
7376 rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
7377 bm->rmap_update_timer = rmap_delay_timer;
7378
7379 /* if the dynamic update handling is being disabled, and a timer
7380 * is
7381 * running, stop the timer and act as if the timer has already
7382 * fired.
7383 */
7384 if (!rmap_delay_timer && bm->t_rmap_update) {
7385 THREAD_OFF(bm->t_rmap_update);
7386 thread_execute(bm->master, bgp_route_map_update_timer,
7387 NULL, 0);
7388 }
7389 return CMD_SUCCESS;
7390 } else {
7391 vty_out(vty, "%% BGP invalid route-map delay-timer\n");
7392 return CMD_WARNING_CONFIG_FAILED;
7393 }
7394 }
7395
7396 DEFUN (no_bgp_set_route_map_delay_timer,
7397 no_bgp_set_route_map_delay_timer_cmd,
7398 "no bgp route-map delay-timer [(0-600)]",
7399 NO_STR
7400 BGP_STR
7401 "Default BGP route-map delay timer\n"
7402 "Reset to default time to wait for processing route-map changes\n"
7403 "0 disables the timer, no route updates happen when route-maps change\n")
7404 {
7405
7406 bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
7407
7408 return CMD_SUCCESS;
7409 }
7410
7411 /* neighbor interface */
7412 static int peer_interface_vty(struct vty *vty, const char *ip_str,
7413 const char *str)
7414 {
7415 struct peer *peer;
7416
7417 peer = peer_lookup_vty(vty, ip_str);
7418 if (!peer || peer->conf_if) {
7419 vty_out(vty, "%% BGP invalid peer %s\n", ip_str);
7420 return CMD_WARNING_CONFIG_FAILED;
7421 }
7422
7423 if (str)
7424 peer_interface_set(peer, str);
7425 else
7426 peer_interface_unset(peer);
7427
7428 return CMD_SUCCESS;
7429 }
7430
7431 DEFUN (neighbor_interface,
7432 neighbor_interface_cmd,
7433 "neighbor <A.B.C.D|X:X::X:X> interface WORD",
7434 NEIGHBOR_STR
7435 NEIGHBOR_ADDR_STR
7436 "Interface\n"
7437 "Interface name\n")
7438 {
7439 int idx_ip = 1;
7440 int idx_word = 3;
7441
7442 return peer_interface_vty(vty, argv[idx_ip]->arg, argv[idx_word]->arg);
7443 }
7444
7445 DEFUN (no_neighbor_interface,
7446 no_neighbor_interface_cmd,
7447 "no neighbor <A.B.C.D|X:X::X:X> interface WORD",
7448 NO_STR
7449 NEIGHBOR_STR
7450 NEIGHBOR_ADDR_STR
7451 "Interface\n"
7452 "Interface name\n")
7453 {
7454 int idx_peer = 2;
7455
7456 return peer_interface_vty(vty, argv[idx_peer]->arg, NULL);
7457 }
7458
7459 DEFUN (neighbor_distribute_list,
7460 neighbor_distribute_list_cmd,
7461 "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7462 NEIGHBOR_STR
7463 NEIGHBOR_ADDR_STR2
7464 "Filter updates to/from this neighbor\n"
7465 "IP Access-list name\n"
7466 "Filter incoming updates\n"
7467 "Filter outgoing updates\n")
7468 {
7469 int idx_peer = 1;
7470 int idx_acl = 3;
7471 int direct, ret;
7472 struct peer *peer;
7473
7474 const char *pstr = argv[idx_peer]->arg;
7475 const char *acl = argv[idx_acl]->arg;
7476 const char *inout = argv[argc - 1]->text;
7477
7478 peer = peer_and_group_lookup_vty(vty, pstr);
7479 if (!peer)
7480 return CMD_WARNING_CONFIG_FAILED;
7481
7482 /* Check filter direction. */
7483 direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
7484 ret = peer_distribute_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
7485 direct, acl);
7486
7487 return bgp_vty_return(vty, ret);
7488 }
7489
7490 ALIAS_HIDDEN(
7491 neighbor_distribute_list, neighbor_distribute_list_hidden_cmd,
7492 "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7493 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7494 "Filter updates to/from this neighbor\n"
7495 "IP Access-list name\n"
7496 "Filter incoming updates\n"
7497 "Filter outgoing updates\n")
7498
7499 DEFUN (no_neighbor_distribute_list,
7500 no_neighbor_distribute_list_cmd,
7501 "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7502 NO_STR
7503 NEIGHBOR_STR
7504 NEIGHBOR_ADDR_STR2
7505 "Filter updates to/from this neighbor\n"
7506 "IP Access-list name\n"
7507 "Filter incoming updates\n"
7508 "Filter outgoing updates\n")
7509 {
7510 int idx_peer = 2;
7511 int direct, ret;
7512 struct peer *peer;
7513
7514 const char *pstr = argv[idx_peer]->arg;
7515 const char *inout = argv[argc - 1]->text;
7516
7517 peer = peer_and_group_lookup_vty(vty, pstr);
7518 if (!peer)
7519 return CMD_WARNING_CONFIG_FAILED;
7520
7521 /* Check filter direction. */
7522 direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
7523 ret = peer_distribute_unset(peer, bgp_node_afi(vty), bgp_node_safi(vty),
7524 direct);
7525
7526 return bgp_vty_return(vty, ret);
7527 }
7528
7529 ALIAS_HIDDEN(
7530 no_neighbor_distribute_list, no_neighbor_distribute_list_hidden_cmd,
7531 "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7532 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7533 "Filter updates to/from this neighbor\n"
7534 "IP Access-list name\n"
7535 "Filter incoming updates\n"
7536 "Filter outgoing updates\n")
7537
7538 /* Set prefix list to the peer. */
7539 static int peer_prefix_list_set_vty(struct vty *vty, const char *ip_str,
7540 afi_t afi, safi_t safi,
7541 const char *name_str,
7542 const char *direct_str)
7543 {
7544 int ret;
7545 int direct = FILTER_IN;
7546 struct peer *peer;
7547
7548 peer = peer_and_group_lookup_vty(vty, ip_str);
7549 if (!peer)
7550 return CMD_WARNING_CONFIG_FAILED;
7551
7552 /* Check filter direction. */
7553 if (strncmp(direct_str, "i", 1) == 0)
7554 direct = FILTER_IN;
7555 else if (strncmp(direct_str, "o", 1) == 0)
7556 direct = FILTER_OUT;
7557
7558 ret = peer_prefix_list_set(peer, afi, safi, direct, name_str);
7559
7560 return bgp_vty_return(vty, ret);
7561 }
7562
7563 static int peer_prefix_list_unset_vty(struct vty *vty, const char *ip_str,
7564 afi_t afi, safi_t safi,
7565 const char *direct_str)
7566 {
7567 int ret;
7568 struct peer *peer;
7569 int direct = FILTER_IN;
7570
7571 peer = peer_and_group_lookup_vty(vty, ip_str);
7572 if (!peer)
7573 return CMD_WARNING_CONFIG_FAILED;
7574
7575 /* Check filter direction. */
7576 if (strncmp(direct_str, "i", 1) == 0)
7577 direct = FILTER_IN;
7578 else if (strncmp(direct_str, "o", 1) == 0)
7579 direct = FILTER_OUT;
7580
7581 ret = peer_prefix_list_unset(peer, afi, safi, direct);
7582
7583 return bgp_vty_return(vty, ret);
7584 }
7585
7586 DEFUN (neighbor_prefix_list,
7587 neighbor_prefix_list_cmd,
7588 "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7589 NEIGHBOR_STR
7590 NEIGHBOR_ADDR_STR2
7591 "Filter updates to/from this neighbor\n"
7592 "Name of a prefix list\n"
7593 "Filter incoming updates\n"
7594 "Filter outgoing updates\n")
7595 {
7596 int idx_peer = 1;
7597 int idx_word = 3;
7598 int idx_in_out = 4;
7599 return peer_prefix_list_set_vty(
7600 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
7601 argv[idx_word]->arg, argv[idx_in_out]->arg);
7602 }
7603
7604 ALIAS_HIDDEN(neighbor_prefix_list, neighbor_prefix_list_hidden_cmd,
7605 "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7606 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7607 "Filter updates to/from this neighbor\n"
7608 "Name of a prefix list\n"
7609 "Filter incoming updates\n"
7610 "Filter outgoing updates\n")
7611
7612 DEFUN (no_neighbor_prefix_list,
7613 no_neighbor_prefix_list_cmd,
7614 "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7615 NO_STR
7616 NEIGHBOR_STR
7617 NEIGHBOR_ADDR_STR2
7618 "Filter updates to/from this neighbor\n"
7619 "Name of a prefix list\n"
7620 "Filter incoming updates\n"
7621 "Filter outgoing updates\n")
7622 {
7623 int idx_peer = 2;
7624 int idx_in_out = 5;
7625 return peer_prefix_list_unset_vty(vty, argv[idx_peer]->arg,
7626 bgp_node_afi(vty), bgp_node_safi(vty),
7627 argv[idx_in_out]->arg);
7628 }
7629
7630 ALIAS_HIDDEN(no_neighbor_prefix_list, no_neighbor_prefix_list_hidden_cmd,
7631 "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7632 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7633 "Filter updates to/from this neighbor\n"
7634 "Name of a prefix list\n"
7635 "Filter incoming updates\n"
7636 "Filter outgoing updates\n")
7637
7638 static int peer_aslist_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
7639 safi_t safi, const char *name_str,
7640 const char *direct_str)
7641 {
7642 int ret;
7643 struct peer *peer;
7644 int direct = FILTER_IN;
7645
7646 peer = peer_and_group_lookup_vty(vty, ip_str);
7647 if (!peer)
7648 return CMD_WARNING_CONFIG_FAILED;
7649
7650 /* Check filter direction. */
7651 if (strncmp(direct_str, "i", 1) == 0)
7652 direct = FILTER_IN;
7653 else if (strncmp(direct_str, "o", 1) == 0)
7654 direct = FILTER_OUT;
7655
7656 ret = peer_aslist_set(peer, afi, safi, direct, name_str);
7657
7658 return bgp_vty_return(vty, ret);
7659 }
7660
7661 static int peer_aslist_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
7662 safi_t safi, const char *direct_str)
7663 {
7664 int ret;
7665 struct peer *peer;
7666 int direct = FILTER_IN;
7667
7668 peer = peer_and_group_lookup_vty(vty, ip_str);
7669 if (!peer)
7670 return CMD_WARNING_CONFIG_FAILED;
7671
7672 /* Check filter direction. */
7673 if (strncmp(direct_str, "i", 1) == 0)
7674 direct = FILTER_IN;
7675 else if (strncmp(direct_str, "o", 1) == 0)
7676 direct = FILTER_OUT;
7677
7678 ret = peer_aslist_unset(peer, afi, safi, direct);
7679
7680 return bgp_vty_return(vty, ret);
7681 }
7682
7683 DEFUN (neighbor_filter_list,
7684 neighbor_filter_list_cmd,
7685 "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7686 NEIGHBOR_STR
7687 NEIGHBOR_ADDR_STR2
7688 "Establish BGP filters\n"
7689 "AS path access-list name\n"
7690 "Filter incoming routes\n"
7691 "Filter outgoing routes\n")
7692 {
7693 int idx_peer = 1;
7694 int idx_word = 3;
7695 int idx_in_out = 4;
7696 return peer_aslist_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
7697 bgp_node_safi(vty), argv[idx_word]->arg,
7698 argv[idx_in_out]->arg);
7699 }
7700
7701 ALIAS_HIDDEN(neighbor_filter_list, neighbor_filter_list_hidden_cmd,
7702 "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7703 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7704 "Establish BGP filters\n"
7705 "AS path access-list name\n"
7706 "Filter incoming routes\n"
7707 "Filter outgoing routes\n")
7708
7709 DEFUN (no_neighbor_filter_list,
7710 no_neighbor_filter_list_cmd,
7711 "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7712 NO_STR
7713 NEIGHBOR_STR
7714 NEIGHBOR_ADDR_STR2
7715 "Establish BGP filters\n"
7716 "AS path access-list name\n"
7717 "Filter incoming routes\n"
7718 "Filter outgoing routes\n")
7719 {
7720 int idx_peer = 2;
7721 int idx_in_out = 5;
7722 return peer_aslist_unset_vty(vty, argv[idx_peer]->arg,
7723 bgp_node_afi(vty), bgp_node_safi(vty),
7724 argv[idx_in_out]->arg);
7725 }
7726
7727 ALIAS_HIDDEN(no_neighbor_filter_list, no_neighbor_filter_list_hidden_cmd,
7728 "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7729 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7730 "Establish BGP filters\n"
7731 "AS path access-list name\n"
7732 "Filter incoming routes\n"
7733 "Filter outgoing routes\n")
7734
7735 /* Set advertise-map to the peer. */
7736 static int peer_advertise_map_set_vty(struct vty *vty, const char *ip_str,
7737 afi_t afi, safi_t safi,
7738 const char *advertise_str,
7739 const char *condition_str, bool condition,
7740 bool set)
7741 {
7742 int ret = CMD_WARNING_CONFIG_FAILED;
7743 struct peer *peer;
7744 struct route_map *advertise_map;
7745 struct route_map *condition_map;
7746
7747 peer = peer_and_group_lookup_vty(vty, ip_str);
7748 if (!peer)
7749 return ret;
7750
7751 condition_map = route_map_lookup_warn_noexist(vty, condition_str);
7752 advertise_map = route_map_lookup_warn_noexist(vty, advertise_str);
7753
7754 if (set)
7755 ret = peer_advertise_map_set(peer, afi, safi, advertise_str,
7756 advertise_map, condition_str,
7757 condition_map, condition);
7758 else
7759 ret = peer_advertise_map_unset(peer, afi, safi, advertise_str,
7760 advertise_map, condition_str,
7761 condition_map, condition);
7762
7763 return bgp_vty_return(vty, ret);
7764 }
7765
7766 DEFPY (bgp_condadv_period,
7767 bgp_condadv_period_cmd,
7768 "[no$no] bgp conditional-advertisement timer (5-240)$period",
7769 NO_STR
7770 BGP_STR
7771 "Conditional advertisement settings\n"
7772 "Set period to rescan BGP table to check if condition is met\n"
7773 "Period between BGP table scans, in seconds; default 60\n")
7774 {
7775 VTY_DECLVAR_CONTEXT(bgp, bgp);
7776
7777 bgp->condition_check_period =
7778 no ? DEFAULT_CONDITIONAL_ROUTES_POLL_TIME : period;
7779
7780 return CMD_SUCCESS;
7781 }
7782
7783 DEFPY (neighbor_advertise_map,
7784 neighbor_advertise_map_cmd,
7785 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor advertise-map RMAP_NAME$advertise_str <exist-map|non-exist-map>$exist RMAP_NAME$condition_str",
7786 NO_STR
7787 NEIGHBOR_STR
7788 NEIGHBOR_ADDR_STR2
7789 "Route-map to conditionally advertise routes\n"
7790 "Name of advertise map\n"
7791 "Advertise routes only if prefixes in exist-map are installed in BGP table\n"
7792 "Advertise routes only if prefixes in non-exist-map are not installed in BGP table\n"
7793 "Name of the exist or non exist map\n")
7794 {
7795 bool condition = CONDITION_EXIST;
7796
7797 if (!strcmp(exist, "non-exist-map"))
7798 condition = CONDITION_NON_EXIST;
7799
7800 return peer_advertise_map_set_vty(vty, neighbor, bgp_node_afi(vty),
7801 bgp_node_safi(vty), advertise_str,
7802 condition_str, condition, !no);
7803 }
7804
7805 ALIAS_HIDDEN(neighbor_advertise_map, neighbor_advertise_map_hidden_cmd,
7806 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor advertise-map RMAP_NAME$advertise_str <exist-map|non-exist-map>$exist RMAP_NAME$condition_str",
7807 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7808 "Route-map to conditionally advertise routes\n"
7809 "Name of advertise map\n"
7810 "Advertise routes only if prefixes in exist-map are installed in BGP table\n"
7811 "Advertise routes only if prefixes in non-exist-map are not installed in BGP table\n"
7812 "Name of the exist or non exist map\n")
7813
7814 /* Set route-map to the peer. */
7815 static int peer_route_map_set_vty(struct vty *vty, const char *ip_str,
7816 afi_t afi, safi_t safi, const char *name_str,
7817 const char *direct_str)
7818 {
7819 int ret;
7820 struct peer *peer;
7821 int direct = RMAP_IN;
7822 struct route_map *route_map;
7823
7824 peer = peer_and_group_lookup_vty(vty, ip_str);
7825 if (!peer)
7826 return CMD_WARNING_CONFIG_FAILED;
7827
7828 /* Check filter direction. */
7829 if (strncmp(direct_str, "in", 2) == 0)
7830 direct = RMAP_IN;
7831 else if (strncmp(direct_str, "o", 1) == 0)
7832 direct = RMAP_OUT;
7833
7834 route_map = route_map_lookup_warn_noexist(vty, name_str);
7835 ret = peer_route_map_set(peer, afi, safi, direct, name_str, route_map);
7836
7837 return bgp_vty_return(vty, ret);
7838 }
7839
7840 static int peer_route_map_unset_vty(struct vty *vty, const char *ip_str,
7841 afi_t afi, safi_t safi,
7842 const char *direct_str)
7843 {
7844 int ret;
7845 struct peer *peer;
7846 int direct = RMAP_IN;
7847
7848 peer = peer_and_group_lookup_vty(vty, ip_str);
7849 if (!peer)
7850 return CMD_WARNING_CONFIG_FAILED;
7851
7852 /* Check filter direction. */
7853 if (strncmp(direct_str, "in", 2) == 0)
7854 direct = RMAP_IN;
7855 else if (strncmp(direct_str, "o", 1) == 0)
7856 direct = RMAP_OUT;
7857
7858 ret = peer_route_map_unset(peer, afi, safi, direct);
7859
7860 return bgp_vty_return(vty, ret);
7861 }
7862
7863 DEFUN (neighbor_route_map,
7864 neighbor_route_map_cmd,
7865 "neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
7866 NEIGHBOR_STR
7867 NEIGHBOR_ADDR_STR2
7868 "Apply route map to neighbor\n"
7869 "Name of route map\n"
7870 "Apply map to incoming routes\n"
7871 "Apply map to outbound routes\n")
7872 {
7873 int idx_peer = 1;
7874 int idx_word = 3;
7875 int idx_in_out = 4;
7876 return peer_route_map_set_vty(
7877 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
7878 argv[idx_word]->arg, argv[idx_in_out]->arg);
7879 }
7880
7881 ALIAS_HIDDEN(neighbor_route_map, neighbor_route_map_hidden_cmd,
7882 "neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
7883 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7884 "Apply route map to neighbor\n"
7885 "Name of route map\n"
7886 "Apply map to incoming routes\n"
7887 "Apply map to outbound routes\n")
7888
7889 DEFUN (no_neighbor_route_map,
7890 no_neighbor_route_map_cmd,
7891 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
7892 NO_STR
7893 NEIGHBOR_STR
7894 NEIGHBOR_ADDR_STR2
7895 "Apply route map to neighbor\n"
7896 "Name of route map\n"
7897 "Apply map to incoming routes\n"
7898 "Apply map to outbound routes\n")
7899 {
7900 int idx_peer = 2;
7901 int idx_in_out = 5;
7902 return peer_route_map_unset_vty(vty, argv[idx_peer]->arg,
7903 bgp_node_afi(vty), bgp_node_safi(vty),
7904 argv[idx_in_out]->arg);
7905 }
7906
7907 ALIAS_HIDDEN(no_neighbor_route_map, no_neighbor_route_map_hidden_cmd,
7908 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
7909 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7910 "Apply route map to neighbor\n"
7911 "Name of route map\n"
7912 "Apply map to incoming routes\n"
7913 "Apply map to outbound routes\n")
7914
7915 /* Set unsuppress-map to the peer. */
7916 static int peer_unsuppress_map_set_vty(struct vty *vty, const char *ip_str,
7917 afi_t afi, safi_t safi,
7918 const char *name_str)
7919 {
7920 int ret;
7921 struct peer *peer;
7922 struct route_map *route_map;
7923
7924 peer = peer_and_group_lookup_vty(vty, ip_str);
7925 if (!peer)
7926 return CMD_WARNING_CONFIG_FAILED;
7927
7928 route_map = route_map_lookup_warn_noexist(vty, name_str);
7929 ret = peer_unsuppress_map_set(peer, afi, safi, name_str, route_map);
7930
7931 return bgp_vty_return(vty, ret);
7932 }
7933
7934 /* Unset route-map from the peer. */
7935 static int peer_unsuppress_map_unset_vty(struct vty *vty, const char *ip_str,
7936 afi_t afi, safi_t safi)
7937 {
7938 int ret;
7939 struct peer *peer;
7940
7941 peer = peer_and_group_lookup_vty(vty, ip_str);
7942 if (!peer)
7943 return CMD_WARNING_CONFIG_FAILED;
7944
7945 ret = peer_unsuppress_map_unset(peer, afi, safi);
7946
7947 return bgp_vty_return(vty, ret);
7948 }
7949
7950 DEFUN (neighbor_unsuppress_map,
7951 neighbor_unsuppress_map_cmd,
7952 "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
7953 NEIGHBOR_STR
7954 NEIGHBOR_ADDR_STR2
7955 "Route-map to selectively unsuppress suppressed routes\n"
7956 "Name of route map\n")
7957 {
7958 int idx_peer = 1;
7959 int idx_word = 3;
7960 return peer_unsuppress_map_set_vty(
7961 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
7962 argv[idx_word]->arg);
7963 }
7964
7965 ALIAS_HIDDEN(neighbor_unsuppress_map, neighbor_unsuppress_map_hidden_cmd,
7966 "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
7967 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7968 "Route-map to selectively unsuppress suppressed routes\n"
7969 "Name of route map\n")
7970
7971 DEFUN (no_neighbor_unsuppress_map,
7972 no_neighbor_unsuppress_map_cmd,
7973 "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
7974 NO_STR
7975 NEIGHBOR_STR
7976 NEIGHBOR_ADDR_STR2
7977 "Route-map to selectively unsuppress suppressed routes\n"
7978 "Name of route map\n")
7979 {
7980 int idx_peer = 2;
7981 return peer_unsuppress_map_unset_vty(vty, argv[idx_peer]->arg,
7982 bgp_node_afi(vty),
7983 bgp_node_safi(vty));
7984 }
7985
7986 ALIAS_HIDDEN(no_neighbor_unsuppress_map, no_neighbor_unsuppress_map_hidden_cmd,
7987 "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
7988 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7989 "Route-map to selectively unsuppress suppressed routes\n"
7990 "Name of route map\n")
7991
7992 static int peer_maximum_prefix_set_vty(struct vty *vty, const char *ip_str,
7993 afi_t afi, safi_t safi,
7994 const char *num_str,
7995 const char *threshold_str, int warning,
7996 const char *restart_str,
7997 const char *force_str)
7998 {
7999 int ret;
8000 struct peer *peer;
8001 uint32_t max;
8002 uint8_t threshold;
8003 uint16_t restart;
8004
8005 peer = peer_and_group_lookup_vty(vty, ip_str);
8006 if (!peer)
8007 return CMD_WARNING_CONFIG_FAILED;
8008
8009 max = strtoul(num_str, NULL, 10);
8010 if (threshold_str)
8011 threshold = atoi(threshold_str);
8012 else
8013 threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
8014
8015 if (restart_str)
8016 restart = atoi(restart_str);
8017 else
8018 restart = 0;
8019
8020 ret = peer_maximum_prefix_set(peer, afi, safi, max, threshold, warning,
8021 restart, force_str ? true : false);
8022
8023 return bgp_vty_return(vty, ret);
8024 }
8025
8026 static int peer_maximum_prefix_unset_vty(struct vty *vty, const char *ip_str,
8027 afi_t afi, safi_t safi)
8028 {
8029 int ret;
8030 struct peer *peer;
8031
8032 peer = peer_and_group_lookup_vty(vty, ip_str);
8033 if (!peer)
8034 return CMD_WARNING_CONFIG_FAILED;
8035
8036 ret = peer_maximum_prefix_unset(peer, afi, safi);
8037
8038 return bgp_vty_return(vty, ret);
8039 }
8040
8041 /* Maximum number of prefix to be sent to the neighbor. */
8042 DEFUN(neighbor_maximum_prefix_out,
8043 neighbor_maximum_prefix_out_cmd,
8044 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix-out (1-4294967295)",
8045 NEIGHBOR_STR
8046 NEIGHBOR_ADDR_STR2
8047 "Maximum number of prefixes to be sent to this peer\n"
8048 "Maximum no. of prefix limit\n")
8049 {
8050 int ret;
8051 int idx_peer = 1;
8052 int idx_number = 3;
8053 struct peer *peer;
8054 uint32_t max;
8055 afi_t afi = bgp_node_afi(vty);
8056 safi_t safi = bgp_node_safi(vty);
8057
8058 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8059 if (!peer)
8060 return CMD_WARNING_CONFIG_FAILED;
8061
8062 max = strtoul(argv[idx_number]->arg, NULL, 10);
8063
8064 ret = peer_maximum_prefix_out_set(peer, afi, safi, max);
8065
8066 return bgp_vty_return(vty, ret);
8067 }
8068
8069 DEFUN(no_neighbor_maximum_prefix_out,
8070 no_neighbor_maximum_prefix_out_cmd,
8071 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix-out [(1-4294967295)]",
8072 NO_STR
8073 NEIGHBOR_STR
8074 NEIGHBOR_ADDR_STR2
8075 "Maximum number of prefixes to be sent to this peer\n"
8076 "Maximum no. of prefix limit\n")
8077 {
8078 int ret;
8079 int idx_peer = 2;
8080 struct peer *peer;
8081 afi_t afi = bgp_node_afi(vty);
8082 safi_t safi = bgp_node_safi(vty);
8083
8084 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8085 if (!peer)
8086 return CMD_WARNING_CONFIG_FAILED;
8087
8088 ret = peer_maximum_prefix_out_unset(peer, afi, safi);
8089
8090 return bgp_vty_return(vty, ret);
8091 }
8092
8093 /* Maximum number of prefix configuration. Prefix count is different
8094 for each peer configuration. So this configuration can be set for
8095 each peer configuration. */
8096 DEFUN (neighbor_maximum_prefix,
8097 neighbor_maximum_prefix_cmd,
8098 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) [force]",
8099 NEIGHBOR_STR
8100 NEIGHBOR_ADDR_STR2
8101 "Maximum number of prefix accept from this peer\n"
8102 "maximum no. of prefix limit\n"
8103 "Force checking all received routes not only accepted\n")
8104 {
8105 int idx_peer = 1;
8106 int idx_number = 3;
8107 int idx_force = 0;
8108 char *force = NULL;
8109
8110 if (argv_find(argv, argc, "force", &idx_force))
8111 force = argv[idx_force]->arg;
8112
8113 return peer_maximum_prefix_set_vty(
8114 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8115 argv[idx_number]->arg, NULL, 0, NULL, force);
8116 }
8117
8118 ALIAS_HIDDEN(neighbor_maximum_prefix, neighbor_maximum_prefix_hidden_cmd,
8119 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) [force]",
8120 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8121 "Maximum number of prefix accept from this peer\n"
8122 "maximum no. of prefix limit\n"
8123 "Force checking all received routes not only accepted\n")
8124
8125 DEFUN (neighbor_maximum_prefix_threshold,
8126 neighbor_maximum_prefix_threshold_cmd,
8127 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) [force]",
8128 NEIGHBOR_STR
8129 NEIGHBOR_ADDR_STR2
8130 "Maximum number of prefix accept from this peer\n"
8131 "maximum no. of prefix limit\n"
8132 "Threshold value (%) at which to generate a warning msg\n"
8133 "Force checking all received routes not only accepted\n")
8134 {
8135 int idx_peer = 1;
8136 int idx_number = 3;
8137 int idx_number_2 = 4;
8138 int idx_force = 0;
8139 char *force = NULL;
8140
8141 if (argv_find(argv, argc, "force", &idx_force))
8142 force = argv[idx_force]->arg;
8143
8144 return peer_maximum_prefix_set_vty(
8145 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8146 argv[idx_number]->arg, argv[idx_number_2]->arg, 0, NULL, force);
8147 }
8148
8149 ALIAS_HIDDEN(
8150 neighbor_maximum_prefix_threshold,
8151 neighbor_maximum_prefix_threshold_hidden_cmd,
8152 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) [force]",
8153 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8154 "Maximum number of prefix accept from this peer\n"
8155 "maximum no. of prefix limit\n"
8156 "Threshold value (%) at which to generate a warning msg\n"
8157 "Force checking all received routes not only accepted\n")
8158
8159 DEFUN (neighbor_maximum_prefix_warning,
8160 neighbor_maximum_prefix_warning_cmd,
8161 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only [force]",
8162 NEIGHBOR_STR
8163 NEIGHBOR_ADDR_STR2
8164 "Maximum number of prefix accept from this peer\n"
8165 "maximum no. of prefix limit\n"
8166 "Only give warning message when limit is exceeded\n"
8167 "Force checking all received routes not only accepted\n")
8168 {
8169 int idx_peer = 1;
8170 int idx_number = 3;
8171 int idx_force = 0;
8172 char *force = NULL;
8173
8174 if (argv_find(argv, argc, "force", &idx_force))
8175 force = argv[idx_force]->arg;
8176
8177 return peer_maximum_prefix_set_vty(
8178 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8179 argv[idx_number]->arg, NULL, 1, NULL, force);
8180 }
8181
8182 ALIAS_HIDDEN(
8183 neighbor_maximum_prefix_warning,
8184 neighbor_maximum_prefix_warning_hidden_cmd,
8185 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only [force]",
8186 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8187 "Maximum number of prefix accept from this peer\n"
8188 "maximum no. of prefix limit\n"
8189 "Only give warning message when limit is exceeded\n"
8190 "Force checking all received routes not only accepted\n")
8191
8192 DEFUN (neighbor_maximum_prefix_threshold_warning,
8193 neighbor_maximum_prefix_threshold_warning_cmd,
8194 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only [force]",
8195 NEIGHBOR_STR
8196 NEIGHBOR_ADDR_STR2
8197 "Maximum number of prefix accept from this peer\n"
8198 "maximum no. of prefix limit\n"
8199 "Threshold value (%) at which to generate a warning msg\n"
8200 "Only give warning message when limit is exceeded\n"
8201 "Force checking all received routes not only accepted\n")
8202 {
8203 int idx_peer = 1;
8204 int idx_number = 3;
8205 int idx_number_2 = 4;
8206 int idx_force = 0;
8207 char *force = NULL;
8208
8209 if (argv_find(argv, argc, "force", &idx_force))
8210 force = argv[idx_force]->arg;
8211
8212 return peer_maximum_prefix_set_vty(
8213 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8214 argv[idx_number]->arg, argv[idx_number_2]->arg, 1, NULL, force);
8215 }
8216
8217 ALIAS_HIDDEN(
8218 neighbor_maximum_prefix_threshold_warning,
8219 neighbor_maximum_prefix_threshold_warning_hidden_cmd,
8220 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only [force]",
8221 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8222 "Maximum number of prefix accept from this peer\n"
8223 "maximum no. of prefix limit\n"
8224 "Threshold value (%) at which to generate a warning msg\n"
8225 "Only give warning message when limit is exceeded\n"
8226 "Force checking all received routes not only accepted\n")
8227
8228 DEFUN (neighbor_maximum_prefix_restart,
8229 neighbor_maximum_prefix_restart_cmd,
8230 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535) [force]",
8231 NEIGHBOR_STR
8232 NEIGHBOR_ADDR_STR2
8233 "Maximum number of prefix accept from this peer\n"
8234 "maximum no. of prefix limit\n"
8235 "Restart bgp connection after limit is exceeded\n"
8236 "Restart interval in minutes\n"
8237 "Force checking all received routes not only accepted\n")
8238 {
8239 int idx_peer = 1;
8240 int idx_number = 3;
8241 int idx_number_2 = 5;
8242 int idx_force = 0;
8243 char *force = NULL;
8244
8245 if (argv_find(argv, argc, "force", &idx_force))
8246 force = argv[idx_force]->arg;
8247
8248 return peer_maximum_prefix_set_vty(
8249 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8250 argv[idx_number]->arg, NULL, 0, argv[idx_number_2]->arg, force);
8251 }
8252
8253 ALIAS_HIDDEN(
8254 neighbor_maximum_prefix_restart,
8255 neighbor_maximum_prefix_restart_hidden_cmd,
8256 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535) [force]",
8257 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8258 "Maximum number of prefix accept from this peer\n"
8259 "maximum no. of prefix limit\n"
8260 "Restart bgp connection after limit is exceeded\n"
8261 "Restart interval in minutes\n"
8262 "Force checking all received routes not only accepted\n")
8263
8264 DEFUN (neighbor_maximum_prefix_threshold_restart,
8265 neighbor_maximum_prefix_threshold_restart_cmd,
8266 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535) [force]",
8267 NEIGHBOR_STR
8268 NEIGHBOR_ADDR_STR2
8269 "Maximum number of prefixes to accept from this peer\n"
8270 "maximum no. of prefix limit\n"
8271 "Threshold value (%) at which to generate a warning msg\n"
8272 "Restart bgp connection after limit is exceeded\n"
8273 "Restart interval in minutes\n"
8274 "Force checking all received routes not only accepted\n")
8275 {
8276 int idx_peer = 1;
8277 int idx_number = 3;
8278 int idx_number_2 = 4;
8279 int idx_number_3 = 6;
8280 int idx_force = 0;
8281 char *force = NULL;
8282
8283 if (argv_find(argv, argc, "force", &idx_force))
8284 force = argv[idx_force]->arg;
8285
8286 return peer_maximum_prefix_set_vty(
8287 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8288 argv[idx_number]->arg, argv[idx_number_2]->arg, 0,
8289 argv[idx_number_3]->arg, force);
8290 }
8291
8292 ALIAS_HIDDEN(
8293 neighbor_maximum_prefix_threshold_restart,
8294 neighbor_maximum_prefix_threshold_restart_hidden_cmd,
8295 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535) [force]",
8296 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8297 "Maximum number of prefixes to accept from this peer\n"
8298 "maximum no. of prefix limit\n"
8299 "Threshold value (%) at which to generate a warning msg\n"
8300 "Restart bgp connection after limit is exceeded\n"
8301 "Restart interval in minutes\n"
8302 "Force checking all received routes not only accepted\n")
8303
8304 DEFUN (no_neighbor_maximum_prefix,
8305 no_neighbor_maximum_prefix_cmd,
8306 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only] [force]]",
8307 NO_STR
8308 NEIGHBOR_STR
8309 NEIGHBOR_ADDR_STR2
8310 "Maximum number of prefixes to accept from this peer\n"
8311 "maximum no. of prefix limit\n"
8312 "Threshold value (%) at which to generate a warning msg\n"
8313 "Restart bgp connection after limit is exceeded\n"
8314 "Restart interval in minutes\n"
8315 "Only give warning message when limit is exceeded\n"
8316 "Force checking all received routes not only accepted\n")
8317 {
8318 int idx_peer = 2;
8319 return peer_maximum_prefix_unset_vty(vty, argv[idx_peer]->arg,
8320 bgp_node_afi(vty),
8321 bgp_node_safi(vty));
8322 }
8323
8324 ALIAS_HIDDEN(
8325 no_neighbor_maximum_prefix, no_neighbor_maximum_prefix_hidden_cmd,
8326 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only] [force]]",
8327 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8328 "Maximum number of prefixes to accept from this peer\n"
8329 "maximum no. of prefix limit\n"
8330 "Threshold value (%) at which to generate a warning msg\n"
8331 "Restart bgp connection after limit is exceeded\n"
8332 "Restart interval in minutes\n"
8333 "Only give warning message when limit is exceeded\n"
8334 "Force checking all received routes not only accepted\n")
8335
8336 /* "neighbor accept-own" */
8337 DEFPY (neighbor_accept_own,
8338 neighbor_accept_own_cmd,
8339 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor accept-own",
8340 NO_STR
8341 NEIGHBOR_STR
8342 NEIGHBOR_ADDR_STR2
8343 "Enable handling of self-originated VPN routes containing ACCEPT_OWN community\n")
8344 {
8345 struct peer *peer;
8346 afi_t afi = bgp_node_afi(vty);
8347 safi_t safi = bgp_node_safi(vty);
8348 int ret;
8349
8350 peer = peer_and_group_lookup_vty(vty, neighbor);
8351 if (!peer)
8352 return CMD_WARNING_CONFIG_FAILED;
8353
8354 if (no)
8355 ret = peer_af_flag_unset(peer, afi, safi, PEER_FLAG_ACCEPT_OWN);
8356 else
8357 ret = peer_af_flag_set(peer, afi, safi, PEER_FLAG_ACCEPT_OWN);
8358
8359 return bgp_vty_return(vty, ret);
8360 }
8361
8362 /* "neighbor soo" */
8363 DEFPY (neighbor_soo,
8364 neighbor_soo_cmd,
8365 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor soo ASN:NN_OR_IP-ADDRESS:NN$soo",
8366 NEIGHBOR_STR
8367 NEIGHBOR_ADDR_STR2
8368 "Set the Site-of-Origin (SoO) extended community\n"
8369 "VPN extended community\n")
8370 {
8371 struct peer *peer;
8372 afi_t afi = bgp_node_afi(vty);
8373 safi_t safi = bgp_node_safi(vty);
8374 struct ecommunity *ecomm_soo;
8375
8376 peer = peer_and_group_lookup_vty(vty, neighbor);
8377 if (!peer)
8378 return CMD_WARNING_CONFIG_FAILED;
8379
8380 ecomm_soo = ecommunity_str2com(soo, ECOMMUNITY_SITE_ORIGIN, 0);
8381 if (!ecomm_soo) {
8382 vty_out(vty, "%% Malformed SoO extended community\n");
8383 return CMD_WARNING;
8384 }
8385 ecommunity_str(ecomm_soo);
8386
8387 if (!ecommunity_match(peer->soo[afi][safi], ecomm_soo)) {
8388 ecommunity_free(&peer->soo[afi][safi]);
8389 peer->soo[afi][safi] = ecomm_soo;
8390 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_SOO);
8391 }
8392
8393 return bgp_vty_return(vty,
8394 peer_af_flag_set(peer, afi, safi, PEER_FLAG_SOO));
8395 }
8396
8397 DEFPY (no_neighbor_soo,
8398 no_neighbor_soo_cmd,
8399 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor soo [ASN:NN_OR_IP-ADDRESS:NN$soo]",
8400 NO_STR
8401 NEIGHBOR_STR
8402 NEIGHBOR_ADDR_STR2
8403 "Set the Site-of-Origin (SoO) extended community\n"
8404 "VPN extended community\n")
8405 {
8406 struct peer *peer;
8407 afi_t afi = bgp_node_afi(vty);
8408 safi_t safi = bgp_node_safi(vty);
8409
8410 peer = peer_and_group_lookup_vty(vty, neighbor);
8411 if (!peer)
8412 return CMD_WARNING_CONFIG_FAILED;
8413
8414 ecommunity_free(&peer->soo[afi][safi]);
8415
8416 return bgp_vty_return(
8417 vty, peer_af_flag_unset(peer, afi, safi, PEER_FLAG_SOO));
8418 }
8419
8420 /* "neighbor allowas-in" */
8421 DEFUN (neighbor_allowas_in,
8422 neighbor_allowas_in_cmd,
8423 "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8424 NEIGHBOR_STR
8425 NEIGHBOR_ADDR_STR2
8426 "Accept as-path with my AS present in it\n"
8427 "Number of occurrences of AS number\n"
8428 "Only accept my AS in the as-path if the route was originated in my AS\n")
8429 {
8430 int idx_peer = 1;
8431 int idx_number_origin = 3;
8432 int ret;
8433 int origin = 0;
8434 struct peer *peer;
8435 int allow_num = 0;
8436
8437 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8438 if (!peer)
8439 return CMD_WARNING_CONFIG_FAILED;
8440
8441 if (argc <= idx_number_origin)
8442 allow_num = 3;
8443 else {
8444 if (argv[idx_number_origin]->type == WORD_TKN)
8445 origin = 1;
8446 else
8447 allow_num = atoi(argv[idx_number_origin]->arg);
8448 }
8449
8450 ret = peer_allowas_in_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8451 allow_num, origin);
8452
8453 return bgp_vty_return(vty, ret);
8454 }
8455
8456 ALIAS_HIDDEN(
8457 neighbor_allowas_in, neighbor_allowas_in_hidden_cmd,
8458 "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8459 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8460 "Accept as-path with my AS present in it\n"
8461 "Number of occurrences of AS number\n"
8462 "Only accept my AS in the as-path if the route was originated in my AS\n")
8463
8464 DEFUN (no_neighbor_allowas_in,
8465 no_neighbor_allowas_in_cmd,
8466 "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8467 NO_STR
8468 NEIGHBOR_STR
8469 NEIGHBOR_ADDR_STR2
8470 "allow local ASN appears in aspath attribute\n"
8471 "Number of occurrences of AS number\n"
8472 "Only accept my AS in the as-path if the route was originated in my AS\n")
8473 {
8474 int idx_peer = 2;
8475 int ret;
8476 struct peer *peer;
8477
8478 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8479 if (!peer)
8480 return CMD_WARNING_CONFIG_FAILED;
8481
8482 ret = peer_allowas_in_unset(peer, bgp_node_afi(vty),
8483 bgp_node_safi(vty));
8484
8485 return bgp_vty_return(vty, ret);
8486 }
8487
8488 ALIAS_HIDDEN(
8489 no_neighbor_allowas_in, no_neighbor_allowas_in_hidden_cmd,
8490 "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8491 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8492 "allow local ASN appears in aspath attribute\n"
8493 "Number of occurrences of AS number\n"
8494 "Only accept my AS in the as-path if the route was originated in my AS\n")
8495
8496 DEFUN (neighbor_ttl_security,
8497 neighbor_ttl_security_cmd,
8498 "neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
8499 NEIGHBOR_STR
8500 NEIGHBOR_ADDR_STR2
8501 "BGP ttl-security parameters\n"
8502 "Specify the maximum number of hops to the BGP peer\n"
8503 "Number of hops to BGP peer\n")
8504 {
8505 int idx_peer = 1;
8506 int idx_number = 4;
8507 struct peer *peer;
8508 int gtsm_hops;
8509
8510 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8511 if (!peer)
8512 return CMD_WARNING_CONFIG_FAILED;
8513
8514 gtsm_hops = strtoul(argv[idx_number]->arg, NULL, 10);
8515
8516 /*
8517 * If 'neighbor swpX', then this is for directly connected peers,
8518 * we should not accept a ttl-security hops value greater than 1.
8519 */
8520 if (peer->conf_if && (gtsm_hops > BGP_GTSM_HOPS_CONNECTED)) {
8521 vty_out(vty,
8522 "%s is directly connected peer, hops cannot exceed 1\n",
8523 argv[idx_peer]->arg);
8524 return CMD_WARNING_CONFIG_FAILED;
8525 }
8526
8527 return bgp_vty_return(vty, peer_ttl_security_hops_set(peer, gtsm_hops));
8528 }
8529
8530 DEFUN (no_neighbor_ttl_security,
8531 no_neighbor_ttl_security_cmd,
8532 "no neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
8533 NO_STR
8534 NEIGHBOR_STR
8535 NEIGHBOR_ADDR_STR2
8536 "BGP ttl-security parameters\n"
8537 "Specify the maximum number of hops to the BGP peer\n"
8538 "Number of hops to BGP peer\n")
8539 {
8540 int idx_peer = 2;
8541 struct peer *peer;
8542
8543 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8544 if (!peer)
8545 return CMD_WARNING_CONFIG_FAILED;
8546
8547 return bgp_vty_return(vty, peer_ttl_security_hops_unset(peer));
8548 }
8549
8550 /* disable-addpath-rx */
8551 DEFUN(neighbor_disable_addpath_rx,
8552 neighbor_disable_addpath_rx_cmd,
8553 "neighbor <A.B.C.D|X:X::X:X|WORD> disable-addpath-rx",
8554 NEIGHBOR_STR
8555 NEIGHBOR_ADDR_STR2
8556 "Do not accept additional paths\n")
8557 {
8558 char *peer_str = argv[1]->arg;
8559 struct peer *peer;
8560 afi_t afi = bgp_node_afi(vty);
8561 safi_t safi = bgp_node_safi(vty);
8562
8563 peer = peer_and_group_lookup_vty(vty, peer_str);
8564 if (!peer)
8565 return CMD_WARNING_CONFIG_FAILED;
8566
8567 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
8568 PEER_FLAG_DISABLE_ADDPATH_RX);
8569 }
8570
8571 DEFUN(no_neighbor_disable_addpath_rx,
8572 no_neighbor_disable_addpath_rx_cmd,
8573 "no neighbor <A.B.C.D|X:X::X:X|WORD> disable-addpath-rx",
8574 NO_STR
8575 NEIGHBOR_STR
8576 NEIGHBOR_ADDR_STR2
8577 "Do not accept additional paths\n")
8578 {
8579 char *peer_str = argv[2]->arg;
8580 struct peer *peer;
8581 afi_t afi = bgp_node_afi(vty);
8582 safi_t safi = bgp_node_safi(vty);
8583
8584 peer = peer_and_group_lookup_vty(vty, peer_str);
8585 if (!peer)
8586 return CMD_WARNING_CONFIG_FAILED;
8587
8588 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
8589 PEER_FLAG_DISABLE_ADDPATH_RX);
8590 }
8591
8592 DEFUN (neighbor_addpath_tx_all_paths,
8593 neighbor_addpath_tx_all_paths_cmd,
8594 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8595 NEIGHBOR_STR
8596 NEIGHBOR_ADDR_STR2
8597 "Use addpath to advertise all paths to a neighbor\n")
8598 {
8599 int idx_peer = 1;
8600 struct peer *peer;
8601
8602 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8603 if (!peer)
8604 return CMD_WARNING_CONFIG_FAILED;
8605
8606 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8607 BGP_ADDPATH_ALL);
8608 return CMD_SUCCESS;
8609 }
8610
8611 ALIAS_HIDDEN(neighbor_addpath_tx_all_paths,
8612 neighbor_addpath_tx_all_paths_hidden_cmd,
8613 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8614 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8615 "Use addpath to advertise all paths to a neighbor\n")
8616
8617 DEFUN (no_neighbor_addpath_tx_all_paths,
8618 no_neighbor_addpath_tx_all_paths_cmd,
8619 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8620 NO_STR
8621 NEIGHBOR_STR
8622 NEIGHBOR_ADDR_STR2
8623 "Use addpath to advertise all paths to a neighbor\n")
8624 {
8625 int idx_peer = 2;
8626 struct peer *peer;
8627
8628 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8629 if (!peer)
8630 return CMD_WARNING_CONFIG_FAILED;
8631
8632 if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
8633 != BGP_ADDPATH_ALL) {
8634 vty_out(vty,
8635 "%% Peer not currently configured to transmit all paths.");
8636 return CMD_WARNING_CONFIG_FAILED;
8637 }
8638
8639 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8640 BGP_ADDPATH_NONE);
8641
8642 return CMD_SUCCESS;
8643 }
8644
8645 ALIAS_HIDDEN(no_neighbor_addpath_tx_all_paths,
8646 no_neighbor_addpath_tx_all_paths_hidden_cmd,
8647 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8648 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8649 "Use addpath to advertise all paths to a neighbor\n")
8650
8651 DEFUN (neighbor_addpath_tx_bestpath_per_as,
8652 neighbor_addpath_tx_bestpath_per_as_cmd,
8653 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8654 NEIGHBOR_STR
8655 NEIGHBOR_ADDR_STR2
8656 "Use addpath to advertise the bestpath per each neighboring AS\n")
8657 {
8658 int idx_peer = 1;
8659 struct peer *peer;
8660
8661 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8662 if (!peer)
8663 return CMD_WARNING_CONFIG_FAILED;
8664
8665 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8666 BGP_ADDPATH_BEST_PER_AS);
8667
8668 return CMD_SUCCESS;
8669 }
8670
8671 ALIAS_HIDDEN(neighbor_addpath_tx_bestpath_per_as,
8672 neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
8673 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8674 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8675 "Use addpath to advertise the bestpath per each neighboring AS\n")
8676
8677 DEFUN (no_neighbor_addpath_tx_bestpath_per_as,
8678 no_neighbor_addpath_tx_bestpath_per_as_cmd,
8679 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8680 NO_STR
8681 NEIGHBOR_STR
8682 NEIGHBOR_ADDR_STR2
8683 "Use addpath to advertise the bestpath per each neighboring AS\n")
8684 {
8685 int idx_peer = 2;
8686 struct peer *peer;
8687
8688 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8689 if (!peer)
8690 return CMD_WARNING_CONFIG_FAILED;
8691
8692 if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
8693 != BGP_ADDPATH_BEST_PER_AS) {
8694 vty_out(vty,
8695 "%% Peer not currently configured to transmit all best path per as.");
8696 return CMD_WARNING_CONFIG_FAILED;
8697 }
8698
8699 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8700 BGP_ADDPATH_NONE);
8701
8702 return CMD_SUCCESS;
8703 }
8704
8705 ALIAS_HIDDEN(no_neighbor_addpath_tx_bestpath_per_as,
8706 no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
8707 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8708 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8709 "Use addpath to advertise the bestpath per each neighboring AS\n")
8710
8711 DEFPY(
8712 neighbor_aspath_loop_detection, neighbor_aspath_loop_detection_cmd,
8713 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor sender-as-path-loop-detection",
8714 NEIGHBOR_STR
8715 NEIGHBOR_ADDR_STR2
8716 "Detect AS loops before sending to neighbor\n")
8717 {
8718 struct peer *peer;
8719
8720 peer = peer_and_group_lookup_vty(vty, neighbor);
8721 if (!peer)
8722 return CMD_WARNING_CONFIG_FAILED;
8723
8724 peer->as_path_loop_detection = true;
8725
8726 return CMD_SUCCESS;
8727 }
8728
8729 DEFPY(
8730 no_neighbor_aspath_loop_detection,
8731 no_neighbor_aspath_loop_detection_cmd,
8732 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor sender-as-path-loop-detection",
8733 NO_STR
8734 NEIGHBOR_STR
8735 NEIGHBOR_ADDR_STR2
8736 "Detect AS loops before sending to neighbor\n")
8737 {
8738 struct peer *peer;
8739
8740 peer = peer_and_group_lookup_vty(vty, neighbor);
8741 if (!peer)
8742 return CMD_WARNING_CONFIG_FAILED;
8743
8744 peer->as_path_loop_detection = false;
8745
8746 return CMD_SUCCESS;
8747 }
8748
8749 static int set_ecom_list(struct vty *vty, int argc, struct cmd_token **argv,
8750 struct ecommunity **list, bool is_rt6)
8751 {
8752 struct ecommunity *ecom = NULL;
8753 struct ecommunity *ecomadd;
8754
8755 for (; argc; --argc, ++argv) {
8756 if (is_rt6)
8757 ecomadd = ecommunity_str2com_ipv6(argv[0]->arg,
8758 ECOMMUNITY_ROUTE_TARGET,
8759 0);
8760 else
8761 ecomadd = ecommunity_str2com(argv[0]->arg,
8762 ECOMMUNITY_ROUTE_TARGET,
8763 0);
8764 if (!ecomadd) {
8765 vty_out(vty, "Malformed community-list value\n");
8766 if (ecom)
8767 ecommunity_free(&ecom);
8768 return CMD_WARNING_CONFIG_FAILED;
8769 }
8770
8771 if (ecom) {
8772 ecommunity_merge(ecom, ecomadd);
8773 ecommunity_free(&ecomadd);
8774 } else {
8775 ecom = ecomadd;
8776 }
8777 }
8778
8779 if (*list) {
8780 ecommunity_free(&*list);
8781 }
8782 *list = ecom;
8783
8784 return CMD_SUCCESS;
8785 }
8786
8787 /*
8788 * v2vimport is true if we are handling a `import vrf ...` command
8789 */
8790 static afi_t vpn_policy_getafi(struct vty *vty, struct bgp *bgp, bool v2vimport)
8791 {
8792 afi_t afi;
8793
8794 switch (vty->node) {
8795 case BGP_IPV4_NODE:
8796 afi = AFI_IP;
8797 break;
8798 case BGP_IPV6_NODE:
8799 afi = AFI_IP6;
8800 break;
8801 default:
8802 vty_out(vty,
8803 "%% context error: valid only in address-family <ipv4|ipv6> unicast block\n");
8804 return AFI_MAX;
8805 }
8806
8807 if (!v2vimport) {
8808 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
8809 BGP_CONFIG_VRF_TO_VRF_IMPORT)
8810 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
8811 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
8812 vty_out(vty,
8813 "%% error: Please unconfigure import vrf commands before using vpn commands\n");
8814 return AFI_MAX;
8815 }
8816 } else {
8817 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
8818 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)
8819 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
8820 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
8821 vty_out(vty,
8822 "%% error: Please unconfigure vpn to vrf commands before using import vrf commands\n");
8823 return AFI_MAX;
8824 }
8825 }
8826 return afi;
8827 }
8828
8829 DEFPY (af_rd_vpn_export,
8830 af_rd_vpn_export_cmd,
8831 "[no] rd vpn export ASN:NN_OR_IP-ADDRESS:NN$rd_str",
8832 NO_STR
8833 "Specify route distinguisher\n"
8834 "Between current address-family and vpn\n"
8835 "For routes leaked from current address-family to vpn\n"
8836 "Route Distinguisher (<as-number>:<number> | <ip-address>:<number>)\n")
8837 {
8838 VTY_DECLVAR_CONTEXT(bgp, bgp);
8839 struct prefix_rd prd;
8840 int ret;
8841 afi_t afi;
8842 int idx = 0;
8843 bool yes = true;
8844
8845 if (argv_find(argv, argc, "no", &idx))
8846 yes = false;
8847
8848 if (yes) {
8849 ret = str2prefix_rd(rd_str, &prd);
8850 if (!ret) {
8851 vty_out(vty, "%% Malformed rd\n");
8852 return CMD_WARNING_CONFIG_FAILED;
8853 }
8854 }
8855
8856 afi = vpn_policy_getafi(vty, bgp, false);
8857 if (afi == AFI_MAX)
8858 return CMD_WARNING_CONFIG_FAILED;
8859
8860 /*
8861 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
8862 */
8863 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
8864 bgp_get_default(), bgp);
8865
8866 if (yes) {
8867 bgp->vpn_policy[afi].tovpn_rd = prd;
8868 SET_FLAG(bgp->vpn_policy[afi].flags,
8869 BGP_VPN_POLICY_TOVPN_RD_SET);
8870 } else {
8871 UNSET_FLAG(bgp->vpn_policy[afi].flags,
8872 BGP_VPN_POLICY_TOVPN_RD_SET);
8873 }
8874
8875 /* post-change: re-export vpn routes */
8876 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
8877 bgp_get_default(), bgp);
8878
8879 return CMD_SUCCESS;
8880 }
8881
8882 ALIAS (af_rd_vpn_export,
8883 af_no_rd_vpn_export_cmd,
8884 "no rd vpn export",
8885 NO_STR
8886 "Specify route distinguisher\n"
8887 "Between current address-family and vpn\n"
8888 "For routes leaked from current address-family to vpn\n")
8889
8890 DEFPY (af_label_vpn_export,
8891 af_label_vpn_export_cmd,
8892 "[no] label vpn export <(0-1048575)$label_val|auto$label_auto>",
8893 NO_STR
8894 "label value for VRF\n"
8895 "Between current address-family and vpn\n"
8896 "For routes leaked from current address-family to vpn\n"
8897 "Label Value <0-1048575>\n"
8898 "Automatically assign a label\n")
8899 {
8900 VTY_DECLVAR_CONTEXT(bgp, bgp);
8901 mpls_label_t label = MPLS_LABEL_NONE;
8902 afi_t afi;
8903 int idx = 0;
8904 bool yes = true;
8905
8906 if (argv_find(argv, argc, "no", &idx))
8907 yes = false;
8908
8909 /* If "no ...", squash trailing parameter */
8910 if (!yes)
8911 label_auto = NULL;
8912
8913 if (yes) {
8914 if (!label_auto)
8915 label = label_val; /* parser should force unsigned */
8916 }
8917
8918 afi = vpn_policy_getafi(vty, bgp, false);
8919 if (afi == AFI_MAX)
8920 return CMD_WARNING_CONFIG_FAILED;
8921
8922
8923 if (label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
8924 BGP_VPN_POLICY_TOVPN_LABEL_AUTO))
8925 /* no change */
8926 return CMD_SUCCESS;
8927
8928 /*
8929 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
8930 */
8931 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
8932 bgp_get_default(), bgp);
8933
8934 if (!label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
8935 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
8936
8937 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
8938
8939 /*
8940 * label has previously been automatically
8941 * assigned by labelpool: release it
8942 *
8943 * NB if tovpn_label == MPLS_LABEL_NONE it
8944 * means the automatic assignment is in flight
8945 * and therefore the labelpool callback must
8946 * detect that the auto label is not needed.
8947 */
8948
8949 bgp_lp_release(LP_TYPE_VRF,
8950 &bgp->vpn_policy[afi],
8951 bgp->vpn_policy[afi].tovpn_label);
8952 }
8953 UNSET_FLAG(bgp->vpn_policy[afi].flags,
8954 BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
8955 }
8956
8957 bgp->vpn_policy[afi].tovpn_label = label;
8958 if (label_auto) {
8959 SET_FLAG(bgp->vpn_policy[afi].flags,
8960 BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
8961 bgp_lp_get(LP_TYPE_VRF, &bgp->vpn_policy[afi],
8962 vpn_leak_label_callback);
8963 }
8964
8965 /* post-change: re-export vpn routes */
8966 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
8967 bgp_get_default(), bgp);
8968
8969 hook_call(bgp_snmp_update_last_changed, bgp);
8970 return CMD_SUCCESS;
8971 }
8972
8973 DEFPY (af_sid_vpn_export,
8974 af_sid_vpn_export_cmd,
8975 "[no] sid vpn export <(1-1048575)$sid_idx|auto$sid_auto>",
8976 NO_STR
8977 "sid value for VRF\n"
8978 "Between current address-family and vpn\n"
8979 "For routes leaked from current address-family to vpn\n"
8980 "Sid allocation index\n"
8981 "Automatically assign a label\n")
8982 {
8983 VTY_DECLVAR_CONTEXT(bgp, bgp);
8984 afi_t afi;
8985 int debug = 0;
8986 int idx = 0;
8987 bool yes = true;
8988
8989 if (argv_find(argv, argc, "no", &idx))
8990 yes = false;
8991 debug = (BGP_DEBUG(vpn, VPN_LEAK_TO_VRF) |
8992 BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF));
8993
8994 afi = vpn_policy_getafi(vty, bgp, false);
8995 if (afi == AFI_MAX)
8996 return CMD_WARNING_CONFIG_FAILED;
8997
8998 if (!yes) {
8999 /* implement me */
9000 vty_out(vty, "It's not implemented\n");
9001 return CMD_WARNING_CONFIG_FAILED;
9002 }
9003
9004 if (bgp->tovpn_sid_index != 0 ||
9005 CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)) {
9006 vty_out(vty,
9007 "per-vrf sid and per-af sid are mutually exclusive\n"
9008 "Failed: per-vrf sid is configured. Remove per-vrf sid before configuring per-af sid\n");
9009 return CMD_WARNING_CONFIG_FAILED;
9010 }
9011
9012 /* skip when it's already configured */
9013 if ((sid_idx != 0 && bgp->vpn_policy[afi].tovpn_sid_index != 0)
9014 || (sid_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9015 BGP_VPN_POLICY_TOVPN_SID_AUTO)))
9016 return CMD_SUCCESS;
9017
9018 /*
9019 * mode change between sid_idx and sid_auto isn't supported.
9020 * user must negate sid vpn export when they want to change the mode
9021 */
9022 if ((sid_auto && bgp->vpn_policy[afi].tovpn_sid_index != 0)
9023 || (sid_idx != 0 && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9024 BGP_VPN_POLICY_TOVPN_SID_AUTO))) {
9025 vty_out(vty, "it's already configured as %s.\n",
9026 sid_auto ? "auto-mode" : "idx-mode");
9027 return CMD_WARNING_CONFIG_FAILED;
9028 }
9029
9030 /* pre-change */
9031 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9032 bgp_get_default(), bgp);
9033
9034 if (sid_auto) {
9035 /* SID allocation auto-mode */
9036 if (debug)
9037 zlog_debug("%s: auto sid alloc.", __func__);
9038 SET_FLAG(bgp->vpn_policy[afi].flags,
9039 BGP_VPN_POLICY_TOVPN_SID_AUTO);
9040 } else {
9041 /* SID allocation index-mode */
9042 if (debug)
9043 zlog_debug("%s: idx %ld sid alloc.", __func__, sid_idx);
9044 bgp->vpn_policy[afi].tovpn_sid_index = sid_idx;
9045 }
9046
9047 /* post-change */
9048 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9049 bgp_get_default(), bgp);
9050 return CMD_SUCCESS;
9051 }
9052
9053 DEFPY (bgp_sid_vpn_export,
9054 bgp_sid_vpn_export_cmd,
9055 "[no] sid vpn per-vrf export <(1-255)$sid_idx|auto$sid_auto>",
9056 NO_STR
9057 "sid value for VRF\n"
9058 "Between current vrf and vpn\n"
9059 "sid per-VRF (both IPv4 and IPv6 address families)\n"
9060 "For routes leaked from current vrf to vpn\n"
9061 "Sid allocation index\n"
9062 "Automatically assign a label\n")
9063 {
9064 VTY_DECLVAR_CONTEXT(bgp, bgp);
9065 int debug;
9066
9067 debug = (BGP_DEBUG(vpn, VPN_LEAK_TO_VRF) |
9068 BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF));
9069
9070 if (no) {
9071 /* when per-VRF SID is not set, do nothing */
9072 if (bgp->tovpn_sid_index == 0 &&
9073 !CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO))
9074 return CMD_SUCCESS;
9075
9076 sid_idx = 0;
9077 sid_auto = false;
9078 bgp->tovpn_sid_index = 0;
9079 UNSET_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO);
9080 }
9081
9082 if (bgp->vpn_policy[AFI_IP].tovpn_sid_index != 0 ||
9083 CHECK_FLAG(bgp->vpn_policy[AFI_IP].flags,
9084 BGP_VPN_POLICY_TOVPN_SID_AUTO) ||
9085 bgp->vpn_policy[AFI_IP6].tovpn_sid_index != 0 ||
9086 CHECK_FLAG(bgp->vpn_policy[AFI_IP6].flags,
9087 BGP_VPN_POLICY_TOVPN_SID_AUTO)) {
9088 vty_out(vty,
9089 "per-vrf sid and per-af sid are mutually exclusive\n"
9090 "Failed: per-af sid is configured. Remove per-af sid before configuring per-vrf sid\n");
9091 return CMD_WARNING_CONFIG_FAILED;
9092 }
9093
9094 /* skip when it's already configured */
9095 if ((sid_idx != 0 && bgp->tovpn_sid_index != 0) ||
9096 (sid_auto && CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)))
9097 return CMD_SUCCESS;
9098
9099 /*
9100 * mode change between sid_idx and sid_auto isn't supported.
9101 * user must negate sid vpn export when they want to change the mode
9102 */
9103 if ((sid_auto && bgp->tovpn_sid_index != 0) ||
9104 (sid_idx != 0 &&
9105 CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO))) {
9106 vty_out(vty, "it's already configured as %s.\n",
9107 sid_auto ? "auto-mode" : "idx-mode");
9108 return CMD_WARNING_CONFIG_FAILED;
9109 }
9110
9111 /* pre-change */
9112 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP, bgp_get_default(),
9113 bgp);
9114 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6, bgp_get_default(),
9115 bgp);
9116
9117 if (sid_auto) {
9118 /* SID allocation auto-mode */
9119 if (debug)
9120 zlog_debug("%s: auto per-vrf sid alloc.", __func__);
9121 SET_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO);
9122 } else if (sid_idx != 0) {
9123 /* SID allocation index-mode */
9124 if (debug)
9125 zlog_debug("%s: idx %ld per-vrf sid alloc.", __func__,
9126 sid_idx);
9127 bgp->tovpn_sid_index = sid_idx;
9128 }
9129
9130 /* post-change */
9131 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP, bgp_get_default(),
9132 bgp);
9133 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
9134 bgp_get_default(), bgp);
9135
9136 return CMD_SUCCESS;
9137 }
9138
9139 ALIAS (af_label_vpn_export,
9140 af_no_label_vpn_export_cmd,
9141 "no label vpn export",
9142 NO_STR
9143 "label value for VRF\n"
9144 "Between current address-family and vpn\n"
9145 "For routes leaked from current address-family to vpn\n")
9146
9147 ALIAS (bgp_sid_vpn_export,
9148 no_bgp_sid_vpn_export_cmd,
9149 "no$no sid vpn per-vrf export",
9150 NO_STR
9151 "sid value for VRF\n"
9152 "Between current vrf and vpn\n"
9153 "sid per-VRF (both IPv4 and IPv6 address families)\n"
9154 "For routes leaked from current vrf to vpn\n")
9155
9156 DEFPY (af_nexthop_vpn_export,
9157 af_nexthop_vpn_export_cmd,
9158 "[no] nexthop vpn export [<A.B.C.D|X:X::X:X>$nexthop_su]",
9159 NO_STR
9160 "Specify next hop to use for VRF advertised prefixes\n"
9161 "Between current address-family and vpn\n"
9162 "For routes leaked from current address-family to vpn\n"
9163 "IPv4 prefix\n"
9164 "IPv6 prefix\n")
9165 {
9166 VTY_DECLVAR_CONTEXT(bgp, bgp);
9167 afi_t afi;
9168 struct prefix p;
9169
9170 if (!no) {
9171 if (!nexthop_su) {
9172 vty_out(vty, "%% Nexthop required\n");
9173 return CMD_WARNING_CONFIG_FAILED;
9174 }
9175 if (!sockunion2hostprefix(nexthop_su, &p))
9176 return CMD_WARNING_CONFIG_FAILED;
9177 }
9178
9179 afi = vpn_policy_getafi(vty, bgp, false);
9180 if (afi == AFI_MAX)
9181 return CMD_WARNING_CONFIG_FAILED;
9182
9183 /*
9184 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
9185 */
9186 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9187 bgp_get_default(), bgp);
9188
9189 if (!no) {
9190 bgp->vpn_policy[afi].tovpn_nexthop = p;
9191 SET_FLAG(bgp->vpn_policy[afi].flags,
9192 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
9193 } else {
9194 UNSET_FLAG(bgp->vpn_policy[afi].flags,
9195 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
9196 }
9197
9198 /* post-change: re-export vpn routes */
9199 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9200 bgp_get_default(), bgp);
9201
9202 return CMD_SUCCESS;
9203 }
9204
9205 static int vpn_policy_getdirs(struct vty *vty, const char *dstr, int *dodir)
9206 {
9207 if (!strcmp(dstr, "import")) {
9208 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
9209 } else if (!strcmp(dstr, "export")) {
9210 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
9211 } else if (!strcmp(dstr, "both")) {
9212 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
9213 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
9214 } else {
9215 vty_out(vty, "%% direction parse error\n");
9216 return CMD_WARNING_CONFIG_FAILED;
9217 }
9218 return CMD_SUCCESS;
9219 }
9220
9221 DEFPY (af_rt_vpn_imexport,
9222 af_rt_vpn_imexport_cmd,
9223 "[no] <rt|route-target> vpn <import|export|both>$direction_str RTLIST...",
9224 NO_STR
9225 "Specify route target list\n"
9226 "Specify route target list\n"
9227 "Between current address-family and vpn\n"
9228 "For routes leaked from vpn to current address-family: match any\n"
9229 "For routes leaked from current address-family to vpn: set\n"
9230 "both import: match any and export: set\n"
9231 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
9232 {
9233 VTY_DECLVAR_CONTEXT(bgp, bgp);
9234 int ret;
9235 struct ecommunity *ecom = NULL;
9236 int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
9237 enum vpn_policy_direction dir;
9238 afi_t afi;
9239 int idx = 0;
9240 bool yes = true;
9241
9242 if (argv_find(argv, argc, "no", &idx))
9243 yes = false;
9244
9245 afi = vpn_policy_getafi(vty, bgp, false);
9246 if (afi == AFI_MAX)
9247 return CMD_WARNING_CONFIG_FAILED;
9248
9249 ret = vpn_policy_getdirs(vty, direction_str, dodir);
9250 if (ret != CMD_SUCCESS)
9251 return ret;
9252
9253 if (yes) {
9254 if (!argv_find(argv, argc, "RTLIST", &idx)) {
9255 vty_out(vty, "%% Missing RTLIST\n");
9256 return CMD_WARNING_CONFIG_FAILED;
9257 }
9258 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom, false);
9259 if (ret != CMD_SUCCESS) {
9260 return ret;
9261 }
9262 }
9263
9264 for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
9265 if (!dodir[dir])
9266 continue;
9267
9268 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9269
9270 if (yes) {
9271 if (bgp->vpn_policy[afi].rtlist[dir])
9272 ecommunity_free(
9273 &bgp->vpn_policy[afi].rtlist[dir]);
9274 bgp->vpn_policy[afi].rtlist[dir] =
9275 ecommunity_dup(ecom);
9276 } else {
9277 if (bgp->vpn_policy[afi].rtlist[dir])
9278 ecommunity_free(
9279 &bgp->vpn_policy[afi].rtlist[dir]);
9280 bgp->vpn_policy[afi].rtlist[dir] = NULL;
9281 }
9282
9283 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9284 }
9285
9286 if (ecom)
9287 ecommunity_free(&ecom);
9288
9289 return CMD_SUCCESS;
9290 }
9291
9292 ALIAS (af_rt_vpn_imexport,
9293 af_no_rt_vpn_imexport_cmd,
9294 "no <rt|route-target> vpn <import|export|both>$direction_str",
9295 NO_STR
9296 "Specify route target list\n"
9297 "Specify route target list\n"
9298 "Between current address-family and vpn\n"
9299 "For routes leaked from vpn to current address-family\n"
9300 "For routes leaked from current address-family to vpn\n"
9301 "both import and export\n")
9302
9303 DEFPY (af_route_map_vpn_imexport,
9304 af_route_map_vpn_imexport_cmd,
9305 /* future: "route-map <vpn|evpn|vrf NAME> <import|export> RMAP" */
9306 "[no] route-map vpn <import|export>$direction_str RMAP$rmap_str",
9307 NO_STR
9308 "Specify route map\n"
9309 "Between current address-family and vpn\n"
9310 "For routes leaked from vpn to current address-family\n"
9311 "For routes leaked from current address-family to vpn\n"
9312 "name of route-map\n")
9313 {
9314 VTY_DECLVAR_CONTEXT(bgp, bgp);
9315 int ret;
9316 int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
9317 enum vpn_policy_direction dir;
9318 afi_t afi;
9319 int idx = 0;
9320 bool yes = true;
9321
9322 if (argv_find(argv, argc, "no", &idx))
9323 yes = false;
9324
9325 afi = vpn_policy_getafi(vty, bgp, false);
9326 if (afi == AFI_MAX)
9327 return CMD_WARNING_CONFIG_FAILED;
9328
9329 ret = vpn_policy_getdirs(vty, direction_str, dodir);
9330 if (ret != CMD_SUCCESS)
9331 return ret;
9332
9333 for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
9334 if (!dodir[dir])
9335 continue;
9336
9337 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9338
9339 if (yes) {
9340 if (bgp->vpn_policy[afi].rmap_name[dir])
9341 XFREE(MTYPE_ROUTE_MAP_NAME,
9342 bgp->vpn_policy[afi].rmap_name[dir]);
9343 bgp->vpn_policy[afi].rmap_name[dir] = XSTRDUP(
9344 MTYPE_ROUTE_MAP_NAME, rmap_str);
9345 bgp->vpn_policy[afi].rmap[dir] =
9346 route_map_lookup_warn_noexist(vty, rmap_str);
9347 if (!bgp->vpn_policy[afi].rmap[dir])
9348 return CMD_SUCCESS;
9349 } else {
9350 if (bgp->vpn_policy[afi].rmap_name[dir])
9351 XFREE(MTYPE_ROUTE_MAP_NAME,
9352 bgp->vpn_policy[afi].rmap_name[dir]);
9353 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
9354 bgp->vpn_policy[afi].rmap[dir] = NULL;
9355 }
9356
9357 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9358 }
9359
9360 return CMD_SUCCESS;
9361 }
9362
9363 ALIAS (af_route_map_vpn_imexport,
9364 af_no_route_map_vpn_imexport_cmd,
9365 "no route-map vpn <import|export>$direction_str",
9366 NO_STR
9367 "Specify route map\n"
9368 "Between current address-family and vpn\n"
9369 "For routes leaked from vpn to current address-family\n"
9370 "For routes leaked from current address-family to vpn\n")
9371
9372 DEFPY(af_import_vrf_route_map, af_import_vrf_route_map_cmd,
9373 "import vrf route-map RMAP$rmap_str",
9374 "Import routes from another VRF\n"
9375 "Vrf routes being filtered\n"
9376 "Specify route map\n"
9377 "name of route-map\n")
9378 {
9379 VTY_DECLVAR_CONTEXT(bgp, bgp);
9380 enum vpn_policy_direction dir = BGP_VPN_POLICY_DIR_FROMVPN;
9381 afi_t afi;
9382 struct bgp *bgp_default;
9383
9384 afi = vpn_policy_getafi(vty, bgp, true);
9385 if (afi == AFI_MAX)
9386 return CMD_WARNING_CONFIG_FAILED;
9387
9388 bgp_default = bgp_get_default();
9389 if (!bgp_default) {
9390 int32_t ret;
9391 as_t as = bgp->as;
9392
9393 /* Auto-create assuming the same AS */
9394 ret = bgp_get_vty(&bgp_default, &as, NULL,
9395 BGP_INSTANCE_TYPE_DEFAULT);
9396
9397 if (ret) {
9398 vty_out(vty,
9399 "VRF default is not configured as a bgp instance\n");
9400 return CMD_WARNING;
9401 }
9402 }
9403
9404 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9405
9406 if (bgp->vpn_policy[afi].rmap_name[dir])
9407 XFREE(MTYPE_ROUTE_MAP_NAME,
9408 bgp->vpn_policy[afi].rmap_name[dir]);
9409 bgp->vpn_policy[afi].rmap_name[dir] =
9410 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_str);
9411 bgp->vpn_policy[afi].rmap[dir] =
9412 route_map_lookup_warn_noexist(vty, rmap_str);
9413 if (!bgp->vpn_policy[afi].rmap[dir])
9414 return CMD_SUCCESS;
9415
9416 SET_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9417 BGP_CONFIG_VRF_TO_VRF_IMPORT);
9418
9419 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9420
9421 return CMD_SUCCESS;
9422 }
9423
9424 DEFPY(af_no_import_vrf_route_map, af_no_import_vrf_route_map_cmd,
9425 "no import vrf route-map [RMAP$rmap_str]",
9426 NO_STR
9427 "Import routes from another VRF\n"
9428 "Vrf routes being filtered\n"
9429 "Specify route map\n"
9430 "name of route-map\n")
9431 {
9432 VTY_DECLVAR_CONTEXT(bgp, bgp);
9433 enum vpn_policy_direction dir = BGP_VPN_POLICY_DIR_FROMVPN;
9434 afi_t afi;
9435
9436 afi = vpn_policy_getafi(vty, bgp, true);
9437 if (afi == AFI_MAX)
9438 return CMD_WARNING_CONFIG_FAILED;
9439
9440 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9441
9442 if (bgp->vpn_policy[afi].rmap_name[dir])
9443 XFREE(MTYPE_ROUTE_MAP_NAME,
9444 bgp->vpn_policy[afi].rmap_name[dir]);
9445 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
9446 bgp->vpn_policy[afi].rmap[dir] = NULL;
9447
9448 if (bgp->vpn_policy[afi].import_vrf->count == 0)
9449 UNSET_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9450 BGP_CONFIG_VRF_TO_VRF_IMPORT);
9451
9452 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9453
9454 return CMD_SUCCESS;
9455 }
9456
9457 DEFPY(bgp_imexport_vrf, bgp_imexport_vrf_cmd,
9458 "[no] import vrf VIEWVRFNAME$import_name",
9459 NO_STR
9460 "Import routes from another VRF\n"
9461 "VRF to import from\n"
9462 "The name of the VRF\n")
9463 {
9464 VTY_DECLVAR_CONTEXT(bgp, bgp);
9465 struct listnode *node;
9466 struct bgp *vrf_bgp, *bgp_default;
9467 int32_t ret = 0;
9468 as_t as = bgp->as;
9469 bool remove = false;
9470 int32_t idx = 0;
9471 char *vname;
9472 enum bgp_instance_type bgp_type = BGP_INSTANCE_TYPE_VRF;
9473 safi_t safi;
9474 afi_t afi;
9475
9476 if (import_name == NULL) {
9477 vty_out(vty, "%% Missing import name\n");
9478 return CMD_WARNING;
9479 }
9480
9481 if (strcmp(import_name, "route-map") == 0) {
9482 vty_out(vty, "%% Must include route-map name\n");
9483 return CMD_WARNING;
9484 }
9485
9486 if (argv_find(argv, argc, "no", &idx))
9487 remove = true;
9488
9489 afi = vpn_policy_getafi(vty, bgp, true);
9490 if (afi == AFI_MAX)
9491 return CMD_WARNING_CONFIG_FAILED;
9492
9493 safi = bgp_node_safi(vty);
9494
9495 if (((BGP_INSTANCE_TYPE_DEFAULT == bgp->inst_type)
9496 && (strcmp(import_name, VRF_DEFAULT_NAME) == 0))
9497 || (bgp->name && (strcmp(import_name, bgp->name) == 0))) {
9498 vty_out(vty, "%% Cannot %s vrf %s into itself\n",
9499 remove ? "unimport" : "import", import_name);
9500 return CMD_WARNING;
9501 }
9502
9503 bgp_default = bgp_get_default();
9504 if (!bgp_default) {
9505 /* Auto-create assuming the same AS */
9506 ret = bgp_get_vty(&bgp_default, &as, NULL,
9507 BGP_INSTANCE_TYPE_DEFAULT);
9508
9509 if (ret) {
9510 vty_out(vty,
9511 "VRF default is not configured as a bgp instance\n");
9512 return CMD_WARNING;
9513 }
9514 }
9515
9516 vrf_bgp = bgp_lookup_by_name(import_name);
9517 if (!vrf_bgp) {
9518 if (strcmp(import_name, VRF_DEFAULT_NAME) == 0)
9519 vrf_bgp = bgp_default;
9520 else
9521 /* Auto-create assuming the same AS */
9522 ret = bgp_get_vty(&vrf_bgp, &as, import_name, bgp_type);
9523
9524 if (ret) {
9525 vty_out(vty,
9526 "VRF %s is not configured as a bgp instance\n",
9527 import_name);
9528 return CMD_WARNING;
9529 }
9530 }
9531
9532 if (remove) {
9533 vrf_unimport_from_vrf(bgp, vrf_bgp, afi, safi);
9534 } else {
9535 /* Already importing from "import_vrf"? */
9536 for (ALL_LIST_ELEMENTS_RO(bgp->vpn_policy[afi].import_vrf, node,
9537 vname)) {
9538 if (strcmp(vname, import_name) == 0)
9539 return CMD_WARNING;
9540 }
9541
9542 vrf_import_from_vrf(bgp, vrf_bgp, afi, safi);
9543 }
9544
9545 return CMD_SUCCESS;
9546 }
9547
9548 /* This command is valid only in a bgp vrf instance or the default instance */
9549 DEFPY (bgp_imexport_vpn,
9550 bgp_imexport_vpn_cmd,
9551 "[no] <import|export>$direction_str vpn",
9552 NO_STR
9553 "Import routes to this address-family\n"
9554 "Export routes from this address-family\n"
9555 "to/from default instance VPN RIB\n")
9556 {
9557 VTY_DECLVAR_CONTEXT(bgp, bgp);
9558 int previous_state;
9559 afi_t afi;
9560 safi_t safi;
9561 int idx = 0;
9562 bool yes = true;
9563 int flag;
9564 enum vpn_policy_direction dir;
9565
9566 if (argv_find(argv, argc, "no", &idx))
9567 yes = false;
9568
9569 if (BGP_INSTANCE_TYPE_VRF != bgp->inst_type &&
9570 BGP_INSTANCE_TYPE_DEFAULT != bgp->inst_type) {
9571
9572 vty_out(vty, "%% import|export vpn valid only for bgp vrf or default instance\n");
9573 return CMD_WARNING_CONFIG_FAILED;
9574 }
9575
9576 afi = bgp_node_afi(vty);
9577 safi = bgp_node_safi(vty);
9578 if ((SAFI_UNICAST != safi) || ((AFI_IP != afi) && (AFI_IP6 != afi))) {
9579 vty_out(vty, "%% import|export vpn valid only for unicast ipv4|ipv6\n");
9580 return CMD_WARNING_CONFIG_FAILED;
9581 }
9582
9583 if (!strcmp(direction_str, "import")) {
9584 flag = BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT;
9585 dir = BGP_VPN_POLICY_DIR_FROMVPN;
9586 } else if (!strcmp(direction_str, "export")) {
9587 flag = BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT;
9588 dir = BGP_VPN_POLICY_DIR_TOVPN;
9589 } else {
9590 vty_out(vty, "%% unknown direction %s\n", direction_str);
9591 return CMD_WARNING_CONFIG_FAILED;
9592 }
9593
9594 previous_state = CHECK_FLAG(bgp->af_flags[afi][safi], flag);
9595
9596 if (yes) {
9597 SET_FLAG(bgp->af_flags[afi][safi], flag);
9598 if (!previous_state) {
9599 /* trigger export current vrf */
9600 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9601 }
9602 } else {
9603 if (previous_state) {
9604 /* trigger un-export current vrf */
9605 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9606 }
9607 UNSET_FLAG(bgp->af_flags[afi][safi], flag);
9608 }
9609
9610 hook_call(bgp_snmp_init_stats, bgp);
9611
9612 return CMD_SUCCESS;
9613 }
9614
9615 DEFPY (af_routetarget_import,
9616 af_routetarget_import_cmd,
9617 "[no] <rt|route-target|route-target6|rt6> redirect import RTLIST...",
9618 NO_STR
9619 "Specify route target list\n"
9620 "Specify route target list\n"
9621 "Specify route target list\n"
9622 "Specify route target list\n"
9623 "Flow-spec redirect type route target\n"
9624 "Import routes to this address-family\n"
9625 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN|IPV6:MN)\n")
9626 {
9627 VTY_DECLVAR_CONTEXT(bgp, bgp);
9628 int ret;
9629 struct ecommunity *ecom = NULL;
9630 afi_t afi;
9631 int idx = 0, idx_unused = 0;
9632 bool yes = true;
9633 bool rt6 = false;
9634
9635 if (argv_find(argv, argc, "no", &idx))
9636 yes = false;
9637
9638 if (argv_find(argv, argc, "rt6", &idx_unused) ||
9639 argv_find(argv, argc, "route-target6", &idx_unused))
9640 rt6 = true;
9641
9642 afi = vpn_policy_getafi(vty, bgp, false);
9643 if (afi == AFI_MAX)
9644 return CMD_WARNING_CONFIG_FAILED;
9645
9646 if (rt6 && afi != AFI_IP6)
9647 return CMD_WARNING_CONFIG_FAILED;
9648
9649 if (yes) {
9650 if (!argv_find(argv, argc, "RTLIST", &idx)) {
9651 vty_out(vty, "%% Missing RTLIST\n");
9652 return CMD_WARNING_CONFIG_FAILED;
9653 }
9654 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom, rt6);
9655 if (ret != CMD_SUCCESS)
9656 return ret;
9657 }
9658
9659 if (yes) {
9660 if (bgp->vpn_policy[afi].import_redirect_rtlist)
9661 ecommunity_free(&bgp->vpn_policy[afi]
9662 .import_redirect_rtlist);
9663 bgp->vpn_policy[afi].import_redirect_rtlist =
9664 ecommunity_dup(ecom);
9665 } else {
9666 if (bgp->vpn_policy[afi].import_redirect_rtlist)
9667 ecommunity_free(&bgp->vpn_policy[afi]
9668 .import_redirect_rtlist);
9669 bgp->vpn_policy[afi].import_redirect_rtlist = NULL;
9670 }
9671
9672 if (ecom)
9673 ecommunity_free(&ecom);
9674
9675 return CMD_SUCCESS;
9676 }
9677
9678 DEFUN_NOSH (address_family_ipv4_safi,
9679 address_family_ipv4_safi_cmd,
9680 "address-family ipv4 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
9681 "Enter Address Family command mode\n"
9682 BGP_AF_STR
9683 BGP_SAFI_WITH_LABEL_HELP_STR)
9684 {
9685
9686 if (argc == 3) {
9687 VTY_DECLVAR_CONTEXT(bgp, bgp);
9688 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
9689 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
9690 && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
9691 && safi != SAFI_EVPN) {
9692 vty_out(vty,
9693 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
9694 return CMD_WARNING_CONFIG_FAILED;
9695 }
9696 vty->node = bgp_node_type(AFI_IP, safi);
9697 } else
9698 vty->node = BGP_IPV4_NODE;
9699
9700 return CMD_SUCCESS;
9701 }
9702
9703 DEFUN_NOSH (address_family_ipv6_safi,
9704 address_family_ipv6_safi_cmd,
9705 "address-family ipv6 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
9706 "Enter Address Family command mode\n"
9707 BGP_AF_STR
9708 BGP_SAFI_WITH_LABEL_HELP_STR)
9709 {
9710 if (argc == 3) {
9711 VTY_DECLVAR_CONTEXT(bgp, bgp);
9712 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
9713 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
9714 && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
9715 && safi != SAFI_EVPN) {
9716 vty_out(vty,
9717 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
9718 return CMD_WARNING_CONFIG_FAILED;
9719 }
9720 vty->node = bgp_node_type(AFI_IP6, safi);
9721 } else
9722 vty->node = BGP_IPV6_NODE;
9723
9724 return CMD_SUCCESS;
9725 }
9726
9727 #ifdef KEEP_OLD_VPN_COMMANDS
9728 DEFUN_NOSH (address_family_vpnv4,
9729 address_family_vpnv4_cmd,
9730 "address-family vpnv4 [unicast]",
9731 "Enter Address Family command mode\n"
9732 BGP_AF_STR
9733 BGP_AF_MODIFIER_STR)
9734 {
9735 vty->node = BGP_VPNV4_NODE;
9736 return CMD_SUCCESS;
9737 }
9738
9739 DEFUN_NOSH (address_family_vpnv6,
9740 address_family_vpnv6_cmd,
9741 "address-family vpnv6 [unicast]",
9742 "Enter Address Family command mode\n"
9743 BGP_AF_STR
9744 BGP_AF_MODIFIER_STR)
9745 {
9746 vty->node = BGP_VPNV6_NODE;
9747 return CMD_SUCCESS;
9748 }
9749 #endif /* KEEP_OLD_VPN_COMMANDS */
9750
9751 DEFUN_NOSH (address_family_evpn,
9752 address_family_evpn_cmd,
9753 "address-family l2vpn evpn",
9754 "Enter Address Family command mode\n"
9755 BGP_AF_STR
9756 BGP_AF_MODIFIER_STR)
9757 {
9758 VTY_DECLVAR_CONTEXT(bgp, bgp);
9759 vty->node = BGP_EVPN_NODE;
9760 return CMD_SUCCESS;
9761 }
9762
9763 DEFUN_NOSH (bgp_segment_routing_srv6,
9764 bgp_segment_routing_srv6_cmd,
9765 "segment-routing srv6",
9766 "Segment-Routing configuration\n"
9767 "Segment-Routing SRv6 configuration\n")
9768 {
9769 VTY_DECLVAR_CONTEXT(bgp, bgp);
9770 bgp->srv6_enabled = true;
9771 vty->node = BGP_SRV6_NODE;
9772 return CMD_SUCCESS;
9773 }
9774
9775 DEFUN (no_bgp_segment_routing_srv6,
9776 no_bgp_segment_routing_srv6_cmd,
9777 "no segment-routing srv6",
9778 NO_STR
9779 "Segment-Routing configuration\n"
9780 "Segment-Routing SRv6 configuration\n")
9781 {
9782 VTY_DECLVAR_CONTEXT(bgp, bgp);
9783
9784 if (strlen(bgp->srv6_locator_name) > 0)
9785 if (bgp_srv6_locator_unset(bgp) < 0)
9786 return CMD_WARNING_CONFIG_FAILED;
9787
9788 bgp->srv6_enabled = false;
9789 return CMD_SUCCESS;
9790 }
9791
9792 DEFPY (bgp_srv6_locator,
9793 bgp_srv6_locator_cmd,
9794 "locator NAME$name",
9795 "Specify SRv6 locator\n"
9796 "Specify SRv6 locator\n")
9797 {
9798 VTY_DECLVAR_CONTEXT(bgp, bgp);
9799 int ret;
9800
9801 if (strlen(bgp->srv6_locator_name) > 0
9802 && strcmp(name, bgp->srv6_locator_name) != 0) {
9803 vty_out(vty, "srv6 locator is already configured\n");
9804 return CMD_WARNING_CONFIG_FAILED;
9805 }
9806
9807 snprintf(bgp->srv6_locator_name,
9808 sizeof(bgp->srv6_locator_name), "%s", name);
9809
9810 ret = bgp_zebra_srv6_manager_get_locator_chunk(name);
9811 if (ret < 0)
9812 return CMD_WARNING_CONFIG_FAILED;
9813
9814 return CMD_SUCCESS;
9815 }
9816
9817 DEFPY (no_bgp_srv6_locator,
9818 no_bgp_srv6_locator_cmd,
9819 "no locator NAME$name",
9820 NO_STR
9821 "Specify SRv6 locator\n"
9822 "Specify SRv6 locator\n")
9823 {
9824 VTY_DECLVAR_CONTEXT(bgp, bgp);
9825
9826 /* when locator isn't configured, do nothing */
9827 if (strlen(bgp->srv6_locator_name) < 1)
9828 return CMD_SUCCESS;
9829
9830 /* name validation */
9831 if (strcmp(name, bgp->srv6_locator_name) != 0) {
9832 vty_out(vty, "%% No srv6 locator is configured\n");
9833 return CMD_WARNING_CONFIG_FAILED;
9834 }
9835
9836 /* unset locator */
9837 if (bgp_srv6_locator_unset(bgp) < 0)
9838 return CMD_WARNING_CONFIG_FAILED;
9839
9840 return CMD_SUCCESS;
9841 }
9842
9843 DEFPY (show_bgp_srv6,
9844 show_bgp_srv6_cmd,
9845 "show bgp segment-routing srv6",
9846 SHOW_STR
9847 BGP_STR
9848 "BGP Segment Routing\n"
9849 "BGP Segment Routing SRv6\n")
9850 {
9851 struct bgp *bgp;
9852 struct listnode *node;
9853 struct srv6_locator_chunk *chunk;
9854 struct bgp_srv6_function *func;
9855 char buf[256];
9856
9857 bgp = bgp_get_default();
9858 if (!bgp)
9859 return CMD_SUCCESS;
9860
9861 vty_out(vty, "locator_name: %s\n", bgp->srv6_locator_name);
9862 vty_out(vty, "locator_chunks:\n");
9863 for (ALL_LIST_ELEMENTS_RO(bgp->srv6_locator_chunks, node, chunk)) {
9864 vty_out(vty, "- %pFX\n", &chunk->prefix);
9865 vty_out(vty, " block-length: %d\n", chunk->block_bits_length);
9866 vty_out(vty, " node-length: %d\n", chunk->node_bits_length);
9867 vty_out(vty, " func-length: %d\n",
9868 chunk->function_bits_length);
9869 vty_out(vty, " arg-length: %d\n", chunk->argument_bits_length);
9870 }
9871
9872 vty_out(vty, "functions:\n");
9873 for (ALL_LIST_ELEMENTS_RO(bgp->srv6_functions, node, func)) {
9874 inet_ntop(AF_INET6, &func->sid, buf, sizeof(buf));
9875 vty_out(vty, "- sid: %s\n", buf);
9876 vty_out(vty, " locator: %s\n", func->locator_name);
9877 }
9878
9879 vty_out(vty, "bgps:\n");
9880 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp)) {
9881 vty_out(vty, "- name: %s\n",
9882 bgp->name ? bgp->name : "default");
9883
9884 vty_out(vty, " vpn_policy[AFI_IP].tovpn_sid: %pI6\n",
9885 bgp->vpn_policy[AFI_IP].tovpn_sid);
9886 vty_out(vty, " vpn_policy[AFI_IP6].tovpn_sid: %pI6\n",
9887 bgp->vpn_policy[AFI_IP6].tovpn_sid);
9888 vty_out(vty, " per-vrf tovpn_sid: %pI6\n", bgp->tovpn_sid);
9889 }
9890
9891 return CMD_SUCCESS;
9892 }
9893
9894 DEFUN_NOSH (exit_address_family,
9895 exit_address_family_cmd,
9896 "exit-address-family",
9897 "Exit from Address Family configuration mode\n")
9898 {
9899 if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
9900 || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
9901 || vty->node == BGP_IPV6_NODE || vty->node == BGP_IPV6M_NODE
9902 || vty->node == BGP_IPV6L_NODE || vty->node == BGP_VPNV6_NODE
9903 || vty->node == BGP_EVPN_NODE
9904 || vty->node == BGP_FLOWSPECV4_NODE
9905 || vty->node == BGP_FLOWSPECV6_NODE)
9906 vty->node = BGP_NODE;
9907 return CMD_SUCCESS;
9908 }
9909
9910 /* Recalculate bestpath and re-advertise a prefix */
9911 static int bgp_clear_prefix(struct vty *vty, const char *view_name,
9912 const char *ip_str, afi_t afi, safi_t safi,
9913 struct prefix_rd *prd)
9914 {
9915 int ret;
9916 struct prefix match;
9917 struct bgp_dest *dest;
9918 struct bgp_dest *rm;
9919 struct bgp *bgp;
9920 struct bgp_table *table;
9921 struct bgp_table *rib;
9922
9923 /* BGP structure lookup. */
9924 if (view_name) {
9925 bgp = bgp_lookup_by_name(view_name);
9926 if (bgp == NULL) {
9927 vty_out(vty, "%% Can't find BGP instance %s\n",
9928 view_name);
9929 return CMD_WARNING;
9930 }
9931 } else {
9932 bgp = bgp_get_default();
9933 if (bgp == NULL) {
9934 vty_out(vty, "%% No BGP process is configured\n");
9935 return CMD_WARNING;
9936 }
9937 }
9938
9939 /* Check IP address argument. */
9940 ret = str2prefix(ip_str, &match);
9941 if (!ret) {
9942 vty_out(vty, "%% address is malformed\n");
9943 return CMD_WARNING;
9944 }
9945
9946 match.family = afi2family(afi);
9947 rib = bgp->rib[afi][safi];
9948
9949 if (safi == SAFI_MPLS_VPN) {
9950 for (dest = bgp_table_top(rib); dest;
9951 dest = bgp_route_next(dest)) {
9952 const struct prefix *dest_p = bgp_dest_get_prefix(dest);
9953
9954 if (prd && memcmp(dest_p->u.val, prd->val, 8) != 0)
9955 continue;
9956
9957 table = bgp_dest_get_bgp_table_info(dest);
9958 if (table == NULL)
9959 continue;
9960
9961 rm = bgp_node_match(table, &match);
9962 if (rm != NULL) {
9963 const struct prefix *rm_p =
9964 bgp_dest_get_prefix(rm);
9965
9966 if (rm_p->prefixlen == match.prefixlen) {
9967 SET_FLAG(rm->flags,
9968 BGP_NODE_USER_CLEAR);
9969 bgp_process(bgp, rm, afi, safi);
9970 }
9971 bgp_dest_unlock_node(rm);
9972 }
9973 }
9974 } else {
9975 dest = bgp_node_match(rib, &match);
9976 if (dest != NULL) {
9977 const struct prefix *dest_p = bgp_dest_get_prefix(dest);
9978
9979 if (dest_p->prefixlen == match.prefixlen) {
9980 SET_FLAG(dest->flags, BGP_NODE_USER_CLEAR);
9981 bgp_process(bgp, dest, afi, safi);
9982 }
9983 bgp_dest_unlock_node(dest);
9984 }
9985 }
9986
9987 return CMD_SUCCESS;
9988 }
9989
9990 /* one clear bgp command to rule them all */
9991 DEFUN (clear_ip_bgp_all,
9992 clear_ip_bgp_all_cmd,
9993 "clear [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6|l2vpn> [<unicast|multicast|vpn|labeled-unicast|flowspec|evpn>]] <*|A.B.C.D$neighbor|X:X::X:X$neighbor|WORD$neighbor|(1-4294967295)|external|peer-group PGNAME> [<soft [<in|out>]|in [prefix-filter]|out|message-stats>]",
9994 CLEAR_STR
9995 IP_STR
9996 BGP_STR
9997 BGP_INSTANCE_HELP_STR
9998 BGP_AFI_HELP_STR
9999 BGP_AF_STR
10000 BGP_SAFI_WITH_LABEL_HELP_STR
10001 BGP_AF_MODIFIER_STR
10002 "Clear all peers\n"
10003 "BGP IPv4 neighbor to clear\n"
10004 "BGP IPv6 neighbor to clear\n"
10005 "BGP neighbor on interface to clear\n"
10006 "Clear peers with the AS number\n"
10007 "Clear all external peers\n"
10008 "Clear all members of peer-group\n"
10009 "BGP peer-group name\n"
10010 BGP_SOFT_STR
10011 BGP_SOFT_IN_STR
10012 BGP_SOFT_OUT_STR
10013 BGP_SOFT_IN_STR
10014 "Push out prefix-list ORF and do inbound soft reconfig\n"
10015 BGP_SOFT_OUT_STR
10016 "Reset message statistics\n")
10017 {
10018 char *vrf = NULL;
10019
10020 afi_t afi = AFI_UNSPEC;
10021 safi_t safi = SAFI_UNSPEC;
10022 enum clear_sort clr_sort = clear_peer;
10023 enum bgp_clear_type clr_type;
10024 char *clr_arg = NULL;
10025
10026 int idx = 0;
10027
10028 /* clear [ip] bgp */
10029 if (argv_find(argv, argc, "ip", &idx))
10030 afi = AFI_IP;
10031
10032 /* [<vrf> VIEWVRFNAME] */
10033 if (argv_find(argv, argc, "vrf", &idx)) {
10034 vrf = argv[idx + 1]->arg;
10035 idx += 2;
10036 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
10037 vrf = NULL;
10038 } else if (argv_find(argv, argc, "view", &idx)) {
10039 /* [<view> VIEWVRFNAME] */
10040 vrf = argv[idx + 1]->arg;
10041 idx += 2;
10042 }
10043 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
10044 if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
10045 argv_find_and_parse_safi(argv, argc, &idx, &safi);
10046
10047 /* <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group PGNAME> */
10048 if (argv_find(argv, argc, "*", &idx)) {
10049 clr_sort = clear_all;
10050 } else if (argv_find(argv, argc, "A.B.C.D", &idx)) {
10051 clr_sort = clear_peer;
10052 clr_arg = argv[idx]->arg;
10053 } else if (argv_find(argv, argc, "X:X::X:X", &idx)) {
10054 clr_sort = clear_peer;
10055 clr_arg = argv[idx]->arg;
10056 } else if (argv_find(argv, argc, "peer-group", &idx)) {
10057 clr_sort = clear_group;
10058 idx++;
10059 clr_arg = argv[idx]->arg;
10060 } else if (argv_find(argv, argc, "PGNAME", &idx)) {
10061 clr_sort = clear_peer;
10062 clr_arg = argv[idx]->arg;
10063 } else if (argv_find(argv, argc, "WORD", &idx)) {
10064 clr_sort = clear_peer;
10065 clr_arg = argv[idx]->arg;
10066 } else if (argv_find(argv, argc, "(1-4294967295)", &idx)) {
10067 clr_sort = clear_as;
10068 clr_arg = argv[idx]->arg;
10069 } else if (argv_find(argv, argc, "external", &idx)) {
10070 clr_sort = clear_external;
10071 }
10072
10073 /* [<soft [<in|out>]|in [prefix-filter]|out|message-stats>] */
10074 if (argv_find(argv, argc, "soft", &idx)) {
10075 if (argv_find(argv, argc, "in", &idx)
10076 || argv_find(argv, argc, "out", &idx))
10077 clr_type = strmatch(argv[idx]->text, "in")
10078 ? BGP_CLEAR_SOFT_IN
10079 : BGP_CLEAR_SOFT_OUT;
10080 else
10081 clr_type = BGP_CLEAR_SOFT_BOTH;
10082 } else if (argv_find(argv, argc, "in", &idx)) {
10083 clr_type = argv_find(argv, argc, "prefix-filter", &idx)
10084 ? BGP_CLEAR_SOFT_IN_ORF_PREFIX
10085 : BGP_CLEAR_SOFT_IN;
10086 } else if (argv_find(argv, argc, "out", &idx)) {
10087 clr_type = BGP_CLEAR_SOFT_OUT;
10088 } else if (argv_find(argv, argc, "message-stats", &idx)) {
10089 clr_type = BGP_CLEAR_MESSAGE_STATS;
10090 } else
10091 clr_type = BGP_CLEAR_SOFT_NONE;
10092
10093 return bgp_clear_vty(vty, vrf, afi, safi, clr_sort, clr_type, clr_arg);
10094 }
10095
10096 DEFUN (clear_ip_bgp_prefix,
10097 clear_ip_bgp_prefix_cmd,
10098 "clear [ip] bgp [<view|vrf> VIEWVRFNAME] prefix A.B.C.D/M",
10099 CLEAR_STR
10100 IP_STR
10101 BGP_STR
10102 BGP_INSTANCE_HELP_STR
10103 "Clear bestpath and re-advertise\n"
10104 "IPv4 prefix\n")
10105 {
10106 char *vrf = NULL;
10107 char *prefix = NULL;
10108
10109 int idx = 0;
10110
10111 /* [<view|vrf> VIEWVRFNAME] */
10112 if (argv_find(argv, argc, "vrf", &idx)) {
10113 vrf = argv[idx + 1]->arg;
10114 idx += 2;
10115 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
10116 vrf = NULL;
10117 } else if (argv_find(argv, argc, "view", &idx)) {
10118 /* [<view> VIEWVRFNAME] */
10119 vrf = argv[idx + 1]->arg;
10120 idx += 2;
10121 }
10122
10123 prefix = argv[argc - 1]->arg;
10124
10125 return bgp_clear_prefix(vty, vrf, prefix, AFI_IP, SAFI_UNICAST, NULL);
10126 }
10127
10128 DEFUN (clear_bgp_ipv6_safi_prefix,
10129 clear_bgp_ipv6_safi_prefix_cmd,
10130 "clear [ip] bgp ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
10131 CLEAR_STR
10132 IP_STR
10133 BGP_STR
10134 BGP_AF_STR
10135 BGP_SAFI_HELP_STR
10136 "Clear bestpath and re-advertise\n"
10137 "IPv6 prefix\n")
10138 {
10139 int idx_safi = 0;
10140 int idx_ipv6_prefix = 0;
10141 safi_t safi = SAFI_UNICAST;
10142 char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
10143 argv[idx_ipv6_prefix]->arg : NULL;
10144
10145 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
10146 return bgp_clear_prefix(
10147 vty, NULL, prefix, AFI_IP6,
10148 safi, NULL);
10149 }
10150
10151 DEFUN (clear_bgp_instance_ipv6_safi_prefix,
10152 clear_bgp_instance_ipv6_safi_prefix_cmd,
10153 "clear [ip] bgp <view|vrf> VIEWVRFNAME ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
10154 CLEAR_STR
10155 IP_STR
10156 BGP_STR
10157 BGP_INSTANCE_HELP_STR
10158 BGP_AF_STR
10159 BGP_SAFI_HELP_STR
10160 "Clear bestpath and re-advertise\n"
10161 "IPv6 prefix\n")
10162 {
10163 int idx_safi = 0;
10164 int idx_vrfview = 0;
10165 int idx_ipv6_prefix = 0;
10166 safi_t safi = SAFI_UNICAST;
10167 char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
10168 argv[idx_ipv6_prefix]->arg : NULL;
10169 char *vrfview = NULL;
10170
10171 /* [<view|vrf> VIEWVRFNAME] */
10172 if (argv_find(argv, argc, "vrf", &idx_vrfview)) {
10173 vrfview = argv[idx_vrfview + 1]->arg;
10174 if (vrfview && strmatch(vrfview, VRF_DEFAULT_NAME))
10175 vrfview = NULL;
10176 } else if (argv_find(argv, argc, "view", &idx_vrfview)) {
10177 /* [<view> VIEWVRFNAME] */
10178 vrfview = argv[idx_vrfview + 1]->arg;
10179 }
10180 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
10181
10182 return bgp_clear_prefix(
10183 vty, vrfview, prefix,
10184 AFI_IP6, safi, NULL);
10185 }
10186
10187 DEFUN (show_bgp_views,
10188 show_bgp_views_cmd,
10189 "show [ip] bgp views",
10190 SHOW_STR
10191 IP_STR
10192 BGP_STR
10193 "Show the defined BGP views\n")
10194 {
10195 struct list *inst = bm->bgp;
10196 struct listnode *node;
10197 struct bgp *bgp;
10198
10199 vty_out(vty, "Defined BGP views:\n");
10200 for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
10201 /* Skip VRFs. */
10202 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
10203 continue;
10204 vty_out(vty, "\t%s (AS%u)\n", bgp->name ? bgp->name : "(null)",
10205 bgp->as);
10206 }
10207
10208 return CMD_SUCCESS;
10209 }
10210
10211 DEFUN (show_bgp_vrfs,
10212 show_bgp_vrfs_cmd,
10213 "show [ip] bgp vrfs [json]",
10214 SHOW_STR
10215 IP_STR
10216 BGP_STR
10217 "Show BGP VRFs\n"
10218 JSON_STR)
10219 {
10220 char buf[ETHER_ADDR_STRLEN];
10221 struct list *inst = bm->bgp;
10222 struct listnode *node;
10223 struct bgp *bgp;
10224 bool uj = use_json(argc, argv);
10225 json_object *json = NULL;
10226 json_object *json_vrfs = NULL;
10227 int count = 0;
10228
10229 if (uj) {
10230 json = json_object_new_object();
10231 json_vrfs = json_object_new_object();
10232 }
10233
10234 for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
10235 const char *name, *type;
10236 struct peer *peer;
10237 struct listnode *node2, *nnode2;
10238 int peers_cfg, peers_estb;
10239 json_object *json_vrf = NULL;
10240
10241 /* Skip Views. */
10242 if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
10243 continue;
10244
10245 count++;
10246 if (!uj && count == 1) {
10247 vty_out(vty,
10248 "%4s %-5s %-16s %9s %10s %-37s\n",
10249 "Type", "Id", "routerId", "#PeersCfg",
10250 "#PeersEstb", "Name");
10251 vty_out(vty, "%11s %-16s %-21s %-6s\n", " ",
10252 "L3-VNI", "RouterMAC", "Interface");
10253 }
10254
10255 peers_cfg = peers_estb = 0;
10256 if (uj)
10257 json_vrf = json_object_new_object();
10258
10259
10260 for (ALL_LIST_ELEMENTS(bgp->peer, node2, nnode2, peer)) {
10261 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10262 continue;
10263 peers_cfg++;
10264 if (peer_established(peer))
10265 peers_estb++;
10266 }
10267
10268 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
10269 name = VRF_DEFAULT_NAME;
10270 type = "DFLT";
10271 } else {
10272 name = bgp->name;
10273 type = "VRF";
10274 }
10275
10276
10277 if (uj) {
10278 int64_t vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
10279 ? -1
10280 : (int64_t)bgp->vrf_id;
10281 char buf[BUFSIZ] = {0};
10282
10283 json_object_string_add(json_vrf, "type", type);
10284 json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
10285 json_object_string_addf(json_vrf, "routerId", "%pI4",
10286 &bgp->router_id);
10287 json_object_int_add(json_vrf, "numConfiguredPeers",
10288 peers_cfg);
10289 json_object_int_add(json_vrf, "numEstablishedPeers",
10290 peers_estb);
10291
10292 json_object_int_add(json_vrf, "l3vni", bgp->l3vni);
10293 json_object_string_add(
10294 json_vrf, "rmac",
10295 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
10296 json_object_string_add(json_vrf, "interface",
10297 ifindex2ifname(bgp->l3vni_svi_ifindex,
10298 bgp->vrf_id));
10299 json_object_object_add(json_vrfs, name, json_vrf);
10300 } else {
10301 vty_out(vty, "%4s %-5d %-16pI4 %-9u %-10u %-37s\n",
10302 type,
10303 bgp->vrf_id == VRF_UNKNOWN ? -1
10304 : (int)bgp->vrf_id,
10305 &bgp->router_id, peers_cfg, peers_estb, name);
10306 vty_out(vty,"%11s %-16u %-21s %-20s\n", " ",
10307 bgp->l3vni,
10308 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)),
10309 ifindex2ifname(bgp->l3vni_svi_ifindex,
10310 bgp->vrf_id));
10311 }
10312 }
10313
10314 if (uj) {
10315 json_object_object_add(json, "vrfs", json_vrfs);
10316
10317 json_object_int_add(json, "totalVrfs", count);
10318
10319 vty_json(vty, json);
10320 } else {
10321 if (count)
10322 vty_out(vty,
10323 "\nTotal number of VRFs (including default): %d\n",
10324 count);
10325 }
10326
10327 return CMD_SUCCESS;
10328 }
10329
10330 DEFUN (show_bgp_mac_hash,
10331 show_bgp_mac_hash_cmd,
10332 "show bgp mac hash",
10333 SHOW_STR
10334 BGP_STR
10335 "Mac Address\n"
10336 "Mac Address database\n")
10337 {
10338 bgp_mac_dump_table(vty);
10339
10340 return CMD_SUCCESS;
10341 }
10342
10343 static void show_tip_entry(struct hash_bucket *bucket, void *args)
10344 {
10345 struct vty *vty = (struct vty *)args;
10346 struct tip_addr *tip = (struct tip_addr *)bucket->data;
10347
10348 vty_out(vty, "addr: %pI4, count: %d\n", &tip->addr, tip->refcnt);
10349 }
10350
10351 static void bgp_show_martian_nexthops(struct vty *vty, struct bgp *bgp)
10352 {
10353 vty_out(vty, "self nexthop database:\n");
10354 bgp_nexthop_show_address_hash(vty, bgp);
10355
10356 vty_out(vty, "Tunnel-ip database:\n");
10357 hash_iterate(bgp->tip_hash,
10358 (void (*)(struct hash_bucket *, void *))show_tip_entry,
10359 vty);
10360 }
10361
10362 DEFUN(show_bgp_martian_nexthop_db, show_bgp_martian_nexthop_db_cmd,
10363 "show bgp [<view|vrf> VIEWVRFNAME] martian next-hop",
10364 SHOW_STR BGP_STR BGP_INSTANCE_HELP_STR
10365 "martian next-hops\n"
10366 "martian next-hop database\n")
10367 {
10368 struct bgp *bgp = NULL;
10369 int idx = 0;
10370 char *name = NULL;
10371
10372 /* [<vrf> VIEWVRFNAME] */
10373 if (argv_find(argv, argc, "vrf", &idx)) {
10374 name = argv[idx + 1]->arg;
10375 if (name && strmatch(name, VRF_DEFAULT_NAME))
10376 name = NULL;
10377 } else if (argv_find(argv, argc, "view", &idx))
10378 /* [<view> VIEWVRFNAME] */
10379 name = argv[idx + 1]->arg;
10380 if (name)
10381 bgp = bgp_lookup_by_name(name);
10382 else
10383 bgp = bgp_get_default();
10384
10385 if (!bgp) {
10386 vty_out(vty, "%% No BGP process is configured\n");
10387 return CMD_WARNING;
10388 }
10389 bgp_show_martian_nexthops(vty, bgp);
10390
10391 return CMD_SUCCESS;
10392 }
10393
10394 DEFUN (show_bgp_memory,
10395 show_bgp_memory_cmd,
10396 "show [ip] bgp memory",
10397 SHOW_STR
10398 IP_STR
10399 BGP_STR
10400 "Global BGP memory statistics\n")
10401 {
10402 char memstrbuf[MTYPE_MEMSTR_LEN];
10403 unsigned long count;
10404
10405 /* RIB related usage stats */
10406 count = mtype_stats_alloc(MTYPE_BGP_NODE);
10407 vty_out(vty, "%ld RIB nodes, using %s of memory\n", count,
10408 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10409 count * sizeof(struct bgp_dest)));
10410
10411 count = mtype_stats_alloc(MTYPE_BGP_ROUTE);
10412 vty_out(vty, "%ld BGP routes, using %s of memory\n", count,
10413 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10414 count * sizeof(struct bgp_path_info)));
10415 if ((count = mtype_stats_alloc(MTYPE_BGP_ROUTE_EXTRA)))
10416 vty_out(vty, "%ld BGP route ancillaries, using %s of memory\n",
10417 count,
10418 mtype_memstr(
10419 memstrbuf, sizeof(memstrbuf),
10420 count * sizeof(struct bgp_path_info_extra)));
10421
10422 if ((count = mtype_stats_alloc(MTYPE_BGP_STATIC)))
10423 vty_out(vty, "%ld Static routes, using %s of memory\n", count,
10424 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10425 count * sizeof(struct bgp_static)));
10426
10427 if ((count = mtype_stats_alloc(MTYPE_BGP_PACKET)))
10428 vty_out(vty, "%ld Packets, using %s of memory\n", count,
10429 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10430 count * sizeof(struct bpacket)));
10431
10432 /* Adj-In/Out */
10433 if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_IN)))
10434 vty_out(vty, "%ld Adj-In entries, using %s of memory\n", count,
10435 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10436 count * sizeof(struct bgp_adj_in)));
10437 if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_OUT)))
10438 vty_out(vty, "%ld Adj-Out entries, using %s of memory\n", count,
10439 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10440 count * sizeof(struct bgp_adj_out)));
10441
10442 if ((count = mtype_stats_alloc(MTYPE_BGP_NEXTHOP_CACHE)))
10443 vty_out(vty, "%ld Nexthop cache entries, using %s of memory\n",
10444 count,
10445 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10446 count * sizeof(struct bgp_nexthop_cache)));
10447
10448 if ((count = mtype_stats_alloc(MTYPE_BGP_DAMP_INFO)))
10449 vty_out(vty, "%ld Dampening entries, using %s of memory\n",
10450 count,
10451 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10452 count * sizeof(struct bgp_damp_info)));
10453
10454 /* Attributes */
10455 count = attr_count();
10456 vty_out(vty, "%ld BGP attributes, using %s of memory\n", count,
10457 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10458 count * sizeof(struct attr)));
10459
10460 if ((count = attr_unknown_count()))
10461 vty_out(vty, "%ld unknown attributes\n", count);
10462
10463 /* AS_PATH attributes */
10464 count = aspath_count();
10465 vty_out(vty, "%ld BGP AS-PATH entries, using %s of memory\n", count,
10466 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10467 count * sizeof(struct aspath)));
10468
10469 count = mtype_stats_alloc(MTYPE_AS_SEG);
10470 vty_out(vty, "%ld BGP AS-PATH segments, using %s of memory\n", count,
10471 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10472 count * sizeof(struct assegment)));
10473
10474 /* Other attributes */
10475 if ((count = community_count()))
10476 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
10477 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10478 count * sizeof(struct community)));
10479 if ((count = mtype_stats_alloc(MTYPE_ECOMMUNITY)))
10480 vty_out(vty,
10481 "%ld BGP ext-community entries, using %s of memory\n",
10482 count,
10483 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10484 count * sizeof(struct ecommunity)));
10485 if ((count = mtype_stats_alloc(MTYPE_LCOMMUNITY)))
10486 vty_out(vty,
10487 "%ld BGP large-community entries, using %s of memory\n",
10488 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10489 count * sizeof(struct lcommunity)));
10490
10491 if ((count = mtype_stats_alloc(MTYPE_CLUSTER)))
10492 vty_out(vty, "%ld Cluster lists, using %s of memory\n", count,
10493 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10494 count * sizeof(struct cluster_list)));
10495
10496 /* Peer related usage */
10497 count = mtype_stats_alloc(MTYPE_BGP_PEER);
10498 vty_out(vty, "%ld peers, using %s of memory\n", count,
10499 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10500 count * sizeof(struct peer)));
10501
10502 if ((count = mtype_stats_alloc(MTYPE_PEER_GROUP)))
10503 vty_out(vty, "%ld peer groups, using %s of memory\n", count,
10504 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10505 count * sizeof(struct peer_group)));
10506
10507 /* Other */
10508 if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
10509 vty_out(vty, "%ld compiled regexes, using %s of memory\n",
10510 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10511 count * sizeof(regex_t)));
10512 return CMD_SUCCESS;
10513 }
10514
10515 static void bgp_show_bestpath_json(struct bgp *bgp, json_object *json)
10516 {
10517 json_object *bestpath = json_object_new_object();
10518
10519 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE))
10520 json_object_string_add(bestpath, "asPath", "ignore");
10521
10522 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED))
10523 json_object_string_add(bestpath, "asPath", "confed");
10524
10525 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
10526 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET))
10527 json_object_string_add(bestpath, "multiPathRelax",
10528 "as-set");
10529 else
10530 json_object_string_add(bestpath, "multiPathRelax",
10531 "true");
10532 } else
10533 json_object_string_add(bestpath, "multiPathRelax", "false");
10534
10535 if (CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
10536 json_object_boolean_true_add(bestpath, "peerTypeRelax");
10537
10538 if (CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID))
10539 json_object_string_add(bestpath, "compareRouterId", "true");
10540 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED)
10541 || CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST)) {
10542 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED))
10543 json_object_string_add(bestpath, "med", "confed");
10544 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST))
10545 json_object_string_add(bestpath, "med",
10546 "missing-as-worst");
10547 else
10548 json_object_string_add(bestpath, "med", "true");
10549 }
10550
10551 json_object_object_add(json, "bestPath", bestpath);
10552 }
10553
10554 /* Print the error code/subcode for why the peer is down */
10555 static void bgp_show_peer_reset(struct vty * vty, struct peer *peer,
10556 json_object *json_peer, bool use_json)
10557 {
10558 const char *code_str;
10559 const char *subcode_str;
10560
10561 if (use_json) {
10562 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND
10563 || peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10564 char errorcodesubcode_hexstr[5];
10565 char errorcodesubcode_str[256];
10566
10567 code_str = bgp_notify_code_str(peer->notify.code);
10568 subcode_str = bgp_notify_subcode_str(
10569 peer->notify.code,
10570 peer->notify.subcode);
10571
10572 snprintf(errorcodesubcode_hexstr,
10573 sizeof(errorcodesubcode_hexstr), "%02X%02X",
10574 peer->notify.code, peer->notify.subcode);
10575 json_object_string_add(json_peer,
10576 "lastErrorCodeSubcode",
10577 errorcodesubcode_hexstr);
10578 snprintf(errorcodesubcode_str, 255, "%s%s",
10579 code_str, subcode_str);
10580 json_object_string_add(json_peer,
10581 "lastNotificationReason",
10582 errorcodesubcode_str);
10583 json_object_boolean_add(json_peer,
10584 "lastNotificationHardReset",
10585 peer->notify.hard_reset);
10586 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10587 && peer->notify.code == BGP_NOTIFY_CEASE
10588 && (peer->notify.subcode
10589 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10590 || peer->notify.subcode
10591 == BGP_NOTIFY_CEASE_ADMIN_RESET)
10592 && peer->notify.length) {
10593 char msgbuf[1024];
10594 const char *msg_str;
10595
10596 msg_str = bgp_notify_admin_message(
10597 msgbuf, sizeof(msgbuf),
10598 (uint8_t *)peer->notify.data,
10599 peer->notify.length);
10600 if (msg_str)
10601 json_object_string_add(
10602 json_peer,
10603 "lastShutdownDescription",
10604 msg_str);
10605 }
10606
10607 }
10608 json_object_string_add(json_peer, "lastResetDueTo",
10609 peer_down_str[(int)peer->last_reset]);
10610 json_object_int_add(json_peer, "lastResetCode",
10611 peer->last_reset);
10612 } else {
10613 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND
10614 || peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10615 code_str = bgp_notify_code_str(peer->notify.code);
10616 subcode_str =
10617 bgp_notify_subcode_str(peer->notify.code,
10618 peer->notify.subcode);
10619 vty_out(vty, " Notification %s (%s%s%s)\n",
10620 peer->last_reset == PEER_DOWN_NOTIFY_SEND
10621 ? "sent"
10622 : "received",
10623 code_str, subcode_str,
10624 peer->notify.hard_reset
10625 ? bgp_notify_subcode_str(
10626 BGP_NOTIFY_CEASE,
10627 BGP_NOTIFY_CEASE_HARD_RESET)
10628 : "");
10629 } else {
10630 vty_out(vty, " %s\n",
10631 peer_down_str[(int)peer->last_reset]);
10632 }
10633 }
10634 }
10635
10636 static inline bool bgp_has_peer_failed(struct peer *peer, afi_t afi,
10637 safi_t safi)
10638 {
10639 return ((!peer_established(peer)) || !peer->afc_recv[afi][safi]);
10640 }
10641
10642 static void bgp_show_failed_summary(struct vty *vty, struct bgp *bgp,
10643 struct peer *peer, json_object *json_peer,
10644 int max_neighbor_width, bool use_json)
10645 {
10646 char timebuf[BGP_UPTIME_LEN], dn_flag[2];
10647 int len;
10648
10649 if (use_json) {
10650 if (peer_dynamic_neighbor(peer))
10651 json_object_boolean_true_add(json_peer,
10652 "dynamicPeer");
10653 if (peer->hostname)
10654 json_object_string_add(json_peer, "hostname",
10655 peer->hostname);
10656
10657 if (peer->domainname)
10658 json_object_string_add(json_peer, "domainname",
10659 peer->domainname);
10660 json_object_int_add(json_peer, "connectionsEstablished",
10661 peer->established);
10662 json_object_int_add(json_peer, "connectionsDropped",
10663 peer->dropped);
10664 peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
10665 use_json, json_peer);
10666 if (peer_established(peer))
10667 json_object_string_add(json_peer, "lastResetDueTo",
10668 "AFI/SAFI Not Negotiated");
10669 else
10670 bgp_show_peer_reset(NULL, peer, json_peer, true);
10671 } else {
10672 dn_flag[1] = '\0';
10673 dn_flag[0] = peer_dynamic_neighbor(peer) ? '*' : '\0';
10674 if (peer->hostname
10675 && CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME))
10676 len = vty_out(vty, "%s%s(%s)", dn_flag,
10677 peer->hostname, peer->host);
10678 else
10679 len = vty_out(vty, "%s%s", dn_flag, peer->host);
10680
10681 /* pad the neighbor column with spaces */
10682 if (len < max_neighbor_width)
10683 vty_out(vty, "%*s", max_neighbor_width - len,
10684 " ");
10685 vty_out(vty, "%7d %7d %9s", peer->established,
10686 peer->dropped,
10687 peer_uptime(peer->uptime, timebuf,
10688 BGP_UPTIME_LEN, 0, NULL));
10689 if (peer_established(peer))
10690 vty_out(vty, " AFI/SAFI Not Negotiated\n");
10691 else
10692 bgp_show_peer_reset(vty, peer, NULL,
10693 false);
10694 }
10695 }
10696
10697 /* Strip peer's description to the given size. */
10698 static char *bgp_peer_description_stripped(char *desc, uint32_t size)
10699 {
10700 static char stripped[BUFSIZ];
10701 uint32_t i = 0;
10702 uint32_t last_space = 0;
10703
10704 while (i < size) {
10705 if (*(desc + i) == 0) {
10706 stripped[i] = '\0';
10707 return stripped;
10708 }
10709 if (i != 0 && *(desc + i) == ' ' && last_space != i - 1)
10710 last_space = i;
10711 stripped[i] = *(desc + i);
10712 i++;
10713 }
10714
10715 if (last_space > size)
10716 stripped[size + 1] = '\0';
10717 else
10718 stripped[last_space] = '\0';
10719
10720 return stripped;
10721 }
10722
10723 /* Determine whether var peer should be filtered out of the summary. */
10724 static bool bgp_show_summary_is_peer_filtered(struct peer *peer,
10725 struct peer *fpeer, int as_type,
10726 as_t as)
10727 {
10728
10729 /* filter neighbor XXXX */
10730 if (fpeer && fpeer != peer)
10731 return true;
10732
10733 /* filter remote-as (internal|external) */
10734 if (as_type != AS_UNSPECIFIED) {
10735 if (peer->as_type == AS_SPECIFIED) {
10736 if (as_type == AS_INTERNAL) {
10737 if (peer->as != peer->local_as)
10738 return true;
10739 } else if (peer->as == peer->local_as)
10740 return true;
10741 } else if (as_type != peer->as_type)
10742 return true;
10743 } else if (as && as != peer->as) /* filter remote-as XXX */
10744 return true;
10745
10746 return false;
10747 }
10748
10749 /* Show BGP peer's summary information.
10750 *
10751 * Peer's description is stripped according to if `wide` option is given
10752 * or not.
10753 *
10754 * When adding new columns to `show bgp summary` output, please make
10755 * sure `Desc` is the lastest column to show because it can contain
10756 * whitespaces and the whole output will be tricky.
10757 */
10758 static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
10759 struct peer *fpeer, int as_type, as_t as,
10760 uint16_t show_flags)
10761 {
10762 struct peer *peer;
10763 struct listnode *node, *nnode;
10764 unsigned int count = 0, dn_count = 0;
10765 char timebuf[BGP_UPTIME_LEN], dn_flag[2];
10766 char neighbor_buf[VTY_BUFSIZ];
10767 int neighbor_col_default_width = 16;
10768 int len, failed_count = 0;
10769 unsigned int filtered_count = 0;
10770 int max_neighbor_width = 0;
10771 int pfx_rcd_safi;
10772 json_object *json = NULL;
10773 json_object *json_peer = NULL;
10774 json_object *json_peers = NULL;
10775 struct peer_af *paf;
10776 struct bgp_filter *filter;
10777 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
10778 bool show_failed = CHECK_FLAG(show_flags, BGP_SHOW_OPT_FAILED);
10779 bool show_established =
10780 CHECK_FLAG(show_flags, BGP_SHOW_OPT_ESTABLISHED);
10781 bool show_wide = CHECK_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
10782 bool show_terse = CHECK_FLAG(show_flags, BGP_SHOW_OPT_TERSE);
10783
10784 /* labeled-unicast routes are installed in the unicast table so in order
10785 * to
10786 * display the correct PfxRcd value we must look at SAFI_UNICAST
10787 */
10788
10789 if (safi == SAFI_LABELED_UNICAST)
10790 pfx_rcd_safi = SAFI_UNICAST;
10791 else
10792 pfx_rcd_safi = safi;
10793
10794 if (use_json) {
10795 json = json_object_new_object();
10796 json_peers = json_object_new_object();
10797 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
10798 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
10799 as_type, as)) {
10800 filtered_count++;
10801 count++;
10802 continue;
10803 }
10804
10805 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10806 continue;
10807
10808 if (peer->afc[afi][safi]) {
10809 /* See if we have at least a single failed peer */
10810 if (bgp_has_peer_failed(peer, afi, safi))
10811 failed_count++;
10812 count++;
10813 }
10814 if (peer_dynamic_neighbor(peer))
10815 dn_count++;
10816 }
10817
10818 } else {
10819 /* Loop over all neighbors that will be displayed to determine
10820 * how many
10821 * characters are needed for the Neighbor column
10822 */
10823 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
10824 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
10825 as_type, as)) {
10826 filtered_count++;
10827 count++;
10828 continue;
10829 }
10830
10831 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10832 continue;
10833
10834 if (peer->afc[afi][safi]) {
10835 memset(dn_flag, '\0', sizeof(dn_flag));
10836 if (peer_dynamic_neighbor(peer))
10837 dn_flag[0] = '*';
10838
10839 if (peer->hostname
10840 && CHECK_FLAG(bgp->flags,
10841 BGP_FLAG_SHOW_HOSTNAME))
10842 snprintf(neighbor_buf,
10843 sizeof(neighbor_buf),
10844 "%s%s(%s) ", dn_flag,
10845 peer->hostname, peer->host);
10846 else
10847 snprintf(neighbor_buf,
10848 sizeof(neighbor_buf), "%s%s ",
10849 dn_flag, peer->host);
10850
10851 len = strlen(neighbor_buf);
10852
10853 if (len > max_neighbor_width)
10854 max_neighbor_width = len;
10855
10856 /* See if we have at least a single failed peer */
10857 if (bgp_has_peer_failed(peer, afi, safi))
10858 failed_count++;
10859 count++;
10860 }
10861 }
10862
10863 /* Originally we displayed the Neighbor column as 16
10864 * characters wide so make that the default
10865 */
10866 if (max_neighbor_width < neighbor_col_default_width)
10867 max_neighbor_width = neighbor_col_default_width;
10868 }
10869
10870 if (show_failed && !failed_count) {
10871 if (use_json) {
10872 json_object_int_add(json, "failedPeersCount", 0);
10873 json_object_int_add(json, "dynamicPeers", dn_count);
10874 json_object_int_add(json, "totalPeers", count);
10875
10876 vty_json(vty, json);
10877 } else {
10878 vty_out(vty, "%% No failed BGP neighbors found\n");
10879 }
10880 return CMD_SUCCESS;
10881 }
10882
10883 count = 0; /* Reset the value as its used again */
10884 filtered_count = 0;
10885 dn_count = 0;
10886 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
10887 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10888 continue;
10889
10890 if (!peer->afc[afi][safi])
10891 continue;
10892
10893 if (!count) {
10894 unsigned long ents;
10895 char memstrbuf[MTYPE_MEMSTR_LEN];
10896 int64_t vrf_id_ui;
10897
10898 vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
10899 ? -1
10900 : (int64_t)bgp->vrf_id;
10901
10902 /* Usage summary and header */
10903 if (use_json) {
10904 json_object_string_addf(json, "routerId",
10905 "%pI4",
10906 &bgp->router_id);
10907 json_object_int_add(json, "as", bgp->as);
10908 json_object_int_add(json, "vrfId", vrf_id_ui);
10909 json_object_string_add(
10910 json, "vrfName",
10911 (bgp->inst_type
10912 == BGP_INSTANCE_TYPE_DEFAULT)
10913 ? VRF_DEFAULT_NAME
10914 : bgp->name);
10915 } else {
10916 vty_out(vty,
10917 "BGP router identifier %pI4, local AS number %u vrf-id %d",
10918 &bgp->router_id, bgp->as,
10919 bgp->vrf_id == VRF_UNKNOWN
10920 ? -1
10921 : (int)bgp->vrf_id);
10922 vty_out(vty, "\n");
10923 }
10924
10925 if (bgp_update_delay_configured(bgp)) {
10926 if (use_json) {
10927 json_object_int_add(
10928 json, "updateDelayLimit",
10929 bgp->v_update_delay);
10930
10931 if (bgp->v_update_delay
10932 != bgp->v_establish_wait)
10933 json_object_int_add(
10934 json,
10935 "updateDelayEstablishWait",
10936 bgp->v_establish_wait);
10937
10938 if (bgp_update_delay_active(bgp)) {
10939 json_object_string_add(
10940 json,
10941 "updateDelayFirstNeighbor",
10942 bgp->update_delay_begin_time);
10943 json_object_boolean_true_add(
10944 json,
10945 "updateDelayInProgress");
10946 } else {
10947 if (bgp->update_delay_over) {
10948 json_object_string_add(
10949 json,
10950 "updateDelayFirstNeighbor",
10951 bgp->update_delay_begin_time);
10952 json_object_string_add(
10953 json,
10954 "updateDelayBestpathResumed",
10955 bgp->update_delay_end_time);
10956 json_object_string_add(
10957 json,
10958 "updateDelayZebraUpdateResume",
10959 bgp->update_delay_zebra_resume_time);
10960 json_object_string_add(
10961 json,
10962 "updateDelayPeerUpdateResume",
10963 bgp->update_delay_peers_resume_time);
10964 }
10965 }
10966 } else {
10967 vty_out(vty,
10968 "Read-only mode update-delay limit: %d seconds\n",
10969 bgp->v_update_delay);
10970 if (bgp->v_update_delay
10971 != bgp->v_establish_wait)
10972 vty_out(vty,
10973 " Establish wait: %d seconds\n",
10974 bgp->v_establish_wait);
10975
10976 if (bgp_update_delay_active(bgp)) {
10977 vty_out(vty,
10978 " First neighbor established: %s\n",
10979 bgp->update_delay_begin_time);
10980 vty_out(vty,
10981 " Delay in progress\n");
10982 } else {
10983 if (bgp->update_delay_over) {
10984 vty_out(vty,
10985 " First neighbor established: %s\n",
10986 bgp->update_delay_begin_time);
10987 vty_out(vty,
10988 " Best-paths resumed: %s\n",
10989 bgp->update_delay_end_time);
10990 vty_out(vty,
10991 " zebra update resumed: %s\n",
10992 bgp->update_delay_zebra_resume_time);
10993 vty_out(vty,
10994 " peers update resumed: %s\n",
10995 bgp->update_delay_peers_resume_time);
10996 }
10997 }
10998 }
10999 }
11000
11001 if (use_json) {
11002 if (bgp_maxmed_onstartup_configured(bgp)
11003 && bgp->maxmed_active)
11004 json_object_boolean_true_add(
11005 json, "maxMedOnStartup");
11006 if (bgp->v_maxmed_admin)
11007 json_object_boolean_true_add(
11008 json, "maxMedAdministrative");
11009
11010 json_object_int_add(
11011 json, "tableVersion",
11012 bgp_table_version(bgp->rib[afi][safi]));
11013
11014 ents = bgp_table_count(bgp->rib[afi][safi]);
11015 json_object_int_add(json, "ribCount", ents);
11016 json_object_int_add(
11017 json, "ribMemory",
11018 ents * sizeof(struct bgp_dest));
11019
11020 ents = bgp->af_peer_count[afi][safi];
11021 json_object_int_add(json, "peerCount", ents);
11022 json_object_int_add(json, "peerMemory",
11023 ents * sizeof(struct peer));
11024
11025 if ((ents = listcount(bgp->group))) {
11026 json_object_int_add(
11027 json, "peerGroupCount", ents);
11028 json_object_int_add(
11029 json, "peerGroupMemory",
11030 ents * sizeof(struct
11031 peer_group));
11032 }
11033
11034 if (CHECK_FLAG(bgp->af_flags[afi][safi],
11035 BGP_CONFIG_DAMPENING))
11036 json_object_boolean_true_add(
11037 json, "dampeningEnabled");
11038 } else {
11039 if (!show_terse) {
11040 if (bgp_maxmed_onstartup_configured(bgp)
11041 && bgp->maxmed_active)
11042 vty_out(vty,
11043 "Max-med on-startup active\n");
11044 if (bgp->v_maxmed_admin)
11045 vty_out(vty,
11046 "Max-med administrative active\n");
11047
11048 vty_out(vty,
11049 "BGP table version %" PRIu64
11050 "\n",
11051 bgp_table_version(
11052 bgp->rib[afi][safi]));
11053
11054 ents = bgp_table_count(
11055 bgp->rib[afi][safi]);
11056 vty_out(vty,
11057 "RIB entries %ld, using %s of memory\n",
11058 ents,
11059 mtype_memstr(
11060 memstrbuf,
11061 sizeof(memstrbuf),
11062 ents
11063 * sizeof(
11064 struct
11065 bgp_dest)));
11066
11067 /* Peer related usage */
11068 ents = bgp->af_peer_count[afi][safi];
11069 vty_out(vty,
11070 "Peers %ld, using %s of memory\n",
11071 ents,
11072 mtype_memstr(
11073 memstrbuf,
11074 sizeof(memstrbuf),
11075 ents
11076 * sizeof(
11077 struct
11078 peer)));
11079
11080 if ((ents = listcount(bgp->group)))
11081 vty_out(vty,
11082 "Peer groups %ld, using %s of memory\n",
11083 ents,
11084 mtype_memstr(
11085 memstrbuf,
11086 sizeof(memstrbuf),
11087 ents
11088 * sizeof(
11089 struct
11090 peer_group)));
11091
11092 if (CHECK_FLAG(bgp->af_flags[afi][safi],
11093 BGP_CONFIG_DAMPENING))
11094 vty_out(vty,
11095 "Dampening enabled.\n");
11096 }
11097 if (show_failed) {
11098 vty_out(vty, "\n");
11099
11100 /* Subtract 8 here because 'Neighbor' is
11101 * 8 characters */
11102 vty_out(vty, "Neighbor");
11103 vty_out(vty, "%*s",
11104 max_neighbor_width - 8, " ");
11105 vty_out(vty,
11106 BGP_SHOW_SUMMARY_HEADER_FAILED);
11107 }
11108 }
11109 }
11110
11111 paf = peer_af_find(peer, afi, safi);
11112 filter = &peer->filter[afi][safi];
11113
11114 count++;
11115 /* Works for both failed & successful cases */
11116 if (peer_dynamic_neighbor(peer))
11117 dn_count++;
11118
11119 if (use_json) {
11120 json_peer = NULL;
11121 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11122 as_type, as)) {
11123 filtered_count++;
11124 continue;
11125 }
11126 if (show_failed &&
11127 bgp_has_peer_failed(peer, afi, safi)) {
11128 json_peer = json_object_new_object();
11129 bgp_show_failed_summary(vty, bgp, peer,
11130 json_peer, 0, use_json);
11131 } else if (!show_failed) {
11132 if (show_established
11133 && bgp_has_peer_failed(peer, afi, safi)) {
11134 filtered_count++;
11135 continue;
11136 }
11137
11138 json_peer = json_object_new_object();
11139 if (peer_dynamic_neighbor(peer)) {
11140 json_object_boolean_true_add(json_peer,
11141 "dynamicPeer");
11142 }
11143
11144 if (peer->hostname)
11145 json_object_string_add(json_peer, "hostname",
11146 peer->hostname);
11147
11148 if (peer->domainname)
11149 json_object_string_add(json_peer, "domainname",
11150 peer->domainname);
11151
11152 json_object_int_add(json_peer, "remoteAs", peer->as);
11153 json_object_int_add(
11154 json_peer, "localAs",
11155 peer->change_local_as
11156 ? peer->change_local_as
11157 : peer->local_as);
11158 json_object_int_add(json_peer, "version", 4);
11159 json_object_int_add(json_peer, "msgRcvd",
11160 PEER_TOTAL_RX(peer));
11161 json_object_int_add(json_peer, "msgSent",
11162 PEER_TOTAL_TX(peer));
11163
11164 atomic_size_t outq_count, inq_count;
11165 outq_count = atomic_load_explicit(
11166 &peer->obuf->count,
11167 memory_order_relaxed);
11168 inq_count = atomic_load_explicit(
11169 &peer->ibuf->count,
11170 memory_order_relaxed);
11171
11172 json_object_int_add(json_peer, "tableVersion",
11173 peer->version[afi][safi]);
11174 json_object_int_add(json_peer, "outq",
11175 outq_count);
11176 json_object_int_add(json_peer, "inq",
11177 inq_count);
11178 peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
11179 use_json, json_peer);
11180
11181 json_object_int_add(json_peer, "pfxRcd",
11182 peer->pcount[afi][pfx_rcd_safi]);
11183
11184 if (paf && PAF_SUBGRP(paf))
11185 json_object_int_add(
11186 json_peer, "pfxSnt",
11187 (PAF_SUBGRP(paf))->scount);
11188 else
11189 json_object_int_add(json_peer, "pfxSnt",
11190 0);
11191
11192 /* BGP FSM state */
11193 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
11194 || CHECK_FLAG(peer->bgp->flags,
11195 BGP_FLAG_SHUTDOWN))
11196 json_object_string_add(json_peer,
11197 "state",
11198 "Idle (Admin)");
11199 else if (peer->afc_recv[afi][safi])
11200 json_object_string_add(
11201 json_peer, "state",
11202 lookup_msg(bgp_status_msg,
11203 peer->status, NULL));
11204 else if (CHECK_FLAG(
11205 peer->sflags,
11206 PEER_STATUS_PREFIX_OVERFLOW))
11207 json_object_string_add(json_peer,
11208 "state",
11209 "Idle (PfxCt)");
11210 else
11211 json_object_string_add(
11212 json_peer, "state",
11213 lookup_msg(bgp_status_msg,
11214 peer->status, NULL));
11215
11216 /* BGP peer state */
11217 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
11218 || CHECK_FLAG(peer->bgp->flags,
11219 BGP_FLAG_SHUTDOWN))
11220 json_object_string_add(json_peer,
11221 "peerState",
11222 "Admin");
11223 else if (CHECK_FLAG(
11224 peer->sflags,
11225 PEER_STATUS_PREFIX_OVERFLOW))
11226 json_object_string_add(json_peer,
11227 "peerState",
11228 "PfxCt");
11229 else if (CHECK_FLAG(peer->flags,
11230 PEER_FLAG_PASSIVE))
11231 json_object_string_add(json_peer,
11232 "peerState",
11233 "Passive");
11234 else if (CHECK_FLAG(peer->sflags,
11235 PEER_STATUS_NSF_WAIT))
11236 json_object_string_add(json_peer,
11237 "peerState",
11238 "NSF passive");
11239 else if (CHECK_FLAG(
11240 peer->bgp->flags,
11241 BGP_FLAG_EBGP_REQUIRES_POLICY)
11242 && (!bgp_inbound_policy_exists(peer,
11243 filter)
11244 || !bgp_outbound_policy_exists(
11245 peer, filter)))
11246 json_object_string_add(json_peer,
11247 "peerState",
11248 "Policy");
11249 else
11250 json_object_string_add(
11251 json_peer, "peerState", "OK");
11252
11253 json_object_int_add(json_peer, "connectionsEstablished",
11254 peer->established);
11255 json_object_int_add(json_peer, "connectionsDropped",
11256 peer->dropped);
11257 if (peer->desc)
11258 json_object_string_add(
11259 json_peer, "desc", peer->desc);
11260 }
11261 /* Avoid creating empty peer dicts in JSON */
11262 if (json_peer == NULL)
11263 continue;
11264
11265 if (peer->conf_if)
11266 json_object_string_add(json_peer, "idType",
11267 "interface");
11268 else if (peer->su.sa.sa_family == AF_INET)
11269 json_object_string_add(json_peer, "idType",
11270 "ipv4");
11271 else if (peer->su.sa.sa_family == AF_INET6)
11272 json_object_string_add(json_peer, "idType",
11273 "ipv6");
11274 json_object_object_add(json_peers, peer->host,
11275 json_peer);
11276 } else {
11277 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11278 as_type, as)) {
11279 filtered_count++;
11280 continue;
11281 }
11282 if (show_failed &&
11283 bgp_has_peer_failed(peer, afi, safi)) {
11284 bgp_show_failed_summary(vty, bgp, peer, NULL,
11285 max_neighbor_width,
11286 use_json);
11287 } else if (!show_failed) {
11288 if (show_established
11289 && bgp_has_peer_failed(peer, afi, safi)) {
11290 filtered_count++;
11291 continue;
11292 }
11293
11294 if ((count - filtered_count) == 1) {
11295 /* display headline before the first
11296 * neighbor line */
11297 vty_out(vty, "\n");
11298
11299 /* Subtract 8 here because 'Neighbor' is
11300 * 8 characters */
11301 vty_out(vty, "Neighbor");
11302 vty_out(vty, "%*s",
11303 max_neighbor_width - 8, " ");
11304 vty_out(vty,
11305 show_wide
11306 ? BGP_SHOW_SUMMARY_HEADER_ALL_WIDE
11307 : BGP_SHOW_SUMMARY_HEADER_ALL);
11308 }
11309
11310 memset(dn_flag, '\0', sizeof(dn_flag));
11311 if (peer_dynamic_neighbor(peer)) {
11312 dn_flag[0] = '*';
11313 }
11314
11315 if (peer->hostname
11316 && CHECK_FLAG(bgp->flags,
11317 BGP_FLAG_SHOW_HOSTNAME))
11318 len = vty_out(vty, "%s%s(%s)", dn_flag,
11319 peer->hostname,
11320 peer->host);
11321 else
11322 len = vty_out(vty, "%s%s", dn_flag, peer->host);
11323
11324 /* pad the neighbor column with spaces */
11325 if (len < max_neighbor_width)
11326 vty_out(vty, "%*s", max_neighbor_width - len,
11327 " ");
11328
11329 atomic_size_t outq_count, inq_count;
11330 outq_count = atomic_load_explicit(
11331 &peer->obuf->count,
11332 memory_order_relaxed);
11333 inq_count = atomic_load_explicit(
11334 &peer->ibuf->count,
11335 memory_order_relaxed);
11336
11337 if (show_wide)
11338 vty_out(vty,
11339 "4 %10u %10u %9u %9u %8" PRIu64
11340 " %4zu %4zu %8s",
11341 peer->as,
11342 peer->change_local_as
11343 ? peer->change_local_as
11344 : peer->local_as,
11345 PEER_TOTAL_RX(peer),
11346 PEER_TOTAL_TX(peer),
11347 peer->version[afi][safi],
11348 inq_count, outq_count,
11349 peer_uptime(peer->uptime,
11350 timebuf,
11351 BGP_UPTIME_LEN, 0,
11352 NULL));
11353 else
11354 vty_out(vty, "4 %10u %9u %9u %8" PRIu64
11355 " %4zu %4zu %8s",
11356 peer->as, PEER_TOTAL_RX(peer),
11357 PEER_TOTAL_TX(peer),
11358 peer->version[afi][safi],
11359 inq_count, outq_count,
11360 peer_uptime(peer->uptime,
11361 timebuf,
11362 BGP_UPTIME_LEN, 0,
11363 NULL));
11364
11365 if (peer_established(peer)) {
11366 if (peer->afc_recv[afi][safi]) {
11367 if (CHECK_FLAG(
11368 bgp->flags,
11369 BGP_FLAG_EBGP_REQUIRES_POLICY)
11370 && !bgp_inbound_policy_exists(
11371 peer, filter))
11372 vty_out(vty, " %12s",
11373 "(Policy)");
11374 else
11375 vty_out(vty,
11376 " %12u",
11377 peer->pcount
11378 [afi]
11379 [pfx_rcd_safi]);
11380 } else {
11381 vty_out(vty, " NoNeg");
11382 }
11383
11384 if (paf && PAF_SUBGRP(paf)) {
11385 if (CHECK_FLAG(
11386 bgp->flags,
11387 BGP_FLAG_EBGP_REQUIRES_POLICY)
11388 && !bgp_outbound_policy_exists(
11389 peer, filter))
11390 vty_out(vty, " %8s",
11391 "(Policy)");
11392 else
11393 vty_out(vty,
11394 " %8u",
11395 (PAF_SUBGRP(
11396 paf))
11397 ->scount);
11398 } else {
11399 vty_out(vty, " NoNeg");
11400 }
11401 } else {
11402 if (CHECK_FLAG(peer->flags,
11403 PEER_FLAG_SHUTDOWN)
11404 || CHECK_FLAG(peer->bgp->flags,
11405 BGP_FLAG_SHUTDOWN))
11406 vty_out(vty, " Idle (Admin)");
11407 else if (CHECK_FLAG(
11408 peer->sflags,
11409 PEER_STATUS_PREFIX_OVERFLOW))
11410 vty_out(vty, " Idle (PfxCt)");
11411 else
11412 vty_out(vty, " %12s",
11413 lookup_msg(bgp_status_msg,
11414 peer->status, NULL));
11415
11416 vty_out(vty, " %8u", 0);
11417 }
11418 /* Make sure `Desc` column is the lastest in
11419 * the output.
11420 */
11421 if (peer->desc)
11422 vty_out(vty, " %s",
11423 bgp_peer_description_stripped(
11424 peer->desc,
11425 show_wide ? 64 : 20));
11426 else
11427 vty_out(vty, " N/A");
11428 vty_out(vty, "\n");
11429 }
11430
11431 }
11432 }
11433
11434 if (use_json) {
11435 json_object_object_add(json, "peers", json_peers);
11436 json_object_int_add(json, "failedPeers", failed_count);
11437 json_object_int_add(json, "displayedPeers",
11438 count - filtered_count);
11439 json_object_int_add(json, "totalPeers", count);
11440 json_object_int_add(json, "dynamicPeers", dn_count);
11441
11442 if (!show_failed)
11443 bgp_show_bestpath_json(bgp, json);
11444
11445 vty_json(vty, json);
11446 } else {
11447 if (count) {
11448 if (filtered_count == count)
11449 vty_out(vty, "\n%% No matching neighbor\n");
11450 else {
11451 if (show_failed)
11452 vty_out(vty, "\nDisplayed neighbors %d",
11453 failed_count);
11454 else if (as_type != AS_UNSPECIFIED || as
11455 || fpeer || show_established)
11456 vty_out(vty, "\nDisplayed neighbors %d",
11457 count - filtered_count);
11458
11459 vty_out(vty, "\nTotal number of neighbors %d\n",
11460 count);
11461 }
11462 } else {
11463 vty_out(vty, "No %s neighbor is configured\n",
11464 get_afi_safi_str(afi, safi, false));
11465 }
11466
11467 if (dn_count) {
11468 vty_out(vty, "* - dynamic neighbor\n");
11469 vty_out(vty, "%d dynamic neighbor(s), limit %d\n",
11470 dn_count, bgp->dynamic_neighbors_limit);
11471 }
11472 }
11473
11474 return CMD_SUCCESS;
11475 }
11476
11477 static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
11478 int safi, struct peer *fpeer, int as_type,
11479 as_t as, uint16_t show_flags)
11480 {
11481 int is_first = 1;
11482 int afi_wildcard = (afi == AFI_MAX);
11483 int safi_wildcard = (safi == SAFI_MAX);
11484 int is_wildcard = (afi_wildcard || safi_wildcard);
11485 bool nbr_output = false;
11486 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11487
11488 if (use_json && is_wildcard)
11489 vty_out(vty, "{\n");
11490 if (afi_wildcard)
11491 afi = 1; /* AFI_IP */
11492 while (afi < AFI_MAX) {
11493 if (safi_wildcard)
11494 safi = 1; /* SAFI_UNICAST */
11495 while (safi < SAFI_MAX) {
11496 if (bgp_afi_safi_peer_exists(bgp, afi, safi)) {
11497 nbr_output = true;
11498
11499 if (is_wildcard) {
11500 /*
11501 * So limit output to those afi/safi
11502 * pairs that
11503 * actualy have something interesting in
11504 * them
11505 */
11506 if (use_json) {
11507 if (!is_first)
11508 vty_out(vty, ",\n");
11509 else
11510 is_first = 0;
11511
11512 vty_out(vty, "\"%s\":",
11513 get_afi_safi_str(afi,
11514 safi,
11515 true));
11516 } else {
11517 vty_out(vty,
11518 "\n%s Summary (%s):\n",
11519 get_afi_safi_str(afi,
11520 safi,
11521 false),
11522 bgp->name_pretty);
11523 }
11524 }
11525 bgp_show_summary(vty, bgp, afi, safi, fpeer,
11526 as_type, as, show_flags);
11527 }
11528 safi++;
11529 if (!safi_wildcard)
11530 safi = SAFI_MAX;
11531 }
11532 afi++;
11533 if (!afi_wildcard)
11534 afi = AFI_MAX;
11535 }
11536
11537 if (use_json && is_wildcard)
11538 vty_out(vty, "}\n");
11539 else if (!nbr_output) {
11540 if (use_json)
11541 vty_out(vty, "{}\n");
11542 else
11543 vty_out(vty, "%% No BGP neighbors found in %s\n",
11544 bgp->name_pretty);
11545 }
11546 }
11547
11548 static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
11549 safi_t safi,
11550 const char *neighbor,
11551 int as_type, as_t as,
11552 uint16_t show_flags)
11553 {
11554 struct listnode *node, *nnode;
11555 struct bgp *bgp;
11556 struct peer *fpeer = NULL;
11557 int is_first = 1;
11558 bool nbr_output = false;
11559 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11560
11561 if (use_json)
11562 vty_out(vty, "{\n");
11563
11564 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
11565 nbr_output = true;
11566 if (use_json) {
11567 if (!is_first)
11568 vty_out(vty, ",\n");
11569 else
11570 is_first = 0;
11571
11572 vty_out(vty, "\"%s\":",
11573 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11574 ? VRF_DEFAULT_NAME
11575 : bgp->name);
11576 }
11577 if (neighbor) {
11578 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11579 use_json);
11580 if (!fpeer)
11581 continue;
11582 }
11583 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer, as_type,
11584 as, show_flags);
11585 }
11586
11587 if (use_json)
11588 vty_out(vty, "}\n");
11589 else if (!nbr_output)
11590 vty_out(vty, "%% BGP instance not found\n");
11591 }
11592
11593 int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
11594 safi_t safi, const char *neighbor, int as_type,
11595 as_t as, uint16_t show_flags)
11596 {
11597 struct bgp *bgp;
11598 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11599 struct peer *fpeer = NULL;
11600
11601 if (name) {
11602 if (strmatch(name, "all")) {
11603 bgp_show_all_instances_summary_vty(vty, afi, safi,
11604 neighbor, as_type,
11605 as, show_flags);
11606 return CMD_SUCCESS;
11607 } else {
11608 bgp = bgp_lookup_by_name(name);
11609
11610 if (!bgp) {
11611 if (use_json)
11612 vty_out(vty, "{}\n");
11613 else
11614 vty_out(vty,
11615 "%% BGP instance not found\n");
11616 return CMD_WARNING;
11617 }
11618
11619 if (neighbor) {
11620 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11621 use_json);
11622 if (!fpeer)
11623 return CMD_WARNING;
11624 }
11625 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer,
11626 as_type, as, show_flags);
11627 return CMD_SUCCESS;
11628 }
11629 }
11630
11631 bgp = bgp_get_default();
11632
11633 if (bgp) {
11634 if (neighbor) {
11635 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11636 use_json);
11637 if (!fpeer)
11638 return CMD_WARNING;
11639 }
11640 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer, as_type,
11641 as, show_flags);
11642 } else {
11643 if (use_json)
11644 vty_out(vty, "{}\n");
11645 else
11646 vty_out(vty, "%% BGP instance not found\n");
11647 return CMD_WARNING;
11648 }
11649
11650 return CMD_SUCCESS;
11651 }
11652
11653 /* `show [ip] bgp summary' commands. */
11654 DEFPY(show_ip_bgp_summary, show_ip_bgp_summary_cmd,
11655 "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR
11656 " [" BGP_SAFI_WITH_LABEL_CMD_STR
11657 "]] [all$all] summary [established|failed] [<neighbor <A.B.C.D|X:X::X:X|WORD>|remote-as <(1-4294967295)|internal|external>>] [terse] [wide] [json$uj]",
11658 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
11659 BGP_SAFI_WITH_LABEL_HELP_STR
11660 "Display the entries for all address families\n"
11661 "Summary of BGP neighbor status\n"
11662 "Show only sessions in Established state\n"
11663 "Show only sessions not in Established state\n"
11664 "Show only the specified neighbor session\n"
11665 "Neighbor to display information about\n"
11666 "Neighbor to display information about\n"
11667 "Neighbor on BGP configured interface\n"
11668 "Show only the specified remote AS sessions\n"
11669 "AS number\n"
11670 "Internal (iBGP) AS sessions\n"
11671 "External (eBGP) AS sessions\n"
11672 "Shorten the information on BGP instances\n"
11673 "Increase table width for longer output\n" JSON_STR)
11674 {
11675 char *vrf = NULL;
11676 afi_t afi = AFI_MAX;
11677 safi_t safi = SAFI_MAX;
11678 as_t as = 0; /* 0 means AS filter not set */
11679 int as_type = AS_UNSPECIFIED;
11680 uint16_t show_flags = 0;
11681
11682 int idx = 0;
11683
11684 /* show [ip] bgp */
11685 if (!all && argv_find(argv, argc, "ip", &idx))
11686 afi = AFI_IP;
11687 /* [<vrf> VIEWVRFNAME] */
11688 if (argv_find(argv, argc, "vrf", &idx)) {
11689 vrf = argv[idx + 1]->arg;
11690 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11691 vrf = NULL;
11692 } else if (argv_find(argv, argc, "view", &idx))
11693 /* [<view> VIEWVRFNAME] */
11694 vrf = argv[idx + 1]->arg;
11695 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
11696 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
11697 argv_find_and_parse_safi(argv, argc, &idx, &safi);
11698 }
11699
11700 if (argv_find(argv, argc, "failed", &idx))
11701 SET_FLAG(show_flags, BGP_SHOW_OPT_FAILED);
11702
11703 if (argv_find(argv, argc, "established", &idx))
11704 SET_FLAG(show_flags, BGP_SHOW_OPT_ESTABLISHED);
11705
11706 if (argv_find(argv, argc, "remote-as", &idx)) {
11707 if (argv[idx + 1]->arg[0] == 'i')
11708 as_type = AS_INTERNAL;
11709 else if (argv[idx + 1]->arg[0] == 'e')
11710 as_type = AS_EXTERNAL;
11711 else
11712 as = (as_t)atoi(argv[idx + 1]->arg);
11713 }
11714
11715 if (argv_find(argv, argc, "terse", &idx))
11716 SET_FLAG(show_flags, BGP_SHOW_OPT_TERSE);
11717
11718 if (argv_find(argv, argc, "wide", &idx))
11719 SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
11720
11721 if (argv_find(argv, argc, "json", &idx))
11722 SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11723
11724 return bgp_show_summary_vty(vty, vrf, afi, safi, neighbor, as_type, as,
11725 show_flags);
11726 }
11727
11728 const char *get_afi_safi_str(afi_t afi, safi_t safi, bool for_json)
11729 {
11730 if (for_json)
11731 return get_afi_safi_json_str(afi, safi);
11732 else
11733 return get_afi_safi_vty_str(afi, safi);
11734 }
11735
11736
11737 static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
11738 afi_t afi, safi_t safi,
11739 uint16_t adv_smcap, uint16_t adv_rmcap,
11740 uint16_t rcv_smcap, uint16_t rcv_rmcap,
11741 bool use_json, json_object *json_pref)
11742 {
11743 /* Send-Mode */
11744 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
11745 || CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap)) {
11746 if (use_json) {
11747 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
11748 && CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
11749 json_object_string_add(json_pref, "sendMode",
11750 "advertisedAndReceived");
11751 else if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
11752 json_object_string_add(json_pref, "sendMode",
11753 "advertised");
11754 else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
11755 json_object_string_add(json_pref, "sendMode",
11756 "received");
11757 } else {
11758 vty_out(vty, " Send-mode: ");
11759 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
11760 vty_out(vty, "advertised");
11761 if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
11762 vty_out(vty, "%sreceived",
11763 CHECK_FLAG(p->af_cap[afi][safi],
11764 adv_smcap)
11765 ? ", "
11766 : "");
11767 vty_out(vty, "\n");
11768 }
11769 }
11770
11771 /* Receive-Mode */
11772 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
11773 || CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap)) {
11774 if (use_json) {
11775 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
11776 && CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
11777 json_object_string_add(json_pref, "recvMode",
11778 "advertisedAndReceived");
11779 else if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
11780 json_object_string_add(json_pref, "recvMode",
11781 "advertised");
11782 else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
11783 json_object_string_add(json_pref, "recvMode",
11784 "received");
11785 } else {
11786 vty_out(vty, " Receive-mode: ");
11787 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
11788 vty_out(vty, "advertised");
11789 if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
11790 vty_out(vty, "%sreceived",
11791 CHECK_FLAG(p->af_cap[afi][safi],
11792 adv_rmcap)
11793 ? ", "
11794 : "");
11795 vty_out(vty, "\n");
11796 }
11797 }
11798 }
11799
11800 static void bgp_show_neighnor_graceful_restart_flags(struct vty *vty,
11801 struct peer *p,
11802 bool use_json,
11803 json_object *json)
11804 {
11805 bool rbit = false;
11806 bool nbit = false;
11807
11808 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)
11809 && (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
11810 && (peer_established(p))) {
11811 rbit = CHECK_FLAG(p->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV);
11812 nbit = CHECK_FLAG(p->cap, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV);
11813 }
11814
11815 if (use_json) {
11816 json_object_boolean_add(json, "rBit", rbit);
11817 json_object_boolean_add(json, "nBit", nbit);
11818 } else {
11819 vty_out(vty, "\n R bit: %s", rbit ? "True" : "False");
11820 vty_out(vty, "\n N bit: %s\n", nbit ? "True" : "False");
11821 }
11822 }
11823
11824 static void bgp_show_neighbor_graceful_restart_remote_mode(struct vty *vty,
11825 struct peer *peer,
11826 bool use_json,
11827 json_object *json)
11828 {
11829 const char *mode = "NotApplicable";
11830
11831 if (!use_json)
11832 vty_out(vty, "\n Remote GR Mode: ");
11833
11834 if (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV)
11835 && (peer_established(peer))) {
11836
11837 if ((peer->nsf_af_count == 0)
11838 && !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
11839
11840 mode = "Disable";
11841
11842 } else if (peer->nsf_af_count == 0
11843 && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
11844
11845 mode = "Helper";
11846
11847 } else if (peer->nsf_af_count != 0
11848 && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
11849
11850 mode = "Restart";
11851 }
11852 }
11853
11854 if (use_json) {
11855 json_object_string_add(json, "remoteGrMode", mode);
11856 } else
11857 vty_out(vty, mode, "\n");
11858 }
11859
11860 static void bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
11861 struct peer *p,
11862 bool use_json,
11863 json_object *json)
11864 {
11865 const char *mode = "Invalid";
11866
11867 if (!use_json)
11868 vty_out(vty, " Local GR Mode: ");
11869
11870 if (bgp_peer_gr_mode_get(p) == PEER_HELPER)
11871 mode = "Helper";
11872 else if (bgp_peer_gr_mode_get(p) == PEER_GR)
11873 mode = "Restart";
11874 else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE)
11875 mode = "Disable";
11876 else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT) {
11877 if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_HELPER)
11878 mode = "Helper*";
11879 else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_GR)
11880 mode = "Restart*";
11881 else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_DISABLE)
11882 mode = "Disable*";
11883 else
11884 mode = "Invalid*";
11885 }
11886
11887 if (use_json) {
11888 json_object_string_add(json, "localGrMode", mode);
11889 } else {
11890 vty_out(vty, mode, "\n");
11891 }
11892 }
11893
11894 static void bgp_show_neighbor_graceful_restart_capability_per_afi_safi(
11895 struct vty *vty, struct peer *peer, bool use_json, json_object *json)
11896 {
11897 afi_t afi;
11898 safi_t safi;
11899 json_object *json_afi_safi = NULL;
11900 json_object *json_timer = NULL;
11901 json_object *json_endofrib_status = NULL;
11902 bool eor_flag = false;
11903
11904 FOREACH_AFI_SAFI_NSF (afi, safi) {
11905 if (!peer->afc[afi][safi])
11906 continue;
11907
11908 if (!CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV) ||
11909 !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV))
11910 continue;
11911
11912 if (use_json) {
11913 json_afi_safi = json_object_new_object();
11914 json_endofrib_status = json_object_new_object();
11915 json_timer = json_object_new_object();
11916 }
11917
11918 if (peer->eor_stime[afi][safi] >= peer->pkt_stime[afi][safi])
11919 eor_flag = true;
11920 else
11921 eor_flag = false;
11922
11923 if (!use_json) {
11924 vty_out(vty, " %s:\n",
11925 get_afi_safi_str(afi, safi, false));
11926
11927 vty_out(vty, " F bit: ");
11928 }
11929
11930 if (peer->nsf[afi][safi] &&
11931 CHECK_FLAG(peer->af_cap[afi][safi],
11932 PEER_CAP_RESTART_AF_PRESERVE_RCV)) {
11933
11934 if (use_json) {
11935 json_object_boolean_true_add(json_afi_safi,
11936 "fBit");
11937 } else
11938 vty_out(vty, "True\n");
11939 } else {
11940 if (use_json)
11941 json_object_boolean_false_add(json_afi_safi,
11942 "fBit");
11943 else
11944 vty_out(vty, "False\n");
11945 }
11946
11947 if (!use_json)
11948 vty_out(vty, " End-of-RIB sent: ");
11949
11950 if (CHECK_FLAG(peer->af_sflags[afi][safi],
11951 PEER_STATUS_EOR_SEND)) {
11952 if (use_json) {
11953 json_object_boolean_true_add(
11954 json_endofrib_status, "endOfRibSend");
11955
11956 PRINT_EOR_JSON(eor_flag);
11957 } else {
11958 vty_out(vty, "Yes\n");
11959 vty_out(vty,
11960 " End-of-RIB sent after update: ");
11961
11962 PRINT_EOR(eor_flag);
11963 }
11964 } else {
11965 if (use_json) {
11966 json_object_boolean_false_add(
11967 json_endofrib_status, "endOfRibSend");
11968 json_object_boolean_false_add(
11969 json_endofrib_status,
11970 "endOfRibSentAfterUpdate");
11971 } else {
11972 vty_out(vty, "No\n");
11973 vty_out(vty,
11974 " End-of-RIB sent after update: ");
11975 vty_out(vty, "No\n");
11976 }
11977 }
11978
11979 if (!use_json)
11980 vty_out(vty, " End-of-RIB received: ");
11981
11982 if (CHECK_FLAG(peer->af_sflags[afi][safi],
11983 PEER_STATUS_EOR_RECEIVED)) {
11984 if (use_json)
11985 json_object_boolean_true_add(
11986 json_endofrib_status, "endOfRibRecv");
11987 else
11988 vty_out(vty, "Yes\n");
11989 } else {
11990 if (use_json)
11991 json_object_boolean_false_add(
11992 json_endofrib_status, "endOfRibRecv");
11993 else
11994 vty_out(vty, "No\n");
11995 }
11996
11997 if (use_json) {
11998 json_object_int_add(json_timer, "stalePathTimer",
11999 peer->bgp->stalepath_time);
12000
12001 if (peer->t_gr_stale != NULL) {
12002 json_object_int_add(json_timer,
12003 "stalePathTimerRemaining",
12004 thread_timer_remain_second(
12005 peer->t_gr_stale));
12006 }
12007
12008 /* Display Configured Selection
12009 * Deferral only when when
12010 * Gr mode is enabled.
12011 */
12012 if (CHECK_FLAG(peer->flags,
12013 PEER_FLAG_GRACEFUL_RESTART)) {
12014 json_object_int_add(json_timer,
12015 "selectionDeferralTimer",
12016 peer->bgp->stalepath_time);
12017 }
12018
12019 if (peer->bgp->gr_info[afi][safi].t_select_deferral !=
12020 NULL) {
12021
12022 json_object_int_add(
12023 json_timer,
12024 "selectionDeferralTimerRemaining",
12025 thread_timer_remain_second(
12026 peer->bgp->gr_info[afi][safi]
12027 .t_select_deferral));
12028 }
12029 } else {
12030 vty_out(vty, " Timers:\n");
12031 vty_out(vty,
12032 " Configured Stale Path Time(sec): %u\n",
12033 peer->bgp->stalepath_time);
12034
12035 if (peer->t_gr_stale != NULL)
12036 vty_out(vty,
12037 " Stale Path Remaining(sec): %ld\n",
12038 thread_timer_remain_second(
12039 peer->t_gr_stale));
12040 /* Display Configured Selection
12041 * Deferral only when when
12042 * Gr mode is enabled.
12043 */
12044 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
12045 vty_out(vty,
12046 " Configured Selection Deferral Time(sec): %u\n",
12047 peer->bgp->select_defer_time);
12048
12049 if (peer->bgp->gr_info[afi][safi].t_select_deferral !=
12050 NULL)
12051 vty_out(vty,
12052 " Selection Deferral Time Remaining(sec): %ld\n",
12053 thread_timer_remain_second(
12054 peer->bgp->gr_info[afi][safi]
12055 .t_select_deferral));
12056 }
12057 if (use_json) {
12058 json_object_object_add(json_afi_safi, "endOfRibStatus",
12059 json_endofrib_status);
12060 json_object_object_add(json_afi_safi, "timers",
12061 json_timer);
12062 json_object_object_add(
12063 json, get_afi_safi_str(afi, safi, true),
12064 json_afi_safi);
12065 }
12066 }
12067 }
12068
12069 static void bgp_show_neighbor_graceful_restart_time(struct vty *vty,
12070 struct peer *p,
12071 bool use_json,
12072 json_object *json)
12073 {
12074 if (use_json) {
12075 json_object *json_timer = NULL;
12076
12077 json_timer = json_object_new_object();
12078
12079 json_object_int_add(json_timer, "configuredRestartTimer",
12080 p->bgp->restart_time);
12081
12082 json_object_int_add(json_timer, "receivedRestartTimer",
12083 p->v_gr_restart);
12084
12085 if (p->t_gr_restart != NULL)
12086 json_object_int_add(
12087 json_timer, "restartTimerRemaining",
12088 thread_timer_remain_second(p->t_gr_restart));
12089
12090 json_object_object_add(json, "timers", json_timer);
12091 } else {
12092
12093 vty_out(vty, " Timers:\n");
12094 vty_out(vty, " Configured Restart Time(sec): %u\n",
12095 p->bgp->restart_time);
12096
12097 vty_out(vty, " Received Restart Time(sec): %u\n",
12098 p->v_gr_restart);
12099 if (p->t_gr_restart != NULL)
12100 vty_out(vty, " Restart Time Remaining(sec): %ld\n",
12101 thread_timer_remain_second(p->t_gr_restart));
12102 if (p->t_gr_restart != NULL) {
12103 vty_out(vty, " Restart Time Remaining(sec): %ld\n",
12104 thread_timer_remain_second(p->t_gr_restart));
12105 }
12106 }
12107 }
12108
12109 static void bgp_show_peer_gr_status(struct vty *vty, struct peer *p,
12110 bool use_json, json_object *json)
12111 {
12112 char dn_flag[2] = {0};
12113 /* '*' + v6 address of neighbor */
12114 char neighborAddr[INET6_ADDRSTRLEN + 1] = {0};
12115
12116 if (!p->conf_if && peer_dynamic_neighbor(p))
12117 dn_flag[0] = '*';
12118
12119 if (p->conf_if) {
12120 if (use_json)
12121 json_object_string_addf(json, "neighborAddr", "%pSU",
12122 &p->su);
12123 else
12124 vty_out(vty, "BGP neighbor on %s: %pSU\n", p->conf_if,
12125 &p->su);
12126 } else {
12127 snprintf(neighborAddr, sizeof(neighborAddr), "%s%s", dn_flag,
12128 p->host);
12129
12130 if (use_json)
12131 json_object_string_add(json, "neighborAddr",
12132 neighborAddr);
12133 else
12134 vty_out(vty, "BGP neighbor is %s\n", neighborAddr);
12135 }
12136
12137 /* more gr info in new format */
12138 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, use_json, json);
12139 }
12140
12141 static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
12142 safi_t safi, bool use_json,
12143 json_object *json_neigh)
12144 {
12145 struct bgp_filter *filter;
12146 struct peer_af *paf;
12147 char orf_pfx_name[BUFSIZ];
12148 int orf_pfx_count;
12149 json_object *json_af = NULL;
12150 json_object *json_prefA = NULL;
12151 json_object *json_prefB = NULL;
12152 json_object *json_addr = NULL;
12153 json_object *json_advmap = NULL;
12154
12155 if (use_json) {
12156 json_addr = json_object_new_object();
12157 json_af = json_object_new_object();
12158 filter = &p->filter[afi][safi];
12159
12160 if (peer_group_active(p))
12161 json_object_string_add(json_addr, "peerGroupMember",
12162 p->group->name);
12163
12164 paf = peer_af_find(p, afi, safi);
12165 if (paf && PAF_SUBGRP(paf)) {
12166 json_object_int_add(json_addr, "updateGroupId",
12167 PAF_UPDGRP(paf)->id);
12168 json_object_int_add(json_addr, "subGroupId",
12169 PAF_SUBGRP(paf)->id);
12170 json_object_int_add(json_addr, "packetQueueLength",
12171 bpacket_queue_virtual_length(paf));
12172 }
12173
12174 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12175 || CHECK_FLAG(p->af_cap[afi][safi],
12176 PEER_CAP_ORF_PREFIX_SM_RCV)
12177 || CHECK_FLAG(p->af_cap[afi][safi],
12178 PEER_CAP_ORF_PREFIX_RM_ADV)
12179 || CHECK_FLAG(p->af_cap[afi][safi],
12180 PEER_CAP_ORF_PREFIX_RM_RCV)) {
12181 json_object_int_add(json_af, "orfType",
12182 ORF_TYPE_PREFIX);
12183 json_prefA = json_object_new_object();
12184 bgp_show_peer_afi_orf_cap(vty, p, afi, safi,
12185 PEER_CAP_ORF_PREFIX_SM_ADV,
12186 PEER_CAP_ORF_PREFIX_RM_ADV,
12187 PEER_CAP_ORF_PREFIX_SM_RCV,
12188 PEER_CAP_ORF_PREFIX_RM_RCV,
12189 use_json, json_prefA);
12190 json_object_object_add(json_af, "orfPrefixList",
12191 json_prefA);
12192 }
12193
12194 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12195 || CHECK_FLAG(p->af_cap[afi][safi],
12196 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12197 || CHECK_FLAG(p->af_cap[afi][safi],
12198 PEER_CAP_ORF_PREFIX_RM_ADV)
12199 || CHECK_FLAG(p->af_cap[afi][safi],
12200 PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
12201 json_object_int_add(json_af, "orfOldType",
12202 ORF_TYPE_PREFIX_OLD);
12203 json_prefB = json_object_new_object();
12204 bgp_show_peer_afi_orf_cap(
12205 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12206 PEER_CAP_ORF_PREFIX_RM_ADV,
12207 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
12208 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json,
12209 json_prefB);
12210 json_object_object_add(json_af, "orfOldPrefixList",
12211 json_prefB);
12212 }
12213
12214 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12215 || CHECK_FLAG(p->af_cap[afi][safi],
12216 PEER_CAP_ORF_PREFIX_SM_RCV)
12217 || CHECK_FLAG(p->af_cap[afi][safi],
12218 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12219 || CHECK_FLAG(p->af_cap[afi][safi],
12220 PEER_CAP_ORF_PREFIX_RM_ADV)
12221 || CHECK_FLAG(p->af_cap[afi][safi],
12222 PEER_CAP_ORF_PREFIX_RM_RCV)
12223 || CHECK_FLAG(p->af_cap[afi][safi],
12224 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
12225 json_object_object_add(json_addr, "afDependentCap",
12226 json_af);
12227 else
12228 json_object_free(json_af);
12229
12230 snprintf(orf_pfx_name, sizeof(orf_pfx_name), "%s.%d.%d",
12231 p->host, afi, safi);
12232 orf_pfx_count = prefix_bgp_show_prefix_list(
12233 NULL, afi, orf_pfx_name, use_json);
12234
12235 if (CHECK_FLAG(p->af_sflags[afi][safi],
12236 PEER_STATUS_ORF_PREFIX_SEND)
12237 || orf_pfx_count) {
12238 if (CHECK_FLAG(p->af_sflags[afi][safi],
12239 PEER_STATUS_ORF_PREFIX_SEND))
12240 json_object_boolean_true_add(json_neigh,
12241 "orfSent");
12242 if (orf_pfx_count)
12243 json_object_int_add(json_addr, "orfRecvCounter",
12244 orf_pfx_count);
12245 }
12246 if (CHECK_FLAG(p->af_sflags[afi][safi],
12247 PEER_STATUS_ORF_WAIT_REFRESH))
12248 json_object_string_add(
12249 json_addr, "orfFirstUpdate",
12250 "deferredUntilORFOrRouteRefreshRecvd");
12251
12252 if (CHECK_FLAG(p->af_flags[afi][safi],
12253 PEER_FLAG_REFLECTOR_CLIENT))
12254 json_object_boolean_true_add(json_addr,
12255 "routeReflectorClient");
12256 if (CHECK_FLAG(p->af_flags[afi][safi],
12257 PEER_FLAG_RSERVER_CLIENT))
12258 json_object_boolean_true_add(json_addr,
12259 "routeServerClient");
12260 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
12261 json_object_boolean_true_add(json_addr,
12262 "inboundSoftConfigPermit");
12263
12264 if (CHECK_FLAG(p->af_flags[afi][safi],
12265 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
12266 json_object_boolean_true_add(
12267 json_addr,
12268 "privateAsNumsAllReplacedInUpdatesToNbr");
12269 else if (CHECK_FLAG(p->af_flags[afi][safi],
12270 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
12271 json_object_boolean_true_add(
12272 json_addr,
12273 "privateAsNumsReplacedInUpdatesToNbr");
12274 else if (CHECK_FLAG(p->af_flags[afi][safi],
12275 PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
12276 json_object_boolean_true_add(
12277 json_addr,
12278 "privateAsNumsAllRemovedInUpdatesToNbr");
12279 else if (CHECK_FLAG(p->af_flags[afi][safi],
12280 PEER_FLAG_REMOVE_PRIVATE_AS))
12281 json_object_boolean_true_add(
12282 json_addr,
12283 "privateAsNumsRemovedInUpdatesToNbr");
12284
12285 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN)) {
12286 if (CHECK_FLAG(p->af_flags[afi][safi],
12287 PEER_FLAG_ALLOWAS_IN_ORIGIN))
12288 json_object_boolean_true_add(json_addr,
12289 "allowAsInOrigin");
12290 else
12291 json_object_int_add(json_addr, "allowAsInCount",
12292 p->allowas_in[afi][safi]);
12293 }
12294
12295 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
12296 json_object_boolean_true_add(
12297 json_addr,
12298 bgp_addpath_names(p->addpath_type[afi][safi])
12299 ->type_json_name);
12300
12301 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
12302 json_object_string_add(json_addr,
12303 "overrideASNsInOutboundUpdates",
12304 "ifAspathEqualRemoteAs");
12305
12306 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
12307 || CHECK_FLAG(p->af_flags[afi][safi],
12308 PEER_FLAG_FORCE_NEXTHOP_SELF))
12309 json_object_boolean_true_add(json_addr,
12310 "routerAlwaysNextHop");
12311 if (CHECK_FLAG(p->af_flags[afi][safi],
12312 PEER_FLAG_AS_PATH_UNCHANGED))
12313 json_object_boolean_true_add(
12314 json_addr, "unchangedAsPathPropogatedToNbr");
12315 if (CHECK_FLAG(p->af_flags[afi][safi],
12316 PEER_FLAG_NEXTHOP_UNCHANGED))
12317 json_object_boolean_true_add(
12318 json_addr, "unchangedNextHopPropogatedToNbr");
12319 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
12320 json_object_boolean_true_add(
12321 json_addr, "unchangedMedPropogatedToNbr");
12322 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
12323 || CHECK_FLAG(p->af_flags[afi][safi],
12324 PEER_FLAG_SEND_EXT_COMMUNITY)) {
12325 if (CHECK_FLAG(p->af_flags[afi][safi],
12326 PEER_FLAG_SEND_COMMUNITY)
12327 && CHECK_FLAG(p->af_flags[afi][safi],
12328 PEER_FLAG_SEND_EXT_COMMUNITY))
12329 json_object_string_add(json_addr,
12330 "commAttriSentToNbr",
12331 "extendedAndStandard");
12332 else if (CHECK_FLAG(p->af_flags[afi][safi],
12333 PEER_FLAG_SEND_EXT_COMMUNITY))
12334 json_object_string_add(json_addr,
12335 "commAttriSentToNbr",
12336 "extended");
12337 else
12338 json_object_string_add(json_addr,
12339 "commAttriSentToNbr",
12340 "standard");
12341 }
12342 if (CHECK_FLAG(p->af_flags[afi][safi],
12343 PEER_FLAG_DEFAULT_ORIGINATE)) {
12344 if (p->default_rmap[afi][safi].name)
12345 json_object_string_add(
12346 json_addr, "defaultRouteMap",
12347 p->default_rmap[afi][safi].name);
12348
12349 if (paf && PAF_SUBGRP(paf)
12350 && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
12351 SUBGRP_STATUS_DEFAULT_ORIGINATE))
12352 json_object_boolean_true_add(json_addr,
12353 "defaultSent");
12354 else
12355 json_object_boolean_true_add(json_addr,
12356 "defaultNotSent");
12357 }
12358
12359 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
12360 if (is_evpn_enabled())
12361 json_object_boolean_true_add(
12362 json_addr, "advertiseAllVnis");
12363 }
12364
12365 if (filter->plist[FILTER_IN].name
12366 || filter->dlist[FILTER_IN].name
12367 || filter->aslist[FILTER_IN].name
12368 || filter->map[RMAP_IN].name)
12369 json_object_boolean_true_add(json_addr,
12370 "inboundPathPolicyConfig");
12371 if (filter->plist[FILTER_OUT].name
12372 || filter->dlist[FILTER_OUT].name
12373 || filter->aslist[FILTER_OUT].name
12374 || filter->map[RMAP_OUT].name || filter->usmap.name)
12375 json_object_boolean_true_add(
12376 json_addr, "outboundPathPolicyConfig");
12377
12378 /* prefix-list */
12379 if (filter->plist[FILTER_IN].name)
12380 json_object_string_add(json_addr,
12381 "incomingUpdatePrefixFilterList",
12382 filter->plist[FILTER_IN].name);
12383 if (filter->plist[FILTER_OUT].name)
12384 json_object_string_add(json_addr,
12385 "outgoingUpdatePrefixFilterList",
12386 filter->plist[FILTER_OUT].name);
12387
12388 /* distribute-list */
12389 if (filter->dlist[FILTER_IN].name)
12390 json_object_string_add(
12391 json_addr, "incomingUpdateNetworkFilterList",
12392 filter->dlist[FILTER_IN].name);
12393 if (filter->dlist[FILTER_OUT].name)
12394 json_object_string_add(
12395 json_addr, "outgoingUpdateNetworkFilterList",
12396 filter->dlist[FILTER_OUT].name);
12397
12398 /* filter-list. */
12399 if (filter->aslist[FILTER_IN].name)
12400 json_object_string_add(json_addr,
12401 "incomingUpdateAsPathFilterList",
12402 filter->aslist[FILTER_IN].name);
12403 if (filter->aslist[FILTER_OUT].name)
12404 json_object_string_add(json_addr,
12405 "outgoingUpdateAsPathFilterList",
12406 filter->aslist[FILTER_OUT].name);
12407
12408 /* route-map. */
12409 if (filter->map[RMAP_IN].name)
12410 json_object_string_add(
12411 json_addr, "routeMapForIncomingAdvertisements",
12412 filter->map[RMAP_IN].name);
12413 if (filter->map[RMAP_OUT].name)
12414 json_object_string_add(
12415 json_addr, "routeMapForOutgoingAdvertisements",
12416 filter->map[RMAP_OUT].name);
12417
12418 /* ebgp-requires-policy (inbound) */
12419 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12420 && !bgp_inbound_policy_exists(p, filter))
12421 json_object_string_add(
12422 json_addr, "inboundEbgpRequiresPolicy",
12423 "Inbound updates discarded due to missing policy");
12424
12425 /* ebgp-requires-policy (outbound) */
12426 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12427 && (!bgp_outbound_policy_exists(p, filter)))
12428 json_object_string_add(
12429 json_addr, "outboundEbgpRequiresPolicy",
12430 "Outbound updates discarded due to missing policy");
12431
12432 /* unsuppress-map */
12433 if (filter->usmap.name)
12434 json_object_string_add(json_addr,
12435 "selectiveUnsuppressRouteMap",
12436 filter->usmap.name);
12437
12438 /* advertise-map */
12439 if (filter->advmap.aname) {
12440 json_advmap = json_object_new_object();
12441 json_object_string_add(json_advmap, "condition",
12442 filter->advmap.condition
12443 ? "EXIST"
12444 : "NON_EXIST");
12445 json_object_string_add(json_advmap, "conditionMap",
12446 filter->advmap.cname);
12447 json_object_string_add(json_advmap, "advertiseMap",
12448 filter->advmap.aname);
12449 json_object_string_add(
12450 json_advmap, "advertiseStatus",
12451 filter->advmap.update_type ==
12452 UPDATE_TYPE_ADVERTISE
12453 ? "Advertise"
12454 : "Withdraw");
12455 json_object_object_add(json_addr, "advertiseMap",
12456 json_advmap);
12457 }
12458
12459 /* Receive prefix count */
12460 json_object_int_add(json_addr, "acceptedPrefixCounter",
12461 p->pcount[afi][safi]);
12462 if (paf && PAF_SUBGRP(paf))
12463 json_object_int_add(json_addr, "sentPrefixCounter",
12464 (PAF_SUBGRP(paf))->scount);
12465
12466 /* Maximum prefix */
12467 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_OUT))
12468 json_object_int_add(json_addr, "prefixOutAllowedMax",
12469 p->pmax_out[afi][safi]);
12470
12471 /* Maximum prefix */
12472 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
12473 json_object_int_add(json_addr, "prefixAllowedMax",
12474 p->pmax[afi][safi]);
12475 if (CHECK_FLAG(p->af_flags[afi][safi],
12476 PEER_FLAG_MAX_PREFIX_WARNING))
12477 json_object_boolean_true_add(
12478 json_addr, "prefixAllowedMaxWarning");
12479 json_object_int_add(json_addr,
12480 "prefixAllowedWarningThresh",
12481 p->pmax_threshold[afi][safi]);
12482 if (p->pmax_restart[afi][safi])
12483 json_object_int_add(
12484 json_addr,
12485 "prefixAllowedRestartIntervalMsecs",
12486 p->pmax_restart[afi][safi] * 60000);
12487 }
12488 json_object_object_add(json_neigh,
12489 get_afi_safi_str(afi, safi, true),
12490 json_addr);
12491
12492 } else {
12493 filter = &p->filter[afi][safi];
12494
12495 vty_out(vty, " For address family: %s\n",
12496 get_afi_safi_str(afi, safi, false));
12497
12498 if (peer_group_active(p))
12499 vty_out(vty, " %s peer-group member\n",
12500 p->group->name);
12501
12502 paf = peer_af_find(p, afi, safi);
12503 if (paf && PAF_SUBGRP(paf)) {
12504 vty_out(vty, " Update group %" PRIu64", subgroup %" PRIu64 "\n",
12505 PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id);
12506 vty_out(vty, " Packet Queue length %d\n",
12507 bpacket_queue_virtual_length(paf));
12508 } else {
12509 vty_out(vty, " Not part of any update group\n");
12510 }
12511 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12512 || CHECK_FLAG(p->af_cap[afi][safi],
12513 PEER_CAP_ORF_PREFIX_SM_RCV)
12514 || CHECK_FLAG(p->af_cap[afi][safi],
12515 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12516 || CHECK_FLAG(p->af_cap[afi][safi],
12517 PEER_CAP_ORF_PREFIX_RM_ADV)
12518 || CHECK_FLAG(p->af_cap[afi][safi],
12519 PEER_CAP_ORF_PREFIX_RM_RCV)
12520 || CHECK_FLAG(p->af_cap[afi][safi],
12521 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
12522 vty_out(vty, " AF-dependant capabilities:\n");
12523
12524 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12525 || CHECK_FLAG(p->af_cap[afi][safi],
12526 PEER_CAP_ORF_PREFIX_SM_RCV)
12527 || CHECK_FLAG(p->af_cap[afi][safi],
12528 PEER_CAP_ORF_PREFIX_RM_ADV)
12529 || CHECK_FLAG(p->af_cap[afi][safi],
12530 PEER_CAP_ORF_PREFIX_RM_RCV)) {
12531 vty_out(vty,
12532 " Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
12533 ORF_TYPE_PREFIX);
12534 bgp_show_peer_afi_orf_cap(
12535 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12536 PEER_CAP_ORF_PREFIX_RM_ADV,
12537 PEER_CAP_ORF_PREFIX_SM_RCV,
12538 PEER_CAP_ORF_PREFIX_RM_RCV, use_json, NULL);
12539 }
12540 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12541 || CHECK_FLAG(p->af_cap[afi][safi],
12542 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12543 || CHECK_FLAG(p->af_cap[afi][safi],
12544 PEER_CAP_ORF_PREFIX_RM_ADV)
12545 || CHECK_FLAG(p->af_cap[afi][safi],
12546 PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
12547 vty_out(vty,
12548 " Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
12549 ORF_TYPE_PREFIX_OLD);
12550 bgp_show_peer_afi_orf_cap(
12551 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12552 PEER_CAP_ORF_PREFIX_RM_ADV,
12553 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
12554 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, NULL);
12555 }
12556
12557 snprintf(orf_pfx_name, sizeof(orf_pfx_name), "%s.%d.%d",
12558 p->host, afi, safi);
12559 orf_pfx_count = prefix_bgp_show_prefix_list(
12560 NULL, afi, orf_pfx_name, use_json);
12561
12562 if (CHECK_FLAG(p->af_sflags[afi][safi],
12563 PEER_STATUS_ORF_PREFIX_SEND)
12564 || orf_pfx_count) {
12565 vty_out(vty, " Outbound Route Filter (ORF):");
12566 if (CHECK_FLAG(p->af_sflags[afi][safi],
12567 PEER_STATUS_ORF_PREFIX_SEND))
12568 vty_out(vty, " sent;");
12569 if (orf_pfx_count)
12570 vty_out(vty, " received (%d entries)",
12571 orf_pfx_count);
12572 vty_out(vty, "\n");
12573 }
12574 if (CHECK_FLAG(p->af_sflags[afi][safi],
12575 PEER_STATUS_ORF_WAIT_REFRESH))
12576 vty_out(vty,
12577 " First update is deferred until ORF or ROUTE-REFRESH is received\n");
12578
12579 if (CHECK_FLAG(p->af_flags[afi][safi],
12580 PEER_FLAG_REFLECTOR_CLIENT))
12581 vty_out(vty, " Route-Reflector Client\n");
12582 if (CHECK_FLAG(p->af_flags[afi][safi],
12583 PEER_FLAG_RSERVER_CLIENT))
12584 vty_out(vty, " Route-Server Client\n");
12585
12586 if (peer_af_flag_check(p, afi, safi, PEER_FLAG_ORR_GROUP))
12587 vty_out(vty, " ORR group (configured) : %s\n",
12588 p->orr_group_name[afi][safi]);
12589
12590 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
12591 vty_out(vty,
12592 " Inbound soft reconfiguration allowed\n");
12593
12594 if (CHECK_FLAG(p->af_flags[afi][safi],
12595 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
12596 vty_out(vty,
12597 " Private AS numbers (all) replaced in updates to this neighbor\n");
12598 else if (CHECK_FLAG(p->af_flags[afi][safi],
12599 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
12600 vty_out(vty,
12601 " Private AS numbers replaced in updates to this neighbor\n");
12602 else if (CHECK_FLAG(p->af_flags[afi][safi],
12603 PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
12604 vty_out(vty,
12605 " Private AS numbers (all) removed in updates to this neighbor\n");
12606 else if (CHECK_FLAG(p->af_flags[afi][safi],
12607 PEER_FLAG_REMOVE_PRIVATE_AS))
12608 vty_out(vty,
12609 " Private AS numbers removed in updates to this neighbor\n");
12610
12611 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN)) {
12612 if (CHECK_FLAG(p->af_flags[afi][safi],
12613 PEER_FLAG_ALLOWAS_IN_ORIGIN))
12614 vty_out(vty,
12615 " Local AS allowed as path origin\n");
12616 else
12617 vty_out(vty,
12618 " Local AS allowed in path, %d occurrences\n",
12619 p->allowas_in[afi][safi]);
12620 }
12621
12622 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
12623 vty_out(vty, " %s\n",
12624 bgp_addpath_names(p->addpath_type[afi][safi])
12625 ->human_description);
12626
12627 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
12628 vty_out(vty,
12629 " Override ASNs in outbound updates if aspath equals remote-as\n");
12630
12631 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
12632 || CHECK_FLAG(p->af_flags[afi][safi],
12633 PEER_FLAG_FORCE_NEXTHOP_SELF))
12634 vty_out(vty, " NEXT_HOP is always this router\n");
12635 if (CHECK_FLAG(p->af_flags[afi][safi],
12636 PEER_FLAG_AS_PATH_UNCHANGED))
12637 vty_out(vty,
12638 " AS_PATH is propagated unchanged to this neighbor\n");
12639 if (CHECK_FLAG(p->af_flags[afi][safi],
12640 PEER_FLAG_NEXTHOP_UNCHANGED))
12641 vty_out(vty,
12642 " NEXT_HOP is propagated unchanged to this neighbor\n");
12643 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
12644 vty_out(vty,
12645 " MED is propagated unchanged to this neighbor\n");
12646 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
12647 || CHECK_FLAG(p->af_flags[afi][safi],
12648 PEER_FLAG_SEND_EXT_COMMUNITY)
12649 || CHECK_FLAG(p->af_flags[afi][safi],
12650 PEER_FLAG_SEND_LARGE_COMMUNITY)) {
12651 vty_out(vty,
12652 " Community attribute sent to this neighbor");
12653 if (CHECK_FLAG(p->af_flags[afi][safi],
12654 PEER_FLAG_SEND_COMMUNITY)
12655 && CHECK_FLAG(p->af_flags[afi][safi],
12656 PEER_FLAG_SEND_EXT_COMMUNITY)
12657 && CHECK_FLAG(p->af_flags[afi][safi],
12658 PEER_FLAG_SEND_LARGE_COMMUNITY))
12659 vty_out(vty, "(all)\n");
12660 else if (CHECK_FLAG(p->af_flags[afi][safi],
12661 PEER_FLAG_SEND_LARGE_COMMUNITY))
12662 vty_out(vty, "(large)\n");
12663 else if (CHECK_FLAG(p->af_flags[afi][safi],
12664 PEER_FLAG_SEND_EXT_COMMUNITY))
12665 vty_out(vty, "(extended)\n");
12666 else
12667 vty_out(vty, "(standard)\n");
12668 }
12669 if (CHECK_FLAG(p->af_flags[afi][safi],
12670 PEER_FLAG_DEFAULT_ORIGINATE)) {
12671 vty_out(vty, " Default information originate,");
12672
12673 if (p->default_rmap[afi][safi].name)
12674 vty_out(vty, " default route-map %s%s,",
12675 p->default_rmap[afi][safi].map ? "*"
12676 : "",
12677 p->default_rmap[afi][safi].name);
12678 if (paf && PAF_SUBGRP(paf)
12679 && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
12680 SUBGRP_STATUS_DEFAULT_ORIGINATE))
12681 vty_out(vty, " default sent\n");
12682 else
12683 vty_out(vty, " default not sent\n");
12684 }
12685
12686 /* advertise-vni-all */
12687 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
12688 if (is_evpn_enabled())
12689 vty_out(vty, " advertise-all-vni\n");
12690 }
12691
12692 if (filter->plist[FILTER_IN].name
12693 || filter->dlist[FILTER_IN].name
12694 || filter->aslist[FILTER_IN].name
12695 || filter->map[RMAP_IN].name)
12696 vty_out(vty, " Inbound path policy configured\n");
12697 if (filter->plist[FILTER_OUT].name
12698 || filter->dlist[FILTER_OUT].name
12699 || filter->aslist[FILTER_OUT].name
12700 || filter->map[RMAP_OUT].name || filter->usmap.name)
12701 vty_out(vty, " Outbound path policy configured\n");
12702
12703 /* prefix-list */
12704 if (filter->plist[FILTER_IN].name)
12705 vty_out(vty,
12706 " Incoming update prefix filter list is %s%s\n",
12707 filter->plist[FILTER_IN].plist ? "*" : "",
12708 filter->plist[FILTER_IN].name);
12709 if (filter->plist[FILTER_OUT].name)
12710 vty_out(vty,
12711 " Outgoing update prefix filter list is %s%s\n",
12712 filter->plist[FILTER_OUT].plist ? "*" : "",
12713 filter->plist[FILTER_OUT].name);
12714
12715 /* distribute-list */
12716 if (filter->dlist[FILTER_IN].name)
12717 vty_out(vty,
12718 " Incoming update network filter list is %s%s\n",
12719 filter->dlist[FILTER_IN].alist ? "*" : "",
12720 filter->dlist[FILTER_IN].name);
12721 if (filter->dlist[FILTER_OUT].name)
12722 vty_out(vty,
12723 " Outgoing update network filter list is %s%s\n",
12724 filter->dlist[FILTER_OUT].alist ? "*" : "",
12725 filter->dlist[FILTER_OUT].name);
12726
12727 /* filter-list. */
12728 if (filter->aslist[FILTER_IN].name)
12729 vty_out(vty,
12730 " Incoming update AS path filter list is %s%s\n",
12731 filter->aslist[FILTER_IN].aslist ? "*" : "",
12732 filter->aslist[FILTER_IN].name);
12733 if (filter->aslist[FILTER_OUT].name)
12734 vty_out(vty,
12735 " Outgoing update AS path filter list is %s%s\n",
12736 filter->aslist[FILTER_OUT].aslist ? "*" : "",
12737 filter->aslist[FILTER_OUT].name);
12738
12739 /* route-map. */
12740 if (filter->map[RMAP_IN].name)
12741 vty_out(vty,
12742 " Route map for incoming advertisements is %s%s\n",
12743 filter->map[RMAP_IN].map ? "*" : "",
12744 filter->map[RMAP_IN].name);
12745 if (filter->map[RMAP_OUT].name)
12746 vty_out(vty,
12747 " Route map for outgoing advertisements is %s%s\n",
12748 filter->map[RMAP_OUT].map ? "*" : "",
12749 filter->map[RMAP_OUT].name);
12750
12751 /* ebgp-requires-policy (inbound) */
12752 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12753 && !bgp_inbound_policy_exists(p, filter))
12754 vty_out(vty,
12755 " Inbound updates discarded due to missing policy\n");
12756
12757 /* ebgp-requires-policy (outbound) */
12758 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12759 && !bgp_outbound_policy_exists(p, filter))
12760 vty_out(vty,
12761 " Outbound updates discarded due to missing policy\n");
12762
12763 /* unsuppress-map */
12764 if (filter->usmap.name)
12765 vty_out(vty,
12766 " Route map for selective unsuppress is %s%s\n",
12767 filter->usmap.map ? "*" : "",
12768 filter->usmap.name);
12769
12770 /* advertise-map */
12771 if (filter->advmap.aname && filter->advmap.cname)
12772 vty_out(vty,
12773 " Condition %s, Condition-map %s%s, Advertise-map %s%s, status: %s\n",
12774 filter->advmap.condition ? "EXIST"
12775 : "NON_EXIST",
12776 filter->advmap.cmap ? "*" : "",
12777 filter->advmap.cname,
12778 filter->advmap.amap ? "*" : "",
12779 filter->advmap.aname,
12780 filter->advmap.update_type ==
12781 UPDATE_TYPE_ADVERTISE
12782 ? "Advertise"
12783 : "Withdraw");
12784
12785 /* Receive prefix count */
12786 vty_out(vty, " %u accepted prefixes\n",
12787 p->pcount[afi][safi]);
12788
12789 /* maximum-prefix-out */
12790 if (CHECK_FLAG(p->af_flags[afi][safi],
12791 PEER_FLAG_MAX_PREFIX_OUT))
12792 vty_out(vty,
12793 " Maximum allowed prefixes sent %u\n",
12794 p->pmax_out[afi][safi]);
12795
12796 /* Maximum prefix */
12797 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
12798 vty_out(vty,
12799 " Maximum prefixes allowed %u%s\n",
12800 p->pmax[afi][safi],
12801 CHECK_FLAG(p->af_flags[afi][safi],
12802 PEER_FLAG_MAX_PREFIX_WARNING)
12803 ? " (warning-only)"
12804 : "");
12805 vty_out(vty, " Threshold for warning message %d%%",
12806 p->pmax_threshold[afi][safi]);
12807 if (p->pmax_restart[afi][safi])
12808 vty_out(vty, ", restart interval %d min",
12809 p->pmax_restart[afi][safi]);
12810 vty_out(vty, "\n");
12811 }
12812
12813 vty_out(vty, "\n");
12814 }
12815 }
12816
12817 static void bgp_show_peer(struct vty *vty, struct peer *p, bool use_json,
12818 json_object *json)
12819 {
12820 struct bgp *bgp;
12821 char buf1[PREFIX2STR_BUFFER];
12822 char timebuf[BGP_UPTIME_LEN];
12823 char dn_flag[2];
12824 afi_t afi;
12825 safi_t safi;
12826 uint16_t i;
12827 uint8_t *msg;
12828 json_object *json_neigh = NULL;
12829 time_t epoch_tbuf;
12830 uint32_t sync_tcp_mss;
12831
12832 bgp = p->bgp;
12833
12834 if (use_json)
12835 json_neigh = json_object_new_object();
12836
12837 memset(dn_flag, '\0', sizeof(dn_flag));
12838 if (!p->conf_if && peer_dynamic_neighbor(p))
12839 dn_flag[0] = '*';
12840
12841 if (!use_json) {
12842 if (p->conf_if) /* Configured interface name. */
12843 vty_out(vty, "BGP neighbor on %s: %pSU, ", p->conf_if,
12844 &p->su);
12845 else /* Configured IP address. */
12846 vty_out(vty, "BGP neighbor is %s%s, ", dn_flag,
12847 p->host);
12848 }
12849
12850 if (use_json) {
12851 if (p->conf_if && BGP_PEER_SU_UNSPEC(p))
12852 json_object_string_add(json_neigh, "bgpNeighborAddr",
12853 "none");
12854 else if (p->conf_if && !BGP_PEER_SU_UNSPEC(p))
12855 json_object_string_addf(json_neigh, "bgpNeighborAddr",
12856 "%pSU", &p->su);
12857
12858 json_object_int_add(json_neigh, "remoteAs", p->as);
12859
12860 if (p->change_local_as)
12861 json_object_int_add(json_neigh, "localAs",
12862 p->change_local_as);
12863 else
12864 json_object_int_add(json_neigh, "localAs", p->local_as);
12865
12866 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
12867 json_object_boolean_true_add(json_neigh,
12868 "localAsNoPrepend");
12869
12870 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS))
12871 json_object_boolean_true_add(json_neigh,
12872 "localAsReplaceAs");
12873 } else {
12874 if ((p->as_type == AS_SPECIFIED) || (p->as_type == AS_EXTERNAL)
12875 || (p->as_type == AS_INTERNAL))
12876 vty_out(vty, "remote AS %u, ", p->as);
12877 else
12878 vty_out(vty, "remote AS Unspecified, ");
12879 vty_out(vty, "local AS %u%s%s, ",
12880 p->change_local_as ? p->change_local_as : p->local_as,
12881 CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND)
12882 ? " no-prepend"
12883 : "",
12884 CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS)
12885 ? " replace-as"
12886 : "");
12887 }
12888 /* peer type internal or confed-internal */
12889 if ((p->as == p->local_as) || (p->as_type == AS_INTERNAL)) {
12890 if (use_json) {
12891 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
12892 json_object_boolean_true_add(
12893 json_neigh, "nbrConfedInternalLink");
12894 else
12895 json_object_boolean_true_add(json_neigh,
12896 "nbrInternalLink");
12897 } else {
12898 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
12899 vty_out(vty, "confed-internal link\n");
12900 else
12901 vty_out(vty, "internal link\n");
12902 }
12903 /* peer type external or confed-external */
12904 } else if (p->as || (p->as_type == AS_EXTERNAL)) {
12905 if (use_json) {
12906 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
12907 json_object_boolean_true_add(
12908 json_neigh, "nbrConfedExternalLink");
12909 else
12910 json_object_boolean_true_add(json_neigh,
12911 "nbrExternalLink");
12912 } else {
12913 if (bgp_confederation_peers_check(bgp, p->as))
12914 vty_out(vty, "confed-external link\n");
12915 else
12916 vty_out(vty, "external link\n");
12917 }
12918 } else {
12919 if (use_json)
12920 json_object_boolean_true_add(json_neigh,
12921 "nbrUnspecifiedLink");
12922 else
12923 vty_out(vty, "unspecified link\n");
12924 }
12925
12926 /* Roles */
12927 if (use_json) {
12928 json_object_string_add(json_neigh, "localRole",
12929 bgp_get_name_by_role(p->local_role));
12930 json_object_string_add(json_neigh, "remoteRole",
12931 bgp_get_name_by_role(p->remote_role));
12932 } else {
12933 vty_out(vty, " Local Role: %s\n",
12934 bgp_get_name_by_role(p->local_role));
12935 vty_out(vty, " Remote Role: %s\n",
12936 bgp_get_name_by_role(p->remote_role));
12937 }
12938
12939
12940 /* Description. */
12941 if (p->desc) {
12942 if (use_json)
12943 json_object_string_add(json_neigh, "nbrDesc", p->desc);
12944 else
12945 vty_out(vty, " Description: %s\n", p->desc);
12946 }
12947
12948 if (p->hostname) {
12949 if (use_json) {
12950 if (p->hostname)
12951 json_object_string_add(json_neigh, "hostname",
12952 p->hostname);
12953
12954 if (p->domainname)
12955 json_object_string_add(json_neigh, "domainname",
12956 p->domainname);
12957 } else {
12958 if (p->domainname && (p->domainname[0] != '\0'))
12959 vty_out(vty, "Hostname: %s.%s\n", p->hostname,
12960 p->domainname);
12961 else
12962 vty_out(vty, "Hostname: %s\n", p->hostname);
12963 }
12964 }
12965
12966 /* Peer-group */
12967 if (p->group) {
12968 if (use_json) {
12969 json_object_string_add(json_neigh, "peerGroup",
12970 p->group->name);
12971
12972 if (dn_flag[0]) {
12973 struct prefix prefix, *range = NULL;
12974
12975 if (sockunion2hostprefix(&(p->su), &prefix))
12976 range = peer_group_lookup_dynamic_neighbor_range(
12977 p->group, &prefix);
12978
12979 if (range) {
12980 json_object_string_addf(
12981 json_neigh,
12982 "peerSubnetRangeGroup", "%pFX",
12983 range);
12984 }
12985 }
12986 } else {
12987 vty_out(vty,
12988 " Member of peer-group %s for session parameters\n",
12989 p->group->name);
12990
12991 if (dn_flag[0]) {
12992 struct prefix prefix, *range = NULL;
12993
12994 if (sockunion2hostprefix(&(p->su), &prefix))
12995 range = peer_group_lookup_dynamic_neighbor_range(
12996 p->group, &prefix);
12997
12998 if (range) {
12999 vty_out(vty,
13000 " Belongs to the subnet range group: %pFX\n",
13001 range);
13002 }
13003 }
13004 }
13005 }
13006
13007 if (use_json) {
13008 /* Administrative shutdown. */
13009 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN)
13010 || CHECK_FLAG(p->bgp->flags, BGP_FLAG_SHUTDOWN))
13011 json_object_boolean_true_add(json_neigh,
13012 "adminShutDown");
13013
13014 /* BGP Version. */
13015 json_object_int_add(json_neigh, "bgpVersion", 4);
13016 json_object_string_addf(json_neigh, "remoteRouterId", "%pI4",
13017 &p->remote_id);
13018 json_object_string_addf(json_neigh, "localRouterId", "%pI4",
13019 &bgp->router_id);
13020
13021 /* Confederation */
13022 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
13023 && bgp_confederation_peers_check(bgp, p->as))
13024 json_object_boolean_true_add(json_neigh,
13025 "nbrCommonAdmin");
13026
13027 /* Status. */
13028 json_object_string_add(
13029 json_neigh, "bgpState",
13030 lookup_msg(bgp_status_msg, p->status, NULL));
13031
13032 if (peer_established(p)) {
13033 time_t uptime;
13034
13035 uptime = monotime(NULL);
13036 uptime -= p->uptime;
13037 epoch_tbuf = time(NULL) - uptime;
13038
13039 json_object_int_add(json_neigh, "bgpTimerUpMsec",
13040 uptime * 1000);
13041 json_object_string_add(json_neigh, "bgpTimerUpString",
13042 peer_uptime(p->uptime, timebuf,
13043 BGP_UPTIME_LEN, 0,
13044 NULL));
13045 json_object_int_add(json_neigh,
13046 "bgpTimerUpEstablishedEpoch",
13047 epoch_tbuf);
13048 }
13049
13050 else if (p->status == Active) {
13051 if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
13052 json_object_string_add(json_neigh, "bgpStateIs",
13053 "passive");
13054 else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
13055 json_object_string_add(json_neigh, "bgpStateIs",
13056 "passiveNSF");
13057 }
13058
13059 /* read timer */
13060 time_t uptime;
13061 struct tm tm;
13062
13063 uptime = monotime(NULL);
13064 uptime -= p->readtime;
13065 gmtime_r(&uptime, &tm);
13066
13067 json_object_int_add(json_neigh, "bgpTimerLastRead",
13068 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13069 + (tm.tm_hour * 3600000));
13070
13071 uptime = monotime(NULL);
13072 uptime -= p->last_write;
13073 gmtime_r(&uptime, &tm);
13074
13075 json_object_int_add(json_neigh, "bgpTimerLastWrite",
13076 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13077 + (tm.tm_hour * 3600000));
13078
13079 uptime = monotime(NULL);
13080 uptime -= p->update_time;
13081 gmtime_r(&uptime, &tm);
13082
13083 json_object_int_add(json_neigh, "bgpInUpdateElapsedTimeMsecs",
13084 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13085 + (tm.tm_hour * 3600000));
13086
13087 /* Configured timer values. */
13088 json_object_int_add(json_neigh,
13089 "bgpTimerConfiguredHoldTimeMsecs",
13090 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13091 ? p->holdtime * 1000
13092 : bgp->default_holdtime * 1000);
13093 json_object_int_add(json_neigh,
13094 "bgpTimerConfiguredKeepAliveIntervalMsecs",
13095 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13096 ? p->keepalive * 1000
13097 : bgp->default_keepalive * 1000);
13098 json_object_int_add(json_neigh, "bgpTimerHoldTimeMsecs",
13099 p->v_holdtime * 1000);
13100 json_object_int_add(json_neigh,
13101 "bgpTimerKeepAliveIntervalMsecs",
13102 p->v_keepalive * 1000);
13103 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER_DELAYOPEN)) {
13104 json_object_int_add(json_neigh,
13105 "bgpTimerDelayOpenTimeMsecs",
13106 p->v_delayopen * 1000);
13107 }
13108
13109 /* Configured and Synced tcp-mss value for peer */
13110 if (CHECK_FLAG(p->flags, PEER_FLAG_TCP_MSS)) {
13111 sync_tcp_mss = sockopt_tcp_mss_get(p->fd);
13112 json_object_int_add(json_neigh, "bgpTcpMssConfigured",
13113 p->tcp_mss);
13114 json_object_int_add(json_neigh, "bgpTcpMssSynced",
13115 sync_tcp_mss);
13116 }
13117
13118 /* Extended Optional Parameters Length for BGP OPEN Message */
13119 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(p))
13120 json_object_boolean_true_add(
13121 json_neigh, "extendedOptionalParametersLength");
13122 else
13123 json_object_boolean_false_add(
13124 json_neigh, "extendedOptionalParametersLength");
13125
13126 /* Conditional advertisements */
13127 json_object_int_add(
13128 json_neigh,
13129 "bgpTimerConfiguredConditionalAdvertisementsSec",
13130 bgp->condition_check_period);
13131 if (thread_is_scheduled(bgp->t_condition_check))
13132 json_object_int_add(
13133 json_neigh,
13134 "bgpTimerUntilConditionalAdvertisementsSec",
13135 thread_timer_remain_second(
13136 bgp->t_condition_check));
13137 } else {
13138 /* Administrative shutdown. */
13139 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN)
13140 || CHECK_FLAG(p->bgp->flags, BGP_FLAG_SHUTDOWN))
13141 vty_out(vty, " Administratively shut down\n");
13142
13143 /* BGP Version. */
13144 vty_out(vty, " BGP version 4");
13145 vty_out(vty, ", remote router ID %s",
13146 inet_ntop(AF_INET, &p->remote_id, buf1, sizeof(buf1)));
13147 vty_out(vty, ", local router ID %s\n",
13148 inet_ntop(AF_INET, &bgp->router_id, buf1,
13149 sizeof(buf1)));
13150
13151 /* Confederation */
13152 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
13153 && bgp_confederation_peers_check(bgp, p->as))
13154 vty_out(vty,
13155 " Neighbor under common administration\n");
13156
13157 /* Status. */
13158 vty_out(vty, " BGP state = %s",
13159 lookup_msg(bgp_status_msg, p->status, NULL));
13160
13161 if (peer_established(p))
13162 vty_out(vty, ", up for %8s",
13163 peer_uptime(p->uptime, timebuf, BGP_UPTIME_LEN,
13164 0, NULL));
13165
13166 else if (p->status == Active) {
13167 if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
13168 vty_out(vty, " (passive)");
13169 else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
13170 vty_out(vty, " (NSF passive)");
13171 }
13172 vty_out(vty, "\n");
13173
13174 /* read timer */
13175 vty_out(vty, " Last read %s",
13176 peer_uptime(p->readtime, timebuf, BGP_UPTIME_LEN, 0,
13177 NULL));
13178 vty_out(vty, ", Last write %s\n",
13179 peer_uptime(p->last_write, timebuf, BGP_UPTIME_LEN, 0,
13180 NULL));
13181
13182 /* Configured timer values. */
13183 vty_out(vty,
13184 " Hold time is %d seconds, keepalive interval is %d seconds\n",
13185 p->v_holdtime, p->v_keepalive);
13186 vty_out(vty, " Configured hold time is %d seconds",
13187 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13188 ? p->holdtime
13189 : bgp->default_holdtime);
13190 vty_out(vty, ", keepalive interval is %d seconds\n",
13191 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13192 ? p->keepalive
13193 : bgp->default_keepalive);
13194 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER_DELAYOPEN))
13195 vty_out(vty,
13196 " Configured DelayOpenTime is %d seconds\n",
13197 p->delayopen);
13198
13199 /* Configured and synced tcp-mss value for peer */
13200 if (CHECK_FLAG(p->flags, PEER_FLAG_TCP_MSS)) {
13201 sync_tcp_mss = sockopt_tcp_mss_get(p->fd);
13202 vty_out(vty, " Configured tcp-mss is %d", p->tcp_mss);
13203 vty_out(vty, ", synced tcp-mss is %d\n", sync_tcp_mss);
13204 }
13205
13206 /* Extended Optional Parameters Length for BGP OPEN Message */
13207 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(p))
13208 vty_out(vty,
13209 " Extended Optional Parameters Length is enabled\n");
13210
13211 /* Conditional advertisements */
13212 vty_out(vty,
13213 " Configured conditional advertisements interval is %d seconds\n",
13214 bgp->condition_check_period);
13215 if (thread_is_scheduled(bgp->t_condition_check))
13216 vty_out(vty,
13217 " Time until conditional advertisements begin is %lu seconds\n",
13218 thread_timer_remain_second(
13219 bgp->t_condition_check));
13220 }
13221 /* Capability. */
13222 if (peer_established(p) &&
13223 (p->cap || peer_afc_advertised(p) || peer_afc_received(p))) {
13224 if (use_json) {
13225 json_object *json_cap = NULL;
13226
13227 json_cap = json_object_new_object();
13228
13229 /* AS4 */
13230 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV) ||
13231 CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
13232 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV) &&
13233 CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
13234 json_object_string_add(
13235 json_cap, "4byteAs",
13236 "advertisedAndReceived");
13237 else if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV))
13238 json_object_string_add(json_cap,
13239 "4byteAs",
13240 "advertised");
13241 else if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
13242 json_object_string_add(json_cap,
13243 "4byteAs",
13244 "received");
13245 }
13246
13247 /* Extended Message Support */
13248 if (CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_ADV) &&
13249 CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_RCV))
13250 json_object_string_add(json_cap,
13251 "extendedMessage",
13252 "advertisedAndReceived");
13253 else if (CHECK_FLAG(p->cap,
13254 PEER_CAP_EXTENDED_MESSAGE_ADV))
13255 json_object_string_add(json_cap,
13256 "extendedMessage",
13257 "advertised");
13258 else if (CHECK_FLAG(p->cap,
13259 PEER_CAP_EXTENDED_MESSAGE_RCV))
13260 json_object_string_add(json_cap,
13261 "extendedMessage",
13262 "received");
13263
13264 /* AddPath */
13265 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV) ||
13266 CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_ADV)) {
13267 json_object *json_add = NULL;
13268 const char *print_store;
13269
13270 json_add = json_object_new_object();
13271
13272 FOREACH_AFI_SAFI (afi, safi) {
13273 json_object *json_sub = NULL;
13274 json_sub = json_object_new_object();
13275 print_store = get_afi_safi_str(
13276 afi, safi, true);
13277
13278 if (CHECK_FLAG(
13279 p->af_cap[afi][safi],
13280 PEER_CAP_ADDPATH_AF_TX_ADV) ||
13281 CHECK_FLAG(
13282 p->af_cap[afi][safi],
13283 PEER_CAP_ADDPATH_AF_TX_RCV)) {
13284 if (CHECK_FLAG(
13285 p->af_cap[afi]
13286 [safi],
13287 PEER_CAP_ADDPATH_AF_TX_ADV) &&
13288 CHECK_FLAG(
13289 p->af_cap[afi]
13290 [safi],
13291 PEER_CAP_ADDPATH_AF_TX_RCV))
13292 json_object_boolean_true_add(
13293 json_sub,
13294 "txAdvertisedAndReceived");
13295 else if (
13296 CHECK_FLAG(
13297 p->af_cap[afi]
13298 [safi],
13299 PEER_CAP_ADDPATH_AF_TX_ADV))
13300 json_object_boolean_true_add(
13301 json_sub,
13302 "txAdvertised");
13303 else if (
13304 CHECK_FLAG(
13305 p->af_cap[afi]
13306 [safi],
13307 PEER_CAP_ADDPATH_AF_TX_RCV))
13308 json_object_boolean_true_add(
13309 json_sub,
13310 "txReceived");
13311 }
13312
13313 if (CHECK_FLAG(
13314 p->af_cap[afi][safi],
13315 PEER_CAP_ADDPATH_AF_RX_ADV) ||
13316 CHECK_FLAG(
13317 p->af_cap[afi][safi],
13318 PEER_CAP_ADDPATH_AF_RX_RCV)) {
13319 if (CHECK_FLAG(
13320 p->af_cap[afi]
13321 [safi],
13322 PEER_CAP_ADDPATH_AF_RX_ADV) &&
13323 CHECK_FLAG(
13324 p->af_cap[afi]
13325 [safi],
13326 PEER_CAP_ADDPATH_AF_RX_RCV))
13327 json_object_boolean_true_add(
13328 json_sub,
13329 "rxAdvertisedAndReceived");
13330 else if (
13331 CHECK_FLAG(
13332 p->af_cap[afi]
13333 [safi],
13334 PEER_CAP_ADDPATH_AF_RX_ADV))
13335 json_object_boolean_true_add(
13336 json_sub,
13337 "rxAdvertised");
13338 else if (
13339 CHECK_FLAG(
13340 p->af_cap[afi]
13341 [safi],
13342 PEER_CAP_ADDPATH_AF_RX_RCV))
13343 json_object_boolean_true_add(
13344 json_sub,
13345 "rxReceived");
13346 }
13347
13348 if (CHECK_FLAG(
13349 p->af_cap[afi][safi],
13350 PEER_CAP_ADDPATH_AF_TX_ADV) ||
13351 CHECK_FLAG(
13352 p->af_cap[afi][safi],
13353 PEER_CAP_ADDPATH_AF_TX_RCV) ||
13354 CHECK_FLAG(
13355 p->af_cap[afi][safi],
13356 PEER_CAP_ADDPATH_AF_RX_ADV) ||
13357 CHECK_FLAG(
13358 p->af_cap[afi][safi],
13359 PEER_CAP_ADDPATH_AF_RX_RCV))
13360 json_object_object_add(
13361 json_add, print_store,
13362 json_sub);
13363 else
13364 json_object_free(json_sub);
13365 }
13366
13367 json_object_object_add(json_cap, "addPath",
13368 json_add);
13369 }
13370
13371 /* Dynamic */
13372 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV) ||
13373 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV)) {
13374 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV) &&
13375 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV))
13376 json_object_string_add(
13377 json_cap, "dynamic",
13378 "advertisedAndReceived");
13379 else if (CHECK_FLAG(p->cap,
13380 PEER_CAP_DYNAMIC_ADV))
13381 json_object_string_add(json_cap,
13382 "dynamic",
13383 "advertised");
13384 else if (CHECK_FLAG(p->cap,
13385 PEER_CAP_DYNAMIC_RCV))
13386 json_object_string_add(json_cap,
13387 "dynamic",
13388 "received");
13389 }
13390
13391 /* Role */
13392 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV) ||
13393 CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV)) {
13394 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV) &&
13395 CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
13396 json_object_string_add(
13397 json_cap, "role",
13398 "advertisedAndReceived");
13399 else if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV))
13400 json_object_string_add(json_cap, "role",
13401 "advertised");
13402 else if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
13403 json_object_string_add(json_cap, "role",
13404 "received");
13405 }
13406
13407 /* Extended nexthop */
13408 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV) ||
13409 CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
13410 json_object *json_nxt = NULL;
13411 const char *print_store;
13412
13413
13414 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV) &&
13415 CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
13416 json_object_string_add(
13417 json_cap, "extendedNexthop",
13418 "advertisedAndReceived");
13419 else if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV))
13420 json_object_string_add(
13421 json_cap, "extendedNexthop",
13422 "advertised");
13423 else if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
13424 json_object_string_add(
13425 json_cap, "extendedNexthop",
13426 "received");
13427
13428 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)) {
13429 json_nxt = json_object_new_object();
13430
13431 for (safi = SAFI_UNICAST;
13432 safi < SAFI_MAX; safi++) {
13433 if (CHECK_FLAG(
13434 p->af_cap[AFI_IP]
13435 [safi],
13436 PEER_CAP_ENHE_AF_RCV)) {
13437 print_store =
13438 get_afi_safi_str(
13439 AFI_IP,
13440 safi,
13441 true);
13442 json_object_string_add(
13443 json_nxt,
13444 print_store,
13445 "recieved"); /* misspelled for compatibility */
13446 }
13447 }
13448 json_object_object_add(
13449 json_cap,
13450 "extendedNexthopFamililesByPeer",
13451 json_nxt);
13452 }
13453 }
13454
13455 /* Long-lived Graceful Restart */
13456 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV) ||
13457 CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV)) {
13458 json_object *json_llgr = NULL;
13459 const char *afi_safi_str;
13460
13461 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV) &&
13462 CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
13463 json_object_string_add(
13464 json_cap,
13465 "longLivedGracefulRestart",
13466 "advertisedAndReceived");
13467 else if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV))
13468 json_object_string_add(
13469 json_cap,
13470 "longLivedGracefulRestart",
13471 "advertised");
13472 else if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
13473 json_object_string_add(
13474 json_cap,
13475 "longLivedGracefulRestart",
13476 "received");
13477
13478 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV)) {
13479 json_llgr = json_object_new_object();
13480
13481 FOREACH_AFI_SAFI (afi, safi) {
13482 if (CHECK_FLAG(
13483 p->af_cap[afi]
13484 [safi],
13485 PEER_CAP_ENHE_AF_RCV)) {
13486 afi_safi_str =
13487 get_afi_safi_str(
13488 afi,
13489 safi,
13490 true);
13491 json_object_string_add(
13492 json_llgr,
13493 afi_safi_str,
13494 "received");
13495 }
13496 }
13497 json_object_object_add(
13498 json_cap,
13499 "longLivedGracefulRestartByPeer",
13500 json_llgr);
13501 }
13502 }
13503
13504 /* Route Refresh */
13505 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) ||
13506 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_NEW_RCV) ||
13507 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_OLD_RCV)) {
13508 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) &&
13509 (CHECK_FLAG(p->cap,
13510 PEER_CAP_REFRESH_NEW_RCV) ||
13511 CHECK_FLAG(p->cap,
13512 PEER_CAP_REFRESH_OLD_RCV))) {
13513 if (CHECK_FLAG(
13514 p->cap,
13515 PEER_CAP_REFRESH_OLD_RCV) &&
13516 CHECK_FLAG(
13517 p->cap,
13518 PEER_CAP_REFRESH_NEW_RCV))
13519 json_object_string_add(
13520 json_cap,
13521 "routeRefresh",
13522 "advertisedAndReceivedOldNew");
13523 else {
13524 if (CHECK_FLAG(
13525 p->cap,
13526 PEER_CAP_REFRESH_OLD_RCV))
13527 json_object_string_add(
13528 json_cap,
13529 "routeRefresh",
13530 "advertisedAndReceivedOld");
13531 else
13532 json_object_string_add(
13533 json_cap,
13534 "routeRefresh",
13535 "advertisedAndReceivedNew");
13536 }
13537 } else if (CHECK_FLAG(p->cap,
13538 PEER_CAP_REFRESH_ADV))
13539 json_object_string_add(json_cap,
13540 "routeRefresh",
13541 "advertised");
13542 else if (CHECK_FLAG(p->cap,
13543 PEER_CAP_REFRESH_NEW_RCV) ||
13544 CHECK_FLAG(p->cap,
13545 PEER_CAP_REFRESH_OLD_RCV))
13546 json_object_string_add(json_cap,
13547 "routeRefresh",
13548 "received");
13549 }
13550
13551 /* Enhanced Route Refresh */
13552 if (CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_ADV) ||
13553 CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_RCV)) {
13554 if (CHECK_FLAG(p->cap,
13555 PEER_CAP_ENHANCED_RR_ADV) &&
13556 CHECK_FLAG(p->cap,
13557 PEER_CAP_ENHANCED_RR_RCV))
13558 json_object_string_add(
13559 json_cap,
13560 "enhancedRouteRefresh",
13561 "advertisedAndReceived");
13562 else if (CHECK_FLAG(p->cap,
13563 PEER_CAP_ENHANCED_RR_ADV))
13564 json_object_string_add(
13565 json_cap,
13566 "enhancedRouteRefresh",
13567 "advertised");
13568 else if (CHECK_FLAG(p->cap,
13569 PEER_CAP_ENHANCED_RR_RCV))
13570 json_object_string_add(
13571 json_cap,
13572 "enhancedRouteRefresh",
13573 "received");
13574 }
13575
13576 /* Multiprotocol Extensions */
13577 json_object *json_multi = NULL;
13578
13579 json_multi = json_object_new_object();
13580
13581 FOREACH_AFI_SAFI (afi, safi) {
13582 if (p->afc_adv[afi][safi] ||
13583 p->afc_recv[afi][safi]) {
13584 json_object *json_exten = NULL;
13585 json_exten = json_object_new_object();
13586
13587 if (p->afc_adv[afi][safi] &&
13588 p->afc_recv[afi][safi])
13589 json_object_boolean_true_add(
13590 json_exten,
13591 "advertisedAndReceived");
13592 else if (p->afc_adv[afi][safi])
13593 json_object_boolean_true_add(
13594 json_exten,
13595 "advertised");
13596 else if (p->afc_recv[afi][safi])
13597 json_object_boolean_true_add(
13598 json_exten, "received");
13599
13600 json_object_object_add(
13601 json_multi,
13602 get_afi_safi_str(afi, safi,
13603 true),
13604 json_exten);
13605 }
13606 }
13607 json_object_object_add(json_cap,
13608 "multiprotocolExtensions",
13609 json_multi);
13610
13611 /* Hostname capabilities */
13612 json_object *json_hname = NULL;
13613
13614 json_hname = json_object_new_object();
13615
13616 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
13617 json_object_string_add(
13618 json_hname, "advHostName",
13619 bgp->peer_self->hostname
13620 ? bgp->peer_self->hostname
13621 : "n/a");
13622 json_object_string_add(
13623 json_hname, "advDomainName",
13624 bgp->peer_self->domainname
13625 ? bgp->peer_self->domainname
13626 : "n/a");
13627 }
13628
13629
13630 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
13631 json_object_string_add(
13632 json_hname, "rcvHostName",
13633 p->hostname ? p->hostname : "n/a");
13634 json_object_string_add(
13635 json_hname, "rcvDomainName",
13636 p->domainname ? p->domainname : "n/a");
13637 }
13638
13639 json_object_object_add(json_cap, "hostName",
13640 json_hname);
13641
13642 /* Graceful Restart */
13643 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) ||
13644 CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)) {
13645 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV) &&
13646 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
13647 json_object_string_add(
13648 json_cap, "gracefulRestart",
13649 "advertisedAndReceived");
13650 else if (CHECK_FLAG(p->cap,
13651 PEER_CAP_RESTART_ADV))
13652 json_object_string_add(
13653 json_cap,
13654 "gracefulRestartCapability",
13655 "advertised");
13656 else if (CHECK_FLAG(p->cap,
13657 PEER_CAP_RESTART_RCV))
13658 json_object_string_add(
13659 json_cap,
13660 "gracefulRestartCapability",
13661 "received");
13662
13663 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
13664 int restart_af_count = 0;
13665 json_object *json_restart = NULL;
13666 json_restart = json_object_new_object();
13667
13668 json_object_int_add(
13669 json_cap,
13670 "gracefulRestartRemoteTimerMsecs",
13671 p->v_gr_restart * 1000);
13672
13673 FOREACH_AFI_SAFI (afi, safi) {
13674 if (CHECK_FLAG(
13675 p->af_cap[afi]
13676 [safi],
13677 PEER_CAP_RESTART_AF_RCV)) {
13678 json_object *json_sub =
13679 NULL;
13680 json_sub =
13681 json_object_new_object();
13682
13683 if (CHECK_FLAG(
13684 p->af_cap
13685 [afi]
13686 [safi],
13687 PEER_CAP_RESTART_AF_PRESERVE_RCV))
13688 json_object_boolean_true_add(
13689 json_sub,
13690 "preserved");
13691 restart_af_count++;
13692 json_object_object_add(
13693 json_restart,
13694 get_afi_safi_str(
13695 afi,
13696 safi,
13697 true),
13698 json_sub);
13699 }
13700 }
13701 if (!restart_af_count) {
13702 json_object_string_add(
13703 json_cap,
13704 "addressFamiliesByPeer",
13705 "none");
13706 json_object_free(json_restart);
13707 } else
13708 json_object_object_add(
13709 json_cap,
13710 "addressFamiliesByPeer",
13711 json_restart);
13712 }
13713 }
13714 json_object_object_add(
13715 json_neigh, "neighborCapabilities", json_cap);
13716 } else {
13717 vty_out(vty, " Neighbor capabilities:\n");
13718
13719 /* AS4 */
13720 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV) ||
13721 CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
13722 vty_out(vty, " 4 Byte AS:");
13723 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV))
13724 vty_out(vty, " advertised");
13725 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
13726 vty_out(vty, " %sreceived",
13727 CHECK_FLAG(p->cap,
13728 PEER_CAP_AS4_ADV)
13729 ? "and "
13730 : "");
13731 vty_out(vty, "\n");
13732 }
13733
13734 /* Extended Message Support */
13735 if (CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_RCV) ||
13736 CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_ADV)) {
13737 vty_out(vty, " Extended Message:");
13738 if (CHECK_FLAG(p->cap,
13739 PEER_CAP_EXTENDED_MESSAGE_ADV))
13740 vty_out(vty, " advertised");
13741 if (CHECK_FLAG(p->cap,
13742 PEER_CAP_EXTENDED_MESSAGE_RCV))
13743 vty_out(vty, " %sreceived",
13744 CHECK_FLAG(
13745 p->cap,
13746 PEER_CAP_EXTENDED_MESSAGE_ADV)
13747 ? "and "
13748 : "");
13749 vty_out(vty, "\n");
13750 }
13751
13752 /* AddPath */
13753 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV) ||
13754 CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_ADV)) {
13755 vty_out(vty, " AddPath:\n");
13756
13757 FOREACH_AFI_SAFI (afi, safi) {
13758 if (CHECK_FLAG(
13759 p->af_cap[afi][safi],
13760 PEER_CAP_ADDPATH_AF_TX_ADV) ||
13761 CHECK_FLAG(
13762 p->af_cap[afi][safi],
13763 PEER_CAP_ADDPATH_AF_TX_RCV)) {
13764 vty_out(vty, " %s: TX ",
13765 get_afi_safi_str(
13766 afi, safi,
13767 false));
13768
13769 if (CHECK_FLAG(
13770 p->af_cap[afi]
13771 [safi],
13772 PEER_CAP_ADDPATH_AF_TX_ADV))
13773 vty_out(vty,
13774 "advertised");
13775
13776 if (CHECK_FLAG(
13777 p->af_cap[afi]
13778 [safi],
13779 PEER_CAP_ADDPATH_AF_TX_RCV))
13780 vty_out(vty,
13781 "%sreceived",
13782 CHECK_FLAG(
13783 p->af_cap
13784 [afi]
13785 [safi],
13786 PEER_CAP_ADDPATH_AF_TX_ADV)
13787 ? " and "
13788 : "");
13789
13790 vty_out(vty, "\n");
13791 }
13792
13793 if (CHECK_FLAG(
13794 p->af_cap[afi][safi],
13795 PEER_CAP_ADDPATH_AF_RX_ADV) ||
13796 CHECK_FLAG(
13797 p->af_cap[afi][safi],
13798 PEER_CAP_ADDPATH_AF_RX_RCV)) {
13799 vty_out(vty, " %s: RX ",
13800 get_afi_safi_str(
13801 afi, safi,
13802 false));
13803
13804 if (CHECK_FLAG(
13805 p->af_cap[afi]
13806 [safi],
13807 PEER_CAP_ADDPATH_AF_RX_ADV))
13808 vty_out(vty,
13809 "advertised");
13810
13811 if (CHECK_FLAG(
13812 p->af_cap[afi]
13813 [safi],
13814 PEER_CAP_ADDPATH_AF_RX_RCV))
13815 vty_out(vty,
13816 "%sreceived",
13817 CHECK_FLAG(
13818 p->af_cap
13819 [afi]
13820 [safi],
13821 PEER_CAP_ADDPATH_AF_RX_ADV)
13822 ? " and "
13823 : "");
13824
13825 vty_out(vty, "\n");
13826 }
13827 }
13828 }
13829
13830 /* Dynamic */
13831 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV) ||
13832 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV)) {
13833 vty_out(vty, " Dynamic:");
13834 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV))
13835 vty_out(vty, " advertised");
13836 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV))
13837 vty_out(vty, " %sreceived",
13838 CHECK_FLAG(p->cap,
13839 PEER_CAP_DYNAMIC_ADV)
13840 ? "and "
13841 : "");
13842 vty_out(vty, "\n");
13843 }
13844
13845 /* Role */
13846 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV) ||
13847 CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV)) {
13848 vty_out(vty, " Role:");
13849 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV))
13850 vty_out(vty, " advertised");
13851 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
13852 vty_out(vty, " %sreceived",
13853 CHECK_FLAG(p->cap,
13854 PEER_CAP_ROLE_ADV)
13855 ? "and "
13856 : "");
13857 vty_out(vty, "\n");
13858 }
13859
13860 /* Extended nexthop */
13861 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV) ||
13862 CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
13863 vty_out(vty, " Extended nexthop:");
13864 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV))
13865 vty_out(vty, " advertised");
13866 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
13867 vty_out(vty, " %sreceived",
13868 CHECK_FLAG(p->cap,
13869 PEER_CAP_ENHE_ADV)
13870 ? "and "
13871 : "");
13872 vty_out(vty, "\n");
13873
13874 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)) {
13875 vty_out(vty,
13876 " Address families by peer:\n ");
13877 for (safi = SAFI_UNICAST;
13878 safi < SAFI_MAX; safi++)
13879 if (CHECK_FLAG(
13880 p->af_cap[AFI_IP]
13881 [safi],
13882 PEER_CAP_ENHE_AF_RCV))
13883 vty_out(vty,
13884 " %s\n",
13885 get_afi_safi_str(
13886 AFI_IP,
13887 safi,
13888 false));
13889 }
13890 }
13891
13892 /* Long-lived Graceful Restart */
13893 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV) ||
13894 CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV)) {
13895 vty_out(vty,
13896 " Long-lived Graceful Restart:");
13897 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV))
13898 vty_out(vty, " advertised");
13899 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
13900 vty_out(vty, " %sreceived",
13901 CHECK_FLAG(p->cap,
13902 PEER_CAP_LLGR_ADV)
13903 ? "and "
13904 : "");
13905 vty_out(vty, "\n");
13906
13907 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV)) {
13908 vty_out(vty,
13909 " Address families by peer:\n");
13910 FOREACH_AFI_SAFI (afi, safi)
13911 if (CHECK_FLAG(
13912 p->af_cap[afi]
13913 [safi],
13914 PEER_CAP_LLGR_AF_RCV))
13915 vty_out(vty,
13916 " %s\n",
13917 get_afi_safi_str(
13918 afi,
13919 safi,
13920 false));
13921 }
13922 }
13923
13924 /* Route Refresh */
13925 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) ||
13926 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_NEW_RCV) ||
13927 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_OLD_RCV)) {
13928 vty_out(vty, " Route refresh:");
13929 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV))
13930 vty_out(vty, " advertised");
13931 if (CHECK_FLAG(p->cap,
13932 PEER_CAP_REFRESH_NEW_RCV) ||
13933 CHECK_FLAG(p->cap,
13934 PEER_CAP_REFRESH_OLD_RCV))
13935 vty_out(vty, " %sreceived(%s)",
13936 CHECK_FLAG(p->cap,
13937 PEER_CAP_REFRESH_ADV)
13938 ? "and "
13939 : "",
13940 (CHECK_FLAG(
13941 p->cap,
13942 PEER_CAP_REFRESH_OLD_RCV) &&
13943 CHECK_FLAG(
13944 p->cap,
13945 PEER_CAP_REFRESH_NEW_RCV))
13946 ? "old & new"
13947 : CHECK_FLAG(
13948 p->cap,
13949 PEER_CAP_REFRESH_OLD_RCV)
13950 ? "old"
13951 : "new");
13952
13953 vty_out(vty, "\n");
13954 }
13955
13956 /* Enhanced Route Refresh */
13957 if (CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_ADV) ||
13958 CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_RCV)) {
13959 vty_out(vty, " Enhanced Route Refresh:");
13960 if (CHECK_FLAG(p->cap,
13961 PEER_CAP_ENHANCED_RR_ADV))
13962 vty_out(vty, " advertised");
13963 if (CHECK_FLAG(p->cap,
13964 PEER_CAP_ENHANCED_RR_RCV))
13965 vty_out(vty, " %sreceived",
13966 CHECK_FLAG(p->cap,
13967 PEER_CAP_REFRESH_ADV)
13968 ? "and "
13969 : "");
13970 vty_out(vty, "\n");
13971 }
13972
13973 /* Multiprotocol Extensions */
13974 FOREACH_AFI_SAFI (afi, safi)
13975 if (p->afc_adv[afi][safi] ||
13976 p->afc_recv[afi][safi]) {
13977 vty_out(vty, " Address Family %s:",
13978 get_afi_safi_str(afi, safi,
13979 false));
13980 if (p->afc_adv[afi][safi])
13981 vty_out(vty, " advertised");
13982 if (p->afc_recv[afi][safi])
13983 vty_out(vty, " %sreceived",
13984 p->afc_adv[afi][safi]
13985 ? "and "
13986 : "");
13987 vty_out(vty, "\n");
13988 }
13989
13990 /* Hostname capability */
13991 vty_out(vty, " Hostname Capability:");
13992
13993 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
13994 vty_out(vty,
13995 " advertised (name: %s,domain name: %s)",
13996 bgp->peer_self->hostname
13997 ? bgp->peer_self->hostname
13998 : "n/a",
13999 bgp->peer_self->domainname
14000 ? bgp->peer_self->domainname
14001 : "n/a");
14002 } else {
14003 vty_out(vty, " not advertised");
14004 }
14005
14006 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
14007 vty_out(vty,
14008 " received (name: %s,domain name: %s)",
14009 p->hostname ? p->hostname : "n/a",
14010 p->domainname ? p->domainname : "n/a");
14011 } else {
14012 vty_out(vty, " not received");
14013 }
14014
14015 vty_out(vty, "\n");
14016
14017 /* Graceful Restart */
14018 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) ||
14019 CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)) {
14020 vty_out(vty,
14021 " Graceful Restart Capability:");
14022 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV))
14023 vty_out(vty, " advertised");
14024 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
14025 vty_out(vty, " %sreceived",
14026 CHECK_FLAG(p->cap,
14027 PEER_CAP_RESTART_ADV)
14028 ? "and "
14029 : "");
14030 vty_out(vty, "\n");
14031
14032 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14033 int restart_af_count = 0;
14034
14035 vty_out(vty,
14036 " Remote Restart timer is %d seconds\n",
14037 p->v_gr_restart);
14038 vty_out(vty,
14039 " Address families by peer:\n ");
14040
14041 FOREACH_AFI_SAFI (afi, safi)
14042 if (CHECK_FLAG(
14043 p->af_cap[afi]
14044 [safi],
14045 PEER_CAP_RESTART_AF_RCV)) {
14046 vty_out(vty, "%s%s(%s)",
14047 restart_af_count
14048 ? ", "
14049 : "",
14050 get_afi_safi_str(
14051 afi,
14052 safi,
14053 false),
14054 CHECK_FLAG(
14055 p->af_cap
14056 [afi]
14057 [safi],
14058 PEER_CAP_RESTART_AF_PRESERVE_RCV)
14059 ? "preserved"
14060 : "not preserved");
14061 restart_af_count++;
14062 }
14063 if (!restart_af_count)
14064 vty_out(vty, "none");
14065 vty_out(vty, "\n");
14066 }
14067 } /* Graceful Restart */
14068 }
14069 }
14070
14071 /* graceful restart information */
14072 json_object *json_grace = NULL;
14073 json_object *json_grace_send = NULL;
14074 json_object *json_grace_recv = NULL;
14075 int eor_send_af_count = 0;
14076 int eor_receive_af_count = 0;
14077
14078 if (use_json) {
14079 json_grace = json_object_new_object();
14080 json_grace_send = json_object_new_object();
14081 json_grace_recv = json_object_new_object();
14082
14083 if ((peer_established(p)) &&
14084 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14085 FOREACH_AFI_SAFI (afi, safi) {
14086 if (CHECK_FLAG(p->af_sflags[afi][safi],
14087 PEER_STATUS_EOR_SEND)) {
14088 json_object_boolean_true_add(
14089 json_grace_send,
14090 get_afi_safi_str(afi, safi,
14091 true));
14092 eor_send_af_count++;
14093 }
14094 }
14095 FOREACH_AFI_SAFI (afi, safi) {
14096 if (CHECK_FLAG(p->af_sflags[afi][safi],
14097 PEER_STATUS_EOR_RECEIVED)) {
14098 json_object_boolean_true_add(
14099 json_grace_recv,
14100 get_afi_safi_str(afi, safi,
14101 true));
14102 eor_receive_af_count++;
14103 }
14104 }
14105 }
14106 json_object_object_add(json_grace, "endOfRibSend",
14107 json_grace_send);
14108 json_object_object_add(json_grace, "endOfRibRecv",
14109 json_grace_recv);
14110
14111
14112 if (p->t_gr_restart)
14113 json_object_int_add(
14114 json_grace, "gracefulRestartTimerMsecs",
14115 thread_timer_remain_second(p->t_gr_restart) *
14116 1000);
14117
14118 if (p->t_gr_stale)
14119 json_object_int_add(
14120 json_grace, "gracefulStalepathTimerMsecs",
14121 thread_timer_remain_second(p->t_gr_stale) *
14122 1000);
14123 /* more gr info in new format */
14124 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, use_json, json_grace);
14125 json_object_object_add(json_neigh, "gracefulRestartInfo",
14126 json_grace);
14127 } else {
14128 vty_out(vty, " Graceful restart information:\n");
14129 if ((peer_established(p)) &&
14130 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14131
14132 vty_out(vty, " End-of-RIB send: ");
14133 FOREACH_AFI_SAFI (afi, safi) {
14134 if (CHECK_FLAG(p->af_sflags[afi][safi],
14135 PEER_STATUS_EOR_SEND)) {
14136 vty_out(vty, "%s%s",
14137 eor_send_af_count ? ", " : "",
14138 get_afi_safi_str(afi, safi,
14139 false));
14140 eor_send_af_count++;
14141 }
14142 }
14143 vty_out(vty, "\n");
14144 vty_out(vty, " End-of-RIB received: ");
14145 FOREACH_AFI_SAFI (afi, safi) {
14146 if (CHECK_FLAG(p->af_sflags[afi][safi],
14147 PEER_STATUS_EOR_RECEIVED)) {
14148 vty_out(vty, "%s%s",
14149 eor_receive_af_count ? ", "
14150 : "",
14151 get_afi_safi_str(afi, safi,
14152 false));
14153 eor_receive_af_count++;
14154 }
14155 }
14156 vty_out(vty, "\n");
14157 }
14158
14159 if (p->t_gr_restart)
14160 vty_out(vty,
14161 " The remaining time of restart timer is %ld\n",
14162 thread_timer_remain_second(p->t_gr_restart));
14163
14164 if (p->t_gr_stale)
14165 vty_out(vty,
14166 " The remaining time of stalepath timer is %ld\n",
14167 thread_timer_remain_second(p->t_gr_stale));
14168
14169 /* more gr info in new format */
14170 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, use_json, NULL);
14171 }
14172
14173 if (use_json) {
14174 json_object *json_stat = NULL;
14175 json_stat = json_object_new_object();
14176 /* Packet counts. */
14177
14178 atomic_size_t outq_count, inq_count;
14179 outq_count = atomic_load_explicit(&p->obuf->count,
14180 memory_order_relaxed);
14181 inq_count = atomic_load_explicit(&p->ibuf->count,
14182 memory_order_relaxed);
14183
14184 json_object_int_add(json_stat, "depthInq",
14185 (unsigned long)inq_count);
14186 json_object_int_add(json_stat, "depthOutq",
14187 (unsigned long)outq_count);
14188 json_object_int_add(json_stat, "opensSent",
14189 atomic_load_explicit(&p->open_out,
14190 memory_order_relaxed));
14191 json_object_int_add(json_stat, "opensRecv",
14192 atomic_load_explicit(&p->open_in,
14193 memory_order_relaxed));
14194 json_object_int_add(json_stat, "notificationsSent",
14195 atomic_load_explicit(&p->notify_out,
14196 memory_order_relaxed));
14197 json_object_int_add(json_stat, "notificationsRecv",
14198 atomic_load_explicit(&p->notify_in,
14199 memory_order_relaxed));
14200 json_object_int_add(json_stat, "updatesSent",
14201 atomic_load_explicit(&p->update_out,
14202 memory_order_relaxed));
14203 json_object_int_add(json_stat, "updatesRecv",
14204 atomic_load_explicit(&p->update_in,
14205 memory_order_relaxed));
14206 json_object_int_add(json_stat, "keepalivesSent",
14207 atomic_load_explicit(&p->keepalive_out,
14208 memory_order_relaxed));
14209 json_object_int_add(json_stat, "keepalivesRecv",
14210 atomic_load_explicit(&p->keepalive_in,
14211 memory_order_relaxed));
14212 json_object_int_add(json_stat, "routeRefreshSent",
14213 atomic_load_explicit(&p->refresh_out,
14214 memory_order_relaxed));
14215 json_object_int_add(json_stat, "routeRefreshRecv",
14216 atomic_load_explicit(&p->refresh_in,
14217 memory_order_relaxed));
14218 json_object_int_add(json_stat, "capabilitySent",
14219 atomic_load_explicit(&p->dynamic_cap_out,
14220 memory_order_relaxed));
14221 json_object_int_add(json_stat, "capabilityRecv",
14222 atomic_load_explicit(&p->dynamic_cap_in,
14223 memory_order_relaxed));
14224 json_object_int_add(json_stat, "totalSent", PEER_TOTAL_TX(p));
14225 json_object_int_add(json_stat, "totalRecv", PEER_TOTAL_RX(p));
14226 json_object_object_add(json_neigh, "messageStats", json_stat);
14227 } else {
14228 atomic_size_t outq_count, inq_count, open_out, open_in,
14229 notify_out, notify_in, update_out, update_in,
14230 keepalive_out, keepalive_in, refresh_out, refresh_in,
14231 dynamic_cap_out, dynamic_cap_in;
14232 outq_count = atomic_load_explicit(&p->obuf->count,
14233 memory_order_relaxed);
14234 inq_count = atomic_load_explicit(&p->ibuf->count,
14235 memory_order_relaxed);
14236 open_out = atomic_load_explicit(&p->open_out,
14237 memory_order_relaxed);
14238 open_in =
14239 atomic_load_explicit(&p->open_in, memory_order_relaxed);
14240 notify_out = atomic_load_explicit(&p->notify_out,
14241 memory_order_relaxed);
14242 notify_in = atomic_load_explicit(&p->notify_in,
14243 memory_order_relaxed);
14244 update_out = atomic_load_explicit(&p->update_out,
14245 memory_order_relaxed);
14246 update_in = atomic_load_explicit(&p->update_in,
14247 memory_order_relaxed);
14248 keepalive_out = atomic_load_explicit(&p->keepalive_out,
14249 memory_order_relaxed);
14250 keepalive_in = atomic_load_explicit(&p->keepalive_in,
14251 memory_order_relaxed);
14252 refresh_out = atomic_load_explicit(&p->refresh_out,
14253 memory_order_relaxed);
14254 refresh_in = atomic_load_explicit(&p->refresh_in,
14255 memory_order_relaxed);
14256 dynamic_cap_out = atomic_load_explicit(&p->dynamic_cap_out,
14257 memory_order_relaxed);
14258 dynamic_cap_in = atomic_load_explicit(&p->dynamic_cap_in,
14259 memory_order_relaxed);
14260
14261 /* Packet counts. */
14262 vty_out(vty, " Message statistics:\n");
14263 vty_out(vty, " Inq depth is %zu\n", inq_count);
14264 vty_out(vty, " Outq depth is %zu\n", outq_count);
14265 vty_out(vty, " Sent Rcvd\n");
14266 vty_out(vty, " Opens: %10zu %10zu\n", open_out,
14267 open_in);
14268 vty_out(vty, " Notifications: %10zu %10zu\n", notify_out,
14269 notify_in);
14270 vty_out(vty, " Updates: %10zu %10zu\n", update_out,
14271 update_in);
14272 vty_out(vty, " Keepalives: %10zu %10zu\n", keepalive_out,
14273 keepalive_in);
14274 vty_out(vty, " Route Refresh: %10zu %10zu\n", refresh_out,
14275 refresh_in);
14276 vty_out(vty, " Capability: %10zu %10zu\n",
14277 dynamic_cap_out, dynamic_cap_in);
14278 vty_out(vty, " Total: %10u %10u\n",
14279 (uint32_t)PEER_TOTAL_TX(p), (uint32_t)PEER_TOTAL_RX(p));
14280 }
14281
14282 if (use_json) {
14283 /* advertisement-interval */
14284 json_object_int_add(json_neigh,
14285 "minBtwnAdvertisementRunsTimerMsecs",
14286 p->v_routeadv * 1000);
14287
14288 /* Update-source. */
14289 if (p->update_if || p->update_source) {
14290 if (p->update_if)
14291 json_object_string_add(json_neigh,
14292 "updateSource",
14293 p->update_if);
14294 else if (p->update_source)
14295 json_object_string_addf(json_neigh,
14296 "updateSource", "%pSU",
14297 p->update_source);
14298 }
14299 } else {
14300 /* advertisement-interval */
14301 vty_out(vty,
14302 " Minimum time between advertisement runs is %d seconds\n",
14303 p->v_routeadv);
14304
14305 /* Update-source. */
14306 if (p->update_if || p->update_source) {
14307 vty_out(vty, " Update source is ");
14308 if (p->update_if)
14309 vty_out(vty, "%s", p->update_if);
14310 else if (p->update_source)
14311 vty_out(vty, "%pSU", p->update_source);
14312 vty_out(vty, "\n");
14313 }
14314
14315 vty_out(vty, "\n");
14316 }
14317
14318 /* Address Family Information */
14319 json_object *json_hold = NULL;
14320
14321 if (use_json)
14322 json_hold = json_object_new_object();
14323
14324 FOREACH_AFI_SAFI (afi, safi)
14325 if (p->afc[afi][safi])
14326 bgp_show_peer_afi(vty, p, afi, safi, use_json,
14327 json_hold);
14328
14329 if (use_json) {
14330 json_object_object_add(json_neigh, "addressFamilyInfo",
14331 json_hold);
14332 json_object_int_add(json_neigh, "connectionsEstablished",
14333 p->established);
14334 json_object_int_add(json_neigh, "connectionsDropped",
14335 p->dropped);
14336 } else
14337 vty_out(vty, " Connections established %d; dropped %d\n",
14338 p->established, p->dropped);
14339
14340 if (!p->last_reset) {
14341 if (use_json)
14342 json_object_string_add(json_neigh, "lastReset",
14343 "never");
14344 else
14345 vty_out(vty, " Last reset never\n");
14346 } else {
14347 if (use_json) {
14348 time_t uptime;
14349 struct tm tm;
14350
14351 uptime = monotime(NULL);
14352 uptime -= p->resettime;
14353 gmtime_r(&uptime, &tm);
14354
14355 json_object_int_add(json_neigh, "lastResetTimerMsecs",
14356 (tm.tm_sec * 1000)
14357 + (tm.tm_min * 60000)
14358 + (tm.tm_hour * 3600000));
14359 bgp_show_peer_reset(NULL, p, json_neigh, true);
14360 } else {
14361 vty_out(vty, " Last reset %s, ",
14362 peer_uptime(p->resettime, timebuf,
14363 BGP_UPTIME_LEN, 0, NULL));
14364
14365 bgp_show_peer_reset(vty, p, NULL, false);
14366 if (p->last_reset_cause_size) {
14367 msg = p->last_reset_cause;
14368 vty_out(vty,
14369 " Message received that caused BGP to send a NOTIFICATION:\n ");
14370 for (i = 1; i <= p->last_reset_cause_size;
14371 i++) {
14372 vty_out(vty, "%02X", *msg++);
14373
14374 if (i != p->last_reset_cause_size) {
14375 if (i % 16 == 0) {
14376 vty_out(vty, "\n ");
14377 } else if (i % 4 == 0) {
14378 vty_out(vty, " ");
14379 }
14380 }
14381 }
14382 vty_out(vty, "\n");
14383 }
14384 }
14385 }
14386
14387 if (CHECK_FLAG(p->sflags, PEER_STATUS_PREFIX_OVERFLOW)) {
14388 if (use_json)
14389 json_object_boolean_true_add(json_neigh,
14390 "prefixesConfigExceedMax");
14391 else
14392 vty_out(vty,
14393 " Peer had exceeded the max. no. of prefixes configured.\n");
14394
14395 if (p->t_pmax_restart) {
14396 if (use_json) {
14397 json_object_boolean_true_add(
14398 json_neigh, "reducePrefixNumFrom");
14399 json_object_int_add(json_neigh,
14400 "restartInTimerMsec",
14401 thread_timer_remain_second(
14402 p->t_pmax_restart)
14403 * 1000);
14404 } else
14405 vty_out(vty,
14406 " Reduce the no. of prefix from %s, will restart in %ld seconds\n",
14407 p->host, thread_timer_remain_second(
14408 p->t_pmax_restart));
14409 } else {
14410 if (use_json)
14411 json_object_boolean_true_add(
14412 json_neigh,
14413 "reducePrefixNumAndClearIpBgp");
14414 else
14415 vty_out(vty,
14416 " Reduce the no. of prefix and clear ip bgp %s to restore peering\n",
14417 p->host);
14418 }
14419 }
14420
14421 /* EBGP Multihop and GTSM */
14422 if (p->sort != BGP_PEER_IBGP) {
14423 if (use_json) {
14424 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14425 json_object_int_add(json_neigh,
14426 "externalBgpNbrMaxHopsAway",
14427 p->gtsm_hops);
14428 else
14429 json_object_int_add(json_neigh,
14430 "externalBgpNbrMaxHopsAway",
14431 p->ttl);
14432 } else {
14433 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14434 vty_out(vty,
14435 " External BGP neighbor may be up to %d hops away.\n",
14436 p->gtsm_hops);
14437 else
14438 vty_out(vty,
14439 " External BGP neighbor may be up to %d hops away.\n",
14440 p->ttl);
14441 }
14442 } else {
14443 if (use_json) {
14444 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14445 json_object_int_add(json_neigh,
14446 "internalBgpNbrMaxHopsAway",
14447 p->gtsm_hops);
14448 else
14449 json_object_int_add(json_neigh,
14450 "internalBgpNbrMaxHopsAway",
14451 p->ttl);
14452 } else {
14453 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14454 vty_out(vty,
14455 " Internal BGP neighbor may be up to %d hops away.\n",
14456 p->gtsm_hops);
14457 else
14458 vty_out(vty,
14459 " Internal BGP neighbor may be up to %d hops away.\n",
14460 p->ttl);
14461 }
14462 }
14463
14464 /* Local address. */
14465 if (p->su_local) {
14466 if (use_json) {
14467 json_object_string_addf(json_neigh, "hostLocal", "%pSU",
14468 p->su_local);
14469 json_object_int_add(json_neigh, "portLocal",
14470 ntohs(p->su_local->sin.sin_port));
14471 } else
14472 vty_out(vty, "Local host: %pSU, Local port: %d\n",
14473 p->su_local, ntohs(p->su_local->sin.sin_port));
14474 } else {
14475 if (use_json) {
14476 json_object_string_add(json_neigh, "hostLocal",
14477 "Unknown");
14478 json_object_int_add(json_neigh, "portLocal", -1);
14479 }
14480 }
14481
14482 /* Remote address. */
14483 if (p->su_remote) {
14484 if (use_json) {
14485 json_object_string_addf(json_neigh, "hostForeign",
14486 "%pSU", p->su_remote);
14487 json_object_int_add(json_neigh, "portForeign",
14488 ntohs(p->su_remote->sin.sin_port));
14489 } else
14490 vty_out(vty, "Foreign host: %pSU, Foreign port: %d\n",
14491 p->su_remote,
14492 ntohs(p->su_remote->sin.sin_port));
14493 } else {
14494 if (use_json) {
14495 json_object_string_add(json_neigh, "hostForeign",
14496 "Unknown");
14497 json_object_int_add(json_neigh, "portForeign", -1);
14498 }
14499 }
14500
14501 /* Nexthop display. */
14502 if (p->su_local) {
14503 if (use_json) {
14504 json_object_string_addf(json_neigh, "nexthop", "%pI4",
14505 &p->nexthop.v4);
14506 json_object_string_addf(json_neigh, "nexthopGlobal",
14507 "%pI6", &p->nexthop.v6_global);
14508 json_object_string_addf(json_neigh, "nexthopLocal",
14509 "%pI6", &p->nexthop.v6_local);
14510 if (p->shared_network)
14511 json_object_string_add(json_neigh,
14512 "bgpConnection",
14513 "sharedNetwork");
14514 else
14515 json_object_string_add(json_neigh,
14516 "bgpConnection",
14517 "nonSharedNetwork");
14518 } else {
14519 vty_out(vty, "Nexthop: %s\n",
14520 inet_ntop(AF_INET, &p->nexthop.v4, buf1,
14521 sizeof(buf1)));
14522 vty_out(vty, "Nexthop global: %s\n",
14523 inet_ntop(AF_INET6, &p->nexthop.v6_global, buf1,
14524 sizeof(buf1)));
14525 vty_out(vty, "Nexthop local: %s\n",
14526 inet_ntop(AF_INET6, &p->nexthop.v6_local, buf1,
14527 sizeof(buf1)));
14528 vty_out(vty, "BGP connection: %s\n",
14529 p->shared_network ? "shared network"
14530 : "non shared network");
14531 }
14532 }
14533
14534 /* Timer information. */
14535 if (use_json) {
14536 json_object_int_add(json_neigh, "connectRetryTimer",
14537 p->v_connect);
14538 if (peer_established(p) && p->rtt)
14539 json_object_int_add(json_neigh, "estimatedRttInMsecs",
14540 p->rtt);
14541 if (p->t_start)
14542 json_object_int_add(
14543 json_neigh, "nextStartTimerDueInMsecs",
14544 thread_timer_remain_second(p->t_start) * 1000);
14545 if (p->t_connect)
14546 json_object_int_add(
14547 json_neigh, "nextConnectTimerDueInMsecs",
14548 thread_timer_remain_second(p->t_connect)
14549 * 1000);
14550 if (p->t_routeadv) {
14551 json_object_int_add(json_neigh, "mraiInterval",
14552 p->v_routeadv);
14553 json_object_int_add(
14554 json_neigh, "mraiTimerExpireInMsecs",
14555 thread_timer_remain_second(p->t_routeadv)
14556 * 1000);
14557 }
14558 if (p->password)
14559 json_object_int_add(json_neigh, "authenticationEnabled",
14560 1);
14561
14562 if (p->t_read)
14563 json_object_string_add(json_neigh, "readThread", "on");
14564 else
14565 json_object_string_add(json_neigh, "readThread", "off");
14566
14567 if (CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON))
14568 json_object_string_add(json_neigh, "writeThread", "on");
14569 else
14570 json_object_string_add(json_neigh, "writeThread",
14571 "off");
14572 } else {
14573 vty_out(vty, "BGP Connect Retry Timer in Seconds: %d\n",
14574 p->v_connect);
14575 if (peer_established(p) && p->rtt)
14576 vty_out(vty, "Estimated round trip time: %d ms\n",
14577 p->rtt);
14578 if (p->t_start)
14579 vty_out(vty, "Next start timer due in %ld seconds\n",
14580 thread_timer_remain_second(p->t_start));
14581 if (p->t_connect)
14582 vty_out(vty, "Next connect timer due in %ld seconds\n",
14583 thread_timer_remain_second(p->t_connect));
14584 if (p->t_routeadv)
14585 vty_out(vty,
14586 "MRAI (interval %u) timer expires in %ld seconds\n",
14587 p->v_routeadv,
14588 thread_timer_remain_second(p->t_routeadv));
14589 if (p->password)
14590 vty_out(vty, "Peer Authentication Enabled\n");
14591
14592 vty_out(vty, "Read thread: %s Write thread: %s FD used: %d\n",
14593 p->t_read ? "on" : "off",
14594 CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON)
14595 ? "on"
14596 : "off", p->fd);
14597 }
14598
14599 if (p->notify.code == BGP_NOTIFY_OPEN_ERR
14600 && p->notify.subcode == BGP_NOTIFY_OPEN_UNSUP_CAPBL)
14601 bgp_capability_vty_out(vty, p, use_json, json_neigh);
14602
14603 if (!use_json)
14604 vty_out(vty, "\n");
14605
14606 /* BFD information. */
14607 if (p->bfd_config)
14608 bgp_bfd_show_info(vty, p, json_neigh);
14609
14610 if (use_json) {
14611 if (p->conf_if) /* Configured interface name. */
14612 json_object_object_add(json, p->conf_if, json_neigh);
14613 else /* Configured IP address. */
14614 json_object_object_add(json, p->host, json_neigh);
14615 }
14616 }
14617
14618 static int bgp_show_neighbor_graceful_restart(struct vty *vty, struct bgp *bgp,
14619 enum show_type type,
14620 union sockunion *su,
14621 const char *conf_if, afi_t afi,
14622 bool use_json)
14623 {
14624 struct listnode *node, *nnode;
14625 struct peer *peer;
14626 int find = 0;
14627 safi_t safi = SAFI_UNICAST;
14628 json_object *json = NULL;
14629 json_object *json_neighbor = NULL;
14630
14631 if (use_json) {
14632 json = json_object_new_object();
14633 json_neighbor = json_object_new_object();
14634 }
14635
14636 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
14637
14638 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
14639 continue;
14640
14641 if ((peer->afc[afi][safi]) == 0)
14642 continue;
14643
14644 if (type == show_all) {
14645 bgp_show_peer_gr_status(vty, peer, use_json,
14646 json_neighbor);
14647
14648 if (use_json) {
14649 json_object_object_add(json, peer->host,
14650 json_neighbor);
14651 json_neighbor = NULL;
14652 }
14653
14654 } else if (type == show_peer) {
14655 if (conf_if) {
14656 if ((peer->conf_if
14657 && !strcmp(peer->conf_if, conf_if))
14658 || (peer->hostname
14659 && !strcmp(peer->hostname, conf_if))) {
14660 find = 1;
14661 bgp_show_peer_gr_status(vty, peer,
14662 use_json,
14663 json_neighbor);
14664 }
14665 } else {
14666 if (sockunion_same(&peer->su, su)) {
14667 find = 1;
14668 bgp_show_peer_gr_status(vty, peer,
14669 use_json,
14670 json_neighbor);
14671 }
14672 }
14673 if (use_json && find)
14674 json_object_object_add(json, peer->host,
14675 json_neighbor);
14676 }
14677
14678 if (find) {
14679 json_neighbor = NULL;
14680 break;
14681 }
14682 }
14683
14684 if (type == show_peer && !find) {
14685 if (use_json)
14686 json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
14687 else
14688 vty_out(vty, "%% No such neighbor\n");
14689 }
14690 if (use_json) {
14691 if (json_neighbor)
14692 json_object_free(json_neighbor);
14693 vty_json(vty, json);
14694 } else {
14695 vty_out(vty, "\n");
14696 }
14697
14698 return CMD_SUCCESS;
14699 }
14700
14701 static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
14702 enum show_type type, union sockunion *su,
14703 const char *conf_if, bool use_json,
14704 json_object *json)
14705 {
14706 struct listnode *node, *nnode;
14707 struct peer *peer;
14708 int find = 0;
14709 bool nbr_output = false;
14710 afi_t afi = AFI_MAX;
14711 safi_t safi = SAFI_MAX;
14712
14713 if (type == show_ipv4_peer || type == show_ipv4_all) {
14714 afi = AFI_IP;
14715 } else if (type == show_ipv6_peer || type == show_ipv6_all) {
14716 afi = AFI_IP6;
14717 }
14718
14719 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
14720 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
14721 continue;
14722
14723 switch (type) {
14724 case show_all:
14725 bgp_show_peer(vty, peer, use_json, json);
14726 nbr_output = true;
14727 break;
14728 case show_peer:
14729 if (conf_if) {
14730 if ((peer->conf_if
14731 && !strcmp(peer->conf_if, conf_if))
14732 || (peer->hostname
14733 && !strcmp(peer->hostname, conf_if))) {
14734 find = 1;
14735 bgp_show_peer(vty, peer, use_json,
14736 json);
14737 }
14738 } else {
14739 if (sockunion_same(&peer->su, su)) {
14740 find = 1;
14741 bgp_show_peer(vty, peer, use_json,
14742 json);
14743 }
14744 }
14745 break;
14746 case show_ipv4_peer:
14747 case show_ipv6_peer:
14748 FOREACH_SAFI (safi) {
14749 if (peer->afc[afi][safi]) {
14750 if (conf_if) {
14751 if ((peer->conf_if
14752 && !strcmp(peer->conf_if, conf_if))
14753 || (peer->hostname
14754 && !strcmp(peer->hostname, conf_if))) {
14755 find = 1;
14756 bgp_show_peer(vty, peer, use_json,
14757 json);
14758 break;
14759 }
14760 } else {
14761 if (sockunion_same(&peer->su, su)) {
14762 find = 1;
14763 bgp_show_peer(vty, peer, use_json,
14764 json);
14765 break;
14766 }
14767 }
14768 }
14769 }
14770 break;
14771 case show_ipv4_all:
14772 case show_ipv6_all:
14773 FOREACH_SAFI (safi) {
14774 if (peer->afc[afi][safi]) {
14775 bgp_show_peer(vty, peer, use_json, json);
14776 nbr_output = true;
14777 break;
14778 }
14779 }
14780 break;
14781 }
14782 }
14783
14784 if ((type == show_peer || type == show_ipv4_peer ||
14785 type == show_ipv6_peer) && !find) {
14786 if (use_json)
14787 json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
14788 else
14789 vty_out(vty, "%% No such neighbor in this view/vrf\n");
14790 }
14791
14792 if (type != show_peer && type != show_ipv4_peer &&
14793 type != show_ipv6_peer && !nbr_output && !use_json)
14794 vty_out(vty, "%% No BGP neighbors found\n");
14795
14796 if (use_json) {
14797 vty_out(vty, "%s\n", json_object_to_json_string_ext(
14798 json, JSON_C_TO_STRING_PRETTY));
14799 } else {
14800 vty_out(vty, "\n");
14801 }
14802
14803 return CMD_SUCCESS;
14804 }
14805
14806 static void bgp_show_neighbor_graceful_restart_vty(struct vty *vty,
14807 enum show_type type,
14808 const char *ip_str,
14809 afi_t afi, bool use_json)
14810 {
14811
14812 int ret;
14813 struct bgp *bgp;
14814 union sockunion su;
14815
14816 bgp = bgp_get_default();
14817
14818 if (!bgp)
14819 return;
14820
14821 if (!use_json)
14822 bgp_show_global_graceful_restart_mode_vty(vty, bgp, use_json,
14823 NULL);
14824
14825 if (ip_str) {
14826 ret = str2sockunion(ip_str, &su);
14827 if (ret < 0)
14828 bgp_show_neighbor_graceful_restart(
14829 vty, bgp, type, NULL, ip_str, afi, use_json);
14830 else
14831 bgp_show_neighbor_graceful_restart(vty, bgp, type, &su,
14832 NULL, afi, use_json);
14833 } else
14834 bgp_show_neighbor_graceful_restart(vty, bgp, type, NULL, NULL,
14835 afi, use_json);
14836 }
14837
14838 static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
14839 enum show_type type,
14840 const char *ip_str,
14841 bool use_json)
14842 {
14843 struct listnode *node, *nnode;
14844 struct bgp *bgp;
14845 union sockunion su;
14846 json_object *json = NULL;
14847 int ret, is_first = 1;
14848 bool nbr_output = false;
14849
14850 if (use_json)
14851 vty_out(vty, "{\n");
14852
14853 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
14854 nbr_output = true;
14855 if (use_json) {
14856 if (!(json = json_object_new_object())) {
14857 flog_err(
14858 EC_BGP_JSON_MEM_ERROR,
14859 "Unable to allocate memory for JSON object");
14860 vty_out(vty,
14861 "{\"error\": {\"message:\": \"Unable to allocate memory for JSON object\"}}}\n");
14862 return;
14863 }
14864
14865 json_object_int_add(json, "vrfId",
14866 (bgp->vrf_id == VRF_UNKNOWN)
14867 ? -1
14868 : (int64_t)bgp->vrf_id);
14869 json_object_string_add(
14870 json, "vrfName",
14871 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
14872 ? VRF_DEFAULT_NAME
14873 : bgp->name);
14874
14875 if (!is_first)
14876 vty_out(vty, ",\n");
14877 else
14878 is_first = 0;
14879
14880 vty_out(vty, "\"%s\":",
14881 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
14882 ? VRF_DEFAULT_NAME
14883 : bgp->name);
14884 } else {
14885 vty_out(vty, "\nInstance %s:\n",
14886 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
14887 ? VRF_DEFAULT_NAME
14888 : bgp->name);
14889 }
14890
14891 if (type == show_peer || type == show_ipv4_peer ||
14892 type == show_ipv6_peer) {
14893 ret = str2sockunion(ip_str, &su);
14894 if (ret < 0)
14895 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
14896 use_json, json);
14897 else
14898 bgp_show_neighbor(vty, bgp, type, &su, NULL,
14899 use_json, json);
14900 } else {
14901 bgp_show_neighbor(vty, bgp, type, NULL, NULL,
14902 use_json, json);
14903 }
14904 json_object_free(json);
14905 json = NULL;
14906 }
14907
14908 if (use_json)
14909 vty_out(vty, "}\n");
14910 else if (!nbr_output)
14911 vty_out(vty, "%% BGP instance not found\n");
14912 }
14913
14914 static int bgp_show_neighbor_vty(struct vty *vty, const char *name,
14915 enum show_type type, const char *ip_str,
14916 bool use_json)
14917 {
14918 int ret;
14919 struct bgp *bgp;
14920 union sockunion su;
14921 json_object *json = NULL;
14922
14923 if (name) {
14924 if (strmatch(name, "all")) {
14925 bgp_show_all_instances_neighbors_vty(vty, type, ip_str,
14926 use_json);
14927 return CMD_SUCCESS;
14928 } else {
14929 bgp = bgp_lookup_by_name(name);
14930 if (!bgp) {
14931 if (use_json) {
14932 json = json_object_new_object();
14933 vty_json(vty, json);
14934 } else
14935 vty_out(vty,
14936 "%% BGP instance not found\n");
14937
14938 return CMD_WARNING;
14939 }
14940 }
14941 } else {
14942 bgp = bgp_get_default();
14943 }
14944
14945 if (bgp) {
14946 json = json_object_new_object();
14947 if (ip_str) {
14948 ret = str2sockunion(ip_str, &su);
14949 if (ret < 0)
14950 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
14951 use_json, json);
14952 else
14953 bgp_show_neighbor(vty, bgp, type, &su, NULL,
14954 use_json, json);
14955 } else {
14956 bgp_show_neighbor(vty, bgp, type, NULL, NULL, use_json,
14957 json);
14958 }
14959 json_object_free(json);
14960 } else {
14961 if (use_json)
14962 vty_out(vty, "{}\n");
14963 else
14964 vty_out(vty, "%% BGP instance not found\n");
14965 }
14966
14967 return CMD_SUCCESS;
14968 }
14969
14970
14971
14972 /* "show [ip] bgp neighbors graceful-restart" commands. */
14973 DEFUN (show_ip_bgp_neighbors_graceful_restart,
14974 show_ip_bgp_neighbors_graceful_restart_cmd,
14975 "show bgp [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] graceful-restart [json]",
14976 SHOW_STR
14977 BGP_STR
14978 IP_STR
14979 IPV6_STR
14980 NEIGHBOR_STR
14981 "Neighbor to display information about\n"
14982 "Neighbor to display information about\n"
14983 "Neighbor on BGP configured interface\n"
14984 GR_SHOW
14985 JSON_STR)
14986 {
14987 char *sh_arg = NULL;
14988 enum show_type sh_type;
14989 int idx = 0;
14990 afi_t afi = AFI_MAX;
14991 bool uj = use_json(argc, argv);
14992
14993 if (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
14994 afi = AFI_MAX;
14995
14996 idx++;
14997
14998 if (argv_find(argv, argc, "A.B.C.D", &idx)
14999 || argv_find(argv, argc, "X:X::X:X", &idx)
15000 || argv_find(argv, argc, "WORD", &idx)) {
15001 sh_type = show_peer;
15002 sh_arg = argv[idx]->arg;
15003 } else
15004 sh_type = show_all;
15005
15006 if (!argv_find(argv, argc, "graceful-restart", &idx))
15007 return CMD_SUCCESS;
15008
15009
15010 return bgp_show_neighbor_graceful_restart_afi_all(vty, sh_type, sh_arg,
15011 afi, uj);
15012 }
15013
15014 /* "show [ip] bgp neighbors" commands. */
15015 DEFUN (show_ip_bgp_neighbors,
15016 show_ip_bgp_neighbors_cmd,
15017 "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] [json]",
15018 SHOW_STR
15019 IP_STR
15020 BGP_STR
15021 BGP_INSTANCE_HELP_STR
15022 BGP_AF_STR
15023 BGP_AF_STR
15024 "Detailed information on TCP and BGP neighbor connections\n"
15025 "Neighbor to display information about\n"
15026 "Neighbor to display information about\n"
15027 "Neighbor on BGP configured interface\n"
15028 JSON_STR)
15029 {
15030 char *vrf = NULL;
15031 char *sh_arg = NULL;
15032 enum show_type sh_type;
15033 afi_t afi = AFI_MAX;
15034
15035 bool uj = use_json(argc, argv);
15036
15037 int idx = 0;
15038
15039 /* [<vrf> VIEWVRFNAME] */
15040 if (argv_find(argv, argc, "vrf", &idx)) {
15041 vrf = argv[idx + 1]->arg;
15042 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15043 vrf = NULL;
15044 } else if (argv_find(argv, argc, "view", &idx))
15045 /* [<view> VIEWVRFNAME] */
15046 vrf = argv[idx + 1]->arg;
15047
15048 idx++;
15049
15050 if (argv_find(argv, argc, "ipv4", &idx)) {
15051 sh_type = show_ipv4_all;
15052 afi = AFI_IP;
15053 } else if (argv_find(argv, argc, "ipv6", &idx)) {
15054 sh_type = show_ipv6_all;
15055 afi = AFI_IP6;
15056 } else {
15057 sh_type = show_all;
15058 }
15059
15060 if (argv_find(argv, argc, "A.B.C.D", &idx)
15061 || argv_find(argv, argc, "X:X::X:X", &idx)
15062 || argv_find(argv, argc, "WORD", &idx)) {
15063 sh_type = show_peer;
15064 sh_arg = argv[idx]->arg;
15065 }
15066
15067 if (sh_type == show_peer && afi == AFI_IP) {
15068 sh_type = show_ipv4_peer;
15069 } else if (sh_type == show_peer && afi == AFI_IP6) {
15070 sh_type = show_ipv6_peer;
15071 }
15072
15073 return bgp_show_neighbor_vty(vty, vrf, sh_type, sh_arg, uj);
15074 }
15075
15076 /* Show BGP's AS paths internal data. There are both `show [ip] bgp
15077 paths' and `show ip mbgp paths'. Those functions results are the
15078 same.*/
15079 DEFUN (show_ip_bgp_paths,
15080 show_ip_bgp_paths_cmd,
15081 "show [ip] bgp ["BGP_SAFI_CMD_STR"] paths",
15082 SHOW_STR
15083 IP_STR
15084 BGP_STR
15085 BGP_SAFI_HELP_STR
15086 "Path information\n")
15087 {
15088 vty_out(vty, "Address Refcnt Path\n");
15089 aspath_print_all_vty(vty);
15090 return CMD_SUCCESS;
15091 }
15092
15093 #include "hash.h"
15094
15095 static void community_show_all_iterator(struct hash_bucket *bucket,
15096 struct vty *vty)
15097 {
15098 struct community *com;
15099
15100 com = (struct community *)bucket->data;
15101 vty_out(vty, "[%p] (%ld) %s\n", (void *)com, com->refcnt,
15102 community_str(com, false, false));
15103 }
15104
15105 /* Show BGP's community internal data. */
15106 DEFUN (show_ip_bgp_community_info,
15107 show_ip_bgp_community_info_cmd,
15108 "show [ip] bgp community-info",
15109 SHOW_STR
15110 IP_STR
15111 BGP_STR
15112 "List all bgp community information\n")
15113 {
15114 vty_out(vty, "Address Refcnt Community\n");
15115
15116 hash_iterate(community_hash(),
15117 (void (*)(struct hash_bucket *,
15118 void *))community_show_all_iterator,
15119 vty);
15120
15121 return CMD_SUCCESS;
15122 }
15123
15124 static void lcommunity_show_all_iterator(struct hash_bucket *bucket,
15125 struct vty *vty)
15126 {
15127 struct lcommunity *lcom;
15128
15129 lcom = (struct lcommunity *)bucket->data;
15130 vty_out(vty, "[%p] (%ld) %s\n", (void *)lcom, lcom->refcnt,
15131 lcommunity_str(lcom, false, false));
15132 }
15133
15134 /* Show BGP's community internal data. */
15135 DEFUN (show_ip_bgp_lcommunity_info,
15136 show_ip_bgp_lcommunity_info_cmd,
15137 "show ip bgp large-community-info",
15138 SHOW_STR
15139 IP_STR
15140 BGP_STR
15141 "List all bgp large-community information\n")
15142 {
15143 vty_out(vty, "Address Refcnt Large-community\n");
15144
15145 hash_iterate(lcommunity_hash(),
15146 (void (*)(struct hash_bucket *,
15147 void *))lcommunity_show_all_iterator,
15148 vty);
15149
15150 return CMD_SUCCESS;
15151 }
15152 /* Graceful Restart */
15153
15154 static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
15155 struct bgp *bgp,
15156 bool use_json,
15157 json_object *json)
15158 {
15159
15160
15161 vty_out(vty, "\n%s", SHOW_GR_HEADER);
15162
15163 enum global_mode bgp_global_gr_mode = bgp_global_gr_mode_get(bgp);
15164
15165 switch (bgp_global_gr_mode) {
15166
15167 case GLOBAL_HELPER:
15168 vty_out(vty, "Global BGP GR Mode : Helper\n");
15169 break;
15170
15171 case GLOBAL_GR:
15172 vty_out(vty, "Global BGP GR Mode : Restart\n");
15173 break;
15174
15175 case GLOBAL_DISABLE:
15176 vty_out(vty, "Global BGP GR Mode : Disable\n");
15177 break;
15178
15179 case GLOBAL_INVALID:
15180 vty_out(vty,
15181 "Global BGP GR Mode Invalid\n");
15182 break;
15183 }
15184 vty_out(vty, "\n");
15185 }
15186
15187 static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
15188 enum show_type type,
15189 const char *ip_str,
15190 afi_t afi, bool use_json)
15191 {
15192 if ((afi == AFI_MAX) && (ip_str == NULL)) {
15193 afi = AFI_IP;
15194
15195 while ((afi != AFI_L2VPN) && (afi < AFI_MAX)) {
15196
15197 bgp_show_neighbor_graceful_restart_vty(
15198 vty, type, ip_str, afi, use_json);
15199 afi++;
15200 }
15201 } else if (afi != AFI_MAX) {
15202 bgp_show_neighbor_graceful_restart_vty(vty, type, ip_str, afi,
15203 use_json);
15204 } else {
15205 return CMD_ERR_INCOMPLETE;
15206 }
15207
15208 return CMD_SUCCESS;
15209 }
15210 /* Graceful Restart */
15211
15212 DEFUN (show_ip_bgp_attr_info,
15213 show_ip_bgp_attr_info_cmd,
15214 "show [ip] bgp attribute-info",
15215 SHOW_STR
15216 IP_STR
15217 BGP_STR
15218 "List all bgp attribute information\n")
15219 {
15220 attr_show_all(vty);
15221 return CMD_SUCCESS;
15222 }
15223
15224 static int bgp_show_route_leak_vty(struct vty *vty, const char *name,
15225 afi_t afi, safi_t safi,
15226 bool use_json, json_object *json)
15227 {
15228 struct bgp *bgp;
15229 struct listnode *node;
15230 char *vname;
15231 char *ecom_str;
15232 enum vpn_policy_direction dir;
15233
15234 if (json) {
15235 json_object *json_import_vrfs = NULL;
15236 json_object *json_export_vrfs = NULL;
15237
15238 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
15239
15240 if (!bgp) {
15241 vty_json(vty, json);
15242
15243 return CMD_WARNING;
15244 }
15245
15246 /* Provide context for the block */
15247 json_object_string_add(json, "vrf", name ? name : "default");
15248 json_object_string_add(json, "afiSafi",
15249 get_afi_safi_str(afi, safi, true));
15250
15251 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15252 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
15253 json_object_string_add(json, "importFromVrfs", "none");
15254 json_object_string_add(json, "importRts", "none");
15255 } else {
15256 json_import_vrfs = json_object_new_array();
15257
15258 for (ALL_LIST_ELEMENTS_RO(
15259 bgp->vpn_policy[afi].import_vrf,
15260 node, vname))
15261 json_object_array_add(json_import_vrfs,
15262 json_object_new_string(vname));
15263
15264 json_object_object_add(json, "importFromVrfs",
15265 json_import_vrfs);
15266 dir = BGP_VPN_POLICY_DIR_FROMVPN;
15267 if (bgp->vpn_policy[afi].rtlist[dir]) {
15268 ecom_str = ecommunity_ecom2str(
15269 bgp->vpn_policy[afi].rtlist[dir],
15270 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15271 json_object_string_add(json, "importRts",
15272 ecom_str);
15273 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15274 } else
15275 json_object_string_add(json, "importRts",
15276 "none");
15277 }
15278
15279 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15280 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
15281 json_object_string_add(json, "exportToVrfs", "none");
15282 json_object_string_add(json, "routeDistinguisher",
15283 "none");
15284 json_object_string_add(json, "exportRts", "none");
15285 } else {
15286 json_export_vrfs = json_object_new_array();
15287
15288 for (ALL_LIST_ELEMENTS_RO(
15289 bgp->vpn_policy[afi].export_vrf,
15290 node, vname))
15291 json_object_array_add(json_export_vrfs,
15292 json_object_new_string(vname));
15293 json_object_object_add(json, "exportToVrfs",
15294 json_export_vrfs);
15295 json_object_string_addf(json, "routeDistinguisher",
15296 "%pRD",
15297 &bgp->vpn_policy[afi].tovpn_rd);
15298
15299 dir = BGP_VPN_POLICY_DIR_TOVPN;
15300 if (bgp->vpn_policy[afi].rtlist[dir]) {
15301 ecom_str = ecommunity_ecom2str(
15302 bgp->vpn_policy[afi].rtlist[dir],
15303 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15304 json_object_string_add(json, "exportRts",
15305 ecom_str);
15306 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15307 } else
15308 json_object_string_add(json, "exportRts",
15309 "none");
15310 }
15311
15312 if (use_json) {
15313 vty_json(vty, json);
15314 }
15315 } else {
15316 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
15317
15318 if (!bgp) {
15319 vty_out(vty, "%% No such BGP instance exist\n");
15320 return CMD_WARNING;
15321 }
15322
15323 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15324 BGP_CONFIG_VRF_TO_VRF_IMPORT))
15325 vty_out(vty,
15326 "This VRF is not importing %s routes from any other VRF\n",
15327 get_afi_safi_str(afi, safi, false));
15328 else {
15329 vty_out(vty,
15330 "This VRF is importing %s routes from the following VRFs:\n",
15331 get_afi_safi_str(afi, safi, false));
15332
15333 for (ALL_LIST_ELEMENTS_RO(
15334 bgp->vpn_policy[afi].import_vrf,
15335 node, vname))
15336 vty_out(vty, " %s\n", vname);
15337
15338 dir = BGP_VPN_POLICY_DIR_FROMVPN;
15339 ecom_str = NULL;
15340 if (bgp->vpn_policy[afi].rtlist[dir]) {
15341 ecom_str = ecommunity_ecom2str(
15342 bgp->vpn_policy[afi].rtlist[dir],
15343 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15344 vty_out(vty, "Import RT(s): %s\n", ecom_str);
15345
15346 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15347 } else
15348 vty_out(vty, "Import RT(s):\n");
15349 }
15350
15351 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15352 BGP_CONFIG_VRF_TO_VRF_EXPORT))
15353 vty_out(vty,
15354 "This VRF is not exporting %s routes to any other VRF\n",
15355 get_afi_safi_str(afi, safi, false));
15356 else {
15357 vty_out(vty,
15358 "This VRF is exporting %s routes to the following VRFs:\n",
15359 get_afi_safi_str(afi, safi, false));
15360
15361 for (ALL_LIST_ELEMENTS_RO(
15362 bgp->vpn_policy[afi].export_vrf,
15363 node, vname))
15364 vty_out(vty, " %s\n", vname);
15365
15366 vty_out(vty, "RD: %pRD\n",
15367 &bgp->vpn_policy[afi].tovpn_rd);
15368
15369 dir = BGP_VPN_POLICY_DIR_TOVPN;
15370 if (bgp->vpn_policy[afi].rtlist[dir]) {
15371 ecom_str = ecommunity_ecom2str(
15372 bgp->vpn_policy[afi].rtlist[dir],
15373 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15374 vty_out(vty, "Export RT: %s\n", ecom_str);
15375 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15376 } else
15377 vty_out(vty, "Import RT(s):\n");
15378 }
15379 }
15380
15381 return CMD_SUCCESS;
15382 }
15383
15384 static int bgp_show_all_instance_route_leak_vty(struct vty *vty, afi_t afi,
15385 safi_t safi, bool use_json)
15386 {
15387 struct listnode *node, *nnode;
15388 struct bgp *bgp;
15389 char *vrf_name = NULL;
15390 json_object *json = NULL;
15391 json_object *json_vrf = NULL;
15392 json_object *json_vrfs = NULL;
15393
15394 if (use_json) {
15395 json = json_object_new_object();
15396 json_vrfs = json_object_new_object();
15397 }
15398
15399 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
15400
15401 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT)
15402 vrf_name = bgp->name;
15403
15404 if (use_json) {
15405 json_vrf = json_object_new_object();
15406 } else {
15407 vty_out(vty, "\nInstance %s:\n",
15408 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15409 ? VRF_DEFAULT_NAME : bgp->name);
15410 }
15411 bgp_show_route_leak_vty(vty, vrf_name, afi, safi, 0, json_vrf);
15412 if (use_json) {
15413 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15414 json_object_object_add(json_vrfs,
15415 VRF_DEFAULT_NAME, json_vrf);
15416 else
15417 json_object_object_add(json_vrfs, vrf_name,
15418 json_vrf);
15419 }
15420 }
15421
15422 if (use_json) {
15423 json_object_object_add(json, "vrfs", json_vrfs);
15424 vty_json(vty, json);
15425 }
15426
15427 return CMD_SUCCESS;
15428 }
15429
15430 /* "show [ip] bgp route-leak" command. */
15431 DEFUN (show_ip_bgp_route_leak,
15432 show_ip_bgp_route_leak_cmd,
15433 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] route-leak [json]",
15434 SHOW_STR
15435 IP_STR
15436 BGP_STR
15437 BGP_INSTANCE_HELP_STR
15438 BGP_AFI_HELP_STR
15439 BGP_SAFI_HELP_STR
15440 "Route leaking information\n"
15441 JSON_STR)
15442 {
15443 char *vrf = NULL;
15444 afi_t afi = AFI_MAX;
15445 safi_t safi = SAFI_MAX;
15446
15447 bool uj = use_json(argc, argv);
15448 int idx = 0;
15449 json_object *json = NULL;
15450
15451 /* show [ip] bgp */
15452 if (argv_find(argv, argc, "ip", &idx)) {
15453 afi = AFI_IP;
15454 safi = SAFI_UNICAST;
15455 }
15456 /* [vrf VIEWVRFNAME] */
15457 if (argv_find(argv, argc, "view", &idx)) {
15458 vty_out(vty,
15459 "%% This command is not applicable to BGP views\n");
15460 return CMD_WARNING;
15461 }
15462
15463 if (argv_find(argv, argc, "vrf", &idx)) {
15464 vrf = argv[idx + 1]->arg;
15465 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15466 vrf = NULL;
15467 }
15468 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
15469 if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
15470 argv_find_and_parse_safi(argv, argc, &idx, &safi);
15471
15472 if (!((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST)) {
15473 vty_out(vty,
15474 "%% This command is applicable only for unicast ipv4|ipv6\n");
15475 return CMD_WARNING;
15476 }
15477
15478 if (vrf && strmatch(vrf, "all"))
15479 return bgp_show_all_instance_route_leak_vty(vty, afi, safi, uj);
15480
15481 if (uj)
15482 json = json_object_new_object();
15483
15484 return bgp_show_route_leak_vty(vty, vrf, afi, safi, uj, json);
15485 }
15486
15487 static void bgp_show_all_instances_updgrps_vty(struct vty *vty, afi_t afi,
15488 safi_t safi)
15489 {
15490 struct listnode *node, *nnode;
15491 struct bgp *bgp;
15492
15493 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
15494 vty_out(vty, "\nInstance %s:\n",
15495 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15496 ? VRF_DEFAULT_NAME
15497 : bgp->name);
15498 update_group_show(bgp, afi, safi, vty, 0);
15499 }
15500 }
15501
15502 static int bgp_show_update_groups(struct vty *vty, const char *name, int afi,
15503 int safi, uint64_t subgrp_id)
15504 {
15505 struct bgp *bgp;
15506
15507 if (name) {
15508 if (strmatch(name, "all")) {
15509 bgp_show_all_instances_updgrps_vty(vty, afi, safi);
15510 return CMD_SUCCESS;
15511 } else {
15512 bgp = bgp_lookup_by_name(name);
15513 }
15514 } else {
15515 bgp = bgp_get_default();
15516 }
15517
15518 if (bgp)
15519 update_group_show(bgp, afi, safi, vty, subgrp_id);
15520 return CMD_SUCCESS;
15521 }
15522
15523 DEFUN (show_ip_bgp_updgrps,
15524 show_ip_bgp_updgrps_cmd,
15525 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] update-groups [SUBGROUP-ID]",
15526 SHOW_STR
15527 IP_STR
15528 BGP_STR
15529 BGP_INSTANCE_HELP_STR
15530 BGP_AFI_HELP_STR
15531 BGP_SAFI_WITH_LABEL_HELP_STR
15532 "Detailed info about dynamic update groups\n"
15533 "Specific subgroup to display detailed info for\n")
15534 {
15535 char *vrf = NULL;
15536 afi_t afi = AFI_IP6;
15537 safi_t safi = SAFI_UNICAST;
15538 uint64_t subgrp_id = 0;
15539
15540 int idx = 0;
15541
15542 /* show [ip] bgp */
15543 if (argv_find(argv, argc, "ip", &idx))
15544 afi = AFI_IP;
15545 /* [<vrf> VIEWVRFNAME] */
15546 if (argv_find(argv, argc, "vrf", &idx)) {
15547 vrf = argv[idx + 1]->arg;
15548 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15549 vrf = NULL;
15550 } else if (argv_find(argv, argc, "view", &idx))
15551 /* [<view> VIEWVRFNAME] */
15552 vrf = argv[idx + 1]->arg;
15553 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
15554 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
15555 argv_find_and_parse_safi(argv, argc, &idx, &safi);
15556 }
15557
15558 /* get subgroup id, if provided */
15559 idx = argc - 1;
15560 if (argv[idx]->type == VARIABLE_TKN)
15561 subgrp_id = strtoull(argv[idx]->arg, NULL, 10);
15562
15563 return (bgp_show_update_groups(vty, vrf, afi, safi, subgrp_id));
15564 }
15565
15566 DEFUN (show_bgp_instance_all_ipv6_updgrps,
15567 show_bgp_instance_all_ipv6_updgrps_cmd,
15568 "show [ip] bgp <view|vrf> all update-groups",
15569 SHOW_STR
15570 IP_STR
15571 BGP_STR
15572 BGP_INSTANCE_ALL_HELP_STR
15573 "Detailed info about dynamic update groups\n")
15574 {
15575 bgp_show_all_instances_updgrps_vty(vty, AFI_IP6, SAFI_UNICAST);
15576 return CMD_SUCCESS;
15577 }
15578
15579 DEFUN (show_bgp_l2vpn_evpn_updgrps,
15580 show_bgp_l2vpn_evpn_updgrps_cmd,
15581 "show [ip] bgp l2vpn evpn update-groups",
15582 SHOW_STR
15583 IP_STR
15584 BGP_STR
15585 "l2vpn address family\n"
15586 "evpn sub-address family\n"
15587 "Detailed info about dynamic update groups\n")
15588 {
15589 char *vrf = NULL;
15590 uint64_t subgrp_id = 0;
15591
15592 bgp_show_update_groups(vty, vrf, AFI_L2VPN, SAFI_EVPN, subgrp_id);
15593 return CMD_SUCCESS;
15594 }
15595
15596 DEFUN (show_bgp_updgrps_stats,
15597 show_bgp_updgrps_stats_cmd,
15598 "show [ip] bgp update-groups statistics",
15599 SHOW_STR
15600 IP_STR
15601 BGP_STR
15602 "Detailed info about dynamic update groups\n"
15603 "Statistics\n")
15604 {
15605 struct bgp *bgp;
15606
15607 bgp = bgp_get_default();
15608 if (bgp)
15609 update_group_show_stats(bgp, vty);
15610
15611 return CMD_SUCCESS;
15612 }
15613
15614 DEFUN (show_bgp_instance_updgrps_stats,
15615 show_bgp_instance_updgrps_stats_cmd,
15616 "show [ip] bgp <view|vrf> VIEWVRFNAME update-groups statistics",
15617 SHOW_STR
15618 IP_STR
15619 BGP_STR
15620 BGP_INSTANCE_HELP_STR
15621 "Detailed info about dynamic update groups\n"
15622 "Statistics\n")
15623 {
15624 int idx_word = 3;
15625 struct bgp *bgp;
15626
15627 bgp = bgp_lookup_by_name(argv[idx_word]->arg);
15628 if (bgp)
15629 update_group_show_stats(bgp, vty);
15630
15631 return CMD_SUCCESS;
15632 }
15633
15634 static void show_bgp_updgrps_adj_info_aux(struct vty *vty, const char *name,
15635 afi_t afi, safi_t safi,
15636 const char *what, uint64_t subgrp_id)
15637 {
15638 struct bgp *bgp;
15639
15640 if (name)
15641 bgp = bgp_lookup_by_name(name);
15642 else
15643 bgp = bgp_get_default();
15644
15645 if (bgp) {
15646 if (!strcmp(what, "advertise-queue"))
15647 update_group_show_adj_queue(bgp, afi, safi, vty,
15648 subgrp_id);
15649 else if (!strcmp(what, "advertised-routes"))
15650 update_group_show_advertised(bgp, afi, safi, vty,
15651 subgrp_id);
15652 else if (!strcmp(what, "packet-queue"))
15653 update_group_show_packet_queue(bgp, afi, safi, vty,
15654 subgrp_id);
15655 }
15656 }
15657
15658 DEFPY(show_ip_bgp_instance_updgrps_adj_s,
15659 show_ip_bgp_instance_updgrps_adj_s_cmd,
15660 "show [ip]$ip bgp [<view|vrf> VIEWVRFNAME$vrf] [<ipv4|ipv6>$afi <unicast|multicast|vpn>$safi] update-groups [SUBGROUP-ID]$sgid <advertise-queue|advertised-routes|packet-queue>$rtq",
15661 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
15662 BGP_SAFI_HELP_STR
15663 "Detailed info about dynamic update groups\n"
15664 "Specific subgroup to display info for\n"
15665 "Advertisement queue\n"
15666 "Announced routes\n"
15667 "Packet queue\n")
15668 {
15669 uint64_t subgrp_id = 0;
15670 afi_t afiz;
15671 safi_t safiz;
15672 if (sgid)
15673 subgrp_id = strtoull(sgid, NULL, 10);
15674
15675 if (!ip && !afi)
15676 afiz = AFI_IP6;
15677 if (!ip && afi)
15678 afiz = bgp_vty_afi_from_str(afi);
15679 if (ip && !afi)
15680 afiz = AFI_IP;
15681 if (ip && afi) {
15682 afiz = bgp_vty_afi_from_str(afi);
15683 if (afiz != AFI_IP)
15684 vty_out(vty,
15685 "%% Cannot specify both 'ip' and 'ipv6'\n");
15686 return CMD_WARNING;
15687 }
15688
15689 safiz = safi ? bgp_vty_safi_from_str(safi) : SAFI_UNICAST;
15690
15691 show_bgp_updgrps_adj_info_aux(vty, vrf, afiz, safiz, rtq, subgrp_id);
15692 return CMD_SUCCESS;
15693 }
15694
15695 static int bgp_show_one_peer_group(struct vty *vty, struct peer_group *group,
15696 json_object *json)
15697 {
15698 struct listnode *node, *nnode;
15699 struct prefix *range;
15700 struct peer *conf;
15701 struct peer *peer;
15702 afi_t afi;
15703 safi_t safi;
15704 const char *peer_status;
15705 int lr_count;
15706 int dynamic;
15707 bool af_cfgd;
15708 json_object *json_peer_group = NULL;
15709 json_object *json_peer_group_afc = NULL;
15710 json_object *json_peer_group_members = NULL;
15711 json_object *json_peer_group_dynamic = NULL;
15712 json_object *json_peer_group_dynamic_af = NULL;
15713 json_object *json_peer_group_ranges = NULL;
15714
15715 conf = group->conf;
15716
15717 if (json) {
15718 json_peer_group = json_object_new_object();
15719 json_peer_group_afc = json_object_new_array();
15720 }
15721
15722 if (conf->as_type == AS_SPECIFIED || conf->as_type == AS_EXTERNAL) {
15723 if (json)
15724 json_object_int_add(json_peer_group, "remoteAs",
15725 conf->as);
15726 else
15727 vty_out(vty, "\nBGP peer-group %s, remote AS %u\n",
15728 group->name, conf->as);
15729 } else if (conf->as_type == AS_INTERNAL) {
15730 if (json)
15731 json_object_int_add(json_peer_group, "remoteAs",
15732 group->bgp->as);
15733 else
15734 vty_out(vty, "\nBGP peer-group %s, remote AS %u\n",
15735 group->name, group->bgp->as);
15736 } else {
15737 if (!json)
15738 vty_out(vty, "\nBGP peer-group %s\n", group->name);
15739 }
15740
15741 if ((group->bgp->as == conf->as) || (conf->as_type == AS_INTERNAL)) {
15742 if (json)
15743 json_object_string_add(json_peer_group, "type",
15744 "internal");
15745 else
15746 vty_out(vty, " Peer-group type is internal\n");
15747 } else {
15748 if (json)
15749 json_object_string_add(json_peer_group, "type",
15750 "external");
15751 else
15752 vty_out(vty, " Peer-group type is external\n");
15753 }
15754
15755 /* Display AFs configured. */
15756 if (!json)
15757 vty_out(vty, " Configured address-families:");
15758
15759 FOREACH_AFI_SAFI (afi, safi) {
15760 if (conf->afc[afi][safi]) {
15761 af_cfgd = true;
15762 if (json)
15763 json_object_array_add(
15764 json_peer_group_afc,
15765 json_object_new_string(get_afi_safi_str(
15766 afi, safi, false)));
15767 else
15768 vty_out(vty, " %s;",
15769 get_afi_safi_str(afi, safi, false));
15770 }
15771 }
15772
15773 if (json) {
15774 json_object_object_add(json_peer_group,
15775 "addressFamiliesConfigured",
15776 json_peer_group_afc);
15777 } else {
15778 if (!af_cfgd)
15779 vty_out(vty, " none\n");
15780 else
15781 vty_out(vty, "\n");
15782 }
15783
15784 /* Display listen ranges (for dynamic neighbors), if any */
15785 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
15786 lr_count = listcount(group->listen_range[afi]);
15787 if (lr_count) {
15788 if (json) {
15789 if (!json_peer_group_dynamic)
15790 json_peer_group_dynamic =
15791 json_object_new_object();
15792
15793 json_peer_group_dynamic_af =
15794 json_object_new_object();
15795 json_peer_group_ranges =
15796 json_object_new_array();
15797 json_object_int_add(json_peer_group_dynamic_af,
15798 "count", lr_count);
15799 } else {
15800 vty_out(vty, " %d %s listen range(s)\n",
15801 lr_count, afi2str(afi));
15802 }
15803
15804 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node,
15805 nnode, range)) {
15806 if (json) {
15807 char buf[BUFSIZ];
15808
15809 snprintfrr(buf, sizeof(buf), "%pFX",
15810 range);
15811
15812 json_object_array_add(
15813 json_peer_group_ranges,
15814 json_object_new_string(buf));
15815 } else {
15816 vty_out(vty, " %pFX\n", range);
15817 }
15818 }
15819
15820 if (json) {
15821 json_object_object_add(
15822 json_peer_group_dynamic_af, "ranges",
15823 json_peer_group_ranges);
15824
15825 json_object_object_add(
15826 json_peer_group_dynamic, afi2str(afi),
15827 json_peer_group_dynamic_af);
15828 }
15829 }
15830 }
15831
15832 if (json_peer_group_dynamic)
15833 json_object_object_add(json_peer_group, "dynamicRanges",
15834 json_peer_group_dynamic);
15835
15836 /* Display group members and their status */
15837 if (listcount(group->peer)) {
15838 if (json)
15839 json_peer_group_members = json_object_new_object();
15840 else
15841 vty_out(vty, " Peer-group members:\n");
15842 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
15843 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
15844 || CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHUTDOWN))
15845 peer_status = "Idle (Admin)";
15846 else if (CHECK_FLAG(peer->sflags,
15847 PEER_STATUS_PREFIX_OVERFLOW))
15848 peer_status = "Idle (PfxCt)";
15849 else
15850 peer_status = lookup_msg(bgp_status_msg,
15851 peer->status, NULL);
15852
15853 dynamic = peer_dynamic_neighbor(peer);
15854
15855 if (json) {
15856 json_object *json_peer_group_member =
15857 json_object_new_object();
15858
15859 json_object_string_add(json_peer_group_member,
15860 "status", peer_status);
15861
15862 if (dynamic)
15863 json_object_boolean_true_add(
15864 json_peer_group_member,
15865 "dynamic");
15866
15867 json_object_object_add(json_peer_group_members,
15868 peer->host,
15869 json_peer_group_member);
15870 } else {
15871 vty_out(vty, " %s %s %s \n", peer->host,
15872 dynamic ? "(dynamic)" : "",
15873 peer_status);
15874 }
15875 }
15876 if (json)
15877 json_object_object_add(json_peer_group, "members",
15878 json_peer_group_members);
15879 }
15880
15881 if (json)
15882 json_object_object_add(json, group->name, json_peer_group);
15883
15884 return CMD_SUCCESS;
15885 }
15886
15887 static int bgp_show_peer_group_vty(struct vty *vty, const char *name,
15888 const char *group_name, bool uj)
15889 {
15890 struct bgp *bgp;
15891 struct listnode *node, *nnode;
15892 struct peer_group *group;
15893 bool found = false;
15894 json_object *json = NULL;
15895
15896 if (uj)
15897 json = json_object_new_object();
15898
15899 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
15900
15901 if (!bgp) {
15902 if (uj)
15903 vty_json(vty, json);
15904 else
15905 vty_out(vty, "%% BGP instance not found\n");
15906
15907 return CMD_WARNING;
15908 }
15909
15910 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
15911 if (group_name) {
15912 if (strmatch(group->name, group_name)) {
15913 bgp_show_one_peer_group(vty, group, json);
15914 found = true;
15915 break;
15916 }
15917 } else {
15918 bgp_show_one_peer_group(vty, group, json);
15919 }
15920 }
15921
15922 if (group_name && !found && !uj)
15923 vty_out(vty, "%% No such peer-group\n");
15924
15925 if (uj)
15926 vty_json(vty, json);
15927
15928 return CMD_SUCCESS;
15929 }
15930
15931 DEFUN(show_ip_bgp_peer_groups, show_ip_bgp_peer_groups_cmd,
15932 "show [ip] bgp [<view|vrf> VIEWVRFNAME] peer-group [PGNAME] [json]",
15933 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR
15934 "Detailed information on BGP peer groups\n"
15935 "Peer group name\n" JSON_STR)
15936 {
15937 char *vrf, *pg;
15938 int idx = 0;
15939 bool uj = use_json(argc, argv);
15940
15941 vrf = argv_find(argv, argc, "VIEWVRFNAME", &idx) ? argv[idx]->arg
15942 : NULL;
15943 pg = argv_find(argv, argc, "PGNAME", &idx) ? argv[idx]->arg : NULL;
15944
15945 return bgp_show_peer_group_vty(vty, vrf, pg, uj);
15946 }
15947
15948
15949 /* Redistribute VTY commands. */
15950
15951 DEFUN (bgp_redistribute_ipv4,
15952 bgp_redistribute_ipv4_cmd,
15953 "redistribute " FRR_IP_REDIST_STR_BGPD,
15954 "Redistribute information from another routing protocol\n"
15955 FRR_IP_REDIST_HELP_STR_BGPD)
15956 {
15957 VTY_DECLVAR_CONTEXT(bgp, bgp);
15958 int idx_protocol = 1;
15959 int type;
15960
15961 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
15962 if (type < 0) {
15963 vty_out(vty, "%% Invalid route type\n");
15964 return CMD_WARNING_CONFIG_FAILED;
15965 }
15966
15967 bgp_redist_add(bgp, AFI_IP, type, 0);
15968 return bgp_redistribute_set(bgp, AFI_IP, type, 0, false);
15969 }
15970
15971 ALIAS_HIDDEN(
15972 bgp_redistribute_ipv4, bgp_redistribute_ipv4_hidden_cmd,
15973 "redistribute " FRR_IP_REDIST_STR_BGPD,
15974 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD)
15975
15976 DEFUN (bgp_redistribute_ipv4_rmap,
15977 bgp_redistribute_ipv4_rmap_cmd,
15978 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME",
15979 "Redistribute information from another routing protocol\n"
15980 FRR_IP_REDIST_HELP_STR_BGPD
15981 "Route map reference\n"
15982 "Pointer to route-map entries\n")
15983 {
15984 VTY_DECLVAR_CONTEXT(bgp, bgp);
15985 int idx_protocol = 1;
15986 int idx_word = 3;
15987 int type;
15988 struct bgp_redist *red;
15989 bool changed;
15990 struct route_map *route_map = route_map_lookup_warn_noexist(
15991 vty, argv[idx_word]->arg);
15992
15993 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
15994 if (type < 0) {
15995 vty_out(vty, "%% Invalid route type\n");
15996 return CMD_WARNING_CONFIG_FAILED;
15997 }
15998
15999 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16000 changed =
16001 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16002 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16003 }
16004
16005 ALIAS_HIDDEN(
16006 bgp_redistribute_ipv4_rmap, bgp_redistribute_ipv4_rmap_hidden_cmd,
16007 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME",
16008 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16009 "Route map reference\n"
16010 "Pointer to route-map entries\n")
16011
16012 DEFUN (bgp_redistribute_ipv4_metric,
16013 bgp_redistribute_ipv4_metric_cmd,
16014 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
16015 "Redistribute information from another routing protocol\n"
16016 FRR_IP_REDIST_HELP_STR_BGPD
16017 "Metric for redistributed routes\n"
16018 "Default metric\n")
16019 {
16020 VTY_DECLVAR_CONTEXT(bgp, bgp);
16021 int idx_protocol = 1;
16022 int idx_number = 3;
16023 int type;
16024 uint32_t metric;
16025 struct bgp_redist *red;
16026 bool changed;
16027
16028 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16029 if (type < 0) {
16030 vty_out(vty, "%% Invalid route type\n");
16031 return CMD_WARNING_CONFIG_FAILED;
16032 }
16033 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16034
16035 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16036 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16037 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16038 }
16039
16040 ALIAS_HIDDEN(
16041 bgp_redistribute_ipv4_metric, bgp_redistribute_ipv4_metric_hidden_cmd,
16042 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
16043 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16044 "Metric for redistributed routes\n"
16045 "Default metric\n")
16046
16047 DEFUN (bgp_redistribute_ipv4_rmap_metric,
16048 bgp_redistribute_ipv4_rmap_metric_cmd,
16049 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME metric (0-4294967295)",
16050 "Redistribute information from another routing protocol\n"
16051 FRR_IP_REDIST_HELP_STR_BGPD
16052 "Route map reference\n"
16053 "Pointer to route-map entries\n"
16054 "Metric for redistributed routes\n"
16055 "Default metric\n")
16056 {
16057 VTY_DECLVAR_CONTEXT(bgp, bgp);
16058 int idx_protocol = 1;
16059 int idx_word = 3;
16060 int idx_number = 5;
16061 int type;
16062 uint32_t metric;
16063 struct bgp_redist *red;
16064 bool changed;
16065 struct route_map *route_map =
16066 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16067
16068 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16069 if (type < 0) {
16070 vty_out(vty, "%% Invalid route type\n");
16071 return CMD_WARNING_CONFIG_FAILED;
16072 }
16073 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16074
16075 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16076 changed =
16077 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16078 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16079 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16080 }
16081
16082 ALIAS_HIDDEN(
16083 bgp_redistribute_ipv4_rmap_metric,
16084 bgp_redistribute_ipv4_rmap_metric_hidden_cmd,
16085 "redistribute " FRR_IP_REDIST_STR_BGPD
16086 " route-map RMAP_NAME metric (0-4294967295)",
16087 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16088 "Route map reference\n"
16089 "Pointer to route-map entries\n"
16090 "Metric for redistributed routes\n"
16091 "Default metric\n")
16092
16093 DEFUN (bgp_redistribute_ipv4_metric_rmap,
16094 bgp_redistribute_ipv4_metric_rmap_cmd,
16095 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295) route-map RMAP_NAME",
16096 "Redistribute information from another routing protocol\n"
16097 FRR_IP_REDIST_HELP_STR_BGPD
16098 "Metric for redistributed routes\n"
16099 "Default metric\n"
16100 "Route map reference\n"
16101 "Pointer to route-map entries\n")
16102 {
16103 VTY_DECLVAR_CONTEXT(bgp, bgp);
16104 int idx_protocol = 1;
16105 int idx_number = 3;
16106 int idx_word = 5;
16107 int type;
16108 uint32_t metric;
16109 struct bgp_redist *red;
16110 bool changed;
16111 struct route_map *route_map =
16112 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16113
16114 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16115 if (type < 0) {
16116 vty_out(vty, "%% Invalid route type\n");
16117 return CMD_WARNING_CONFIG_FAILED;
16118 }
16119 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16120
16121 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16122 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16123 changed |=
16124 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16125 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16126 }
16127
16128 ALIAS_HIDDEN(
16129 bgp_redistribute_ipv4_metric_rmap,
16130 bgp_redistribute_ipv4_metric_rmap_hidden_cmd,
16131 "redistribute " FRR_IP_REDIST_STR_BGPD
16132 " metric (0-4294967295) route-map RMAP_NAME",
16133 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16134 "Metric for redistributed routes\n"
16135 "Default metric\n"
16136 "Route map reference\n"
16137 "Pointer to route-map entries\n")
16138
16139 DEFUN (bgp_redistribute_ipv4_ospf,
16140 bgp_redistribute_ipv4_ospf_cmd,
16141 "redistribute <ospf|table> (1-65535)",
16142 "Redistribute information from another routing protocol\n"
16143 "Open Shortest Path First (OSPFv2)\n"
16144 "Non-main Kernel Routing Table\n"
16145 "Instance ID/Table ID\n")
16146 {
16147 VTY_DECLVAR_CONTEXT(bgp, bgp);
16148 int idx_ospf_table = 1;
16149 int idx_number = 2;
16150 unsigned short instance;
16151 unsigned short protocol;
16152
16153 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16154
16155 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16156 protocol = ZEBRA_ROUTE_OSPF;
16157 else
16158 protocol = ZEBRA_ROUTE_TABLE;
16159
16160 bgp_redist_add(bgp, AFI_IP, protocol, instance);
16161 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, false);
16162 }
16163
16164 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf, bgp_redistribute_ipv4_ospf_hidden_cmd,
16165 "redistribute <ospf|table> (1-65535)",
16166 "Redistribute information from another routing protocol\n"
16167 "Open Shortest Path First (OSPFv2)\n"
16168 "Non-main Kernel Routing Table\n"
16169 "Instance ID/Table ID\n")
16170
16171 DEFUN (bgp_redistribute_ipv4_ospf_rmap,
16172 bgp_redistribute_ipv4_ospf_rmap_cmd,
16173 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME",
16174 "Redistribute information from another routing protocol\n"
16175 "Open Shortest Path First (OSPFv2)\n"
16176 "Non-main Kernel Routing Table\n"
16177 "Instance ID/Table ID\n"
16178 "Route map reference\n"
16179 "Pointer to route-map entries\n")
16180 {
16181 VTY_DECLVAR_CONTEXT(bgp, bgp);
16182 int idx_ospf_table = 1;
16183 int idx_number = 2;
16184 int idx_word = 4;
16185 struct bgp_redist *red;
16186 unsigned short instance;
16187 int protocol;
16188 bool changed;
16189 struct route_map *route_map =
16190 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16191
16192 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16193 protocol = ZEBRA_ROUTE_OSPF;
16194 else
16195 protocol = ZEBRA_ROUTE_TABLE;
16196
16197 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16198 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16199 changed =
16200 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16201 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16202 }
16203
16204 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_rmap,
16205 bgp_redistribute_ipv4_ospf_rmap_hidden_cmd,
16206 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME",
16207 "Redistribute information from another routing protocol\n"
16208 "Open Shortest Path First (OSPFv2)\n"
16209 "Non-main Kernel Routing Table\n"
16210 "Instance ID/Table ID\n"
16211 "Route map reference\n"
16212 "Pointer to route-map entries\n")
16213
16214 DEFUN (bgp_redistribute_ipv4_ospf_metric,
16215 bgp_redistribute_ipv4_ospf_metric_cmd,
16216 "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
16217 "Redistribute information from another routing protocol\n"
16218 "Open Shortest Path First (OSPFv2)\n"
16219 "Non-main Kernel Routing Table\n"
16220 "Instance ID/Table ID\n"
16221 "Metric for redistributed routes\n"
16222 "Default metric\n")
16223 {
16224 VTY_DECLVAR_CONTEXT(bgp, bgp);
16225 int idx_ospf_table = 1;
16226 int idx_number = 2;
16227 int idx_number_2 = 4;
16228 uint32_t metric;
16229 struct bgp_redist *red;
16230 unsigned short instance;
16231 int protocol;
16232 bool changed;
16233
16234 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16235 protocol = ZEBRA_ROUTE_OSPF;
16236 else
16237 protocol = ZEBRA_ROUTE_TABLE;
16238
16239 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16240 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16241
16242 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16243 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16244 metric);
16245 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16246 }
16247
16248 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_metric,
16249 bgp_redistribute_ipv4_ospf_metric_hidden_cmd,
16250 "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
16251 "Redistribute information from another routing protocol\n"
16252 "Open Shortest Path First (OSPFv2)\n"
16253 "Non-main Kernel Routing Table\n"
16254 "Instance ID/Table ID\n"
16255 "Metric for redistributed routes\n"
16256 "Default metric\n")
16257
16258 DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
16259 bgp_redistribute_ipv4_ospf_rmap_metric_cmd,
16260 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME metric (0-4294967295)",
16261 "Redistribute information from another routing protocol\n"
16262 "Open Shortest Path First (OSPFv2)\n"
16263 "Non-main Kernel Routing Table\n"
16264 "Instance ID/Table ID\n"
16265 "Route map reference\n"
16266 "Pointer to route-map entries\n"
16267 "Metric for redistributed routes\n"
16268 "Default metric\n")
16269 {
16270 VTY_DECLVAR_CONTEXT(bgp, bgp);
16271 int idx_ospf_table = 1;
16272 int idx_number = 2;
16273 int idx_word = 4;
16274 int idx_number_2 = 6;
16275 uint32_t metric;
16276 struct bgp_redist *red;
16277 unsigned short instance;
16278 int protocol;
16279 bool changed;
16280 struct route_map *route_map =
16281 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16282
16283 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16284 protocol = ZEBRA_ROUTE_OSPF;
16285 else
16286 protocol = ZEBRA_ROUTE_TABLE;
16287
16288 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16289 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16290
16291 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16292 changed =
16293 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16294 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16295 metric);
16296 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16297 }
16298
16299 ALIAS_HIDDEN(
16300 bgp_redistribute_ipv4_ospf_rmap_metric,
16301 bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd,
16302 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME metric (0-4294967295)",
16303 "Redistribute information from another routing protocol\n"
16304 "Open Shortest Path First (OSPFv2)\n"
16305 "Non-main Kernel Routing Table\n"
16306 "Instance ID/Table ID\n"
16307 "Route map reference\n"
16308 "Pointer to route-map entries\n"
16309 "Metric for redistributed routes\n"
16310 "Default metric\n")
16311
16312 DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
16313 bgp_redistribute_ipv4_ospf_metric_rmap_cmd,
16314 "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map RMAP_NAME",
16315 "Redistribute information from another routing protocol\n"
16316 "Open Shortest Path First (OSPFv2)\n"
16317 "Non-main Kernel Routing Table\n"
16318 "Instance ID/Table ID\n"
16319 "Metric for redistributed routes\n"
16320 "Default metric\n"
16321 "Route map reference\n"
16322 "Pointer to route-map entries\n")
16323 {
16324 VTY_DECLVAR_CONTEXT(bgp, bgp);
16325 int idx_ospf_table = 1;
16326 int idx_number = 2;
16327 int idx_number_2 = 4;
16328 int idx_word = 6;
16329 uint32_t metric;
16330 struct bgp_redist *red;
16331 unsigned short instance;
16332 int protocol;
16333 bool changed;
16334 struct route_map *route_map =
16335 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16336
16337 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16338 protocol = ZEBRA_ROUTE_OSPF;
16339 else
16340 protocol = ZEBRA_ROUTE_TABLE;
16341
16342 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16343 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16344
16345 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16346 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16347 metric);
16348 changed |=
16349 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16350 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16351 }
16352
16353 ALIAS_HIDDEN(
16354 bgp_redistribute_ipv4_ospf_metric_rmap,
16355 bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd,
16356 "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map RMAP_NAME",
16357 "Redistribute information from another routing protocol\n"
16358 "Open Shortest Path First (OSPFv2)\n"
16359 "Non-main Kernel Routing Table\n"
16360 "Instance ID/Table ID\n"
16361 "Metric for redistributed routes\n"
16362 "Default metric\n"
16363 "Route map reference\n"
16364 "Pointer to route-map entries\n")
16365
16366 DEFUN (no_bgp_redistribute_ipv4_ospf,
16367 no_bgp_redistribute_ipv4_ospf_cmd,
16368 "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map RMAP_NAME}]",
16369 NO_STR
16370 "Redistribute information from another routing protocol\n"
16371 "Open Shortest Path First (OSPFv2)\n"
16372 "Non-main Kernel Routing Table\n"
16373 "Instance ID/Table ID\n"
16374 "Metric for redistributed routes\n"
16375 "Default metric\n"
16376 "Route map reference\n"
16377 "Pointer to route-map entries\n")
16378 {
16379 VTY_DECLVAR_CONTEXT(bgp, bgp);
16380 int idx_ospf_table = 2;
16381 int idx_number = 3;
16382 unsigned short instance;
16383 int protocol;
16384
16385 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16386 protocol = ZEBRA_ROUTE_OSPF;
16387 else
16388 protocol = ZEBRA_ROUTE_TABLE;
16389
16390 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16391 return bgp_redistribute_unset(bgp, AFI_IP, protocol, instance);
16392 }
16393
16394 ALIAS_HIDDEN(
16395 no_bgp_redistribute_ipv4_ospf, no_bgp_redistribute_ipv4_ospf_hidden_cmd,
16396 "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map RMAP_NAME}]",
16397 NO_STR
16398 "Redistribute information from another routing protocol\n"
16399 "Open Shortest Path First (OSPFv2)\n"
16400 "Non-main Kernel Routing Table\n"
16401 "Instance ID/Table ID\n"
16402 "Metric for redistributed routes\n"
16403 "Default metric\n"
16404 "Route map reference\n"
16405 "Pointer to route-map entries\n")
16406
16407 DEFUN (no_bgp_redistribute_ipv4,
16408 no_bgp_redistribute_ipv4_cmd,
16409 "no redistribute " FRR_IP_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16410 NO_STR
16411 "Redistribute information from another routing protocol\n"
16412 FRR_IP_REDIST_HELP_STR_BGPD
16413 "Metric for redistributed routes\n"
16414 "Default metric\n"
16415 "Route map reference\n"
16416 "Pointer to route-map entries\n")
16417 {
16418 VTY_DECLVAR_CONTEXT(bgp, bgp);
16419 int idx_protocol = 2;
16420 int type;
16421
16422 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16423 if (type < 0) {
16424 vty_out(vty, "%% Invalid route type\n");
16425 return CMD_WARNING_CONFIG_FAILED;
16426 }
16427 return bgp_redistribute_unset(bgp, AFI_IP, type, 0);
16428 }
16429
16430 ALIAS_HIDDEN(
16431 no_bgp_redistribute_ipv4, no_bgp_redistribute_ipv4_hidden_cmd,
16432 "no redistribute " FRR_IP_REDIST_STR_BGPD
16433 " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16434 NO_STR
16435 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16436 "Metric for redistributed routes\n"
16437 "Default metric\n"
16438 "Route map reference\n"
16439 "Pointer to route-map entries\n")
16440
16441 DEFUN (bgp_redistribute_ipv6,
16442 bgp_redistribute_ipv6_cmd,
16443 "redistribute " FRR_IP6_REDIST_STR_BGPD,
16444 "Redistribute information from another routing protocol\n"
16445 FRR_IP6_REDIST_HELP_STR_BGPD)
16446 {
16447 VTY_DECLVAR_CONTEXT(bgp, bgp);
16448 int idx_protocol = 1;
16449 int type;
16450
16451 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16452 if (type < 0) {
16453 vty_out(vty, "%% Invalid route type\n");
16454 return CMD_WARNING_CONFIG_FAILED;
16455 }
16456
16457 bgp_redist_add(bgp, AFI_IP6, type, 0);
16458 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, false);
16459 }
16460
16461 DEFUN (bgp_redistribute_ipv6_rmap,
16462 bgp_redistribute_ipv6_rmap_cmd,
16463 "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map RMAP_NAME",
16464 "Redistribute information from another routing protocol\n"
16465 FRR_IP6_REDIST_HELP_STR_BGPD
16466 "Route map reference\n"
16467 "Pointer to route-map entries\n")
16468 {
16469 VTY_DECLVAR_CONTEXT(bgp, bgp);
16470 int idx_protocol = 1;
16471 int idx_word = 3;
16472 int type;
16473 struct bgp_redist *red;
16474 bool changed;
16475 struct route_map *route_map =
16476 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16477
16478 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16479 if (type < 0) {
16480 vty_out(vty, "%% Invalid route type\n");
16481 return CMD_WARNING_CONFIG_FAILED;
16482 }
16483
16484 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16485 changed =
16486 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16487 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16488 }
16489
16490 DEFUN (bgp_redistribute_ipv6_metric,
16491 bgp_redistribute_ipv6_metric_cmd,
16492 "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295)",
16493 "Redistribute information from another routing protocol\n"
16494 FRR_IP6_REDIST_HELP_STR_BGPD
16495 "Metric for redistributed routes\n"
16496 "Default metric\n")
16497 {
16498 VTY_DECLVAR_CONTEXT(bgp, bgp);
16499 int idx_protocol = 1;
16500 int idx_number = 3;
16501 int type;
16502 uint32_t metric;
16503 struct bgp_redist *red;
16504 bool changed;
16505
16506 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16507 if (type < 0) {
16508 vty_out(vty, "%% Invalid route type\n");
16509 return CMD_WARNING_CONFIG_FAILED;
16510 }
16511 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16512
16513 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16514 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
16515 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16516 }
16517
16518 DEFUN (bgp_redistribute_ipv6_rmap_metric,
16519 bgp_redistribute_ipv6_rmap_metric_cmd,
16520 "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map RMAP_NAME metric (0-4294967295)",
16521 "Redistribute information from another routing protocol\n"
16522 FRR_IP6_REDIST_HELP_STR_BGPD
16523 "Route map reference\n"
16524 "Pointer to route-map entries\n"
16525 "Metric for redistributed routes\n"
16526 "Default metric\n")
16527 {
16528 VTY_DECLVAR_CONTEXT(bgp, bgp);
16529 int idx_protocol = 1;
16530 int idx_word = 3;
16531 int idx_number = 5;
16532 int type;
16533 uint32_t metric;
16534 struct bgp_redist *red;
16535 bool changed;
16536 struct route_map *route_map =
16537 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16538
16539 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16540 if (type < 0) {
16541 vty_out(vty, "%% Invalid route type\n");
16542 return CMD_WARNING_CONFIG_FAILED;
16543 }
16544 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16545
16546 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16547 changed =
16548 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16549 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP6, type,
16550 metric);
16551 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16552 }
16553
16554 DEFUN (bgp_redistribute_ipv6_metric_rmap,
16555 bgp_redistribute_ipv6_metric_rmap_cmd,
16556 "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295) route-map RMAP_NAME",
16557 "Redistribute information from another routing protocol\n"
16558 FRR_IP6_REDIST_HELP_STR_BGPD
16559 "Metric for redistributed routes\n"
16560 "Default metric\n"
16561 "Route map reference\n"
16562 "Pointer to route-map entries\n")
16563 {
16564 VTY_DECLVAR_CONTEXT(bgp, bgp);
16565 int idx_protocol = 1;
16566 int idx_number = 3;
16567 int idx_word = 5;
16568 int type;
16569 uint32_t metric;
16570 struct bgp_redist *red;
16571 bool changed;
16572 struct route_map *route_map =
16573 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16574
16575 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16576 if (type < 0) {
16577 vty_out(vty, "%% Invalid route type\n");
16578 return CMD_WARNING_CONFIG_FAILED;
16579 }
16580 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16581
16582 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16583 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, SAFI_UNICAST,
16584 metric);
16585 changed |=
16586 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16587 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16588 }
16589
16590 DEFUN (no_bgp_redistribute_ipv6,
16591 no_bgp_redistribute_ipv6_cmd,
16592 "no redistribute " FRR_IP6_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16593 NO_STR
16594 "Redistribute information from another routing protocol\n"
16595 FRR_IP6_REDIST_HELP_STR_BGPD
16596 "Metric for redistributed routes\n"
16597 "Default metric\n"
16598 "Route map reference\n"
16599 "Pointer to route-map entries\n")
16600 {
16601 VTY_DECLVAR_CONTEXT(bgp, bgp);
16602 int idx_protocol = 2;
16603 int type;
16604
16605 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16606 if (type < 0) {
16607 vty_out(vty, "%% Invalid route type\n");
16608 return CMD_WARNING_CONFIG_FAILED;
16609 }
16610
16611 return bgp_redistribute_unset(bgp, AFI_IP6, type, 0);
16612 }
16613
16614 /* Neighbor update tcp-mss. */
16615 static int peer_tcp_mss_vty(struct vty *vty, const char *peer_str,
16616 const char *tcp_mss_str)
16617 {
16618 struct peer *peer;
16619 uint32_t tcp_mss_val = 0;
16620
16621 peer = peer_and_group_lookup_vty(vty, peer_str);
16622 if (!peer)
16623 return CMD_WARNING_CONFIG_FAILED;
16624
16625 if (tcp_mss_str) {
16626 tcp_mss_val = strtoul(tcp_mss_str, NULL, 10);
16627 peer_tcp_mss_set(peer, tcp_mss_val);
16628 } else {
16629 peer_tcp_mss_unset(peer);
16630 }
16631
16632 return CMD_SUCCESS;
16633 }
16634
16635 DEFUN(neighbor_tcp_mss, neighbor_tcp_mss_cmd,
16636 "neighbor <A.B.C.D|X:X::X:X|WORD> tcp-mss (1-65535)",
16637 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
16638 "TCP max segment size\n"
16639 "TCP MSS value\n")
16640 {
16641 int peer_index = 1;
16642 int mss_index = 3;
16643
16644 vty_out(vty,
16645 " Warning: Reset BGP session for tcp-mss value to take effect\n");
16646 return peer_tcp_mss_vty(vty, argv[peer_index]->arg,
16647 argv[mss_index]->arg);
16648 }
16649
16650 DEFUN(no_neighbor_tcp_mss, no_neighbor_tcp_mss_cmd,
16651 "no neighbor <A.B.C.D|X:X::X:X|WORD> tcp-mss [(1-65535)]",
16652 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
16653 "TCP max segment size\n"
16654 "TCP MSS value\n")
16655 {
16656 int peer_index = 2;
16657
16658 vty_out(vty,
16659 " Warning: Reset BGP session for tcp-mss value to take effect\n");
16660 return peer_tcp_mss_vty(vty, argv[peer_index]->arg, NULL);
16661 }
16662
16663 DEFPY(bgp_retain_route_target, bgp_retain_route_target_cmd,
16664 "[no$no] bgp retain route-target all",
16665 NO_STR BGP_STR
16666 "Retain BGP updates\n"
16667 "Retain BGP updates based on route-target values\n"
16668 "Retain all BGP updates\n")
16669 {
16670 bool check;
16671 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
16672
16673 check = CHECK_FLAG(bgp->af_flags[bgp_node_afi(vty)][bgp_node_safi(vty)],
16674 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
16675 if (check != !no) {
16676 if (!no)
16677 SET_FLAG(bgp->af_flags[bgp_node_afi(vty)]
16678 [bgp_node_safi(vty)],
16679 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
16680 else
16681 UNSET_FLAG(bgp->af_flags[bgp_node_afi(vty)]
16682 [bgp_node_safi(vty)],
16683 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
16684 /* trigger a flush to re-sync with ADJ-RIB-in */
16685 bgp_clear(vty, bgp, bgp_node_afi(vty), bgp_node_safi(vty),
16686 clear_all, BGP_CLEAR_SOFT_IN, NULL);
16687 }
16688 return CMD_SUCCESS;
16689 }
16690
16691 static void bgp_config_write_redistribute(struct vty *vty, struct bgp *bgp,
16692 afi_t afi, safi_t safi)
16693 {
16694 int i;
16695
16696 /* Unicast redistribution only. */
16697 if (safi != SAFI_UNICAST)
16698 return;
16699
16700 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
16701 /* Redistribute BGP does not make sense. */
16702 if (i != ZEBRA_ROUTE_BGP) {
16703 struct list *red_list;
16704 struct listnode *node;
16705 struct bgp_redist *red;
16706
16707 red_list = bgp->redist[afi][i];
16708 if (!red_list)
16709 continue;
16710
16711 for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
16712 /* "redistribute" configuration. */
16713 vty_out(vty, " redistribute %s",
16714 zebra_route_string(i));
16715 if (red->instance)
16716 vty_out(vty, " %d", red->instance);
16717 if (red->redist_metric_flag)
16718 vty_out(vty, " metric %u",
16719 red->redist_metric);
16720 if (red->rmap.name)
16721 vty_out(vty, " route-map %s",
16722 red->rmap.name);
16723 vty_out(vty, "\n");
16724 }
16725 }
16726 }
16727 }
16728
16729 /* peer-group helpers for config-write */
16730
16731 static bool peergroup_flag_check(struct peer *peer, uint64_t flag)
16732 {
16733 if (!peer_group_active(peer)) {
16734 if (CHECK_FLAG(peer->flags_invert, flag))
16735 return !CHECK_FLAG(peer->flags, flag);
16736 else
16737 return !!CHECK_FLAG(peer->flags, flag);
16738 }
16739
16740 return !!CHECK_FLAG(peer->flags_override, flag);
16741 }
16742
16743 static bool peergroup_af_flag_check(struct peer *peer, afi_t afi, safi_t safi,
16744 uint64_t flag)
16745 {
16746 if (!peer_group_active(peer)) {
16747 if (CHECK_FLAG(peer->af_flags_invert[afi][safi], flag))
16748 return !peer_af_flag_check(peer, afi, safi, flag);
16749 else
16750 return !!peer_af_flag_check(peer, afi, safi, flag);
16751 }
16752
16753 return !!CHECK_FLAG(peer->af_flags_override[afi][safi], flag);
16754 }
16755
16756 static bool peergroup_filter_check(struct peer *peer, afi_t afi, safi_t safi,
16757 uint8_t type, int direct)
16758 {
16759 struct bgp_filter *filter;
16760
16761 if (peer_group_active(peer))
16762 return !!CHECK_FLAG(peer->filter_override[afi][safi][direct],
16763 type);
16764
16765 filter = &peer->filter[afi][safi];
16766 switch (type) {
16767 case PEER_FT_DISTRIBUTE_LIST:
16768 return !!(filter->dlist[direct].name);
16769 case PEER_FT_FILTER_LIST:
16770 return !!(filter->aslist[direct].name);
16771 case PEER_FT_PREFIX_LIST:
16772 return !!(filter->plist[direct].name);
16773 case PEER_FT_ROUTE_MAP:
16774 return !!(filter->map[direct].name);
16775 case PEER_FT_UNSUPPRESS_MAP:
16776 return !!(filter->usmap.name);
16777 case PEER_FT_ADVERTISE_MAP:
16778 return !!(filter->advmap.aname
16779 && ((filter->advmap.condition == direct)
16780 && filter->advmap.cname));
16781 default:
16782 return false;
16783 }
16784 }
16785
16786 /* Return true if the addpath type is set for peer and different from
16787 * peer-group.
16788 */
16789 static bool peergroup_af_addpath_check(struct peer *peer, afi_t afi,
16790 safi_t safi)
16791 {
16792 enum bgp_addpath_strat type, g_type;
16793
16794 type = peer->addpath_type[afi][safi];
16795
16796 if (type != BGP_ADDPATH_NONE) {
16797 if (peer_group_active(peer)) {
16798 g_type = peer->group->conf->addpath_type[afi][safi];
16799
16800 if (type != g_type)
16801 return true;
16802 else
16803 return false;
16804 }
16805
16806 return true;
16807 }
16808
16809 return false;
16810 }
16811
16812 /* This is part of the address-family block (unicast only) */
16813 static void bgp_vpn_policy_config_write_afi(struct vty *vty, struct bgp *bgp,
16814 afi_t afi)
16815 {
16816 int indent = 2;
16817 uint32_t tovpn_sid_index = 0;
16818
16819 if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]) {
16820 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
16821 BGP_CONFIG_VRF_TO_VRF_IMPORT))
16822 vty_out(vty, "%*simport vrf route-map %s\n", indent, "",
16823 bgp->vpn_policy[afi]
16824 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
16825 else
16826 vty_out(vty, "%*sroute-map vpn import %s\n", indent, "",
16827 bgp->vpn_policy[afi]
16828 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
16829 }
16830 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
16831 BGP_CONFIG_VRF_TO_VRF_IMPORT)
16832 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
16833 BGP_CONFIG_VRF_TO_VRF_EXPORT))
16834 return;
16835
16836 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
16837 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
16838
16839 vty_out(vty, "%*slabel vpn export %s\n", indent, "", "auto");
16840
16841 } else {
16842 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
16843 vty_out(vty, "%*slabel vpn export %u\n", indent, "",
16844 bgp->vpn_policy[afi].tovpn_label);
16845 }
16846 }
16847
16848 tovpn_sid_index = bgp->vpn_policy[afi].tovpn_sid_index;
16849 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
16850 BGP_VPN_POLICY_TOVPN_SID_AUTO)) {
16851 vty_out(vty, "%*ssid vpn export %s\n", indent, "", "auto");
16852 } else if (tovpn_sid_index != 0) {
16853 vty_out(vty, "%*ssid vpn export %d\n", indent, "",
16854 tovpn_sid_index);
16855 }
16856
16857 if (CHECK_FLAG(bgp->vpn_policy[afi].flags, BGP_VPN_POLICY_TOVPN_RD_SET))
16858 vty_out(vty, "%*srd vpn export %pRD\n", indent, "",
16859 &bgp->vpn_policy[afi].tovpn_rd);
16860
16861 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
16862 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET)) {
16863
16864 char buf[PREFIX_STRLEN];
16865 if (inet_ntop(bgp->vpn_policy[afi].tovpn_nexthop.family,
16866 &bgp->vpn_policy[afi].tovpn_nexthop.u.prefix, buf,
16867 sizeof(buf))) {
16868
16869 vty_out(vty, "%*snexthop vpn export %s\n",
16870 indent, "", buf);
16871 }
16872 }
16873 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]
16874 && bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]
16875 && ecommunity_cmp(
16876 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
16877 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN])) {
16878
16879 char *b = ecommunity_ecom2str(
16880 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN],
16881 ECOMMUNITY_FORMAT_ROUTE_MAP, ECOMMUNITY_ROUTE_TARGET);
16882 vty_out(vty, "%*srt vpn both %s\n", indent, "", b);
16883 XFREE(MTYPE_ECOMMUNITY_STR, b);
16884 } else {
16885 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]) {
16886 char *b = ecommunity_ecom2str(
16887 bgp->vpn_policy[afi]
16888 .rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
16889 ECOMMUNITY_FORMAT_ROUTE_MAP,
16890 ECOMMUNITY_ROUTE_TARGET);
16891 vty_out(vty, "%*srt vpn import %s\n", indent, "", b);
16892 XFREE(MTYPE_ECOMMUNITY_STR, b);
16893 }
16894 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]) {
16895 char *b = ecommunity_ecom2str(
16896 bgp->vpn_policy[afi]
16897 .rtlist[BGP_VPN_POLICY_DIR_TOVPN],
16898 ECOMMUNITY_FORMAT_ROUTE_MAP,
16899 ECOMMUNITY_ROUTE_TARGET);
16900 vty_out(vty, "%*srt vpn export %s\n", indent, "", b);
16901 XFREE(MTYPE_ECOMMUNITY_STR, b);
16902 }
16903 }
16904
16905 if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_TOVPN])
16906 vty_out(vty, "%*sroute-map vpn export %s\n", indent, "",
16907 bgp->vpn_policy[afi]
16908 .rmap_name[BGP_VPN_POLICY_DIR_TOVPN]);
16909
16910 if (bgp->vpn_policy[afi].import_redirect_rtlist) {
16911 char *b = ecommunity_ecom2str(
16912 bgp->vpn_policy[afi]
16913 .import_redirect_rtlist,
16914 ECOMMUNITY_FORMAT_ROUTE_MAP,
16915 ECOMMUNITY_ROUTE_TARGET);
16916
16917 if (bgp->vpn_policy[afi].import_redirect_rtlist->unit_size
16918 != ECOMMUNITY_SIZE)
16919 vty_out(vty, "%*srt6 redirect import %s\n",
16920 indent, "", b);
16921 else
16922 vty_out(vty, "%*srt redirect import %s\n",
16923 indent, "", b);
16924 XFREE(MTYPE_ECOMMUNITY_STR, b);
16925 }
16926 }
16927
16928 static void bgp_config_write_filter(struct vty *vty, struct peer *peer,
16929 afi_t afi, safi_t safi)
16930 {
16931 struct bgp_filter *filter;
16932 char *addr;
16933
16934 addr = peer->host;
16935 filter = &peer->filter[afi][safi];
16936
16937 /* distribute-list. */
16938 if (peergroup_filter_check(peer, afi, safi, PEER_FT_DISTRIBUTE_LIST,
16939 FILTER_IN))
16940 vty_out(vty, " neighbor %s distribute-list %s in\n", addr,
16941 filter->dlist[FILTER_IN].name);
16942
16943 if (peergroup_filter_check(peer, afi, safi, PEER_FT_DISTRIBUTE_LIST,
16944 FILTER_OUT))
16945 vty_out(vty, " neighbor %s distribute-list %s out\n", addr,
16946 filter->dlist[FILTER_OUT].name);
16947
16948 /* prefix-list. */
16949 if (peergroup_filter_check(peer, afi, safi, PEER_FT_PREFIX_LIST,
16950 FILTER_IN))
16951 vty_out(vty, " neighbor %s prefix-list %s in\n", addr,
16952 filter->plist[FILTER_IN].name);
16953
16954 if (peergroup_filter_check(peer, afi, safi, PEER_FT_PREFIX_LIST,
16955 FILTER_OUT))
16956 vty_out(vty, " neighbor %s prefix-list %s out\n", addr,
16957 filter->plist[FILTER_OUT].name);
16958
16959 /* route-map. */
16960 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ROUTE_MAP, RMAP_IN))
16961 vty_out(vty, " neighbor %s route-map %s in\n", addr,
16962 filter->map[RMAP_IN].name);
16963
16964 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ROUTE_MAP,
16965 RMAP_OUT))
16966 vty_out(vty, " neighbor %s route-map %s out\n", addr,
16967 filter->map[RMAP_OUT].name);
16968
16969 /* unsuppress-map */
16970 if (peergroup_filter_check(peer, afi, safi, PEER_FT_UNSUPPRESS_MAP, 0))
16971 vty_out(vty, " neighbor %s unsuppress-map %s\n", addr,
16972 filter->usmap.name);
16973
16974 /* advertise-map : always applied in OUT direction*/
16975 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ADVERTISE_MAP,
16976 CONDITION_NON_EXIST))
16977 vty_out(vty,
16978 " neighbor %s advertise-map %s non-exist-map %s\n",
16979 addr, filter->advmap.aname, filter->advmap.cname);
16980
16981 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ADVERTISE_MAP,
16982 CONDITION_EXIST))
16983 vty_out(vty, " neighbor %s advertise-map %s exist-map %s\n",
16984 addr, filter->advmap.aname, filter->advmap.cname);
16985
16986 /* filter-list. */
16987 if (peergroup_filter_check(peer, afi, safi, PEER_FT_FILTER_LIST,
16988 FILTER_IN))
16989 vty_out(vty, " neighbor %s filter-list %s in\n", addr,
16990 filter->aslist[FILTER_IN].name);
16991
16992 if (peergroup_filter_check(peer, afi, safi, PEER_FT_FILTER_LIST,
16993 FILTER_OUT))
16994 vty_out(vty, " neighbor %s filter-list %s out\n", addr,
16995 filter->aslist[FILTER_OUT].name);
16996 }
16997
16998 /* BGP peer configuration display function. */
16999 static void bgp_config_write_peer_global(struct vty *vty, struct bgp *bgp,
17000 struct peer *peer)
17001 {
17002 struct peer *g_peer = NULL;
17003 char *addr;
17004 int if_pg_printed = false;
17005 int if_ras_printed = false;
17006
17007 /* Skip dynamic neighbors. */
17008 if (peer_dynamic_neighbor(peer))
17009 return;
17010
17011 if (peer->conf_if)
17012 addr = peer->conf_if;
17013 else
17014 addr = peer->host;
17015
17016 /************************************
17017 ****** Global to the neighbor ******
17018 ************************************/
17019 if (peer->conf_if) {
17020 if (CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
17021 vty_out(vty, " neighbor %s interface v6only", addr);
17022 else
17023 vty_out(vty, " neighbor %s interface", addr);
17024
17025 if (peer_group_active(peer)) {
17026 vty_out(vty, " peer-group %s", peer->group->name);
17027 if_pg_printed = true;
17028 } else if (peer->as_type == AS_SPECIFIED) {
17029 vty_out(vty, " remote-as %u", peer->as);
17030 if_ras_printed = true;
17031 } else if (peer->as_type == AS_INTERNAL) {
17032 vty_out(vty, " remote-as internal");
17033 if_ras_printed = true;
17034 } else if (peer->as_type == AS_EXTERNAL) {
17035 vty_out(vty, " remote-as external");
17036 if_ras_printed = true;
17037 }
17038
17039 vty_out(vty, "\n");
17040 }
17041
17042 /* remote-as and peer-group */
17043 /* peer is a member of a peer-group */
17044 if (peer_group_active(peer)) {
17045 g_peer = peer->group->conf;
17046
17047 if (g_peer->as_type == AS_UNSPECIFIED && !if_ras_printed) {
17048 if (peer->as_type == AS_SPECIFIED) {
17049 vty_out(vty, " neighbor %s remote-as %u\n",
17050 addr, peer->as);
17051 } else if (peer->as_type == AS_INTERNAL) {
17052 vty_out(vty,
17053 " neighbor %s remote-as internal\n",
17054 addr);
17055 } else if (peer->as_type == AS_EXTERNAL) {
17056 vty_out(vty,
17057 " neighbor %s remote-as external\n",
17058 addr);
17059 }
17060 }
17061
17062 /* For swpX peers we displayed the peer-group
17063 * via 'neighbor swpX interface peer-group PGNAME' */
17064 if (!if_pg_printed)
17065 vty_out(vty, " neighbor %s peer-group %s\n", addr,
17066 peer->group->name);
17067 }
17068
17069 /* peer is NOT a member of a peer-group */
17070 else {
17071 /* peer is a peer-group, declare the peer-group */
17072 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
17073 vty_out(vty, " neighbor %s peer-group\n", addr);
17074 }
17075
17076 if (!if_ras_printed) {
17077 if (peer->as_type == AS_SPECIFIED) {
17078 vty_out(vty, " neighbor %s remote-as %u\n",
17079 addr, peer->as);
17080 } else if (peer->as_type == AS_INTERNAL) {
17081 vty_out(vty,
17082 " neighbor %s remote-as internal\n",
17083 addr);
17084 } else if (peer->as_type == AS_EXTERNAL) {
17085 vty_out(vty,
17086 " neighbor %s remote-as external\n",
17087 addr);
17088 }
17089 }
17090 }
17091
17092 /* local-as */
17093 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS)) {
17094 vty_out(vty, " neighbor %s local-as %u", addr,
17095 peer->change_local_as);
17096 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND))
17097 vty_out(vty, " no-prepend");
17098 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS))
17099 vty_out(vty, " replace-as");
17100 vty_out(vty, "\n");
17101 }
17102
17103 /* description */
17104 if (peer->desc) {
17105 vty_out(vty, " neighbor %s description %s\n", addr, peer->desc);
17106 }
17107
17108 /* shutdown */
17109 if (peergroup_flag_check(peer, PEER_FLAG_SHUTDOWN)) {
17110 if (peer->tx_shutdown_message)
17111 vty_out(vty, " neighbor %s shutdown message %s\n", addr,
17112 peer->tx_shutdown_message);
17113 else
17114 vty_out(vty, " neighbor %s shutdown\n", addr);
17115 }
17116
17117 if (peergroup_flag_check(peer, PEER_FLAG_RTT_SHUTDOWN))
17118 vty_out(vty, " neighbor %s shutdown rtt %u count %u\n", addr,
17119 peer->rtt_expected, peer->rtt_keepalive_conf);
17120
17121 /* bfd */
17122 if (peer->bfd_config)
17123 bgp_bfd_peer_config_write(vty, peer, addr);
17124
17125 /* password */
17126 if (peergroup_flag_check(peer, PEER_FLAG_PASSWORD))
17127 vty_out(vty, " neighbor %s password %s\n", addr,
17128 peer->password);
17129
17130 /* neighbor solo */
17131 if (CHECK_FLAG(peer->flags, PEER_FLAG_LONESOUL)) {
17132 if (!peer_group_active(peer)) {
17133 vty_out(vty, " neighbor %s solo\n", addr);
17134 }
17135 }
17136
17137 /* BGP port */
17138 if (peer->port != BGP_PORT_DEFAULT) {
17139 vty_out(vty, " neighbor %s port %d\n", addr, peer->port);
17140 }
17141
17142 /* Local interface name */
17143 if (peer->ifname) {
17144 vty_out(vty, " neighbor %s interface %s\n", addr, peer->ifname);
17145 }
17146
17147 /* TCP max segment size */
17148 if (CHECK_FLAG(peer->flags, PEER_FLAG_TCP_MSS))
17149 vty_out(vty, " neighbor %s tcp-mss %d\n", addr, peer->tcp_mss);
17150
17151 /* passive */
17152 if (peergroup_flag_check(peer, PEER_FLAG_PASSIVE))
17153 vty_out(vty, " neighbor %s passive\n", addr);
17154
17155 /* ebgp-multihop */
17156 if (peer->sort != BGP_PEER_IBGP && peer->ttl != BGP_DEFAULT_TTL
17157 && !(peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED
17158 && peer->ttl == MAXTTL)) {
17159 if (!peer_group_active(peer) || g_peer->ttl != peer->ttl) {
17160 vty_out(vty, " neighbor %s ebgp-multihop %d\n", addr,
17161 peer->ttl);
17162 }
17163 }
17164
17165 /* role */
17166 if (peergroup_flag_check(peer, PEER_FLAG_ROLE) &&
17167 peer->local_role != ROLE_UNDEFINED)
17168 vty_out(vty, " neighbor %s local-role %s%s\n", addr,
17169 bgp_get_name_by_role(peer->local_role),
17170 CHECK_FLAG(peer->flags, PEER_FLAG_ROLE_STRICT_MODE)
17171 ? " strict-mode"
17172 : "");
17173
17174 /* ttl-security hops */
17175 if (peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED) {
17176 if (!peer_group_active(peer)
17177 || g_peer->gtsm_hops != peer->gtsm_hops) {
17178 vty_out(vty, " neighbor %s ttl-security hops %d\n",
17179 addr, peer->gtsm_hops);
17180 }
17181 }
17182
17183 /* disable-connected-check */
17184 if (peergroup_flag_check(peer, PEER_FLAG_DISABLE_CONNECTED_CHECK))
17185 vty_out(vty, " neighbor %s disable-connected-check\n", addr);
17186
17187 /* link-bw-encoding-ieee */
17188 if (peergroup_flag_check(peer, PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE))
17189 vty_out(vty, " neighbor %s disable-link-bw-encoding-ieee\n",
17190 addr);
17191
17192 /* extended-optional-parameters */
17193 if (peergroup_flag_check(peer, PEER_FLAG_EXTENDED_OPT_PARAMS))
17194 vty_out(vty, " neighbor %s extended-optional-parameters\n",
17195 addr);
17196
17197 /* enforce-first-as */
17198 if (peergroup_flag_check(peer, PEER_FLAG_ENFORCE_FIRST_AS))
17199 vty_out(vty, " neighbor %s enforce-first-as\n", addr);
17200
17201 /* update-source */
17202 if (peergroup_flag_check(peer, PEER_FLAG_UPDATE_SOURCE)) {
17203 if (peer->update_source)
17204 vty_out(vty, " neighbor %s update-source %pSU\n", addr,
17205 peer->update_source);
17206 else if (peer->update_if)
17207 vty_out(vty, " neighbor %s update-source %s\n", addr,
17208 peer->update_if);
17209 }
17210
17211 /* advertisement-interval */
17212 if (peergroup_flag_check(peer, PEER_FLAG_ROUTEADV))
17213 vty_out(vty, " neighbor %s advertisement-interval %u\n", addr,
17214 peer->routeadv);
17215
17216 /* timers */
17217 if (peergroup_flag_check(peer, PEER_FLAG_TIMER))
17218 vty_out(vty, " neighbor %s timers %u %u\n", addr,
17219 peer->keepalive, peer->holdtime);
17220
17221 /* timers connect */
17222 if (peergroup_flag_check(peer, PEER_FLAG_TIMER_CONNECT))
17223 vty_out(vty, " neighbor %s timers connect %u\n", addr,
17224 peer->connect);
17225 /* need special-case handling for changed default values due to
17226 * config profile / version (because there is no "timers bgp connect"
17227 * command, we need to save this per-peer :/)
17228 */
17229 else if (!peer_group_active(peer) && !peer->connect &&
17230 peer->bgp->default_connect_retry != SAVE_BGP_CONNECT_RETRY)
17231 vty_out(vty, " neighbor %s timers connect %u\n", addr,
17232 peer->bgp->default_connect_retry);
17233
17234 /* timers delayopen */
17235 if (peergroup_flag_check(peer, PEER_FLAG_TIMER_DELAYOPEN))
17236 vty_out(vty, " neighbor %s timers delayopen %u\n", addr,
17237 peer->delayopen);
17238 /* Save config even though flag is not set if default values have been
17239 * changed
17240 */
17241 else if (!peer_group_active(peer) && !peer->delayopen
17242 && peer->bgp->default_delayopen != BGP_DEFAULT_DELAYOPEN)
17243 vty_out(vty, " neighbor %s timers delayopen %u\n", addr,
17244 peer->bgp->default_delayopen);
17245
17246 /* capability dynamic */
17247 if (peergroup_flag_check(peer, PEER_FLAG_DYNAMIC_CAPABILITY))
17248 vty_out(vty, " neighbor %s capability dynamic\n", addr);
17249
17250 /* capability extended-nexthop */
17251 if (peergroup_flag_check(peer, PEER_FLAG_CAPABILITY_ENHE)) {
17252 if (CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE) &&
17253 !peer->conf_if)
17254 vty_out(vty,
17255 " no neighbor %s capability extended-nexthop\n",
17256 addr);
17257 else if (!peer->conf_if)
17258 vty_out(vty,
17259 " neighbor %s capability extended-nexthop\n",
17260 addr);
17261 }
17262
17263 /* dont-capability-negotiation */
17264 if (peergroup_flag_check(peer, PEER_FLAG_DONT_CAPABILITY))
17265 vty_out(vty, " neighbor %s dont-capability-negotiate\n", addr);
17266
17267 /* override-capability */
17268 if (peergroup_flag_check(peer, PEER_FLAG_OVERRIDE_CAPABILITY))
17269 vty_out(vty, " neighbor %s override-capability\n", addr);
17270
17271 /* strict-capability-match */
17272 if (peergroup_flag_check(peer, PEER_FLAG_STRICT_CAP_MATCH))
17273 vty_out(vty, " neighbor %s strict-capability-match\n", addr);
17274
17275 /* Sender side AS path loop detection. */
17276 if (peer->as_path_loop_detection)
17277 vty_out(vty, " neighbor %s sender-as-path-loop-detection\n",
17278 addr);
17279
17280 if (!CHECK_FLAG(peer->peer_gr_new_status_flag,
17281 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT)) {
17282
17283 if (CHECK_FLAG(peer->peer_gr_new_status_flag,
17284 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER)) {
17285 vty_out(vty,
17286 " neighbor %s graceful-restart-helper\n", addr);
17287 } else if (CHECK_FLAG(
17288 peer->peer_gr_new_status_flag,
17289 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART)) {
17290 vty_out(vty,
17291 " neighbor %s graceful-restart\n", addr);
17292 } else if (
17293 (!(CHECK_FLAG(peer->peer_gr_new_status_flag,
17294 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
17295 && !(CHECK_FLAG(
17296 peer->peer_gr_new_status_flag,
17297 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART)))) {
17298 vty_out(vty, " neighbor %s graceful-restart-disable\n",
17299 addr);
17300 }
17301 }
17302 }
17303
17304 /* BGP peer configuration display function. */
17305 static void bgp_config_write_peer_af(struct vty *vty, struct bgp *bgp,
17306 struct peer *peer, afi_t afi, safi_t safi)
17307 {
17308 struct peer *g_peer = NULL;
17309 char *addr;
17310 bool flag_scomm, flag_secomm, flag_slcomm;
17311
17312 /* Skip dynamic neighbors. */
17313 if (peer_dynamic_neighbor(peer))
17314 return;
17315
17316 if (peer->conf_if)
17317 addr = peer->conf_if;
17318 else
17319 addr = peer->host;
17320
17321 /************************************
17322 ****** Per AF to the neighbor ******
17323 ************************************/
17324 if (peer_group_active(peer)) {
17325 g_peer = peer->group->conf;
17326
17327 /* If the peer-group is active but peer is not, print a 'no
17328 * activate' */
17329 if (g_peer->afc[afi][safi] && !peer->afc[afi][safi]) {
17330 vty_out(vty, " no neighbor %s activate\n", addr);
17331 }
17332
17333 /* If the peer-group is not active but peer is, print an
17334 'activate' */
17335 else if (!g_peer->afc[afi][safi] && peer->afc[afi][safi]) {
17336 vty_out(vty, " neighbor %s activate\n", addr);
17337 }
17338 } else {
17339 if (peer->afc[afi][safi]) {
17340 if (safi == SAFI_ENCAP)
17341 vty_out(vty, " neighbor %s activate\n", addr);
17342 else if (!bgp->default_af[afi][safi])
17343 vty_out(vty, " neighbor %s activate\n", addr);
17344 } else {
17345 if (bgp->default_af[afi][safi])
17346 vty_out(vty, " no neighbor %s activate\n",
17347 addr);
17348 }
17349 }
17350
17351 /* addpath TX knobs */
17352 if (peergroup_af_addpath_check(peer, afi, safi)) {
17353 switch (peer->addpath_type[afi][safi]) {
17354 case BGP_ADDPATH_ALL:
17355 vty_out(vty, " neighbor %s addpath-tx-all-paths\n",
17356 addr);
17357 break;
17358 case BGP_ADDPATH_BEST_PER_AS:
17359 vty_out(vty,
17360 " neighbor %s addpath-tx-bestpath-per-AS\n",
17361 addr);
17362 break;
17363 case BGP_ADDPATH_MAX:
17364 case BGP_ADDPATH_NONE:
17365 break;
17366 }
17367 }
17368
17369 if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_DISABLE_ADDPATH_RX))
17370 vty_out(vty, " neighbor %s disable-addpath-rx\n", addr);
17371
17372 /* ORF capability. */
17373 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ORF_PREFIX_SM)
17374 || peergroup_af_flag_check(peer, afi, safi,
17375 PEER_FLAG_ORF_PREFIX_RM)) {
17376 vty_out(vty, " neighbor %s capability orf prefix-list", addr);
17377
17378 if (peergroup_af_flag_check(peer, afi, safi,
17379 PEER_FLAG_ORF_PREFIX_SM)
17380 && peergroup_af_flag_check(peer, afi, safi,
17381 PEER_FLAG_ORF_PREFIX_RM))
17382 vty_out(vty, " both");
17383 else if (peergroup_af_flag_check(peer, afi, safi,
17384 PEER_FLAG_ORF_PREFIX_SM))
17385 vty_out(vty, " send");
17386 else
17387 vty_out(vty, " receive");
17388 vty_out(vty, "\n");
17389 }
17390
17391 /* Route reflector client. */
17392 if (peergroup_af_flag_check(peer, afi, safi,
17393 PEER_FLAG_REFLECTOR_CLIENT)) {
17394 vty_out(vty, " neighbor %s route-reflector-client\n", addr);
17395 }
17396
17397 /* next-hop-self force */
17398 if (peergroup_af_flag_check(peer, afi, safi,
17399 PEER_FLAG_FORCE_NEXTHOP_SELF)) {
17400 vty_out(vty, " neighbor %s next-hop-self force\n", addr);
17401 }
17402
17403 /* next-hop-self */
17404 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_NEXTHOP_SELF)) {
17405 vty_out(vty, " neighbor %s next-hop-self\n", addr);
17406 }
17407
17408 /* remove-private-AS */
17409 if (peergroup_af_flag_check(peer, afi, safi,
17410 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE)) {
17411 vty_out(vty, " neighbor %s remove-private-AS all replace-AS\n",
17412 addr);
17413 }
17414
17415 else if (peergroup_af_flag_check(peer, afi, safi,
17416 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE)) {
17417 vty_out(vty, " neighbor %s remove-private-AS replace-AS\n",
17418 addr);
17419 }
17420
17421 else if (peergroup_af_flag_check(peer, afi, safi,
17422 PEER_FLAG_REMOVE_PRIVATE_AS_ALL)) {
17423 vty_out(vty, " neighbor %s remove-private-AS all\n", addr);
17424 }
17425
17426 else if (peergroup_af_flag_check(peer, afi, safi,
17427 PEER_FLAG_REMOVE_PRIVATE_AS)) {
17428 vty_out(vty, " neighbor %s remove-private-AS\n", addr);
17429 }
17430
17431 /* as-override */
17432 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_AS_OVERRIDE)) {
17433 vty_out(vty, " neighbor %s as-override\n", addr);
17434 }
17435
17436 /* send-community print. */
17437 flag_scomm = peergroup_af_flag_check(peer, afi, safi,
17438 PEER_FLAG_SEND_COMMUNITY);
17439 flag_secomm = peergroup_af_flag_check(peer, afi, safi,
17440 PEER_FLAG_SEND_EXT_COMMUNITY);
17441 flag_slcomm = peergroup_af_flag_check(peer, afi, safi,
17442 PEER_FLAG_SEND_LARGE_COMMUNITY);
17443
17444 if (flag_scomm && flag_secomm && flag_slcomm) {
17445 vty_out(vty, " no neighbor %s send-community all\n", addr);
17446 } else {
17447 if (flag_scomm)
17448 vty_out(vty, " no neighbor %s send-community\n", addr);
17449 if (flag_secomm)
17450 vty_out(vty,
17451 " no neighbor %s send-community extended\n",
17452 addr);
17453
17454 if (flag_slcomm)
17455 vty_out(vty, " no neighbor %s send-community large\n",
17456 addr);
17457 }
17458
17459 /* Default information */
17460 if (peergroup_af_flag_check(peer, afi, safi,
17461 PEER_FLAG_DEFAULT_ORIGINATE)) {
17462 vty_out(vty, " neighbor %s default-originate", addr);
17463
17464 if (peer->default_rmap[afi][safi].name)
17465 vty_out(vty, " route-map %s",
17466 peer->default_rmap[afi][safi].name);
17467
17468 vty_out(vty, "\n");
17469 }
17470
17471 /* Soft reconfiguration inbound. */
17472 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_SOFT_RECONFIG)) {
17473 vty_out(vty, " neighbor %s soft-reconfiguration inbound\n",
17474 addr);
17475 }
17476
17477 /* maximum-prefix. */
17478 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_MAX_PREFIX)) {
17479 vty_out(vty, " neighbor %s maximum-prefix %u", addr,
17480 peer->pmax[afi][safi]);
17481
17482 if (peer->pmax_threshold[afi][safi]
17483 != MAXIMUM_PREFIX_THRESHOLD_DEFAULT)
17484 vty_out(vty, " %u", peer->pmax_threshold[afi][safi]);
17485 if (peer_af_flag_check(peer, afi, safi,
17486 PEER_FLAG_MAX_PREFIX_WARNING))
17487 vty_out(vty, " warning-only");
17488 if (peer->pmax_restart[afi][safi])
17489 vty_out(vty, " restart %u",
17490 peer->pmax_restart[afi][safi]);
17491 if (peer_af_flag_check(peer, afi, safi,
17492 PEER_FLAG_MAX_PREFIX_FORCE))
17493 vty_out(vty, " force");
17494
17495 vty_out(vty, "\n");
17496 }
17497
17498 /* maximum-prefix-out */
17499 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_MAX_PREFIX_OUT))
17500 vty_out(vty, " neighbor %s maximum-prefix-out %u\n",
17501 addr, peer->pmax_out[afi][safi]);
17502
17503 /* Route server client. */
17504 if (peergroup_af_flag_check(peer, afi, safi,
17505 PEER_FLAG_RSERVER_CLIENT)) {
17506 vty_out(vty, " neighbor %s route-server-client\n", addr);
17507 }
17508
17509 /* Nexthop-local unchanged. */
17510 if (peergroup_af_flag_check(peer, afi, safi,
17511 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED)) {
17512 vty_out(vty, " neighbor %s nexthop-local unchanged\n", addr);
17513 }
17514
17515 /* allowas-in <1-10> */
17516 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ALLOWAS_IN)) {
17517 if (peer_af_flag_check(peer, afi, safi,
17518 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
17519 vty_out(vty, " neighbor %s allowas-in origin\n", addr);
17520 } else if (peer->allowas_in[afi][safi] == 3) {
17521 vty_out(vty, " neighbor %s allowas-in\n", addr);
17522 } else {
17523 vty_out(vty, " neighbor %s allowas-in %d\n", addr,
17524 peer->allowas_in[afi][safi]);
17525 }
17526 }
17527
17528 /* accept-own */
17529 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ACCEPT_OWN))
17530 vty_out(vty, " neighbor %s accept-own\n", addr);
17531
17532 /* soo */
17533 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_SOO)) {
17534 char *soo_str = ecommunity_ecom2str(
17535 peer->soo[afi][safi], ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
17536
17537 vty_out(vty, " neighbor %s soo %s\n", addr, soo_str);
17538 XFREE(MTYPE_ECOMMUNITY_STR, soo_str);
17539 }
17540
17541 /* weight */
17542 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_WEIGHT))
17543 vty_out(vty, " neighbor %s weight %lu\n", addr,
17544 peer->weight[afi][safi]);
17545
17546 /* Filter. */
17547 bgp_config_write_filter(vty, peer, afi, safi);
17548
17549 /* atribute-unchanged. */
17550 if (peer_af_flag_check(peer, afi, safi, PEER_FLAG_AS_PATH_UNCHANGED)
17551 || (safi != SAFI_EVPN
17552 && peer_af_flag_check(peer, afi, safi,
17553 PEER_FLAG_NEXTHOP_UNCHANGED))
17554 || peer_af_flag_check(peer, afi, safi, PEER_FLAG_MED_UNCHANGED)) {
17555
17556 if (!peer_group_active(peer)
17557 || peergroup_af_flag_check(peer, afi, safi,
17558 PEER_FLAG_AS_PATH_UNCHANGED)
17559 || peergroup_af_flag_check(peer, afi, safi,
17560 PEER_FLAG_NEXTHOP_UNCHANGED)
17561 || peergroup_af_flag_check(peer, afi, safi,
17562 PEER_FLAG_MED_UNCHANGED)) {
17563
17564 vty_out(vty,
17565 " neighbor %s attribute-unchanged%s%s%s\n",
17566 addr,
17567 peer_af_flag_check(peer, afi, safi,
17568 PEER_FLAG_AS_PATH_UNCHANGED)
17569 ? " as-path"
17570 : "",
17571 peer_af_flag_check(peer, afi, safi,
17572 PEER_FLAG_NEXTHOP_UNCHANGED)
17573 ? " next-hop"
17574 : "",
17575 peer_af_flag_check(peer, afi, safi,
17576 PEER_FLAG_MED_UNCHANGED)
17577 ? " med"
17578 : "");
17579 }
17580 }
17581
17582 if (peer_af_flag_check(peer, afi, safi, PEER_FLAG_ORR_GROUP))
17583 vty_out(vty, " neighbor %s optimal-route-reflection %s\n",
17584 addr, peer->orr_group_name[afi][safi]);
17585 }
17586
17587 static void bgp_vpn_config_write(struct vty *vty, struct bgp *bgp, afi_t afi,
17588 safi_t safi)
17589 {
17590 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
17591 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL))
17592 vty_out(vty, " no bgp retain route-target all\n");
17593 }
17594
17595 /* Address family based peer configuration display. */
17596 static void bgp_config_write_family(struct vty *vty, struct bgp *bgp, afi_t afi,
17597 safi_t safi)
17598 {
17599 struct peer *peer;
17600 struct peer_group *group;
17601 struct listnode *node, *nnode;
17602
17603
17604 vty_frame(vty, " !\n address-family ");
17605 if (afi == AFI_IP) {
17606 if (safi == SAFI_UNICAST)
17607 vty_frame(vty, "ipv4 unicast");
17608 else if (safi == SAFI_LABELED_UNICAST)
17609 vty_frame(vty, "ipv4 labeled-unicast");
17610 else if (safi == SAFI_MULTICAST)
17611 vty_frame(vty, "ipv4 multicast");
17612 else if (safi == SAFI_MPLS_VPN)
17613 vty_frame(vty, "ipv4 vpn");
17614 else if (safi == SAFI_ENCAP)
17615 vty_frame(vty, "ipv4 encap");
17616 else if (safi == SAFI_FLOWSPEC)
17617 vty_frame(vty, "ipv4 flowspec");
17618 } else if (afi == AFI_IP6) {
17619 if (safi == SAFI_UNICAST)
17620 vty_frame(vty, "ipv6 unicast");
17621 else if (safi == SAFI_LABELED_UNICAST)
17622 vty_frame(vty, "ipv6 labeled-unicast");
17623 else if (safi == SAFI_MULTICAST)
17624 vty_frame(vty, "ipv6 multicast");
17625 else if (safi == SAFI_MPLS_VPN)
17626 vty_frame(vty, "ipv6 vpn");
17627 else if (safi == SAFI_ENCAP)
17628 vty_frame(vty, "ipv6 encap");
17629 else if (safi == SAFI_FLOWSPEC)
17630 vty_frame(vty, "ipv6 flowspec");
17631 } else if (afi == AFI_L2VPN) {
17632 if (safi == SAFI_EVPN)
17633 vty_frame(vty, "l2vpn evpn");
17634 }
17635 vty_frame(vty, "\n");
17636
17637 bgp_config_write_distance(vty, bgp, afi, safi);
17638
17639 bgp_config_write_network(vty, bgp, afi, safi);
17640
17641 bgp_config_write_redistribute(vty, bgp, afi, safi);
17642
17643 /* BGP flag dampening. */
17644 if (CHECK_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
17645 bgp_config_write_damp(vty, afi, safi);
17646
17647 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group))
17648 bgp_config_write_peer_af(vty, bgp, group->conf, afi, safi);
17649
17650 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
17651 /* Do not display doppelganger peers */
17652 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
17653 bgp_config_write_peer_af(vty, bgp, peer, afi, safi);
17654 }
17655
17656 bgp_config_write_maxpaths(vty, bgp, afi, safi);
17657 bgp_config_write_table_map(vty, bgp, afi, safi);
17658
17659 if (safi == SAFI_EVPN)
17660 bgp_config_write_evpn_info(vty, bgp, afi, safi);
17661
17662 if (safi == SAFI_FLOWSPEC)
17663 bgp_fs_config_write_pbr(vty, bgp, afi, safi);
17664
17665 if (safi == SAFI_MPLS_VPN)
17666 bgp_vpn_config_write(vty, bgp, afi, safi);
17667
17668 if (safi == SAFI_UNICAST) {
17669 bgp_vpn_policy_config_write_afi(vty, bgp, afi);
17670 if (CHECK_FLAG(bgp->af_flags[afi][safi],
17671 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)) {
17672
17673 vty_out(vty, " export vpn\n");
17674 }
17675 if (CHECK_FLAG(bgp->af_flags[afi][safi],
17676 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
17677
17678 vty_out(vty, " import vpn\n");
17679 }
17680 if (CHECK_FLAG(bgp->af_flags[afi][safi],
17681 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
17682 char *name;
17683
17684 for (ALL_LIST_ELEMENTS_RO(
17685 bgp->vpn_policy[afi].import_vrf, node,
17686 name))
17687 vty_out(vty, " import vrf %s\n", name);
17688 }
17689 }
17690
17691 /* Optimal Route Reflection */
17692 bgp_config_write_orr(vty, bgp, afi, safi);
17693
17694 vty_endframe(vty, " exit-address-family\n");
17695 }
17696
17697 int bgp_config_write(struct vty *vty)
17698 {
17699 struct bgp *bgp;
17700 struct peer_group *group;
17701 struct peer *peer;
17702 struct listnode *node, *nnode;
17703 struct listnode *mnode, *mnnode;
17704 afi_t afi;
17705 safi_t safi;
17706 uint32_t tovpn_sid_index = 0;
17707
17708 if (bm->rmap_update_timer != RMAP_DEFAULT_UPDATE_TIMER)
17709 vty_out(vty, "bgp route-map delay-timer %u\n",
17710 bm->rmap_update_timer);
17711
17712 if (bm->v_update_delay != BGP_UPDATE_DELAY_DEF) {
17713 vty_out(vty, "bgp update-delay %d", bm->v_update_delay);
17714 if (bm->v_update_delay != bm->v_establish_wait)
17715 vty_out(vty, " %d", bm->v_establish_wait);
17716 vty_out(vty, "\n");
17717 }
17718
17719 if (bm->wait_for_fib)
17720 vty_out(vty, "bgp suppress-fib-pending\n");
17721
17722 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
17723 vty_out(vty, "bgp graceful-shutdown\n");
17724
17725 /* No-RIB (Zebra) option flag configuration */
17726 if (bgp_option_check(BGP_OPT_NO_FIB))
17727 vty_out(vty, "bgp no-rib\n");
17728
17729 if (CHECK_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA))
17730 vty_out(vty, "bgp send-extra-data zebra\n");
17731
17732 /* BGP session DSCP value */
17733 if (bm->tcp_dscp != IPTOS_PREC_INTERNETCONTROL)
17734 vty_out(vty, "bgp session-dscp %u\n", bm->tcp_dscp >> 2);
17735
17736 /* BGP configuration. */
17737 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp)) {
17738
17739 /* skip all auto created vrf as they dont have user config */
17740 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_AUTO))
17741 continue;
17742
17743 /* Router bgp ASN */
17744 vty_out(vty, "router bgp %u", bgp->as);
17745
17746 if (bgp->name)
17747 vty_out(vty, " %s %s",
17748 (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
17749 ? "view" : "vrf", bgp->name);
17750 vty_out(vty, "\n");
17751
17752 /* BGP fast-external-failover. */
17753 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
17754 vty_out(vty, " no bgp fast-external-failover\n");
17755
17756 /* BGP router ID. */
17757 if (bgp->router_id_static.s_addr != INADDR_ANY)
17758 vty_out(vty, " bgp router-id %pI4\n",
17759 &bgp->router_id_static);
17760
17761 /* Suppress fib pending */
17762 if (CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_FIB_PENDING))
17763 vty_out(vty, " bgp suppress-fib-pending\n");
17764
17765 /* BGP log-neighbor-changes. */
17766 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES)
17767 != SAVE_BGP_LOG_NEIGHBOR_CHANGES)
17768 vty_out(vty, " %sbgp log-neighbor-changes\n",
17769 CHECK_FLAG(bgp->flags,
17770 BGP_FLAG_LOG_NEIGHBOR_CHANGES)
17771 ? ""
17772 : "no ");
17773
17774 /* BGP configuration. */
17775 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED))
17776 vty_out(vty, " bgp always-compare-med\n");
17777
17778 /* RFC8212 default eBGP policy. */
17779 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
17780 != SAVE_BGP_EBGP_REQUIRES_POLICY)
17781 vty_out(vty, " %sbgp ebgp-requires-policy\n",
17782 CHECK_FLAG(bgp->flags,
17783 BGP_FLAG_EBGP_REQUIRES_POLICY)
17784 ? ""
17785 : "no ");
17786
17787 /* draft-ietf-idr-deprecate-as-set-confed-set */
17788 if (bgp->reject_as_sets)
17789 vty_out(vty, " bgp reject-as-sets\n");
17790
17791 /* Suppress duplicate updates if the route actually not changed
17792 */
17793 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES)
17794 != SAVE_BGP_SUPPRESS_DUPLICATES)
17795 vty_out(vty, " %sbgp suppress-duplicates\n",
17796 CHECK_FLAG(bgp->flags,
17797 BGP_FLAG_SUPPRESS_DUPLICATES)
17798 ? ""
17799 : "no ");
17800
17801 /* Send Hard Reset CEASE Notification for 'Administrative Reset'
17802 */
17803 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET) !=
17804 SAVE_BGP_HARD_ADMIN_RESET)
17805 vty_out(vty, " %sbgp hard-administrative-reset\n",
17806 CHECK_FLAG(bgp->flags,
17807 BGP_FLAG_HARD_ADMIN_RESET)
17808 ? ""
17809 : "no ");
17810
17811 /* BGP default <afi>-<safi> */
17812 FOREACH_AFI_SAFI (afi, safi) {
17813 if (afi == AFI_IP && safi == SAFI_UNICAST) {
17814 if (!bgp->default_af[afi][safi])
17815 vty_out(vty, " no bgp default %s\n",
17816 get_bgp_default_af_flag(afi,
17817 safi));
17818 } else if (bgp->default_af[afi][safi])
17819 vty_out(vty, " bgp default %s\n",
17820 get_bgp_default_af_flag(afi, safi));
17821 }
17822
17823 /* BGP default local-preference. */
17824 if (bgp->default_local_pref != BGP_DEFAULT_LOCAL_PREF)
17825 vty_out(vty, " bgp default local-preference %u\n",
17826 bgp->default_local_pref);
17827
17828 /* BGP default show-hostname */
17829 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME)
17830 != SAVE_BGP_SHOW_HOSTNAME)
17831 vty_out(vty, " %sbgp default show-hostname\n",
17832 CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME)
17833 ? ""
17834 : "no ");
17835
17836 /* BGP default show-nexthop-hostname */
17837 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME)
17838 != SAVE_BGP_SHOW_HOSTNAME)
17839 vty_out(vty, " %sbgp default show-nexthop-hostname\n",
17840 CHECK_FLAG(bgp->flags,
17841 BGP_FLAG_SHOW_NEXTHOP_HOSTNAME)
17842 ? ""
17843 : "no ");
17844
17845 /* BGP default subgroup-pkt-queue-max. */
17846 if (bgp->default_subgroup_pkt_queue_max
17847 != BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX)
17848 vty_out(vty, " bgp default subgroup-pkt-queue-max %u\n",
17849 bgp->default_subgroup_pkt_queue_max);
17850
17851 /* BGP client-to-client reflection. */
17852 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT))
17853 vty_out(vty, " no bgp client-to-client reflection\n");
17854
17855 /* BGP cluster ID. */
17856 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CLUSTER_ID))
17857 vty_out(vty, " bgp cluster-id %pI4\n",
17858 &bgp->cluster_id);
17859
17860 /* Disable ebgp connected nexthop check */
17861 if (CHECK_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
17862 vty_out(vty,
17863 " bgp disable-ebgp-connected-route-check\n");
17864
17865 /* Confederation identifier*/
17866 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
17867 vty_out(vty, " bgp confederation identifier %u\n",
17868 bgp->confed_id);
17869
17870 /* Confederation peer */
17871 if (bgp->confed_peers_cnt > 0) {
17872 int i;
17873
17874 vty_out(vty, " bgp confederation peers");
17875
17876 for (i = 0; i < bgp->confed_peers_cnt; i++)
17877 vty_out(vty, " %u", bgp->confed_peers[i]);
17878
17879 vty_out(vty, "\n");
17880 }
17881
17882 /* BGP deterministic-med. */
17883 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)
17884 != SAVE_BGP_DETERMINISTIC_MED)
17885 vty_out(vty, " %sbgp deterministic-med\n",
17886 CHECK_FLAG(bgp->flags,
17887 BGP_FLAG_DETERMINISTIC_MED)
17888 ? ""
17889 : "no ");
17890
17891 /* BGP update-delay. */
17892 bgp_config_write_update_delay(vty, bgp);
17893
17894 if (bgp->v_maxmed_onstartup
17895 != BGP_MAXMED_ONSTARTUP_UNCONFIGURED) {
17896 vty_out(vty, " bgp max-med on-startup %u",
17897 bgp->v_maxmed_onstartup);
17898 if (bgp->maxmed_onstartup_value
17899 != BGP_MAXMED_VALUE_DEFAULT)
17900 vty_out(vty, " %u",
17901 bgp->maxmed_onstartup_value);
17902 vty_out(vty, "\n");
17903 }
17904 if (bgp->v_maxmed_admin != BGP_MAXMED_ADMIN_UNCONFIGURED) {
17905 vty_out(vty, " bgp max-med administrative");
17906 if (bgp->maxmed_admin_value != BGP_MAXMED_VALUE_DEFAULT)
17907 vty_out(vty, " %u", bgp->maxmed_admin_value);
17908 vty_out(vty, "\n");
17909 }
17910
17911 /* write quanta */
17912 bgp_config_write_wpkt_quanta(vty, bgp);
17913 /* read quanta */
17914 bgp_config_write_rpkt_quanta(vty, bgp);
17915
17916 /* coalesce time */
17917 bgp_config_write_coalesce_time(vty, bgp);
17918
17919 /* BGP per-instance graceful-shutdown */
17920 /* BGP-wide settings and per-instance settings are mutually
17921 * exclusive.
17922 */
17923 if (!CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
17924 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN))
17925 vty_out(vty, " bgp graceful-shutdown\n");
17926
17927 /* Long-lived Graceful Restart */
17928 if (bgp->llgr_stale_time != BGP_DEFAULT_LLGR_STALE_TIME)
17929 vty_out(vty,
17930 " bgp long-lived-graceful-restart stale-time %u\n",
17931 bgp->llgr_stale_time);
17932
17933 /* BGP graceful-restart. */
17934 if (bgp->stalepath_time != BGP_DEFAULT_STALEPATH_TIME)
17935 vty_out(vty,
17936 " bgp graceful-restart stalepath-time %u\n",
17937 bgp->stalepath_time);
17938
17939 if (bgp->restart_time != BGP_DEFAULT_RESTART_TIME)
17940 vty_out(vty, " bgp graceful-restart restart-time %u\n",
17941 bgp->restart_time);
17942
17943 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION) !=
17944 SAVE_BGP_GRACEFUL_NOTIFICATION)
17945 vty_out(vty, " %sbgp graceful-restart notification\n",
17946 CHECK_FLAG(bgp->flags,
17947 BGP_FLAG_GRACEFUL_NOTIFICATION)
17948 ? ""
17949 : "no ");
17950
17951 if (bgp->select_defer_time != BGP_DEFAULT_SELECT_DEFERRAL_TIME)
17952 vty_out(vty,
17953 " bgp graceful-restart select-defer-time %u\n",
17954 bgp->select_defer_time);
17955
17956 if (bgp_global_gr_mode_get(bgp) == GLOBAL_GR)
17957 vty_out(vty, " bgp graceful-restart\n");
17958
17959 if (bgp_global_gr_mode_get(bgp) == GLOBAL_DISABLE)
17960 vty_out(vty, " bgp graceful-restart-disable\n");
17961
17962 /* BGP graceful-restart Preserve State F bit. */
17963 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD))
17964 vty_out(vty,
17965 " bgp graceful-restart preserve-fw-state\n");
17966
17967 /* BGP TCP keepalive */
17968 bgp_config_tcp_keepalive(vty, bgp);
17969
17970 /* Stale timer for RIB */
17971 if (bgp->rib_stale_time != BGP_DEFAULT_RIB_STALE_TIME)
17972 vty_out(vty,
17973 " bgp graceful-restart rib-stale-time %u\n",
17974 bgp->rib_stale_time);
17975
17976 /* BGP bestpath method. */
17977 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE))
17978 vty_out(vty, " bgp bestpath as-path ignore\n");
17979 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED))
17980 vty_out(vty, " bgp bestpath as-path confed\n");
17981
17982 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
17983 if (CHECK_FLAG(bgp->flags,
17984 BGP_FLAG_MULTIPATH_RELAX_AS_SET)) {
17985 vty_out(vty,
17986 " bgp bestpath as-path multipath-relax as-set\n");
17987 } else {
17988 vty_out(vty,
17989 " bgp bestpath as-path multipath-relax\n");
17990 }
17991 }
17992
17993 if (CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
17994 vty_out(vty,
17995 " bgp route-reflector allow-outbound-policy\n");
17996 }
17997 if (CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID))
17998 vty_out(vty, " bgp bestpath compare-routerid\n");
17999 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED)
18000 || CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST)) {
18001 vty_out(vty, " bgp bestpath med");
18002 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED))
18003 vty_out(vty, " confed");
18004 if (CHECK_FLAG(bgp->flags,
18005 BGP_FLAG_MED_MISSING_AS_WORST))
18006 vty_out(vty, " missing-as-worst");
18007 vty_out(vty, "\n");
18008 }
18009
18010 if (CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
18011 vty_out(vty,
18012 " bgp bestpath peer-type multipath-relax\n");
18013
18014 /* Link bandwidth handling. */
18015 if (bgp->lb_handling == BGP_LINK_BW_IGNORE_BW)
18016 vty_out(vty, " bgp bestpath bandwidth ignore\n");
18017 else if (bgp->lb_handling == BGP_LINK_BW_SKIP_MISSING)
18018 vty_out(vty, " bgp bestpath bandwidth skip-missing\n");
18019 else if (bgp->lb_handling == BGP_LINK_BW_DEFWT_4_MISSING)
18020 vty_out(vty, " bgp bestpath bandwidth default-weight-for-missing\n");
18021
18022 /* BGP network import check. */
18023 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)
18024 != SAVE_BGP_IMPORT_CHECK)
18025 vty_out(vty, " %sbgp network import-check\n",
18026 CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)
18027 ? ""
18028 : "no ");
18029
18030 /* BGP timers configuration. */
18031 if (bgp->default_keepalive != SAVE_BGP_KEEPALIVE
18032 || bgp->default_holdtime != SAVE_BGP_HOLDTIME)
18033 vty_out(vty, " timers bgp %u %u\n",
18034 bgp->default_keepalive, bgp->default_holdtime);
18035
18036 /* BGP minimum holdtime configuration. */
18037 if (bgp->default_min_holdtime != SAVE_BGP_HOLDTIME
18038 && bgp->default_min_holdtime != 0)
18039 vty_out(vty, " bgp minimum-holdtime %u\n",
18040 bgp->default_min_holdtime);
18041
18042 /* Conditional advertisement timer configuration */
18043 if (bgp->condition_check_period
18044 != DEFAULT_CONDITIONAL_ROUTES_POLL_TIME)
18045 vty_out(vty,
18046 " bgp conditional-advertisement timer %u\n",
18047 bgp->condition_check_period);
18048
18049 /* peer-group */
18050 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
18051 bgp_config_write_peer_global(vty, bgp, group->conf);
18052 }
18053
18054 /* Normal neighbor configuration. */
18055 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
18056 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
18057 bgp_config_write_peer_global(vty, bgp, peer);
18058 }
18059
18060 /* listen range and limit for dynamic BGP neighbors */
18061 bgp_config_write_listen(vty, bgp);
18062
18063 /*
18064 * BGP default autoshutdown neighbors
18065 *
18066 * This must be placed after any peer and peer-group
18067 * configuration, to avoid setting all peers to shutdown after
18068 * a daemon restart, which is undesired behavior. (see #2286)
18069 */
18070 if (bgp->autoshutdown)
18071 vty_out(vty, " bgp default shutdown\n");
18072
18073 /* BGP instance administrative shutdown */
18074 if (CHECK_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN))
18075 vty_out(vty, " bgp shutdown\n");
18076
18077 if (bgp->allow_martian)
18078 vty_out(vty, " bgp allow-martian-nexthop\n");
18079
18080 if (bgp->fast_convergence)
18081 vty_out(vty, " bgp fast-convergence\n");
18082
18083 if (bgp->srv6_enabled) {
18084 vty_frame(vty, " !\n segment-routing srv6\n");
18085 if (strlen(bgp->srv6_locator_name))
18086 vty_out(vty, " locator %s\n",
18087 bgp->srv6_locator_name);
18088 vty_endframe(vty, " exit\n");
18089 }
18090
18091 tovpn_sid_index = bgp->tovpn_sid_index;
18092 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)) {
18093 vty_out(vty, " sid vpn per-vrf export auto\n");
18094 } else if (tovpn_sid_index != 0) {
18095 vty_out(vty, " sid vpn per-vrf export %d\n",
18096 tovpn_sid_index);
18097 }
18098
18099 /* IPv4 unicast configuration. */
18100 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_UNICAST);
18101
18102 /* IPv4 multicast configuration. */
18103 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_MULTICAST);
18104
18105 /* IPv4 labeled-unicast configuration. */
18106 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_LABELED_UNICAST);
18107
18108 /* IPv4 VPN configuration. */
18109 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_MPLS_VPN);
18110
18111 /* ENCAPv4 configuration. */
18112 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_ENCAP);
18113
18114 /* FLOWSPEC v4 configuration. */
18115 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_FLOWSPEC);
18116
18117 /* IPv6 unicast configuration. */
18118 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_UNICAST);
18119
18120 /* IPv6 multicast configuration. */
18121 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_MULTICAST);
18122
18123 /* IPv6 labeled-unicast configuration. */
18124 bgp_config_write_family(vty, bgp, AFI_IP6,
18125 SAFI_LABELED_UNICAST);
18126
18127 /* IPv6 VPN configuration. */
18128 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_MPLS_VPN);
18129
18130 /* ENCAPv6 configuration. */
18131 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_ENCAP);
18132
18133 /* FLOWSPEC v6 configuration. */
18134 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_FLOWSPEC);
18135
18136 /* EVPN configuration. */
18137 bgp_config_write_family(vty, bgp, AFI_L2VPN, SAFI_EVPN);
18138
18139 hook_call(bgp_inst_config_write, bgp, vty);
18140
18141 #ifdef ENABLE_BGP_VNC
18142 bgp_rfapi_cfg_write(vty, bgp);
18143 #endif
18144
18145 vty_out(vty, "exit\n");
18146 vty_out(vty, "!\n");
18147 }
18148 return 0;
18149 }
18150
18151
18152 /* BGP node structure. */
18153 static struct cmd_node bgp_node = {
18154 .name = "bgp",
18155 .node = BGP_NODE,
18156 .parent_node = CONFIG_NODE,
18157 .prompt = "%s(config-router)# ",
18158 .config_write = bgp_config_write,
18159 };
18160
18161 static struct cmd_node bgp_ipv4_unicast_node = {
18162 .name = "bgp ipv4 unicast",
18163 .node = BGP_IPV4_NODE,
18164 .parent_node = BGP_NODE,
18165 .prompt = "%s(config-router-af)# ",
18166 .no_xpath = true,
18167 };
18168
18169 static struct cmd_node bgp_ipv4_multicast_node = {
18170 .name = "bgp ipv4 multicast",
18171 .node = BGP_IPV4M_NODE,
18172 .parent_node = BGP_NODE,
18173 .prompt = "%s(config-router-af)# ",
18174 .no_xpath = true,
18175 };
18176
18177 static struct cmd_node bgp_ipv4_labeled_unicast_node = {
18178 .name = "bgp ipv4 labeled unicast",
18179 .node = BGP_IPV4L_NODE,
18180 .parent_node = BGP_NODE,
18181 .prompt = "%s(config-router-af)# ",
18182 .no_xpath = true,
18183 };
18184
18185 static struct cmd_node bgp_ipv6_unicast_node = {
18186 .name = "bgp ipv6 unicast",
18187 .node = BGP_IPV6_NODE,
18188 .parent_node = BGP_NODE,
18189 .prompt = "%s(config-router-af)# ",
18190 .no_xpath = true,
18191 };
18192
18193 static struct cmd_node bgp_ipv6_multicast_node = {
18194 .name = "bgp ipv6 multicast",
18195 .node = BGP_IPV6M_NODE,
18196 .parent_node = BGP_NODE,
18197 .prompt = "%s(config-router-af)# ",
18198 .no_xpath = true,
18199 };
18200
18201 static struct cmd_node bgp_ipv6_labeled_unicast_node = {
18202 .name = "bgp ipv6 labeled unicast",
18203 .node = BGP_IPV6L_NODE,
18204 .parent_node = BGP_NODE,
18205 .prompt = "%s(config-router-af)# ",
18206 .no_xpath = true,
18207 };
18208
18209 static struct cmd_node bgp_vpnv4_node = {
18210 .name = "bgp vpnv4",
18211 .node = BGP_VPNV4_NODE,
18212 .parent_node = BGP_NODE,
18213 .prompt = "%s(config-router-af)# ",
18214 .no_xpath = true,
18215 };
18216
18217 static struct cmd_node bgp_vpnv6_node = {
18218 .name = "bgp vpnv6",
18219 .node = BGP_VPNV6_NODE,
18220 .parent_node = BGP_NODE,
18221 .prompt = "%s(config-router-af-vpnv6)# ",
18222 .no_xpath = true,
18223 };
18224
18225 static struct cmd_node bgp_evpn_node = {
18226 .name = "bgp evpn",
18227 .node = BGP_EVPN_NODE,
18228 .parent_node = BGP_NODE,
18229 .prompt = "%s(config-router-evpn)# ",
18230 .no_xpath = true,
18231 };
18232
18233 static struct cmd_node bgp_evpn_vni_node = {
18234 .name = "bgp evpn vni",
18235 .node = BGP_EVPN_VNI_NODE,
18236 .parent_node = BGP_EVPN_NODE,
18237 .prompt = "%s(config-router-af-vni)# ",
18238 };
18239
18240 static struct cmd_node bgp_flowspecv4_node = {
18241 .name = "bgp ipv4 flowspec",
18242 .node = BGP_FLOWSPECV4_NODE,
18243 .parent_node = BGP_NODE,
18244 .prompt = "%s(config-router-af)# ",
18245 .no_xpath = true,
18246 };
18247
18248 static struct cmd_node bgp_flowspecv6_node = {
18249 .name = "bgp ipv6 flowspec",
18250 .node = BGP_FLOWSPECV6_NODE,
18251 .parent_node = BGP_NODE,
18252 .prompt = "%s(config-router-af-vpnv6)# ",
18253 .no_xpath = true,
18254 };
18255
18256 static struct cmd_node bgp_srv6_node = {
18257 .name = "bgp srv6",
18258 .node = BGP_SRV6_NODE,
18259 .parent_node = BGP_NODE,
18260 .prompt = "%s(config-router-srv6)# ",
18261 };
18262
18263 static void community_list_vty(void);
18264
18265 static void bgp_ac_peergroup(vector comps, struct cmd_token *token)
18266 {
18267 struct bgp *bgp;
18268 struct peer_group *group;
18269 struct listnode *lnbgp, *lnpeer;
18270
18271 for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
18272 for (ALL_LIST_ELEMENTS_RO(bgp->group, lnpeer, group))
18273 vector_set(comps,
18274 XSTRDUP(MTYPE_COMPLETION, group->name));
18275 }
18276 }
18277
18278 static void bgp_ac_peer(vector comps, struct cmd_token *token)
18279 {
18280 struct bgp *bgp;
18281 struct peer *peer;
18282 struct listnode *lnbgp, *lnpeer;
18283
18284 for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
18285 for (ALL_LIST_ELEMENTS_RO(bgp->peer, lnpeer, peer)) {
18286 /* only provide suggestions on the appropriate input
18287 * token type,
18288 * they'll otherwise show up multiple times */
18289 enum cmd_token_type match_type;
18290 char *name = peer->host;
18291
18292 if (peer->conf_if) {
18293 match_type = VARIABLE_TKN;
18294 name = peer->conf_if;
18295 } else if (strchr(peer->host, ':'))
18296 match_type = IPV6_TKN;
18297 else
18298 match_type = IPV4_TKN;
18299
18300 if (token->type != match_type)
18301 continue;
18302
18303 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, name));
18304 }
18305 }
18306 }
18307
18308 static void bgp_ac_neighbor(vector comps, struct cmd_token *token)
18309 {
18310 bgp_ac_peer(comps, token);
18311
18312 if (token->type == VARIABLE_TKN)
18313 bgp_ac_peergroup(comps, token);
18314 }
18315
18316 static const struct cmd_variable_handler bgp_var_neighbor[] = {
18317 {.varname = "neighbor", .completions = bgp_ac_neighbor},
18318 {.varname = "neighbors", .completions = bgp_ac_neighbor},
18319 {.varname = "peer", .completions = bgp_ac_neighbor},
18320 {.completions = NULL}};
18321
18322 static const struct cmd_variable_handler bgp_var_peergroup[] = {
18323 {.tokenname = "PGNAME", .completions = bgp_ac_peergroup},
18324 {.completions = NULL} };
18325
18326 DEFINE_HOOK(bgp_config_end, (struct bgp *bgp), (bgp));
18327
18328 static struct thread *t_bgp_cfg;
18329
18330 bool bgp_config_inprocess(void)
18331 {
18332 return thread_is_scheduled(t_bgp_cfg);
18333 }
18334
18335 static void bgp_config_finish(struct thread *t)
18336 {
18337 struct listnode *node;
18338 struct bgp *bgp;
18339
18340 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp))
18341 hook_call(bgp_config_end, bgp);
18342 }
18343
18344 static void bgp_config_start(void)
18345 {
18346 #define BGP_PRE_CONFIG_MAX_WAIT_SECONDS 600
18347 THREAD_OFF(t_bgp_cfg);
18348 thread_add_timer(bm->master, bgp_config_finish, NULL,
18349 BGP_PRE_CONFIG_MAX_WAIT_SECONDS, &t_bgp_cfg);
18350 }
18351
18352 /* When we receive a hook the configuration is read,
18353 * we start a timer to make sure we postpone sending
18354 * EoR before route-maps are processed.
18355 * This is especially valid if using `bgp route-map delay-timer`.
18356 */
18357 static void bgp_config_end(void)
18358 {
18359 #define BGP_POST_CONFIG_DELAY_SECONDS 1
18360 uint32_t bgp_post_config_delay =
18361 thread_is_scheduled(bm->t_rmap_update)
18362 ? thread_timer_remain_second(bm->t_rmap_update)
18363 : BGP_POST_CONFIG_DELAY_SECONDS;
18364
18365 /* If BGP config processing thread isn't running, then
18366 * we can return and rely it's properly handled.
18367 */
18368 if (!bgp_config_inprocess())
18369 return;
18370
18371 THREAD_OFF(t_bgp_cfg);
18372
18373 /* Start a new timer to make sure we don't send EoR
18374 * before route-maps are processed.
18375 */
18376 thread_add_timer(bm->master, bgp_config_finish, NULL,
18377 bgp_post_config_delay, &t_bgp_cfg);
18378 }
18379
18380 static int config_write_interface_one(struct vty *vty, struct vrf *vrf)
18381 {
18382 int write = 0;
18383 struct interface *ifp;
18384 struct bgp_interface *iifp;
18385
18386 FOR_ALL_INTERFACES (vrf, ifp) {
18387 iifp = ifp->info;
18388 if (!iifp)
18389 continue;
18390
18391 if_vty_config_start(vty, ifp);
18392
18393 if (CHECK_FLAG(iifp->flags,
18394 BGP_INTERFACE_MPLS_BGP_FORWARDING)) {
18395 vty_out(vty, " mpls bgp forwarding\n");
18396 write++;
18397 }
18398
18399 if_vty_config_end(vty);
18400 }
18401
18402 return write;
18403 }
18404
18405 /* Configuration write function for bgpd. */
18406 static int config_write_interface(struct vty *vty)
18407 {
18408 int write = 0;
18409 struct vrf *vrf = NULL;
18410
18411 /* Display all VRF aware OSPF interface configuration */
18412 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
18413 write += config_write_interface_one(vty, vrf);
18414 }
18415
18416 return write;
18417 }
18418
18419 DEFPY(mpls_bgp_forwarding, mpls_bgp_forwarding_cmd,
18420 "[no$no] mpls bgp forwarding",
18421 NO_STR MPLS_STR BGP_STR
18422 "Enable MPLS forwarding for eBGP directly connected peers\n")
18423 {
18424 bool check;
18425 struct bgp_interface *iifp;
18426
18427 VTY_DECLVAR_CONTEXT(interface, ifp);
18428 iifp = ifp->info;
18429 if (!iifp) {
18430 vty_out(vty, "Interface %s not available\n", ifp->name);
18431 return CMD_WARNING_CONFIG_FAILED;
18432 }
18433 check = CHECK_FLAG(iifp->flags, BGP_INTERFACE_MPLS_BGP_FORWARDING);
18434 if (check != !no) {
18435 if (no)
18436 UNSET_FLAG(iifp->flags,
18437 BGP_INTERFACE_MPLS_BGP_FORWARDING);
18438 else
18439 SET_FLAG(iifp->flags,
18440 BGP_INTERFACE_MPLS_BGP_FORWARDING);
18441 /* trigger a nht update on eBGP sessions */
18442 if (if_is_operative(ifp))
18443 bgp_nht_ifp_up(ifp);
18444 }
18445 return CMD_SUCCESS;
18446 }
18447
18448 /* Initialization of BGP interface. */
18449 static void bgp_vty_if_init(void)
18450 {
18451 /* Install interface node. */
18452 if_cmd_init(config_write_interface);
18453
18454 /* "mpls bgp forwarding" commands. */
18455 install_element(INTERFACE_NODE, &mpls_bgp_forwarding_cmd);
18456 }
18457
18458 void bgp_vty_init(void)
18459 {
18460 cmd_variable_handler_register(bgp_var_neighbor);
18461 cmd_variable_handler_register(bgp_var_peergroup);
18462
18463 cmd_init_config_callbacks(bgp_config_start, bgp_config_end);
18464
18465 /* Install bgp top node. */
18466 install_node(&bgp_node);
18467 install_node(&bgp_ipv4_unicast_node);
18468 install_node(&bgp_ipv4_multicast_node);
18469 install_node(&bgp_ipv4_labeled_unicast_node);
18470 install_node(&bgp_ipv6_unicast_node);
18471 install_node(&bgp_ipv6_multicast_node);
18472 install_node(&bgp_ipv6_labeled_unicast_node);
18473 install_node(&bgp_vpnv4_node);
18474 install_node(&bgp_vpnv6_node);
18475 install_node(&bgp_evpn_node);
18476 install_node(&bgp_evpn_vni_node);
18477 install_node(&bgp_flowspecv4_node);
18478 install_node(&bgp_flowspecv6_node);
18479 install_node(&bgp_srv6_node);
18480
18481 /* Install default VTY commands to new nodes. */
18482 install_default(BGP_NODE);
18483 install_default(BGP_IPV4_NODE);
18484 install_default(BGP_IPV4M_NODE);
18485 install_default(BGP_IPV4L_NODE);
18486 install_default(BGP_IPV6_NODE);
18487 install_default(BGP_IPV6M_NODE);
18488 install_default(BGP_IPV6L_NODE);
18489 install_default(BGP_VPNV4_NODE);
18490 install_default(BGP_VPNV6_NODE);
18491 install_default(BGP_FLOWSPECV4_NODE);
18492 install_default(BGP_FLOWSPECV6_NODE);
18493 install_default(BGP_EVPN_NODE);
18494 install_default(BGP_EVPN_VNI_NODE);
18495 install_default(BGP_SRV6_NODE);
18496
18497 /* "bgp local-mac" hidden commands. */
18498 install_element(CONFIG_NODE, &bgp_local_mac_cmd);
18499 install_element(CONFIG_NODE, &no_bgp_local_mac_cmd);
18500
18501 /* "bgp suppress-fib-pending" global */
18502 install_element(CONFIG_NODE, &bgp_global_suppress_fib_pending_cmd);
18503
18504 /* bgp route-map delay-timer commands. */
18505 install_element(CONFIG_NODE, &bgp_set_route_map_delay_timer_cmd);
18506 install_element(CONFIG_NODE, &no_bgp_set_route_map_delay_timer_cmd);
18507
18508 install_element(BGP_NODE, &bgp_allow_martian_cmd);
18509
18510 /* bgp fast-convergence command */
18511 install_element(BGP_NODE, &bgp_fast_convergence_cmd);
18512 install_element(BGP_NODE, &no_bgp_fast_convergence_cmd);
18513
18514 /* global bgp update-delay command */
18515 install_element(CONFIG_NODE, &bgp_global_update_delay_cmd);
18516 install_element(CONFIG_NODE, &no_bgp_global_update_delay_cmd);
18517
18518 /* global bgp graceful-shutdown command */
18519 install_element(CONFIG_NODE, &bgp_graceful_shutdown_cmd);
18520 install_element(CONFIG_NODE, &no_bgp_graceful_shutdown_cmd);
18521
18522 /* Dummy commands (Currently not supported) */
18523 install_element(BGP_NODE, &no_synchronization_cmd);
18524 install_element(BGP_NODE, &no_auto_summary_cmd);
18525
18526 /* "router bgp" commands. */
18527 install_element(CONFIG_NODE, &router_bgp_cmd);
18528
18529 /* "no router bgp" commands. */
18530 install_element(CONFIG_NODE, &no_router_bgp_cmd);
18531
18532 /* "bgp session-dscp command */
18533 install_element(CONFIG_NODE, &bgp_session_dscp_cmd);
18534 install_element(CONFIG_NODE, &no_bgp_session_dscp_cmd);
18535
18536 /* "bgp router-id" commands. */
18537 install_element(BGP_NODE, &bgp_router_id_cmd);
18538 install_element(BGP_NODE, &no_bgp_router_id_cmd);
18539
18540 /* "bgp suppress-fib-pending" command */
18541 install_element(BGP_NODE, &bgp_suppress_fib_pending_cmd);
18542
18543 /* "bgp cluster-id" commands. */
18544 install_element(BGP_NODE, &bgp_cluster_id_cmd);
18545 install_element(BGP_NODE, &no_bgp_cluster_id_cmd);
18546
18547 /* "bgp no-rib" commands. */
18548 install_element(CONFIG_NODE, &bgp_norib_cmd);
18549 install_element(CONFIG_NODE, &no_bgp_norib_cmd);
18550
18551 install_element(CONFIG_NODE, &no_bgp_send_extra_data_cmd);
18552
18553 /* "bgp confederation" commands. */
18554 install_element(BGP_NODE, &bgp_confederation_identifier_cmd);
18555 install_element(BGP_NODE, &no_bgp_confederation_identifier_cmd);
18556
18557 /* "bgp confederation peers" commands. */
18558 install_element(BGP_NODE, &bgp_confederation_peers_cmd);
18559 install_element(BGP_NODE, &no_bgp_confederation_peers_cmd);
18560
18561 /* bgp max-med command */
18562 install_element(BGP_NODE, &bgp_maxmed_admin_cmd);
18563 install_element(BGP_NODE, &no_bgp_maxmed_admin_cmd);
18564 install_element(BGP_NODE, &bgp_maxmed_admin_medv_cmd);
18565 install_element(BGP_NODE, &bgp_maxmed_onstartup_cmd);
18566 install_element(BGP_NODE, &no_bgp_maxmed_onstartup_cmd);
18567
18568 /* "neighbor role" commands. */
18569 install_element(BGP_NODE, &neighbor_role_cmd);
18570 install_element(BGP_NODE, &neighbor_role_strict_cmd);
18571 install_element(BGP_NODE, &no_neighbor_role_cmd);
18572
18573 /* bgp disable-ebgp-connected-nh-check */
18574 install_element(BGP_NODE, &bgp_disable_connected_route_check_cmd);
18575 install_element(BGP_NODE, &no_bgp_disable_connected_route_check_cmd);
18576
18577 /* bgp update-delay command */
18578 install_element(BGP_NODE, &bgp_update_delay_cmd);
18579 install_element(BGP_NODE, &no_bgp_update_delay_cmd);
18580
18581 install_element(BGP_NODE, &bgp_wpkt_quanta_cmd);
18582 install_element(BGP_NODE, &bgp_rpkt_quanta_cmd);
18583
18584 install_element(BGP_NODE, &bgp_coalesce_time_cmd);
18585 install_element(BGP_NODE, &no_bgp_coalesce_time_cmd);
18586
18587 /* "maximum-paths" commands. */
18588 install_element(BGP_NODE, &bgp_maxpaths_hidden_cmd);
18589 install_element(BGP_NODE, &no_bgp_maxpaths_hidden_cmd);
18590 install_element(BGP_IPV4_NODE, &bgp_maxpaths_cmd);
18591 install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_cmd);
18592 install_element(BGP_IPV6_NODE, &bgp_maxpaths_cmd);
18593 install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_cmd);
18594 install_element(BGP_NODE, &bgp_maxpaths_ibgp_hidden_cmd);
18595 install_element(BGP_NODE, &bgp_maxpaths_ibgp_cluster_hidden_cmd);
18596 install_element(BGP_NODE, &no_bgp_maxpaths_ibgp_hidden_cmd);
18597 install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cmd);
18598 install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
18599 install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_ibgp_cmd);
18600 install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cmd);
18601 install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
18602 install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_ibgp_cmd);
18603
18604 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_cmd);
18605 install_element(BGP_IPV4L_NODE, &no_bgp_maxpaths_cmd);
18606 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_ibgp_cmd);
18607 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
18608 install_element(BGP_IPV4L_NODE, &no_bgp_maxpaths_ibgp_cmd);
18609 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_cmd);
18610 install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_cmd);
18611 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cmd);
18612 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
18613 install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_ibgp_cmd);
18614
18615 /* "timers bgp" commands. */
18616 install_element(BGP_NODE, &bgp_timers_cmd);
18617 install_element(BGP_NODE, &no_bgp_timers_cmd);
18618
18619 /* "minimum-holdtime" commands. */
18620 install_element(BGP_NODE, &bgp_minimum_holdtime_cmd);
18621 install_element(BGP_NODE, &no_bgp_minimum_holdtime_cmd);
18622
18623 /* route-map delay-timer commands - per instance for backwards compat.
18624 */
18625 install_element(BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
18626 install_element(BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
18627
18628 /* "bgp client-to-client reflection" commands */
18629 install_element(BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
18630 install_element(BGP_NODE, &bgp_client_to_client_reflection_cmd);
18631
18632 /* "bgp always-compare-med" commands */
18633 install_element(BGP_NODE, &bgp_always_compare_med_cmd);
18634 install_element(BGP_NODE, &no_bgp_always_compare_med_cmd);
18635
18636 /* bgp ebgp-requires-policy */
18637 install_element(BGP_NODE, &bgp_ebgp_requires_policy_cmd);
18638 install_element(BGP_NODE, &no_bgp_ebgp_requires_policy_cmd);
18639
18640 /* bgp suppress-duplicates */
18641 install_element(BGP_NODE, &bgp_suppress_duplicates_cmd);
18642 install_element(BGP_NODE, &no_bgp_suppress_duplicates_cmd);
18643
18644 /* bgp reject-as-sets */
18645 install_element(BGP_NODE, &bgp_reject_as_sets_cmd);
18646 install_element(BGP_NODE, &no_bgp_reject_as_sets_cmd);
18647
18648 /* "bgp deterministic-med" commands */
18649 install_element(BGP_NODE, &bgp_deterministic_med_cmd);
18650 install_element(BGP_NODE, &no_bgp_deterministic_med_cmd);
18651
18652 /* "bgp graceful-restart" command */
18653 install_element(BGP_NODE, &bgp_graceful_restart_cmd);
18654 install_element(BGP_NODE, &no_bgp_graceful_restart_cmd);
18655
18656 /* "bgp graceful-restart-disable" command */
18657 install_element(BGP_NODE, &bgp_graceful_restart_disable_cmd);
18658 install_element(BGP_NODE, &no_bgp_graceful_restart_disable_cmd);
18659
18660 /* "neighbor a:b:c:d graceful-restart" command */
18661 install_element(BGP_NODE, &bgp_neighbor_graceful_restart_set_cmd);
18662 install_element(BGP_NODE, &no_bgp_neighbor_graceful_restart_set_cmd);
18663
18664 /* "neighbor a:b:c:d graceful-restart-disable" command */
18665 install_element(BGP_NODE,
18666 &bgp_neighbor_graceful_restart_disable_set_cmd);
18667 install_element(BGP_NODE,
18668 &no_bgp_neighbor_graceful_restart_disable_set_cmd);
18669
18670 /* "neighbor a:b:c:d graceful-restart-helper" command */
18671 install_element(BGP_NODE,
18672 &bgp_neighbor_graceful_restart_helper_set_cmd);
18673 install_element(BGP_NODE,
18674 &no_bgp_neighbor_graceful_restart_helper_set_cmd);
18675
18676 install_element(BGP_NODE, &bgp_graceful_restart_stalepath_time_cmd);
18677 install_element(BGP_NODE, &no_bgp_graceful_restart_stalepath_time_cmd);
18678 install_element(BGP_NODE, &bgp_graceful_restart_restart_time_cmd);
18679 install_element(BGP_NODE, &no_bgp_graceful_restart_restart_time_cmd);
18680 install_element(BGP_NODE, &bgp_graceful_restart_select_defer_time_cmd);
18681 install_element(BGP_NODE,
18682 &no_bgp_graceful_restart_select_defer_time_cmd);
18683 install_element(BGP_NODE, &bgp_graceful_restart_preserve_fw_cmd);
18684 install_element(BGP_NODE, &no_bgp_graceful_restart_preserve_fw_cmd);
18685 install_element(BGP_NODE, &bgp_graceful_restart_notification_cmd);
18686
18687 install_element(BGP_NODE, &bgp_graceful_restart_disable_eor_cmd);
18688 install_element(BGP_NODE, &no_bgp_graceful_restart_disable_eor_cmd);
18689 install_element(BGP_NODE, &bgp_graceful_restart_rib_stale_time_cmd);
18690 install_element(BGP_NODE, &no_bgp_graceful_restart_rib_stale_time_cmd);
18691
18692 /* "bgp graceful-shutdown" commands */
18693 install_element(BGP_NODE, &bgp_graceful_shutdown_cmd);
18694 install_element(BGP_NODE, &no_bgp_graceful_shutdown_cmd);
18695
18696 /* "bgp hard-administrative-reset" commands */
18697 install_element(BGP_NODE, &bgp_administrative_reset_cmd);
18698
18699 /* "bgp long-lived-graceful-restart" commands */
18700 install_element(BGP_NODE, &bgp_llgr_stalepath_time_cmd);
18701 install_element(BGP_NODE, &no_bgp_llgr_stalepath_time_cmd);
18702
18703 /* "bgp fast-external-failover" commands */
18704 install_element(BGP_NODE, &bgp_fast_external_failover_cmd);
18705 install_element(BGP_NODE, &no_bgp_fast_external_failover_cmd);
18706
18707 /* "bgp bestpath compare-routerid" commands */
18708 install_element(BGP_NODE, &bgp_bestpath_compare_router_id_cmd);
18709 install_element(BGP_NODE, &no_bgp_bestpath_compare_router_id_cmd);
18710
18711 /* "bgp bestpath as-path ignore" commands */
18712 install_element(BGP_NODE, &bgp_bestpath_aspath_ignore_cmd);
18713 install_element(BGP_NODE, &no_bgp_bestpath_aspath_ignore_cmd);
18714
18715 /* "bgp bestpath as-path confed" commands */
18716 install_element(BGP_NODE, &bgp_bestpath_aspath_confed_cmd);
18717 install_element(BGP_NODE, &no_bgp_bestpath_aspath_confed_cmd);
18718
18719 /* "bgp bestpath as-path multipath-relax" commands */
18720 install_element(BGP_NODE, &bgp_bestpath_aspath_multipath_relax_cmd);
18721 install_element(BGP_NODE, &no_bgp_bestpath_aspath_multipath_relax_cmd);
18722
18723 /* "bgp bestpath peer-type multipath-relax" commands */
18724 install_element(BGP_NODE, &bgp_bestpath_peer_type_multipath_relax_cmd);
18725 install_element(BGP_NODE,
18726 &no_bgp_bestpath_peer_type_multipath_relax_cmd);
18727
18728 /* "bgp log-neighbor-changes" commands */
18729 install_element(BGP_NODE, &bgp_log_neighbor_changes_cmd);
18730 install_element(BGP_NODE, &no_bgp_log_neighbor_changes_cmd);
18731
18732 /* "bgp bestpath med" commands */
18733 install_element(BGP_NODE, &bgp_bestpath_med_cmd);
18734 install_element(BGP_NODE, &no_bgp_bestpath_med_cmd);
18735
18736 /* "bgp bestpath bandwidth" commands */
18737 install_element(BGP_NODE, &bgp_bestpath_bw_cmd);
18738 install_element(BGP_NODE, &no_bgp_bestpath_bw_cmd);
18739
18740 /* "no bgp default <afi>-<safi>" commands. */
18741 install_element(BGP_NODE, &bgp_default_afi_safi_cmd);
18742
18743 /* "bgp network import-check" commands. */
18744 install_element(BGP_NODE, &bgp_network_import_check_cmd);
18745 install_element(BGP_NODE, &bgp_network_import_check_exact_cmd);
18746 install_element(BGP_NODE, &no_bgp_network_import_check_cmd);
18747
18748 /* "bgp default local-preference" commands. */
18749 install_element(BGP_NODE, &bgp_default_local_preference_cmd);
18750 install_element(BGP_NODE, &no_bgp_default_local_preference_cmd);
18751
18752 /* bgp default show-hostname */
18753 install_element(BGP_NODE, &bgp_default_show_hostname_cmd);
18754 install_element(BGP_NODE, &no_bgp_default_show_hostname_cmd);
18755
18756 /* bgp default show-nexthop-hostname */
18757 install_element(BGP_NODE, &bgp_default_show_nexthop_hostname_cmd);
18758 install_element(BGP_NODE, &no_bgp_default_show_nexthop_hostname_cmd);
18759
18760 /* "bgp default subgroup-pkt-queue-max" commands. */
18761 install_element(BGP_NODE, &bgp_default_subgroup_pkt_queue_max_cmd);
18762 install_element(BGP_NODE, &no_bgp_default_subgroup_pkt_queue_max_cmd);
18763
18764 /* bgp ibgp-allow-policy-mods command */
18765 install_element(BGP_NODE, &bgp_rr_allow_outbound_policy_cmd);
18766 install_element(BGP_NODE, &no_bgp_rr_allow_outbound_policy_cmd);
18767
18768 /* "bgp listen limit" commands. */
18769 install_element(BGP_NODE, &bgp_listen_limit_cmd);
18770 install_element(BGP_NODE, &no_bgp_listen_limit_cmd);
18771
18772 /* "bgp listen range" commands. */
18773 install_element(BGP_NODE, &bgp_listen_range_cmd);
18774 install_element(BGP_NODE, &no_bgp_listen_range_cmd);
18775
18776 /* "bgp default shutdown" command */
18777 install_element(BGP_NODE, &bgp_default_shutdown_cmd);
18778
18779 /* "bgp shutdown" commands */
18780 install_element(BGP_NODE, &bgp_shutdown_cmd);
18781 install_element(BGP_NODE, &bgp_shutdown_msg_cmd);
18782 install_element(BGP_NODE, &no_bgp_shutdown_cmd);
18783 install_element(BGP_NODE, &no_bgp_shutdown_msg_cmd);
18784
18785 /* "neighbor remote-as" commands. */
18786 install_element(BGP_NODE, &neighbor_remote_as_cmd);
18787 install_element(BGP_NODE, &neighbor_interface_config_cmd);
18788 install_element(BGP_NODE, &neighbor_interface_config_v6only_cmd);
18789 install_element(BGP_NODE, &neighbor_interface_config_remote_as_cmd);
18790 install_element(BGP_NODE,
18791 &neighbor_interface_v6only_config_remote_as_cmd);
18792 install_element(BGP_NODE, &no_neighbor_cmd);
18793 install_element(BGP_NODE, &no_neighbor_interface_config_cmd);
18794
18795 /* "neighbor peer-group" commands. */
18796 install_element(BGP_NODE, &neighbor_peer_group_cmd);
18797 install_element(BGP_NODE, &no_neighbor_peer_group_cmd);
18798 install_element(BGP_NODE,
18799 &no_neighbor_interface_peer_group_remote_as_cmd);
18800
18801 /* "neighbor local-as" commands. */
18802 install_element(BGP_NODE, &neighbor_local_as_cmd);
18803 install_element(BGP_NODE, &neighbor_local_as_no_prepend_cmd);
18804 install_element(BGP_NODE, &neighbor_local_as_no_prepend_replace_as_cmd);
18805 install_element(BGP_NODE, &no_neighbor_local_as_cmd);
18806
18807 /* "neighbor solo" commands. */
18808 install_element(BGP_NODE, &neighbor_solo_cmd);
18809 install_element(BGP_NODE, &no_neighbor_solo_cmd);
18810
18811 /* "neighbor password" commands. */
18812 install_element(BGP_NODE, &neighbor_password_cmd);
18813 install_element(BGP_NODE, &no_neighbor_password_cmd);
18814
18815 /* "neighbor activate" commands. */
18816 install_element(BGP_NODE, &neighbor_activate_hidden_cmd);
18817 install_element(BGP_IPV4_NODE, &neighbor_activate_cmd);
18818 install_element(BGP_IPV4M_NODE, &neighbor_activate_cmd);
18819 install_element(BGP_IPV4L_NODE, &neighbor_activate_cmd);
18820 install_element(BGP_IPV6_NODE, &neighbor_activate_cmd);
18821 install_element(BGP_IPV6M_NODE, &neighbor_activate_cmd);
18822 install_element(BGP_IPV6L_NODE, &neighbor_activate_cmd);
18823 install_element(BGP_VPNV4_NODE, &neighbor_activate_cmd);
18824 install_element(BGP_VPNV6_NODE, &neighbor_activate_cmd);
18825 install_element(BGP_FLOWSPECV4_NODE, &neighbor_activate_cmd);
18826 install_element(BGP_FLOWSPECV6_NODE, &neighbor_activate_cmd);
18827 install_element(BGP_EVPN_NODE, &neighbor_activate_cmd);
18828
18829 /* "no neighbor activate" commands. */
18830 install_element(BGP_NODE, &no_neighbor_activate_hidden_cmd);
18831 install_element(BGP_IPV4_NODE, &no_neighbor_activate_cmd);
18832 install_element(BGP_IPV4M_NODE, &no_neighbor_activate_cmd);
18833 install_element(BGP_IPV4L_NODE, &no_neighbor_activate_cmd);
18834 install_element(BGP_IPV6_NODE, &no_neighbor_activate_cmd);
18835 install_element(BGP_IPV6M_NODE, &no_neighbor_activate_cmd);
18836 install_element(BGP_IPV6L_NODE, &no_neighbor_activate_cmd);
18837 install_element(BGP_VPNV4_NODE, &no_neighbor_activate_cmd);
18838 install_element(BGP_VPNV6_NODE, &no_neighbor_activate_cmd);
18839 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_activate_cmd);
18840 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_activate_cmd);
18841 install_element(BGP_EVPN_NODE, &no_neighbor_activate_cmd);
18842
18843 /* "neighbor peer-group" set commands. */
18844 install_element(BGP_NODE, &neighbor_set_peer_group_cmd);
18845 install_element(BGP_IPV4_NODE, &neighbor_set_peer_group_hidden_cmd);
18846 install_element(BGP_IPV4M_NODE, &neighbor_set_peer_group_hidden_cmd);
18847 install_element(BGP_IPV6_NODE, &neighbor_set_peer_group_hidden_cmd);
18848 install_element(BGP_IPV6M_NODE, &neighbor_set_peer_group_hidden_cmd);
18849 install_element(BGP_IPV6L_NODE, &neighbor_set_peer_group_hidden_cmd);
18850 install_element(BGP_VPNV4_NODE, &neighbor_set_peer_group_hidden_cmd);
18851 install_element(BGP_VPNV6_NODE, &neighbor_set_peer_group_hidden_cmd);
18852 install_element(BGP_FLOWSPECV4_NODE,
18853 &neighbor_set_peer_group_hidden_cmd);
18854 install_element(BGP_FLOWSPECV6_NODE,
18855 &neighbor_set_peer_group_hidden_cmd);
18856
18857 /* "no neighbor peer-group unset" commands. */
18858 install_element(BGP_NODE, &no_neighbor_set_peer_group_cmd);
18859 install_element(BGP_IPV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18860 install_element(BGP_IPV4M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18861 install_element(BGP_IPV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18862 install_element(BGP_IPV6M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18863 install_element(BGP_IPV6L_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18864 install_element(BGP_VPNV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18865 install_element(BGP_VPNV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
18866 install_element(BGP_FLOWSPECV4_NODE,
18867 &no_neighbor_set_peer_group_hidden_cmd);
18868 install_element(BGP_FLOWSPECV6_NODE,
18869 &no_neighbor_set_peer_group_hidden_cmd);
18870
18871 /* "neighbor softreconfiguration inbound" commands.*/
18872 install_element(BGP_NODE, &neighbor_soft_reconfiguration_hidden_cmd);
18873 install_element(BGP_NODE, &no_neighbor_soft_reconfiguration_hidden_cmd);
18874 install_element(BGP_IPV4_NODE, &neighbor_soft_reconfiguration_cmd);
18875 install_element(BGP_IPV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
18876 install_element(BGP_IPV4L_NODE, &neighbor_soft_reconfiguration_cmd);
18877 install_element(BGP_IPV4L_NODE, &no_neighbor_soft_reconfiguration_cmd);
18878 install_element(BGP_IPV4M_NODE, &neighbor_soft_reconfiguration_cmd);
18879 install_element(BGP_IPV4M_NODE, &no_neighbor_soft_reconfiguration_cmd);
18880 install_element(BGP_IPV6_NODE, &neighbor_soft_reconfiguration_cmd);
18881 install_element(BGP_IPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
18882 install_element(BGP_IPV6M_NODE, &neighbor_soft_reconfiguration_cmd);
18883 install_element(BGP_IPV6M_NODE, &no_neighbor_soft_reconfiguration_cmd);
18884 install_element(BGP_IPV6L_NODE, &neighbor_soft_reconfiguration_cmd);
18885 install_element(BGP_IPV6L_NODE, &no_neighbor_soft_reconfiguration_cmd);
18886 install_element(BGP_VPNV4_NODE, &neighbor_soft_reconfiguration_cmd);
18887 install_element(BGP_VPNV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
18888 install_element(BGP_VPNV6_NODE, &neighbor_soft_reconfiguration_cmd);
18889 install_element(BGP_VPNV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
18890 install_element(BGP_FLOWSPECV4_NODE,
18891 &neighbor_soft_reconfiguration_cmd);
18892 install_element(BGP_FLOWSPECV4_NODE,
18893 &no_neighbor_soft_reconfiguration_cmd);
18894 install_element(BGP_FLOWSPECV6_NODE,
18895 &neighbor_soft_reconfiguration_cmd);
18896 install_element(BGP_FLOWSPECV6_NODE,
18897 &no_neighbor_soft_reconfiguration_cmd);
18898 install_element(BGP_EVPN_NODE, &neighbor_soft_reconfiguration_cmd);
18899 install_element(BGP_EVPN_NODE, &no_neighbor_soft_reconfiguration_cmd);
18900
18901 /* "neighbor attribute-unchanged" commands. */
18902 install_element(BGP_NODE, &neighbor_attr_unchanged_hidden_cmd);
18903 install_element(BGP_NODE, &no_neighbor_attr_unchanged_hidden_cmd);
18904 install_element(BGP_IPV4_NODE, &neighbor_attr_unchanged_cmd);
18905 install_element(BGP_IPV4_NODE, &no_neighbor_attr_unchanged_cmd);
18906 install_element(BGP_IPV4M_NODE, &neighbor_attr_unchanged_cmd);
18907 install_element(BGP_IPV4M_NODE, &no_neighbor_attr_unchanged_cmd);
18908 install_element(BGP_IPV4L_NODE, &neighbor_attr_unchanged_cmd);
18909 install_element(BGP_IPV4L_NODE, &no_neighbor_attr_unchanged_cmd);
18910 install_element(BGP_IPV6_NODE, &neighbor_attr_unchanged_cmd);
18911 install_element(BGP_IPV6_NODE, &no_neighbor_attr_unchanged_cmd);
18912 install_element(BGP_IPV6M_NODE, &neighbor_attr_unchanged_cmd);
18913 install_element(BGP_IPV6M_NODE, &no_neighbor_attr_unchanged_cmd);
18914 install_element(BGP_IPV6L_NODE, &neighbor_attr_unchanged_cmd);
18915 install_element(BGP_IPV6L_NODE, &no_neighbor_attr_unchanged_cmd);
18916 install_element(BGP_VPNV4_NODE, &neighbor_attr_unchanged_cmd);
18917 install_element(BGP_VPNV4_NODE, &no_neighbor_attr_unchanged_cmd);
18918 install_element(BGP_VPNV6_NODE, &neighbor_attr_unchanged_cmd);
18919 install_element(BGP_VPNV6_NODE, &no_neighbor_attr_unchanged_cmd);
18920
18921 install_element(BGP_EVPN_NODE, &neighbor_attr_unchanged_cmd);
18922 install_element(BGP_EVPN_NODE, &no_neighbor_attr_unchanged_cmd);
18923
18924 install_element(BGP_FLOWSPECV4_NODE, &neighbor_attr_unchanged_cmd);
18925 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_attr_unchanged_cmd);
18926 install_element(BGP_FLOWSPECV6_NODE, &neighbor_attr_unchanged_cmd);
18927 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_attr_unchanged_cmd);
18928
18929 /* "nexthop-local unchanged" commands */
18930 install_element(BGP_IPV6_NODE, &neighbor_nexthop_local_unchanged_cmd);
18931 install_element(BGP_IPV6_NODE,
18932 &no_neighbor_nexthop_local_unchanged_cmd);
18933
18934 /* "neighbor next-hop-self" commands. */
18935 install_element(BGP_NODE, &neighbor_nexthop_self_hidden_cmd);
18936 install_element(BGP_NODE, &no_neighbor_nexthop_self_hidden_cmd);
18937 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_cmd);
18938 install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_cmd);
18939 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_cmd);
18940 install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_cmd);
18941 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_cmd);
18942 install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_cmd);
18943 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_cmd);
18944 install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_cmd);
18945 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_cmd);
18946 install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_cmd);
18947 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_cmd);
18948 install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_cmd);
18949 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_cmd);
18950 install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_cmd);
18951 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_cmd);
18952 install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_cmd);
18953 install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_cmd);
18954 install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_cmd);
18955
18956 /* "neighbor next-hop-self force" commands. */
18957 install_element(BGP_NODE, &neighbor_nexthop_self_force_hidden_cmd);
18958 install_element(BGP_NODE, &no_neighbor_nexthop_self_force_hidden_cmd);
18959 install_element(BGP_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18960 install_element(BGP_NODE, &no_neighbor_nexthop_self_all_hidden_cmd);
18961 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_force_cmd);
18962 install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_force_cmd);
18963 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18964 install_element(BGP_IPV4_NODE,
18965 &no_neighbor_nexthop_self_all_hidden_cmd);
18966 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_force_cmd);
18967 install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_force_cmd);
18968 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18969 install_element(BGP_IPV4M_NODE,
18970 &no_neighbor_nexthop_self_all_hidden_cmd);
18971 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_force_cmd);
18972 install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_force_cmd);
18973 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18974 install_element(BGP_IPV4L_NODE,
18975 &no_neighbor_nexthop_self_all_hidden_cmd);
18976 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_force_cmd);
18977 install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_force_cmd);
18978 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18979 install_element(BGP_IPV6_NODE,
18980 &no_neighbor_nexthop_self_all_hidden_cmd);
18981 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_force_cmd);
18982 install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_force_cmd);
18983 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18984 install_element(BGP_IPV6M_NODE,
18985 &no_neighbor_nexthop_self_all_hidden_cmd);
18986 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_force_cmd);
18987 install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_force_cmd);
18988 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18989 install_element(BGP_IPV6L_NODE,
18990 &no_neighbor_nexthop_self_all_hidden_cmd);
18991 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_force_cmd);
18992 install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_force_cmd);
18993 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18994 install_element(BGP_VPNV4_NODE,
18995 &no_neighbor_nexthop_self_all_hidden_cmd);
18996 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_force_cmd);
18997 install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_force_cmd);
18998 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
18999 install_element(BGP_VPNV6_NODE,
19000 &no_neighbor_nexthop_self_all_hidden_cmd);
19001 install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_force_cmd);
19002 install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_force_cmd);
19003
19004 /* "neighbor as-override" commands. */
19005 install_element(BGP_NODE, &neighbor_as_override_hidden_cmd);
19006 install_element(BGP_NODE, &no_neighbor_as_override_hidden_cmd);
19007 install_element(BGP_IPV4_NODE, &neighbor_as_override_cmd);
19008 install_element(BGP_IPV4_NODE, &no_neighbor_as_override_cmd);
19009 install_element(BGP_IPV4M_NODE, &neighbor_as_override_cmd);
19010 install_element(BGP_IPV4M_NODE, &no_neighbor_as_override_cmd);
19011 install_element(BGP_IPV4L_NODE, &neighbor_as_override_cmd);
19012 install_element(BGP_IPV4L_NODE, &no_neighbor_as_override_cmd);
19013 install_element(BGP_IPV6_NODE, &neighbor_as_override_cmd);
19014 install_element(BGP_IPV6_NODE, &no_neighbor_as_override_cmd);
19015 install_element(BGP_IPV6M_NODE, &neighbor_as_override_cmd);
19016 install_element(BGP_IPV6M_NODE, &no_neighbor_as_override_cmd);
19017 install_element(BGP_IPV6L_NODE, &neighbor_as_override_cmd);
19018 install_element(BGP_IPV6L_NODE, &no_neighbor_as_override_cmd);
19019 install_element(BGP_VPNV4_NODE, &neighbor_as_override_cmd);
19020 install_element(BGP_VPNV4_NODE, &no_neighbor_as_override_cmd);
19021 install_element(BGP_VPNV6_NODE, &neighbor_as_override_cmd);
19022 install_element(BGP_VPNV6_NODE, &no_neighbor_as_override_cmd);
19023
19024 /* "neighbor remove-private-AS" commands. */
19025 install_element(BGP_NODE, &neighbor_remove_private_as_hidden_cmd);
19026 install_element(BGP_NODE, &no_neighbor_remove_private_as_hidden_cmd);
19027 install_element(BGP_NODE, &neighbor_remove_private_as_all_hidden_cmd);
19028 install_element(BGP_NODE,
19029 &no_neighbor_remove_private_as_all_hidden_cmd);
19030 install_element(BGP_NODE,
19031 &neighbor_remove_private_as_replace_as_hidden_cmd);
19032 install_element(BGP_NODE,
19033 &no_neighbor_remove_private_as_replace_as_hidden_cmd);
19034 install_element(BGP_NODE,
19035 &neighbor_remove_private_as_all_replace_as_hidden_cmd);
19036 install_element(
19037 BGP_NODE,
19038 &no_neighbor_remove_private_as_all_replace_as_hidden_cmd);
19039 install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_cmd);
19040 install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_cmd);
19041 install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_all_cmd);
19042 install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_cmd);
19043 install_element(BGP_IPV4_NODE,
19044 &neighbor_remove_private_as_replace_as_cmd);
19045 install_element(BGP_IPV4_NODE,
19046 &no_neighbor_remove_private_as_replace_as_cmd);
19047 install_element(BGP_IPV4_NODE,
19048 &neighbor_remove_private_as_all_replace_as_cmd);
19049 install_element(BGP_IPV4_NODE,
19050 &no_neighbor_remove_private_as_all_replace_as_cmd);
19051 install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_cmd);
19052 install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_cmd);
19053 install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_all_cmd);
19054 install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_cmd);
19055 install_element(BGP_IPV4M_NODE,
19056 &neighbor_remove_private_as_replace_as_cmd);
19057 install_element(BGP_IPV4M_NODE,
19058 &no_neighbor_remove_private_as_replace_as_cmd);
19059 install_element(BGP_IPV4M_NODE,
19060 &neighbor_remove_private_as_all_replace_as_cmd);
19061 install_element(BGP_IPV4M_NODE,
19062 &no_neighbor_remove_private_as_all_replace_as_cmd);
19063 install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_cmd);
19064 install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_cmd);
19065 install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_all_cmd);
19066 install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_all_cmd);
19067 install_element(BGP_IPV4L_NODE,
19068 &neighbor_remove_private_as_replace_as_cmd);
19069 install_element(BGP_IPV4L_NODE,
19070 &no_neighbor_remove_private_as_replace_as_cmd);
19071 install_element(BGP_IPV4L_NODE,
19072 &neighbor_remove_private_as_all_replace_as_cmd);
19073 install_element(BGP_IPV4L_NODE,
19074 &no_neighbor_remove_private_as_all_replace_as_cmd);
19075 install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_cmd);
19076 install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_cmd);
19077 install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_all_cmd);
19078 install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_cmd);
19079 install_element(BGP_IPV6_NODE,
19080 &neighbor_remove_private_as_replace_as_cmd);
19081 install_element(BGP_IPV6_NODE,
19082 &no_neighbor_remove_private_as_replace_as_cmd);
19083 install_element(BGP_IPV6_NODE,
19084 &neighbor_remove_private_as_all_replace_as_cmd);
19085 install_element(BGP_IPV6_NODE,
19086 &no_neighbor_remove_private_as_all_replace_as_cmd);
19087 install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_cmd);
19088 install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_cmd);
19089 install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_all_cmd);
19090 install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_cmd);
19091 install_element(BGP_IPV6M_NODE,
19092 &neighbor_remove_private_as_replace_as_cmd);
19093 install_element(BGP_IPV6M_NODE,
19094 &no_neighbor_remove_private_as_replace_as_cmd);
19095 install_element(BGP_IPV6M_NODE,
19096 &neighbor_remove_private_as_all_replace_as_cmd);
19097 install_element(BGP_IPV6M_NODE,
19098 &no_neighbor_remove_private_as_all_replace_as_cmd);
19099 install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_cmd);
19100 install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_cmd);
19101 install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_all_cmd);
19102 install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_all_cmd);
19103 install_element(BGP_IPV6L_NODE,
19104 &neighbor_remove_private_as_replace_as_cmd);
19105 install_element(BGP_IPV6L_NODE,
19106 &no_neighbor_remove_private_as_replace_as_cmd);
19107 install_element(BGP_IPV6L_NODE,
19108 &neighbor_remove_private_as_all_replace_as_cmd);
19109 install_element(BGP_IPV6L_NODE,
19110 &no_neighbor_remove_private_as_all_replace_as_cmd);
19111 install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_cmd);
19112 install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_cmd);
19113 install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_all_cmd);
19114 install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_cmd);
19115 install_element(BGP_VPNV4_NODE,
19116 &neighbor_remove_private_as_replace_as_cmd);
19117 install_element(BGP_VPNV4_NODE,
19118 &no_neighbor_remove_private_as_replace_as_cmd);
19119 install_element(BGP_VPNV4_NODE,
19120 &neighbor_remove_private_as_all_replace_as_cmd);
19121 install_element(BGP_VPNV4_NODE,
19122 &no_neighbor_remove_private_as_all_replace_as_cmd);
19123 install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_cmd);
19124 install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_cmd);
19125 install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_all_cmd);
19126 install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_cmd);
19127 install_element(BGP_VPNV6_NODE,
19128 &neighbor_remove_private_as_replace_as_cmd);
19129 install_element(BGP_VPNV6_NODE,
19130 &no_neighbor_remove_private_as_replace_as_cmd);
19131 install_element(BGP_VPNV6_NODE,
19132 &neighbor_remove_private_as_all_replace_as_cmd);
19133 install_element(BGP_VPNV6_NODE,
19134 &no_neighbor_remove_private_as_all_replace_as_cmd);
19135
19136 /* "neighbor send-community" commands.*/
19137 install_element(BGP_NODE, &neighbor_send_community_hidden_cmd);
19138 install_element(BGP_NODE, &neighbor_send_community_type_hidden_cmd);
19139 install_element(BGP_NODE, &no_neighbor_send_community_hidden_cmd);
19140 install_element(BGP_NODE, &no_neighbor_send_community_type_hidden_cmd);
19141 install_element(BGP_IPV4_NODE, &neighbor_send_community_cmd);
19142 install_element(BGP_IPV4_NODE, &neighbor_send_community_type_cmd);
19143 install_element(BGP_IPV4_NODE, &no_neighbor_send_community_cmd);
19144 install_element(BGP_IPV4_NODE, &no_neighbor_send_community_type_cmd);
19145 install_element(BGP_IPV4M_NODE, &neighbor_send_community_cmd);
19146 install_element(BGP_IPV4M_NODE, &neighbor_send_community_type_cmd);
19147 install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_cmd);
19148 install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_type_cmd);
19149 install_element(BGP_IPV4L_NODE, &neighbor_send_community_cmd);
19150 install_element(BGP_IPV4L_NODE, &neighbor_send_community_type_cmd);
19151 install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_cmd);
19152 install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_type_cmd);
19153 install_element(BGP_IPV6_NODE, &neighbor_send_community_cmd);
19154 install_element(BGP_IPV6_NODE, &neighbor_send_community_type_cmd);
19155 install_element(BGP_IPV6_NODE, &no_neighbor_send_community_cmd);
19156 install_element(BGP_IPV6_NODE, &no_neighbor_send_community_type_cmd);
19157 install_element(BGP_IPV6M_NODE, &neighbor_send_community_cmd);
19158 install_element(BGP_IPV6M_NODE, &neighbor_send_community_type_cmd);
19159 install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_cmd);
19160 install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_type_cmd);
19161 install_element(BGP_IPV6L_NODE, &neighbor_send_community_cmd);
19162 install_element(BGP_IPV6L_NODE, &neighbor_send_community_type_cmd);
19163 install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_cmd);
19164 install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_type_cmd);
19165 install_element(BGP_VPNV4_NODE, &neighbor_send_community_cmd);
19166 install_element(BGP_VPNV4_NODE, &neighbor_send_community_type_cmd);
19167 install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_cmd);
19168 install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_type_cmd);
19169 install_element(BGP_VPNV6_NODE, &neighbor_send_community_cmd);
19170 install_element(BGP_VPNV6_NODE, &neighbor_send_community_type_cmd);
19171 install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_cmd);
19172 install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_type_cmd);
19173
19174 /* "neighbor route-reflector" commands.*/
19175 install_element(BGP_NODE, &neighbor_route_reflector_client_hidden_cmd);
19176 install_element(BGP_NODE,
19177 &no_neighbor_route_reflector_client_hidden_cmd);
19178 install_element(BGP_IPV4_NODE, &neighbor_route_reflector_client_cmd);
19179 install_element(BGP_IPV4_NODE, &no_neighbor_route_reflector_client_cmd);
19180 install_element(BGP_IPV4M_NODE, &neighbor_route_reflector_client_cmd);
19181 install_element(BGP_IPV4M_NODE,
19182 &no_neighbor_route_reflector_client_cmd);
19183 install_element(BGP_IPV4L_NODE, &neighbor_route_reflector_client_cmd);
19184 install_element(BGP_IPV4L_NODE,
19185 &no_neighbor_route_reflector_client_cmd);
19186 install_element(BGP_IPV6_NODE, &neighbor_route_reflector_client_cmd);
19187 install_element(BGP_IPV6_NODE, &no_neighbor_route_reflector_client_cmd);
19188 install_element(BGP_IPV6M_NODE, &neighbor_route_reflector_client_cmd);
19189 install_element(BGP_IPV6M_NODE,
19190 &no_neighbor_route_reflector_client_cmd);
19191 install_element(BGP_IPV6L_NODE, &neighbor_route_reflector_client_cmd);
19192 install_element(BGP_IPV6L_NODE,
19193 &no_neighbor_route_reflector_client_cmd);
19194 install_element(BGP_VPNV4_NODE, &neighbor_route_reflector_client_cmd);
19195 install_element(BGP_VPNV4_NODE,
19196 &no_neighbor_route_reflector_client_cmd);
19197 install_element(BGP_VPNV6_NODE, &neighbor_route_reflector_client_cmd);
19198 install_element(BGP_VPNV6_NODE,
19199 &no_neighbor_route_reflector_client_cmd);
19200 install_element(BGP_FLOWSPECV4_NODE,
19201 &neighbor_route_reflector_client_cmd);
19202 install_element(BGP_FLOWSPECV4_NODE,
19203 &no_neighbor_route_reflector_client_cmd);
19204 install_element(BGP_FLOWSPECV6_NODE,
19205 &neighbor_route_reflector_client_cmd);
19206 install_element(BGP_FLOWSPECV6_NODE,
19207 &no_neighbor_route_reflector_client_cmd);
19208 install_element(BGP_EVPN_NODE, &neighbor_route_reflector_client_cmd);
19209 install_element(BGP_EVPN_NODE, &no_neighbor_route_reflector_client_cmd);
19210
19211 /* "optimal-route-reflection" commands */
19212 install_element(BGP_IPV4_NODE, &optimal_route_reflection_cmd);
19213 install_element(BGP_IPV4M_NODE, &optimal_route_reflection_cmd);
19214 install_element(BGP_IPV4L_NODE, &optimal_route_reflection_cmd);
19215 install_element(BGP_IPV6_NODE, &optimal_route_reflection_cmd);
19216 install_element(BGP_IPV6M_NODE, &optimal_route_reflection_cmd);
19217 install_element(BGP_IPV6L_NODE, &optimal_route_reflection_cmd);
19218 install_element(BGP_VPNV4_NODE, &optimal_route_reflection_cmd);
19219 install_element(BGP_VPNV6_NODE, &optimal_route_reflection_cmd);
19220 install_element(BGP_FLOWSPECV4_NODE, &optimal_route_reflection_cmd);
19221 install_element(BGP_FLOWSPECV6_NODE, &optimal_route_reflection_cmd);
19222 install_element(BGP_EVPN_NODE, &optimal_route_reflection_cmd);
19223
19224 /* "neighbor optimal-route-reflection" commands */
19225 install_element(BGP_IPV4_NODE, &neighbor_optimal_route_reflection_cmd);
19226 install_element(BGP_IPV4M_NODE, &neighbor_optimal_route_reflection_cmd);
19227 install_element(BGP_IPV4L_NODE, &neighbor_optimal_route_reflection_cmd);
19228 install_element(BGP_IPV6_NODE, &neighbor_optimal_route_reflection_cmd);
19229 install_element(BGP_IPV6M_NODE, &neighbor_optimal_route_reflection_cmd);
19230 install_element(BGP_IPV6L_NODE, &neighbor_optimal_route_reflection_cmd);
19231 install_element(BGP_VPNV4_NODE, &neighbor_optimal_route_reflection_cmd);
19232 install_element(BGP_VPNV6_NODE, &neighbor_optimal_route_reflection_cmd);
19233 install_element(BGP_FLOWSPECV4_NODE,
19234 &neighbor_optimal_route_reflection_cmd);
19235 install_element(BGP_FLOWSPECV6_NODE,
19236 &neighbor_optimal_route_reflection_cmd);
19237 install_element(BGP_EVPN_NODE, &neighbor_optimal_route_reflection_cmd);
19238
19239 /* "neighbor route-server" commands.*/
19240 install_element(BGP_NODE, &neighbor_route_server_client_hidden_cmd);
19241 install_element(BGP_NODE, &no_neighbor_route_server_client_hidden_cmd);
19242 install_element(BGP_IPV4_NODE, &neighbor_route_server_client_cmd);
19243 install_element(BGP_IPV4_NODE, &no_neighbor_route_server_client_cmd);
19244 install_element(BGP_IPV4M_NODE, &neighbor_route_server_client_cmd);
19245 install_element(BGP_IPV4M_NODE, &no_neighbor_route_server_client_cmd);
19246 install_element(BGP_IPV4L_NODE, &neighbor_route_server_client_cmd);
19247 install_element(BGP_IPV4L_NODE, &no_neighbor_route_server_client_cmd);
19248 install_element(BGP_IPV6_NODE, &neighbor_route_server_client_cmd);
19249 install_element(BGP_IPV6_NODE, &no_neighbor_route_server_client_cmd);
19250 install_element(BGP_IPV6M_NODE, &neighbor_route_server_client_cmd);
19251 install_element(BGP_IPV6M_NODE, &no_neighbor_route_server_client_cmd);
19252 install_element(BGP_IPV6L_NODE, &neighbor_route_server_client_cmd);
19253 install_element(BGP_IPV6L_NODE, &no_neighbor_route_server_client_cmd);
19254 install_element(BGP_VPNV4_NODE, &neighbor_route_server_client_cmd);
19255 install_element(BGP_VPNV4_NODE, &no_neighbor_route_server_client_cmd);
19256 install_element(BGP_VPNV6_NODE, &neighbor_route_server_client_cmd);
19257 install_element(BGP_VPNV6_NODE, &no_neighbor_route_server_client_cmd);
19258 install_element(BGP_EVPN_NODE, &neighbor_route_server_client_cmd);
19259 install_element(BGP_EVPN_NODE, &no_neighbor_route_server_client_cmd);
19260 install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_server_client_cmd);
19261 install_element(BGP_FLOWSPECV4_NODE,
19262 &no_neighbor_route_server_client_cmd);
19263 install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_server_client_cmd);
19264 install_element(BGP_FLOWSPECV6_NODE,
19265 &no_neighbor_route_server_client_cmd);
19266
19267 /* "neighbor disable-addpath-rx" commands. */
19268 install_element(BGP_IPV4_NODE, &neighbor_disable_addpath_rx_cmd);
19269 install_element(BGP_IPV4_NODE, &no_neighbor_disable_addpath_rx_cmd);
19270 install_element(BGP_IPV4M_NODE, &neighbor_disable_addpath_rx_cmd);
19271 install_element(BGP_IPV4M_NODE, &no_neighbor_disable_addpath_rx_cmd);
19272 install_element(BGP_IPV4L_NODE, &neighbor_disable_addpath_rx_cmd);
19273 install_element(BGP_IPV4L_NODE, &no_neighbor_disable_addpath_rx_cmd);
19274 install_element(BGP_IPV6_NODE, &neighbor_disable_addpath_rx_cmd);
19275 install_element(BGP_IPV6_NODE, &no_neighbor_disable_addpath_rx_cmd);
19276 install_element(BGP_IPV6M_NODE, &neighbor_disable_addpath_rx_cmd);
19277 install_element(BGP_IPV6M_NODE, &no_neighbor_disable_addpath_rx_cmd);
19278 install_element(BGP_IPV6L_NODE, &neighbor_disable_addpath_rx_cmd);
19279 install_element(BGP_IPV6L_NODE, &no_neighbor_disable_addpath_rx_cmd);
19280 install_element(BGP_VPNV4_NODE, &neighbor_disable_addpath_rx_cmd);
19281 install_element(BGP_VPNV4_NODE, &no_neighbor_disable_addpath_rx_cmd);
19282 install_element(BGP_VPNV6_NODE, &neighbor_disable_addpath_rx_cmd);
19283 install_element(BGP_VPNV6_NODE, &no_neighbor_disable_addpath_rx_cmd);
19284
19285 /* "neighbor addpath-tx-all-paths" commands.*/
19286 install_element(BGP_NODE, &neighbor_addpath_tx_all_paths_hidden_cmd);
19287 install_element(BGP_NODE, &no_neighbor_addpath_tx_all_paths_hidden_cmd);
19288 install_element(BGP_IPV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
19289 install_element(BGP_IPV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19290 install_element(BGP_IPV4M_NODE, &neighbor_addpath_tx_all_paths_cmd);
19291 install_element(BGP_IPV4M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19292 install_element(BGP_IPV4L_NODE, &neighbor_addpath_tx_all_paths_cmd);
19293 install_element(BGP_IPV4L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19294 install_element(BGP_IPV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
19295 install_element(BGP_IPV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19296 install_element(BGP_IPV6M_NODE, &neighbor_addpath_tx_all_paths_cmd);
19297 install_element(BGP_IPV6M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19298 install_element(BGP_IPV6L_NODE, &neighbor_addpath_tx_all_paths_cmd);
19299 install_element(BGP_IPV6L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19300 install_element(BGP_VPNV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
19301 install_element(BGP_VPNV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19302 install_element(BGP_VPNV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
19303 install_element(BGP_VPNV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19304
19305 /* "neighbor addpath-tx-bestpath-per-AS" commands.*/
19306 install_element(BGP_NODE,
19307 &neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
19308 install_element(BGP_NODE,
19309 &no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
19310 install_element(BGP_IPV4_NODE,
19311 &neighbor_addpath_tx_bestpath_per_as_cmd);
19312 install_element(BGP_IPV4_NODE,
19313 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19314 install_element(BGP_IPV4M_NODE,
19315 &neighbor_addpath_tx_bestpath_per_as_cmd);
19316 install_element(BGP_IPV4M_NODE,
19317 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19318 install_element(BGP_IPV4L_NODE,
19319 &neighbor_addpath_tx_bestpath_per_as_cmd);
19320 install_element(BGP_IPV4L_NODE,
19321 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19322 install_element(BGP_IPV6_NODE,
19323 &neighbor_addpath_tx_bestpath_per_as_cmd);
19324 install_element(BGP_IPV6_NODE,
19325 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19326 install_element(BGP_IPV6M_NODE,
19327 &neighbor_addpath_tx_bestpath_per_as_cmd);
19328 install_element(BGP_IPV6M_NODE,
19329 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19330 install_element(BGP_IPV6L_NODE,
19331 &neighbor_addpath_tx_bestpath_per_as_cmd);
19332 install_element(BGP_IPV6L_NODE,
19333 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19334 install_element(BGP_VPNV4_NODE,
19335 &neighbor_addpath_tx_bestpath_per_as_cmd);
19336 install_element(BGP_VPNV4_NODE,
19337 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19338 install_element(BGP_VPNV6_NODE,
19339 &neighbor_addpath_tx_bestpath_per_as_cmd);
19340 install_element(BGP_VPNV6_NODE,
19341 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19342
19343 /* "neighbor sender-as-path-loop-detection" commands. */
19344 install_element(BGP_NODE, &neighbor_aspath_loop_detection_cmd);
19345 install_element(BGP_NODE, &no_neighbor_aspath_loop_detection_cmd);
19346
19347 /* "neighbor passive" commands. */
19348 install_element(BGP_NODE, &neighbor_passive_cmd);
19349 install_element(BGP_NODE, &no_neighbor_passive_cmd);
19350
19351
19352 /* "neighbor shutdown" commands. */
19353 install_element(BGP_NODE, &neighbor_shutdown_cmd);
19354 install_element(BGP_NODE, &no_neighbor_shutdown_cmd);
19355 install_element(BGP_NODE, &neighbor_shutdown_msg_cmd);
19356 install_element(BGP_NODE, &no_neighbor_shutdown_msg_cmd);
19357 install_element(BGP_NODE, &neighbor_shutdown_rtt_cmd);
19358 install_element(BGP_NODE, &no_neighbor_shutdown_rtt_cmd);
19359
19360 /* "neighbor capability extended-nexthop" commands.*/
19361 install_element(BGP_NODE, &neighbor_capability_enhe_cmd);
19362 install_element(BGP_NODE, &no_neighbor_capability_enhe_cmd);
19363
19364 /* "neighbor capability orf prefix-list" commands.*/
19365 install_element(BGP_NODE, &neighbor_capability_orf_prefix_hidden_cmd);
19366 install_element(BGP_NODE,
19367 &no_neighbor_capability_orf_prefix_hidden_cmd);
19368 install_element(BGP_IPV4_NODE, &neighbor_capability_orf_prefix_cmd);
19369 install_element(BGP_IPV4_NODE, &no_neighbor_capability_orf_prefix_cmd);
19370 install_element(BGP_IPV4M_NODE, &neighbor_capability_orf_prefix_cmd);
19371 install_element(BGP_IPV4M_NODE, &no_neighbor_capability_orf_prefix_cmd);
19372 install_element(BGP_IPV4L_NODE, &neighbor_capability_orf_prefix_cmd);
19373 install_element(BGP_IPV4L_NODE, &no_neighbor_capability_orf_prefix_cmd);
19374 install_element(BGP_IPV6_NODE, &neighbor_capability_orf_prefix_cmd);
19375 install_element(BGP_IPV6_NODE, &no_neighbor_capability_orf_prefix_cmd);
19376 install_element(BGP_IPV6M_NODE, &neighbor_capability_orf_prefix_cmd);
19377 install_element(BGP_IPV6M_NODE, &no_neighbor_capability_orf_prefix_cmd);
19378 install_element(BGP_IPV6L_NODE, &neighbor_capability_orf_prefix_cmd);
19379 install_element(BGP_IPV6L_NODE, &no_neighbor_capability_orf_prefix_cmd);
19380
19381 /* "neighbor capability dynamic" commands.*/
19382 install_element(BGP_NODE, &neighbor_capability_dynamic_cmd);
19383 install_element(BGP_NODE, &no_neighbor_capability_dynamic_cmd);
19384
19385 /* "neighbor dont-capability-negotiate" commands. */
19386 install_element(BGP_NODE, &neighbor_dont_capability_negotiate_cmd);
19387 install_element(BGP_NODE, &no_neighbor_dont_capability_negotiate_cmd);
19388
19389 /* "neighbor ebgp-multihop" commands. */
19390 install_element(BGP_NODE, &neighbor_ebgp_multihop_cmd);
19391 install_element(BGP_NODE, &neighbor_ebgp_multihop_ttl_cmd);
19392 install_element(BGP_NODE, &no_neighbor_ebgp_multihop_cmd);
19393
19394 /* "neighbor disable-connected-check" commands. */
19395 install_element(BGP_NODE, &neighbor_disable_connected_check_cmd);
19396 install_element(BGP_NODE, &no_neighbor_disable_connected_check_cmd);
19397
19398 /* "neighbor disable-link-bw-encoding-ieee" commands. */
19399 install_element(BGP_NODE, &neighbor_disable_link_bw_encoding_ieee_cmd);
19400 install_element(BGP_NODE,
19401 &no_neighbor_disable_link_bw_encoding_ieee_cmd);
19402
19403 /* "neighbor extended-optional-parameters" commands. */
19404 install_element(BGP_NODE, &neighbor_extended_optional_parameters_cmd);
19405 install_element(BGP_NODE,
19406 &no_neighbor_extended_optional_parameters_cmd);
19407
19408 /* "neighbor enforce-first-as" commands. */
19409 install_element(BGP_NODE, &neighbor_enforce_first_as_cmd);
19410 install_element(BGP_NODE, &no_neighbor_enforce_first_as_cmd);
19411
19412 /* "neighbor description" commands. */
19413 install_element(BGP_NODE, &neighbor_description_cmd);
19414 install_element(BGP_NODE, &no_neighbor_description_cmd);
19415 install_element(BGP_NODE, &no_neighbor_description_comment_cmd);
19416
19417 /* "neighbor update-source" commands. "*/
19418 install_element(BGP_NODE, &neighbor_update_source_cmd);
19419 install_element(BGP_NODE, &no_neighbor_update_source_cmd);
19420
19421 /* "neighbor default-originate" commands. */
19422 install_element(BGP_NODE, &neighbor_default_originate_hidden_cmd);
19423 install_element(BGP_NODE, &neighbor_default_originate_rmap_hidden_cmd);
19424 install_element(BGP_NODE, &no_neighbor_default_originate_hidden_cmd);
19425 install_element(BGP_IPV4_NODE, &neighbor_default_originate_cmd);
19426 install_element(BGP_IPV4_NODE, &neighbor_default_originate_rmap_cmd);
19427 install_element(BGP_IPV4_NODE, &no_neighbor_default_originate_cmd);
19428 install_element(BGP_IPV4M_NODE, &neighbor_default_originate_cmd);
19429 install_element(BGP_IPV4M_NODE, &neighbor_default_originate_rmap_cmd);
19430 install_element(BGP_IPV4M_NODE, &no_neighbor_default_originate_cmd);
19431 install_element(BGP_IPV4L_NODE, &neighbor_default_originate_cmd);
19432 install_element(BGP_IPV4L_NODE, &neighbor_default_originate_rmap_cmd);
19433 install_element(BGP_IPV4L_NODE, &no_neighbor_default_originate_cmd);
19434 install_element(BGP_IPV6_NODE, &neighbor_default_originate_cmd);
19435 install_element(BGP_IPV6_NODE, &neighbor_default_originate_rmap_cmd);
19436 install_element(BGP_IPV6_NODE, &no_neighbor_default_originate_cmd);
19437 install_element(BGP_IPV6M_NODE, &neighbor_default_originate_cmd);
19438 install_element(BGP_IPV6M_NODE, &neighbor_default_originate_rmap_cmd);
19439 install_element(BGP_IPV6M_NODE, &no_neighbor_default_originate_cmd);
19440 install_element(BGP_IPV6L_NODE, &neighbor_default_originate_cmd);
19441 install_element(BGP_IPV6L_NODE, &neighbor_default_originate_rmap_cmd);
19442 install_element(BGP_IPV6L_NODE, &no_neighbor_default_originate_cmd);
19443
19444 /* "neighbor port" commands. */
19445 install_element(BGP_NODE, &neighbor_port_cmd);
19446 install_element(BGP_NODE, &no_neighbor_port_cmd);
19447
19448 /* "neighbor weight" commands. */
19449 install_element(BGP_NODE, &neighbor_weight_hidden_cmd);
19450 install_element(BGP_NODE, &no_neighbor_weight_hidden_cmd);
19451
19452 install_element(BGP_IPV4_NODE, &neighbor_weight_cmd);
19453 install_element(BGP_IPV4_NODE, &no_neighbor_weight_cmd);
19454 install_element(BGP_IPV4M_NODE, &neighbor_weight_cmd);
19455 install_element(BGP_IPV4M_NODE, &no_neighbor_weight_cmd);
19456 install_element(BGP_IPV4L_NODE, &neighbor_weight_cmd);
19457 install_element(BGP_IPV4L_NODE, &no_neighbor_weight_cmd);
19458 install_element(BGP_IPV6_NODE, &neighbor_weight_cmd);
19459 install_element(BGP_IPV6_NODE, &no_neighbor_weight_cmd);
19460 install_element(BGP_IPV6M_NODE, &neighbor_weight_cmd);
19461 install_element(BGP_IPV6M_NODE, &no_neighbor_weight_cmd);
19462 install_element(BGP_IPV6L_NODE, &neighbor_weight_cmd);
19463 install_element(BGP_IPV6L_NODE, &no_neighbor_weight_cmd);
19464 install_element(BGP_VPNV4_NODE, &neighbor_weight_cmd);
19465 install_element(BGP_VPNV4_NODE, &no_neighbor_weight_cmd);
19466 install_element(BGP_VPNV6_NODE, &neighbor_weight_cmd);
19467 install_element(BGP_VPNV6_NODE, &no_neighbor_weight_cmd);
19468
19469 /* "neighbor override-capability" commands. */
19470 install_element(BGP_NODE, &neighbor_override_capability_cmd);
19471 install_element(BGP_NODE, &no_neighbor_override_capability_cmd);
19472
19473 /* "neighbor strict-capability-match" commands. */
19474 install_element(BGP_NODE, &neighbor_strict_capability_cmd);
19475 install_element(BGP_NODE, &no_neighbor_strict_capability_cmd);
19476
19477 /* "neighbor timers" commands. */
19478 install_element(BGP_NODE, &neighbor_timers_cmd);
19479 install_element(BGP_NODE, &no_neighbor_timers_cmd);
19480
19481 /* "neighbor timers connect" commands. */
19482 install_element(BGP_NODE, &neighbor_timers_connect_cmd);
19483 install_element(BGP_NODE, &no_neighbor_timers_connect_cmd);
19484
19485 /* "neighbor timers delayopen" commands. */
19486 install_element(BGP_NODE, &neighbor_timers_delayopen_cmd);
19487 install_element(BGP_NODE, &no_neighbor_timers_delayopen_cmd);
19488
19489 /* "neighbor advertisement-interval" commands. */
19490 install_element(BGP_NODE, &neighbor_advertise_interval_cmd);
19491 install_element(BGP_NODE, &no_neighbor_advertise_interval_cmd);
19492
19493 /* "neighbor interface" commands. */
19494 install_element(BGP_NODE, &neighbor_interface_cmd);
19495 install_element(BGP_NODE, &no_neighbor_interface_cmd);
19496
19497 /* "neighbor distribute" commands. */
19498 install_element(BGP_NODE, &neighbor_distribute_list_hidden_cmd);
19499 install_element(BGP_NODE, &no_neighbor_distribute_list_hidden_cmd);
19500 install_element(BGP_IPV4_NODE, &neighbor_distribute_list_cmd);
19501 install_element(BGP_IPV4_NODE, &no_neighbor_distribute_list_cmd);
19502 install_element(BGP_IPV4M_NODE, &neighbor_distribute_list_cmd);
19503 install_element(BGP_IPV4M_NODE, &no_neighbor_distribute_list_cmd);
19504 install_element(BGP_IPV4L_NODE, &neighbor_distribute_list_cmd);
19505 install_element(BGP_IPV4L_NODE, &no_neighbor_distribute_list_cmd);
19506 install_element(BGP_IPV6_NODE, &neighbor_distribute_list_cmd);
19507 install_element(BGP_IPV6_NODE, &no_neighbor_distribute_list_cmd);
19508 install_element(BGP_IPV6M_NODE, &neighbor_distribute_list_cmd);
19509 install_element(BGP_IPV6M_NODE, &no_neighbor_distribute_list_cmd);
19510 install_element(BGP_IPV6L_NODE, &neighbor_distribute_list_cmd);
19511 install_element(BGP_IPV6L_NODE, &no_neighbor_distribute_list_cmd);
19512 install_element(BGP_VPNV4_NODE, &neighbor_distribute_list_cmd);
19513 install_element(BGP_VPNV4_NODE, &no_neighbor_distribute_list_cmd);
19514 install_element(BGP_VPNV6_NODE, &neighbor_distribute_list_cmd);
19515 install_element(BGP_VPNV6_NODE, &no_neighbor_distribute_list_cmd);
19516
19517 /* "neighbor prefix-list" commands. */
19518 install_element(BGP_NODE, &neighbor_prefix_list_hidden_cmd);
19519 install_element(BGP_NODE, &no_neighbor_prefix_list_hidden_cmd);
19520 install_element(BGP_IPV4_NODE, &neighbor_prefix_list_cmd);
19521 install_element(BGP_IPV4_NODE, &no_neighbor_prefix_list_cmd);
19522 install_element(BGP_IPV4M_NODE, &neighbor_prefix_list_cmd);
19523 install_element(BGP_IPV4M_NODE, &no_neighbor_prefix_list_cmd);
19524 install_element(BGP_IPV4L_NODE, &neighbor_prefix_list_cmd);
19525 install_element(BGP_IPV4L_NODE, &no_neighbor_prefix_list_cmd);
19526 install_element(BGP_IPV6_NODE, &neighbor_prefix_list_cmd);
19527 install_element(BGP_IPV6_NODE, &no_neighbor_prefix_list_cmd);
19528 install_element(BGP_IPV6M_NODE, &neighbor_prefix_list_cmd);
19529 install_element(BGP_IPV6M_NODE, &no_neighbor_prefix_list_cmd);
19530 install_element(BGP_IPV6L_NODE, &neighbor_prefix_list_cmd);
19531 install_element(BGP_IPV6L_NODE, &no_neighbor_prefix_list_cmd);
19532 install_element(BGP_VPNV4_NODE, &neighbor_prefix_list_cmd);
19533 install_element(BGP_VPNV4_NODE, &no_neighbor_prefix_list_cmd);
19534 install_element(BGP_VPNV6_NODE, &neighbor_prefix_list_cmd);
19535 install_element(BGP_VPNV6_NODE, &no_neighbor_prefix_list_cmd);
19536 install_element(BGP_FLOWSPECV4_NODE, &neighbor_prefix_list_cmd);
19537 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_prefix_list_cmd);
19538 install_element(BGP_FLOWSPECV6_NODE, &neighbor_prefix_list_cmd);
19539 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_prefix_list_cmd);
19540
19541 /* "neighbor filter-list" commands. */
19542 install_element(BGP_NODE, &neighbor_filter_list_hidden_cmd);
19543 install_element(BGP_NODE, &no_neighbor_filter_list_hidden_cmd);
19544 install_element(BGP_IPV4_NODE, &neighbor_filter_list_cmd);
19545 install_element(BGP_IPV4_NODE, &no_neighbor_filter_list_cmd);
19546 install_element(BGP_IPV4M_NODE, &neighbor_filter_list_cmd);
19547 install_element(BGP_IPV4M_NODE, &no_neighbor_filter_list_cmd);
19548 install_element(BGP_IPV4L_NODE, &neighbor_filter_list_cmd);
19549 install_element(BGP_IPV4L_NODE, &no_neighbor_filter_list_cmd);
19550 install_element(BGP_IPV6_NODE, &neighbor_filter_list_cmd);
19551 install_element(BGP_IPV6_NODE, &no_neighbor_filter_list_cmd);
19552 install_element(BGP_IPV6M_NODE, &neighbor_filter_list_cmd);
19553 install_element(BGP_IPV6M_NODE, &no_neighbor_filter_list_cmd);
19554 install_element(BGP_IPV6L_NODE, &neighbor_filter_list_cmd);
19555 install_element(BGP_IPV6L_NODE, &no_neighbor_filter_list_cmd);
19556 install_element(BGP_VPNV4_NODE, &neighbor_filter_list_cmd);
19557 install_element(BGP_VPNV4_NODE, &no_neighbor_filter_list_cmd);
19558 install_element(BGP_VPNV6_NODE, &neighbor_filter_list_cmd);
19559 install_element(BGP_VPNV6_NODE, &no_neighbor_filter_list_cmd);
19560 install_element(BGP_FLOWSPECV4_NODE, &neighbor_filter_list_cmd);
19561 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_filter_list_cmd);
19562 install_element(BGP_FLOWSPECV6_NODE, &neighbor_filter_list_cmd);
19563 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_filter_list_cmd);
19564
19565 /* "neighbor route-map" commands. */
19566 install_element(BGP_NODE, &neighbor_route_map_hidden_cmd);
19567 install_element(BGP_NODE, &no_neighbor_route_map_hidden_cmd);
19568 install_element(BGP_IPV4_NODE, &neighbor_route_map_cmd);
19569 install_element(BGP_IPV4_NODE, &no_neighbor_route_map_cmd);
19570 install_element(BGP_IPV4M_NODE, &neighbor_route_map_cmd);
19571 install_element(BGP_IPV4M_NODE, &no_neighbor_route_map_cmd);
19572 install_element(BGP_IPV4L_NODE, &neighbor_route_map_cmd);
19573 install_element(BGP_IPV4L_NODE, &no_neighbor_route_map_cmd);
19574 install_element(BGP_IPV6_NODE, &neighbor_route_map_cmd);
19575 install_element(BGP_IPV6_NODE, &no_neighbor_route_map_cmd);
19576 install_element(BGP_IPV6M_NODE, &neighbor_route_map_cmd);
19577 install_element(BGP_IPV6M_NODE, &no_neighbor_route_map_cmd);
19578 install_element(BGP_IPV6L_NODE, &neighbor_route_map_cmd);
19579 install_element(BGP_IPV6L_NODE, &no_neighbor_route_map_cmd);
19580 install_element(BGP_VPNV4_NODE, &neighbor_route_map_cmd);
19581 install_element(BGP_VPNV4_NODE, &no_neighbor_route_map_cmd);
19582 install_element(BGP_VPNV6_NODE, &neighbor_route_map_cmd);
19583 install_element(BGP_VPNV6_NODE, &no_neighbor_route_map_cmd);
19584 install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_map_cmd);
19585 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_route_map_cmd);
19586 install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_map_cmd);
19587 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_route_map_cmd);
19588 install_element(BGP_EVPN_NODE, &neighbor_route_map_cmd);
19589 install_element(BGP_EVPN_NODE, &no_neighbor_route_map_cmd);
19590
19591 /* "neighbor unsuppress-map" commands. */
19592 install_element(BGP_NODE, &neighbor_unsuppress_map_hidden_cmd);
19593 install_element(BGP_NODE, &no_neighbor_unsuppress_map_hidden_cmd);
19594 install_element(BGP_IPV4_NODE, &neighbor_unsuppress_map_cmd);
19595 install_element(BGP_IPV4_NODE, &no_neighbor_unsuppress_map_cmd);
19596 install_element(BGP_IPV4M_NODE, &neighbor_unsuppress_map_cmd);
19597 install_element(BGP_IPV4M_NODE, &no_neighbor_unsuppress_map_cmd);
19598 install_element(BGP_IPV4L_NODE, &neighbor_unsuppress_map_cmd);
19599 install_element(BGP_IPV4L_NODE, &no_neighbor_unsuppress_map_cmd);
19600 install_element(BGP_IPV6_NODE, &neighbor_unsuppress_map_cmd);
19601 install_element(BGP_IPV6_NODE, &no_neighbor_unsuppress_map_cmd);
19602 install_element(BGP_IPV6M_NODE, &neighbor_unsuppress_map_cmd);
19603 install_element(BGP_IPV6M_NODE, &no_neighbor_unsuppress_map_cmd);
19604 install_element(BGP_IPV6L_NODE, &neighbor_unsuppress_map_cmd);
19605 install_element(BGP_IPV6L_NODE, &no_neighbor_unsuppress_map_cmd);
19606 install_element(BGP_VPNV4_NODE, &neighbor_unsuppress_map_cmd);
19607 install_element(BGP_VPNV4_NODE, &no_neighbor_unsuppress_map_cmd);
19608 install_element(BGP_VPNV6_NODE, &neighbor_unsuppress_map_cmd);
19609 install_element(BGP_VPNV6_NODE, &no_neighbor_unsuppress_map_cmd);
19610
19611 /* "neighbor advertise-map" commands. */
19612 install_element(BGP_NODE, &bgp_condadv_period_cmd);
19613 install_element(BGP_NODE, &neighbor_advertise_map_hidden_cmd);
19614 install_element(BGP_IPV4_NODE, &neighbor_advertise_map_cmd);
19615 install_element(BGP_IPV4M_NODE, &neighbor_advertise_map_cmd);
19616 install_element(BGP_IPV4L_NODE, &neighbor_advertise_map_cmd);
19617 install_element(BGP_IPV6_NODE, &neighbor_advertise_map_cmd);
19618 install_element(BGP_IPV6M_NODE, &neighbor_advertise_map_cmd);
19619 install_element(BGP_IPV6L_NODE, &neighbor_advertise_map_cmd);
19620 install_element(BGP_VPNV4_NODE, &neighbor_advertise_map_cmd);
19621 install_element(BGP_VPNV6_NODE, &neighbor_advertise_map_cmd);
19622
19623 /* neighbor maximum-prefix-out commands. */
19624 install_element(BGP_NODE, &neighbor_maximum_prefix_out_cmd);
19625 install_element(BGP_NODE, &no_neighbor_maximum_prefix_out_cmd);
19626 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_out_cmd);
19627 install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_out_cmd);
19628 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_out_cmd);
19629 install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_out_cmd);
19630 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_out_cmd);
19631 install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_out_cmd);
19632 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_out_cmd);
19633 install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_out_cmd);
19634 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_out_cmd);
19635 install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_out_cmd);
19636 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_out_cmd);
19637 install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_out_cmd);
19638 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_out_cmd);
19639 install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_out_cmd);
19640 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_out_cmd);
19641 install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_out_cmd);
19642
19643 /* "neighbor maximum-prefix" commands. */
19644 install_element(BGP_NODE, &neighbor_maximum_prefix_hidden_cmd);
19645 install_element(BGP_NODE,
19646 &neighbor_maximum_prefix_threshold_hidden_cmd);
19647 install_element(BGP_NODE, &neighbor_maximum_prefix_warning_hidden_cmd);
19648 install_element(BGP_NODE,
19649 &neighbor_maximum_prefix_threshold_warning_hidden_cmd);
19650 install_element(BGP_NODE, &neighbor_maximum_prefix_restart_hidden_cmd);
19651 install_element(BGP_NODE,
19652 &neighbor_maximum_prefix_threshold_restart_hidden_cmd);
19653 install_element(BGP_NODE, &no_neighbor_maximum_prefix_hidden_cmd);
19654 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_cmd);
19655 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
19656 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_warning_cmd);
19657 install_element(BGP_IPV4_NODE,
19658 &neighbor_maximum_prefix_threshold_warning_cmd);
19659 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_restart_cmd);
19660 install_element(BGP_IPV4_NODE,
19661 &neighbor_maximum_prefix_threshold_restart_cmd);
19662 install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_cmd);
19663 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_cmd);
19664 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_cmd);
19665 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_warning_cmd);
19666 install_element(BGP_IPV4M_NODE,
19667 &neighbor_maximum_prefix_threshold_warning_cmd);
19668 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_restart_cmd);
19669 install_element(BGP_IPV4M_NODE,
19670 &neighbor_maximum_prefix_threshold_restart_cmd);
19671 install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_cmd);
19672 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_cmd);
19673 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_threshold_cmd);
19674 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_warning_cmd);
19675 install_element(BGP_IPV4L_NODE,
19676 &neighbor_maximum_prefix_threshold_warning_cmd);
19677 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_restart_cmd);
19678 install_element(BGP_IPV4L_NODE,
19679 &neighbor_maximum_prefix_threshold_restart_cmd);
19680 install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_cmd);
19681 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_cmd);
19682 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
19683 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
19684 install_element(BGP_IPV6_NODE,
19685 &neighbor_maximum_prefix_threshold_warning_cmd);
19686 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
19687 install_element(BGP_IPV6_NODE,
19688 &neighbor_maximum_prefix_threshold_restart_cmd);
19689 install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_cmd);
19690 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_cmd);
19691 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_cmd);
19692 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_warning_cmd);
19693 install_element(BGP_IPV6M_NODE,
19694 &neighbor_maximum_prefix_threshold_warning_cmd);
19695 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_restart_cmd);
19696 install_element(BGP_IPV6M_NODE,
19697 &neighbor_maximum_prefix_threshold_restart_cmd);
19698 install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_cmd);
19699 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_cmd);
19700 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_threshold_cmd);
19701 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_warning_cmd);
19702 install_element(BGP_IPV6L_NODE,
19703 &neighbor_maximum_prefix_threshold_warning_cmd);
19704 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_restart_cmd);
19705 install_element(BGP_IPV6L_NODE,
19706 &neighbor_maximum_prefix_threshold_restart_cmd);
19707 install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_cmd);
19708 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_cmd);
19709 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
19710 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_warning_cmd);
19711 install_element(BGP_VPNV4_NODE,
19712 &neighbor_maximum_prefix_threshold_warning_cmd);
19713 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_restart_cmd);
19714 install_element(BGP_VPNV4_NODE,
19715 &neighbor_maximum_prefix_threshold_restart_cmd);
19716 install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_cmd);
19717 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_cmd);
19718 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
19719 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_warning_cmd);
19720 install_element(BGP_VPNV6_NODE,
19721 &neighbor_maximum_prefix_threshold_warning_cmd);
19722 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_restart_cmd);
19723 install_element(BGP_VPNV6_NODE,
19724 &neighbor_maximum_prefix_threshold_restart_cmd);
19725 install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_cmd);
19726
19727 /* "neighbor allowas-in" */
19728 install_element(BGP_NODE, &neighbor_allowas_in_hidden_cmd);
19729 install_element(BGP_NODE, &no_neighbor_allowas_in_hidden_cmd);
19730 install_element(BGP_IPV4_NODE, &neighbor_allowas_in_cmd);
19731 install_element(BGP_IPV4_NODE, &no_neighbor_allowas_in_cmd);
19732 install_element(BGP_IPV4M_NODE, &neighbor_allowas_in_cmd);
19733 install_element(BGP_IPV4M_NODE, &no_neighbor_allowas_in_cmd);
19734 install_element(BGP_IPV4L_NODE, &neighbor_allowas_in_cmd);
19735 install_element(BGP_IPV4L_NODE, &no_neighbor_allowas_in_cmd);
19736 install_element(BGP_IPV6_NODE, &neighbor_allowas_in_cmd);
19737 install_element(BGP_IPV6_NODE, &no_neighbor_allowas_in_cmd);
19738 install_element(BGP_IPV6M_NODE, &neighbor_allowas_in_cmd);
19739 install_element(BGP_IPV6M_NODE, &no_neighbor_allowas_in_cmd);
19740 install_element(BGP_IPV6L_NODE, &neighbor_allowas_in_cmd);
19741 install_element(BGP_IPV6L_NODE, &no_neighbor_allowas_in_cmd);
19742 install_element(BGP_VPNV4_NODE, &neighbor_allowas_in_cmd);
19743 install_element(BGP_VPNV4_NODE, &no_neighbor_allowas_in_cmd);
19744 install_element(BGP_VPNV6_NODE, &neighbor_allowas_in_cmd);
19745 install_element(BGP_VPNV6_NODE, &no_neighbor_allowas_in_cmd);
19746 install_element(BGP_EVPN_NODE, &neighbor_allowas_in_cmd);
19747 install_element(BGP_EVPN_NODE, &no_neighbor_allowas_in_cmd);
19748
19749 /* neighbor accept-own */
19750 install_element(BGP_VPNV4_NODE, &neighbor_accept_own_cmd);
19751 install_element(BGP_VPNV6_NODE, &neighbor_accept_own_cmd);
19752
19753 /* "neighbor soo" */
19754 install_element(BGP_IPV4_NODE, &neighbor_soo_cmd);
19755 install_element(BGP_IPV4_NODE, &no_neighbor_soo_cmd);
19756 install_element(BGP_IPV4M_NODE, &neighbor_soo_cmd);
19757 install_element(BGP_IPV4M_NODE, &no_neighbor_soo_cmd);
19758 install_element(BGP_IPV4L_NODE, &neighbor_soo_cmd);
19759 install_element(BGP_IPV4L_NODE, &no_neighbor_soo_cmd);
19760 install_element(BGP_IPV6_NODE, &neighbor_soo_cmd);
19761 install_element(BGP_IPV6_NODE, &no_neighbor_soo_cmd);
19762 install_element(BGP_IPV6M_NODE, &neighbor_soo_cmd);
19763 install_element(BGP_IPV6M_NODE, &no_neighbor_soo_cmd);
19764 install_element(BGP_IPV6L_NODE, &neighbor_soo_cmd);
19765 install_element(BGP_IPV6L_NODE, &no_neighbor_soo_cmd);
19766 install_element(BGP_VPNV4_NODE, &neighbor_soo_cmd);
19767 install_element(BGP_VPNV4_NODE, &no_neighbor_soo_cmd);
19768 install_element(BGP_VPNV6_NODE, &neighbor_soo_cmd);
19769 install_element(BGP_VPNV6_NODE, &no_neighbor_soo_cmd);
19770 install_element(BGP_EVPN_NODE, &neighbor_soo_cmd);
19771 install_element(BGP_EVPN_NODE, &no_neighbor_soo_cmd);
19772
19773 /* address-family commands. */
19774 install_element(BGP_NODE, &address_family_ipv4_safi_cmd);
19775 install_element(BGP_NODE, &address_family_ipv6_safi_cmd);
19776 #ifdef KEEP_OLD_VPN_COMMANDS
19777 install_element(BGP_NODE, &address_family_vpnv4_cmd);
19778 install_element(BGP_NODE, &address_family_vpnv6_cmd);
19779 #endif /* KEEP_OLD_VPN_COMMANDS */
19780
19781 install_element(BGP_NODE, &address_family_evpn_cmd);
19782
19783 /* "exit-address-family" command. */
19784 install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
19785 install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
19786 install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
19787 install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
19788 install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
19789 install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
19790 install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
19791 install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
19792 install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
19793 install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
19794 install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
19795
19796 /* BGP retain all route-target */
19797 install_element(BGP_VPNV4_NODE, &bgp_retain_route_target_cmd);
19798 install_element(BGP_VPNV6_NODE, &bgp_retain_route_target_cmd);
19799
19800 /* "clear ip bgp commands" */
19801 install_element(ENABLE_NODE, &clear_ip_bgp_all_cmd);
19802
19803 /* clear ip bgp prefix */
19804 install_element(ENABLE_NODE, &clear_ip_bgp_prefix_cmd);
19805 install_element(ENABLE_NODE, &clear_bgp_ipv6_safi_prefix_cmd);
19806 install_element(ENABLE_NODE, &clear_bgp_instance_ipv6_safi_prefix_cmd);
19807
19808 /* "show [ip] bgp summary" commands. */
19809 install_element(VIEW_NODE, &show_bgp_instance_all_ipv6_updgrps_cmd);
19810 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_updgrps_cmd);
19811 install_element(VIEW_NODE, &show_bgp_instance_updgrps_stats_cmd);
19812 install_element(VIEW_NODE, &show_bgp_updgrps_stats_cmd);
19813 install_element(VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_s_cmd);
19814 install_element(VIEW_NODE, &show_ip_bgp_summary_cmd);
19815 install_element(VIEW_NODE, &show_ip_bgp_updgrps_cmd);
19816
19817 /* "show [ip] bgp neighbors" commands. */
19818 install_element(VIEW_NODE, &show_ip_bgp_neighbors_cmd);
19819
19820 install_element(VIEW_NODE, &show_ip_bgp_neighbors_graceful_restart_cmd);
19821
19822 /* "show [ip] bgp peer-group" commands. */
19823 install_element(VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
19824
19825 /* "show [ip] bgp paths" commands. */
19826 install_element(VIEW_NODE, &show_ip_bgp_paths_cmd);
19827
19828 /* "show [ip] bgp community" commands. */
19829 install_element(VIEW_NODE, &show_ip_bgp_community_info_cmd);
19830
19831 /* "show ip bgp large-community" commands. */
19832 install_element(VIEW_NODE, &show_ip_bgp_lcommunity_info_cmd);
19833 /* "show [ip] bgp attribute-info" commands. */
19834 install_element(VIEW_NODE, &show_ip_bgp_attr_info_cmd);
19835 /* "show [ip] bgp route-leak" command */
19836 install_element(VIEW_NODE, &show_ip_bgp_route_leak_cmd);
19837
19838 /* "redistribute" commands. */
19839 install_element(BGP_NODE, &bgp_redistribute_ipv4_hidden_cmd);
19840 install_element(BGP_NODE, &no_bgp_redistribute_ipv4_hidden_cmd);
19841 install_element(BGP_NODE, &bgp_redistribute_ipv4_rmap_hidden_cmd);
19842 install_element(BGP_NODE, &bgp_redistribute_ipv4_metric_hidden_cmd);
19843 install_element(BGP_NODE,
19844 &bgp_redistribute_ipv4_rmap_metric_hidden_cmd);
19845 install_element(BGP_NODE,
19846 &bgp_redistribute_ipv4_metric_rmap_hidden_cmd);
19847 install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_hidden_cmd);
19848 install_element(BGP_NODE, &no_bgp_redistribute_ipv4_ospf_hidden_cmd);
19849 install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_hidden_cmd);
19850 install_element(BGP_NODE,
19851 &bgp_redistribute_ipv4_ospf_metric_hidden_cmd);
19852 install_element(BGP_NODE,
19853 &bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd);
19854 install_element(BGP_NODE,
19855 &bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd);
19856 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_cmd);
19857 install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_cmd);
19858 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_cmd);
19859 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_cmd);
19860 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
19861 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
19862 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_cmd);
19863 install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
19864 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
19865 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
19866 install_element(BGP_IPV4_NODE,
19867 &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
19868 install_element(BGP_IPV4_NODE,
19869 &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
19870 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_cmd);
19871 install_element(BGP_IPV6_NODE, &no_bgp_redistribute_ipv6_cmd);
19872 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_cmd);
19873 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_cmd);
19874 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_metric_cmd);
19875 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_rmap_cmd);
19876
19877 /* import|export vpn [route-map RMAP_NAME] */
19878 install_element(BGP_IPV4_NODE, &bgp_imexport_vpn_cmd);
19879 install_element(BGP_IPV6_NODE, &bgp_imexport_vpn_cmd);
19880
19881 install_element(BGP_IPV4_NODE, &bgp_imexport_vrf_cmd);
19882 install_element(BGP_IPV6_NODE, &bgp_imexport_vrf_cmd);
19883
19884 /* ttl_security commands */
19885 install_element(BGP_NODE, &neighbor_ttl_security_cmd);
19886 install_element(BGP_NODE, &no_neighbor_ttl_security_cmd);
19887
19888 /* "bgp tcp-keepalive" commands */
19889 install_element(BGP_NODE, &bgp_tcp_keepalive_cmd);
19890 install_element(BGP_NODE, &no_bgp_tcp_keepalive_cmd);
19891
19892 /* "show [ip] bgp memory" commands. */
19893 install_element(VIEW_NODE, &show_bgp_memory_cmd);
19894
19895 /* "show bgp martian next-hop" */
19896 install_element(VIEW_NODE, &show_bgp_martian_nexthop_db_cmd);
19897
19898 install_element(VIEW_NODE, &show_bgp_mac_hash_cmd);
19899
19900 /* "show [ip] bgp views" commands. */
19901 install_element(VIEW_NODE, &show_bgp_views_cmd);
19902
19903 /* "show [ip] bgp vrfs" commands. */
19904 install_element(VIEW_NODE, &show_bgp_vrfs_cmd);
19905
19906 /* Community-list. */
19907 community_list_vty();
19908
19909 community_alias_vty();
19910
19911 /* vpn-policy commands */
19912 install_element(BGP_IPV4_NODE, &af_rd_vpn_export_cmd);
19913 install_element(BGP_IPV6_NODE, &af_rd_vpn_export_cmd);
19914 install_element(BGP_IPV4_NODE, &af_label_vpn_export_cmd);
19915 install_element(BGP_IPV6_NODE, &af_label_vpn_export_cmd);
19916 install_element(BGP_IPV4_NODE, &af_nexthop_vpn_export_cmd);
19917 install_element(BGP_IPV6_NODE, &af_nexthop_vpn_export_cmd);
19918 install_element(BGP_IPV4_NODE, &af_rt_vpn_imexport_cmd);
19919 install_element(BGP_IPV6_NODE, &af_rt_vpn_imexport_cmd);
19920 install_element(BGP_IPV4_NODE, &af_route_map_vpn_imexport_cmd);
19921 install_element(BGP_IPV6_NODE, &af_route_map_vpn_imexport_cmd);
19922 install_element(BGP_IPV4_NODE, &af_import_vrf_route_map_cmd);
19923 install_element(BGP_IPV6_NODE, &af_import_vrf_route_map_cmd);
19924
19925 install_element(BGP_IPV4_NODE, &af_routetarget_import_cmd);
19926 install_element(BGP_IPV6_NODE, &af_routetarget_import_cmd);
19927
19928 install_element(BGP_IPV4_NODE, &af_no_rd_vpn_export_cmd);
19929 install_element(BGP_IPV6_NODE, &af_no_rd_vpn_export_cmd);
19930 install_element(BGP_IPV4_NODE, &af_no_label_vpn_export_cmd);
19931 install_element(BGP_IPV6_NODE, &af_no_label_vpn_export_cmd);
19932 install_element(BGP_IPV4_NODE, &af_no_rt_vpn_imexport_cmd);
19933 install_element(BGP_IPV6_NODE, &af_no_rt_vpn_imexport_cmd);
19934 install_element(BGP_IPV4_NODE, &af_no_route_map_vpn_imexport_cmd);
19935 install_element(BGP_IPV6_NODE, &af_no_route_map_vpn_imexport_cmd);
19936 install_element(BGP_IPV4_NODE, &af_no_import_vrf_route_map_cmd);
19937 install_element(BGP_IPV6_NODE, &af_no_import_vrf_route_map_cmd);
19938
19939 /* tcp-mss command */
19940 install_element(BGP_NODE, &neighbor_tcp_mss_cmd);
19941 install_element(BGP_NODE, &no_neighbor_tcp_mss_cmd);
19942
19943 /* srv6 commands */
19944 install_element(VIEW_NODE, &show_bgp_srv6_cmd);
19945 install_element(BGP_NODE, &bgp_segment_routing_srv6_cmd);
19946 install_element(BGP_NODE, &no_bgp_segment_routing_srv6_cmd);
19947 install_element(BGP_SRV6_NODE, &bgp_srv6_locator_cmd);
19948 install_element(BGP_SRV6_NODE, &no_bgp_srv6_locator_cmd);
19949 install_element(BGP_IPV4_NODE, &af_sid_vpn_export_cmd);
19950 install_element(BGP_IPV6_NODE, &af_sid_vpn_export_cmd);
19951 install_element(BGP_NODE, &bgp_sid_vpn_export_cmd);
19952 install_element(BGP_NODE, &no_bgp_sid_vpn_export_cmd);
19953
19954 bgp_vty_if_init();
19955 }
19956
19957 #include "memory.h"
19958 #include "bgp_regex.h"
19959 #include "bgp_clist.h"
19960 #include "bgp_ecommunity.h"
19961
19962 /* VTY functions. */
19963
19964 /* Direction value to string conversion. */
19965 static const char *community_direct_str(int direct)
19966 {
19967 switch (direct) {
19968 case COMMUNITY_DENY:
19969 return "deny";
19970 case COMMUNITY_PERMIT:
19971 return "permit";
19972 default:
19973 return "unknown";
19974 }
19975 }
19976
19977 /* Display error string. */
19978 static void community_list_perror(struct vty *vty, int ret)
19979 {
19980 switch (ret) {
19981 case COMMUNITY_LIST_ERR_CANT_FIND_LIST:
19982 vty_out(vty, "%% Can't find community-list\n");
19983 break;
19984 case COMMUNITY_LIST_ERR_MALFORMED_VAL:
19985 vty_out(vty, "%% Malformed community-list value\n");
19986 break;
19987 case COMMUNITY_LIST_ERR_STANDARD_CONFLICT:
19988 vty_out(vty,
19989 "%% Community name conflict, previously defined as standard community\n");
19990 break;
19991 case COMMUNITY_LIST_ERR_EXPANDED_CONFLICT:
19992 vty_out(vty,
19993 "%% Community name conflict, previously defined as expanded community\n");
19994 break;
19995 }
19996 }
19997
19998 /* "community-list" keyword help string. */
19999 #define COMMUNITY_LIST_STR "Add a community list entry\n"
20000
20001 /*community-list standard */
20002 DEFUN (community_list_standard,
20003 bgp_community_list_standard_cmd,
20004 "bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20005 BGP_STR
20006 COMMUNITY_LIST_STR
20007 "Community list number (standard)\n"
20008 "Add an standard community-list entry\n"
20009 "Community list name\n"
20010 "Sequence number of an entry\n"
20011 "Sequence number\n"
20012 "Specify community to reject\n"
20013 "Specify community to accept\n"
20014 COMMUNITY_VAL_STR)
20015 {
20016 char *cl_name_or_number = NULL;
20017 char *seq = NULL;
20018 int direct = 0;
20019 int style = COMMUNITY_LIST_STANDARD;
20020 int idx = 0;
20021
20022 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20023 seq = argv[idx]->arg;
20024
20025 idx = 0;
20026 argv_find(argv, argc, "(1-99)", &idx);
20027 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20028 cl_name_or_number = argv[idx]->arg;
20029 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20030 : COMMUNITY_DENY;
20031 argv_find(argv, argc, "AA:NN", &idx);
20032 char *str = argv_concat(argv, argc, idx);
20033
20034 int ret = community_list_set(bgp_clist, cl_name_or_number, str, seq,
20035 direct, style);
20036
20037 XFREE(MTYPE_TMP, str);
20038
20039 if (ret < 0) {
20040 /* Display error string. */
20041 community_list_perror(vty, ret);
20042 return CMD_WARNING_CONFIG_FAILED;
20043 }
20044
20045 return CMD_SUCCESS;
20046 }
20047
20048 DEFUN (no_community_list_standard_all,
20049 no_bgp_community_list_standard_all_cmd,
20050 "no bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20051 NO_STR
20052 BGP_STR
20053 COMMUNITY_LIST_STR
20054 "Community list number (standard)\n"
20055 "Add an standard community-list entry\n"
20056 "Community list name\n"
20057 "Sequence number of an entry\n"
20058 "Sequence number\n"
20059 "Specify community to reject\n"
20060 "Specify community to accept\n"
20061 COMMUNITY_VAL_STR)
20062 {
20063 char *cl_name_or_number = NULL;
20064 char *str = NULL;
20065 int direct = 0;
20066 int style = COMMUNITY_LIST_STANDARD;
20067 char *seq = NULL;
20068 int idx = 0;
20069
20070 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20071 seq = argv[idx]->arg;
20072
20073 idx = 0;
20074 argv_find(argv, argc, "permit", &idx);
20075 argv_find(argv, argc, "deny", &idx);
20076
20077 if (idx) {
20078 direct = argv_find(argv, argc, "permit", &idx)
20079 ? COMMUNITY_PERMIT
20080 : COMMUNITY_DENY;
20081
20082 idx = 0;
20083 argv_find(argv, argc, "AA:NN", &idx);
20084 str = argv_concat(argv, argc, idx);
20085 }
20086
20087 idx = 0;
20088 argv_find(argv, argc, "(1-99)", &idx);
20089 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20090 cl_name_or_number = argv[idx]->arg;
20091
20092 int ret = community_list_unset(bgp_clist, cl_name_or_number, str, seq,
20093 direct, style);
20094
20095 XFREE(MTYPE_TMP, str);
20096
20097 if (ret < 0) {
20098 community_list_perror(vty, ret);
20099 return CMD_WARNING_CONFIG_FAILED;
20100 }
20101
20102 return CMD_SUCCESS;
20103 }
20104
20105 ALIAS(no_community_list_standard_all, no_bgp_community_list_standard_all_list_cmd,
20106 "no bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME>",
20107 NO_STR BGP_STR COMMUNITY_LIST_STR
20108 "Community list number (standard)\n"
20109 "Add an standard community-list entry\n"
20110 "Community list name\n")
20111
20112 /*community-list expanded */
20113 DEFUN (community_list_expanded_all,
20114 bgp_community_list_expanded_all_cmd,
20115 "bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20116 BGP_STR
20117 COMMUNITY_LIST_STR
20118 "Community list number (expanded)\n"
20119 "Add an expanded community-list entry\n"
20120 "Community list name\n"
20121 "Sequence number of an entry\n"
20122 "Sequence number\n"
20123 "Specify community to reject\n"
20124 "Specify community to accept\n"
20125 COMMUNITY_VAL_STR)
20126 {
20127 char *cl_name_or_number = NULL;
20128 char *seq = NULL;
20129 int direct = 0;
20130 int style = COMMUNITY_LIST_EXPANDED;
20131 int idx = 0;
20132
20133 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20134 seq = argv[idx]->arg;
20135
20136 idx = 0;
20137
20138 argv_find(argv, argc, "(100-500)", &idx);
20139 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20140 cl_name_or_number = argv[idx]->arg;
20141 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20142 : COMMUNITY_DENY;
20143 argv_find(argv, argc, "AA:NN", &idx);
20144 char *str = argv_concat(argv, argc, idx);
20145
20146 int ret = community_list_set(bgp_clist, cl_name_or_number, str, seq,
20147 direct, style);
20148
20149 XFREE(MTYPE_TMP, str);
20150
20151 if (ret < 0) {
20152 /* Display error string. */
20153 community_list_perror(vty, ret);
20154 return CMD_WARNING_CONFIG_FAILED;
20155 }
20156
20157 return CMD_SUCCESS;
20158 }
20159
20160 DEFUN (no_community_list_expanded_all,
20161 no_bgp_community_list_expanded_all_cmd,
20162 "no bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20163 NO_STR
20164 BGP_STR
20165 COMMUNITY_LIST_STR
20166 "Community list number (expanded)\n"
20167 "Add an expanded community-list entry\n"
20168 "Community list name\n"
20169 "Sequence number of an entry\n"
20170 "Sequence number\n"
20171 "Specify community to reject\n"
20172 "Specify community to accept\n"
20173 COMMUNITY_VAL_STR)
20174 {
20175 char *cl_name_or_number = NULL;
20176 char *seq = NULL;
20177 char *str = NULL;
20178 int direct = 0;
20179 int style = COMMUNITY_LIST_EXPANDED;
20180 int idx = 0;
20181
20182 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20183 seq = argv[idx]->arg;
20184
20185 idx = 0;
20186 argv_find(argv, argc, "permit", &idx);
20187 argv_find(argv, argc, "deny", &idx);
20188
20189 if (idx) {
20190 direct = argv_find(argv, argc, "permit", &idx)
20191 ? COMMUNITY_PERMIT
20192 : COMMUNITY_DENY;
20193
20194 idx = 0;
20195 argv_find(argv, argc, "AA:NN", &idx);
20196 str = argv_concat(argv, argc, idx);
20197 }
20198
20199 idx = 0;
20200 argv_find(argv, argc, "(100-500)", &idx);
20201 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20202 cl_name_or_number = argv[idx]->arg;
20203
20204 int ret = community_list_unset(bgp_clist, cl_name_or_number, str, seq,
20205 direct, style);
20206
20207 XFREE(MTYPE_TMP, str);
20208
20209 if (ret < 0) {
20210 community_list_perror(vty, ret);
20211 return CMD_WARNING_CONFIG_FAILED;
20212 }
20213
20214 return CMD_SUCCESS;
20215 }
20216
20217 ALIAS(no_community_list_expanded_all,
20218 no_bgp_community_list_expanded_all_list_cmd,
20219 "no bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME>",
20220 NO_STR BGP_STR COMMUNITY_LIST_STR
20221 "Community list number (expanded)\n"
20222 "Add an expanded community-list entry\n"
20223 "Community list name\n")
20224
20225 /* Return configuration string of community-list entry. */
20226 static const char *community_list_config_str(struct community_entry *entry)
20227 {
20228 const char *str;
20229
20230 if (entry->any)
20231 str = "";
20232 else {
20233 if (entry->style == COMMUNITY_LIST_STANDARD)
20234 str = community_str(entry->u.com, false, false);
20235 else if (entry->style == LARGE_COMMUNITY_LIST_STANDARD)
20236 str = lcommunity_str(entry->u.lcom, false, false);
20237 else
20238 str = entry->config;
20239 }
20240 return str;
20241 }
20242
20243 static void community_list_show(struct vty *vty, struct community_list *list)
20244 {
20245 struct community_entry *entry;
20246
20247 for (entry = list->head; entry; entry = entry->next) {
20248 if (entry == list->head) {
20249 if (all_digit(list->name))
20250 vty_out(vty, "Community %s list %s\n",
20251 entry->style == COMMUNITY_LIST_STANDARD
20252 ? "standard"
20253 : "(expanded) access",
20254 list->name);
20255 else
20256 vty_out(vty, "Named Community %s list %s\n",
20257 entry->style == COMMUNITY_LIST_STANDARD
20258 ? "standard"
20259 : "expanded",
20260 list->name);
20261 }
20262 if (entry->any)
20263 vty_out(vty, " %s\n",
20264 community_direct_str(entry->direct));
20265 else
20266 vty_out(vty, " %s %s\n",
20267 community_direct_str(entry->direct),
20268 community_list_config_str(entry));
20269 }
20270 }
20271
20272 DEFUN (show_community_list,
20273 show_bgp_community_list_cmd,
20274 "show bgp community-list",
20275 SHOW_STR
20276 BGP_STR
20277 "List community-list\n")
20278 {
20279 struct community_list *list;
20280 struct community_list_master *cm;
20281
20282 cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
20283 if (!cm)
20284 return CMD_SUCCESS;
20285
20286 for (list = cm->num.head; list; list = list->next)
20287 community_list_show(vty, list);
20288
20289 for (list = cm->str.head; list; list = list->next)
20290 community_list_show(vty, list);
20291
20292 return CMD_SUCCESS;
20293 }
20294
20295 DEFUN (show_community_list_arg,
20296 show_bgp_community_list_arg_cmd,
20297 "show bgp community-list <(1-500)|COMMUNITY_LIST_NAME> detail",
20298 SHOW_STR
20299 BGP_STR
20300 "List community-list\n"
20301 "Community-list number\n"
20302 "Community-list name\n"
20303 "Detailed information on community-list\n")
20304 {
20305 int idx_comm_list = 3;
20306 struct community_list *list;
20307
20308 list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
20309 COMMUNITY_LIST_MASTER);
20310 if (!list) {
20311 vty_out(vty, "%% Can't find community-list\n");
20312 return CMD_WARNING;
20313 }
20314
20315 community_list_show(vty, list);
20316
20317 return CMD_SUCCESS;
20318 }
20319
20320 /*
20321 * Large Community code.
20322 */
20323 static int lcommunity_list_set_vty(struct vty *vty, int argc,
20324 struct cmd_token **argv, int style,
20325 int reject_all_digit_name)
20326 {
20327 int ret;
20328 int direct;
20329 char *str;
20330 int idx = 0;
20331 char *cl_name;
20332 char *seq = NULL;
20333
20334 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20335 seq = argv[idx]->arg;
20336
20337 idx = 0;
20338 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20339 : COMMUNITY_DENY;
20340
20341 /* All digit name check. */
20342 idx = 0;
20343 argv_find(argv, argc, "LCOMMUNITY_LIST_NAME", &idx);
20344 argv_find(argv, argc, "(1-99)", &idx);
20345 argv_find(argv, argc, "(100-500)", &idx);
20346 cl_name = argv[idx]->arg;
20347 if (reject_all_digit_name && all_digit(cl_name)) {
20348 vty_out(vty, "%% Community name cannot have all digits\n");
20349 return CMD_WARNING_CONFIG_FAILED;
20350 }
20351
20352 idx = 0;
20353 argv_find(argv, argc, "AA:BB:CC", &idx);
20354 argv_find(argv, argc, "LINE", &idx);
20355 /* Concat community string argument. */
20356 if (idx)
20357 str = argv_concat(argv, argc, idx);
20358 else
20359 str = NULL;
20360
20361 ret = lcommunity_list_set(bgp_clist, cl_name, str, seq, direct, style);
20362
20363 /* Free temporary community list string allocated by
20364 argv_concat(). */
20365 XFREE(MTYPE_TMP, str);
20366
20367 if (ret < 0) {
20368 community_list_perror(vty, ret);
20369 return CMD_WARNING_CONFIG_FAILED;
20370 }
20371 return CMD_SUCCESS;
20372 }
20373
20374 static int lcommunity_list_unset_vty(struct vty *vty, int argc,
20375 struct cmd_token **argv, int style)
20376 {
20377 int ret;
20378 int direct = 0;
20379 char *str = NULL;
20380 int idx = 0;
20381 char *seq = NULL;
20382
20383 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20384 seq = argv[idx]->arg;
20385
20386 idx = 0;
20387 argv_find(argv, argc, "permit", &idx);
20388 argv_find(argv, argc, "deny", &idx);
20389
20390 if (idx) {
20391 /* Check the list direct. */
20392 if (strncmp(argv[idx]->arg, "p", 1) == 0)
20393 direct = COMMUNITY_PERMIT;
20394 else
20395 direct = COMMUNITY_DENY;
20396
20397 idx = 0;
20398 argv_find(argv, argc, "LINE", &idx);
20399 argv_find(argv, argc, "AA:AA:NN", &idx);
20400 /* Concat community string argument. */
20401 str = argv_concat(argv, argc, idx);
20402 }
20403
20404 idx = 0;
20405 argv_find(argv, argc, "(1-99)", &idx);
20406 argv_find(argv, argc, "(100-500)", &idx);
20407 argv_find(argv, argc, "LCOMMUNITY_LIST_NAME", &idx);
20408
20409 /* Unset community list. */
20410 ret = lcommunity_list_unset(bgp_clist, argv[idx]->arg, str, seq, direct,
20411 style);
20412
20413 /* Free temporary community list string allocated by
20414 argv_concat(). */
20415 XFREE(MTYPE_TMP, str);
20416
20417 if (ret < 0) {
20418 community_list_perror(vty, ret);
20419 return CMD_WARNING_CONFIG_FAILED;
20420 }
20421
20422 return CMD_SUCCESS;
20423 }
20424
20425 /* "large-community-list" keyword help string. */
20426 #define LCOMMUNITY_LIST_STR "Add a large community list entry\n"
20427 #define LCOMMUNITY_VAL_STR "large community in 'aa:bb:cc' format\n"
20428
20429 DEFUN (lcommunity_list_standard,
20430 bgp_lcommunity_list_standard_cmd,
20431 "bgp large-community-list (1-99) [seq (0-4294967295)] <deny|permit> AA:BB:CC...",
20432 BGP_STR
20433 LCOMMUNITY_LIST_STR
20434 "Large Community list number (standard)\n"
20435 "Sequence number of an entry\n"
20436 "Sequence number\n"
20437 "Specify large community to reject\n"
20438 "Specify large community to accept\n"
20439 LCOMMUNITY_VAL_STR)
20440 {
20441 return lcommunity_list_set_vty(vty, argc, argv,
20442 LARGE_COMMUNITY_LIST_STANDARD, 0);
20443 }
20444
20445 DEFUN (lcommunity_list_expanded,
20446 bgp_lcommunity_list_expanded_cmd,
20447 "bgp large-community-list (100-500) [seq (0-4294967295)] <deny|permit> LINE...",
20448 BGP_STR
20449 LCOMMUNITY_LIST_STR
20450 "Large Community list number (expanded)\n"
20451 "Sequence number of an entry\n"
20452 "Sequence number\n"
20453 "Specify large community to reject\n"
20454 "Specify large community to accept\n"
20455 "An ordered list as a regular-expression\n")
20456 {
20457 return lcommunity_list_set_vty(vty, argc, argv,
20458 LARGE_COMMUNITY_LIST_EXPANDED, 0);
20459 }
20460
20461 DEFUN (lcommunity_list_name_standard,
20462 bgp_lcommunity_list_name_standard_cmd,
20463 "bgp large-community-list standard LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> AA:BB:CC...",
20464 BGP_STR
20465 LCOMMUNITY_LIST_STR
20466 "Specify standard large-community-list\n"
20467 "Large Community list name\n"
20468 "Sequence number of an entry\n"
20469 "Sequence number\n"
20470 "Specify large community to reject\n"
20471 "Specify large community to accept\n"
20472 LCOMMUNITY_VAL_STR)
20473 {
20474 return lcommunity_list_set_vty(vty, argc, argv,
20475 LARGE_COMMUNITY_LIST_STANDARD, 1);
20476 }
20477
20478 DEFUN (lcommunity_list_name_expanded,
20479 bgp_lcommunity_list_name_expanded_cmd,
20480 "bgp large-community-list expanded LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> LINE...",
20481 BGP_STR
20482 LCOMMUNITY_LIST_STR
20483 "Specify expanded large-community-list\n"
20484 "Large Community list name\n"
20485 "Sequence number of an entry\n"
20486 "Sequence number\n"
20487 "Specify large community to reject\n"
20488 "Specify large community to accept\n"
20489 "An ordered list as a regular-expression\n")
20490 {
20491 return lcommunity_list_set_vty(vty, argc, argv,
20492 LARGE_COMMUNITY_LIST_EXPANDED, 1);
20493 }
20494
20495 DEFUN (no_lcommunity_list_all,
20496 no_bgp_lcommunity_list_all_cmd,
20497 "no bgp large-community-list <(1-99)|(100-500)|LCOMMUNITY_LIST_NAME>",
20498 NO_STR
20499 BGP_STR
20500 LCOMMUNITY_LIST_STR
20501 "Large Community list number (standard)\n"
20502 "Large Community list number (expanded)\n"
20503 "Large Community list name\n")
20504 {
20505 return lcommunity_list_unset_vty(vty, argc, argv,
20506 LARGE_COMMUNITY_LIST_STANDARD);
20507 }
20508
20509 DEFUN (no_lcommunity_list_name_standard_all,
20510 no_bgp_lcommunity_list_name_standard_all_cmd,
20511 "no bgp large-community-list standard LCOMMUNITY_LIST_NAME",
20512 NO_STR
20513 BGP_STR
20514 LCOMMUNITY_LIST_STR
20515 "Specify standard large-community-list\n"
20516 "Large Community list name\n")
20517 {
20518 return lcommunity_list_unset_vty(vty, argc, argv,
20519 LARGE_COMMUNITY_LIST_STANDARD);
20520 }
20521
20522 DEFUN (no_lcommunity_list_name_expanded_all,
20523 no_bgp_lcommunity_list_name_expanded_all_cmd,
20524 "no bgp large-community-list expanded LCOMMUNITY_LIST_NAME",
20525 NO_STR
20526 BGP_STR
20527 LCOMMUNITY_LIST_STR
20528 "Specify expanded large-community-list\n"
20529 "Large Community list name\n")
20530 {
20531 return lcommunity_list_unset_vty(vty, argc, argv,
20532 LARGE_COMMUNITY_LIST_EXPANDED);
20533 }
20534
20535 DEFUN (no_lcommunity_list_standard,
20536 no_bgp_lcommunity_list_standard_cmd,
20537 "no bgp large-community-list (1-99) [seq (0-4294967295)] <deny|permit> AA:AA:NN...",
20538 NO_STR
20539 BGP_STR
20540 LCOMMUNITY_LIST_STR
20541 "Large Community list number (standard)\n"
20542 "Sequence number of an entry\n"
20543 "Sequence number\n"
20544 "Specify large community to reject\n"
20545 "Specify large community to accept\n"
20546 LCOMMUNITY_VAL_STR)
20547 {
20548 return lcommunity_list_unset_vty(vty, argc, argv,
20549 LARGE_COMMUNITY_LIST_STANDARD);
20550 }
20551
20552 DEFUN (no_lcommunity_list_expanded,
20553 no_bgp_lcommunity_list_expanded_cmd,
20554 "no bgp large-community-list (100-500) [seq (0-4294967295)] <deny|permit> LINE...",
20555 NO_STR
20556 BGP_STR
20557 LCOMMUNITY_LIST_STR
20558 "Large Community list number (expanded)\n"
20559 "Sequence number of an entry\n"
20560 "Sequence number\n"
20561 "Specify large community to reject\n"
20562 "Specify large community to accept\n"
20563 "An ordered list as a regular-expression\n")
20564 {
20565 return lcommunity_list_unset_vty(vty, argc, argv,
20566 LARGE_COMMUNITY_LIST_EXPANDED);
20567 }
20568
20569 DEFUN (no_lcommunity_list_name_standard,
20570 no_bgp_lcommunity_list_name_standard_cmd,
20571 "no bgp large-community-list standard LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> AA:AA:NN...",
20572 NO_STR
20573 BGP_STR
20574 LCOMMUNITY_LIST_STR
20575 "Specify standard large-community-list\n"
20576 "Large Community list name\n"
20577 "Sequence number of an entry\n"
20578 "Sequence number\n"
20579 "Specify large community to reject\n"
20580 "Specify large community to accept\n"
20581 LCOMMUNITY_VAL_STR)
20582 {
20583 return lcommunity_list_unset_vty(vty, argc, argv,
20584 LARGE_COMMUNITY_LIST_STANDARD);
20585 }
20586
20587 DEFUN (no_lcommunity_list_name_expanded,
20588 no_bgp_lcommunity_list_name_expanded_cmd,
20589 "no bgp large-community-list expanded LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> LINE...",
20590 NO_STR
20591 BGP_STR
20592 LCOMMUNITY_LIST_STR
20593 "Specify expanded large-community-list\n"
20594 "Large community list name\n"
20595 "Sequence number of an entry\n"
20596 "Sequence number\n"
20597 "Specify large community to reject\n"
20598 "Specify large community to accept\n"
20599 "An ordered list as a regular-expression\n")
20600 {
20601 return lcommunity_list_unset_vty(vty, argc, argv,
20602 LARGE_COMMUNITY_LIST_EXPANDED);
20603 }
20604
20605 static void lcommunity_list_show(struct vty *vty, struct community_list *list)
20606 {
20607 struct community_entry *entry;
20608
20609 for (entry = list->head; entry; entry = entry->next) {
20610 if (entry == list->head) {
20611 if (all_digit(list->name))
20612 vty_out(vty, "Large community %s list %s\n",
20613 entry->style ==
20614 LARGE_COMMUNITY_LIST_STANDARD
20615 ? "standard"
20616 : "(expanded) access",
20617 list->name);
20618 else
20619 vty_out(vty,
20620 "Named large community %s list %s\n",
20621 entry->style ==
20622 LARGE_COMMUNITY_LIST_STANDARD
20623 ? "standard"
20624 : "expanded",
20625 list->name);
20626 }
20627 if (entry->any)
20628 vty_out(vty, " %s\n",
20629 community_direct_str(entry->direct));
20630 else
20631 vty_out(vty, " %s %s\n",
20632 community_direct_str(entry->direct),
20633 community_list_config_str(entry));
20634 }
20635 }
20636
20637 DEFUN (show_lcommunity_list,
20638 show_bgp_lcommunity_list_cmd,
20639 "show bgp large-community-list",
20640 SHOW_STR
20641 BGP_STR
20642 "List large-community list\n")
20643 {
20644 struct community_list *list;
20645 struct community_list_master *cm;
20646
20647 cm = community_list_master_lookup(bgp_clist,
20648 LARGE_COMMUNITY_LIST_MASTER);
20649 if (!cm)
20650 return CMD_SUCCESS;
20651
20652 for (list = cm->num.head; list; list = list->next)
20653 lcommunity_list_show(vty, list);
20654
20655 for (list = cm->str.head; list; list = list->next)
20656 lcommunity_list_show(vty, list);
20657
20658 return CMD_SUCCESS;
20659 }
20660
20661 DEFUN (show_lcommunity_list_arg,
20662 show_bgp_lcommunity_list_arg_cmd,
20663 "show bgp large-community-list <(1-500)|LCOMMUNITY_LIST_NAME> detail",
20664 SHOW_STR
20665 BGP_STR
20666 "List large-community list\n"
20667 "Large-community-list number\n"
20668 "Large-community-list name\n"
20669 "Detailed information on large-community-list\n")
20670 {
20671 struct community_list *list;
20672
20673 list = community_list_lookup(bgp_clist, argv[3]->arg, 0,
20674 LARGE_COMMUNITY_LIST_MASTER);
20675 if (!list) {
20676 vty_out(vty, "%% Can't find large-community-list\n");
20677 return CMD_WARNING;
20678 }
20679
20680 lcommunity_list_show(vty, list);
20681
20682 return CMD_SUCCESS;
20683 }
20684
20685 /* "extcommunity-list" keyword help string. */
20686 #define EXTCOMMUNITY_LIST_STR "Add a extended community list entry\n"
20687 #define EXTCOMMUNITY_VAL_STR "Extended community attribute in 'rt aa:nn_or_IPaddr:nn' OR 'soo aa:nn_or_IPaddr:nn' format\n"
20688
20689 DEFUN (extcommunity_list_standard,
20690 bgp_extcommunity_list_standard_cmd,
20691 "bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20692 BGP_STR
20693 EXTCOMMUNITY_LIST_STR
20694 "Extended Community list number (standard)\n"
20695 "Specify standard extcommunity-list\n"
20696 "Community list name\n"
20697 "Sequence number of an entry\n"
20698 "Sequence number\n"
20699 "Specify community to reject\n"
20700 "Specify community to accept\n"
20701 EXTCOMMUNITY_VAL_STR)
20702 {
20703 int style = EXTCOMMUNITY_LIST_STANDARD;
20704 int direct = 0;
20705 char *cl_number_or_name = NULL;
20706 char *seq = NULL;
20707
20708 int idx = 0;
20709
20710 argv_find(argv, argc, "(1-99)", &idx);
20711 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
20712 cl_number_or_name = argv[idx]->arg;
20713
20714 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20715 seq = argv[idx]->arg;
20716
20717 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20718 : COMMUNITY_DENY;
20719 argv_find(argv, argc, "AA:NN", &idx);
20720 char *str = argv_concat(argv, argc, idx);
20721
20722 int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str, seq,
20723 direct, style);
20724
20725 XFREE(MTYPE_TMP, str);
20726
20727 if (ret < 0) {
20728 community_list_perror(vty, ret);
20729 return CMD_WARNING_CONFIG_FAILED;
20730 }
20731
20732 return CMD_SUCCESS;
20733 }
20734
20735 DEFUN (extcommunity_list_name_expanded,
20736 bgp_extcommunity_list_name_expanded_cmd,
20737 "bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> LINE...",
20738 BGP_STR
20739 EXTCOMMUNITY_LIST_STR
20740 "Extended Community list number (expanded)\n"
20741 "Specify expanded extcommunity-list\n"
20742 "Extended Community list name\n"
20743 "Sequence number of an entry\n"
20744 "Sequence number\n"
20745 "Specify community to reject\n"
20746 "Specify community to accept\n"
20747 "An ordered list as a regular-expression\n")
20748 {
20749 int style = EXTCOMMUNITY_LIST_EXPANDED;
20750 int direct = 0;
20751 char *cl_number_or_name = NULL;
20752 char *seq = NULL;
20753 int idx = 0;
20754
20755 argv_find(argv, argc, "(100-500)", &idx);
20756 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
20757 cl_number_or_name = argv[idx]->arg;
20758
20759 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20760 seq = argv[idx]->arg;
20761
20762 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20763 : COMMUNITY_DENY;
20764 argv_find(argv, argc, "LINE", &idx);
20765 char *str = argv_concat(argv, argc, idx);
20766
20767 int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str, seq,
20768 direct, style);
20769
20770 XFREE(MTYPE_TMP, str);
20771
20772 if (ret < 0) {
20773 community_list_perror(vty, ret);
20774 return CMD_WARNING_CONFIG_FAILED;
20775 }
20776
20777 return CMD_SUCCESS;
20778 }
20779
20780 DEFUN (no_extcommunity_list_standard_all,
20781 no_bgp_extcommunity_list_standard_all_cmd,
20782 "no bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20783 NO_STR
20784 BGP_STR
20785 EXTCOMMUNITY_LIST_STR
20786 "Extended Community list number (standard)\n"
20787 "Specify standard extcommunity-list\n"
20788 "Community list name\n"
20789 "Sequence number of an entry\n"
20790 "Sequence number\n"
20791 "Specify community to reject\n"
20792 "Specify community to accept\n"
20793 EXTCOMMUNITY_VAL_STR)
20794 {
20795 int style = EXTCOMMUNITY_LIST_STANDARD;
20796 int direct = 0;
20797 char *cl_number_or_name = NULL;
20798 char *str = NULL;
20799 char *seq = NULL;
20800 int idx = 0;
20801
20802 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20803 seq = argv[idx]->arg;
20804
20805 idx = 0;
20806 argv_find(argv, argc, "permit", &idx);
20807 argv_find(argv, argc, "deny", &idx);
20808 if (idx) {
20809 direct = argv_find(argv, argc, "permit", &idx)
20810 ? COMMUNITY_PERMIT
20811 : COMMUNITY_DENY;
20812
20813 idx = 0;
20814 argv_find(argv, argc, "AA:NN", &idx);
20815 str = argv_concat(argv, argc, idx);
20816 }
20817
20818 idx = 0;
20819 argv_find(argv, argc, "(1-99)", &idx);
20820 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
20821 cl_number_or_name = argv[idx]->arg;
20822
20823 int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
20824 seq, direct, style);
20825
20826 XFREE(MTYPE_TMP, str);
20827
20828 if (ret < 0) {
20829 community_list_perror(vty, ret);
20830 return CMD_WARNING_CONFIG_FAILED;
20831 }
20832
20833 return CMD_SUCCESS;
20834 }
20835
20836 ALIAS(no_extcommunity_list_standard_all,
20837 no_bgp_extcommunity_list_standard_all_list_cmd,
20838 "no bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME>",
20839 NO_STR BGP_STR EXTCOMMUNITY_LIST_STR
20840 "Extended Community list number (standard)\n"
20841 "Specify standard extcommunity-list\n"
20842 "Community list name\n")
20843
20844 DEFUN (no_extcommunity_list_expanded_all,
20845 no_bgp_extcommunity_list_expanded_all_cmd,
20846 "no bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> LINE...",
20847 NO_STR
20848 BGP_STR
20849 EXTCOMMUNITY_LIST_STR
20850 "Extended Community list number (expanded)\n"
20851 "Specify expanded extcommunity-list\n"
20852 "Extended Community list name\n"
20853 "Sequence number of an entry\n"
20854 "Sequence number\n"
20855 "Specify community to reject\n"
20856 "Specify community to accept\n"
20857 "An ordered list as a regular-expression\n")
20858 {
20859 int style = EXTCOMMUNITY_LIST_EXPANDED;
20860 int direct = 0;
20861 char *cl_number_or_name = NULL;
20862 char *str = NULL;
20863 char *seq = NULL;
20864 int idx = 0;
20865
20866 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20867 seq = argv[idx]->arg;
20868
20869 idx = 0;
20870 argv_find(argv, argc, "permit", &idx);
20871 argv_find(argv, argc, "deny", &idx);
20872
20873 if (idx) {
20874 direct = argv_find(argv, argc, "permit", &idx)
20875 ? COMMUNITY_PERMIT
20876 : COMMUNITY_DENY;
20877
20878 idx = 0;
20879 argv_find(argv, argc, "LINE", &idx);
20880 str = argv_concat(argv, argc, idx);
20881 }
20882
20883 idx = 0;
20884 argv_find(argv, argc, "(100-500)", &idx);
20885 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
20886 cl_number_or_name = argv[idx]->arg;
20887
20888 int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
20889 seq, direct, style);
20890
20891 XFREE(MTYPE_TMP, str);
20892
20893 if (ret < 0) {
20894 community_list_perror(vty, ret);
20895 return CMD_WARNING_CONFIG_FAILED;
20896 }
20897
20898 return CMD_SUCCESS;
20899 }
20900
20901 ALIAS(no_extcommunity_list_expanded_all,
20902 no_bgp_extcommunity_list_expanded_all_list_cmd,
20903 "no bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME>",
20904 NO_STR BGP_STR EXTCOMMUNITY_LIST_STR
20905 "Extended Community list number (expanded)\n"
20906 "Specify expanded extcommunity-list\n"
20907 "Extended Community list name\n")
20908
20909 static void extcommunity_list_show(struct vty *vty, struct community_list *list)
20910 {
20911 struct community_entry *entry;
20912
20913 for (entry = list->head; entry; entry = entry->next) {
20914 if (entry == list->head) {
20915 if (all_digit(list->name))
20916 vty_out(vty, "Extended community %s list %s\n",
20917 entry->style == EXTCOMMUNITY_LIST_STANDARD
20918 ? "standard"
20919 : "(expanded) access",
20920 list->name);
20921 else
20922 vty_out(vty,
20923 "Named extended community %s list %s\n",
20924 entry->style == EXTCOMMUNITY_LIST_STANDARD
20925 ? "standard"
20926 : "expanded",
20927 list->name);
20928 }
20929 if (entry->any)
20930 vty_out(vty, " %s\n",
20931 community_direct_str(entry->direct));
20932 else
20933 vty_out(vty, " %s %s\n",
20934 community_direct_str(entry->direct),
20935 community_list_config_str(entry));
20936 }
20937 }
20938
20939 DEFUN (show_extcommunity_list,
20940 show_bgp_extcommunity_list_cmd,
20941 "show bgp extcommunity-list",
20942 SHOW_STR
20943 BGP_STR
20944 "List extended-community list\n")
20945 {
20946 struct community_list *list;
20947 struct community_list_master *cm;
20948
20949 cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
20950 if (!cm)
20951 return CMD_SUCCESS;
20952
20953 for (list = cm->num.head; list; list = list->next)
20954 extcommunity_list_show(vty, list);
20955
20956 for (list = cm->str.head; list; list = list->next)
20957 extcommunity_list_show(vty, list);
20958
20959 return CMD_SUCCESS;
20960 }
20961
20962 DEFUN (show_extcommunity_list_arg,
20963 show_bgp_extcommunity_list_arg_cmd,
20964 "show bgp extcommunity-list <(1-500)|EXTCOMMUNITY_LIST_NAME> detail",
20965 SHOW_STR
20966 BGP_STR
20967 "List extended-community list\n"
20968 "Extcommunity-list number\n"
20969 "Extcommunity-list name\n"
20970 "Detailed information on extcommunity-list\n")
20971 {
20972 int idx_comm_list = 3;
20973 struct community_list *list;
20974
20975 list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
20976 EXTCOMMUNITY_LIST_MASTER);
20977 if (!list) {
20978 vty_out(vty, "%% Can't find extcommunity-list\n");
20979 return CMD_WARNING;
20980 }
20981
20982 extcommunity_list_show(vty, list);
20983
20984 return CMD_SUCCESS;
20985 }
20986
20987 /* Display community-list and extcommunity-list configuration. */
20988 static int community_list_config_write(struct vty *vty)
20989 {
20990 struct community_list *list;
20991 struct community_entry *entry;
20992 struct community_list_master *cm;
20993 int write = 0;
20994
20995 /* Community-list. */
20996 cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
20997
20998 for (list = cm->num.head; list; list = list->next)
20999 for (entry = list->head; entry; entry = entry->next) {
21000 vty_out(vty,
21001 "bgp community-list %s seq %" PRId64 " %s %s\n",
21002 list->name, entry->seq,
21003 community_direct_str(entry->direct),
21004 community_list_config_str(entry));
21005 write++;
21006 }
21007 for (list = cm->str.head; list; list = list->next)
21008 for (entry = list->head; entry; entry = entry->next) {
21009 vty_out(vty,
21010 "bgp community-list %s %s seq %" PRId64 " %s %s\n",
21011 entry->style == COMMUNITY_LIST_STANDARD
21012 ? "standard"
21013 : "expanded",
21014 list->name, entry->seq,
21015 community_direct_str(entry->direct),
21016 community_list_config_str(entry));
21017 write++;
21018 }
21019
21020 /* Extcommunity-list. */
21021 cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
21022
21023 for (list = cm->num.head; list; list = list->next)
21024 for (entry = list->head; entry; entry = entry->next) {
21025 vty_out(vty,
21026 "bgp extcommunity-list %s seq %" PRId64 " %s %s\n",
21027 list->name, entry->seq,
21028 community_direct_str(entry->direct),
21029 community_list_config_str(entry));
21030 write++;
21031 }
21032 for (list = cm->str.head; list; list = list->next)
21033 for (entry = list->head; entry; entry = entry->next) {
21034 vty_out(vty,
21035 "bgp extcommunity-list %s %s seq %" PRId64" %s %s\n",
21036 entry->style == EXTCOMMUNITY_LIST_STANDARD
21037 ? "standard"
21038 : "expanded",
21039 list->name, entry->seq,
21040 community_direct_str(entry->direct),
21041 community_list_config_str(entry));
21042 write++;
21043 }
21044
21045
21046 /* lcommunity-list. */
21047 cm = community_list_master_lookup(bgp_clist,
21048 LARGE_COMMUNITY_LIST_MASTER);
21049
21050 for (list = cm->num.head; list; list = list->next)
21051 for (entry = list->head; entry; entry = entry->next) {
21052 vty_out(vty,
21053 "bgp large-community-list %s seq %" PRId64" %s %s\n",
21054 list->name, entry->seq,
21055 community_direct_str(entry->direct),
21056 community_list_config_str(entry));
21057 write++;
21058 }
21059 for (list = cm->str.head; list; list = list->next)
21060 for (entry = list->head; entry; entry = entry->next) {
21061 vty_out(vty,
21062 "bgp large-community-list %s %s seq %" PRId64" %s %s\n",
21063
21064 entry->style == LARGE_COMMUNITY_LIST_STANDARD
21065 ? "standard"
21066 : "expanded",
21067 list->name, entry->seq, community_direct_str(entry->direct),
21068 community_list_config_str(entry));
21069 write++;
21070 }
21071
21072 return write;
21073 }
21074
21075 static int community_list_config_write(struct vty *vty);
21076 static struct cmd_node community_list_node = {
21077 .name = "community list",
21078 .node = COMMUNITY_LIST_NODE,
21079 .prompt = "",
21080 .config_write = community_list_config_write,
21081 };
21082
21083 static void community_list_vty(void)
21084 {
21085 install_node(&community_list_node);
21086
21087 /* Community-list. */
21088 install_element(CONFIG_NODE, &bgp_community_list_standard_cmd);
21089 install_element(CONFIG_NODE, &bgp_community_list_expanded_all_cmd);
21090 install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_cmd);
21091 install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_list_cmd);
21092 install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_cmd);
21093 install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_list_cmd);
21094 install_element(VIEW_NODE, &show_bgp_community_list_cmd);
21095 install_element(VIEW_NODE, &show_bgp_community_list_arg_cmd);
21096
21097 /* Extcommunity-list. */
21098 install_element(CONFIG_NODE, &bgp_extcommunity_list_standard_cmd);
21099 install_element(CONFIG_NODE, &bgp_extcommunity_list_name_expanded_cmd);
21100 install_element(CONFIG_NODE, &no_bgp_extcommunity_list_standard_all_cmd);
21101 install_element(CONFIG_NODE,
21102 &no_bgp_extcommunity_list_standard_all_list_cmd);
21103 install_element(CONFIG_NODE, &no_bgp_extcommunity_list_expanded_all_cmd);
21104 install_element(CONFIG_NODE,
21105 &no_bgp_extcommunity_list_expanded_all_list_cmd);
21106 install_element(VIEW_NODE, &show_bgp_extcommunity_list_cmd);
21107 install_element(VIEW_NODE, &show_bgp_extcommunity_list_arg_cmd);
21108
21109 /* Large Community List */
21110 install_element(CONFIG_NODE, &bgp_lcommunity_list_standard_cmd);
21111 install_element(CONFIG_NODE, &bgp_lcommunity_list_expanded_cmd);
21112 install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard_cmd);
21113 install_element(CONFIG_NODE, &bgp_lcommunity_list_name_expanded_cmd);
21114 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_all_cmd);
21115 install_element(CONFIG_NODE,
21116 &no_bgp_lcommunity_list_name_standard_all_cmd);
21117 install_element(CONFIG_NODE,
21118 &no_bgp_lcommunity_list_name_expanded_all_cmd);
21119 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_cmd);
21120 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_expanded_cmd);
21121 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_standard_cmd);
21122 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_expanded_cmd);
21123 install_element(VIEW_NODE, &show_bgp_lcommunity_list_cmd);
21124 install_element(VIEW_NODE, &show_bgp_lcommunity_list_arg_cmd);
21125
21126 bgp_community_list_command_completion_setup();
21127 }
21128
21129 static struct cmd_node community_alias_node = {
21130 .name = "community alias",
21131 .node = COMMUNITY_ALIAS_NODE,
21132 .prompt = "",
21133 .config_write = bgp_community_alias_write,
21134 };
21135
21136 void community_alias_vty(void)
21137 {
21138 install_node(&community_alias_node);
21139
21140 /* Community-list. */
21141 install_element(CONFIG_NODE, &bgp_community_alias_cmd);
21142
21143 bgp_community_alias_command_completion_setup();
21144 }
FRRouting mirror