]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_vty.c
projects / mirror_frr.git / blob
? search:


3bc64c34991486945d164f22059729057357ada7
[mirror_frr.git] / bgpd / bgp_vty.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* BGP VTY interface.
3 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro
4 */
5
6 #include <zebra.h>
7
8 #include "command.h"
9 #include "lib/json.h"
10 #include "lib/sockopt.h"
11 #include "lib_errors.h"
12 #include "lib/zclient.h"
13 #include "lib/printfrr.h"
14 #include "prefix.h"
15 #include "plist.h"
16 #include "buffer.h"
17 #include "linklist.h"
18 #include "stream.h"
19 #include "event.h"
20 #include "log.h"
21 #include "memory.h"
22 #include "lib_vty.h"
23 #include "hash.h"
24 #include "queue.h"
25 #include "filter.h"
26 #include "frrstr.h"
27 #include "asn.h"
28
29 #include "bgpd/bgpd.h"
30 #include "bgpd/bgp_attr_evpn.h"
31 #include "bgpd/bgp_advertise.h"
32 #include "bgpd/bgp_attr.h"
33 #include "bgpd/bgp_aspath.h"
34 #include "bgpd/bgp_community.h"
35 #include "bgpd/bgp_community_alias.h"
36 #include "bgpd/bgp_ecommunity.h"
37 #include "bgpd/bgp_lcommunity.h"
38 #include "bgpd/bgp_damp.h"
39 #include "bgpd/bgp_debug.h"
40 #include "bgpd/bgp_errors.h"
41 #include "bgpd/bgp_fsm.h"
42 #include "bgpd/bgp_nht.h"
43 #include "bgpd/bgp_nexthop.h"
44 #include "bgpd/bgp_network.h"
45 #include "bgpd/bgp_open.h"
46 #include "bgpd/bgp_regex.h"
47 #include "bgpd/bgp_route.h"
48 #include "bgpd/bgp_mplsvpn.h"
49 #include "bgpd/bgp_zebra.h"
50 #include "bgpd/bgp_table.h"
51 #include "bgpd/bgp_vty.h"
52 #include "bgpd/bgp_mpath.h"
53 #include "bgpd/bgp_packet.h"
54 #include "bgpd/bgp_updgrp.h"
55 #include "bgpd/bgp_bfd.h"
56 #include "bgpd/bgp_io.h"
57 #include "bgpd/bgp_evpn.h"
58 #include "bgpd/bgp_evpn_vty.h"
59 #include "bgpd/bgp_evpn_mh.h"
60 #include "bgpd/bgp_addpath.h"
61 #include "bgpd/bgp_mac.h"
62 #include "bgpd/bgp_flowspec.h"
63 #include "bgpd/bgp_conditional_adv.h"
64 #ifdef ENABLE_BGP_VNC
65 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
66 #endif
67
68 FRR_CFG_DEFAULT_BOOL(BGP_IMPORT_CHECK,
69 {
70 .val_bool = false,
71 .match_profile = "traditional",
72 .match_version = "< 7.4",
73 },
74 { .val_bool = true },
75 );
76 FRR_CFG_DEFAULT_BOOL(BGP_SHOW_HOSTNAME,
77 { .val_bool = true, .match_profile = "datacenter", },
78 { .val_bool = false },
79 );
80 FRR_CFG_DEFAULT_BOOL(BGP_SHOW_NEXTHOP_HOSTNAME,
81 { .val_bool = true, .match_profile = "datacenter", },
82 { .val_bool = false },
83 );
84 FRR_CFG_DEFAULT_BOOL(BGP_LOG_NEIGHBOR_CHANGES,
85 { .val_bool = true, .match_profile = "datacenter", },
86 { .val_bool = false },
87 );
88 FRR_CFG_DEFAULT_BOOL(BGP_DETERMINISTIC_MED,
89 { .val_bool = true, .match_profile = "datacenter", },
90 { .val_bool = false },
91 );
92 FRR_CFG_DEFAULT_ULONG(BGP_CONNECT_RETRY,
93 { .val_ulong = 10, .match_profile = "datacenter", },
94 { .val_ulong = 120 },
95 );
96 FRR_CFG_DEFAULT_ULONG(BGP_HOLDTIME,
97 { .val_ulong = 9, .match_profile = "datacenter", },
98 { .val_ulong = 180 },
99 );
100 FRR_CFG_DEFAULT_ULONG(BGP_KEEPALIVE,
101 { .val_ulong = 3, .match_profile = "datacenter", },
102 { .val_ulong = 60 },
103 );
104 FRR_CFG_DEFAULT_BOOL(BGP_EBGP_REQUIRES_POLICY,
105 { .val_bool = false, .match_profile = "datacenter", },
106 { .val_bool = false, .match_version = "< 7.4", },
107 { .val_bool = true },
108 );
109 FRR_CFG_DEFAULT_BOOL(BGP_SUPPRESS_DUPLICATES,
110 { .val_bool = false, .match_version = "< 7.6", },
111 { .val_bool = true },
112 );
113 FRR_CFG_DEFAULT_BOOL(BGP_GRACEFUL_NOTIFICATION,
114 { .val_bool = false, .match_version = "< 8.3", },
115 { .val_bool = true },
116 );
117 FRR_CFG_DEFAULT_BOOL(BGP_HARD_ADMIN_RESET,
118 { .val_bool = false, .match_version = "< 8.3", },
119 { .val_bool = true },
120 );
121
122 DEFINE_HOOK(bgp_inst_config_write,
123 (struct bgp *bgp, struct vty *vty),
124 (bgp, vty));
125 DEFINE_HOOK(bgp_snmp_update_last_changed, (struct bgp *bgp), (bgp));
126 DEFINE_HOOK(bgp_snmp_init_stats, (struct bgp *bgp), (bgp));
127
128 static struct peer_group *listen_range_exists(struct bgp *bgp,
129 struct prefix *range, int exact);
130
131 /* Show BGP peer's information. */
132 enum show_type {
133 show_all,
134 show_peer,
135 show_ipv4_all,
136 show_ipv6_all,
137 show_ipv4_peer,
138 show_ipv6_peer
139 };
140
141 static struct peer_group *listen_range_exists(struct bgp *bgp,
142 struct prefix *range, int exact);
143
144 static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
145 struct bgp *bgp);
146
147 static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
148 enum show_type type,
149 const char *ip_str,
150 afi_t afi, bool use_json);
151
152 static enum node_type bgp_node_type(afi_t afi, safi_t safi)
153 {
154 switch (afi) {
155 case AFI_IP:
156 switch (safi) {
157 case SAFI_UNICAST:
158 return BGP_IPV4_NODE;
159 case SAFI_MULTICAST:
160 return BGP_IPV4M_NODE;
161 case SAFI_LABELED_UNICAST:
162 return BGP_IPV4L_NODE;
163 case SAFI_MPLS_VPN:
164 return BGP_VPNV4_NODE;
165 case SAFI_FLOWSPEC:
166 return BGP_FLOWSPECV4_NODE;
167 case SAFI_UNSPEC:
168 case SAFI_ENCAP:
169 case SAFI_EVPN:
170 case SAFI_MAX:
171 /* not expected */
172 return BGP_IPV4_NODE;
173 }
174 break;
175 case AFI_IP6:
176 switch (safi) {
177 case SAFI_UNICAST:
178 return BGP_IPV6_NODE;
179 case SAFI_MULTICAST:
180 return BGP_IPV6M_NODE;
181 case SAFI_LABELED_UNICAST:
182 return BGP_IPV6L_NODE;
183 case SAFI_MPLS_VPN:
184 return BGP_VPNV6_NODE;
185 case SAFI_FLOWSPEC:
186 return BGP_FLOWSPECV6_NODE;
187 case SAFI_UNSPEC:
188 case SAFI_ENCAP:
189 case SAFI_EVPN:
190 case SAFI_MAX:
191 /* not expected and the return value seems wrong */
192 return BGP_IPV4_NODE;
193 }
194 break;
195 case AFI_L2VPN:
196 return BGP_EVPN_NODE;
197 case AFI_UNSPEC:
198 case AFI_MAX:
199 // We should never be here but to clarify the switch statement..
200 return BGP_IPV4_NODE;
201 }
202
203 // Impossible to happen
204 return BGP_IPV4_NODE;
205 }
206
207 static const char *get_afi_safi_vty_str(afi_t afi, safi_t safi)
208 {
209 if (afi == AFI_IP) {
210 if (safi == SAFI_UNICAST)
211 return "IPv4 Unicast";
212 if (safi == SAFI_MULTICAST)
213 return "IPv4 Multicast";
214 if (safi == SAFI_LABELED_UNICAST)
215 return "IPv4 Labeled Unicast";
216 if (safi == SAFI_MPLS_VPN)
217 return "IPv4 VPN";
218 if (safi == SAFI_ENCAP)
219 return "IPv4 Encap";
220 if (safi == SAFI_FLOWSPEC)
221 return "IPv4 Flowspec";
222 } else if (afi == AFI_IP6) {
223 if (safi == SAFI_UNICAST)
224 return "IPv6 Unicast";
225 if (safi == SAFI_MULTICAST)
226 return "IPv6 Multicast";
227 if (safi == SAFI_LABELED_UNICAST)
228 return "IPv6 Labeled Unicast";
229 if (safi == SAFI_MPLS_VPN)
230 return "IPv6 VPN";
231 if (safi == SAFI_ENCAP)
232 return "IPv6 Encap";
233 if (safi == SAFI_FLOWSPEC)
234 return "IPv6 Flowspec";
235 } else if (afi == AFI_L2VPN) {
236 if (safi == SAFI_EVPN)
237 return "L2VPN EVPN";
238 }
239
240 return "Unknown";
241 }
242
243 /*
244 * Please note that we have intentionally camelCased
245 * the return strings here. So if you want
246 * to use this function, please ensure you
247 * are doing this within json output
248 */
249 static const char *get_afi_safi_json_str(afi_t afi, safi_t safi)
250 {
251 if (afi == AFI_IP) {
252 if (safi == SAFI_UNICAST)
253 return "ipv4Unicast";
254 if (safi == SAFI_MULTICAST)
255 return "ipv4Multicast";
256 if (safi == SAFI_LABELED_UNICAST)
257 return "ipv4LabeledUnicast";
258 if (safi == SAFI_MPLS_VPN)
259 return "ipv4Vpn";
260 if (safi == SAFI_ENCAP)
261 return "ipv4Encap";
262 if (safi == SAFI_FLOWSPEC)
263 return "ipv4Flowspec";
264 } else if (afi == AFI_IP6) {
265 if (safi == SAFI_UNICAST)
266 return "ipv6Unicast";
267 if (safi == SAFI_MULTICAST)
268 return "ipv6Multicast";
269 if (safi == SAFI_LABELED_UNICAST)
270 return "ipv6LabeledUnicast";
271 if (safi == SAFI_MPLS_VPN)
272 return "ipv6Vpn";
273 if (safi == SAFI_ENCAP)
274 return "ipv6Encap";
275 if (safi == SAFI_FLOWSPEC)
276 return "ipv6Flowspec";
277 } else if (afi == AFI_L2VPN) {
278 if (safi == SAFI_EVPN)
279 return "l2VpnEvpn";
280 }
281
282 return "Unknown";
283 }
284
285 /* unset srv6 locator */
286 static int bgp_srv6_locator_unset(struct bgp *bgp)
287 {
288 int ret;
289 struct listnode *node, *nnode;
290 struct srv6_locator_chunk *chunk;
291 struct bgp_srv6_function *func;
292 struct bgp *bgp_vrf;
293
294 /* release chunk notification via ZAPI */
295 ret = bgp_zebra_srv6_manager_release_locator_chunk(
296 bgp->srv6_locator_name);
297 if (ret < 0)
298 return -1;
299
300 /* refresh chunks */
301 for (ALL_LIST_ELEMENTS(bgp->srv6_locator_chunks, node, nnode, chunk)) {
302 listnode_delete(bgp->srv6_locator_chunks, chunk);
303 srv6_locator_chunk_free(&chunk);
304 }
305
306 /* refresh functions */
307 for (ALL_LIST_ELEMENTS(bgp->srv6_functions, node, nnode, func)) {
308 listnode_delete(bgp->srv6_functions, func);
309 XFREE(MTYPE_BGP_SRV6_FUNCTION, func);
310 }
311
312 /* refresh tovpn_sid */
313 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
314 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
315 continue;
316
317 /* refresh vpnv4 tovpn_sid */
318 XFREE(MTYPE_BGP_SRV6_SID,
319 bgp_vrf->vpn_policy[AFI_IP].tovpn_sid);
320
321 /* refresh vpnv6 tovpn_sid */
322 XFREE(MTYPE_BGP_SRV6_SID,
323 bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid);
324
325 /* refresh per-vrf tovpn_sid */
326 XFREE(MTYPE_BGP_SRV6_SID, bgp_vrf->tovpn_sid);
327 }
328
329 /* update vpn bgp processes */
330 vpn_leak_postchange_all();
331
332 /* refresh tovpn_sid_locator */
333 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
334 if (bgp_vrf->inst_type != BGP_INSTANCE_TYPE_VRF)
335 continue;
336
337 /* refresh vpnv4 tovpn_sid_locator */
338 srv6_locator_chunk_free(
339 &bgp_vrf->vpn_policy[AFI_IP].tovpn_sid_locator);
340
341 /* refresh vpnv6 tovpn_sid_locator */
342 srv6_locator_chunk_free(
343 &bgp_vrf->vpn_policy[AFI_IP6].tovpn_sid_locator);
344
345 /* refresh per-vrf tovpn_sid_locator */
346 srv6_locator_chunk_free(&bgp_vrf->tovpn_sid_locator);
347 }
348
349 /* clear locator name */
350 memset(bgp->srv6_locator_name, 0, sizeof(bgp->srv6_locator_name));
351
352 return 0;
353 }
354
355 /* Utility function to get address family from current node. */
356 afi_t bgp_node_afi(struct vty *vty)
357 {
358 afi_t afi;
359 switch (vty->node) {
360 case BGP_IPV6_NODE:
361 case BGP_IPV6M_NODE:
362 case BGP_IPV6L_NODE:
363 case BGP_VPNV6_NODE:
364 case BGP_FLOWSPECV6_NODE:
365 afi = AFI_IP6;
366 break;
367 case BGP_EVPN_NODE:
368 afi = AFI_L2VPN;
369 break;
370 default:
371 afi = AFI_IP;
372 break;
373 }
374 return afi;
375 }
376
377 /* Utility function to get subsequent address family from current
378 node. */
379 safi_t bgp_node_safi(struct vty *vty)
380 {
381 safi_t safi;
382 switch (vty->node) {
383 case BGP_VPNV4_NODE:
384 case BGP_VPNV6_NODE:
385 safi = SAFI_MPLS_VPN;
386 break;
387 case BGP_IPV4M_NODE:
388 case BGP_IPV6M_NODE:
389 safi = SAFI_MULTICAST;
390 break;
391 case BGP_EVPN_NODE:
392 safi = SAFI_EVPN;
393 break;
394 case BGP_IPV4L_NODE:
395 case BGP_IPV6L_NODE:
396 safi = SAFI_LABELED_UNICAST;
397 break;
398 case BGP_FLOWSPECV4_NODE:
399 case BGP_FLOWSPECV6_NODE:
400 safi = SAFI_FLOWSPEC;
401 break;
402 default:
403 safi = SAFI_UNICAST;
404 break;
405 }
406 return safi;
407 }
408
409 /**
410 * Converts an AFI in string form to afi_t
411 *
412 * @param afi string, one of
413 * - "ipv4"
414 * - "ipv6"
415 * - "l2vpn"
416 * @return the corresponding afi_t
417 */
418 afi_t bgp_vty_afi_from_str(const char *afi_str)
419 {
420 afi_t afi = AFI_MAX; /* unknown */
421 if (strmatch(afi_str, "ipv4"))
422 afi = AFI_IP;
423 else if (strmatch(afi_str, "ipv6"))
424 afi = AFI_IP6;
425 else if (strmatch(afi_str, "l2vpn"))
426 afi = AFI_L2VPN;
427 return afi;
428 }
429
430 int argv_find_and_parse_afi(struct cmd_token **argv, int argc, int *index,
431 afi_t *afi)
432 {
433 int ret = 0;
434 if (argv_find(argv, argc, "ipv4", index)) {
435 ret = 1;
436 if (afi)
437 *afi = AFI_IP;
438 } else if (argv_find(argv, argc, "ipv6", index)) {
439 ret = 1;
440 if (afi)
441 *afi = AFI_IP6;
442 } else if (argv_find(argv, argc, "l2vpn", index)) {
443 ret = 1;
444 if (afi)
445 *afi = AFI_L2VPN;
446 }
447 return ret;
448 }
449
450 /* supports <unicast|multicast|vpn|labeled-unicast> */
451 safi_t bgp_vty_safi_from_str(const char *safi_str)
452 {
453 safi_t safi = SAFI_MAX; /* unknown */
454 if (strmatch(safi_str, "multicast"))
455 safi = SAFI_MULTICAST;
456 else if (strmatch(safi_str, "unicast"))
457 safi = SAFI_UNICAST;
458 else if (strmatch(safi_str, "vpn"))
459 safi = SAFI_MPLS_VPN;
460 else if (strmatch(safi_str, "evpn"))
461 safi = SAFI_EVPN;
462 else if (strmatch(safi_str, "labeled-unicast"))
463 safi = SAFI_LABELED_UNICAST;
464 else if (strmatch(safi_str, "flowspec"))
465 safi = SAFI_FLOWSPEC;
466 return safi;
467 }
468
469 int argv_find_and_parse_safi(struct cmd_token **argv, int argc, int *index,
470 safi_t *safi)
471 {
472 int ret = 0;
473 if (argv_find(argv, argc, "unicast", index)) {
474 ret = 1;
475 if (safi)
476 *safi = SAFI_UNICAST;
477 } else if (argv_find(argv, argc, "multicast", index)) {
478 ret = 1;
479 if (safi)
480 *safi = SAFI_MULTICAST;
481 } else if (argv_find(argv, argc, "labeled-unicast", index)) {
482 ret = 1;
483 if (safi)
484 *safi = SAFI_LABELED_UNICAST;
485 } else if (argv_find(argv, argc, "vpn", index)) {
486 ret = 1;
487 if (safi)
488 *safi = SAFI_MPLS_VPN;
489 } else if (argv_find(argv, argc, "evpn", index)) {
490 ret = 1;
491 if (safi)
492 *safi = SAFI_EVPN;
493 } else if (argv_find(argv, argc, "flowspec", index)) {
494 ret = 1;
495 if (safi)
496 *safi = SAFI_FLOWSPEC;
497 }
498 return ret;
499 }
500
501 /*
502 * Convert an afi_t/safi_t pair to matching BGP_DEFAULT_AF* flag.
503 *
504 * afi
505 * address-family identifier
506 *
507 * safi
508 * subsequent address-family identifier
509 *
510 * Returns:
511 * default_af string corresponding to the supplied afi/safi pair.
512 * If afi/safi is invalid or if flag for afi/safi doesn't exist,
513 * return -1.
514 */
515 static const char *get_bgp_default_af_flag(afi_t afi, safi_t safi)
516 {
517 switch (afi) {
518 case AFI_IP:
519 switch (safi) {
520 case SAFI_UNICAST:
521 return "ipv4-unicast";
522 case SAFI_MULTICAST:
523 return "ipv4-multicast";
524 case SAFI_MPLS_VPN:
525 return "ipv4-vpn";
526 case SAFI_ENCAP:
527 return "ipv4-encap";
528 case SAFI_LABELED_UNICAST:
529 return "ipv4-labeled-unicast";
530 case SAFI_FLOWSPEC:
531 return "ipv4-flowspec";
532 case SAFI_UNSPEC:
533 case SAFI_EVPN:
534 case SAFI_MAX:
535 return "unknown-afi/safi";
536 }
537 break;
538 case AFI_IP6:
539 switch (safi) {
540 case SAFI_UNICAST:
541 return "ipv6-unicast";
542 case SAFI_MULTICAST:
543 return "ipv6-multicast";
544 case SAFI_MPLS_VPN:
545 return "ipv6-vpn";
546 case SAFI_ENCAP:
547 return "ipv6-encap";
548 case SAFI_LABELED_UNICAST:
549 return "ipv6-labeled-unicast";
550 case SAFI_FLOWSPEC:
551 return "ipv6-flowspec";
552 case SAFI_UNSPEC:
553 case SAFI_EVPN:
554 case SAFI_MAX:
555 return "unknown-afi/safi";
556 }
557 break;
558 case AFI_L2VPN:
559 switch (safi) {
560 case SAFI_EVPN:
561 return "l2vpn-evpn";
562 case SAFI_UNICAST:
563 case SAFI_MULTICAST:
564 case SAFI_MPLS_VPN:
565 case SAFI_ENCAP:
566 case SAFI_LABELED_UNICAST:
567 case SAFI_FLOWSPEC:
568 case SAFI_UNSPEC:
569 case SAFI_MAX:
570 return "unknown-afi/safi";
571 }
572 break;
573 case AFI_UNSPEC:
574 case AFI_MAX:
575 return "unknown-afi/safi";
576 }
577 /* all AFIs are accounted for above, so this shouldn't happen */
578
579 assert(!"Reached end of function where we did not expect to");
580 }
581
582 int bgp_get_vty(struct bgp **bgp, as_t *as, const char *name,
583 enum bgp_instance_type inst_type, const char *as_pretty,
584 enum asnotation_mode asnotation)
585 {
586 int ret = bgp_get(bgp, as, name, inst_type, as_pretty, asnotation);
587
588 if (ret == BGP_CREATED) {
589 bgp_timers_set(*bgp, DFLT_BGP_KEEPALIVE, DFLT_BGP_HOLDTIME,
590 DFLT_BGP_CONNECT_RETRY, BGP_DEFAULT_DELAYOPEN);
591
592 if (DFLT_BGP_IMPORT_CHECK)
593 SET_FLAG((*bgp)->flags, BGP_FLAG_IMPORT_CHECK);
594 if (DFLT_BGP_SHOW_HOSTNAME)
595 SET_FLAG((*bgp)->flags, BGP_FLAG_SHOW_HOSTNAME);
596 if (DFLT_BGP_SHOW_NEXTHOP_HOSTNAME)
597 SET_FLAG((*bgp)->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
598 if (DFLT_BGP_LOG_NEIGHBOR_CHANGES)
599 SET_FLAG((*bgp)->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
600 if (DFLT_BGP_DETERMINISTIC_MED)
601 SET_FLAG((*bgp)->flags, BGP_FLAG_DETERMINISTIC_MED);
602 if (DFLT_BGP_EBGP_REQUIRES_POLICY)
603 SET_FLAG((*bgp)->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
604 if (DFLT_BGP_SUPPRESS_DUPLICATES)
605 SET_FLAG((*bgp)->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
606 if (DFLT_BGP_GRACEFUL_NOTIFICATION)
607 SET_FLAG((*bgp)->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
608 if (DFLT_BGP_HARD_ADMIN_RESET)
609 SET_FLAG((*bgp)->flags, BGP_FLAG_HARD_ADMIN_RESET);
610
611 ret = BGP_SUCCESS;
612 }
613 return ret;
614 }
615
616 /*
617 * bgp_vty_find_and_parse_afi_safi_bgp
618 *
619 * For a given 'show ...' command, correctly parse the afi/safi/bgp out from it
620 * This function *assumes* that the calling function pre-sets the afi/safi/bgp
621 * to appropriate values for the calling function. This is to allow the
622 * calling function to make decisions appropriate for the show command
623 * that is being parsed.
624 *
625 * The show commands are generally of the form:
626 * "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>
627 * [<unicast|multicast|vpn|labeled-unicast>]] ..."
628 *
629 * Since we use argv_find if the show command in particular doesn't have:
630 * [ip]
631 * [<view|vrf> VIEWVRFNAME]
632 * [<ipv4|ipv6> [<unicast|multicast|vpn|labeled-unicast>]]
633 * The command parsing should still be ok.
634 *
635 * vty -> The vty for the command so we can output some useful data in
636 * the event of a parse error in the vrf.
637 * argv -> The command tokens
638 * argc -> How many command tokens we have
639 * idx -> The current place in the command, generally should be 0 for this
640 * function
641 * afi -> The parsed afi if it was included in the show command, returned here
642 * safi -> The parsed safi if it was included in the show command, returned here
643 * bgp -> Pointer to the bgp data structure we need to fill in.
644 * use_json -> json is configured or not
645 *
646 * The function returns the correct location in the parse tree for the
647 * last token found.
648 *
649 * Returns 0 for failure to parse correctly, else the idx position of where
650 * it found the last token.
651 */
652 int bgp_vty_find_and_parse_afi_safi_bgp(struct vty *vty,
653 struct cmd_token **argv, int argc,
654 int *idx, afi_t *afi, safi_t *safi,
655 struct bgp **bgp, bool use_json)
656 {
657 char *vrf_name = NULL;
658
659 assert(afi);
660 assert(safi);
661 assert(bgp);
662
663 if (argv_find(argv, argc, "ip", idx))
664 *afi = AFI_IP;
665
666 if (argv_find(argv, argc, "view", idx))
667 vrf_name = argv[*idx + 1]->arg;
668 else if (argv_find(argv, argc, "vrf", idx)) {
669 vrf_name = argv[*idx + 1]->arg;
670 if (strmatch(vrf_name, VRF_DEFAULT_NAME))
671 vrf_name = NULL;
672 }
673 if (vrf_name) {
674 if (strmatch(vrf_name, "all"))
675 *bgp = NULL;
676 else {
677 *bgp = bgp_lookup_by_name(vrf_name);
678 if (!*bgp) {
679 if (use_json) {
680 json_object *json = NULL;
681 json = json_object_new_object();
682 json_object_string_add(
683 json, "warning",
684 "View/Vrf is unknown");
685 vty_json(vty, json);
686 }
687 else
688 vty_out(vty, "View/Vrf %s is unknown\n",
689 vrf_name);
690 *idx = 0;
691 return 0;
692 }
693 }
694 } else {
695 *bgp = bgp_get_default();
696 if (!*bgp) {
697 if (use_json) {
698 json_object *json = NULL;
699 json = json_object_new_object();
700 json_object_string_add(
701 json, "warning",
702 "Default BGP instance not found");
703 vty_json(vty, json);
704 }
705 else
706 vty_out(vty,
707 "Default BGP instance not found\n");
708 *idx = 0;
709 return 0;
710 }
711 }
712
713 if (argv_find_and_parse_afi(argv, argc, idx, afi))
714 argv_find_and_parse_safi(argv, argc, idx, safi);
715
716 *idx += 1;
717 return *idx;
718 }
719
720 static bool peer_address_self_check(struct bgp *bgp, union sockunion *su)
721 {
722 struct interface *ifp = NULL;
723 struct listnode *node;
724 struct bgp_listener *listener;
725 union sockunion all_su;
726
727 if (su->sa.sa_family == AF_INET) {
728 (void)str2sockunion("0.0.0.0", &all_su);
729 ifp = if_lookup_by_ipv4_exact(&su->sin.sin_addr, bgp->vrf_id);
730 } else if (su->sa.sa_family == AF_INET6) {
731 (void)str2sockunion("::", &all_su);
732 ifp = if_lookup_by_ipv6_exact(&su->sin6.sin6_addr,
733 su->sin6.sin6_scope_id,
734 bgp->vrf_id);
735 }
736
737 if (ifp) {
738 for (ALL_LIST_ELEMENTS_RO(bm->listen_sockets, node, listener)) {
739 if (sockunion_family(su) !=
740 sockunion_family(&listener->su))
741 continue;
742
743 /* If 0.0.0.0/:: is a listener, then treat as self and
744 * reject.
745 */
746 if (!sockunion_cmp(&listener->su, su) ||
747 !sockunion_cmp(&listener->su, &all_su))
748 return true;
749 }
750 }
751
752 return false;
753 }
754
755 /* Utility function for looking up peer from VTY. */
756 /* This is used only for configuration, so disallow if attempted on
757 * a dynamic neighbor.
758 */
759 static struct peer *peer_lookup_vty(struct vty *vty, const char *ip_str)
760 {
761 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
762 int ret;
763 union sockunion su;
764 struct peer *peer;
765
766 if (!bgp) {
767 return NULL;
768 }
769
770 ret = str2sockunion(ip_str, &su);
771 if (ret < 0) {
772 peer = peer_lookup_by_conf_if(bgp, ip_str);
773 if (!peer) {
774 if ((peer = peer_lookup_by_hostname(bgp, ip_str))
775 == NULL) {
776 vty_out(vty,
777 "%% Malformed address or name: %s\n",
778 ip_str);
779 return NULL;
780 }
781 }
782 } else {
783 peer = peer_lookup(bgp, &su);
784 if (!peer) {
785 vty_out(vty,
786 "%% Specify remote-as or peer-group commands first\n");
787 return NULL;
788 }
789 if (peer_dynamic_neighbor(peer)) {
790 vty_out(vty,
791 "%% Operation not allowed on a dynamic neighbor\n");
792 return NULL;
793 }
794 }
795 return peer;
796 }
797
798 /* Utility function for looking up peer or peer group. */
799 /* This is used only for configuration, so disallow if attempted on
800 * a dynamic neighbor.
801 */
802 struct peer *peer_and_group_lookup_vty(struct vty *vty, const char *peer_str)
803 {
804 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
805 int ret;
806 union sockunion su;
807 struct peer *peer = NULL;
808 struct peer_group *group = NULL;
809
810 if (!bgp) {
811 return NULL;
812 }
813
814 ret = str2sockunion(peer_str, &su);
815 if (ret == 0) {
816 /* IP address, locate peer. */
817 peer = peer_lookup(bgp, &su);
818 } else {
819 /* Not IP, could match either peer configured on interface or a
820 * group. */
821 peer = peer_lookup_by_conf_if(bgp, peer_str);
822 if (!peer)
823 group = peer_group_lookup(bgp, peer_str);
824 }
825
826 if (peer) {
827 if (peer_dynamic_neighbor(peer)) {
828 zlog_warn(
829 "%pBP: Operation not allowed on a dynamic neighbor",
830 peer);
831 vty_out(vty,
832 "%% Operation not allowed on a dynamic neighbor\n");
833 return NULL;
834 }
835
836 return peer;
837 }
838
839 if (group)
840 return group->conf;
841
842 zlog_warn("Specify remote-as or peer-group commands first before: %s",
843 vty->buf);
844 vty_out(vty, "%% Specify remote-as or peer-group commands first\n");
845
846 return NULL;
847 }
848
849 int bgp_vty_return(struct vty *vty, enum bgp_create_error_code ret)
850 {
851 const char *str = NULL;
852
853 switch (ret) {
854 case BGP_SUCCESS:
855 case BGP_CREATED:
856 case BGP_GR_NO_OPERATION:
857 break;
858 case BGP_ERR_INVALID_VALUE:
859 str = "Invalid value";
860 break;
861 case BGP_ERR_INVALID_FLAG:
862 str = "Invalid flag";
863 break;
864 case BGP_ERR_PEER_GROUP_SHUTDOWN:
865 str = "Peer-group has been shutdown. Activate the peer-group first";
866 break;
867 case BGP_ERR_PEER_FLAG_CONFLICT:
868 str = "Can't set override-capability and strict-capability-match at the same time";
869 break;
870 case BGP_ERR_PEER_GROUP_NO_REMOTE_AS:
871 str = "Specify remote-as or peer-group remote AS first";
872 break;
873 case BGP_ERR_PEER_GROUP_CANT_CHANGE:
874 str = "Cannot change the peer-group. Deconfigure first";
875 break;
876 case BGP_ERR_PEER_GROUP_MISMATCH:
877 str = "Peer is not a member of this peer-group";
878 break;
879 case BGP_ERR_PEER_FILTER_CONFLICT:
880 str = "Prefix/distribute list can not co-exist";
881 break;
882 case BGP_ERR_NOT_INTERNAL_PEER:
883 str = "Invalid command. Not an internal neighbor";
884 break;
885 case BGP_ERR_REMOVE_PRIVATE_AS:
886 str = "remove-private-AS cannot be configured for IBGP peers";
887 break;
888 case BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS:
889 str = "Cannot have local-as same as BGP AS number";
890 break;
891 case BGP_ERR_TCPSIG_FAILED:
892 str = "Error while applying TCP-Sig to session(s)";
893 break;
894 case BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK:
895 str = "ebgp-multihop and ttl-security cannot be configured together";
896 break;
897 case BGP_ERR_NO_IBGP_WITH_TTLHACK:
898 str = "ttl-security only allowed for EBGP peers";
899 break;
900 case BGP_ERR_AS_OVERRIDE:
901 str = "as-override cannot be configured for IBGP peers";
902 break;
903 case BGP_ERR_INVALID_DYNAMIC_NEIGHBORS_LIMIT:
904 str = "Invalid limit for number of dynamic neighbors";
905 break;
906 case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_EXISTS:
907 str = "Dynamic neighbor listen range already exists";
908 break;
909 case BGP_ERR_INVALID_FOR_DYNAMIC_PEER:
910 str = "Operation not allowed on a dynamic neighbor";
911 break;
912 case BGP_ERR_INVALID_FOR_DIRECT_PEER:
913 str = "Operation not allowed on a directly connected neighbor";
914 break;
915 case BGP_ERR_PEER_SAFI_CONFLICT:
916 str = "Cannot activate peer for both 'ipv4 unicast' and 'ipv4 labeled-unicast'";
917 break;
918 case BGP_ERR_GR_INVALID_CMD:
919 str = "The Graceful Restart command used is not valid at this moment.";
920 break;
921 case BGP_ERR_GR_OPERATION_FAILED:
922 str = "The Graceful Restart Operation failed due to an err.";
923 break;
924 case BGP_ERR_PEER_GROUP_MEMBER:
925 str = "Peer-group member cannot override remote-as of peer-group.";
926 break;
927 case BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT:
928 str = "Peer-group members must be all internal or all external.";
929 break;
930 case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND:
931 str = "Range specified cannot be deleted because it is not part of current config.";
932 break;
933 case BGP_ERR_INSTANCE_MISMATCH:
934 str = "Instance specified does not match the current instance.";
935 break;
936 case BGP_ERR_NO_INTERFACE_CONFIG:
937 str = "Interface specified is not being used for interface based peer.";
938 break;
939 case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
940 str = "No configuration already specified for soft reconfiguration.";
941 break;
942 case BGP_ERR_AS_MISMATCH:
943 str = "BGP is already running.";
944 break;
945 case BGP_ERR_AF_UNCONFIGURED:
946 str = "AFI/SAFI specified is not currently configured.";
947 break;
948 case BGP_ERR_INVALID_AS:
949 str = "Confederation AS specified is the same AS as our AS.";
950 break;
951 case BGP_ERR_INVALID_ROLE_NAME:
952 str = "Invalid role name";
953 break;
954 case BGP_ERR_INVALID_INTERNAL_ROLE:
955 str = "External roles can be set only on eBGP session";
956 break;
957 }
958 if (str) {
959 vty_out(vty, "%% %s\n", str);
960 return CMD_WARNING_CONFIG_FAILED;
961 }
962 return CMD_SUCCESS;
963 }
964
965 /* BGP clear sort. */
966 enum clear_sort {
967 clear_all,
968 clear_peer,
969 clear_group,
970 clear_external,
971 clear_as
972 };
973
974 static void bgp_clear_vty_error(struct vty *vty, struct peer *peer, afi_t afi,
975 safi_t safi, int error)
976 {
977 switch (error) {
978 case BGP_ERR_AF_UNCONFIGURED:
979 if (vty)
980 vty_out(vty,
981 "%% BGP: Enable %s address family for the neighbor %s\n",
982 get_afi_safi_str(afi, safi, false), peer->host);
983 else
984 zlog_warn(
985 "%% BGP: Enable %s address family for the neighbor %s",
986 get_afi_safi_str(afi, safi, false), peer->host);
987 break;
988 case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
989 if (vty)
990 vty_out(vty,
991 "%% BGP: Inbound soft reconfig for %s not possible as it\n has neither refresh capability, nor inbound soft reconfig\n",
992 peer->host);
993 else
994 zlog_warn(
995 "%% BGP: Inbound soft reconfig for %s not possible as it has neither refresh capability, nor inbound soft reconfig",
996 peer->host);
997 break;
998 default:
999 break;
1000 }
1001 }
1002
1003 static int bgp_peer_clear(struct peer *peer, afi_t afi, safi_t safi,
1004 struct listnode **nnode, enum bgp_clear_type stype)
1005 {
1006 int ret = 0;
1007 struct peer_af *paf;
1008
1009 /* if afi/.safi not specified, spin thru all of them */
1010 if ((afi == AFI_UNSPEC) && (safi == SAFI_UNSPEC)) {
1011 afi_t tmp_afi;
1012 safi_t tmp_safi;
1013 enum bgp_af_index index;
1014
1015 for (index = BGP_AF_START; index < BGP_AF_MAX; index++) {
1016 paf = peer->peer_af_array[index];
1017 if (!paf)
1018 continue;
1019
1020 if (paf && paf->subgroup)
1021 SET_FLAG(paf->subgroup->sflags,
1022 SUBGRP_STATUS_FORCE_UPDATES);
1023
1024 tmp_afi = paf->afi;
1025 tmp_safi = paf->safi;
1026 if (!peer->afc[tmp_afi][tmp_safi])
1027 continue;
1028
1029 if (stype == BGP_CLEAR_SOFT_NONE)
1030 ret = peer_clear(peer, nnode);
1031 else
1032 ret = peer_clear_soft(peer, tmp_afi, tmp_safi,
1033 stype);
1034 }
1035 /* if afi specified and safi not, spin thru safis on this afi */
1036 } else if (safi == SAFI_UNSPEC) {
1037 safi_t tmp_safi;
1038
1039 for (tmp_safi = SAFI_UNICAST;
1040 tmp_safi < SAFI_MAX; tmp_safi++) {
1041 if (!peer->afc[afi][tmp_safi])
1042 continue;
1043
1044 paf = peer_af_find(peer, afi, tmp_safi);
1045 if (paf && paf->subgroup)
1046 SET_FLAG(paf->subgroup->sflags,
1047 SUBGRP_STATUS_FORCE_UPDATES);
1048
1049 if (stype == BGP_CLEAR_SOFT_NONE)
1050 ret = peer_clear(peer, nnode);
1051 else
1052 ret = peer_clear_soft(peer, afi,
1053 tmp_safi, stype);
1054 }
1055 /* both afi/safi specified, let the caller know if not defined */
1056 } else {
1057 if (!peer->afc[afi][safi])
1058 return 1;
1059
1060 paf = peer_af_find(peer, afi, safi);
1061 if (paf && paf->subgroup)
1062 SET_FLAG(paf->subgroup->sflags,
1063 SUBGRP_STATUS_FORCE_UPDATES);
1064
1065 if (stype == BGP_CLEAR_SOFT_NONE)
1066 ret = peer_clear(peer, nnode);
1067 else
1068 ret = peer_clear_soft(peer, afi, safi, stype);
1069 }
1070
1071 return ret;
1072 }
1073
1074 /* `clear ip bgp' functions. */
1075 static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
1076 enum clear_sort sort, enum bgp_clear_type stype,
1077 const char *arg)
1078 {
1079 int ret = 0;
1080 bool found = false;
1081 struct peer *peer;
1082
1083 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
1084
1085 /* Clear all neighbors. */
1086 /*
1087 * Pass along pointer to next node to peer_clear() when walking all
1088 * nodes on the BGP instance as that may get freed if it is a
1089 * doppelganger
1090 */
1091 if (sort == clear_all) {
1092 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1093
1094 bgp_peer_gr_flags_update(peer);
1095
1096 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1097 gr_router_detected = true;
1098
1099 ret = bgp_peer_clear(peer, afi, safi, &nnode,
1100 stype);
1101
1102 if (ret < 0)
1103 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1104 }
1105
1106 if (gr_router_detected
1107 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1108 bgp_zebra_send_capabilities(bgp, false);
1109 } else if (!gr_router_detected
1110 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1111 bgp_zebra_send_capabilities(bgp, true);
1112 }
1113
1114 /* This is to apply read-only mode on this clear. */
1115 if (stype == BGP_CLEAR_SOFT_NONE)
1116 bgp->update_delay_over = 0;
1117
1118 return CMD_SUCCESS;
1119 }
1120
1121 /* Clear specified neighbor. */
1122 if (sort == clear_peer) {
1123 union sockunion su;
1124
1125 /* Make sockunion for lookup. */
1126 ret = str2sockunion(arg, &su);
1127 if (ret < 0) {
1128 peer = peer_lookup_by_conf_if(bgp, arg);
1129 if (!peer) {
1130 peer = peer_lookup_by_hostname(bgp, arg);
1131 if (!peer) {
1132 vty_out(vty,
1133 "Malformed address or name: %s\n",
1134 arg);
1135 return CMD_WARNING;
1136 }
1137 }
1138 } else {
1139 peer = peer_lookup(bgp, &su);
1140 if (!peer) {
1141 vty_out(vty,
1142 "%% BGP: Unknown neighbor - \"%s\"\n",
1143 arg);
1144 return CMD_WARNING;
1145 }
1146 }
1147
1148 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
1149 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
1150
1151 ret = bgp_peer_clear(peer, afi, safi, NULL, stype);
1152
1153 /* if afi/safi not defined for this peer, let caller know */
1154 if (ret == 1)
1155 ret = BGP_ERR_AF_UNCONFIGURED;
1156
1157 if (ret < 0)
1158 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1159
1160 return CMD_SUCCESS;
1161 }
1162
1163 /* Clear all neighbors belonging to a specific peer-group. */
1164 if (sort == clear_group) {
1165 struct peer_group *group;
1166
1167 group = peer_group_lookup(bgp, arg);
1168 if (!group) {
1169 vty_out(vty, "%% BGP: No such peer-group %s\n", arg);
1170 return CMD_WARNING;
1171 }
1172
1173 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
1174 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1175
1176 if (ret < 0)
1177 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1178 else
1179 found = true;
1180 }
1181
1182 if (!found)
1183 vty_out(vty,
1184 "%% BGP: No %s peer belonging to peer-group %s is configured\n",
1185 get_afi_safi_str(afi, safi, false), arg);
1186
1187 return CMD_SUCCESS;
1188 }
1189
1190 /* Clear all external (eBGP) neighbors. */
1191 if (sort == clear_external) {
1192 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1193 if (peer->sort == BGP_PEER_IBGP)
1194 continue;
1195
1196 bgp_peer_gr_flags_update(peer);
1197
1198 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1199 gr_router_detected = true;
1200
1201 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1202
1203 if (ret < 0)
1204 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1205 else
1206 found = true;
1207 }
1208
1209 if (gr_router_detected
1210 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1211 bgp_zebra_send_capabilities(bgp, false);
1212 } else if (!gr_router_detected
1213 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1214 bgp_zebra_send_capabilities(bgp, true);
1215 }
1216
1217 if (!found)
1218 vty_out(vty,
1219 "%% BGP: No external %s peer is configured\n",
1220 get_afi_safi_str(afi, safi, false));
1221
1222 return CMD_SUCCESS;
1223 }
1224
1225 /* Clear all neighbors belonging to a specific AS. */
1226 if (sort == clear_as) {
1227 as_t as;
1228
1229 if (!asn_str2asn(arg, &as)) {
1230 vty_out(vty, "%% BGP: No such AS %s\n", arg);
1231 return CMD_WARNING;
1232 }
1233
1234 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1235 if (peer->as != as)
1236 continue;
1237
1238 bgp_peer_gr_flags_update(peer);
1239
1240 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
1241 gr_router_detected = true;
1242
1243 ret = bgp_peer_clear(peer, afi, safi, &nnode, stype);
1244
1245 if (ret < 0)
1246 bgp_clear_vty_error(vty, peer, afi, safi, ret);
1247 else
1248 found = true;
1249 }
1250
1251 if (gr_router_detected
1252 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
1253 bgp_zebra_send_capabilities(bgp, false);
1254 } else if (!gr_router_detected
1255 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
1256 bgp_zebra_send_capabilities(bgp, true);
1257 }
1258
1259 if (!found)
1260 vty_out(vty,
1261 "%% BGP: No %s peer is configured with AS %s\n",
1262 get_afi_safi_str(afi, safi, false), arg);
1263
1264 return CMD_SUCCESS;
1265 }
1266
1267 return CMD_SUCCESS;
1268 }
1269
1270 static int bgp_clear_vty(struct vty *vty, const char *name, afi_t afi,
1271 safi_t safi, enum clear_sort sort,
1272 enum bgp_clear_type stype, const char *arg)
1273 {
1274 struct bgp *bgp;
1275
1276 /* BGP structure lookup. */
1277 if (name) {
1278 bgp = bgp_lookup_by_name(name);
1279 if (bgp == NULL) {
1280 vty_out(vty, "Can't find BGP instance %s\n", name);
1281 return CMD_WARNING;
1282 }
1283 } else {
1284 bgp = bgp_get_default();
1285 if (bgp == NULL) {
1286 vty_out(vty, "No BGP process is configured\n");
1287 return CMD_WARNING;
1288 }
1289 }
1290
1291 return bgp_clear(vty, bgp, afi, safi, sort, stype, arg);
1292 }
1293
1294 /* clear soft inbound */
1295 static void bgp_clear_star_soft_in(struct vty *vty, const char *name)
1296 {
1297 afi_t afi;
1298 safi_t safi;
1299
1300 FOREACH_AFI_SAFI (afi, safi)
1301 bgp_clear_vty(vty, name, afi, safi, clear_all,
1302 BGP_CLEAR_SOFT_IN, NULL);
1303 }
1304
1305 /* clear soft outbound */
1306 static void bgp_clear_star_soft_out(struct vty *vty, const char *name)
1307 {
1308 afi_t afi;
1309 safi_t safi;
1310
1311 FOREACH_AFI_SAFI (afi, safi)
1312 bgp_clear_vty(vty, name, afi, safi, clear_all,
1313 BGP_CLEAR_SOFT_OUT, NULL);
1314 }
1315
1316
1317 void bgp_clear_soft_in(struct bgp *bgp, afi_t afi, safi_t safi)
1318 {
1319 bgp_clear(NULL, bgp, afi, safi, clear_all, BGP_CLEAR_SOFT_IN, NULL);
1320 }
1321
1322 static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
1323 uint64_t flag, int set)
1324 {
1325 int ret;
1326 struct peer *peer;
1327
1328 peer = peer_and_group_lookup_vty(vty, ip_str);
1329 if (!peer)
1330 return CMD_WARNING_CONFIG_FAILED;
1331
1332 /*
1333 * If 'neighbor <interface>', then this is for directly connected peers,
1334 * we should not accept disable-connected-check.
1335 */
1336 if (peer->conf_if && (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)) {
1337 vty_out(vty,
1338 "%s is directly connected peer, cannot accept disable-connected-check\n",
1339 ip_str);
1340 return CMD_WARNING_CONFIG_FAILED;
1341 }
1342
1343 if (!set && flag == PEER_FLAG_SHUTDOWN)
1344 peer_tx_shutdown_message_unset(peer);
1345
1346 if (set)
1347 ret = peer_flag_set(peer, flag);
1348 else
1349 ret = peer_flag_unset(peer, flag);
1350
1351 return bgp_vty_return(vty, ret);
1352 }
1353
1354 static int peer_flag_set_vty(struct vty *vty, const char *ip_str, uint64_t flag)
1355 {
1356 return peer_flag_modify_vty(vty, ip_str, flag, 1);
1357 }
1358
1359 static int peer_flag_unset_vty(struct vty *vty, const char *ip_str,
1360 uint64_t flag)
1361 {
1362 return peer_flag_modify_vty(vty, ip_str, flag, 0);
1363 }
1364
1365 #include "bgpd/bgp_vty_clippy.c"
1366
1367 DEFUN_HIDDEN (bgp_local_mac,
1368 bgp_local_mac_cmd,
1369 "bgp local-mac vni " CMD_VNI_RANGE " mac WORD seq (0-4294967295)",
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 "mac-mobility sequence\n"
1377 "seq number\n")
1378 {
1379 int rv;
1380 vni_t vni;
1381 struct ethaddr mac;
1382 struct ipaddr ip;
1383 uint32_t seq;
1384 struct bgp *bgp;
1385
1386 vni = strtoul(argv[3]->arg, NULL, 10);
1387 if (!prefix_str2mac(argv[5]->arg, &mac)) {
1388 vty_out(vty, "%% Malformed MAC address\n");
1389 return CMD_WARNING;
1390 }
1391 memset(&ip, 0, sizeof(ip));
1392 seq = strtoul(argv[7]->arg, NULL, 10);
1393
1394 bgp = bgp_get_default();
1395 if (!bgp) {
1396 vty_out(vty, "Default BGP instance is not there\n");
1397 return CMD_WARNING;
1398 }
1399
1400 rv = bgp_evpn_local_macip_add(bgp, vni, &mac, &ip, 0 /* flags */, seq,
1401 zero_esi);
1402 if (rv < 0) {
1403 vty_out(vty, "Internal error\n");
1404 return CMD_WARNING;
1405 }
1406
1407 return CMD_SUCCESS;
1408 }
1409
1410 DEFUN_HIDDEN (no_bgp_local_mac,
1411 no_bgp_local_mac_cmd,
1412 "no bgp local-mac vni " CMD_VNI_RANGE " mac WORD",
1413 NO_STR
1414 BGP_STR
1415 "Local MAC config\n"
1416 "VxLAN Network Identifier\n"
1417 "VNI number\n"
1418 "local mac\n"
1419 "mac address\n")
1420 {
1421 int rv;
1422 vni_t vni;
1423 struct ethaddr mac;
1424 struct ipaddr ip;
1425 struct bgp *bgp;
1426
1427 vni = strtoul(argv[4]->arg, NULL, 10);
1428 if (!prefix_str2mac(argv[6]->arg, &mac)) {
1429 vty_out(vty, "%% Malformed MAC address\n");
1430 return CMD_WARNING;
1431 }
1432 memset(&ip, 0, sizeof(ip));
1433
1434 bgp = bgp_get_default();
1435 if (!bgp) {
1436 vty_out(vty, "Default BGP instance is not there\n");
1437 return CMD_WARNING;
1438 }
1439
1440 rv = bgp_evpn_local_macip_del(bgp, vni, &mac, &ip, ZEBRA_NEIGH_ACTIVE);
1441 if (rv < 0) {
1442 vty_out(vty, "Internal error\n");
1443 return CMD_WARNING;
1444 }
1445
1446 return CMD_SUCCESS;
1447 }
1448
1449 DEFUN (no_synchronization,
1450 no_synchronization_cmd,
1451 "no synchronization",
1452 NO_STR
1453 "Perform IGP synchronization\n")
1454 {
1455 return CMD_SUCCESS;
1456 }
1457
1458 DEFUN (no_auto_summary,
1459 no_auto_summary_cmd,
1460 "no auto-summary",
1461 NO_STR
1462 "Enable automatic network number summarization\n")
1463 {
1464 return CMD_SUCCESS;
1465 }
1466
1467 /* "router bgp" commands. */
1468 DEFUN_NOSH (router_bgp,
1469 router_bgp_cmd,
1470 "router bgp [ASNUM$instasn [<view|vrf> VIEWVRFNAME] [as-notation <dot|dot+|plain>]]",
1471 ROUTER_STR
1472 BGP_STR
1473 AS_STR
1474 BGP_INSTANCE_HELP_STR
1475 "Force the AS notation output\n"
1476 "use 'AA.BB' format for AS 4 byte values\n"
1477 "use 'AA.BB' format for all AS values\n"
1478 "use plain format for all AS values\n")
1479 {
1480 int idx_asn = 2;
1481 int idx_view_vrf = 3;
1482 int idx_vrf = 4;
1483 int is_new_bgp = 0;
1484 int idx_asnotation = 3;
1485 int idx_asnotation_kind = 4;
1486 enum asnotation_mode asnotation = ASNOTATION_UNDEFINED;
1487 int ret;
1488 as_t as;
1489 struct bgp *bgp;
1490 const char *name = NULL;
1491 enum bgp_instance_type inst_type;
1492
1493 // "router bgp" without an ASN
1494 if (argc == 2) {
1495 // Pending: Make VRF option available for ASN less config
1496 bgp = bgp_get_default();
1497
1498 if (bgp == NULL) {
1499 vty_out(vty, "%% No BGP process is configured\n");
1500 return CMD_WARNING_CONFIG_FAILED;
1501 }
1502
1503 if (listcount(bm->bgp) > 1) {
1504 vty_out(vty, "%% Please specify ASN and VRF\n");
1505 return CMD_WARNING_CONFIG_FAILED;
1506 }
1507 }
1508
1509 // "router bgp X"
1510 else {
1511 if (!asn_str2asn(argv[idx_asn]->arg, &as)) {
1512 vty_out(vty, "%% BGP: No such AS %s\n",
1513 argv[idx_asn]->arg);
1514 return CMD_WARNING_CONFIG_FAILED;
1515 }
1516
1517 if (as == BGP_PRIVATE_AS_MAX || as == BGP_AS4_MAX)
1518 vty_out(vty, "Reserved AS used (%u|%u); AS is %u\n",
1519 BGP_PRIVATE_AS_MAX, BGP_AS4_MAX, as);
1520
1521 inst_type = BGP_INSTANCE_TYPE_DEFAULT;
1522
1523 if (argv_find(argv, argc, "VIEWVRFNAME", &idx_vrf)) {
1524 idx_view_vrf = idx_vrf - 1;
1525 if (argv[idx_view_vrf]->text) {
1526 name = argv[idx_vrf]->arg;
1527
1528 if (!strcmp(argv[idx_view_vrf]->text, "vrf")) {
1529 if (strmatch(name, VRF_DEFAULT_NAME))
1530 name = NULL;
1531 else
1532 inst_type =
1533 BGP_INSTANCE_TYPE_VRF;
1534 } else if (!strcmp(argv[idx_view_vrf]->text,
1535 "view"))
1536 inst_type = BGP_INSTANCE_TYPE_VIEW;
1537 }
1538 }
1539 if (argv_find(argv, argc, "as-notation", &idx_asnotation)) {
1540 idx_asnotation_kind = idx_asnotation + 1;
1541 if (strmatch(argv[idx_asnotation_kind]->text, "dot+"))
1542 asnotation = ASNOTATION_DOTPLUS;
1543 else if (strmatch(argv[idx_asnotation_kind]->text,
1544 "dot"))
1545 asnotation = ASNOTATION_DOT;
1546 else if (strmatch(argv[idx_asnotation_kind]->text,
1547 "plain"))
1548 asnotation = ASNOTATION_PLAIN;
1549 }
1550
1551 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT)
1552 is_new_bgp = (bgp_lookup(as, name) == NULL);
1553
1554 ret = bgp_get_vty(&bgp, &as, name, inst_type,
1555 argv[idx_asn]->arg, asnotation);
1556 switch (ret) {
1557 case BGP_ERR_AS_MISMATCH:
1558 vty_out(vty, "BGP is already running; AS is %s\n",
1559 bgp->as_pretty);
1560 return CMD_WARNING_CONFIG_FAILED;
1561 case BGP_ERR_INSTANCE_MISMATCH:
1562 vty_out(vty,
1563 "BGP instance name and AS number mismatch\n");
1564 vty_out(vty,
1565 "BGP instance is already running; AS is %s\n",
1566 bgp->as_pretty);
1567 return CMD_WARNING_CONFIG_FAILED;
1568 }
1569
1570 /*
1571 * If we just instantiated the default instance, complete
1572 * any pending VRF-VPN leaking that was configured via
1573 * earlier "router bgp X vrf FOO" blocks.
1574 */
1575 if (is_new_bgp && inst_type == BGP_INSTANCE_TYPE_DEFAULT)
1576 vpn_leak_postchange_all();
1577
1578 if (inst_type == BGP_INSTANCE_TYPE_VRF)
1579 bgp_vpn_leak_export(bgp);
1580 /* Pending: handle when user tries to change a view to vrf n vv.
1581 */
1582 /* for pre-existing bgp instance,
1583 * - update as_pretty
1584 * - update asnotation if explicitly mentioned
1585 */
1586 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_AUTO)) {
1587 XFREE(MTYPE_BGP, bgp->as_pretty);
1588 bgp->as_pretty = XSTRDUP(MTYPE_BGP, argv[idx_asn]->arg);
1589 if (!CHECK_FLAG(bgp->config, BGP_CONFIG_ASNOTATION) &&
1590 asnotation != ASNOTATION_UNDEFINED) {
1591 SET_FLAG(bgp->config, BGP_CONFIG_ASNOTATION);
1592 bgp->asnotation = asnotation;
1593 }
1594 }
1595 }
1596
1597 /* unset the auto created flag as the user config is now present */
1598 UNSET_FLAG(bgp->vrf_flags, BGP_VRF_AUTO);
1599 VTY_PUSH_CONTEXT(BGP_NODE, bgp);
1600
1601 return CMD_SUCCESS;
1602 }
1603
1604 /* "no router bgp" commands. */
1605 DEFUN (no_router_bgp,
1606 no_router_bgp_cmd,
1607 "no router bgp [ASNUM$instasn [<view|vrf> VIEWVRFNAME] [as-notation <dot|dot+|plain>]]",
1608 NO_STR
1609 ROUTER_STR
1610 BGP_STR
1611 AS_STR
1612 BGP_INSTANCE_HELP_STR
1613 "Force the AS notation output\n"
1614 "use 'AA.BB' format for AS 4 byte values\n"
1615 "use 'AA.BB' format for all AS values\n"
1616 "use plain format for all AS values\n")
1617 {
1618 int idx_asn = 3;
1619 int idx_vrf = 5;
1620 as_t as;
1621 struct bgp *bgp;
1622 const char *name = NULL;
1623
1624 // "no router bgp" without an ASN
1625 if (argc == 3) {
1626 // Pending: Make VRF option available for ASN less config
1627 bgp = bgp_get_default();
1628
1629 if (bgp == NULL) {
1630 vty_out(vty, "%% No BGP process is configured\n");
1631 return CMD_WARNING_CONFIG_FAILED;
1632 }
1633
1634 if (listcount(bm->bgp) > 1) {
1635 vty_out(vty, "%% Please specify ASN and VRF\n");
1636 return CMD_WARNING_CONFIG_FAILED;
1637 }
1638
1639 if (bgp->l3vni) {
1640 vty_out(vty, "%% Please unconfigure l3vni %u\n",
1641 bgp->l3vni);
1642 return CMD_WARNING_CONFIG_FAILED;
1643 }
1644 } else {
1645 if (!asn_str2asn(argv[idx_asn]->arg, &as)) {
1646 vty_out(vty, "%% BGP: No such AS %s\n",
1647 argv[idx_asn]->arg);
1648 return CMD_WARNING_CONFIG_FAILED;
1649 }
1650 if (argc > 4) {
1651 name = argv[idx_vrf]->arg;
1652 if (strmatch(argv[idx_vrf - 1]->text, "vrf")
1653 && strmatch(name, VRF_DEFAULT_NAME))
1654 name = NULL;
1655 }
1656
1657 /* Lookup bgp structure. */
1658 bgp = bgp_lookup(as, name);
1659 if (!bgp) {
1660 vty_out(vty, "%% Can't find BGP instance\n");
1661 return CMD_WARNING_CONFIG_FAILED;
1662 }
1663
1664 if (bgp->l3vni) {
1665 vty_out(vty, "%% Please unconfigure l3vni %u\n",
1666 bgp->l3vni);
1667 return CMD_WARNING_CONFIG_FAILED;
1668 }
1669
1670 /* Cannot delete default instance if vrf instances exist */
1671 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
1672 struct listnode *node;
1673 struct bgp *tmp_bgp;
1674
1675 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, tmp_bgp)) {
1676 if (tmp_bgp->inst_type != BGP_INSTANCE_TYPE_VRF)
1677 continue;
1678 if (CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1679 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT) ||
1680 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1681 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT) ||
1682 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1683 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT) ||
1684 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1685 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT) ||
1686 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP][SAFI_UNICAST],
1687 BGP_CONFIG_VRF_TO_VRF_EXPORT) ||
1688 CHECK_FLAG(tmp_bgp->af_flags[AFI_IP6][SAFI_UNICAST],
1689 BGP_CONFIG_VRF_TO_VRF_EXPORT) ||
1690 (bgp == bgp_get_evpn() &&
1691 (CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1692 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST) ||
1693 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1694 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP) ||
1695 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1696 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST) ||
1697 CHECK_FLAG(tmp_bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
1698 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP))) ||
1699 (hashcount(tmp_bgp->vnihash))) {
1700 vty_out(vty,
1701 "%% Cannot delete default BGP instance. Dependent VRF instances exist\n");
1702 return CMD_WARNING_CONFIG_FAILED;
1703 }
1704 }
1705 }
1706 }
1707
1708 bgp_delete(bgp);
1709
1710 return CMD_SUCCESS;
1711 }
1712
1713 /* bgp session-dscp */
1714
1715 DEFPY (bgp_session_dscp,
1716 bgp_session_dscp_cmd,
1717 "bgp session-dscp (0-63)$dscp",
1718 BGP_STR
1719 "Override default (C6) bgp TCP session DSCP value\n"
1720 "Manually configured dscp parameter\n")
1721 {
1722 bm->tcp_dscp = dscp << 2;
1723
1724 return CMD_SUCCESS;
1725 }
1726
1727 DEFPY (no_bgp_session_dscp,
1728 no_bgp_session_dscp_cmd,
1729 "no bgp session-dscp [(0-63)]",
1730 NO_STR
1731 BGP_STR
1732 "Override default (C6) bgp TCP session DSCP value\n"
1733 "Manually configured dscp parameter\n")
1734 {
1735 bm->tcp_dscp = IPTOS_PREC_INTERNETCONTROL;
1736
1737 return CMD_SUCCESS;
1738 }
1739
1740 /* BGP router-id. */
1741
1742 DEFPY (bgp_router_id,
1743 bgp_router_id_cmd,
1744 "bgp router-id A.B.C.D",
1745 BGP_STR
1746 "Override configured router identifier\n"
1747 "Manually configured router identifier\n")
1748 {
1749 VTY_DECLVAR_CONTEXT(bgp, bgp);
1750 bgp_router_id_static_set(bgp, router_id);
1751 return CMD_SUCCESS;
1752 }
1753
1754 DEFPY (no_bgp_router_id,
1755 no_bgp_router_id_cmd,
1756 "no bgp router-id [A.B.C.D]",
1757 NO_STR
1758 BGP_STR
1759 "Override configured router identifier\n"
1760 "Manually configured router identifier\n")
1761 {
1762 VTY_DECLVAR_CONTEXT(bgp, bgp);
1763
1764 if (router_id_str) {
1765 if (!IPV4_ADDR_SAME(&bgp->router_id_static, &router_id)) {
1766 vty_out(vty, "%% BGP router-id doesn't match\n");
1767 return CMD_WARNING_CONFIG_FAILED;
1768 }
1769 }
1770
1771 router_id.s_addr = 0;
1772 bgp_router_id_static_set(bgp, router_id);
1773
1774 return CMD_SUCCESS;
1775 }
1776
1777 DEFPY(bgp_community_alias, bgp_community_alias_cmd,
1778 "[no$no] bgp community alias WORD$community ALIAS_NAME$alias_name",
1779 NO_STR BGP_STR
1780 "Add community specific parameters\n"
1781 "Create an alias for a community\n"
1782 "Community (AA:BB or AA:BB:CC)\n"
1783 "Alias name\n")
1784 {
1785 struct community_alias ca = {};
1786 struct community_alias *lookup_community;
1787 struct community_alias *lookup_alias;
1788 struct community *comm;
1789 struct lcommunity *lcomm;
1790 uint8_t invalid = 0;
1791
1792 comm = community_str2com(community);
1793 if (!comm)
1794 invalid++;
1795 community_free(&comm);
1796
1797 lcomm = lcommunity_str2com(community);
1798 if (!lcomm)
1799 invalid++;
1800 lcommunity_free(&lcomm);
1801
1802 if (invalid > 1) {
1803 vty_out(vty, "Invalid community format\n");
1804 return CMD_WARNING;
1805 }
1806
1807 strlcpy(ca.community, community, sizeof(ca.community));
1808 strlcpy(ca.alias, alias_name, sizeof(ca.alias));
1809
1810 lookup_community = bgp_ca_community_lookup(&ca);
1811 lookup_alias = bgp_ca_alias_lookup(&ca);
1812
1813 if (no) {
1814 bgp_ca_alias_delete(&ca);
1815 bgp_ca_community_delete(&ca);
1816 } else {
1817 if (lookup_alias) {
1818 /* Lookup if community hash table has an item
1819 * with the same alias name.
1820 */
1821 strlcpy(ca.community, lookup_alias->community,
1822 sizeof(ca.community));
1823 if (bgp_ca_community_lookup(&ca)) {
1824 vty_out(vty,
1825 "community (%s) already has this alias (%s)\n",
1826 lookup_alias->community,
1827 lookup_alias->alias);
1828 return CMD_WARNING;
1829 }
1830 bgp_ca_alias_delete(&ca);
1831 }
1832
1833 if (lookup_community) {
1834 /* Lookup if alias hash table has an item
1835 * with the same community.
1836 */
1837 strlcpy(ca.alias, lookup_community->alias,
1838 sizeof(ca.alias));
1839 if (bgp_ca_alias_lookup(&ca)) {
1840 vty_out(vty,
1841 "alias (%s) already has this community (%s)\n",
1842 lookup_community->alias,
1843 lookup_community->community);
1844 return CMD_WARNING;
1845 }
1846 bgp_ca_community_delete(&ca);
1847 }
1848
1849 bgp_ca_alias_insert(&ca);
1850 bgp_ca_community_insert(&ca);
1851 }
1852
1853 return CMD_SUCCESS;
1854 }
1855
1856 DEFPY (bgp_global_suppress_fib_pending,
1857 bgp_global_suppress_fib_pending_cmd,
1858 "[no] bgp suppress-fib-pending",
1859 NO_STR
1860 BGP_STR
1861 "Advertise only routes that are programmed in kernel to peers globally\n")
1862 {
1863 bm_wait_for_fib_set(!no);
1864
1865 return CMD_SUCCESS;
1866 }
1867
1868 DEFPY (bgp_suppress_fib_pending,
1869 bgp_suppress_fib_pending_cmd,
1870 "[no] bgp suppress-fib-pending",
1871 NO_STR
1872 BGP_STR
1873 "Advertise only routes that are programmed in kernel to peers\n")
1874 {
1875 VTY_DECLVAR_CONTEXT(bgp, bgp);
1876
1877 bgp_suppress_fib_pending_set(bgp, !no);
1878 return CMD_SUCCESS;
1879 }
1880
1881 /* BGP Cluster ID. */
1882 DEFUN (bgp_cluster_id,
1883 bgp_cluster_id_cmd,
1884 "bgp cluster-id <A.B.C.D|(1-4294967295)>",
1885 BGP_STR
1886 "Configure Route-Reflector Cluster-id\n"
1887 "Route-Reflector Cluster-id in IP address format\n"
1888 "Route-Reflector Cluster-id as 32 bit quantity\n")
1889 {
1890 VTY_DECLVAR_CONTEXT(bgp, bgp);
1891 int idx_ipv4 = 2;
1892 int ret;
1893 struct in_addr cluster;
1894
1895 ret = inet_aton(argv[idx_ipv4]->arg, &cluster);
1896 if (!ret) {
1897 vty_out(vty, "%% Malformed bgp cluster identifier\n");
1898 return CMD_WARNING_CONFIG_FAILED;
1899 }
1900
1901 bgp_cluster_id_set(bgp, &cluster);
1902 bgp_clear_star_soft_out(vty, bgp->name);
1903
1904 return CMD_SUCCESS;
1905 }
1906
1907 DEFUN (no_bgp_cluster_id,
1908 no_bgp_cluster_id_cmd,
1909 "no bgp cluster-id [<A.B.C.D|(1-4294967295)>]",
1910 NO_STR
1911 BGP_STR
1912 "Configure Route-Reflector Cluster-id\n"
1913 "Route-Reflector Cluster-id in IP address format\n"
1914 "Route-Reflector Cluster-id as 32 bit quantity\n")
1915 {
1916 VTY_DECLVAR_CONTEXT(bgp, bgp);
1917 bgp_cluster_id_unset(bgp);
1918 bgp_clear_star_soft_out(vty, bgp->name);
1919
1920 return CMD_SUCCESS;
1921 }
1922
1923 DEFPY (bgp_norib,
1924 bgp_norib_cmd,
1925 "bgp no-rib",
1926 BGP_STR
1927 "Disable BGP route installation to RIB (Zebra)\n")
1928 {
1929 if (bgp_option_check(BGP_OPT_NO_FIB)) {
1930 vty_out(vty,
1931 "%% No-RIB option is already set, nothing to do here.\n");
1932 return CMD_SUCCESS;
1933 }
1934
1935 bgp_option_norib_set_runtime();
1936
1937 return CMD_SUCCESS;
1938 }
1939
1940 DEFPY (no_bgp_norib,
1941 no_bgp_norib_cmd,
1942 "no bgp no-rib",
1943 NO_STR
1944 BGP_STR
1945 "Disable BGP route installation to RIB (Zebra)\n")
1946 {
1947 if (!bgp_option_check(BGP_OPT_NO_FIB)) {
1948 vty_out(vty,
1949 "%% No-RIB option is not set, nothing to do here.\n");
1950 return CMD_SUCCESS;
1951 }
1952
1953 bgp_option_norib_unset_runtime();
1954
1955 return CMD_SUCCESS;
1956 }
1957
1958 DEFPY (no_bgp_send_extra_data,
1959 no_bgp_send_extra_data_cmd,
1960 "[no] bgp send-extra-data zebra",
1961 NO_STR
1962 BGP_STR
1963 "Extra data to Zebra for display/use\n"
1964 "To zebra\n")
1965 {
1966 if (no)
1967 UNSET_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA);
1968 else
1969 SET_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA);
1970
1971 return CMD_SUCCESS;
1972 }
1973
1974 DEFUN (bgp_confederation_identifier,
1975 bgp_confederation_identifier_cmd,
1976 "bgp confederation identifier ASNUM",
1977 BGP_STR
1978 "AS confederation parameters\n"
1979 AS_STR
1980 "Set routing domain confederation AS\n")
1981 {
1982 VTY_DECLVAR_CONTEXT(bgp, bgp);
1983 int idx_number = 3;
1984 as_t as;
1985
1986 if (!asn_str2asn(argv[idx_number]->arg, &as)) {
1987 vty_out(vty, "%% BGP: No such AS %s\n", argv[idx_number]->arg);
1988 return CMD_WARNING_CONFIG_FAILED;
1989 }
1990
1991 bgp_confederation_id_set(bgp, as, argv[idx_number]->arg);
1992
1993 return CMD_SUCCESS;
1994 }
1995
1996 DEFUN (no_bgp_confederation_identifier,
1997 no_bgp_confederation_identifier_cmd,
1998 "no bgp confederation identifier [ASNUM]",
1999 NO_STR
2000 BGP_STR
2001 "AS confederation parameters\n"
2002 AS_STR
2003 "Set routing domain confederation AS\n")
2004 {
2005 VTY_DECLVAR_CONTEXT(bgp, bgp);
2006 bgp_confederation_id_unset(bgp);
2007
2008 return CMD_SUCCESS;
2009 }
2010
2011 DEFUN (bgp_confederation_peers,
2012 bgp_confederation_peers_cmd,
2013 "bgp confederation peers ASNUM...",
2014 BGP_STR
2015 "AS confederation parameters\n"
2016 "Peer ASs in BGP confederation\n"
2017 AS_STR)
2018 {
2019 VTY_DECLVAR_CONTEXT(bgp, bgp);
2020 int idx_asn = 3;
2021 as_t as;
2022 int i;
2023
2024 for (i = idx_asn; i < argc; i++) {
2025 if (!asn_str2asn(argv[i]->arg, &as)) {
2026 vty_out(vty, "%% Invalid confed peer AS value: %s\n",
2027 argv[i]->arg);
2028 continue;
2029 }
2030
2031 bgp_confederation_peers_add(bgp, as, argv[i]->arg);
2032 }
2033 return CMD_SUCCESS;
2034 }
2035
2036 DEFUN (no_bgp_confederation_peers,
2037 no_bgp_confederation_peers_cmd,
2038 "no bgp confederation peers ASNUM...",
2039 NO_STR
2040 BGP_STR
2041 "AS confederation parameters\n"
2042 "Peer ASs in BGP confederation\n"
2043 AS_STR)
2044 {
2045 VTY_DECLVAR_CONTEXT(bgp, bgp);
2046 int idx_asn = 4;
2047 as_t as;
2048 int i;
2049
2050 for (i = idx_asn; i < argc; i++) {
2051 if (!asn_str2asn(argv[i]->arg, &as)) {
2052 vty_out(vty, "%% Invalid confed peer AS value: %s\n",
2053 argv[i]->arg);
2054 continue;
2055 }
2056 bgp_confederation_peers_remove(bgp, as);
2057 }
2058 return CMD_SUCCESS;
2059 }
2060
2061 /**
2062 * Central routine for maximum-paths configuration.
2063 * @peer_type: BGP_PEER_EBGP or BGP_PEER_IBGP
2064 * @set: 1 for setting values, 0 for removing the max-paths config.
2065 */
2066 static int bgp_maxpaths_config_vty(struct vty *vty, int peer_type,
2067 const char *mpaths, uint16_t options,
2068 int set)
2069 {
2070 VTY_DECLVAR_CONTEXT(bgp, bgp);
2071 uint16_t maxpaths = 0;
2072 int ret;
2073 afi_t afi;
2074 safi_t safi;
2075
2076 afi = bgp_node_afi(vty);
2077 safi = bgp_node_safi(vty);
2078
2079 if (set) {
2080 maxpaths = strtol(mpaths, NULL, 10);
2081 if (maxpaths > multipath_num) {
2082 vty_out(vty,
2083 "%% Maxpaths Specified: %d is > than multipath num specified on bgp command line %d",
2084 maxpaths, multipath_num);
2085 return CMD_WARNING_CONFIG_FAILED;
2086 }
2087 ret = bgp_maximum_paths_set(bgp, afi, safi, peer_type, maxpaths,
2088 options);
2089 } else
2090 ret = bgp_maximum_paths_unset(bgp, afi, safi, peer_type);
2091
2092 if (ret < 0) {
2093 vty_out(vty,
2094 "%% Failed to %sset maximum-paths %s %u for afi %u, safi %u\n",
2095 (set == 1) ? "" : "un",
2096 (peer_type == BGP_PEER_EBGP) ? "ebgp" : "ibgp",
2097 maxpaths, afi, safi);
2098 return CMD_WARNING_CONFIG_FAILED;
2099 }
2100
2101 bgp_recalculate_all_bestpaths(bgp);
2102
2103 return CMD_SUCCESS;
2104 }
2105
2106 DEFUN (bgp_maxmed_admin,
2107 bgp_maxmed_admin_cmd,
2108 "bgp max-med administrative ",
2109 BGP_STR
2110 "Advertise routes with max-med\n"
2111 "Administratively applied, for an indefinite period\n")
2112 {
2113 VTY_DECLVAR_CONTEXT(bgp, bgp);
2114
2115 bgp->v_maxmed_admin = 1;
2116 bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
2117
2118 bgp_maxmed_update(bgp);
2119
2120 return CMD_SUCCESS;
2121 }
2122
2123 DEFUN (bgp_maxmed_admin_medv,
2124 bgp_maxmed_admin_medv_cmd,
2125 "bgp max-med administrative (0-4294967295)",
2126 BGP_STR
2127 "Advertise routes with max-med\n"
2128 "Administratively applied, for an indefinite period\n"
2129 "Max MED value to be used\n")
2130 {
2131 VTY_DECLVAR_CONTEXT(bgp, bgp);
2132 int idx_number = 3;
2133
2134 bgp->v_maxmed_admin = 1;
2135 bgp->maxmed_admin_value = strtoul(argv[idx_number]->arg, NULL, 10);
2136
2137 bgp_maxmed_update(bgp);
2138
2139 return CMD_SUCCESS;
2140 }
2141
2142 DEFUN (no_bgp_maxmed_admin,
2143 no_bgp_maxmed_admin_cmd,
2144 "no bgp max-med administrative [(0-4294967295)]",
2145 NO_STR
2146 BGP_STR
2147 "Advertise routes with max-med\n"
2148 "Administratively applied, for an indefinite period\n"
2149 "Max MED value to be used\n")
2150 {
2151 VTY_DECLVAR_CONTEXT(bgp, bgp);
2152 bgp->v_maxmed_admin = BGP_MAXMED_ADMIN_UNCONFIGURED;
2153 bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
2154 bgp_maxmed_update(bgp);
2155
2156 return CMD_SUCCESS;
2157 }
2158
2159 DEFUN (bgp_maxmed_onstartup,
2160 bgp_maxmed_onstartup_cmd,
2161 "bgp max-med on-startup (5-86400) [(0-4294967295)]",
2162 BGP_STR
2163 "Advertise routes with max-med\n"
2164 "Effective on a startup\n"
2165 "Time (seconds) period for max-med\n"
2166 "Max MED value to be used\n")
2167 {
2168 VTY_DECLVAR_CONTEXT(bgp, bgp);
2169 int idx = 0;
2170
2171 if (argv_find(argv, argc, "(5-86400)", &idx))
2172 bgp->v_maxmed_onstartup = strtoul(argv[idx]->arg, NULL, 10);
2173 if (argv_find(argv, argc, "(0-4294967295)", &idx))
2174 bgp->maxmed_onstartup_value = strtoul(argv[idx]->arg, NULL, 10);
2175 else
2176 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
2177
2178 bgp_maxmed_update(bgp);
2179
2180 return CMD_SUCCESS;
2181 }
2182
2183 DEFUN (no_bgp_maxmed_onstartup,
2184 no_bgp_maxmed_onstartup_cmd,
2185 "no bgp max-med on-startup [(5-86400) [(0-4294967295)]]",
2186 NO_STR
2187 BGP_STR
2188 "Advertise routes with max-med\n"
2189 "Effective on a startup\n"
2190 "Time (seconds) period for max-med\n"
2191 "Max MED value to be used\n")
2192 {
2193 VTY_DECLVAR_CONTEXT(bgp, bgp);
2194
2195 /* Cancel max-med onstartup if its on */
2196 if (bgp->t_maxmed_onstartup) {
2197 THREAD_OFF(bgp->t_maxmed_onstartup);
2198 bgp->maxmed_onstartup_over = 1;
2199 }
2200
2201 bgp->v_maxmed_onstartup = BGP_MAXMED_ONSTARTUP_UNCONFIGURED;
2202 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
2203
2204 bgp_maxmed_update(bgp);
2205
2206 return CMD_SUCCESS;
2207 }
2208
2209 static int bgp_global_update_delay_config_vty(struct vty *vty,
2210 uint16_t update_delay,
2211 uint16_t establish_wait)
2212 {
2213 struct listnode *node, *nnode;
2214 struct bgp *bgp;
2215 bool vrf_cfg = false;
2216
2217 /*
2218 * See if update-delay is set per-vrf and warn user to delete it
2219 * Note that we only need to check this if this is the first time
2220 * setting the global config.
2221 */
2222 if (bm->v_update_delay == BGP_UPDATE_DELAY_DEF) {
2223 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2224 if (bgp->v_update_delay != BGP_UPDATE_DELAY_DEF) {
2225 vty_out(vty,
2226 "%% update-delay configuration found in vrf %s\n",
2227 bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT
2228 ? VRF_DEFAULT_NAME
2229 : bgp->name);
2230 vrf_cfg = true;
2231 }
2232 }
2233 }
2234
2235 if (vrf_cfg) {
2236 vty_out(vty,
2237 "%%Failed: global update-delay config not permitted\n");
2238 return CMD_WARNING;
2239 }
2240
2241 if (!establish_wait) { /* update-delay <delay> */
2242 bm->v_update_delay = update_delay;
2243 bm->v_establish_wait = bm->v_update_delay;
2244 } else {
2245 /* update-delay <delay> <establish-wait> */
2246 if (update_delay < establish_wait) {
2247 vty_out(vty,
2248 "%%Failed: update-delay less than the establish-wait!\n");
2249 return CMD_WARNING_CONFIG_FAILED;
2250 }
2251
2252 bm->v_update_delay = update_delay;
2253 bm->v_establish_wait = establish_wait;
2254 }
2255
2256 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2257 bgp->v_update_delay = bm->v_update_delay;
2258 bgp->v_establish_wait = bm->v_establish_wait;
2259 }
2260
2261 return CMD_SUCCESS;
2262 }
2263
2264 static int bgp_global_update_delay_deconfig_vty(struct vty *vty)
2265 {
2266 struct listnode *node, *nnode;
2267 struct bgp *bgp;
2268
2269 bm->v_update_delay = BGP_UPDATE_DELAY_DEF;
2270 bm->v_establish_wait = bm->v_update_delay;
2271
2272 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
2273 bgp->v_update_delay = bm->v_update_delay;
2274 bgp->v_establish_wait = bm->v_establish_wait;
2275 }
2276
2277 return CMD_SUCCESS;
2278 }
2279
2280 static int bgp_update_delay_config_vty(struct vty *vty, uint16_t update_delay,
2281 uint16_t establish_wait)
2282 {
2283 VTY_DECLVAR_CONTEXT(bgp, bgp);
2284
2285 /* if configured globally, per-instance config is not allowed */
2286 if (bm->v_update_delay) {
2287 vty_out(vty,
2288 "%%Failed: per-vrf update-delay config not permitted with global update-delay\n");
2289 return CMD_WARNING_CONFIG_FAILED;
2290 }
2291
2292
2293 if (!establish_wait) /* update-delay <delay> */
2294 {
2295 bgp->v_update_delay = update_delay;
2296 bgp->v_establish_wait = bgp->v_update_delay;
2297 return CMD_SUCCESS;
2298 }
2299
2300 /* update-delay <delay> <establish-wait> */
2301 if (update_delay < establish_wait) {
2302 vty_out(vty,
2303 "%%Failed: update-delay less than the establish-wait!\n");
2304 return CMD_WARNING_CONFIG_FAILED;
2305 }
2306
2307 bgp->v_update_delay = update_delay;
2308 bgp->v_establish_wait = establish_wait;
2309
2310 return CMD_SUCCESS;
2311 }
2312
2313 static int bgp_update_delay_deconfig_vty(struct vty *vty)
2314 {
2315 VTY_DECLVAR_CONTEXT(bgp, bgp);
2316
2317 /* If configured globally, cannot remove from one bgp instance */
2318 if (bm->v_update_delay) {
2319 vty_out(vty,
2320 "%%Failed: bgp update-delay configured globally. Delete per-vrf not permitted\n");
2321 return CMD_WARNING_CONFIG_FAILED;
2322 }
2323 bgp->v_update_delay = BGP_UPDATE_DELAY_DEF;
2324 bgp->v_establish_wait = bgp->v_update_delay;
2325
2326 return CMD_SUCCESS;
2327 }
2328
2329 void bgp_config_write_update_delay(struct vty *vty, struct bgp *bgp)
2330 {
2331 /* If configured globally, no need to display per-instance value */
2332 if (bgp->v_update_delay != bm->v_update_delay) {
2333 vty_out(vty, " update-delay %d", bgp->v_update_delay);
2334 if (bgp->v_update_delay != bgp->v_establish_wait)
2335 vty_out(vty, " %d", bgp->v_establish_wait);
2336 vty_out(vty, "\n");
2337 }
2338 }
2339
2340 /* Global update-delay configuration */
2341 DEFPY (bgp_global_update_delay,
2342 bgp_global_update_delay_cmd,
2343 "bgp update-delay (0-3600)$delay [(1-3600)$wait]",
2344 BGP_STR
2345 "Force initial delay for best-path and updates for all bgp instances\n"
2346 "Max delay in seconds\n"
2347 "Establish wait in seconds\n")
2348 {
2349 return bgp_global_update_delay_config_vty(vty, delay, wait);
2350 }
2351
2352 /* Global update-delay deconfiguration */
2353 DEFPY (no_bgp_global_update_delay,
2354 no_bgp_global_update_delay_cmd,
2355 "no bgp update-delay [(0-3600) [(1-3600)]]",
2356 NO_STR
2357 BGP_STR
2358 "Force initial delay for best-path and updates\n"
2359 "Max delay in seconds\n"
2360 "Establish wait in seconds\n")
2361 {
2362 return bgp_global_update_delay_deconfig_vty(vty);
2363 }
2364
2365 /* Update-delay configuration */
2366
2367 DEFPY (bgp_update_delay,
2368 bgp_update_delay_cmd,
2369 "update-delay (0-3600)$delay [(1-3600)$wait]",
2370 "Force initial delay for best-path and updates\n"
2371 "Max delay in seconds\n"
2372 "Establish wait in seconds\n")
2373 {
2374 return bgp_update_delay_config_vty(vty, delay, wait);
2375 }
2376
2377 /* Update-delay deconfiguration */
2378 DEFPY (no_bgp_update_delay,
2379 no_bgp_update_delay_cmd,
2380 "no update-delay [(0-3600) [(1-3600)]]",
2381 NO_STR
2382 "Force initial delay for best-path and updates\n"
2383 "Max delay in seconds\n"
2384 "Establish wait in seconds\n")
2385 {
2386 return bgp_update_delay_deconfig_vty(vty);
2387 }
2388
2389
2390 static int bgp_wpkt_quanta_config_vty(struct vty *vty, uint32_t quanta,
2391 bool set)
2392 {
2393 VTY_DECLVAR_CONTEXT(bgp, bgp);
2394
2395 quanta = set ? quanta : BGP_WRITE_PACKET_MAX;
2396 atomic_store_explicit(&bgp->wpkt_quanta, quanta, memory_order_relaxed);
2397
2398 return CMD_SUCCESS;
2399 }
2400
2401 static int bgp_rpkt_quanta_config_vty(struct vty *vty, uint32_t quanta,
2402 bool set)
2403 {
2404 VTY_DECLVAR_CONTEXT(bgp, bgp);
2405
2406 quanta = set ? quanta : BGP_READ_PACKET_MAX;
2407 atomic_store_explicit(&bgp->rpkt_quanta, quanta, memory_order_relaxed);
2408
2409 return CMD_SUCCESS;
2410 }
2411
2412 void bgp_config_write_wpkt_quanta(struct vty *vty, struct bgp *bgp)
2413 {
2414 uint32_t quanta =
2415 atomic_load_explicit(&bgp->wpkt_quanta, memory_order_relaxed);
2416 if (quanta != BGP_WRITE_PACKET_MAX)
2417 vty_out(vty, " write-quanta %d\n", quanta);
2418 }
2419
2420 void bgp_config_write_rpkt_quanta(struct vty *vty, struct bgp *bgp)
2421 {
2422 uint32_t quanta =
2423 atomic_load_explicit(&bgp->rpkt_quanta, memory_order_relaxed);
2424 if (quanta != BGP_READ_PACKET_MAX)
2425 vty_out(vty, " read-quanta %d\n", quanta);
2426 }
2427
2428 /* Packet quanta configuration
2429 *
2430 * XXX: The value set here controls the size of a stack buffer in the IO
2431 * thread. When changing these limits be careful to prevent stack overflow.
2432 *
2433 * Furthermore, the maximums used here should correspond to
2434 * BGP_WRITE_PACKET_MAX and BGP_READ_PACKET_MAX.
2435 */
2436 DEFPY (bgp_wpkt_quanta,
2437 bgp_wpkt_quanta_cmd,
2438 "[no] write-quanta (1-64)$quanta",
2439 NO_STR
2440 "How many packets to write to peer socket per run\n"
2441 "Number of packets\n")
2442 {
2443 return bgp_wpkt_quanta_config_vty(vty, quanta, !no);
2444 }
2445
2446 DEFPY (bgp_rpkt_quanta,
2447 bgp_rpkt_quanta_cmd,
2448 "[no] read-quanta (1-10)$quanta",
2449 NO_STR
2450 "How many packets to read from peer socket per I/O cycle\n"
2451 "Number of packets\n")
2452 {
2453 return bgp_rpkt_quanta_config_vty(vty, quanta, !no);
2454 }
2455
2456 void bgp_config_write_coalesce_time(struct vty *vty, struct bgp *bgp)
2457 {
2458 if (!bgp->heuristic_coalesce)
2459 vty_out(vty, " coalesce-time %u\n", bgp->coalesce_time);
2460 }
2461
2462 /* BGP TCP keepalive */
2463 static void bgp_config_tcp_keepalive(struct vty *vty, struct bgp *bgp)
2464 {
2465 if (bgp->tcp_keepalive_idle) {
2466 vty_out(vty, " bgp tcp-keepalive %u %u %u\n",
2467 bgp->tcp_keepalive_idle, bgp->tcp_keepalive_intvl,
2468 bgp->tcp_keepalive_probes);
2469 }
2470 }
2471
2472 DEFUN (bgp_coalesce_time,
2473 bgp_coalesce_time_cmd,
2474 "coalesce-time (0-4294967295)",
2475 "Subgroup coalesce timer\n"
2476 "Subgroup coalesce timer value (in ms)\n")
2477 {
2478 VTY_DECLVAR_CONTEXT(bgp, bgp);
2479
2480 int idx = 0;
2481
2482 bgp->heuristic_coalesce = false;
2483
2484 if (argv_find(argv, argc, "(0-4294967295)", &idx))
2485 bgp->coalesce_time = strtoul(argv[idx]->arg, NULL, 10);
2486
2487 return CMD_SUCCESS;
2488 }
2489
2490 DEFUN (no_bgp_coalesce_time,
2491 no_bgp_coalesce_time_cmd,
2492 "no coalesce-time (0-4294967295)",
2493 NO_STR
2494 "Subgroup coalesce timer\n"
2495 "Subgroup coalesce timer value (in ms)\n")
2496 {
2497 VTY_DECLVAR_CONTEXT(bgp, bgp);
2498
2499 bgp->heuristic_coalesce = true;
2500 bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
2501 return CMD_SUCCESS;
2502 }
2503
2504 /* Maximum-paths configuration */
2505 DEFUN (bgp_maxpaths,
2506 bgp_maxpaths_cmd,
2507 "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
2508 "Forward packets over multiple paths\n"
2509 "Number of paths\n")
2510 {
2511 int idx_number = 1;
2512 return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP,
2513 argv[idx_number]->arg, 0, 1);
2514 }
2515
2516 ALIAS_HIDDEN(bgp_maxpaths, bgp_maxpaths_hidden_cmd,
2517 "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
2518 "Forward packets over multiple paths\n"
2519 "Number of paths\n")
2520
2521 DEFUN (bgp_maxpaths_ibgp,
2522 bgp_maxpaths_ibgp_cmd,
2523 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
2524 "Forward packets over multiple paths\n"
2525 "iBGP-multipath\n"
2526 "Number of paths\n")
2527 {
2528 int idx_number = 2;
2529 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
2530 argv[idx_number]->arg, 0, 1);
2531 }
2532
2533 ALIAS_HIDDEN(bgp_maxpaths_ibgp, bgp_maxpaths_ibgp_hidden_cmd,
2534 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
2535 "Forward packets over multiple paths\n"
2536 "iBGP-multipath\n"
2537 "Number of paths\n")
2538
2539 DEFUN (bgp_maxpaths_ibgp_cluster,
2540 bgp_maxpaths_ibgp_cluster_cmd,
2541 "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM) " equal-cluster-length",
2542 "Forward packets over multiple paths\n"
2543 "iBGP-multipath\n"
2544 "Number of paths\n"
2545 "Match the cluster length\n")
2546 {
2547 int idx_number = 2;
2548 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
2549 argv[idx_number]->arg, true, 1);
2550 }
2551
2552 ALIAS_HIDDEN(bgp_maxpaths_ibgp_cluster, bgp_maxpaths_ibgp_cluster_hidden_cmd,
2553 "maximum-paths ibgp " CMD_RANGE_STR(
2554 1, MULTIPATH_NUM) " equal-cluster-length",
2555 "Forward packets over multiple paths\n"
2556 "iBGP-multipath\n"
2557 "Number of paths\n"
2558 "Match the cluster length\n")
2559
2560 DEFUN (no_bgp_maxpaths,
2561 no_bgp_maxpaths_cmd,
2562 "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
2563 NO_STR
2564 "Forward packets over multiple paths\n"
2565 "Number of paths\n")
2566 {
2567 return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, NULL, 0, 0);
2568 }
2569
2570 ALIAS_HIDDEN(no_bgp_maxpaths, no_bgp_maxpaths_hidden_cmd,
2571 "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]", NO_STR
2572 "Forward packets over multiple paths\n"
2573 "Number of paths\n")
2574
2575 DEFUN (no_bgp_maxpaths_ibgp,
2576 no_bgp_maxpaths_ibgp_cmd,
2577 "no maximum-paths ibgp [" CMD_RANGE_STR(1, MULTIPATH_NUM) " [equal-cluster-length]]",
2578 NO_STR
2579 "Forward packets over multiple paths\n"
2580 "iBGP-multipath\n"
2581 "Number of paths\n"
2582 "Match the cluster length\n")
2583 {
2584 return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, NULL, 0, 0);
2585 }
2586
2587 ALIAS_HIDDEN(no_bgp_maxpaths_ibgp, no_bgp_maxpaths_ibgp_hidden_cmd,
2588 "no maximum-paths ibgp [" CMD_RANGE_STR(
2589 1, MULTIPATH_NUM) " [equal-cluster-length]]",
2590 NO_STR
2591 "Forward packets over multiple paths\n"
2592 "iBGP-multipath\n"
2593 "Number of paths\n"
2594 "Match the cluster length\n")
2595
2596 static void bgp_config_write_maxpaths(struct vty *vty, struct bgp *bgp,
2597 afi_t afi, safi_t safi)
2598 {
2599 if (bgp->maxpaths[afi][safi].maxpaths_ebgp != multipath_num) {
2600 vty_out(vty, " maximum-paths %d\n",
2601 bgp->maxpaths[afi][safi].maxpaths_ebgp);
2602 }
2603
2604 if (bgp->maxpaths[afi][safi].maxpaths_ibgp != multipath_num) {
2605 vty_out(vty, " maximum-paths ibgp %d",
2606 bgp->maxpaths[afi][safi].maxpaths_ibgp);
2607 if (bgp->maxpaths[afi][safi].same_clusterlen)
2608 vty_out(vty, " equal-cluster-length");
2609 vty_out(vty, "\n");
2610 }
2611 }
2612
2613 /* BGP timers. */
2614
2615 DEFUN (bgp_timers,
2616 bgp_timers_cmd,
2617 "timers bgp (0-65535) (0-65535)",
2618 "Adjust routing timers\n"
2619 "BGP timers\n"
2620 "Keepalive interval\n"
2621 "Holdtime\n")
2622 {
2623 VTY_DECLVAR_CONTEXT(bgp, bgp);
2624 int idx_number = 2;
2625 int idx_number_2 = 3;
2626 unsigned long keepalive = 0;
2627 unsigned long holdtime = 0;
2628
2629 keepalive = strtoul(argv[idx_number]->arg, NULL, 10);
2630 holdtime = strtoul(argv[idx_number_2]->arg, NULL, 10);
2631
2632 /* Holdtime value check. */
2633 if (holdtime < 3 && holdtime != 0) {
2634 vty_out(vty,
2635 "%% hold time value must be either 0 or greater than 3\n");
2636 return CMD_WARNING_CONFIG_FAILED;
2637 }
2638
2639 bgp_timers_set(bgp, keepalive, holdtime, DFLT_BGP_CONNECT_RETRY,
2640 BGP_DEFAULT_DELAYOPEN);
2641
2642 return CMD_SUCCESS;
2643 }
2644
2645 DEFUN (no_bgp_timers,
2646 no_bgp_timers_cmd,
2647 "no timers bgp [(0-65535) (0-65535)]",
2648 NO_STR
2649 "Adjust routing timers\n"
2650 "BGP timers\n"
2651 "Keepalive interval\n"
2652 "Holdtime\n")
2653 {
2654 VTY_DECLVAR_CONTEXT(bgp, bgp);
2655 bgp_timers_set(bgp, DFLT_BGP_KEEPALIVE, DFLT_BGP_HOLDTIME,
2656 DFLT_BGP_CONNECT_RETRY, BGP_DEFAULT_DELAYOPEN);
2657
2658 return CMD_SUCCESS;
2659 }
2660
2661 /* BGP minimum holdtime. */
2662
2663 DEFUN(bgp_minimum_holdtime, bgp_minimum_holdtime_cmd,
2664 "bgp minimum-holdtime (1-65535)",
2665 "BGP specific commands\n"
2666 "BGP minimum holdtime\n"
2667 "Seconds\n")
2668 {
2669 VTY_DECLVAR_CONTEXT(bgp, bgp);
2670 int idx_number = 2;
2671 unsigned long min_holdtime;
2672
2673 min_holdtime = strtoul(argv[idx_number]->arg, NULL, 10);
2674
2675 bgp->default_min_holdtime = min_holdtime;
2676
2677 return CMD_SUCCESS;
2678 }
2679
2680 DEFUN(no_bgp_minimum_holdtime, no_bgp_minimum_holdtime_cmd,
2681 "no bgp minimum-holdtime [(1-65535)]",
2682 NO_STR
2683 "BGP specific commands\n"
2684 "BGP minimum holdtime\n"
2685 "Seconds\n")
2686 {
2687 VTY_DECLVAR_CONTEXT(bgp, bgp);
2688
2689 bgp->default_min_holdtime = 0;
2690
2691 return CMD_SUCCESS;
2692 }
2693
2694 DEFPY(bgp_tcp_keepalive, bgp_tcp_keepalive_cmd,
2695 "bgp tcp-keepalive (1-65535)$idle (1-65535)$intvl (1-30)$probes",
2696 BGP_STR
2697 "TCP keepalive parameters\n"
2698 "TCP keepalive idle time (seconds)\n"
2699 "TCP keepalive interval (seconds)\n"
2700 "TCP keepalive maximum probes\n")
2701 {
2702 VTY_DECLVAR_CONTEXT(bgp, bgp);
2703
2704 bgp_tcp_keepalive_set(bgp, (uint16_t)idle, (uint16_t)intvl,
2705 (uint16_t)probes);
2706
2707 return CMD_SUCCESS;
2708 }
2709
2710 DEFPY(no_bgp_tcp_keepalive, no_bgp_tcp_keepalive_cmd,
2711 "no bgp tcp-keepalive [(1-65535) (1-65535) (1-30)]",
2712 NO_STR
2713 BGP_STR
2714 "TCP keepalive parameters\n"
2715 "TCP keepalive idle time (seconds)\n"
2716 "TCP keepalive interval (seconds)\n"
2717 "TCP keepalive maximum probes\n")
2718 {
2719 VTY_DECLVAR_CONTEXT(bgp, bgp);
2720
2721 bgp_tcp_keepalive_unset(bgp);
2722
2723 return CMD_SUCCESS;
2724 }
2725
2726 DEFUN (bgp_client_to_client_reflection,
2727 bgp_client_to_client_reflection_cmd,
2728 "bgp client-to-client reflection",
2729 BGP_STR
2730 "Configure client to client route reflection\n"
2731 "reflection of routes allowed\n")
2732 {
2733 VTY_DECLVAR_CONTEXT(bgp, bgp);
2734 UNSET_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT);
2735 bgp_clear_star_soft_out(vty, bgp->name);
2736
2737 return CMD_SUCCESS;
2738 }
2739
2740 DEFUN (no_bgp_client_to_client_reflection,
2741 no_bgp_client_to_client_reflection_cmd,
2742 "no bgp client-to-client reflection",
2743 NO_STR
2744 BGP_STR
2745 "Configure client to client route reflection\n"
2746 "reflection of routes allowed\n")
2747 {
2748 VTY_DECLVAR_CONTEXT(bgp, bgp);
2749 SET_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT);
2750 bgp_clear_star_soft_out(vty, bgp->name);
2751
2752 return CMD_SUCCESS;
2753 }
2754
2755 /* "bgp always-compare-med" configuration. */
2756 DEFUN (bgp_always_compare_med,
2757 bgp_always_compare_med_cmd,
2758 "bgp always-compare-med",
2759 BGP_STR
2760 "Allow comparing MED from different neighbors\n")
2761 {
2762 VTY_DECLVAR_CONTEXT(bgp, bgp);
2763 SET_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED);
2764 bgp_recalculate_all_bestpaths(bgp);
2765
2766 return CMD_SUCCESS;
2767 }
2768
2769 DEFUN (no_bgp_always_compare_med,
2770 no_bgp_always_compare_med_cmd,
2771 "no bgp always-compare-med",
2772 NO_STR
2773 BGP_STR
2774 "Allow comparing MED from different neighbors\n")
2775 {
2776 VTY_DECLVAR_CONTEXT(bgp, bgp);
2777 UNSET_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED);
2778 bgp_recalculate_all_bestpaths(bgp);
2779
2780 return CMD_SUCCESS;
2781 }
2782
2783
2784 DEFUN(bgp_ebgp_requires_policy, bgp_ebgp_requires_policy_cmd,
2785 "bgp ebgp-requires-policy",
2786 BGP_STR
2787 "Require in and out policy for eBGP peers (RFC8212)\n")
2788 {
2789 VTY_DECLVAR_CONTEXT(bgp, bgp);
2790 SET_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
2791 return CMD_SUCCESS;
2792 }
2793
2794 DEFUN(no_bgp_ebgp_requires_policy, no_bgp_ebgp_requires_policy_cmd,
2795 "no bgp ebgp-requires-policy",
2796 NO_STR
2797 BGP_STR
2798 "Require in and out policy for eBGP peers (RFC8212)\n")
2799 {
2800 VTY_DECLVAR_CONTEXT(bgp, bgp);
2801 UNSET_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY);
2802 return CMD_SUCCESS;
2803 }
2804
2805 DEFUN(bgp_suppress_duplicates, bgp_suppress_duplicates_cmd,
2806 "bgp suppress-duplicates",
2807 BGP_STR
2808 "Suppress duplicate updates if the route actually not changed\n")
2809 {
2810 VTY_DECLVAR_CONTEXT(bgp, bgp);
2811 SET_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
2812 return CMD_SUCCESS;
2813 }
2814
2815 DEFUN(no_bgp_suppress_duplicates, no_bgp_suppress_duplicates_cmd,
2816 "no bgp suppress-duplicates",
2817 NO_STR
2818 BGP_STR
2819 "Suppress duplicate updates if the route actually not changed\n")
2820 {
2821 VTY_DECLVAR_CONTEXT(bgp, bgp);
2822 UNSET_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES);
2823 return CMD_SUCCESS;
2824 }
2825
2826 DEFUN(bgp_reject_as_sets, bgp_reject_as_sets_cmd,
2827 "bgp reject-as-sets",
2828 BGP_STR
2829 "Reject routes with AS_SET or AS_CONFED_SET flag\n")
2830 {
2831 VTY_DECLVAR_CONTEXT(bgp, bgp);
2832 struct listnode *node, *nnode;
2833 struct peer *peer;
2834
2835 bgp->reject_as_sets = true;
2836
2837 /* Reset existing BGP sessions to reject routes
2838 * with aspath containing AS_SET or AS_CONFED_SET.
2839 */
2840 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2841 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2842 peer->last_reset = PEER_DOWN_AS_SETS_REJECT;
2843 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2844 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2845 }
2846 }
2847
2848 return CMD_SUCCESS;
2849 }
2850
2851 DEFUN(no_bgp_reject_as_sets, no_bgp_reject_as_sets_cmd,
2852 "no bgp reject-as-sets",
2853 NO_STR
2854 BGP_STR
2855 "Reject routes with AS_SET or AS_CONFED_SET flag\n")
2856 {
2857 VTY_DECLVAR_CONTEXT(bgp, bgp);
2858 struct listnode *node, *nnode;
2859 struct peer *peer;
2860
2861 bgp->reject_as_sets = false;
2862
2863 /* Reset existing BGP sessions to reject routes
2864 * with aspath containing AS_SET or AS_CONFED_SET.
2865 */
2866 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2867 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2868 peer->last_reset = PEER_DOWN_AS_SETS_REJECT;
2869 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2870 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2871 }
2872 }
2873
2874 return CMD_SUCCESS;
2875 }
2876
2877 /* "bgp deterministic-med" configuration. */
2878 DEFUN (bgp_deterministic_med,
2879 bgp_deterministic_med_cmd,
2880 "bgp deterministic-med",
2881 BGP_STR
2882 "Pick the best-MED path among paths advertised from the neighboring AS\n")
2883 {
2884 VTY_DECLVAR_CONTEXT(bgp, bgp);
2885
2886 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)) {
2887 SET_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED);
2888 bgp_recalculate_all_bestpaths(bgp);
2889 }
2890
2891 return CMD_SUCCESS;
2892 }
2893
2894 DEFUN (no_bgp_deterministic_med,
2895 no_bgp_deterministic_med_cmd,
2896 "no bgp deterministic-med",
2897 NO_STR
2898 BGP_STR
2899 "Pick the best-MED path among paths advertised from the neighboring AS\n")
2900 {
2901 VTY_DECLVAR_CONTEXT(bgp, bgp);
2902 int bestpath_per_as_used;
2903 afi_t afi;
2904 safi_t safi;
2905 struct peer *peer;
2906 struct listnode *node, *nnode;
2907
2908 if (CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)) {
2909 bestpath_per_as_used = 0;
2910
2911 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
2912 FOREACH_AFI_SAFI (afi, safi)
2913 if (bgp_addpath_dmed_required(
2914 peer->addpath_type[afi][safi])) {
2915 bestpath_per_as_used = 1;
2916 break;
2917 }
2918
2919 if (bestpath_per_as_used)
2920 break;
2921 }
2922
2923 if (bestpath_per_as_used) {
2924 vty_out(vty,
2925 "bgp deterministic-med cannot be disabled while addpath-tx-bestpath-per-AS is in use\n");
2926 return CMD_WARNING_CONFIG_FAILED;
2927 } else {
2928 UNSET_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED);
2929 bgp_recalculate_all_bestpaths(bgp);
2930 }
2931 }
2932
2933 return CMD_SUCCESS;
2934 }
2935
2936 /* "bgp graceful-restart mode" configuration. */
2937 DEFUN (bgp_graceful_restart,
2938 bgp_graceful_restart_cmd,
2939 "bgp graceful-restart",
2940 BGP_STR
2941 GR_CMD
2942 )
2943 {
2944 int ret = BGP_GR_FAILURE;
2945
2946 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2947 zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : START ");
2948
2949 VTY_DECLVAR_CONTEXT(bgp, bgp);
2950
2951 ret = bgp_gr_update_all(bgp, GLOBAL_GR_CMD);
2952
2953 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
2954 ret);
2955
2956 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2957 zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : END ");
2958 vty_out(vty,
2959 "Graceful restart configuration changed, reset all peers to take effect\n");
2960 return bgp_vty_return(vty, ret);
2961 }
2962
2963 DEFUN (no_bgp_graceful_restart,
2964 no_bgp_graceful_restart_cmd,
2965 "no bgp graceful-restart",
2966 NO_STR
2967 BGP_STR
2968 NO_GR_CMD
2969 )
2970 {
2971 VTY_DECLVAR_CONTEXT(bgp, bgp);
2972
2973 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2974 zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : START ");
2975
2976 int ret = BGP_GR_FAILURE;
2977
2978 ret = bgp_gr_update_all(bgp, NO_GLOBAL_GR_CMD);
2979
2980 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
2981 ret);
2982
2983 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
2984 zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : END ");
2985 vty_out(vty,
2986 "Graceful restart configuration changed, reset all peers to take effect\n");
2987
2988 return bgp_vty_return(vty, ret);
2989 }
2990
2991 DEFUN (bgp_graceful_restart_stalepath_time,
2992 bgp_graceful_restart_stalepath_time_cmd,
2993 "bgp graceful-restart stalepath-time (1-4095)",
2994 BGP_STR
2995 "Graceful restart capability parameters\n"
2996 "Set the max time to hold onto restarting peer's stale paths\n"
2997 "Delay value (seconds)\n")
2998 {
2999 VTY_DECLVAR_CONTEXT(bgp, bgp);
3000 int idx_number = 3;
3001 uint32_t stalepath;
3002
3003 stalepath = strtoul(argv[idx_number]->arg, NULL, 10);
3004 bgp->stalepath_time = stalepath;
3005 return CMD_SUCCESS;
3006 }
3007
3008 DEFUN (bgp_graceful_restart_restart_time,
3009 bgp_graceful_restart_restart_time_cmd,
3010 "bgp graceful-restart restart-time (0-4095)",
3011 BGP_STR
3012 "Graceful restart capability parameters\n"
3013 "Set the time to wait to delete stale routes before a BGP open message is received\n"
3014 "Delay value (seconds)\n")
3015 {
3016 VTY_DECLVAR_CONTEXT(bgp, bgp);
3017 int idx_number = 3;
3018 uint32_t restart;
3019
3020 restart = strtoul(argv[idx_number]->arg, NULL, 10);
3021 bgp->restart_time = restart;
3022 return CMD_SUCCESS;
3023 }
3024
3025 DEFUN (bgp_graceful_restart_select_defer_time,
3026 bgp_graceful_restart_select_defer_time_cmd,
3027 "bgp graceful-restart select-defer-time (0-3600)",
3028 BGP_STR
3029 "Graceful restart capability parameters\n"
3030 "Set the time to defer the BGP route selection after restart\n"
3031 "Delay value (seconds, 0 - disable)\n")
3032 {
3033 VTY_DECLVAR_CONTEXT(bgp, bgp);
3034 int idx_number = 3;
3035 uint32_t defer_time;
3036
3037 defer_time = strtoul(argv[idx_number]->arg, NULL, 10);
3038 bgp->select_defer_time = defer_time;
3039 if (defer_time == 0)
3040 SET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
3041 else
3042 UNSET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
3043
3044 return CMD_SUCCESS;
3045 }
3046
3047 DEFUN (no_bgp_graceful_restart_stalepath_time,
3048 no_bgp_graceful_restart_stalepath_time_cmd,
3049 "no bgp graceful-restart stalepath-time [(1-4095)]",
3050 NO_STR
3051 BGP_STR
3052 "Graceful restart capability parameters\n"
3053 "Set the max time to hold onto restarting peer's stale paths\n"
3054 "Delay value (seconds)\n")
3055 {
3056 VTY_DECLVAR_CONTEXT(bgp, bgp);
3057
3058 bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
3059 return CMD_SUCCESS;
3060 }
3061
3062 DEFUN (no_bgp_graceful_restart_restart_time,
3063 no_bgp_graceful_restart_restart_time_cmd,
3064 "no bgp graceful-restart restart-time [(0-4095)]",
3065 NO_STR
3066 BGP_STR
3067 "Graceful restart capability parameters\n"
3068 "Set the time to wait to delete stale routes before a BGP open message is received\n"
3069 "Delay value (seconds)\n")
3070 {
3071 VTY_DECLVAR_CONTEXT(bgp, bgp);
3072
3073 bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
3074 return CMD_SUCCESS;
3075 }
3076
3077 DEFUN (no_bgp_graceful_restart_select_defer_time,
3078 no_bgp_graceful_restart_select_defer_time_cmd,
3079 "no bgp graceful-restart select-defer-time [(0-3600)]",
3080 NO_STR
3081 BGP_STR
3082 "Graceful restart capability parameters\n"
3083 "Set the time to defer the BGP route selection after restart\n"
3084 "Delay value (seconds)\n")
3085 {
3086 VTY_DECLVAR_CONTEXT(bgp, bgp);
3087
3088 bgp->select_defer_time = BGP_DEFAULT_SELECT_DEFERRAL_TIME;
3089 UNSET_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE);
3090
3091 return CMD_SUCCESS;
3092 }
3093
3094 DEFUN (bgp_graceful_restart_preserve_fw,
3095 bgp_graceful_restart_preserve_fw_cmd,
3096 "bgp graceful-restart preserve-fw-state",
3097 BGP_STR
3098 "Graceful restart capability parameters\n"
3099 "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
3100 {
3101 VTY_DECLVAR_CONTEXT(bgp, bgp);
3102 SET_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD);
3103 return CMD_SUCCESS;
3104 }
3105
3106 DEFUN (no_bgp_graceful_restart_preserve_fw,
3107 no_bgp_graceful_restart_preserve_fw_cmd,
3108 "no bgp graceful-restart preserve-fw-state",
3109 NO_STR
3110 BGP_STR
3111 "Graceful restart capability parameters\n"
3112 "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
3113 {
3114 VTY_DECLVAR_CONTEXT(bgp, bgp);
3115 UNSET_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD);
3116 return CMD_SUCCESS;
3117 }
3118
3119 DEFPY (bgp_graceful_restart_notification,
3120 bgp_graceful_restart_notification_cmd,
3121 "[no$no] bgp graceful-restart notification",
3122 NO_STR
3123 BGP_STR
3124 "Graceful restart capability parameters\n"
3125 "Indicate Graceful Restart support for BGP NOTIFICATION messages\n")
3126 {
3127 VTY_DECLVAR_CONTEXT(bgp, bgp);
3128
3129 if (no)
3130 UNSET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
3131 else
3132 SET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION);
3133
3134 return CMD_SUCCESS;
3135 }
3136
3137 DEFPY (bgp_administrative_reset,
3138 bgp_administrative_reset_cmd,
3139 "[no$no] bgp hard-administrative-reset",
3140 NO_STR
3141 BGP_STR
3142 "Send Hard Reset CEASE Notification for 'Administrative Reset'\n")
3143 {
3144 VTY_DECLVAR_CONTEXT(bgp, bgp);
3145
3146 if (no)
3147 UNSET_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET);
3148 else
3149 SET_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET);
3150
3151 return CMD_SUCCESS;
3152 }
3153
3154 DEFUN (bgp_graceful_restart_disable,
3155 bgp_graceful_restart_disable_cmd,
3156 "bgp graceful-restart-disable",
3157 BGP_STR
3158 GR_DISABLE)
3159 {
3160 int ret = BGP_GR_FAILURE;
3161
3162 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3163 zlog_debug(
3164 "[BGP_GR] bgp_graceful_restart_disable_cmd : START ");
3165
3166 VTY_DECLVAR_CONTEXT(bgp, bgp);
3167
3168 ret = bgp_gr_update_all(bgp, GLOBAL_DISABLE_CMD);
3169
3170 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp,
3171 bgp->peer, ret);
3172
3173 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3174 zlog_debug(
3175 "[BGP_GR] bgp_graceful_restart_disable_cmd : END ");
3176 vty_out(vty,
3177 "Graceful restart configuration changed, reset all peers to take effect\n");
3178
3179 return bgp_vty_return(vty, ret);
3180 }
3181
3182 DEFUN (no_bgp_graceful_restart_disable,
3183 no_bgp_graceful_restart_disable_cmd,
3184 "no bgp graceful-restart-disable",
3185 NO_STR
3186 BGP_STR
3187 NO_GR_DISABLE
3188 )
3189 {
3190 VTY_DECLVAR_CONTEXT(bgp, bgp);
3191
3192 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3193 zlog_debug(
3194 "[BGP_GR] no_bgp_graceful_restart_disable_cmd : START ");
3195
3196 int ret = BGP_GR_FAILURE;
3197
3198 ret = bgp_gr_update_all(bgp, NO_GLOBAL_DISABLE_CMD);
3199
3200 VTY_BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer,
3201 ret);
3202
3203 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3204 zlog_debug(
3205 "[BGP_GR] no_bgp_graceful_restart_disable_cmd : END ");
3206 vty_out(vty,
3207 "Graceful restart configuration changed, reset all peers to take effect\n");
3208
3209 return bgp_vty_return(vty, ret);
3210 }
3211
3212 DEFUN (bgp_neighbor_graceful_restart_set,
3213 bgp_neighbor_graceful_restart_set_cmd,
3214 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
3215 NEIGHBOR_STR
3216 NEIGHBOR_ADDR_STR2
3217 GR_NEIGHBOR_CMD
3218 )
3219 {
3220 int idx_peer = 1;
3221 struct peer *peer;
3222 int ret = BGP_GR_FAILURE;
3223
3224 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3225
3226 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3227 zlog_debug(
3228 "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : START ");
3229
3230 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3231 if (!peer)
3232 return CMD_WARNING_CONFIG_FAILED;
3233
3234 ret = bgp_neighbor_graceful_restart(peer, PEER_GR_CMD);
3235
3236 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3237 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3238
3239 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3240 zlog_debug(
3241 "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : END ");
3242 vty_out(vty,
3243 "Graceful restart configuration changed, reset this peer to take effect\n");
3244
3245 return bgp_vty_return(vty, ret);
3246 }
3247
3248 DEFUN (no_bgp_neighbor_graceful_restart,
3249 no_bgp_neighbor_graceful_restart_set_cmd,
3250 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
3251 NO_STR
3252 NEIGHBOR_STR
3253 NEIGHBOR_ADDR_STR2
3254 NO_GR_NEIGHBOR_CMD
3255 )
3256 {
3257 int idx_peer = 2;
3258 int ret = BGP_GR_FAILURE;
3259 struct peer *peer;
3260
3261 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3262
3263 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3264 if (!peer)
3265 return CMD_WARNING_CONFIG_FAILED;
3266
3267 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3268 zlog_debug(
3269 "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : START ");
3270
3271 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_GR_CMD);
3272
3273 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3274 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3275
3276 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3277 zlog_debug(
3278 "[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : END ");
3279 vty_out(vty,
3280 "Graceful restart configuration changed, reset this peer to take effect\n");
3281
3282 return bgp_vty_return(vty, ret);
3283 }
3284
3285 DEFUN (bgp_neighbor_graceful_restart_helper_set,
3286 bgp_neighbor_graceful_restart_helper_set_cmd,
3287 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
3288 NEIGHBOR_STR
3289 NEIGHBOR_ADDR_STR2
3290 GR_NEIGHBOR_HELPER_CMD
3291 )
3292 {
3293 int idx_peer = 1;
3294 struct peer *peer;
3295 int ret = BGP_GR_FAILURE;
3296
3297 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3298
3299 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3300 zlog_debug(
3301 "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : START ");
3302
3303 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3304
3305 if (!peer)
3306 return CMD_WARNING_CONFIG_FAILED;
3307
3308
3309 ret = bgp_neighbor_graceful_restart(peer, PEER_HELPER_CMD);
3310
3311 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3312 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3313
3314 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3315 zlog_debug(
3316 "[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : END ");
3317 vty_out(vty,
3318 "Graceful restart configuration changed, reset this peer to take effect\n");
3319
3320 return bgp_vty_return(vty, ret);
3321 }
3322
3323 DEFUN (no_bgp_neighbor_graceful_restart_helper,
3324 no_bgp_neighbor_graceful_restart_helper_set_cmd,
3325 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
3326 NO_STR
3327 NEIGHBOR_STR
3328 NEIGHBOR_ADDR_STR2
3329 NO_GR_NEIGHBOR_HELPER_CMD
3330 )
3331 {
3332 int idx_peer = 2;
3333 int ret = BGP_GR_FAILURE;
3334 struct peer *peer;
3335
3336 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3337
3338 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3339 if (!peer)
3340 return CMD_WARNING_CONFIG_FAILED;
3341
3342 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3343 zlog_debug(
3344 "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
3345
3346 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_HELPER_CMD);
3347
3348 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3349 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3350
3351 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3352 zlog_debug(
3353 "[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
3354 vty_out(vty,
3355 "Graceful restart configuration changed, reset this peer to take effect\n");
3356
3357 return bgp_vty_return(vty, ret);
3358 }
3359
3360 DEFUN (bgp_neighbor_graceful_restart_disable_set,
3361 bgp_neighbor_graceful_restart_disable_set_cmd,
3362 "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
3363 NEIGHBOR_STR
3364 NEIGHBOR_ADDR_STR2
3365 GR_NEIGHBOR_DISABLE_CMD
3366 )
3367 {
3368 int idx_peer = 1;
3369 struct peer *peer;
3370 int ret = BGP_GR_FAILURE;
3371
3372 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3373
3374 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3375 zlog_debug(
3376 "[BGP_GR] bgp_neighbor_graceful_restart_disable_set_cmd : START ");
3377
3378 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3379 if (!peer)
3380 return CMD_WARNING_CONFIG_FAILED;
3381
3382 ret = bgp_neighbor_graceful_restart(peer, PEER_DISABLE_CMD);
3383
3384 if (peer->bgp->t_startup)
3385 bgp_peer_gr_flags_update(peer);
3386
3387 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3388 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3389
3390 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3391 zlog_debug(
3392 "[BGP_GR]bgp_neighbor_graceful_restart_disable_set_cmd : END ");
3393 vty_out(vty,
3394 "Graceful restart configuration changed, reset this peer to take effect\n");
3395
3396 return bgp_vty_return(vty, ret);
3397 }
3398
3399 DEFUN (no_bgp_neighbor_graceful_restart_disable,
3400 no_bgp_neighbor_graceful_restart_disable_set_cmd,
3401 "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
3402 NO_STR
3403 NEIGHBOR_STR
3404 NEIGHBOR_ADDR_STR2
3405 NO_GR_NEIGHBOR_DISABLE_CMD
3406 )
3407 {
3408 int idx_peer = 2;
3409 int ret = BGP_GR_FAILURE;
3410 struct peer *peer;
3411
3412 VTY_BGP_GR_DEFINE_LOOP_VARIABLE;
3413
3414 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3415 if (!peer)
3416 return CMD_WARNING_CONFIG_FAILED;
3417
3418 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3419 zlog_debug(
3420 "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
3421
3422 ret = bgp_neighbor_graceful_restart(peer, NO_PEER_DISABLE_CMD);
3423
3424 VTY_BGP_GR_ROUTER_DETECT(bgp, peer, peer->bgp->peer);
3425 VTY_SEND_BGP_GR_CAPABILITY_TO_ZEBRA(peer->bgp, ret);
3426
3427 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
3428 zlog_debug(
3429 "[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
3430 vty_out(vty,
3431 "Graceful restart configuration changed, reset this peer to take effect\n");
3432
3433 return bgp_vty_return(vty, ret);
3434 }
3435
3436 DEFPY (neighbor_graceful_shutdown,
3437 neighbor_graceful_shutdown_cmd,
3438 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor graceful-shutdown",
3439 NO_STR
3440 NEIGHBOR_STR
3441 NEIGHBOR_ADDR_STR2
3442 "Graceful shutdown\n")
3443 {
3444 afi_t afi;
3445 safi_t safi;
3446 struct peer *peer;
3447 VTY_DECLVAR_CONTEXT(bgp, bgp);
3448 int ret;
3449
3450 peer = peer_and_group_lookup_vty(vty, neighbor);
3451 if (!peer)
3452 return CMD_WARNING_CONFIG_FAILED;
3453
3454 if (no)
3455 ret = peer_flag_unset_vty(vty, neighbor,
3456 PEER_FLAG_GRACEFUL_SHUTDOWN);
3457 else
3458 ret = peer_flag_set_vty(vty, neighbor,
3459 PEER_FLAG_GRACEFUL_SHUTDOWN);
3460
3461 FOREACH_AFI_SAFI (afi, safi) {
3462 if (!peer->afc[afi][safi])
3463 continue;
3464
3465 bgp_clear(vty, bgp, afi, safi, clear_peer, BGP_CLEAR_SOFT_IN,
3466 neighbor);
3467 }
3468
3469 return ret;
3470 }
3471
3472 DEFUN_HIDDEN (bgp_graceful_restart_disable_eor,
3473 bgp_graceful_restart_disable_eor_cmd,
3474 "bgp graceful-restart disable-eor",
3475 BGP_STR
3476 "Graceful restart configuration parameters\n"
3477 "Disable EOR Check\n")
3478 {
3479 VTY_DECLVAR_CONTEXT(bgp, bgp);
3480 SET_FLAG(bgp->flags, BGP_FLAG_GR_DISABLE_EOR);
3481
3482 return CMD_SUCCESS;
3483 }
3484
3485 DEFUN_HIDDEN (no_bgp_graceful_restart_disable_eor,
3486 no_bgp_graceful_restart_disable_eor_cmd,
3487 "no bgp graceful-restart disable-eor",
3488 NO_STR
3489 BGP_STR
3490 "Graceful restart configuration parameters\n"
3491 "Disable EOR Check\n")
3492 {
3493 VTY_DECLVAR_CONTEXT(bgp, bgp);
3494 UNSET_FLAG(bgp->flags, BGP_FLAG_GR_DISABLE_EOR);
3495
3496 return CMD_SUCCESS;
3497 }
3498
3499 DEFUN (bgp_graceful_restart_rib_stale_time,
3500 bgp_graceful_restart_rib_stale_time_cmd,
3501 "bgp graceful-restart rib-stale-time (1-3600)",
3502 BGP_STR
3503 "Graceful restart configuration parameters\n"
3504 "Specify the stale route removal timer in rib\n"
3505 "Delay value (seconds)\n")
3506 {
3507 VTY_DECLVAR_CONTEXT(bgp, bgp);
3508 int idx_number = 3;
3509 uint32_t stale_time;
3510
3511 stale_time = strtoul(argv[idx_number]->arg, NULL, 10);
3512 bgp->rib_stale_time = stale_time;
3513 /* Send the stale timer update message to RIB */
3514 if (bgp_zebra_stale_timer_update(bgp))
3515 return CMD_WARNING;
3516
3517 return CMD_SUCCESS;
3518 }
3519
3520 DEFUN (no_bgp_graceful_restart_rib_stale_time,
3521 no_bgp_graceful_restart_rib_stale_time_cmd,
3522 "no bgp graceful-restart rib-stale-time [(1-3600)]",
3523 NO_STR
3524 BGP_STR
3525 "Graceful restart configuration parameters\n"
3526 "Specify the stale route removal timer in rib\n"
3527 "Delay value (seconds)\n")
3528 {
3529 VTY_DECLVAR_CONTEXT(bgp, bgp);
3530
3531 bgp->rib_stale_time = BGP_DEFAULT_RIB_STALE_TIME;
3532 /* Send the stale timer update message to RIB */
3533 if (bgp_zebra_stale_timer_update(bgp))
3534 return CMD_WARNING;
3535
3536 return CMD_SUCCESS;
3537 }
3538
3539 DEFUN(bgp_llgr_stalepath_time, bgp_llgr_stalepath_time_cmd,
3540 "bgp long-lived-graceful-restart stale-time (1-16777215)",
3541 BGP_STR
3542 "Enable Long-lived Graceful Restart\n"
3543 "Specifies maximum time to wait before purging long-lived stale routes\n"
3544 "Stale time value (seconds)\n")
3545 {
3546 VTY_DECLVAR_CONTEXT(bgp, bgp);
3547
3548 uint32_t llgr_stale_time;
3549
3550 llgr_stale_time = strtoul(argv[3]->arg, NULL, 10);
3551 bgp->llgr_stale_time = llgr_stale_time;
3552
3553 return CMD_SUCCESS;
3554 }
3555
3556 DEFUN(no_bgp_llgr_stalepath_time, no_bgp_llgr_stalepath_time_cmd,
3557 "no bgp long-lived-graceful-restart stale-time [(1-16777215)]",
3558 NO_STR BGP_STR
3559 "Enable Long-lived Graceful Restart\n"
3560 "Specifies maximum time to wait before purging long-lived stale routes\n"
3561 "Stale time value (seconds)\n")
3562 {
3563 VTY_DECLVAR_CONTEXT(bgp, bgp);
3564
3565 bgp->llgr_stale_time = BGP_DEFAULT_LLGR_STALE_TIME;
3566
3567 return CMD_SUCCESS;
3568 }
3569
3570 static inline void bgp_initiate_graceful_shut_unshut(struct vty *vty,
3571 struct bgp *bgp)
3572 {
3573 bgp_static_redo_import_check(bgp);
3574 bgp_redistribute_redo(bgp);
3575 bgp_clear_star_soft_out(vty, bgp->name);
3576 bgp_clear_star_soft_in(vty, bgp->name);
3577 }
3578
3579 static int bgp_global_graceful_shutdown_config_vty(struct vty *vty)
3580 {
3581 struct listnode *node, *nnode;
3582 struct bgp *bgp;
3583 bool vrf_cfg = false;
3584
3585 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
3586 return CMD_SUCCESS;
3587
3588 /* See if graceful-shutdown is set per-vrf and warn user to delete */
3589 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
3590 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3591 vty_out(vty,
3592 "%% graceful-shutdown configuration found in vrf %s\n",
3593 bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT ?
3594 VRF_DEFAULT_NAME : bgp->name);
3595 vrf_cfg = true;
3596 }
3597 }
3598
3599 if (vrf_cfg) {
3600 vty_out(vty,
3601 "%%Failed: global graceful-shutdown not permitted\n");
3602 return CMD_WARNING;
3603 }
3604
3605 /* Set flag globally */
3606 SET_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN);
3607
3608 /* Initiate processing for all BGP instances. */
3609 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3610 bgp_initiate_graceful_shut_unshut(vty, bgp);
3611
3612 return CMD_SUCCESS;
3613 }
3614
3615 static int bgp_global_graceful_shutdown_deconfig_vty(struct vty *vty)
3616 {
3617 struct listnode *node, *nnode;
3618 struct bgp *bgp;
3619
3620 if (!CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
3621 return CMD_SUCCESS;
3622
3623 /* Unset flag globally */
3624 UNSET_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN);
3625
3626 /* Initiate processing for all BGP instances. */
3627 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3628 bgp_initiate_graceful_shut_unshut(vty, bgp);
3629
3630 return CMD_SUCCESS;
3631 }
3632
3633 /* "bgp graceful-shutdown" configuration */
3634 DEFUN (bgp_graceful_shutdown,
3635 bgp_graceful_shutdown_cmd,
3636 "bgp graceful-shutdown",
3637 BGP_STR
3638 "Graceful shutdown parameters\n")
3639 {
3640 if (vty->node == CONFIG_NODE)
3641 return bgp_global_graceful_shutdown_config_vty(vty);
3642
3643 VTY_DECLVAR_CONTEXT(bgp, bgp);
3644
3645 /* if configured globally, per-instance config is not allowed */
3646 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN)) {
3647 vty_out(vty,
3648 "%%Failed: per-vrf graceful-shutdown config not permitted with global graceful-shutdown\n");
3649 return CMD_WARNING_CONFIG_FAILED;
3650 }
3651
3652 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3653 SET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN);
3654 bgp_initiate_graceful_shut_unshut(vty, bgp);
3655 }
3656
3657 return CMD_SUCCESS;
3658 }
3659
3660 DEFUN (no_bgp_graceful_shutdown,
3661 no_bgp_graceful_shutdown_cmd,
3662 "no bgp graceful-shutdown",
3663 NO_STR
3664 BGP_STR
3665 "Graceful shutdown parameters\n")
3666 {
3667 if (vty->node == CONFIG_NODE)
3668 return bgp_global_graceful_shutdown_deconfig_vty(vty);
3669
3670 VTY_DECLVAR_CONTEXT(bgp, bgp);
3671
3672 /* If configured globally, cannot remove from one bgp instance */
3673 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN)) {
3674 vty_out(vty,
3675 "%%Failed: bgp graceful-shutdown configured globally. Delete per-vrf not permitted\n");
3676 return CMD_WARNING_CONFIG_FAILED;
3677 }
3678
3679 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
3680 UNSET_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN);
3681 bgp_initiate_graceful_shut_unshut(vty, bgp);
3682 }
3683
3684 return CMD_SUCCESS;
3685 }
3686
3687 /* "bgp fast-external-failover" configuration. */
3688 DEFUN (bgp_fast_external_failover,
3689 bgp_fast_external_failover_cmd,
3690 "bgp fast-external-failover",
3691 BGP_STR
3692 "Immediately reset session if a link to a directly connected external peer goes down\n")
3693 {
3694 VTY_DECLVAR_CONTEXT(bgp, bgp);
3695 UNSET_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER);
3696 return CMD_SUCCESS;
3697 }
3698
3699 DEFUN (no_bgp_fast_external_failover,
3700 no_bgp_fast_external_failover_cmd,
3701 "no bgp fast-external-failover",
3702 NO_STR
3703 BGP_STR
3704 "Immediately reset session if a link to a directly connected external peer goes down\n")
3705 {
3706 VTY_DECLVAR_CONTEXT(bgp, bgp);
3707 SET_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER);
3708 return CMD_SUCCESS;
3709 }
3710
3711 DEFPY (bgp_bestpath_aigp,
3712 bgp_bestpath_aigp_cmd,
3713 "[no$no] bgp bestpath aigp",
3714 NO_STR
3715 BGP_STR
3716 "Change the default bestpath selection\n"
3717 "Evaluate the AIGP attribute during the best path selection process\n")
3718 {
3719 VTY_DECLVAR_CONTEXT(bgp, bgp);
3720
3721 if (no)
3722 UNSET_FLAG(bgp->flags, BGP_FLAG_COMPARE_AIGP);
3723 else
3724 SET_FLAG(bgp->flags, BGP_FLAG_COMPARE_AIGP);
3725
3726 bgp_recalculate_all_bestpaths(bgp);
3727
3728 return CMD_SUCCESS;
3729 }
3730
3731 /* "bgp bestpath compare-routerid" configuration. */
3732 DEFUN (bgp_bestpath_compare_router_id,
3733 bgp_bestpath_compare_router_id_cmd,
3734 "bgp bestpath compare-routerid",
3735 BGP_STR
3736 "Change the default bestpath selection\n"
3737 "Compare router-id for identical EBGP paths\n")
3738 {
3739 VTY_DECLVAR_CONTEXT(bgp, bgp);
3740 SET_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID);
3741 bgp_recalculate_all_bestpaths(bgp);
3742
3743 return CMD_SUCCESS;
3744 }
3745
3746 DEFUN (no_bgp_bestpath_compare_router_id,
3747 no_bgp_bestpath_compare_router_id_cmd,
3748 "no bgp bestpath compare-routerid",
3749 NO_STR
3750 BGP_STR
3751 "Change the default bestpath selection\n"
3752 "Compare router-id for identical EBGP paths\n")
3753 {
3754 VTY_DECLVAR_CONTEXT(bgp, bgp);
3755 UNSET_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID);
3756 bgp_recalculate_all_bestpaths(bgp);
3757
3758 return CMD_SUCCESS;
3759 }
3760
3761 /* "bgp bestpath as-path ignore" configuration. */
3762 DEFUN (bgp_bestpath_aspath_ignore,
3763 bgp_bestpath_aspath_ignore_cmd,
3764 "bgp bestpath as-path ignore",
3765 BGP_STR
3766 "Change the default bestpath selection\n"
3767 "AS-path attribute\n"
3768 "Ignore as-path length in selecting a route\n")
3769 {
3770 VTY_DECLVAR_CONTEXT(bgp, bgp);
3771 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE);
3772 bgp_recalculate_all_bestpaths(bgp);
3773
3774 return CMD_SUCCESS;
3775 }
3776
3777 DEFUN (no_bgp_bestpath_aspath_ignore,
3778 no_bgp_bestpath_aspath_ignore_cmd,
3779 "no bgp bestpath as-path ignore",
3780 NO_STR
3781 BGP_STR
3782 "Change the default bestpath selection\n"
3783 "AS-path attribute\n"
3784 "Ignore as-path length in selecting a route\n")
3785 {
3786 VTY_DECLVAR_CONTEXT(bgp, bgp);
3787 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE);
3788 bgp_recalculate_all_bestpaths(bgp);
3789
3790 return CMD_SUCCESS;
3791 }
3792
3793 /* "bgp bestpath as-path confed" configuration. */
3794 DEFUN (bgp_bestpath_aspath_confed,
3795 bgp_bestpath_aspath_confed_cmd,
3796 "bgp bestpath as-path confed",
3797 BGP_STR
3798 "Change the default bestpath selection\n"
3799 "AS-path attribute\n"
3800 "Compare path lengths including confederation sets & sequences in selecting a route\n")
3801 {
3802 VTY_DECLVAR_CONTEXT(bgp, bgp);
3803 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED);
3804 bgp_recalculate_all_bestpaths(bgp);
3805
3806 return CMD_SUCCESS;
3807 }
3808
3809 DEFUN (no_bgp_bestpath_aspath_confed,
3810 no_bgp_bestpath_aspath_confed_cmd,
3811 "no bgp bestpath as-path confed",
3812 NO_STR
3813 BGP_STR
3814 "Change the default bestpath selection\n"
3815 "AS-path attribute\n"
3816 "Compare path lengths including confederation sets & sequences in selecting a route\n")
3817 {
3818 VTY_DECLVAR_CONTEXT(bgp, bgp);
3819 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED);
3820 bgp_recalculate_all_bestpaths(bgp);
3821
3822 return CMD_SUCCESS;
3823 }
3824
3825 /* "bgp bestpath as-path multipath-relax" configuration. */
3826 DEFUN (bgp_bestpath_aspath_multipath_relax,
3827 bgp_bestpath_aspath_multipath_relax_cmd,
3828 "bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
3829 BGP_STR
3830 "Change the default bestpath selection\n"
3831 "AS-path attribute\n"
3832 "Allow load sharing across routes that have different AS paths (but same length)\n"
3833 "Generate an AS_SET\n"
3834 "Do not generate an AS_SET\n")
3835 {
3836 VTY_DECLVAR_CONTEXT(bgp, bgp);
3837 int idx = 0;
3838 SET_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
3839
3840 /* no-as-set is now the default behavior so we can silently
3841 * ignore it */
3842 if (argv_find(argv, argc, "as-set", &idx))
3843 SET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3844 else
3845 UNSET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3846
3847 bgp_recalculate_all_bestpaths(bgp);
3848
3849 return CMD_SUCCESS;
3850 }
3851
3852 DEFUN (no_bgp_bestpath_aspath_multipath_relax,
3853 no_bgp_bestpath_aspath_multipath_relax_cmd,
3854 "no bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
3855 NO_STR
3856 BGP_STR
3857 "Change the default bestpath selection\n"
3858 "AS-path attribute\n"
3859 "Allow load sharing across routes that have different AS paths (but same length)\n"
3860 "Generate an AS_SET\n"
3861 "Do not generate an AS_SET\n")
3862 {
3863 VTY_DECLVAR_CONTEXT(bgp, bgp);
3864 UNSET_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
3865 UNSET_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
3866 bgp_recalculate_all_bestpaths(bgp);
3867
3868 return CMD_SUCCESS;
3869 }
3870
3871 /* "bgp bestpath peer-type multipath-relax" configuration. */
3872 DEFUN(bgp_bestpath_peer_type_multipath_relax,
3873 bgp_bestpath_peer_type_multipath_relax_cmd,
3874 "bgp bestpath peer-type multipath-relax",
3875 BGP_STR
3876 "Change the default bestpath selection\n"
3877 "Peer type\n"
3878 "Allow load sharing across routes learned from different peer types\n")
3879 {
3880 VTY_DECLVAR_CONTEXT(bgp, bgp);
3881 SET_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX);
3882 bgp_recalculate_all_bestpaths(bgp);
3883
3884 return CMD_SUCCESS;
3885 }
3886
3887 DEFUN(no_bgp_bestpath_peer_type_multipath_relax,
3888 no_bgp_bestpath_peer_type_multipath_relax_cmd,
3889 "no bgp bestpath peer-type multipath-relax",
3890 NO_STR BGP_STR
3891 "Change the default bestpath selection\n"
3892 "Peer type\n"
3893 "Allow load sharing across routes learned from different peer types\n")
3894 {
3895 VTY_DECLVAR_CONTEXT(bgp, bgp);
3896 UNSET_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX);
3897 bgp_recalculate_all_bestpaths(bgp);
3898
3899 return CMD_SUCCESS;
3900 }
3901
3902 /* "bgp log-neighbor-changes" configuration. */
3903 DEFUN (bgp_log_neighbor_changes,
3904 bgp_log_neighbor_changes_cmd,
3905 "bgp log-neighbor-changes",
3906 BGP_STR
3907 "Log neighbor up/down and reset reason\n")
3908 {
3909 VTY_DECLVAR_CONTEXT(bgp, bgp);
3910 SET_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
3911 return CMD_SUCCESS;
3912 }
3913
3914 DEFUN (no_bgp_log_neighbor_changes,
3915 no_bgp_log_neighbor_changes_cmd,
3916 "no bgp log-neighbor-changes",
3917 NO_STR
3918 BGP_STR
3919 "Log neighbor up/down and reset reason\n")
3920 {
3921 VTY_DECLVAR_CONTEXT(bgp, bgp);
3922 UNSET_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
3923 return CMD_SUCCESS;
3924 }
3925
3926 /* "bgp bestpath med" configuration. */
3927 DEFUN (bgp_bestpath_med,
3928 bgp_bestpath_med_cmd,
3929 "bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
3930 BGP_STR
3931 "Change the default bestpath selection\n"
3932 "MED attribute\n"
3933 "Compare MED among confederation paths\n"
3934 "Treat missing MED as the least preferred one\n"
3935 "Treat missing MED as the least preferred one\n"
3936 "Compare MED among confederation paths\n")
3937 {
3938 VTY_DECLVAR_CONTEXT(bgp, bgp);
3939
3940 int idx = 0;
3941 if (argv_find(argv, argc, "confed", &idx))
3942 SET_FLAG(bgp->flags, BGP_FLAG_MED_CONFED);
3943 idx = 0;
3944 if (argv_find(argv, argc, "missing-as-worst", &idx))
3945 SET_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST);
3946
3947 bgp_recalculate_all_bestpaths(bgp);
3948
3949 return CMD_SUCCESS;
3950 }
3951
3952 DEFUN (no_bgp_bestpath_med,
3953 no_bgp_bestpath_med_cmd,
3954 "no bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
3955 NO_STR
3956 BGP_STR
3957 "Change the default bestpath selection\n"
3958 "MED attribute\n"
3959 "Compare MED among confederation paths\n"
3960 "Treat missing MED as the least preferred one\n"
3961 "Treat missing MED as the least preferred one\n"
3962 "Compare MED among confederation paths\n")
3963 {
3964 VTY_DECLVAR_CONTEXT(bgp, bgp);
3965
3966 int idx = 0;
3967 if (argv_find(argv, argc, "confed", &idx))
3968 UNSET_FLAG(bgp->flags, BGP_FLAG_MED_CONFED);
3969 idx = 0;
3970 if (argv_find(argv, argc, "missing-as-worst", &idx))
3971 UNSET_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST);
3972
3973 bgp_recalculate_all_bestpaths(bgp);
3974
3975 return CMD_SUCCESS;
3976 }
3977
3978 /* "bgp bestpath bandwidth" configuration. */
3979 DEFPY (bgp_bestpath_bw,
3980 bgp_bestpath_bw_cmd,
3981 "bgp bestpath bandwidth <ignore|skip-missing|default-weight-for-missing>$bw_cfg",
3982 BGP_STR
3983 "Change the default bestpath selection\n"
3984 "Link Bandwidth attribute\n"
3985 "Ignore link bandwidth (i.e., do regular ECMP, not weighted)\n"
3986 "Ignore paths without link bandwidth for ECMP (if other paths have it)\n"
3987 "Assign a low default weight (value 1) to paths not having link bandwidth\n")
3988 {
3989 VTY_DECLVAR_CONTEXT(bgp, bgp);
3990 afi_t afi;
3991 safi_t safi;
3992
3993 if (!bw_cfg) {
3994 vty_out(vty, "%% Bandwidth configuration must be specified\n");
3995 return CMD_ERR_INCOMPLETE;
3996 }
3997 if (!strcmp(bw_cfg, "ignore"))
3998 bgp->lb_handling = BGP_LINK_BW_IGNORE_BW;
3999 else if (!strcmp(bw_cfg, "skip-missing"))
4000 bgp->lb_handling = BGP_LINK_BW_SKIP_MISSING;
4001 else if (!strcmp(bw_cfg, "default-weight-for-missing"))
4002 bgp->lb_handling = BGP_LINK_BW_DEFWT_4_MISSING;
4003 else
4004 return CMD_ERR_NO_MATCH;
4005
4006 /* This config is used in route install, so redo that. */
4007 FOREACH_AFI_SAFI (afi, safi) {
4008 if (!bgp_fibupd_safi(safi))
4009 continue;
4010 bgp_zebra_announce_table(bgp, afi, safi);
4011 }
4012
4013 return CMD_SUCCESS;
4014 }
4015
4016 DEFPY (no_bgp_bestpath_bw,
4017 no_bgp_bestpath_bw_cmd,
4018 "no bgp bestpath bandwidth [<ignore|skip-missing|default-weight-for-missing>$bw_cfg]",
4019 NO_STR
4020 BGP_STR
4021 "Change the default bestpath selection\n"
4022 "Link Bandwidth attribute\n"
4023 "Ignore link bandwidth (i.e., do regular ECMP, not weighted)\n"
4024 "Ignore paths without link bandwidth for ECMP (if other paths have it)\n"
4025 "Assign a low default weight (value 1) to paths not having link bandwidth\n")
4026 {
4027 VTY_DECLVAR_CONTEXT(bgp, bgp);
4028 afi_t afi;
4029 safi_t safi;
4030
4031 bgp->lb_handling = BGP_LINK_BW_ECMP;
4032
4033 /* This config is used in route install, so redo that. */
4034 FOREACH_AFI_SAFI (afi, safi) {
4035 if (!bgp_fibupd_safi(safi))
4036 continue;
4037 bgp_zebra_announce_table(bgp, afi, safi);
4038 }
4039 return CMD_SUCCESS;
4040 }
4041
4042 DEFPY(bgp_default_afi_safi, bgp_default_afi_safi_cmd,
4043 "[no] bgp default <ipv4-unicast|"
4044 "ipv4-multicast|"
4045 "ipv4-vpn|"
4046 "ipv4-labeled-unicast|"
4047 "ipv4-flowspec|"
4048 "ipv6-unicast|"
4049 "ipv6-multicast|"
4050 "ipv6-vpn|"
4051 "ipv6-labeled-unicast|"
4052 "ipv6-flowspec|"
4053 "l2vpn-evpn>$afi_safi",
4054 NO_STR
4055 BGP_STR
4056 "Configure BGP defaults\n"
4057 "Activate ipv4-unicast for a peer by default\n"
4058 "Activate ipv4-multicast for a peer by default\n"
4059 "Activate ipv4-vpn for a peer by default\n"
4060 "Activate ipv4-labeled-unicast for a peer by default\n"
4061 "Activate ipv4-flowspec for a peer by default\n"
4062 "Activate ipv6-unicast for a peer by default\n"
4063 "Activate ipv6-multicast for a peer by default\n"
4064 "Activate ipv6-vpn for a peer by default\n"
4065 "Activate ipv6-labeled-unicast for a peer by default\n"
4066 "Activate ipv6-flowspec for a peer by default\n"
4067 "Activate l2vpn-evpn for a peer by default\n")
4068 {
4069 VTY_DECLVAR_CONTEXT(bgp, bgp);
4070 char afi_safi_str[strlen(afi_safi) + 1];
4071 char *afi_safi_str_tok;
4072
4073 strlcpy(afi_safi_str, afi_safi, sizeof(afi_safi_str));
4074 char *afi_str = strtok_r(afi_safi_str, "-", &afi_safi_str_tok);
4075 char *safi_str = strtok_r(NULL, "-", &afi_safi_str_tok);
4076 afi_t afi = bgp_vty_afi_from_str(afi_str);
4077 safi_t safi;
4078
4079 /*
4080 * Impossible situation but making coverity happy
4081 */
4082 assert(afi != AFI_MAX);
4083
4084 if (strmatch(safi_str, "labeled"))
4085 safi = bgp_vty_safi_from_str("labeled-unicast");
4086 else
4087 safi = bgp_vty_safi_from_str(safi_str);
4088
4089 assert(safi != SAFI_MAX);
4090 if (no)
4091 bgp->default_af[afi][safi] = false;
4092 else {
4093 if ((safi == SAFI_LABELED_UNICAST
4094 && bgp->default_af[afi][SAFI_UNICAST])
4095 || (safi == SAFI_UNICAST
4096 && bgp->default_af[afi][SAFI_LABELED_UNICAST]))
4097 bgp_vty_return(vty, BGP_ERR_PEER_SAFI_CONFLICT);
4098 else
4099 bgp->default_af[afi][safi] = true;
4100 }
4101
4102 return CMD_SUCCESS;
4103 }
4104
4105 /* Display hostname in certain command outputs */
4106 DEFUN (bgp_default_show_hostname,
4107 bgp_default_show_hostname_cmd,
4108 "bgp default show-hostname",
4109 BGP_STR
4110 "Configure BGP defaults\n"
4111 "Show hostname in certain command outputs\n")
4112 {
4113 VTY_DECLVAR_CONTEXT(bgp, bgp);
4114 SET_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME);
4115 return CMD_SUCCESS;
4116 }
4117
4118 DEFUN (no_bgp_default_show_hostname,
4119 no_bgp_default_show_hostname_cmd,
4120 "no bgp default show-hostname",
4121 NO_STR
4122 BGP_STR
4123 "Configure BGP defaults\n"
4124 "Show hostname in certain command outputs\n")
4125 {
4126 VTY_DECLVAR_CONTEXT(bgp, bgp);
4127 UNSET_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME);
4128 return CMD_SUCCESS;
4129 }
4130
4131 /* Display hostname in certain command outputs */
4132 DEFUN (bgp_default_show_nexthop_hostname,
4133 bgp_default_show_nexthop_hostname_cmd,
4134 "bgp default show-nexthop-hostname",
4135 BGP_STR
4136 "Configure BGP defaults\n"
4137 "Show hostname for nexthop in certain command outputs\n")
4138 {
4139 VTY_DECLVAR_CONTEXT(bgp, bgp);
4140 SET_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
4141 return CMD_SUCCESS;
4142 }
4143
4144 DEFUN (no_bgp_default_show_nexthop_hostname,
4145 no_bgp_default_show_nexthop_hostname_cmd,
4146 "no bgp default show-nexthop-hostname",
4147 NO_STR
4148 BGP_STR
4149 "Configure BGP defaults\n"
4150 "Show hostname for nexthop in certain command outputs\n")
4151 {
4152 VTY_DECLVAR_CONTEXT(bgp, bgp);
4153 UNSET_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME);
4154 return CMD_SUCCESS;
4155 }
4156
4157 /* "bgp network import-check" configuration. */
4158 DEFUN (bgp_network_import_check,
4159 bgp_network_import_check_cmd,
4160 "bgp network import-check",
4161 BGP_STR
4162 "BGP network command\n"
4163 "Check BGP network route exists in IGP\n")
4164 {
4165 VTY_DECLVAR_CONTEXT(bgp, bgp);
4166 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)) {
4167 SET_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK);
4168 bgp_static_redo_import_check(bgp);
4169 }
4170
4171 return CMD_SUCCESS;
4172 }
4173
4174 ALIAS_HIDDEN(bgp_network_import_check, bgp_network_import_check_exact_cmd,
4175 "bgp network import-check exact",
4176 BGP_STR
4177 "BGP network command\n"
4178 "Check BGP network route exists in IGP\n"
4179 "Match route precisely\n")
4180
4181 DEFUN (no_bgp_network_import_check,
4182 no_bgp_network_import_check_cmd,
4183 "no bgp network import-check",
4184 NO_STR
4185 BGP_STR
4186 "BGP network command\n"
4187 "Check BGP network route exists in IGP\n")
4188 {
4189 VTY_DECLVAR_CONTEXT(bgp, bgp);
4190 if (CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)) {
4191 UNSET_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK);
4192 bgp_static_redo_import_check(bgp);
4193 }
4194
4195 return CMD_SUCCESS;
4196 }
4197
4198 DEFUN (bgp_default_local_preference,
4199 bgp_default_local_preference_cmd,
4200 "bgp default local-preference (0-4294967295)",
4201 BGP_STR
4202 "Configure BGP defaults\n"
4203 "local preference (higher=more preferred)\n"
4204 "Configure default local preference value\n")
4205 {
4206 VTY_DECLVAR_CONTEXT(bgp, bgp);
4207 int idx_number = 3;
4208 uint32_t local_pref;
4209
4210 local_pref = strtoul(argv[idx_number]->arg, NULL, 10);
4211
4212 bgp_default_local_preference_set(bgp, local_pref);
4213 bgp_clear_star_soft_in(vty, bgp->name);
4214
4215 return CMD_SUCCESS;
4216 }
4217
4218 DEFUN (no_bgp_default_local_preference,
4219 no_bgp_default_local_preference_cmd,
4220 "no bgp default local-preference [(0-4294967295)]",
4221 NO_STR
4222 BGP_STR
4223 "Configure BGP defaults\n"
4224 "local preference (higher=more preferred)\n"
4225 "Configure default local preference value\n")
4226 {
4227 VTY_DECLVAR_CONTEXT(bgp, bgp);
4228 bgp_default_local_preference_unset(bgp);
4229 bgp_clear_star_soft_in(vty, bgp->name);
4230
4231 return CMD_SUCCESS;
4232 }
4233
4234
4235 DEFUN (bgp_default_subgroup_pkt_queue_max,
4236 bgp_default_subgroup_pkt_queue_max_cmd,
4237 "bgp default subgroup-pkt-queue-max (20-100)",
4238 BGP_STR
4239 "Configure BGP defaults\n"
4240 "subgroup-pkt-queue-max\n"
4241 "Configure subgroup packet queue max\n")
4242 {
4243 VTY_DECLVAR_CONTEXT(bgp, bgp);
4244 int idx_number = 3;
4245 uint32_t max_size;
4246
4247 max_size = strtoul(argv[idx_number]->arg, NULL, 10);
4248
4249 bgp_default_subgroup_pkt_queue_max_set(bgp, max_size);
4250
4251 return CMD_SUCCESS;
4252 }
4253
4254 DEFUN (no_bgp_default_subgroup_pkt_queue_max,
4255 no_bgp_default_subgroup_pkt_queue_max_cmd,
4256 "no bgp default subgroup-pkt-queue-max [(20-100)]",
4257 NO_STR
4258 BGP_STR
4259 "Configure BGP defaults\n"
4260 "subgroup-pkt-queue-max\n"
4261 "Configure subgroup packet queue max\n")
4262 {
4263 VTY_DECLVAR_CONTEXT(bgp, bgp);
4264 bgp_default_subgroup_pkt_queue_max_unset(bgp);
4265 return CMD_SUCCESS;
4266 }
4267
4268
4269 DEFUN (bgp_rr_allow_outbound_policy,
4270 bgp_rr_allow_outbound_policy_cmd,
4271 "bgp route-reflector allow-outbound-policy",
4272 BGP_STR
4273 "Allow modifications made by out route-map\n"
4274 "on ibgp neighbors\n")
4275 {
4276 VTY_DECLVAR_CONTEXT(bgp, bgp);
4277
4278 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
4279 SET_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
4280 update_group_announce_rrclients(bgp);
4281 bgp_clear_star_soft_out(vty, bgp->name);
4282 }
4283
4284 return CMD_SUCCESS;
4285 }
4286
4287 DEFUN (no_bgp_rr_allow_outbound_policy,
4288 no_bgp_rr_allow_outbound_policy_cmd,
4289 "no bgp route-reflector allow-outbound-policy",
4290 NO_STR
4291 BGP_STR
4292 "Allow modifications made by out route-map\n"
4293 "on ibgp neighbors\n")
4294 {
4295 VTY_DECLVAR_CONTEXT(bgp, bgp);
4296
4297 if (CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
4298 UNSET_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
4299 update_group_announce_rrclients(bgp);
4300 bgp_clear_star_soft_out(vty, bgp->name);
4301 }
4302
4303 return CMD_SUCCESS;
4304 }
4305
4306 DEFUN (bgp_listen_limit,
4307 bgp_listen_limit_cmd,
4308 "bgp listen limit (1-65535)",
4309 BGP_STR
4310 "BGP Dynamic Neighbors listen commands\n"
4311 "Maximum number of BGP Dynamic Neighbors that can be created\n"
4312 "Configure Dynamic Neighbors listen limit value\n")
4313 {
4314 VTY_DECLVAR_CONTEXT(bgp, bgp);
4315 int idx_number = 3;
4316 int listen_limit;
4317
4318 listen_limit = strtoul(argv[idx_number]->arg, NULL, 10);
4319
4320 bgp_listen_limit_set(bgp, listen_limit);
4321
4322 return CMD_SUCCESS;
4323 }
4324
4325 DEFUN (no_bgp_listen_limit,
4326 no_bgp_listen_limit_cmd,
4327 "no bgp listen limit [(1-65535)]",
4328 NO_STR
4329 BGP_STR
4330 "BGP Dynamic Neighbors listen commands\n"
4331 "Maximum number of BGP Dynamic Neighbors that can be created\n"
4332 "Configure Dynamic Neighbors listen limit value\n")
4333 {
4334 VTY_DECLVAR_CONTEXT(bgp, bgp);
4335 bgp_listen_limit_unset(bgp);
4336 return CMD_SUCCESS;
4337 }
4338
4339
4340 /*
4341 * Check if this listen range is already configured. Check for exact
4342 * match or overlap based on input.
4343 */
4344 static struct peer_group *listen_range_exists(struct bgp *bgp,
4345 struct prefix *range, int exact)
4346 {
4347 struct listnode *node, *nnode;
4348 struct listnode *node1, *nnode1;
4349 struct peer_group *group;
4350 struct prefix *lr;
4351 afi_t afi;
4352 int match;
4353
4354 afi = family2afi(range->family);
4355 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
4356 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node1, nnode1,
4357 lr)) {
4358 if (exact)
4359 match = prefix_same(range, lr);
4360 else
4361 match = (prefix_match(range, lr)
4362 || prefix_match(lr, range));
4363 if (match)
4364 return group;
4365 }
4366 }
4367
4368 return NULL;
4369 }
4370
4371 DEFUN (bgp_listen_range,
4372 bgp_listen_range_cmd,
4373 "bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
4374 BGP_STR
4375 "Configure BGP dynamic neighbors listen range\n"
4376 "Configure BGP dynamic neighbors listen range\n"
4377 NEIGHBOR_ADDR_STR
4378 "Member of the peer-group\n"
4379 "Peer-group name\n")
4380 {
4381 VTY_DECLVAR_CONTEXT(bgp, bgp);
4382 struct prefix range;
4383 struct peer_group *group, *existing_group;
4384 afi_t afi;
4385 int ret;
4386 int idx = 0;
4387
4388 argv_find(argv, argc, "A.B.C.D/M", &idx);
4389 argv_find(argv, argc, "X:X::X:X/M", &idx);
4390 char *prefix = argv[idx]->arg;
4391 argv_find(argv, argc, "PGNAME", &idx);
4392 char *peergroup = argv[idx]->arg;
4393
4394 /* Convert IP prefix string to struct prefix. */
4395 ret = str2prefix(prefix, &range);
4396 if (!ret) {
4397 vty_out(vty, "%% Malformed listen range\n");
4398 return CMD_WARNING_CONFIG_FAILED;
4399 }
4400
4401 afi = family2afi(range.family);
4402
4403 if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
4404 vty_out(vty,
4405 "%% Malformed listen range (link-local address)\n");
4406 return CMD_WARNING_CONFIG_FAILED;
4407 }
4408
4409 apply_mask(&range);
4410
4411 /* Check if same listen range is already configured. */
4412 existing_group = listen_range_exists(bgp, &range, 1);
4413 if (existing_group) {
4414 if (strcmp(existing_group->name, peergroup) == 0)
4415 return CMD_SUCCESS;
4416 else {
4417 vty_out(vty,
4418 "%% Same listen range is attached to peer-group %s\n",
4419 existing_group->name);
4420 return CMD_WARNING_CONFIG_FAILED;
4421 }
4422 }
4423
4424 /* Check if an overlapping listen range exists. */
4425 if (listen_range_exists(bgp, &range, 0)) {
4426 vty_out(vty,
4427 "%% Listen range overlaps with existing listen range\n");
4428 return CMD_WARNING_CONFIG_FAILED;
4429 }
4430
4431 group = peer_group_lookup(bgp, peergroup);
4432 if (!group) {
4433 vty_out(vty, "%% Configure the peer-group first\n");
4434 return CMD_WARNING_CONFIG_FAILED;
4435 }
4436
4437 ret = peer_group_listen_range_add(group, &range);
4438 return bgp_vty_return(vty, ret);
4439 }
4440
4441 DEFUN (no_bgp_listen_range,
4442 no_bgp_listen_range_cmd,
4443 "no bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
4444 NO_STR
4445 BGP_STR
4446 "Unconfigure BGP dynamic neighbors listen range\n"
4447 "Unconfigure BGP dynamic neighbors listen range\n"
4448 NEIGHBOR_ADDR_STR
4449 "Member of the peer-group\n"
4450 "Peer-group name\n")
4451 {
4452 VTY_DECLVAR_CONTEXT(bgp, bgp);
4453 struct prefix range;
4454 struct peer_group *group;
4455 afi_t afi;
4456 int ret;
4457 int idx = 0;
4458
4459 argv_find(argv, argc, "A.B.C.D/M", &idx);
4460 argv_find(argv, argc, "X:X::X:X/M", &idx);
4461 char *prefix = argv[idx]->arg;
4462 argv_find(argv, argc, "PGNAME", &idx);
4463 char *peergroup = argv[idx]->arg;
4464
4465 /* Convert IP prefix string to struct prefix. */
4466 ret = str2prefix(prefix, &range);
4467 if (!ret) {
4468 vty_out(vty, "%% Malformed listen range\n");
4469 return CMD_WARNING_CONFIG_FAILED;
4470 }
4471
4472 afi = family2afi(range.family);
4473
4474 if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
4475 vty_out(vty,
4476 "%% Malformed listen range (link-local address)\n");
4477 return CMD_WARNING_CONFIG_FAILED;
4478 }
4479
4480 apply_mask(&range);
4481
4482 group = peer_group_lookup(bgp, peergroup);
4483 if (!group) {
4484 vty_out(vty, "%% Peer-group does not exist\n");
4485 return CMD_WARNING_CONFIG_FAILED;
4486 }
4487
4488 ret = peer_group_listen_range_del(group, &range);
4489 return bgp_vty_return(vty, ret);
4490 }
4491
4492 void bgp_config_write_listen(struct vty *vty, struct bgp *bgp)
4493 {
4494 struct peer_group *group;
4495 struct listnode *node, *nnode, *rnode, *nrnode;
4496 struct prefix *range;
4497 afi_t afi;
4498
4499 if (bgp->dynamic_neighbors_limit != BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT)
4500 vty_out(vty, " bgp listen limit %d\n",
4501 bgp->dynamic_neighbors_limit);
4502
4503 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
4504 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
4505 for (ALL_LIST_ELEMENTS(group->listen_range[afi], rnode,
4506 nrnode, range)) {
4507 vty_out(vty,
4508 " bgp listen range %pFX peer-group %s\n",
4509 range, group->name);
4510 }
4511 }
4512 }
4513 }
4514
4515
4516 DEFUN (bgp_disable_connected_route_check,
4517 bgp_disable_connected_route_check_cmd,
4518 "bgp disable-ebgp-connected-route-check",
4519 BGP_STR
4520 "Disable checking if nexthop is connected on ebgp sessions\n")
4521 {
4522 VTY_DECLVAR_CONTEXT(bgp, bgp);
4523 SET_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
4524 bgp_clear_star_soft_in(vty, bgp->name);
4525
4526 return CMD_SUCCESS;
4527 }
4528
4529 DEFUN (no_bgp_disable_connected_route_check,
4530 no_bgp_disable_connected_route_check_cmd,
4531 "no bgp disable-ebgp-connected-route-check",
4532 NO_STR
4533 BGP_STR
4534 "Disable checking if nexthop is connected on ebgp sessions\n")
4535 {
4536 VTY_DECLVAR_CONTEXT(bgp, bgp);
4537 UNSET_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
4538 bgp_clear_star_soft_in(vty, bgp->name);
4539
4540 return CMD_SUCCESS;
4541 }
4542
4543
4544 static int peer_remote_as_vty(struct vty *vty, const char *peer_str,
4545 const char *as_str)
4546 {
4547 VTY_DECLVAR_CONTEXT(bgp, bgp);
4548 int ret;
4549 as_t as;
4550 int as_type = AS_SPECIFIED;
4551 union sockunion su;
4552
4553 if (as_str[0] == 'i') {
4554 as = 0;
4555 as_type = AS_INTERNAL;
4556 } else if (as_str[0] == 'e') {
4557 as = 0;
4558 as_type = AS_EXTERNAL;
4559 } else if (!asn_str2asn(as_str, &as))
4560 as_type = AS_UNSPECIFIED;
4561
4562 if (as_type == AS_UNSPECIFIED) {
4563 vty_out(vty, "%% Invalid peer AS: %s\n", as_str);
4564 return CMD_WARNING_CONFIG_FAILED;
4565 }
4566 /* If peer is peer group or interface peer, call proper function. */
4567 ret = str2sockunion(peer_str, &su);
4568 if (ret < 0) {
4569 struct peer *peer;
4570
4571 /* Check if existing interface peer */
4572 peer = peer_lookup_by_conf_if(bgp, peer_str);
4573
4574 ret = peer_remote_as(bgp, NULL, peer_str, &as, as_type, as_str);
4575
4576 /* if not interface peer, check peer-group settings */
4577 if (ret < 0 && !peer) {
4578 ret = peer_group_remote_as(bgp, peer_str, &as, as_type,
4579 as_str);
4580 if (ret < 0) {
4581 vty_out(vty,
4582 "%% Create the peer-group or interface first\n");
4583 return CMD_WARNING_CONFIG_FAILED;
4584 }
4585 return CMD_SUCCESS;
4586 }
4587 } else {
4588 if (peer_address_self_check(bgp, &su)) {
4589 vty_out(vty,
4590 "%% Can not configure the local system as neighbor\n");
4591 return CMD_WARNING_CONFIG_FAILED;
4592 }
4593 ret = peer_remote_as(bgp, &su, NULL, &as, as_type, as_str);
4594 }
4595
4596 return bgp_vty_return(vty, ret);
4597 }
4598
4599 DEFUN (bgp_default_shutdown,
4600 bgp_default_shutdown_cmd,
4601 "[no] bgp default shutdown",
4602 NO_STR
4603 BGP_STR
4604 "Configure BGP defaults\n"
4605 "Apply administrative shutdown to newly configured peers\n")
4606 {
4607 VTY_DECLVAR_CONTEXT(bgp, bgp);
4608 bgp->autoshutdown = !strmatch(argv[0]->text, "no");
4609 return CMD_SUCCESS;
4610 }
4611
4612 DEFPY(bgp_shutdown_msg, bgp_shutdown_msg_cmd, "bgp shutdown message MSG...",
4613 BGP_STR
4614 "Administrative shutdown of the BGP instance\n"
4615 "Add a shutdown message (RFC 8203)\n"
4616 "Shutdown message\n")
4617 {
4618 char *msgstr = NULL;
4619
4620 VTY_DECLVAR_CONTEXT(bgp, bgp);
4621
4622 if (argc > 3)
4623 msgstr = argv_concat(argv, argc, 3);
4624
4625 if (msgstr && strlen(msgstr) > BGP_ADMIN_SHUTDOWN_MSG_LEN) {
4626 vty_out(vty, "%% Shutdown message size exceeded %d\n",
4627 BGP_ADMIN_SHUTDOWN_MSG_LEN);
4628 return CMD_WARNING_CONFIG_FAILED;
4629 }
4630
4631 bgp_shutdown_enable(bgp, msgstr);
4632 XFREE(MTYPE_TMP, msgstr);
4633
4634 return CMD_SUCCESS;
4635 }
4636
4637 DEFPY(bgp_shutdown, bgp_shutdown_cmd, "bgp shutdown",
4638 BGP_STR "Administrative shutdown of the BGP instance\n")
4639 {
4640 VTY_DECLVAR_CONTEXT(bgp, bgp);
4641
4642 bgp_shutdown_enable(bgp, NULL);
4643
4644 return CMD_SUCCESS;
4645 }
4646
4647 DEFPY(no_bgp_shutdown, no_bgp_shutdown_cmd, "no bgp shutdown",
4648 NO_STR BGP_STR "Administrative shutdown of the BGP instance\n")
4649 {
4650 VTY_DECLVAR_CONTEXT(bgp, bgp);
4651
4652 bgp_shutdown_disable(bgp);
4653
4654 return CMD_SUCCESS;
4655 }
4656
4657 ALIAS(no_bgp_shutdown, no_bgp_shutdown_msg_cmd,
4658 "no bgp shutdown message MSG...", NO_STR BGP_STR
4659 "Administrative shutdown of the BGP instance\n"
4660 "Add a shutdown message (RFC 8203)\n" "Shutdown message\n")
4661
4662 DEFUN (neighbor_remote_as,
4663 neighbor_remote_as_cmd,
4664 "neighbor <A.B.C.D|X:X::X:X|WORD> remote-as <ASNUM|internal|external>",
4665 NEIGHBOR_STR
4666 NEIGHBOR_ADDR_STR2
4667 "Specify a BGP neighbor\n"
4668 AS_STR
4669 "Internal BGP peer\n"
4670 "External BGP peer\n")
4671 {
4672 int idx_peer = 1;
4673 int idx_remote_as = 3;
4674 return peer_remote_as_vty(vty, argv[idx_peer]->arg,
4675 argv[idx_remote_as]->arg);
4676 }
4677
4678 DEFPY (bgp_allow_martian,
4679 bgp_allow_martian_cmd,
4680 "[no]$no bgp allow-martian-nexthop",
4681 NO_STR
4682 BGP_STR
4683 "Allow Martian nexthops to be received in the NLRI from a peer\n")
4684 {
4685 VTY_DECLVAR_CONTEXT(bgp, bgp);
4686
4687 if (no)
4688 bgp->allow_martian = false;
4689 else
4690 bgp->allow_martian = true;
4691
4692 return CMD_SUCCESS;
4693 }
4694
4695 /* Enable fast convergence of bgp sessions. If this is enabled, bgp
4696 * sessions do not wait for hold timer expiry to bring down the sessions
4697 * when nexthop becomes unreachable
4698 */
4699 DEFUN(bgp_fast_convergence, bgp_fast_convergence_cmd, "bgp fast-convergence",
4700 BGP_STR "Fast convergence for bgp sessions\n")
4701 {
4702 VTY_DECLVAR_CONTEXT(bgp, bgp);
4703 bgp->fast_convergence = true;
4704
4705 return CMD_SUCCESS;
4706 }
4707
4708 DEFUN(no_bgp_fast_convergence, no_bgp_fast_convergence_cmd,
4709 "no bgp fast-convergence",
4710 NO_STR BGP_STR "Fast convergence for bgp sessions\n")
4711 {
4712 VTY_DECLVAR_CONTEXT(bgp, bgp);
4713 bgp->fast_convergence = false;
4714
4715 return CMD_SUCCESS;
4716 }
4717
4718 static int peer_conf_interface_get(struct vty *vty, const char *conf_if,
4719 int v6only,
4720 const char *peer_group_name,
4721 const char *as_str)
4722 {
4723 VTY_DECLVAR_CONTEXT(bgp, bgp);
4724 as_t as = 0;
4725 int as_type = AS_UNSPECIFIED;
4726 struct peer *peer;
4727 struct peer_group *group;
4728 int ret = 0;
4729
4730 group = peer_group_lookup(bgp, conf_if);
4731
4732 if (group) {
4733 vty_out(vty, "%% Name conflict with peer-group \n");
4734 return CMD_WARNING_CONFIG_FAILED;
4735 }
4736
4737 if (as_str) {
4738 if (as_str[0] == 'i') {
4739 as_type = AS_INTERNAL;
4740 } else if (as_str[0] == 'e') {
4741 as_type = AS_EXTERNAL;
4742 } else {
4743 /* Get AS number. */
4744 if (asn_str2asn(as_str, &as))
4745 as_type = AS_SPECIFIED;
4746 }
4747 }
4748
4749 peer = peer_lookup_by_conf_if(bgp, conf_if);
4750 if (peer) {
4751 if (as_str)
4752 ret = peer_remote_as(bgp, NULL, conf_if, &as, as_type,
4753 as_str);
4754 } else {
4755 peer = peer_create(NULL, conf_if, bgp, bgp->as, as, as_type,
4756 NULL, true, as_str);
4757
4758 if (!peer) {
4759 vty_out(vty, "%% BGP failed to create peer\n");
4760 return CMD_WARNING_CONFIG_FAILED;
4761 }
4762
4763 if (v6only)
4764 peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
4765
4766 /* Request zebra to initiate IPv6 RAs on this interface. We do
4767 * this
4768 * any unnumbered peer in order to not worry about run-time
4769 * transitions
4770 * (e.g., peering is initially IPv4, but the IPv4 /30 or /31
4771 * address
4772 * gets deleted later etc.)
4773 */
4774 if (peer->ifp)
4775 bgp_zebra_initiate_radv(bgp, peer);
4776 }
4777
4778 if ((v6only && !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
4779 || (!v6only && CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))) {
4780 if (v6only)
4781 peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
4782 else
4783 peer_flag_unset(peer, PEER_FLAG_IFPEER_V6ONLY);
4784
4785 /* v6only flag changed. Reset bgp seesion */
4786 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4787 peer->last_reset = PEER_DOWN_V6ONLY_CHANGE;
4788 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4789 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4790 } else
4791 bgp_session_reset(peer);
4792 }
4793
4794 if (!CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE)) {
4795 SET_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE);
4796 SET_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE);
4797 SET_FLAG(peer->flags_override, PEER_FLAG_CAPABILITY_ENHE);
4798 }
4799
4800 if (peer_group_name) {
4801 group = peer_group_lookup(bgp, peer_group_name);
4802 if (!group) {
4803 vty_out(vty, "%% Configure the peer-group first\n");
4804 return CMD_WARNING_CONFIG_FAILED;
4805 }
4806
4807 ret = peer_group_bind(bgp, NULL, peer, group, &as);
4808 }
4809
4810 return bgp_vty_return(vty, ret);
4811 }
4812
4813 DEFUN (neighbor_interface_config,
4814 neighbor_interface_config_cmd,
4815 "neighbor WORD interface [peer-group PGNAME]",
4816 NEIGHBOR_STR
4817 "Interface name or neighbor tag\n"
4818 "Enable BGP on interface\n"
4819 "Member of the peer-group\n"
4820 "Peer-group name\n")
4821 {
4822 int idx_word = 1;
4823 int idx_peer_group_word = 4;
4824
4825 if (argc > idx_peer_group_word)
4826 return peer_conf_interface_get(
4827 vty, argv[idx_word]->arg, 0,
4828 argv[idx_peer_group_word]->arg, NULL);
4829 else
4830 return peer_conf_interface_get(vty, argv[idx_word]->arg, 0,
4831 NULL, NULL);
4832 }
4833
4834 DEFUN (neighbor_interface_config_v6only,
4835 neighbor_interface_config_v6only_cmd,
4836 "neighbor WORD interface v6only [peer-group PGNAME]",
4837 NEIGHBOR_STR
4838 "Interface name or neighbor tag\n"
4839 "Enable BGP on interface\n"
4840 "Enable BGP with v6 link-local only\n"
4841 "Member of the peer-group\n"
4842 "Peer-group name\n")
4843 {
4844 int idx_word = 1;
4845 int idx_peer_group_word = 5;
4846
4847 if (argc > idx_peer_group_word)
4848 return peer_conf_interface_get(
4849 vty, argv[idx_word]->arg, 1,
4850 argv[idx_peer_group_word]->arg, NULL);
4851
4852 return peer_conf_interface_get(vty, argv[idx_word]->arg, 1, NULL, NULL);
4853 }
4854
4855
4856 DEFUN (neighbor_interface_config_remote_as,
4857 neighbor_interface_config_remote_as_cmd,
4858 "neighbor WORD interface remote-as <ASNUM|internal|external>",
4859 NEIGHBOR_STR
4860 "Interface name or neighbor tag\n"
4861 "Enable BGP on interface\n"
4862 "Specify a BGP neighbor\n"
4863 AS_STR
4864 "Internal BGP peer\n"
4865 "External BGP peer\n")
4866 {
4867 int idx_word = 1;
4868 int idx_remote_as = 4;
4869 return peer_conf_interface_get(vty, argv[idx_word]->arg, 0, NULL,
4870 argv[idx_remote_as]->arg);
4871 }
4872
4873 DEFUN (neighbor_interface_v6only_config_remote_as,
4874 neighbor_interface_v6only_config_remote_as_cmd,
4875 "neighbor WORD interface v6only remote-as <ASNUM|internal|external>",
4876 NEIGHBOR_STR
4877 "Interface name or neighbor tag\n"
4878 "Enable BGP with v6 link-local only\n"
4879 "Enable BGP on interface\n"
4880 "Specify a BGP neighbor\n"
4881 AS_STR
4882 "Internal BGP peer\n"
4883 "External BGP peer\n")
4884 {
4885 int idx_word = 1;
4886 int idx_remote_as = 5;
4887 return peer_conf_interface_get(vty, argv[idx_word]->arg, 1, NULL,
4888 argv[idx_remote_as]->arg);
4889 }
4890
4891 DEFUN (neighbor_peer_group,
4892 neighbor_peer_group_cmd,
4893 "neighbor WORD peer-group",
4894 NEIGHBOR_STR
4895 "Interface name or neighbor tag\n"
4896 "Configure peer-group\n")
4897 {
4898 VTY_DECLVAR_CONTEXT(bgp, bgp);
4899 int idx_word = 1;
4900 struct peer *peer;
4901 struct peer_group *group;
4902
4903 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
4904 if (peer) {
4905 vty_out(vty, "%% Name conflict with interface: \n");
4906 return CMD_WARNING_CONFIG_FAILED;
4907 }
4908
4909 group = peer_group_get(bgp, argv[idx_word]->arg);
4910 if (!group) {
4911 vty_out(vty, "%% BGP failed to find or create peer-group\n");
4912 return CMD_WARNING_CONFIG_FAILED;
4913 }
4914
4915 return CMD_SUCCESS;
4916 }
4917
4918 DEFUN (no_neighbor,
4919 no_neighbor_cmd,
4920 "no neighbor <WORD|<A.B.C.D|X:X::X:X> [remote-as <(1-4294967295)|internal|external>]>",
4921 NO_STR
4922 NEIGHBOR_STR
4923 NEIGHBOR_ADDR_STR2
4924 "Specify a BGP neighbor\n"
4925 AS_STR
4926 "Internal BGP peer\n"
4927 "External BGP peer\n")
4928 {
4929 VTY_DECLVAR_CONTEXT(bgp, bgp);
4930 int idx_peer = 2;
4931 int ret;
4932 union sockunion su;
4933 struct peer_group *group;
4934 struct peer *peer;
4935 struct peer *other;
4936
4937 ret = str2sockunion(argv[idx_peer]->arg, &su);
4938 if (ret < 0) {
4939 /* look up for neighbor by interface name config. */
4940 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
4941 if (peer) {
4942 /* Request zebra to terminate IPv6 RAs on this
4943 * interface. */
4944 if (peer->ifp)
4945 bgp_zebra_terminate_radv(peer->bgp, peer);
4946 peer_notify_unconfig(peer);
4947 peer_delete(peer);
4948 return CMD_SUCCESS;
4949 }
4950
4951 group = peer_group_lookup(bgp, argv[idx_peer]->arg);
4952 if (group) {
4953 peer_group_notify_unconfig(group);
4954 peer_group_delete(group);
4955 } else {
4956 vty_out(vty, "%% Create the peer-group first\n");
4957 return CMD_WARNING_CONFIG_FAILED;
4958 }
4959 } else {
4960 peer = peer_lookup(bgp, &su);
4961 if (peer) {
4962 if (peer_dynamic_neighbor(peer)) {
4963 vty_out(vty,
4964 "%% Operation not allowed on a dynamic neighbor\n");
4965 return CMD_WARNING_CONFIG_FAILED;
4966 }
4967
4968 other = peer->doppelganger;
4969
4970 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
4971 bgp_zebra_terminate_radv(peer->bgp, peer);
4972
4973 peer_notify_unconfig(peer);
4974 peer_delete(peer);
4975 if (other && other->status != Deleted) {
4976 peer_notify_unconfig(other);
4977 peer_delete(other);
4978 }
4979 }
4980 }
4981
4982 return CMD_SUCCESS;
4983 }
4984
4985 DEFUN (no_neighbor_interface_config,
4986 no_neighbor_interface_config_cmd,
4987 "no neighbor WORD interface [v6only] [peer-group PGNAME] [remote-as <(1-4294967295)|internal|external>]",
4988 NO_STR
4989 NEIGHBOR_STR
4990 "Interface name\n"
4991 "Configure BGP on interface\n"
4992 "Enable BGP with v6 link-local only\n"
4993 "Member of the peer-group\n"
4994 "Peer-group name\n"
4995 "Specify a BGP neighbor\n"
4996 AS_STR
4997 "Internal BGP peer\n"
4998 "External BGP peer\n")
4999 {
5000 VTY_DECLVAR_CONTEXT(bgp, bgp);
5001 int idx_word = 2;
5002 struct peer *peer;
5003
5004 /* look up for neighbor by interface name config. */
5005 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
5006 if (peer) {
5007 /* Request zebra to terminate IPv6 RAs on this interface. */
5008 if (peer->ifp)
5009 bgp_zebra_terminate_radv(peer->bgp, peer);
5010 peer_notify_unconfig(peer);
5011 peer_delete(peer);
5012 } else {
5013 vty_out(vty, "%% Create the bgp interface first\n");
5014 return CMD_WARNING_CONFIG_FAILED;
5015 }
5016 return CMD_SUCCESS;
5017 }
5018
5019 DEFUN (no_neighbor_peer_group,
5020 no_neighbor_peer_group_cmd,
5021 "no neighbor WORD peer-group",
5022 NO_STR
5023 NEIGHBOR_STR
5024 "Neighbor tag\n"
5025 "Configure peer-group\n")
5026 {
5027 VTY_DECLVAR_CONTEXT(bgp, bgp);
5028 int idx_word = 2;
5029 struct peer_group *group;
5030
5031 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5032 if (group) {
5033 peer_group_notify_unconfig(group);
5034 peer_group_delete(group);
5035 } else {
5036 vty_out(vty, "%% Create the peer-group first\n");
5037 return CMD_WARNING_CONFIG_FAILED;
5038 }
5039 return CMD_SUCCESS;
5040 }
5041
5042 DEFUN (no_neighbor_interface_peer_group_remote_as,
5043 no_neighbor_interface_peer_group_remote_as_cmd,
5044 "no neighbor WORD remote-as <ASNUM|internal|external>",
5045 NO_STR
5046 NEIGHBOR_STR
5047 "Interface name or neighbor tag\n"
5048 "Specify a BGP neighbor\n"
5049 AS_STR
5050 "Internal BGP peer\n"
5051 "External BGP peer\n")
5052 {
5053 VTY_DECLVAR_CONTEXT(bgp, bgp);
5054 int idx_word = 2;
5055 struct peer_group *group;
5056 struct peer *peer;
5057
5058 /* look up for neighbor by interface name config. */
5059 peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
5060 if (peer) {
5061 peer_as_change(peer, 0, AS_UNSPECIFIED, NULL);
5062 return CMD_SUCCESS;
5063 }
5064
5065 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5066 if (group)
5067 peer_group_remote_as_delete(group);
5068 else {
5069 vty_out(vty, "%% Create the peer-group or interface first\n");
5070 return CMD_WARNING_CONFIG_FAILED;
5071 }
5072 return CMD_SUCCESS;
5073 }
5074
5075 DEFUN (neighbor_local_as,
5076 neighbor_local_as_cmd,
5077 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as ASNUM",
5078 NEIGHBOR_STR
5079 NEIGHBOR_ADDR_STR2
5080 "Specify a local-as number\n"
5081 "AS number expressed in dotted or plain format used as local AS\n")
5082 {
5083 int idx_peer = 1;
5084 int idx_number = 3;
5085 struct peer *peer;
5086 int ret;
5087 as_t as;
5088
5089 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5090 if (!peer)
5091 return CMD_WARNING_CONFIG_FAILED;
5092
5093 if (!asn_str2asn(argv[idx_number]->arg, &as)) {
5094 vty_out(vty, "%% Invalid neighbor local-as value: %s\n",
5095 argv[idx_number]->arg);
5096 return CMD_WARNING_CONFIG_FAILED;
5097 }
5098
5099 ret = peer_local_as_set(peer, as, 0, 0, argv[idx_number]->arg);
5100 return bgp_vty_return(vty, ret);
5101 }
5102
5103 DEFUN (neighbor_local_as_no_prepend,
5104 neighbor_local_as_no_prepend_cmd,
5105 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as ASNUM no-prepend",
5106 NEIGHBOR_STR
5107 NEIGHBOR_ADDR_STR2
5108 "Specify a local-as number\n"
5109 "AS number expressed in dotted or plain format used as local AS\n"
5110 "Do not prepend local-as to updates from ebgp peers\n")
5111 {
5112 int idx_peer = 1;
5113 int idx_number = 3;
5114 struct peer *peer;
5115 int ret;
5116 as_t as;
5117
5118 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5119 if (!peer)
5120 return CMD_WARNING_CONFIG_FAILED;
5121
5122 if (!asn_str2asn(argv[idx_number]->arg, &as)) {
5123 vty_out(vty, "%% Invalid neighbor local-as value: %s\n",
5124 argv[idx_number]->arg);
5125 return CMD_WARNING_CONFIG_FAILED;
5126 }
5127
5128 ret = peer_local_as_set(peer, as, 1, 0, argv[idx_number]->arg);
5129 return bgp_vty_return(vty, ret);
5130 }
5131
5132 DEFUN (neighbor_local_as_no_prepend_replace_as,
5133 neighbor_local_as_no_prepend_replace_as_cmd,
5134 "neighbor <A.B.C.D|X:X::X:X|WORD> local-as ASNUM no-prepend replace-as",
5135 NEIGHBOR_STR
5136 NEIGHBOR_ADDR_STR2
5137 "Specify a local-as number\n"
5138 "AS number expressed in dotted or plain format used as local AS\n"
5139 "Do not prepend local-as to updates from ebgp peers\n"
5140 "Do not prepend local-as to updates from ibgp peers\n")
5141 {
5142 int idx_peer = 1;
5143 int idx_number = 3;
5144 struct peer *peer;
5145 int ret;
5146 as_t as;
5147
5148 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5149 if (!peer)
5150 return CMD_WARNING_CONFIG_FAILED;
5151
5152 if (!asn_str2asn(argv[idx_number]->arg, &as)) {
5153 vty_out(vty, "%% Invalid neighbor local-as value: %s\n",
5154 argv[idx_number]->arg);
5155 return CMD_WARNING_CONFIG_FAILED;
5156 }
5157
5158 ret = peer_local_as_set(peer, as, 1, 1, argv[idx_number]->arg);
5159 return bgp_vty_return(vty, ret);
5160 }
5161
5162 DEFUN (no_neighbor_local_as,
5163 no_neighbor_local_as_cmd,
5164 "no neighbor <A.B.C.D|X:X::X:X|WORD> local-as [ASNUM [no-prepend [replace-as]]]",
5165 NO_STR
5166 NEIGHBOR_STR
5167 NEIGHBOR_ADDR_STR2
5168 "Specify a local-as number\n"
5169 "AS number expressed in dotted or plain format used as local AS\n"
5170 "Do not prepend local-as to updates from ebgp peers\n"
5171 "Do not prepend local-as to updates from ibgp peers\n")
5172 {
5173 int idx_peer = 2;
5174 struct peer *peer;
5175 int ret;
5176
5177 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5178 if (!peer)
5179 return CMD_WARNING_CONFIG_FAILED;
5180
5181 ret = peer_local_as_unset(peer);
5182 return bgp_vty_return(vty, ret);
5183 }
5184
5185
5186 DEFUN (neighbor_solo,
5187 neighbor_solo_cmd,
5188 "neighbor <A.B.C.D|X:X::X:X|WORD> solo",
5189 NEIGHBOR_STR
5190 NEIGHBOR_ADDR_STR2
5191 "Solo peer - part of its own update group\n")
5192 {
5193 int idx_peer = 1;
5194 struct peer *peer;
5195 int ret;
5196
5197 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5198 if (!peer)
5199 return CMD_WARNING_CONFIG_FAILED;
5200
5201 ret = update_group_adjust_soloness(peer, 1);
5202 return bgp_vty_return(vty, ret);
5203 }
5204
5205 DEFUN (no_neighbor_solo,
5206 no_neighbor_solo_cmd,
5207 "no neighbor <A.B.C.D|X:X::X:X|WORD> solo",
5208 NO_STR
5209 NEIGHBOR_STR
5210 NEIGHBOR_ADDR_STR2
5211 "Solo peer - part of its own update group\n")
5212 {
5213 int idx_peer = 2;
5214 struct peer *peer;
5215 int ret;
5216
5217 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5218 if (!peer)
5219 return CMD_WARNING_CONFIG_FAILED;
5220
5221 ret = update_group_adjust_soloness(peer, 0);
5222 return bgp_vty_return(vty, ret);
5223 }
5224
5225 DEFUN (neighbor_password,
5226 neighbor_password_cmd,
5227 "neighbor <A.B.C.D|X:X::X:X|WORD> password LINE",
5228 NEIGHBOR_STR
5229 NEIGHBOR_ADDR_STR2
5230 "Set a password\n"
5231 "The password\n")
5232 {
5233 int idx_peer = 1;
5234 int idx_line = 3;
5235 struct peer *peer;
5236 int ret;
5237
5238 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5239 if (!peer)
5240 return CMD_WARNING_CONFIG_FAILED;
5241
5242 ret = peer_password_set(peer, argv[idx_line]->arg);
5243 return bgp_vty_return(vty, ret);
5244 }
5245
5246 DEFUN (no_neighbor_password,
5247 no_neighbor_password_cmd,
5248 "no neighbor <A.B.C.D|X:X::X:X|WORD> password [LINE]",
5249 NO_STR
5250 NEIGHBOR_STR
5251 NEIGHBOR_ADDR_STR2
5252 "Set a password\n"
5253 "The password\n")
5254 {
5255 int idx_peer = 2;
5256 struct peer *peer;
5257 int ret;
5258
5259 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5260 if (!peer)
5261 return CMD_WARNING_CONFIG_FAILED;
5262
5263 ret = peer_password_unset(peer);
5264 return bgp_vty_return(vty, ret);
5265 }
5266
5267 DEFUN (neighbor_activate,
5268 neighbor_activate_cmd,
5269 "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5270 NEIGHBOR_STR
5271 NEIGHBOR_ADDR_STR2
5272 "Enable the Address Family for this Neighbor\n")
5273 {
5274 int idx_peer = 1;
5275 int ret;
5276 struct peer *peer;
5277
5278 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5279 if (!peer)
5280 return CMD_WARNING_CONFIG_FAILED;
5281
5282 ret = peer_activate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
5283 return bgp_vty_return(vty, ret);
5284 }
5285
5286 ALIAS_HIDDEN(neighbor_activate, neighbor_activate_hidden_cmd,
5287 "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5288 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5289 "Enable the Address Family for this Neighbor\n")
5290
5291 DEFUN (no_neighbor_activate,
5292 no_neighbor_activate_cmd,
5293 "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5294 NO_STR
5295 NEIGHBOR_STR
5296 NEIGHBOR_ADDR_STR2
5297 "Enable the Address Family for this Neighbor\n")
5298 {
5299 int idx_peer = 2;
5300 int ret;
5301 struct peer *peer;
5302
5303 /* Lookup peer. */
5304 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5305 if (!peer)
5306 return CMD_WARNING_CONFIG_FAILED;
5307
5308 ret = peer_deactivate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
5309 return bgp_vty_return(vty, ret);
5310 }
5311
5312 ALIAS_HIDDEN(no_neighbor_activate, no_neighbor_activate_hidden_cmd,
5313 "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
5314 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5315 "Enable the Address Family for this Neighbor\n")
5316
5317 DEFUN (neighbor_set_peer_group,
5318 neighbor_set_peer_group_cmd,
5319 "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5320 NEIGHBOR_STR
5321 NEIGHBOR_ADDR_STR2
5322 "Member of the peer-group\n"
5323 "Peer-group name\n")
5324 {
5325 VTY_DECLVAR_CONTEXT(bgp, bgp);
5326 int idx_peer = 1;
5327 int idx_word = 3;
5328 int ret;
5329 as_t as;
5330 union sockunion su;
5331 struct peer *peer;
5332 struct peer_group *group;
5333
5334 ret = str2sockunion(argv[idx_peer]->arg, &su);
5335 if (ret < 0) {
5336 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
5337 if (!peer) {
5338 vty_out(vty, "%% Malformed address or name: %s\n",
5339 argv[idx_peer]->arg);
5340 return CMD_WARNING_CONFIG_FAILED;
5341 }
5342 } else {
5343 if (peer_address_self_check(bgp, &su)) {
5344 vty_out(vty,
5345 "%% Can not configure the local system as neighbor\n");
5346 return CMD_WARNING_CONFIG_FAILED;
5347 }
5348
5349 /* Disallow for dynamic neighbor. */
5350 peer = peer_lookup(bgp, &su);
5351 if (peer && peer_dynamic_neighbor(peer)) {
5352 vty_out(vty,
5353 "%% Operation not allowed on a dynamic neighbor\n");
5354 return CMD_WARNING_CONFIG_FAILED;
5355 }
5356 }
5357
5358 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5359 if (!group) {
5360 vty_out(vty, "%% Configure the peer-group first\n");
5361 return CMD_WARNING_CONFIG_FAILED;
5362 }
5363
5364 ret = peer_group_bind(bgp, &su, peer, group, &as);
5365
5366 return bgp_vty_return(vty, ret);
5367 }
5368
5369 ALIAS_HIDDEN(neighbor_set_peer_group, neighbor_set_peer_group_hidden_cmd,
5370 "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5371 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5372 "Member of the peer-group\n"
5373 "Peer-group name\n")
5374
5375 DEFUN (no_neighbor_set_peer_group,
5376 no_neighbor_set_peer_group_cmd,
5377 "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5378 NO_STR
5379 NEIGHBOR_STR
5380 NEIGHBOR_ADDR_STR2
5381 "Member of the peer-group\n"
5382 "Peer-group name\n")
5383 {
5384 VTY_DECLVAR_CONTEXT(bgp, bgp);
5385 int idx_peer = 2;
5386 int idx_word = 4;
5387 int ret;
5388 struct peer *peer;
5389 struct peer_group *group;
5390
5391 peer = peer_lookup_vty(vty, argv[idx_peer]->arg);
5392 if (!peer)
5393 return CMD_WARNING_CONFIG_FAILED;
5394
5395 group = peer_group_lookup(bgp, argv[idx_word]->arg);
5396 if (!group) {
5397 vty_out(vty, "%% Configure the peer-group first\n");
5398 return CMD_WARNING_CONFIG_FAILED;
5399 }
5400
5401 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
5402 bgp_zebra_terminate_radv(peer->bgp, peer);
5403
5404 peer_notify_unconfig(peer);
5405 ret = peer_delete(peer);
5406
5407 return bgp_vty_return(vty, ret);
5408 }
5409
5410 ALIAS_HIDDEN(no_neighbor_set_peer_group, no_neighbor_set_peer_group_hidden_cmd,
5411 "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
5412 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5413 "Member of the peer-group\n"
5414 "Peer-group name\n")
5415
5416 /* neighbor passive. */
5417 DEFUN (neighbor_passive,
5418 neighbor_passive_cmd,
5419 "neighbor <A.B.C.D|X:X::X:X|WORD> passive",
5420 NEIGHBOR_STR
5421 NEIGHBOR_ADDR_STR2
5422 "Don't send open messages to this neighbor\n")
5423 {
5424 int idx_peer = 1;
5425 return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
5426 }
5427
5428 DEFUN (no_neighbor_passive,
5429 no_neighbor_passive_cmd,
5430 "no neighbor <A.B.C.D|X:X::X:X|WORD> passive",
5431 NO_STR
5432 NEIGHBOR_STR
5433 NEIGHBOR_ADDR_STR2
5434 "Don't send open messages to this neighbor\n")
5435 {
5436 int idx_peer = 2;
5437 return peer_flag_unset_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
5438 }
5439
5440 /* neighbor shutdown. */
5441 DEFUN (neighbor_shutdown_msg,
5442 neighbor_shutdown_msg_cmd,
5443 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
5444 NEIGHBOR_STR
5445 NEIGHBOR_ADDR_STR2
5446 "Administratively shut down this neighbor\n"
5447 "Add a shutdown message (RFC 8203)\n"
5448 "Shutdown message\n")
5449 {
5450 int idx_peer = 1;
5451
5452 if (argc >= 5) {
5453 struct peer *peer =
5454 peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5455 char *message;
5456
5457 if (!peer)
5458 return CMD_WARNING_CONFIG_FAILED;
5459 message = argv_concat(argv, argc, 4);
5460 peer_tx_shutdown_message_set(peer, message);
5461 XFREE(MTYPE_TMP, message);
5462 }
5463
5464 return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
5465 }
5466
5467 ALIAS(neighbor_shutdown_msg, neighbor_shutdown_cmd,
5468 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
5469 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5470 "Administratively shut down this neighbor\n")
5471
5472 DEFUN (no_neighbor_shutdown_msg,
5473 no_neighbor_shutdown_msg_cmd,
5474 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
5475 NO_STR
5476 NEIGHBOR_STR
5477 NEIGHBOR_ADDR_STR2
5478 "Administratively shut down this neighbor\n"
5479 "Remove a shutdown message (RFC 8203)\n"
5480 "Shutdown message\n")
5481 {
5482 int idx_peer = 2;
5483
5484 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5485 PEER_FLAG_SHUTDOWN);
5486 }
5487
5488 ALIAS(no_neighbor_shutdown_msg, no_neighbor_shutdown_cmd,
5489 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
5490 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5491 "Administratively shut down this neighbor\n")
5492
5493 DEFUN(neighbor_shutdown_rtt,
5494 neighbor_shutdown_rtt_cmd,
5495 "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown rtt (1-65535) [count (1-255)]",
5496 NEIGHBOR_STR
5497 NEIGHBOR_ADDR_STR2
5498 "Administratively shut down this neighbor\n"
5499 "Shutdown if round-trip-time is higher than expected\n"
5500 "Round-trip-time in milliseconds\n"
5501 "Specify the number of keepalives before shutdown\n"
5502 "The number of keepalives with higher RTT to shutdown\n")
5503 {
5504 int idx_peer = 1;
5505 int idx_rtt = 4;
5506 int idx_count = 0;
5507 struct peer *peer;
5508
5509 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5510
5511 if (!peer)
5512 return CMD_WARNING_CONFIG_FAILED;
5513
5514 peer->rtt_expected = strtol(argv[idx_rtt]->arg, NULL, 10);
5515
5516 if (argv_find(argv, argc, "count", &idx_count))
5517 peer->rtt_keepalive_conf =
5518 strtol(argv[idx_count + 1]->arg, NULL, 10);
5519
5520 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5521 PEER_FLAG_RTT_SHUTDOWN);
5522 }
5523
5524 DEFUN(no_neighbor_shutdown_rtt,
5525 no_neighbor_shutdown_rtt_cmd,
5526 "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown rtt [(1-65535) [count (1-255)]]",
5527 NO_STR
5528 NEIGHBOR_STR
5529 NEIGHBOR_ADDR_STR2
5530 "Administratively shut down this neighbor\n"
5531 "Shutdown if round-trip-time is higher than expected\n"
5532 "Round-trip-time in milliseconds\n"
5533 "Specify the number of keepalives before shutdown\n"
5534 "The number of keepalives with higher RTT to shutdown\n")
5535 {
5536 int idx_peer = 2;
5537 struct peer *peer;
5538
5539 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5540
5541 if (!peer)
5542 return CMD_WARNING_CONFIG_FAILED;
5543
5544 peer->rtt_expected = 0;
5545 peer->rtt_keepalive_conf = 1;
5546
5547 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5548 PEER_FLAG_RTT_SHUTDOWN);
5549 }
5550
5551 /* neighbor capability dynamic. */
5552 DEFUN (neighbor_capability_dynamic,
5553 neighbor_capability_dynamic_cmd,
5554 "neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
5555 NEIGHBOR_STR
5556 NEIGHBOR_ADDR_STR2
5557 "Advertise capability to the peer\n"
5558 "Advertise dynamic capability to this neighbor\n")
5559 {
5560 int idx_peer = 1;
5561 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5562 PEER_FLAG_DYNAMIC_CAPABILITY);
5563 }
5564
5565 DEFUN (no_neighbor_capability_dynamic,
5566 no_neighbor_capability_dynamic_cmd,
5567 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
5568 NO_STR
5569 NEIGHBOR_STR
5570 NEIGHBOR_ADDR_STR2
5571 "Advertise capability to the peer\n"
5572 "Advertise dynamic capability to this neighbor\n")
5573 {
5574 int idx_peer = 2;
5575 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5576 PEER_FLAG_DYNAMIC_CAPABILITY);
5577 }
5578
5579 /* neighbor dont-capability-negotiate */
5580 DEFUN (neighbor_dont_capability_negotiate,
5581 neighbor_dont_capability_negotiate_cmd,
5582 "neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
5583 NEIGHBOR_STR
5584 NEIGHBOR_ADDR_STR2
5585 "Do not perform capability negotiation\n")
5586 {
5587 int idx_peer = 1;
5588 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5589 PEER_FLAG_DONT_CAPABILITY);
5590 }
5591
5592 DEFUN (no_neighbor_dont_capability_negotiate,
5593 no_neighbor_dont_capability_negotiate_cmd,
5594 "no neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
5595 NO_STR
5596 NEIGHBOR_STR
5597 NEIGHBOR_ADDR_STR2
5598 "Do not perform capability negotiation\n")
5599 {
5600 int idx_peer = 2;
5601 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5602 PEER_FLAG_DONT_CAPABILITY);
5603 }
5604
5605 /* neighbor capability extended next hop encoding */
5606 DEFUN (neighbor_capability_enhe,
5607 neighbor_capability_enhe_cmd,
5608 "neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
5609 NEIGHBOR_STR
5610 NEIGHBOR_ADDR_STR2
5611 "Advertise capability to the peer\n"
5612 "Advertise extended next-hop capability to the peer\n")
5613 {
5614 int idx_peer = 1;
5615 struct peer *peer;
5616
5617 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5618 if (peer && peer->conf_if)
5619 return CMD_SUCCESS;
5620
5621 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5622 PEER_FLAG_CAPABILITY_ENHE);
5623 }
5624
5625 DEFUN (no_neighbor_capability_enhe,
5626 no_neighbor_capability_enhe_cmd,
5627 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
5628 NO_STR
5629 NEIGHBOR_STR
5630 NEIGHBOR_ADDR_STR2
5631 "Advertise capability to the peer\n"
5632 "Advertise extended next-hop capability to the peer\n")
5633 {
5634 int idx_peer = 2;
5635 struct peer *peer;
5636
5637 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
5638 if (peer && peer->conf_if) {
5639 vty_out(vty,
5640 "Peer %s cannot have capability extended-nexthop turned off\n",
5641 argv[idx_peer]->arg);
5642 return CMD_WARNING_CONFIG_FAILED;
5643 }
5644
5645 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5646 PEER_FLAG_CAPABILITY_ENHE);
5647 }
5648
5649 /* neighbor capability software-version */
5650 DEFPY(neighbor_capability_software_version,
5651 neighbor_capability_software_version_cmd,
5652 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor capability software-version",
5653 NO_STR
5654 NEIGHBOR_STR
5655 NEIGHBOR_ADDR_STR2
5656 "Advertise capability to the peer\n"
5657 "Advertise Software Version capability to the peer\n")
5658 {
5659 struct peer *peer;
5660
5661 peer = peer_and_group_lookup_vty(vty, neighbor);
5662 if (peer && peer->conf_if)
5663 return CMD_SUCCESS;
5664
5665 if (no)
5666 return peer_flag_unset_vty(vty, neighbor,
5667 PEER_FLAG_CAPABILITY_SOFT_VERSION);
5668 else
5669 return peer_flag_set_vty(vty, neighbor,
5670 PEER_FLAG_CAPABILITY_SOFT_VERSION);
5671 }
5672
5673 static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
5674 afi_t afi, safi_t safi, uint64_t flag,
5675 int set)
5676 {
5677 int ret;
5678 struct peer *peer;
5679
5680 peer = peer_and_group_lookup_vty(vty, peer_str);
5681 if (!peer)
5682 return CMD_WARNING_CONFIG_FAILED;
5683
5684 if (set)
5685 ret = peer_af_flag_set(peer, afi, safi, flag);
5686 else
5687 ret = peer_af_flag_unset(peer, afi, safi, flag);
5688
5689 return bgp_vty_return(vty, ret);
5690 }
5691
5692 static int peer_af_flag_set_vty(struct vty *vty, const char *peer_str,
5693 afi_t afi, safi_t safi, uint64_t flag)
5694 {
5695 return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 1);
5696 }
5697
5698 static int peer_af_flag_unset_vty(struct vty *vty, const char *peer_str,
5699 afi_t afi, safi_t safi, uint64_t flag)
5700 {
5701 return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 0);
5702 }
5703
5704 /* neighbor capability orf prefix-list. */
5705 DEFUN (neighbor_capability_orf_prefix,
5706 neighbor_capability_orf_prefix_cmd,
5707 "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5708 NEIGHBOR_STR
5709 NEIGHBOR_ADDR_STR2
5710 "Advertise capability to the peer\n"
5711 "Advertise ORF capability to the peer\n"
5712 "Advertise prefixlist ORF capability to this neighbor\n"
5713 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5714 "Capability to RECEIVE the ORF from this neighbor\n"
5715 "Capability to SEND the ORF to this neighbor\n")
5716 {
5717 int idx_send_recv = 5;
5718 char *peer_str = argv[1]->arg;
5719 struct peer *peer;
5720 afi_t afi = bgp_node_afi(vty);
5721 safi_t safi = bgp_node_safi(vty);
5722
5723 peer = peer_and_group_lookup_vty(vty, peer_str);
5724 if (!peer)
5725 return CMD_WARNING_CONFIG_FAILED;
5726
5727 if (strmatch(argv[idx_send_recv]->text, "send"))
5728 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5729 PEER_FLAG_ORF_PREFIX_SM);
5730
5731 if (strmatch(argv[idx_send_recv]->text, "receive"))
5732 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5733 PEER_FLAG_ORF_PREFIX_RM);
5734
5735 if (strmatch(argv[idx_send_recv]->text, "both"))
5736 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
5737 PEER_FLAG_ORF_PREFIX_SM)
5738 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
5739 PEER_FLAG_ORF_PREFIX_RM);
5740
5741 return CMD_WARNING_CONFIG_FAILED;
5742 }
5743
5744 ALIAS_HIDDEN(
5745 neighbor_capability_orf_prefix,
5746 neighbor_capability_orf_prefix_hidden_cmd,
5747 "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5748 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5749 "Advertise capability to the peer\n"
5750 "Advertise ORF capability to the peer\n"
5751 "Advertise prefixlist ORF capability to this neighbor\n"
5752 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5753 "Capability to RECEIVE the ORF from this neighbor\n"
5754 "Capability to SEND the ORF to this neighbor\n")
5755
5756 DEFUN (no_neighbor_capability_orf_prefix,
5757 no_neighbor_capability_orf_prefix_cmd,
5758 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5759 NO_STR
5760 NEIGHBOR_STR
5761 NEIGHBOR_ADDR_STR2
5762 "Advertise capability to the peer\n"
5763 "Advertise ORF capability to the peer\n"
5764 "Advertise prefixlist ORF capability to this neighbor\n"
5765 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5766 "Capability to RECEIVE the ORF from this neighbor\n"
5767 "Capability to SEND the ORF to this neighbor\n")
5768 {
5769 int idx_send_recv = 6;
5770 char *peer_str = argv[2]->arg;
5771 struct peer *peer;
5772 afi_t afi = bgp_node_afi(vty);
5773 safi_t safi = bgp_node_safi(vty);
5774
5775 peer = peer_and_group_lookup_vty(vty, peer_str);
5776 if (!peer)
5777 return CMD_WARNING_CONFIG_FAILED;
5778
5779 if (strmatch(argv[idx_send_recv]->text, "send"))
5780 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5781 PEER_FLAG_ORF_PREFIX_SM);
5782
5783 if (strmatch(argv[idx_send_recv]->text, "receive"))
5784 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5785 PEER_FLAG_ORF_PREFIX_RM);
5786
5787 if (strmatch(argv[idx_send_recv]->text, "both"))
5788 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5789 PEER_FLAG_ORF_PREFIX_SM)
5790 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
5791 PEER_FLAG_ORF_PREFIX_RM);
5792
5793 return CMD_WARNING_CONFIG_FAILED;
5794 }
5795
5796 ALIAS_HIDDEN(
5797 no_neighbor_capability_orf_prefix,
5798 no_neighbor_capability_orf_prefix_hidden_cmd,
5799 "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
5800 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5801 "Advertise capability to the peer\n"
5802 "Advertise ORF capability to the peer\n"
5803 "Advertise prefixlist ORF capability to this neighbor\n"
5804 "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
5805 "Capability to RECEIVE the ORF from this neighbor\n"
5806 "Capability to SEND the ORF to this neighbor\n")
5807
5808 /* neighbor next-hop-self. */
5809 DEFUN (neighbor_nexthop_self,
5810 neighbor_nexthop_self_cmd,
5811 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5812 NEIGHBOR_STR
5813 NEIGHBOR_ADDR_STR2
5814 "Disable the next hop calculation for this neighbor\n")
5815 {
5816 int idx_peer = 1;
5817 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5818 bgp_node_safi(vty), PEER_FLAG_NEXTHOP_SELF);
5819 }
5820
5821 ALIAS_HIDDEN(neighbor_nexthop_self, neighbor_nexthop_self_hidden_cmd,
5822 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5823 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5824 "Disable the next hop calculation for this neighbor\n")
5825
5826 /* neighbor next-hop-self. */
5827 DEFUN (neighbor_nexthop_self_force,
5828 neighbor_nexthop_self_force_cmd,
5829 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5830 NEIGHBOR_STR
5831 NEIGHBOR_ADDR_STR2
5832 "Disable the next hop calculation for this neighbor\n"
5833 "Set the next hop to self for reflected routes\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_FORCE_NEXTHOP_SELF);
5839 }
5840
5841 ALIAS_HIDDEN(neighbor_nexthop_self_force,
5842 neighbor_nexthop_self_force_hidden_cmd,
5843 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5844 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5845 "Disable the next hop calculation for this neighbor\n"
5846 "Set the next hop to self for reflected routes\n")
5847
5848 ALIAS_HIDDEN(neighbor_nexthop_self_force,
5849 neighbor_nexthop_self_all_hidden_cmd,
5850 "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
5851 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5852 "Disable the next hop calculation for this neighbor\n"
5853 "Set the next hop to self for reflected routes\n")
5854
5855 DEFUN (no_neighbor_nexthop_self,
5856 no_neighbor_nexthop_self_cmd,
5857 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5858 NO_STR
5859 NEIGHBOR_STR
5860 NEIGHBOR_ADDR_STR2
5861 "Disable the next hop calculation for this neighbor\n")
5862 {
5863 int idx_peer = 2;
5864 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5865 bgp_node_afi(vty), bgp_node_safi(vty),
5866 PEER_FLAG_NEXTHOP_SELF);
5867 }
5868
5869 ALIAS_HIDDEN(no_neighbor_nexthop_self, no_neighbor_nexthop_self_hidden_cmd,
5870 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
5871 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5872 "Disable the next hop calculation for this neighbor\n")
5873
5874 DEFUN (no_neighbor_nexthop_self_force,
5875 no_neighbor_nexthop_self_force_cmd,
5876 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5877 NO_STR
5878 NEIGHBOR_STR
5879 NEIGHBOR_ADDR_STR2
5880 "Disable the next hop calculation for this neighbor\n"
5881 "Set the next hop to self for reflected routes\n")
5882 {
5883 int idx_peer = 2;
5884 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5885 bgp_node_afi(vty), bgp_node_safi(vty),
5886 PEER_FLAG_FORCE_NEXTHOP_SELF);
5887 }
5888
5889 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
5890 no_neighbor_nexthop_self_force_hidden_cmd,
5891 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
5892 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5893 "Disable the next hop calculation for this neighbor\n"
5894 "Set the next hop to self for reflected routes\n")
5895
5896 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
5897 no_neighbor_nexthop_self_all_hidden_cmd,
5898 "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
5899 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5900 "Disable the next hop calculation for this neighbor\n"
5901 "Set the next hop to self for reflected routes\n")
5902
5903 /* neighbor as-override */
5904 DEFUN (neighbor_as_override,
5905 neighbor_as_override_cmd,
5906 "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5907 NEIGHBOR_STR
5908 NEIGHBOR_ADDR_STR2
5909 "Override ASNs in outbound updates if aspath equals remote-as\n")
5910 {
5911 int idx_peer = 1;
5912 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5913 bgp_node_safi(vty), PEER_FLAG_AS_OVERRIDE);
5914 }
5915
5916 ALIAS_HIDDEN(neighbor_as_override, neighbor_as_override_hidden_cmd,
5917 "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5918 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5919 "Override ASNs in outbound updates if aspath equals remote-as\n")
5920
5921 DEFUN (no_neighbor_as_override,
5922 no_neighbor_as_override_cmd,
5923 "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5924 NO_STR
5925 NEIGHBOR_STR
5926 NEIGHBOR_ADDR_STR2
5927 "Override ASNs in outbound updates if aspath equals remote-as\n")
5928 {
5929 int idx_peer = 2;
5930 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
5931 bgp_node_afi(vty), bgp_node_safi(vty),
5932 PEER_FLAG_AS_OVERRIDE);
5933 }
5934
5935 ALIAS_HIDDEN(no_neighbor_as_override, no_neighbor_as_override_hidden_cmd,
5936 "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
5937 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5938 "Override ASNs in outbound updates if aspath equals remote-as\n")
5939
5940 /* neighbor remove-private-AS. */
5941 DEFUN (neighbor_remove_private_as,
5942 neighbor_remove_private_as_cmd,
5943 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5944 NEIGHBOR_STR
5945 NEIGHBOR_ADDR_STR2
5946 "Remove private ASNs in outbound updates\n")
5947 {
5948 int idx_peer = 1;
5949 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5950 bgp_node_safi(vty),
5951 PEER_FLAG_REMOVE_PRIVATE_AS);
5952 }
5953
5954 ALIAS_HIDDEN(neighbor_remove_private_as, neighbor_remove_private_as_hidden_cmd,
5955 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
5956 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5957 "Remove private ASNs in outbound updates\n")
5958
5959 DEFUN (neighbor_remove_private_as_all,
5960 neighbor_remove_private_as_all_cmd,
5961 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5962 NEIGHBOR_STR
5963 NEIGHBOR_ADDR_STR2
5964 "Remove private ASNs in outbound updates\n"
5965 "Apply to all AS numbers\n")
5966 {
5967 int idx_peer = 1;
5968 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5969 bgp_node_safi(vty),
5970 PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
5971 }
5972
5973 ALIAS_HIDDEN(neighbor_remove_private_as_all,
5974 neighbor_remove_private_as_all_hidden_cmd,
5975 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
5976 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5977 "Remove private ASNs in outbound updates\n"
5978 "Apply to all AS numbers\n")
5979
5980 DEFUN (neighbor_remove_private_as_replace_as,
5981 neighbor_remove_private_as_replace_as_cmd,
5982 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5983 NEIGHBOR_STR
5984 NEIGHBOR_ADDR_STR2
5985 "Remove private ASNs in outbound updates\n"
5986 "Replace private ASNs with our ASN in outbound updates\n")
5987 {
5988 int idx_peer = 1;
5989 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5990 bgp_node_safi(vty),
5991 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
5992 }
5993
5994 ALIAS_HIDDEN(neighbor_remove_private_as_replace_as,
5995 neighbor_remove_private_as_replace_as_hidden_cmd,
5996 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
5997 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5998 "Remove private ASNs in outbound updates\n"
5999 "Replace private ASNs with our ASN in outbound updates\n")
6000
6001 DEFUN (neighbor_remove_private_as_all_replace_as,
6002 neighbor_remove_private_as_all_replace_as_cmd,
6003 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
6004 NEIGHBOR_STR
6005 NEIGHBOR_ADDR_STR2
6006 "Remove private ASNs in outbound updates\n"
6007 "Apply to all AS numbers\n"
6008 "Replace private ASNs with our ASN in outbound updates\n")
6009 {
6010 int idx_peer = 1;
6011 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6012 bgp_node_safi(vty),
6013 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
6014 }
6015
6016 ALIAS_HIDDEN(
6017 neighbor_remove_private_as_all_replace_as,
6018 neighbor_remove_private_as_all_replace_as_hidden_cmd,
6019 "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
6020 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6021 "Remove private ASNs in outbound updates\n"
6022 "Apply to all AS numbers\n"
6023 "Replace private ASNs with our ASN in outbound updates\n")
6024
6025 DEFUN (no_neighbor_remove_private_as,
6026 no_neighbor_remove_private_as_cmd,
6027 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
6028 NO_STR
6029 NEIGHBOR_STR
6030 NEIGHBOR_ADDR_STR2
6031 "Remove private ASNs in outbound updates\n")
6032 {
6033 int idx_peer = 2;
6034 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6035 bgp_node_afi(vty), bgp_node_safi(vty),
6036 PEER_FLAG_REMOVE_PRIVATE_AS);
6037 }
6038
6039 ALIAS_HIDDEN(no_neighbor_remove_private_as,
6040 no_neighbor_remove_private_as_hidden_cmd,
6041 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
6042 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6043 "Remove private ASNs in outbound updates\n")
6044
6045 DEFUN (no_neighbor_remove_private_as_all,
6046 no_neighbor_remove_private_as_all_cmd,
6047 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
6048 NO_STR
6049 NEIGHBOR_STR
6050 NEIGHBOR_ADDR_STR2
6051 "Remove private ASNs in outbound updates\n"
6052 "Apply to all AS numbers\n")
6053 {
6054 int idx_peer = 2;
6055 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6056 bgp_node_afi(vty), bgp_node_safi(vty),
6057 PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
6058 }
6059
6060 ALIAS_HIDDEN(no_neighbor_remove_private_as_all,
6061 no_neighbor_remove_private_as_all_hidden_cmd,
6062 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
6063 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6064 "Remove private ASNs in outbound updates\n"
6065 "Apply to all AS numbers\n")
6066
6067 DEFUN (no_neighbor_remove_private_as_replace_as,
6068 no_neighbor_remove_private_as_replace_as_cmd,
6069 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
6070 NO_STR
6071 NEIGHBOR_STR
6072 NEIGHBOR_ADDR_STR2
6073 "Remove private ASNs in outbound updates\n"
6074 "Replace private ASNs with our ASN in outbound updates\n")
6075 {
6076 int idx_peer = 2;
6077 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6078 bgp_node_afi(vty), bgp_node_safi(vty),
6079 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
6080 }
6081
6082 ALIAS_HIDDEN(no_neighbor_remove_private_as_replace_as,
6083 no_neighbor_remove_private_as_replace_as_hidden_cmd,
6084 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
6085 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6086 "Remove private ASNs in outbound updates\n"
6087 "Replace private ASNs with our ASN in outbound updates\n")
6088
6089 DEFUN (no_neighbor_remove_private_as_all_replace_as,
6090 no_neighbor_remove_private_as_all_replace_as_cmd,
6091 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
6092 NO_STR
6093 NEIGHBOR_STR
6094 NEIGHBOR_ADDR_STR2
6095 "Remove private ASNs in outbound updates\n"
6096 "Apply to all AS numbers\n"
6097 "Replace private ASNs with our ASN in outbound updates\n")
6098 {
6099 int idx_peer = 2;
6100 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6101 bgp_node_afi(vty), bgp_node_safi(vty),
6102 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
6103 }
6104
6105 ALIAS_HIDDEN(
6106 no_neighbor_remove_private_as_all_replace_as,
6107 no_neighbor_remove_private_as_all_replace_as_hidden_cmd,
6108 "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
6109 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6110 "Remove private ASNs in outbound updates\n"
6111 "Apply to all AS numbers\n"
6112 "Replace private ASNs with our ASN in outbound updates\n")
6113
6114
6115 /* neighbor send-community. */
6116 DEFUN (neighbor_send_community,
6117 neighbor_send_community_cmd,
6118 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
6119 NEIGHBOR_STR
6120 NEIGHBOR_ADDR_STR2
6121 "Send Community attribute to this neighbor\n")
6122 {
6123 int idx_peer = 1;
6124
6125 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6126 bgp_node_safi(vty),
6127 PEER_FLAG_SEND_COMMUNITY);
6128 }
6129
6130 ALIAS_HIDDEN(neighbor_send_community, neighbor_send_community_hidden_cmd,
6131 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
6132 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6133 "Send Community attribute to this neighbor\n")
6134
6135 DEFUN (no_neighbor_send_community,
6136 no_neighbor_send_community_cmd,
6137 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
6138 NO_STR
6139 NEIGHBOR_STR
6140 NEIGHBOR_ADDR_STR2
6141 "Send Community attribute to this neighbor\n")
6142 {
6143 int idx_peer = 2;
6144
6145 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6146 bgp_node_afi(vty), bgp_node_safi(vty),
6147 PEER_FLAG_SEND_COMMUNITY);
6148 }
6149
6150 ALIAS_HIDDEN(no_neighbor_send_community, no_neighbor_send_community_hidden_cmd,
6151 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
6152 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6153 "Send Community attribute to this neighbor\n")
6154
6155 /* neighbor send-community extended. */
6156 DEFUN (neighbor_send_community_type,
6157 neighbor_send_community_type_cmd,
6158 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6159 NEIGHBOR_STR
6160 NEIGHBOR_ADDR_STR2
6161 "Send Community attribute to this neighbor\n"
6162 "Send Standard and Extended Community attributes\n"
6163 "Send Standard, Large and Extended Community attributes\n"
6164 "Send Extended Community attributes\n"
6165 "Send Standard Community attributes\n"
6166 "Send Large Community attributes\n")
6167 {
6168 const char *type = argv[argc - 1]->text;
6169 char *peer_str = argv[1]->arg;
6170 struct peer *peer;
6171 afi_t afi = bgp_node_afi(vty);
6172 safi_t safi = bgp_node_safi(vty);
6173
6174 peer = peer_and_group_lookup_vty(vty, peer_str);
6175 if (!peer)
6176 return CMD_WARNING_CONFIG_FAILED;
6177
6178 if (strmatch(type, "standard"))
6179 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6180 PEER_FLAG_SEND_COMMUNITY);
6181
6182 if (strmatch(type, "extended"))
6183 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6184 PEER_FLAG_SEND_EXT_COMMUNITY);
6185
6186 if (strmatch(type, "large"))
6187 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6188 PEER_FLAG_SEND_LARGE_COMMUNITY);
6189
6190 if (strmatch(type, "both")) {
6191 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6192 PEER_FLAG_SEND_COMMUNITY)
6193 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6194 PEER_FLAG_SEND_EXT_COMMUNITY);
6195 }
6196 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
6197 PEER_FLAG_SEND_COMMUNITY)
6198 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6199 PEER_FLAG_SEND_EXT_COMMUNITY)
6200 | peer_af_flag_set_vty(vty, peer_str, afi, safi,
6201 PEER_FLAG_SEND_LARGE_COMMUNITY);
6202 }
6203
6204 ALIAS_HIDDEN(
6205 neighbor_send_community_type, neighbor_send_community_type_hidden_cmd,
6206 "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6207 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6208 "Send Community attribute to this neighbor\n"
6209 "Send Standard and Extended Community attributes\n"
6210 "Send Standard, Large and Extended Community attributes\n"
6211 "Send Extended Community attributes\n"
6212 "Send Standard Community attributes\n"
6213 "Send Large Community attributes\n")
6214
6215 DEFUN (no_neighbor_send_community_type,
6216 no_neighbor_send_community_type_cmd,
6217 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6218 NO_STR
6219 NEIGHBOR_STR
6220 NEIGHBOR_ADDR_STR2
6221 "Send Community attribute to this neighbor\n"
6222 "Send Standard and Extended Community attributes\n"
6223 "Send Standard, Large and Extended Community attributes\n"
6224 "Send Extended Community attributes\n"
6225 "Send Standard Community attributes\n"
6226 "Send Large Community attributes\n")
6227 {
6228 const char *type = argv[argc - 1]->text;
6229 char *peer_str = argv[2]->arg;
6230 struct peer *peer;
6231 afi_t afi = bgp_node_afi(vty);
6232 safi_t safi = bgp_node_safi(vty);
6233
6234 peer = peer_and_group_lookup_vty(vty, peer_str);
6235 if (!peer)
6236 return CMD_WARNING_CONFIG_FAILED;
6237
6238 if (strmatch(type, "standard"))
6239 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6240 PEER_FLAG_SEND_COMMUNITY);
6241
6242 if (strmatch(type, "extended"))
6243 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6244 PEER_FLAG_SEND_EXT_COMMUNITY);
6245
6246 if (strmatch(type, "large"))
6247 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6248 PEER_FLAG_SEND_LARGE_COMMUNITY);
6249
6250 if (strmatch(type, "both")) {
6251
6252 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6253 PEER_FLAG_SEND_COMMUNITY)
6254 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6255 PEER_FLAG_SEND_EXT_COMMUNITY);
6256 }
6257
6258 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6259 PEER_FLAG_SEND_COMMUNITY)
6260 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6261 PEER_FLAG_SEND_EXT_COMMUNITY)
6262 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6263 PEER_FLAG_SEND_LARGE_COMMUNITY);
6264 }
6265
6266 ALIAS_HIDDEN(
6267 no_neighbor_send_community_type,
6268 no_neighbor_send_community_type_hidden_cmd,
6269 "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
6270 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6271 "Send Community attribute to this neighbor\n"
6272 "Send Standard and Extended Community attributes\n"
6273 "Send Standard, Large and Extended Community attributes\n"
6274 "Send Extended Community attributes\n"
6275 "Send Standard Community attributes\n"
6276 "Send Large Community attributes\n")
6277
6278 /* neighbor soft-reconfig. */
6279 DEFUN (neighbor_soft_reconfiguration,
6280 neighbor_soft_reconfiguration_cmd,
6281 "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6282 NEIGHBOR_STR
6283 NEIGHBOR_ADDR_STR2
6284 "Per neighbor soft reconfiguration\n"
6285 "Allow inbound soft reconfiguration for this neighbor\n")
6286 {
6287 int idx_peer = 1;
6288 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6289 bgp_node_safi(vty),
6290 PEER_FLAG_SOFT_RECONFIG);
6291 }
6292
6293 ALIAS_HIDDEN(neighbor_soft_reconfiguration,
6294 neighbor_soft_reconfiguration_hidden_cmd,
6295 "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6296 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6297 "Per neighbor soft reconfiguration\n"
6298 "Allow inbound soft reconfiguration for this neighbor\n")
6299
6300 DEFUN (no_neighbor_soft_reconfiguration,
6301 no_neighbor_soft_reconfiguration_cmd,
6302 "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6303 NO_STR
6304 NEIGHBOR_STR
6305 NEIGHBOR_ADDR_STR2
6306 "Per neighbor soft reconfiguration\n"
6307 "Allow inbound soft reconfiguration for this neighbor\n")
6308 {
6309 int idx_peer = 2;
6310 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6311 bgp_node_afi(vty), bgp_node_safi(vty),
6312 PEER_FLAG_SOFT_RECONFIG);
6313 }
6314
6315 ALIAS_HIDDEN(no_neighbor_soft_reconfiguration,
6316 no_neighbor_soft_reconfiguration_hidden_cmd,
6317 "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
6318 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6319 "Per neighbor soft reconfiguration\n"
6320 "Allow inbound soft reconfiguration for this neighbor\n")
6321
6322 DEFUN (neighbor_route_reflector_client,
6323 neighbor_route_reflector_client_cmd,
6324 "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6325 NEIGHBOR_STR
6326 NEIGHBOR_ADDR_STR2
6327 "Configure a neighbor as Route Reflector client\n")
6328 {
6329 int idx_peer = 1;
6330 struct peer *peer;
6331
6332
6333 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6334 if (!peer)
6335 return CMD_WARNING_CONFIG_FAILED;
6336
6337 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6338 bgp_node_safi(vty),
6339 PEER_FLAG_REFLECTOR_CLIENT);
6340 }
6341
6342 ALIAS_HIDDEN(neighbor_route_reflector_client,
6343 neighbor_route_reflector_client_hidden_cmd,
6344 "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6345 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6346 "Configure a neighbor as Route Reflector client\n")
6347
6348 DEFUN (no_neighbor_route_reflector_client,
6349 no_neighbor_route_reflector_client_cmd,
6350 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6351 NO_STR
6352 NEIGHBOR_STR
6353 NEIGHBOR_ADDR_STR2
6354 "Configure a neighbor as Route Reflector client\n")
6355 {
6356 int idx_peer = 2;
6357 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6358 bgp_node_afi(vty), bgp_node_safi(vty),
6359 PEER_FLAG_REFLECTOR_CLIENT);
6360 }
6361
6362 ALIAS_HIDDEN(no_neighbor_route_reflector_client,
6363 no_neighbor_route_reflector_client_hidden_cmd,
6364 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
6365 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6366 "Configure a neighbor as Route Reflector client\n")
6367
6368 /* neighbor route-server-client. */
6369 DEFUN (neighbor_route_server_client,
6370 neighbor_route_server_client_cmd,
6371 "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6372 NEIGHBOR_STR
6373 NEIGHBOR_ADDR_STR2
6374 "Configure a neighbor as Route Server client\n")
6375 {
6376 int idx_peer = 1;
6377 struct peer *peer;
6378
6379 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6380 if (!peer)
6381 return CMD_WARNING_CONFIG_FAILED;
6382 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6383 bgp_node_safi(vty),
6384 PEER_FLAG_RSERVER_CLIENT);
6385 }
6386
6387 ALIAS_HIDDEN(neighbor_route_server_client,
6388 neighbor_route_server_client_hidden_cmd,
6389 "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6390 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6391 "Configure a neighbor as Route Server client\n")
6392
6393 DEFUN (no_neighbor_route_server_client,
6394 no_neighbor_route_server_client_cmd,
6395 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6396 NO_STR
6397 NEIGHBOR_STR
6398 NEIGHBOR_ADDR_STR2
6399 "Configure a neighbor as Route Server client\n")
6400 {
6401 int idx_peer = 2;
6402 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6403 bgp_node_afi(vty), bgp_node_safi(vty),
6404 PEER_FLAG_RSERVER_CLIENT);
6405 }
6406
6407 ALIAS_HIDDEN(no_neighbor_route_server_client,
6408 no_neighbor_route_server_client_hidden_cmd,
6409 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
6410 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6411 "Configure a neighbor as Route Server client\n")
6412
6413 DEFUN (neighbor_nexthop_local_unchanged,
6414 neighbor_nexthop_local_unchanged_cmd,
6415 "neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
6416 NEIGHBOR_STR
6417 NEIGHBOR_ADDR_STR2
6418 "Configure treatment of outgoing link-local nexthop attribute\n"
6419 "Leave link-local nexthop unchanged for this peer\n")
6420 {
6421 int idx_peer = 1;
6422 return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6423 bgp_node_safi(vty),
6424 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
6425 }
6426
6427 DEFUN (no_neighbor_nexthop_local_unchanged,
6428 no_neighbor_nexthop_local_unchanged_cmd,
6429 "no neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
6430 NO_STR
6431 NEIGHBOR_STR
6432 NEIGHBOR_ADDR_STR2
6433 "Configure treatment of outgoing link-local-nexthop attribute\n"
6434 "Leave link-local nexthop unchanged for this peer\n")
6435 {
6436 int idx_peer = 2;
6437 return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6438 bgp_node_afi(vty), bgp_node_safi(vty),
6439 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
6440 }
6441
6442 DEFUN (neighbor_attr_unchanged,
6443 neighbor_attr_unchanged_cmd,
6444 "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6445 NEIGHBOR_STR
6446 NEIGHBOR_ADDR_STR2
6447 "BGP attribute is propagated unchanged to this neighbor\n"
6448 "As-path attribute\n"
6449 "Nexthop attribute\n"
6450 "Med attribute\n")
6451 {
6452 int idx = 0;
6453 char *peer_str = argv[1]->arg;
6454 struct peer *peer;
6455 bool aspath = false;
6456 bool nexthop = false;
6457 bool med = false;
6458 afi_t afi = bgp_node_afi(vty);
6459 safi_t safi = bgp_node_safi(vty);
6460 int ret = 0;
6461
6462 peer = peer_and_group_lookup_vty(vty, peer_str);
6463 if (!peer)
6464 return CMD_WARNING_CONFIG_FAILED;
6465
6466 if (argv_find(argv, argc, "as-path", &idx))
6467 aspath = true;
6468
6469 idx = 0;
6470 if (argv_find(argv, argc, "next-hop", &idx))
6471 nexthop = true;
6472
6473 idx = 0;
6474 if (argv_find(argv, argc, "med", &idx))
6475 med = true;
6476
6477 /* no flags means all of them! */
6478 if (!aspath && !nexthop && !med) {
6479 ret = peer_af_flag_set_vty(vty, peer_str, afi, safi,
6480 PEER_FLAG_AS_PATH_UNCHANGED);
6481 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6482 PEER_FLAG_NEXTHOP_UNCHANGED);
6483 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6484 PEER_FLAG_MED_UNCHANGED);
6485 } else {
6486 if (!aspath) {
6487 if (peer_af_flag_check(peer, afi, safi,
6488 PEER_FLAG_AS_PATH_UNCHANGED)) {
6489 ret |= peer_af_flag_unset_vty(
6490 vty, peer_str, afi, safi,
6491 PEER_FLAG_AS_PATH_UNCHANGED);
6492 }
6493 } else
6494 ret |= peer_af_flag_set_vty(
6495 vty, peer_str, afi, safi,
6496 PEER_FLAG_AS_PATH_UNCHANGED);
6497
6498 if (!nexthop) {
6499 if (peer_af_flag_check(peer, afi, safi,
6500 PEER_FLAG_NEXTHOP_UNCHANGED)) {
6501 ret |= peer_af_flag_unset_vty(
6502 vty, peer_str, afi, safi,
6503 PEER_FLAG_NEXTHOP_UNCHANGED);
6504 }
6505 } else
6506 ret |= peer_af_flag_set_vty(
6507 vty, peer_str, afi, safi,
6508 PEER_FLAG_NEXTHOP_UNCHANGED);
6509
6510 if (!med) {
6511 if (peer_af_flag_check(peer, afi, safi,
6512 PEER_FLAG_MED_UNCHANGED)) {
6513 ret |= peer_af_flag_unset_vty(
6514 vty, peer_str, afi, safi,
6515 PEER_FLAG_MED_UNCHANGED);
6516 }
6517 } else
6518 ret |= peer_af_flag_set_vty(vty, peer_str, afi, safi,
6519 PEER_FLAG_MED_UNCHANGED);
6520 }
6521
6522 return ret;
6523 }
6524
6525 ALIAS_HIDDEN(
6526 neighbor_attr_unchanged, neighbor_attr_unchanged_hidden_cmd,
6527 "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6528 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6529 "BGP attribute is propagated unchanged to this neighbor\n"
6530 "As-path attribute\n"
6531 "Nexthop attribute\n"
6532 "Med attribute\n")
6533
6534 DEFUN (no_neighbor_attr_unchanged,
6535 no_neighbor_attr_unchanged_cmd,
6536 "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6537 NO_STR
6538 NEIGHBOR_STR
6539 NEIGHBOR_ADDR_STR2
6540 "BGP attribute is propagated unchanged to this neighbor\n"
6541 "As-path attribute\n"
6542 "Nexthop attribute\n"
6543 "Med attribute\n")
6544 {
6545 int idx = 0;
6546 char *peer_str = argv[2]->arg;
6547 struct peer *peer;
6548 bool aspath = false;
6549 bool nexthop = false;
6550 bool med = false;
6551 afi_t afi = bgp_node_afi(vty);
6552 safi_t safi = bgp_node_safi(vty);
6553 int ret = 0;
6554
6555 peer = peer_and_group_lookup_vty(vty, peer_str);
6556 if (!peer)
6557 return CMD_WARNING_CONFIG_FAILED;
6558
6559 if (argv_find(argv, argc, "as-path", &idx))
6560 aspath = true;
6561
6562 idx = 0;
6563 if (argv_find(argv, argc, "next-hop", &idx))
6564 nexthop = true;
6565
6566 idx = 0;
6567 if (argv_find(argv, argc, "med", &idx))
6568 med = true;
6569
6570 if (!aspath && !nexthop && !med) // no flags means all of them!
6571 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6572 PEER_FLAG_AS_PATH_UNCHANGED)
6573 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6574 PEER_FLAG_NEXTHOP_UNCHANGED)
6575 | peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6576 PEER_FLAG_MED_UNCHANGED);
6577
6578 if (aspath)
6579 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6580 PEER_FLAG_AS_PATH_UNCHANGED);
6581
6582 if (nexthop)
6583 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6584 PEER_FLAG_NEXTHOP_UNCHANGED);
6585
6586 if (med)
6587 ret |= peer_af_flag_unset_vty(vty, peer_str, afi, safi,
6588 PEER_FLAG_MED_UNCHANGED);
6589
6590 return ret;
6591 }
6592
6593 ALIAS_HIDDEN(
6594 no_neighbor_attr_unchanged, no_neighbor_attr_unchanged_hidden_cmd,
6595 "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
6596 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6597 "BGP attribute is propagated unchanged to this neighbor\n"
6598 "As-path attribute\n"
6599 "Nexthop attribute\n"
6600 "Med attribute\n")
6601
6602 /* EBGP multihop configuration. */
6603 static int peer_ebgp_multihop_set_vty(struct vty *vty, const char *ip_str,
6604 const char *ttl_str)
6605 {
6606 struct peer *peer;
6607 unsigned int ttl;
6608
6609 peer = peer_and_group_lookup_vty(vty, ip_str);
6610 if (!peer)
6611 return CMD_WARNING_CONFIG_FAILED;
6612
6613 if (peer->conf_if)
6614 return bgp_vty_return(vty, BGP_ERR_INVALID_FOR_DIRECT_PEER);
6615
6616 if (!ttl_str)
6617 ttl = MAXTTL;
6618 else
6619 ttl = strtoul(ttl_str, NULL, 10);
6620
6621 return bgp_vty_return(vty, peer_ebgp_multihop_set(peer, ttl));
6622 }
6623
6624 static int peer_ebgp_multihop_unset_vty(struct vty *vty, const char *ip_str)
6625 {
6626 struct peer *peer;
6627
6628 peer = peer_and_group_lookup_vty(vty, ip_str);
6629 if (!peer)
6630 return CMD_WARNING_CONFIG_FAILED;
6631
6632 return bgp_vty_return(vty, peer_ebgp_multihop_unset(peer));
6633 }
6634
6635 /* neighbor ebgp-multihop. */
6636 DEFUN (neighbor_ebgp_multihop,
6637 neighbor_ebgp_multihop_cmd,
6638 "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop",
6639 NEIGHBOR_STR
6640 NEIGHBOR_ADDR_STR2
6641 "Allow EBGP neighbors not on directly connected networks\n")
6642 {
6643 int idx_peer = 1;
6644 return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg, NULL);
6645 }
6646
6647 DEFUN (neighbor_ebgp_multihop_ttl,
6648 neighbor_ebgp_multihop_ttl_cmd,
6649 "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop (1-255)",
6650 NEIGHBOR_STR
6651 NEIGHBOR_ADDR_STR2
6652 "Allow EBGP neighbors not on directly connected networks\n"
6653 "maximum hop count\n")
6654 {
6655 int idx_peer = 1;
6656 int idx_number = 3;
6657 return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg,
6658 argv[idx_number]->arg);
6659 }
6660
6661 DEFUN (no_neighbor_ebgp_multihop,
6662 no_neighbor_ebgp_multihop_cmd,
6663 "no neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop [(1-255)]",
6664 NO_STR
6665 NEIGHBOR_STR
6666 NEIGHBOR_ADDR_STR2
6667 "Allow EBGP neighbors not on directly connected networks\n"
6668 "maximum hop count\n")
6669 {
6670 int idx_peer = 2;
6671 return peer_ebgp_multihop_unset_vty(vty, argv[idx_peer]->arg);
6672 }
6673
6674 DEFPY (neighbor_aigp,
6675 neighbor_aigp_cmd,
6676 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor aigp",
6677 NO_STR
6678 NEIGHBOR_STR
6679 NEIGHBOR_ADDR_STR2
6680 "Enable send and receive of the AIGP attribute per neighbor\n")
6681 {
6682 struct peer *peer;
6683
6684 peer = peer_and_group_lookup_vty(vty, neighbor);
6685 if (!peer)
6686 return CMD_WARNING_CONFIG_FAILED;
6687
6688 if (no)
6689 return peer_flag_unset_vty(vty, neighbor, PEER_FLAG_AIGP);
6690 else
6691 return peer_flag_set_vty(vty, neighbor, PEER_FLAG_AIGP);
6692 }
6693
6694 static uint8_t get_role_by_name(const char *role_str)
6695 {
6696 if (strncmp(role_str, "peer", 2) == 0)
6697 return ROLE_PEER;
6698 if (strncmp(role_str, "provider", 2) == 0)
6699 return ROLE_PROVIDER;
6700 if (strncmp(role_str, "customer", 2) == 0)
6701 return ROLE_CUSTOMER;
6702 if (strncmp(role_str, "rs-server", 4) == 0)
6703 return ROLE_RS_SERVER;
6704 if (strncmp(role_str, "rs-client", 4) == 0)
6705 return ROLE_RS_CLIENT;
6706 return ROLE_UNDEFINED;
6707 }
6708
6709 static int peer_role_set_vty(struct vty *vty, const char *ip_str,
6710 const char *role_str, bool strict_mode)
6711 {
6712 struct peer *peer;
6713
6714 peer = peer_and_group_lookup_vty(vty, ip_str);
6715 if (!peer)
6716 return CMD_WARNING_CONFIG_FAILED;
6717 uint8_t role = get_role_by_name(role_str);
6718
6719 if (role == ROLE_UNDEFINED)
6720 return bgp_vty_return(vty, BGP_ERR_INVALID_ROLE_NAME);
6721 return bgp_vty_return(vty, peer_role_set(peer, role, strict_mode));
6722 }
6723
6724 static int peer_role_unset_vty(struct vty *vty, const char *ip_str)
6725 {
6726 struct peer *peer;
6727
6728 peer = peer_and_group_lookup_vty(vty, ip_str);
6729 if (!peer)
6730 return CMD_WARNING_CONFIG_FAILED;
6731 return bgp_vty_return(vty, peer_role_unset(peer));
6732 }
6733
6734 DEFPY(neighbor_role,
6735 neighbor_role_cmd,
6736 "neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer>",
6737 NEIGHBOR_STR
6738 NEIGHBOR_ADDR_STR2
6739 "Set session role\n"
6740 ROLE_STR)
6741 {
6742 int idx_peer = 1;
6743 int idx_role = 3;
6744
6745 return peer_role_set_vty(vty, argv[idx_peer]->arg, argv[idx_role]->arg,
6746 false);
6747 }
6748
6749 DEFPY(neighbor_role_strict,
6750 neighbor_role_strict_cmd,
6751 "neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer> strict-mode",
6752 NEIGHBOR_STR
6753 NEIGHBOR_ADDR_STR2
6754 "Set session role\n"
6755 ROLE_STR
6756 "Use additional restriction on peer\n")
6757 {
6758 int idx_peer = 1;
6759 int idx_role = 3;
6760
6761 return peer_role_set_vty(vty, argv[idx_peer]->arg, argv[idx_role]->arg,
6762 true);
6763 }
6764
6765 DEFPY(no_neighbor_role,
6766 no_neighbor_role_cmd,
6767 "no neighbor <A.B.C.D|X:X::X:X|WORD> local-role <provider|rs-server|rs-client|customer|peer> [strict-mode]",
6768 NO_STR
6769 NEIGHBOR_STR
6770 NEIGHBOR_ADDR_STR2
6771 "Set session role\n"
6772 ROLE_STR
6773 "Use additional restriction on peer\n")
6774 {
6775 int idx_peer = 2;
6776
6777 return peer_role_unset_vty(vty, argv[idx_peer]->arg);
6778 }
6779
6780 /* disable-connected-check */
6781 DEFUN (neighbor_disable_connected_check,
6782 neighbor_disable_connected_check_cmd,
6783 "neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
6784 NEIGHBOR_STR
6785 NEIGHBOR_ADDR_STR2
6786 "one-hop away EBGP peer using loopback address\n"
6787 "Enforce EBGP neighbors perform multihop\n")
6788 {
6789 int idx_peer = 1;
6790 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6791 PEER_FLAG_DISABLE_CONNECTED_CHECK);
6792 }
6793
6794 DEFUN (no_neighbor_disable_connected_check,
6795 no_neighbor_disable_connected_check_cmd,
6796 "no neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
6797 NO_STR
6798 NEIGHBOR_STR
6799 NEIGHBOR_ADDR_STR2
6800 "one-hop away EBGP peer using loopback address\n"
6801 "Enforce EBGP neighbors perform multihop\n")
6802 {
6803 int idx_peer = 2;
6804 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6805 PEER_FLAG_DISABLE_CONNECTED_CHECK);
6806 }
6807
6808 /* disable-link-bw-encoding-ieee */
6809 DEFUN(neighbor_disable_link_bw_encoding_ieee,
6810 neighbor_disable_link_bw_encoding_ieee_cmd,
6811 "neighbor <A.B.C.D|X:X::X:X|WORD> disable-link-bw-encoding-ieee",
6812 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6813 "Disable IEEE floating-point encoding for extended community bandwidth\n")
6814 {
6815 int idx_peer = 1;
6816
6817 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6818 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE);
6819 }
6820
6821 DEFUN(no_neighbor_disable_link_bw_encoding_ieee,
6822 no_neighbor_disable_link_bw_encoding_ieee_cmd,
6823 "no neighbor <A.B.C.D|X:X::X:X|WORD> disable-link-bw-encoding-ieee",
6824 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6825 "Disable IEEE floating-point encoding for extended community bandwidth\n")
6826 {
6827 int idx_peer = 2;
6828
6829 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6830 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE);
6831 }
6832
6833 /* extended-optional-parameters */
6834 DEFUN(neighbor_extended_optional_parameters,
6835 neighbor_extended_optional_parameters_cmd,
6836 "neighbor <A.B.C.D|X:X::X:X|WORD> extended-optional-parameters",
6837 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6838 "Force the extended optional parameters format for OPEN messages\n")
6839 {
6840 int idx_peer = 1;
6841
6842 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6843 PEER_FLAG_EXTENDED_OPT_PARAMS);
6844 }
6845
6846 DEFUN(no_neighbor_extended_optional_parameters,
6847 no_neighbor_extended_optional_parameters_cmd,
6848 "no neighbor <A.B.C.D|X:X::X:X|WORD> extended-optional-parameters",
6849 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6850 "Force the extended optional parameters format for OPEN messages\n")
6851 {
6852 int idx_peer = 2;
6853
6854 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6855 PEER_FLAG_EXTENDED_OPT_PARAMS);
6856 }
6857
6858 /* enforce-first-as */
6859 DEFUN (neighbor_enforce_first_as,
6860 neighbor_enforce_first_as_cmd,
6861 "neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
6862 NEIGHBOR_STR
6863 NEIGHBOR_ADDR_STR2
6864 "Enforce the first AS for EBGP routes\n")
6865 {
6866 int idx_peer = 1;
6867
6868 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
6869 PEER_FLAG_ENFORCE_FIRST_AS);
6870 }
6871
6872 DEFUN (no_neighbor_enforce_first_as,
6873 no_neighbor_enforce_first_as_cmd,
6874 "no neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
6875 NO_STR
6876 NEIGHBOR_STR
6877 NEIGHBOR_ADDR_STR2
6878 "Enforce the first AS for EBGP routes\n")
6879 {
6880 int idx_peer = 2;
6881
6882 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
6883 PEER_FLAG_ENFORCE_FIRST_AS);
6884 }
6885
6886
6887 DEFUN (neighbor_description,
6888 neighbor_description_cmd,
6889 "neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
6890 NEIGHBOR_STR
6891 NEIGHBOR_ADDR_STR2
6892 "Neighbor specific description\n"
6893 "Up to 80 characters describing this neighbor\n")
6894 {
6895 int idx_peer = 1;
6896 int idx_line = 3;
6897 struct peer *peer;
6898 char *str;
6899
6900 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6901 if (!peer)
6902 return CMD_WARNING_CONFIG_FAILED;
6903
6904 str = argv_concat(argv, argc, idx_line);
6905
6906 peer_description_set(peer, str);
6907
6908 XFREE(MTYPE_TMP, str);
6909
6910 return CMD_SUCCESS;
6911 }
6912
6913 DEFUN (no_neighbor_description,
6914 no_neighbor_description_cmd,
6915 "no neighbor <A.B.C.D|X:X::X:X|WORD> description",
6916 NO_STR
6917 NEIGHBOR_STR
6918 NEIGHBOR_ADDR_STR2
6919 "Neighbor specific description\n")
6920 {
6921 int idx_peer = 2;
6922 struct peer *peer;
6923
6924 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6925 if (!peer)
6926 return CMD_WARNING_CONFIG_FAILED;
6927
6928 peer_description_unset(peer);
6929
6930 return CMD_SUCCESS;
6931 }
6932
6933 ALIAS(no_neighbor_description, no_neighbor_description_comment_cmd,
6934 "no neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
6935 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6936 "Neighbor specific description\n"
6937 "Up to 80 characters describing this neighbor\n")
6938
6939 /* Neighbor update-source. */
6940 static int peer_update_source_vty(struct vty *vty, const char *peer_str,
6941 const char *source_str)
6942 {
6943 struct peer *peer;
6944 struct prefix p;
6945 union sockunion su;
6946
6947 peer = peer_and_group_lookup_vty(vty, peer_str);
6948 if (!peer)
6949 return CMD_WARNING_CONFIG_FAILED;
6950
6951 if (peer->conf_if)
6952 return CMD_WARNING;
6953
6954 if (source_str) {
6955 if (str2sockunion(source_str, &su) == 0)
6956 peer_update_source_addr_set(peer, &su);
6957 else {
6958 if (str2prefix(source_str, &p)) {
6959 vty_out(vty,
6960 "%% Invalid update-source, remove prefix length \n");
6961 return CMD_WARNING_CONFIG_FAILED;
6962 } else
6963 peer_update_source_if_set(peer, source_str);
6964 }
6965 } else
6966 peer_update_source_unset(peer);
6967
6968 return CMD_SUCCESS;
6969 }
6970
6971 #define BGP_UPDATE_SOURCE_HELP_STR \
6972 "IPv4 address\n" \
6973 "IPv6 address\n" \
6974 "Interface name (requires zebra to be running)\n"
6975
6976 DEFUN (neighbor_update_source,
6977 neighbor_update_source_cmd,
6978 "neighbor <A.B.C.D|X:X::X:X|WORD> update-source <A.B.C.D|X:X::X:X|WORD>",
6979 NEIGHBOR_STR
6980 NEIGHBOR_ADDR_STR2
6981 "Source of routing updates\n"
6982 BGP_UPDATE_SOURCE_HELP_STR)
6983 {
6984 int idx_peer = 1;
6985 int idx_peer_2 = 3;
6986 return peer_update_source_vty(vty, argv[idx_peer]->arg,
6987 argv[idx_peer_2]->arg);
6988 }
6989
6990 DEFUN (no_neighbor_update_source,
6991 no_neighbor_update_source_cmd,
6992 "no neighbor <A.B.C.D|X:X::X:X|WORD> update-source [<A.B.C.D|X:X::X:X|WORD>]",
6993 NO_STR
6994 NEIGHBOR_STR
6995 NEIGHBOR_ADDR_STR2
6996 "Source of routing updates\n"
6997 BGP_UPDATE_SOURCE_HELP_STR)
6998 {
6999 int idx_peer = 2;
7000 return peer_update_source_vty(vty, argv[idx_peer]->arg, NULL);
7001 }
7002
7003 static int peer_default_originate_set_vty(struct vty *vty, const char *peer_str,
7004 afi_t afi, safi_t safi,
7005 const char *rmap, int set)
7006 {
7007 int ret;
7008 struct peer *peer;
7009 struct route_map *route_map = NULL;
7010
7011 peer = peer_and_group_lookup_vty(vty, peer_str);
7012 if (!peer)
7013 return CMD_WARNING_CONFIG_FAILED;
7014
7015 if (set) {
7016 if (rmap)
7017 route_map = route_map_lookup_warn_noexist(vty, rmap);
7018 ret = peer_default_originate_set(peer, afi, safi,
7019 rmap, route_map);
7020 } else
7021 ret = peer_default_originate_unset(peer, afi, safi);
7022
7023 return bgp_vty_return(vty, ret);
7024 }
7025
7026 /* neighbor default-originate. */
7027 DEFUN (neighbor_default_originate,
7028 neighbor_default_originate_cmd,
7029 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
7030 NEIGHBOR_STR
7031 NEIGHBOR_ADDR_STR2
7032 "Originate default route to this neighbor\n")
7033 {
7034 int idx_peer = 1;
7035 return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
7036 bgp_node_afi(vty),
7037 bgp_node_safi(vty), NULL, 1);
7038 }
7039
7040 ALIAS_HIDDEN(neighbor_default_originate, neighbor_default_originate_hidden_cmd,
7041 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
7042 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7043 "Originate default route to this neighbor\n")
7044
7045 DEFUN (neighbor_default_originate_rmap,
7046 neighbor_default_originate_rmap_cmd,
7047 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map RMAP_NAME",
7048 NEIGHBOR_STR
7049 NEIGHBOR_ADDR_STR2
7050 "Originate default route to this neighbor\n"
7051 "Route-map to specify criteria to originate default\n"
7052 "route-map name\n")
7053 {
7054 int idx_peer = 1;
7055 int idx_word = 4;
7056 return peer_default_originate_set_vty(
7057 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
7058 argv[idx_word]->arg, 1);
7059 }
7060
7061 ALIAS_HIDDEN(
7062 neighbor_default_originate_rmap,
7063 neighbor_default_originate_rmap_hidden_cmd,
7064 "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map RMAP_NAME",
7065 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7066 "Originate default route to this neighbor\n"
7067 "Route-map to specify criteria to originate default\n"
7068 "route-map name\n")
7069
7070 DEFUN (no_neighbor_default_originate,
7071 no_neighbor_default_originate_cmd,
7072 "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map RMAP_NAME]",
7073 NO_STR
7074 NEIGHBOR_STR
7075 NEIGHBOR_ADDR_STR2
7076 "Originate default route to this neighbor\n"
7077 "Route-map to specify criteria to originate default\n"
7078 "route-map name\n")
7079 {
7080 int idx_peer = 2;
7081 return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
7082 bgp_node_afi(vty),
7083 bgp_node_safi(vty), NULL, 0);
7084 }
7085
7086 ALIAS_HIDDEN(
7087 no_neighbor_default_originate, no_neighbor_default_originate_hidden_cmd,
7088 "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map RMAP_NAME]",
7089 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7090 "Originate default route to this neighbor\n"
7091 "Route-map to specify criteria to originate default\n"
7092 "route-map name\n")
7093
7094
7095 /* Set neighbor's BGP port. */
7096 static int peer_port_vty(struct vty *vty, const char *ip_str, int afi,
7097 const char *port_str)
7098 {
7099 struct peer *peer;
7100 uint16_t port;
7101 struct servent *sp;
7102
7103 peer = peer_and_group_lookup_vty(vty, ip_str);
7104 if (!peer)
7105 return CMD_WARNING_CONFIG_FAILED;
7106
7107 if (!port_str) {
7108 sp = getservbyname("bgp", "tcp");
7109 port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs(sp->s_port);
7110 } else {
7111 port = strtoul(port_str, NULL, 10);
7112 }
7113
7114 peer_port_set(peer, port);
7115
7116 return CMD_SUCCESS;
7117 }
7118
7119 /* Set specified peer's BGP port. */
7120 DEFUN (neighbor_port,
7121 neighbor_port_cmd,
7122 "neighbor <A.B.C.D|X:X::X:X|WORD> port (0-65535)",
7123 NEIGHBOR_STR
7124 NEIGHBOR_ADDR_STR2
7125 "Neighbor's BGP port\n"
7126 "TCP port number\n")
7127 {
7128 int idx_ip = 1;
7129 int idx_number = 3;
7130 return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP,
7131 argv[idx_number]->arg);
7132 }
7133
7134 DEFUN (no_neighbor_port,
7135 no_neighbor_port_cmd,
7136 "no neighbor <A.B.C.D|X:X::X:X|WORD> port [(0-65535)]",
7137 NO_STR
7138 NEIGHBOR_STR
7139 NEIGHBOR_ADDR_STR2
7140 "Neighbor's BGP port\n"
7141 "TCP port number\n")
7142 {
7143 int idx_ip = 2;
7144 return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP, NULL);
7145 }
7146
7147
7148 /* neighbor weight. */
7149 static int peer_weight_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
7150 safi_t safi, const char *weight_str)
7151 {
7152 int ret;
7153 struct peer *peer;
7154 unsigned long weight;
7155
7156 peer = peer_and_group_lookup_vty(vty, ip_str);
7157 if (!peer)
7158 return CMD_WARNING_CONFIG_FAILED;
7159
7160 weight = strtoul(weight_str, NULL, 10);
7161
7162 ret = peer_weight_set(peer, afi, safi, weight);
7163 return bgp_vty_return(vty, ret);
7164 }
7165
7166 static int peer_weight_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
7167 safi_t safi)
7168 {
7169 int ret;
7170 struct peer *peer;
7171
7172 peer = peer_and_group_lookup_vty(vty, ip_str);
7173 if (!peer)
7174 return CMD_WARNING_CONFIG_FAILED;
7175
7176 ret = peer_weight_unset(peer, afi, safi);
7177 return bgp_vty_return(vty, ret);
7178 }
7179
7180 DEFUN (neighbor_weight,
7181 neighbor_weight_cmd,
7182 "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
7183 NEIGHBOR_STR
7184 NEIGHBOR_ADDR_STR2
7185 "Set default weight for routes from this neighbor\n"
7186 "default weight\n")
7187 {
7188 int idx_peer = 1;
7189 int idx_number = 3;
7190 return peer_weight_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
7191 bgp_node_safi(vty), argv[idx_number]->arg);
7192 }
7193
7194 ALIAS_HIDDEN(neighbor_weight, neighbor_weight_hidden_cmd,
7195 "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
7196 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7197 "Set default weight for routes from this neighbor\n"
7198 "default weight\n")
7199
7200 DEFUN (no_neighbor_weight,
7201 no_neighbor_weight_cmd,
7202 "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
7203 NO_STR
7204 NEIGHBOR_STR
7205 NEIGHBOR_ADDR_STR2
7206 "Set default weight for routes from this neighbor\n"
7207 "default weight\n")
7208 {
7209 int idx_peer = 2;
7210 return peer_weight_unset_vty(vty, argv[idx_peer]->arg,
7211 bgp_node_afi(vty), bgp_node_safi(vty));
7212 }
7213
7214 ALIAS_HIDDEN(no_neighbor_weight, no_neighbor_weight_hidden_cmd,
7215 "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
7216 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7217 "Set default weight for routes from this neighbor\n"
7218 "default weight\n")
7219
7220
7221 /* Override capability negotiation. */
7222 DEFUN (neighbor_override_capability,
7223 neighbor_override_capability_cmd,
7224 "neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
7225 NEIGHBOR_STR
7226 NEIGHBOR_ADDR_STR2
7227 "Override capability negotiation result\n")
7228 {
7229 int idx_peer = 1;
7230 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
7231 PEER_FLAG_OVERRIDE_CAPABILITY);
7232 }
7233
7234 DEFUN (no_neighbor_override_capability,
7235 no_neighbor_override_capability_cmd,
7236 "no neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
7237 NO_STR
7238 NEIGHBOR_STR
7239 NEIGHBOR_ADDR_STR2
7240 "Override capability negotiation result\n")
7241 {
7242 int idx_peer = 2;
7243 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
7244 PEER_FLAG_OVERRIDE_CAPABILITY);
7245 }
7246
7247 DEFUN (neighbor_strict_capability,
7248 neighbor_strict_capability_cmd,
7249 "neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
7250 NEIGHBOR_STR
7251 NEIGHBOR_ADDR_STR2
7252 "Strict capability negotiation match\n")
7253 {
7254 int idx_peer = 1;
7255
7256 return peer_flag_set_vty(vty, argv[idx_peer]->arg,
7257 PEER_FLAG_STRICT_CAP_MATCH);
7258 }
7259
7260 DEFUN (no_neighbor_strict_capability,
7261 no_neighbor_strict_capability_cmd,
7262 "no neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
7263 NO_STR
7264 NEIGHBOR_STR
7265 NEIGHBOR_ADDR_STR2
7266 "Strict capability negotiation match\n")
7267 {
7268 int idx_peer = 2;
7269
7270 return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
7271 PEER_FLAG_STRICT_CAP_MATCH);
7272 }
7273
7274 static int peer_timers_set_vty(struct vty *vty, const char *ip_str,
7275 const char *keep_str, const char *hold_str)
7276 {
7277 int ret;
7278 struct peer *peer;
7279 uint32_t keepalive;
7280 uint32_t holdtime;
7281
7282 peer = peer_and_group_lookup_vty(vty, ip_str);
7283 if (!peer)
7284 return CMD_WARNING_CONFIG_FAILED;
7285
7286 keepalive = strtoul(keep_str, NULL, 10);
7287 holdtime = strtoul(hold_str, NULL, 10);
7288
7289 ret = peer_timers_set(peer, keepalive, holdtime);
7290
7291 return bgp_vty_return(vty, ret);
7292 }
7293
7294 static int peer_timers_unset_vty(struct vty *vty, const char *ip_str)
7295 {
7296 int ret;
7297 struct peer *peer;
7298
7299 peer = peer_and_group_lookup_vty(vty, ip_str);
7300 if (!peer)
7301 return CMD_WARNING_CONFIG_FAILED;
7302
7303 ret = peer_timers_unset(peer);
7304
7305 return bgp_vty_return(vty, ret);
7306 }
7307
7308 DEFUN (neighbor_timers,
7309 neighbor_timers_cmd,
7310 "neighbor <A.B.C.D|X:X::X:X|WORD> timers (0-65535) (0-65535)",
7311 NEIGHBOR_STR
7312 NEIGHBOR_ADDR_STR2
7313 "BGP per neighbor timers\n"
7314 "Keepalive interval\n"
7315 "Holdtime\n")
7316 {
7317 int idx_peer = 1;
7318 int idx_number = 3;
7319 int idx_number_2 = 4;
7320 return peer_timers_set_vty(vty, argv[idx_peer]->arg,
7321 argv[idx_number]->arg,
7322 argv[idx_number_2]->arg);
7323 }
7324
7325 DEFUN (no_neighbor_timers,
7326 no_neighbor_timers_cmd,
7327 "no neighbor <A.B.C.D|X:X::X:X|WORD> timers [(0-65535) (0-65535)]",
7328 NO_STR
7329 NEIGHBOR_STR
7330 NEIGHBOR_ADDR_STR2
7331 "BGP per neighbor timers\n"
7332 "Keepalive interval\n"
7333 "Holdtime\n")
7334 {
7335 int idx_peer = 2;
7336 return peer_timers_unset_vty(vty, argv[idx_peer]->arg);
7337 }
7338
7339
7340 static int peer_timers_connect_set_vty(struct vty *vty, const char *ip_str,
7341 const char *time_str)
7342 {
7343 int ret;
7344 struct peer *peer;
7345 uint32_t connect;
7346
7347 peer = peer_and_group_lookup_vty(vty, ip_str);
7348 if (!peer)
7349 return CMD_WARNING_CONFIG_FAILED;
7350
7351 connect = strtoul(time_str, NULL, 10);
7352
7353 ret = peer_timers_connect_set(peer, connect);
7354
7355 return bgp_vty_return(vty, ret);
7356 }
7357
7358 static int peer_timers_connect_unset_vty(struct vty *vty, const char *ip_str)
7359 {
7360 int ret;
7361 struct peer *peer;
7362
7363 peer = peer_and_group_lookup_vty(vty, ip_str);
7364 if (!peer)
7365 return CMD_WARNING_CONFIG_FAILED;
7366
7367 ret = peer_timers_connect_unset(peer);
7368
7369 return bgp_vty_return(vty, ret);
7370 }
7371
7372 DEFUN (neighbor_timers_connect,
7373 neighbor_timers_connect_cmd,
7374 "neighbor <A.B.C.D|X:X::X:X|WORD> timers connect (1-65535)",
7375 NEIGHBOR_STR
7376 NEIGHBOR_ADDR_STR2
7377 "BGP per neighbor timers\n"
7378 "BGP connect timer\n"
7379 "Connect timer\n")
7380 {
7381 int idx_peer = 1;
7382 int idx_number = 4;
7383 return peer_timers_connect_set_vty(vty, argv[idx_peer]->arg,
7384 argv[idx_number]->arg);
7385 }
7386
7387 DEFUN (no_neighbor_timers_connect,
7388 no_neighbor_timers_connect_cmd,
7389 "no neighbor <A.B.C.D|X:X::X:X|WORD> timers connect [(1-65535)]",
7390 NO_STR
7391 NEIGHBOR_STR
7392 NEIGHBOR_ADDR_STR2
7393 "BGP per neighbor timers\n"
7394 "BGP connect timer\n"
7395 "Connect timer\n")
7396 {
7397 int idx_peer = 2;
7398 return peer_timers_connect_unset_vty(vty, argv[idx_peer]->arg);
7399 }
7400
7401 DEFPY (neighbor_timers_delayopen,
7402 neighbor_timers_delayopen_cmd,
7403 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor timers delayopen (1-240)$interval",
7404 NEIGHBOR_STR
7405 NEIGHBOR_ADDR_STR2
7406 "BGP per neighbor timers\n"
7407 "RFC 4271 DelayOpenTimer\n"
7408 "DelayOpenTime timer interval\n")
7409 {
7410 struct peer *peer;
7411
7412 peer = peer_and_group_lookup_vty(vty, neighbor);
7413 if (!peer)
7414 return CMD_WARNING_CONFIG_FAILED;
7415
7416 if (!interval) {
7417 if (peer_timers_delayopen_unset(peer))
7418 return CMD_WARNING_CONFIG_FAILED;
7419 } else {
7420 if (peer_timers_delayopen_set(peer, interval))
7421 return CMD_WARNING_CONFIG_FAILED;
7422 }
7423
7424 return CMD_SUCCESS;
7425 }
7426
7427 DEFPY (no_neighbor_timers_delayopen,
7428 no_neighbor_timers_delayopen_cmd,
7429 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor timers delayopen [(0-65535)]",
7430 NO_STR
7431 NEIGHBOR_STR
7432 NEIGHBOR_ADDR_STR2
7433 "BGP per neighbor timers\n"
7434 "RFC 4271 DelayOpenTimer\n"
7435 "DelayOpenTime timer interval\n")
7436 {
7437 struct peer *peer;
7438
7439 peer = peer_and_group_lookup_vty(vty, neighbor);
7440 if (!peer)
7441 return CMD_WARNING_CONFIG_FAILED;
7442
7443 if (peer_timers_delayopen_unset(peer))
7444 return CMD_WARNING_CONFIG_FAILED;
7445
7446 return CMD_SUCCESS;
7447 }
7448
7449 static int peer_advertise_interval_vty(struct vty *vty, const char *ip_str,
7450 const char *time_str, int set)
7451 {
7452 int ret;
7453 struct peer *peer;
7454 uint32_t routeadv = 0;
7455
7456 peer = peer_and_group_lookup_vty(vty, ip_str);
7457 if (!peer)
7458 return CMD_WARNING_CONFIG_FAILED;
7459
7460 if (time_str)
7461 routeadv = strtoul(time_str, NULL, 10);
7462
7463 if (set)
7464 ret = peer_advertise_interval_set(peer, routeadv);
7465 else
7466 ret = peer_advertise_interval_unset(peer);
7467
7468 return bgp_vty_return(vty, ret);
7469 }
7470
7471 DEFUN (neighbor_advertise_interval,
7472 neighbor_advertise_interval_cmd,
7473 "neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval (0-600)",
7474 NEIGHBOR_STR
7475 NEIGHBOR_ADDR_STR2
7476 "Minimum interval between sending BGP routing updates\n"
7477 "time in seconds\n")
7478 {
7479 int idx_peer = 1;
7480 int idx_number = 3;
7481 return peer_advertise_interval_vty(vty, argv[idx_peer]->arg,
7482 argv[idx_number]->arg, 1);
7483 }
7484
7485 DEFUN (no_neighbor_advertise_interval,
7486 no_neighbor_advertise_interval_cmd,
7487 "no neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval [(0-600)]",
7488 NO_STR
7489 NEIGHBOR_STR
7490 NEIGHBOR_ADDR_STR2
7491 "Minimum interval between sending BGP routing updates\n"
7492 "time in seconds\n")
7493 {
7494 int idx_peer = 2;
7495 return peer_advertise_interval_vty(vty, argv[idx_peer]->arg, NULL, 0);
7496 }
7497
7498
7499 /* Time to wait before processing route-map updates */
7500 DEFUN (bgp_set_route_map_delay_timer,
7501 bgp_set_route_map_delay_timer_cmd,
7502 "bgp route-map delay-timer (0-600)",
7503 SET_STR
7504 "BGP route-map delay timer\n"
7505 "Time in secs to wait before processing route-map changes\n"
7506 "0 disables the timer, no route updates happen when route-maps change\n")
7507 {
7508 int idx_number = 3;
7509 uint32_t rmap_delay_timer;
7510
7511 if (argv[idx_number]->arg) {
7512 rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
7513 bm->rmap_update_timer = rmap_delay_timer;
7514
7515 /* if the dynamic update handling is being disabled, and a timer
7516 * is
7517 * running, stop the timer and act as if the timer has already
7518 * fired.
7519 */
7520 if (!rmap_delay_timer && bm->t_rmap_update) {
7521 THREAD_OFF(bm->t_rmap_update);
7522 thread_execute(bm->master, bgp_route_map_update_timer,
7523 NULL, 0);
7524 }
7525 return CMD_SUCCESS;
7526 } else {
7527 vty_out(vty, "%% BGP invalid route-map delay-timer\n");
7528 return CMD_WARNING_CONFIG_FAILED;
7529 }
7530 }
7531
7532 DEFUN (no_bgp_set_route_map_delay_timer,
7533 no_bgp_set_route_map_delay_timer_cmd,
7534 "no bgp route-map delay-timer [(0-600)]",
7535 NO_STR
7536 BGP_STR
7537 "Default BGP route-map delay timer\n"
7538 "Reset to default time to wait for processing route-map changes\n"
7539 "0 disables the timer, no route updates happen when route-maps change\n")
7540 {
7541
7542 bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
7543
7544 return CMD_SUCCESS;
7545 }
7546
7547 /* neighbor interface */
7548 static int peer_interface_vty(struct vty *vty, const char *ip_str,
7549 const char *str)
7550 {
7551 struct peer *peer;
7552
7553 peer = peer_lookup_vty(vty, ip_str);
7554 if (!peer || peer->conf_if) {
7555 vty_out(vty, "%% BGP invalid peer %s\n", ip_str);
7556 return CMD_WARNING_CONFIG_FAILED;
7557 }
7558
7559 if (str)
7560 peer_interface_set(peer, str);
7561 else
7562 peer_interface_unset(peer);
7563
7564 return CMD_SUCCESS;
7565 }
7566
7567 DEFUN (neighbor_interface,
7568 neighbor_interface_cmd,
7569 "neighbor <A.B.C.D|X:X::X:X> interface WORD",
7570 NEIGHBOR_STR
7571 NEIGHBOR_ADDR_STR
7572 "Interface\n"
7573 "Interface name\n")
7574 {
7575 int idx_ip = 1;
7576 int idx_word = 3;
7577
7578 return peer_interface_vty(vty, argv[idx_ip]->arg, argv[idx_word]->arg);
7579 }
7580
7581 DEFUN (no_neighbor_interface,
7582 no_neighbor_interface_cmd,
7583 "no neighbor <A.B.C.D|X:X::X:X> interface WORD",
7584 NO_STR
7585 NEIGHBOR_STR
7586 NEIGHBOR_ADDR_STR
7587 "Interface\n"
7588 "Interface name\n")
7589 {
7590 int idx_peer = 2;
7591
7592 return peer_interface_vty(vty, argv[idx_peer]->arg, NULL);
7593 }
7594
7595 DEFUN (neighbor_distribute_list,
7596 neighbor_distribute_list_cmd,
7597 "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7598 NEIGHBOR_STR
7599 NEIGHBOR_ADDR_STR2
7600 "Filter updates to/from this neighbor\n"
7601 "IP Access-list name\n"
7602 "Filter incoming updates\n"
7603 "Filter outgoing updates\n")
7604 {
7605 int idx_peer = 1;
7606 int idx_acl = 3;
7607 int direct, ret;
7608 struct peer *peer;
7609
7610 const char *pstr = argv[idx_peer]->arg;
7611 const char *acl = argv[idx_acl]->arg;
7612 const char *inout = argv[argc - 1]->text;
7613
7614 peer = peer_and_group_lookup_vty(vty, pstr);
7615 if (!peer)
7616 return CMD_WARNING_CONFIG_FAILED;
7617
7618 /* Check filter direction. */
7619 direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
7620 ret = peer_distribute_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
7621 direct, acl);
7622
7623 return bgp_vty_return(vty, ret);
7624 }
7625
7626 ALIAS_HIDDEN(
7627 neighbor_distribute_list, neighbor_distribute_list_hidden_cmd,
7628 "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7629 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7630 "Filter updates to/from this neighbor\n"
7631 "IP Access-list name\n"
7632 "Filter incoming updates\n"
7633 "Filter outgoing updates\n")
7634
7635 DEFUN (no_neighbor_distribute_list,
7636 no_neighbor_distribute_list_cmd,
7637 "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7638 NO_STR
7639 NEIGHBOR_STR
7640 NEIGHBOR_ADDR_STR2
7641 "Filter updates to/from this neighbor\n"
7642 "IP Access-list name\n"
7643 "Filter incoming updates\n"
7644 "Filter outgoing updates\n")
7645 {
7646 int idx_peer = 2;
7647 int direct, ret;
7648 struct peer *peer;
7649
7650 const char *pstr = argv[idx_peer]->arg;
7651 const char *inout = argv[argc - 1]->text;
7652
7653 peer = peer_and_group_lookup_vty(vty, pstr);
7654 if (!peer)
7655 return CMD_WARNING_CONFIG_FAILED;
7656
7657 /* Check filter direction. */
7658 direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
7659 ret = peer_distribute_unset(peer, bgp_node_afi(vty), bgp_node_safi(vty),
7660 direct);
7661
7662 return bgp_vty_return(vty, ret);
7663 }
7664
7665 ALIAS_HIDDEN(
7666 no_neighbor_distribute_list, no_neighbor_distribute_list_hidden_cmd,
7667 "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list ACCESSLIST_NAME <in|out>",
7668 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7669 "Filter updates to/from this neighbor\n"
7670 "IP Access-list name\n"
7671 "Filter incoming updates\n"
7672 "Filter outgoing updates\n")
7673
7674 /* Set prefix list to the peer. */
7675 static int peer_prefix_list_set_vty(struct vty *vty, const char *ip_str,
7676 afi_t afi, safi_t safi,
7677 const char *name_str,
7678 const char *direct_str)
7679 {
7680 int ret;
7681 int direct = FILTER_IN;
7682 struct peer *peer;
7683
7684 peer = peer_and_group_lookup_vty(vty, ip_str);
7685 if (!peer)
7686 return CMD_WARNING_CONFIG_FAILED;
7687
7688 /* Check filter direction. */
7689 if (strncmp(direct_str, "i", 1) == 0)
7690 direct = FILTER_IN;
7691 else if (strncmp(direct_str, "o", 1) == 0)
7692 direct = FILTER_OUT;
7693
7694 ret = peer_prefix_list_set(peer, afi, safi, direct, name_str);
7695
7696 return bgp_vty_return(vty, ret);
7697 }
7698
7699 static int peer_prefix_list_unset_vty(struct vty *vty, const char *ip_str,
7700 afi_t afi, safi_t safi,
7701 const char *direct_str)
7702 {
7703 int ret;
7704 struct peer *peer;
7705 int direct = FILTER_IN;
7706
7707 peer = peer_and_group_lookup_vty(vty, ip_str);
7708 if (!peer)
7709 return CMD_WARNING_CONFIG_FAILED;
7710
7711 /* Check filter direction. */
7712 if (strncmp(direct_str, "i", 1) == 0)
7713 direct = FILTER_IN;
7714 else if (strncmp(direct_str, "o", 1) == 0)
7715 direct = FILTER_OUT;
7716
7717 ret = peer_prefix_list_unset(peer, afi, safi, direct);
7718
7719 return bgp_vty_return(vty, ret);
7720 }
7721
7722 DEFUN (neighbor_prefix_list,
7723 neighbor_prefix_list_cmd,
7724 "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7725 NEIGHBOR_STR
7726 NEIGHBOR_ADDR_STR2
7727 "Filter updates to/from this neighbor\n"
7728 "Name of a prefix list\n"
7729 "Filter incoming updates\n"
7730 "Filter outgoing updates\n")
7731 {
7732 int idx_peer = 1;
7733 int idx_word = 3;
7734 int idx_in_out = 4;
7735 return peer_prefix_list_set_vty(
7736 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
7737 argv[idx_word]->arg, argv[idx_in_out]->arg);
7738 }
7739
7740 ALIAS_HIDDEN(neighbor_prefix_list, neighbor_prefix_list_hidden_cmd,
7741 "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7742 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7743 "Filter updates to/from this neighbor\n"
7744 "Name of a prefix list\n"
7745 "Filter incoming updates\n"
7746 "Filter outgoing updates\n")
7747
7748 DEFUN (no_neighbor_prefix_list,
7749 no_neighbor_prefix_list_cmd,
7750 "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7751 NO_STR
7752 NEIGHBOR_STR
7753 NEIGHBOR_ADDR_STR2
7754 "Filter updates to/from this neighbor\n"
7755 "Name of a prefix list\n"
7756 "Filter incoming updates\n"
7757 "Filter outgoing updates\n")
7758 {
7759 int idx_peer = 2;
7760 int idx_in_out = 5;
7761 return peer_prefix_list_unset_vty(vty, argv[idx_peer]->arg,
7762 bgp_node_afi(vty), bgp_node_safi(vty),
7763 argv[idx_in_out]->arg);
7764 }
7765
7766 ALIAS_HIDDEN(no_neighbor_prefix_list, no_neighbor_prefix_list_hidden_cmd,
7767 "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
7768 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7769 "Filter updates to/from this neighbor\n"
7770 "Name of a prefix list\n"
7771 "Filter incoming updates\n"
7772 "Filter outgoing updates\n")
7773
7774 static int peer_aslist_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
7775 safi_t safi, const char *name_str,
7776 const char *direct_str)
7777 {
7778 int ret;
7779 struct peer *peer;
7780 int direct = FILTER_IN;
7781
7782 peer = peer_and_group_lookup_vty(vty, ip_str);
7783 if (!peer)
7784 return CMD_WARNING_CONFIG_FAILED;
7785
7786 /* Check filter direction. */
7787 if (strncmp(direct_str, "i", 1) == 0)
7788 direct = FILTER_IN;
7789 else if (strncmp(direct_str, "o", 1) == 0)
7790 direct = FILTER_OUT;
7791
7792 ret = peer_aslist_set(peer, afi, safi, direct, name_str);
7793
7794 return bgp_vty_return(vty, ret);
7795 }
7796
7797 static int peer_aslist_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
7798 safi_t safi, const char *direct_str)
7799 {
7800 int ret;
7801 struct peer *peer;
7802 int direct = FILTER_IN;
7803
7804 peer = peer_and_group_lookup_vty(vty, ip_str);
7805 if (!peer)
7806 return CMD_WARNING_CONFIG_FAILED;
7807
7808 /* Check filter direction. */
7809 if (strncmp(direct_str, "i", 1) == 0)
7810 direct = FILTER_IN;
7811 else if (strncmp(direct_str, "o", 1) == 0)
7812 direct = FILTER_OUT;
7813
7814 ret = peer_aslist_unset(peer, afi, safi, direct);
7815
7816 return bgp_vty_return(vty, ret);
7817 }
7818
7819 DEFUN (neighbor_filter_list,
7820 neighbor_filter_list_cmd,
7821 "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7822 NEIGHBOR_STR
7823 NEIGHBOR_ADDR_STR2
7824 "Establish BGP filters\n"
7825 "AS path access-list name\n"
7826 "Filter incoming routes\n"
7827 "Filter outgoing routes\n")
7828 {
7829 int idx_peer = 1;
7830 int idx_word = 3;
7831 int idx_in_out = 4;
7832 return peer_aslist_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
7833 bgp_node_safi(vty), argv[idx_word]->arg,
7834 argv[idx_in_out]->arg);
7835 }
7836
7837 ALIAS_HIDDEN(neighbor_filter_list, neighbor_filter_list_hidden_cmd,
7838 "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7839 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7840 "Establish BGP filters\n"
7841 "AS path access-list name\n"
7842 "Filter incoming routes\n"
7843 "Filter outgoing routes\n")
7844
7845 DEFUN (no_neighbor_filter_list,
7846 no_neighbor_filter_list_cmd,
7847 "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7848 NO_STR
7849 NEIGHBOR_STR
7850 NEIGHBOR_ADDR_STR2
7851 "Establish BGP filters\n"
7852 "AS path access-list name\n"
7853 "Filter incoming routes\n"
7854 "Filter outgoing routes\n")
7855 {
7856 int idx_peer = 2;
7857 int idx_in_out = 5;
7858 return peer_aslist_unset_vty(vty, argv[idx_peer]->arg,
7859 bgp_node_afi(vty), bgp_node_safi(vty),
7860 argv[idx_in_out]->arg);
7861 }
7862
7863 ALIAS_HIDDEN(no_neighbor_filter_list, no_neighbor_filter_list_hidden_cmd,
7864 "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list AS_PATH_FILTER_NAME <in|out>",
7865 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7866 "Establish BGP filters\n"
7867 "AS path access-list name\n"
7868 "Filter incoming routes\n"
7869 "Filter outgoing routes\n")
7870
7871 /* Set advertise-map to the peer. */
7872 static int peer_advertise_map_set_vty(struct vty *vty, const char *ip_str,
7873 afi_t afi, safi_t safi,
7874 const char *advertise_str,
7875 const char *condition_str, bool condition,
7876 bool set)
7877 {
7878 int ret = CMD_WARNING_CONFIG_FAILED;
7879 struct peer *peer;
7880 struct route_map *advertise_map;
7881 struct route_map *condition_map;
7882
7883 peer = peer_and_group_lookup_vty(vty, ip_str);
7884 if (!peer)
7885 return ret;
7886
7887 condition_map = route_map_lookup_warn_noexist(vty, condition_str);
7888 advertise_map = route_map_lookup_warn_noexist(vty, advertise_str);
7889
7890 if (set)
7891 ret = peer_advertise_map_set(peer, afi, safi, advertise_str,
7892 advertise_map, condition_str,
7893 condition_map, condition);
7894 else
7895 ret = peer_advertise_map_unset(peer, afi, safi, advertise_str,
7896 advertise_map, condition_str,
7897 condition_map, condition);
7898
7899 return bgp_vty_return(vty, ret);
7900 }
7901
7902 DEFPY (bgp_condadv_period,
7903 bgp_condadv_period_cmd,
7904 "[no$no] bgp conditional-advertisement timer (5-240)$period",
7905 NO_STR
7906 BGP_STR
7907 "Conditional advertisement settings\n"
7908 "Set period to rescan BGP table to check if condition is met\n"
7909 "Period between BGP table scans, in seconds; default 60\n")
7910 {
7911 VTY_DECLVAR_CONTEXT(bgp, bgp);
7912
7913 bgp->condition_check_period =
7914 no ? DEFAULT_CONDITIONAL_ROUTES_POLL_TIME : period;
7915
7916 return CMD_SUCCESS;
7917 }
7918
7919 DEFPY (neighbor_advertise_map,
7920 neighbor_advertise_map_cmd,
7921 "[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",
7922 NO_STR
7923 NEIGHBOR_STR
7924 NEIGHBOR_ADDR_STR2
7925 "Route-map to conditionally advertise routes\n"
7926 "Name of advertise map\n"
7927 "Advertise routes only if prefixes in exist-map are installed in BGP table\n"
7928 "Advertise routes only if prefixes in non-exist-map are not installed in BGP table\n"
7929 "Name of the exist or non exist map\n")
7930 {
7931 bool condition = CONDITION_EXIST;
7932
7933 if (!strcmp(exist, "non-exist-map"))
7934 condition = CONDITION_NON_EXIST;
7935
7936 return peer_advertise_map_set_vty(vty, neighbor, bgp_node_afi(vty),
7937 bgp_node_safi(vty), advertise_str,
7938 condition_str, condition, !no);
7939 }
7940
7941 ALIAS_HIDDEN(neighbor_advertise_map, neighbor_advertise_map_hidden_cmd,
7942 "[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",
7943 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
7944 "Route-map to conditionally advertise routes\n"
7945 "Name of advertise map\n"
7946 "Advertise routes only if prefixes in exist-map are installed in BGP table\n"
7947 "Advertise routes only if prefixes in non-exist-map are not installed in BGP table\n"
7948 "Name of the exist or non exist map\n")
7949
7950 /* Set route-map to the peer. */
7951 static int peer_route_map_set_vty(struct vty *vty, const char *ip_str,
7952 afi_t afi, safi_t safi, const char *name_str,
7953 const char *direct_str)
7954 {
7955 int ret;
7956 struct peer *peer;
7957 int direct = RMAP_IN;
7958 struct route_map *route_map;
7959
7960 peer = peer_and_group_lookup_vty(vty, ip_str);
7961 if (!peer)
7962 return CMD_WARNING_CONFIG_FAILED;
7963
7964 /* Check filter direction. */
7965 if (strncmp(direct_str, "in", 2) == 0)
7966 direct = RMAP_IN;
7967 else if (strncmp(direct_str, "o", 1) == 0)
7968 direct = RMAP_OUT;
7969
7970 route_map = route_map_lookup_warn_noexist(vty, name_str);
7971 ret = peer_route_map_set(peer, afi, safi, direct, name_str, route_map);
7972
7973 return bgp_vty_return(vty, ret);
7974 }
7975
7976 static int peer_route_map_unset_vty(struct vty *vty, const char *ip_str,
7977 afi_t afi, safi_t safi,
7978 const char *direct_str)
7979 {
7980 int ret;
7981 struct peer *peer;
7982 int direct = RMAP_IN;
7983
7984 peer = peer_and_group_lookup_vty(vty, ip_str);
7985 if (!peer)
7986 return CMD_WARNING_CONFIG_FAILED;
7987
7988 /* Check filter direction. */
7989 if (strncmp(direct_str, "in", 2) == 0)
7990 direct = RMAP_IN;
7991 else if (strncmp(direct_str, "o", 1) == 0)
7992 direct = RMAP_OUT;
7993
7994 ret = peer_route_map_unset(peer, afi, safi, direct);
7995
7996 return bgp_vty_return(vty, ret);
7997 }
7998
7999 DEFUN (neighbor_route_map,
8000 neighbor_route_map_cmd,
8001 "neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
8002 NEIGHBOR_STR
8003 NEIGHBOR_ADDR_STR2
8004 "Apply route map to neighbor\n"
8005 "Name of route map\n"
8006 "Apply map to incoming routes\n"
8007 "Apply map to outbound routes\n")
8008 {
8009 int idx_peer = 1;
8010 int idx_word = 3;
8011 int idx_in_out = 4;
8012 return peer_route_map_set_vty(
8013 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8014 argv[idx_word]->arg, argv[idx_in_out]->arg);
8015 }
8016
8017 ALIAS_HIDDEN(neighbor_route_map, neighbor_route_map_hidden_cmd,
8018 "neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
8019 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8020 "Apply route map to neighbor\n"
8021 "Name of route map\n"
8022 "Apply map to incoming routes\n"
8023 "Apply map to outbound routes\n")
8024
8025 DEFUN (no_neighbor_route_map,
8026 no_neighbor_route_map_cmd,
8027 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
8028 NO_STR
8029 NEIGHBOR_STR
8030 NEIGHBOR_ADDR_STR2
8031 "Apply route map to neighbor\n"
8032 "Name of route map\n"
8033 "Apply map to incoming routes\n"
8034 "Apply map to outbound routes\n")
8035 {
8036 int idx_peer = 2;
8037 int idx_in_out = 5;
8038 return peer_route_map_unset_vty(vty, argv[idx_peer]->arg,
8039 bgp_node_afi(vty), bgp_node_safi(vty),
8040 argv[idx_in_out]->arg);
8041 }
8042
8043 ALIAS_HIDDEN(no_neighbor_route_map, no_neighbor_route_map_hidden_cmd,
8044 "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map RMAP_NAME <in|out>",
8045 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8046 "Apply route map to neighbor\n"
8047 "Name of route map\n"
8048 "Apply map to incoming routes\n"
8049 "Apply map to outbound routes\n")
8050
8051 /* Set unsuppress-map to the peer. */
8052 static int peer_unsuppress_map_set_vty(struct vty *vty, const char *ip_str,
8053 afi_t afi, safi_t safi,
8054 const char *name_str)
8055 {
8056 int ret;
8057 struct peer *peer;
8058 struct route_map *route_map;
8059
8060 peer = peer_and_group_lookup_vty(vty, ip_str);
8061 if (!peer)
8062 return CMD_WARNING_CONFIG_FAILED;
8063
8064 route_map = route_map_lookup_warn_noexist(vty, name_str);
8065 ret = peer_unsuppress_map_set(peer, afi, safi, name_str, route_map);
8066
8067 return bgp_vty_return(vty, ret);
8068 }
8069
8070 /* Unset route-map from the peer. */
8071 static int peer_unsuppress_map_unset_vty(struct vty *vty, const char *ip_str,
8072 afi_t afi, safi_t safi)
8073 {
8074 int ret;
8075 struct peer *peer;
8076
8077 peer = peer_and_group_lookup_vty(vty, ip_str);
8078 if (!peer)
8079 return CMD_WARNING_CONFIG_FAILED;
8080
8081 ret = peer_unsuppress_map_unset(peer, afi, safi);
8082
8083 return bgp_vty_return(vty, ret);
8084 }
8085
8086 DEFUN (neighbor_unsuppress_map,
8087 neighbor_unsuppress_map_cmd,
8088 "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
8089 NEIGHBOR_STR
8090 NEIGHBOR_ADDR_STR2
8091 "Route-map to selectively unsuppress suppressed routes\n"
8092 "Name of route map\n")
8093 {
8094 int idx_peer = 1;
8095 int idx_word = 3;
8096 return peer_unsuppress_map_set_vty(
8097 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8098 argv[idx_word]->arg);
8099 }
8100
8101 ALIAS_HIDDEN(neighbor_unsuppress_map, neighbor_unsuppress_map_hidden_cmd,
8102 "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
8103 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8104 "Route-map to selectively unsuppress suppressed routes\n"
8105 "Name of route map\n")
8106
8107 DEFUN (no_neighbor_unsuppress_map,
8108 no_neighbor_unsuppress_map_cmd,
8109 "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
8110 NO_STR
8111 NEIGHBOR_STR
8112 NEIGHBOR_ADDR_STR2
8113 "Route-map to selectively unsuppress suppressed routes\n"
8114 "Name of route map\n")
8115 {
8116 int idx_peer = 2;
8117 return peer_unsuppress_map_unset_vty(vty, argv[idx_peer]->arg,
8118 bgp_node_afi(vty),
8119 bgp_node_safi(vty));
8120 }
8121
8122 ALIAS_HIDDEN(no_neighbor_unsuppress_map, no_neighbor_unsuppress_map_hidden_cmd,
8123 "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
8124 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8125 "Route-map to selectively unsuppress suppressed routes\n"
8126 "Name of route map\n")
8127
8128 static int peer_maximum_prefix_set_vty(struct vty *vty, const char *ip_str,
8129 afi_t afi, safi_t safi,
8130 const char *num_str,
8131 const char *threshold_str, int warning,
8132 const char *restart_str,
8133 const char *force_str)
8134 {
8135 int ret;
8136 struct peer *peer;
8137 uint32_t max;
8138 uint8_t threshold;
8139 uint16_t restart;
8140
8141 peer = peer_and_group_lookup_vty(vty, ip_str);
8142 if (!peer)
8143 return CMD_WARNING_CONFIG_FAILED;
8144
8145 max = strtoul(num_str, NULL, 10);
8146 if (threshold_str)
8147 threshold = atoi(threshold_str);
8148 else
8149 threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
8150
8151 if (restart_str)
8152 restart = atoi(restart_str);
8153 else
8154 restart = 0;
8155
8156 ret = peer_maximum_prefix_set(peer, afi, safi, max, threshold, warning,
8157 restart, force_str ? true : false);
8158
8159 return bgp_vty_return(vty, ret);
8160 }
8161
8162 static int peer_maximum_prefix_unset_vty(struct vty *vty, const char *ip_str,
8163 afi_t afi, safi_t safi)
8164 {
8165 int ret;
8166 struct peer *peer;
8167
8168 peer = peer_and_group_lookup_vty(vty, ip_str);
8169 if (!peer)
8170 return CMD_WARNING_CONFIG_FAILED;
8171
8172 ret = peer_maximum_prefix_unset(peer, afi, safi);
8173
8174 return bgp_vty_return(vty, ret);
8175 }
8176
8177 /* Maximum number of prefix to be sent to the neighbor. */
8178 DEFUN(neighbor_maximum_prefix_out,
8179 neighbor_maximum_prefix_out_cmd,
8180 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix-out (1-4294967295)",
8181 NEIGHBOR_STR
8182 NEIGHBOR_ADDR_STR2
8183 "Maximum number of prefixes to be sent to this peer\n"
8184 "Maximum no. of prefix limit\n")
8185 {
8186 int ret;
8187 int idx_peer = 1;
8188 int idx_number = 3;
8189 struct peer *peer;
8190 uint32_t max;
8191 afi_t afi = bgp_node_afi(vty);
8192 safi_t safi = bgp_node_safi(vty);
8193
8194 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8195 if (!peer)
8196 return CMD_WARNING_CONFIG_FAILED;
8197
8198 max = strtoul(argv[idx_number]->arg, NULL, 10);
8199
8200 ret = peer_maximum_prefix_out_set(peer, afi, safi, max);
8201
8202 return bgp_vty_return(vty, ret);
8203 }
8204
8205 DEFUN(no_neighbor_maximum_prefix_out,
8206 no_neighbor_maximum_prefix_out_cmd,
8207 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix-out [(1-4294967295)]",
8208 NO_STR
8209 NEIGHBOR_STR
8210 NEIGHBOR_ADDR_STR2
8211 "Maximum number of prefixes to be sent to this peer\n"
8212 "Maximum no. of prefix limit\n")
8213 {
8214 int ret;
8215 int idx_peer = 2;
8216 struct peer *peer;
8217 afi_t afi = bgp_node_afi(vty);
8218 safi_t safi = bgp_node_safi(vty);
8219
8220 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8221 if (!peer)
8222 return CMD_WARNING_CONFIG_FAILED;
8223
8224 ret = peer_maximum_prefix_out_unset(peer, afi, safi);
8225
8226 return bgp_vty_return(vty, ret);
8227 }
8228
8229 /* Maximum number of prefix configuration. Prefix count is different
8230 for each peer configuration. So this configuration can be set for
8231 each peer configuration. */
8232 DEFUN (neighbor_maximum_prefix,
8233 neighbor_maximum_prefix_cmd,
8234 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) [force]",
8235 NEIGHBOR_STR
8236 NEIGHBOR_ADDR_STR2
8237 "Maximum number of prefix accept from this peer\n"
8238 "maximum no. of prefix limit\n"
8239 "Force checking all received routes not only accepted\n")
8240 {
8241 int idx_peer = 1;
8242 int idx_number = 3;
8243 int idx_force = 0;
8244 char *force = NULL;
8245
8246 if (argv_find(argv, argc, "force", &idx_force))
8247 force = argv[idx_force]->arg;
8248
8249 return peer_maximum_prefix_set_vty(
8250 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8251 argv[idx_number]->arg, NULL, 0, NULL, force);
8252 }
8253
8254 ALIAS_HIDDEN(neighbor_maximum_prefix, neighbor_maximum_prefix_hidden_cmd,
8255 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) [force]",
8256 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8257 "Maximum number of prefix accept from this peer\n"
8258 "maximum no. of prefix limit\n"
8259 "Force checking all received routes not only accepted\n")
8260
8261 DEFUN (neighbor_maximum_prefix_threshold,
8262 neighbor_maximum_prefix_threshold_cmd,
8263 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) [force]",
8264 NEIGHBOR_STR
8265 NEIGHBOR_ADDR_STR2
8266 "Maximum number of prefix accept from this peer\n"
8267 "maximum no. of prefix limit\n"
8268 "Threshold value (%) at which to generate a warning msg\n"
8269 "Force checking all received routes not only accepted\n")
8270 {
8271 int idx_peer = 1;
8272 int idx_number = 3;
8273 int idx_number_2 = 4;
8274 int idx_force = 0;
8275 char *force = NULL;
8276
8277 if (argv_find(argv, argc, "force", &idx_force))
8278 force = argv[idx_force]->arg;
8279
8280 return peer_maximum_prefix_set_vty(
8281 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8282 argv[idx_number]->arg, argv[idx_number_2]->arg, 0, NULL, force);
8283 }
8284
8285 ALIAS_HIDDEN(
8286 neighbor_maximum_prefix_threshold,
8287 neighbor_maximum_prefix_threshold_hidden_cmd,
8288 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) [force]",
8289 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8290 "Maximum number of prefix accept from this peer\n"
8291 "maximum no. of prefix limit\n"
8292 "Threshold value (%) at which to generate a warning msg\n"
8293 "Force checking all received routes not only accepted\n")
8294
8295 DEFUN (neighbor_maximum_prefix_warning,
8296 neighbor_maximum_prefix_warning_cmd,
8297 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only [force]",
8298 NEIGHBOR_STR
8299 NEIGHBOR_ADDR_STR2
8300 "Maximum number of prefix accept from this peer\n"
8301 "maximum no. of prefix limit\n"
8302 "Only give warning message when limit is exceeded\n"
8303 "Force checking all received routes not only accepted\n")
8304 {
8305 int idx_peer = 1;
8306 int idx_number = 3;
8307 int idx_force = 0;
8308 char *force = NULL;
8309
8310 if (argv_find(argv, argc, "force", &idx_force))
8311 force = argv[idx_force]->arg;
8312
8313 return peer_maximum_prefix_set_vty(
8314 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8315 argv[idx_number]->arg, NULL, 1, NULL, force);
8316 }
8317
8318 ALIAS_HIDDEN(
8319 neighbor_maximum_prefix_warning,
8320 neighbor_maximum_prefix_warning_hidden_cmd,
8321 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only [force]",
8322 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8323 "Maximum number of prefix accept from this peer\n"
8324 "maximum no. of prefix limit\n"
8325 "Only give warning message when limit is exceeded\n"
8326 "Force checking all received routes not only accepted\n")
8327
8328 DEFUN (neighbor_maximum_prefix_threshold_warning,
8329 neighbor_maximum_prefix_threshold_warning_cmd,
8330 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only [force]",
8331 NEIGHBOR_STR
8332 NEIGHBOR_ADDR_STR2
8333 "Maximum number of prefix accept from this peer\n"
8334 "maximum no. of prefix limit\n"
8335 "Threshold value (%) at which to generate a warning msg\n"
8336 "Only give warning message when limit is exceeded\n"
8337 "Force checking all received routes not only accepted\n")
8338 {
8339 int idx_peer = 1;
8340 int idx_number = 3;
8341 int idx_number_2 = 4;
8342 int idx_force = 0;
8343 char *force = NULL;
8344
8345 if (argv_find(argv, argc, "force", &idx_force))
8346 force = argv[idx_force]->arg;
8347
8348 return peer_maximum_prefix_set_vty(
8349 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8350 argv[idx_number]->arg, argv[idx_number_2]->arg, 1, NULL, force);
8351 }
8352
8353 ALIAS_HIDDEN(
8354 neighbor_maximum_prefix_threshold_warning,
8355 neighbor_maximum_prefix_threshold_warning_hidden_cmd,
8356 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only [force]",
8357 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8358 "Maximum number of prefix accept from this peer\n"
8359 "maximum no. of prefix limit\n"
8360 "Threshold value (%) at which to generate a warning msg\n"
8361 "Only give warning message when limit is exceeded\n"
8362 "Force checking all received routes not only accepted\n")
8363
8364 DEFUN (neighbor_maximum_prefix_restart,
8365 neighbor_maximum_prefix_restart_cmd,
8366 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535) [force]",
8367 NEIGHBOR_STR
8368 NEIGHBOR_ADDR_STR2
8369 "Maximum number of prefix accept from this peer\n"
8370 "maximum no. of prefix limit\n"
8371 "Restart bgp connection after limit is exceeded\n"
8372 "Restart interval in minutes\n"
8373 "Force checking all received routes not only accepted\n")
8374 {
8375 int idx_peer = 1;
8376 int idx_number = 3;
8377 int idx_number_2 = 5;
8378 int idx_force = 0;
8379 char *force = NULL;
8380
8381 if (argv_find(argv, argc, "force", &idx_force))
8382 force = argv[idx_force]->arg;
8383
8384 return peer_maximum_prefix_set_vty(
8385 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8386 argv[idx_number]->arg, NULL, 0, argv[idx_number_2]->arg, force);
8387 }
8388
8389 ALIAS_HIDDEN(
8390 neighbor_maximum_prefix_restart,
8391 neighbor_maximum_prefix_restart_hidden_cmd,
8392 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535) [force]",
8393 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8394 "Maximum number of prefix accept from this peer\n"
8395 "maximum no. of prefix limit\n"
8396 "Restart bgp connection after limit is exceeded\n"
8397 "Restart interval in minutes\n"
8398 "Force checking all received routes not only accepted\n")
8399
8400 DEFUN (neighbor_maximum_prefix_threshold_restart,
8401 neighbor_maximum_prefix_threshold_restart_cmd,
8402 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535) [force]",
8403 NEIGHBOR_STR
8404 NEIGHBOR_ADDR_STR2
8405 "Maximum number of prefixes to accept from this peer\n"
8406 "maximum no. of prefix limit\n"
8407 "Threshold value (%) at which to generate a warning msg\n"
8408 "Restart bgp connection after limit is exceeded\n"
8409 "Restart interval in minutes\n"
8410 "Force checking all received routes not only accepted\n")
8411 {
8412 int idx_peer = 1;
8413 int idx_number = 3;
8414 int idx_number_2 = 4;
8415 int idx_number_3 = 6;
8416 int idx_force = 0;
8417 char *force = NULL;
8418
8419 if (argv_find(argv, argc, "force", &idx_force))
8420 force = argv[idx_force]->arg;
8421
8422 return peer_maximum_prefix_set_vty(
8423 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
8424 argv[idx_number]->arg, argv[idx_number_2]->arg, 0,
8425 argv[idx_number_3]->arg, force);
8426 }
8427
8428 ALIAS_HIDDEN(
8429 neighbor_maximum_prefix_threshold_restart,
8430 neighbor_maximum_prefix_threshold_restart_hidden_cmd,
8431 "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535) [force]",
8432 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8433 "Maximum number of prefixes to accept from this peer\n"
8434 "maximum no. of prefix limit\n"
8435 "Threshold value (%) at which to generate a warning msg\n"
8436 "Restart bgp connection after limit is exceeded\n"
8437 "Restart interval in minutes\n"
8438 "Force checking all received routes not only accepted\n")
8439
8440 DEFUN (no_neighbor_maximum_prefix,
8441 no_neighbor_maximum_prefix_cmd,
8442 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only] [force]]",
8443 NO_STR
8444 NEIGHBOR_STR
8445 NEIGHBOR_ADDR_STR2
8446 "Maximum number of prefixes to accept from this peer\n"
8447 "maximum no. of prefix limit\n"
8448 "Threshold value (%) at which to generate a warning msg\n"
8449 "Restart bgp connection after limit is exceeded\n"
8450 "Restart interval in minutes\n"
8451 "Only give warning message when limit is exceeded\n"
8452 "Force checking all received routes not only accepted\n")
8453 {
8454 int idx_peer = 2;
8455 return peer_maximum_prefix_unset_vty(vty, argv[idx_peer]->arg,
8456 bgp_node_afi(vty),
8457 bgp_node_safi(vty));
8458 }
8459
8460 ALIAS_HIDDEN(
8461 no_neighbor_maximum_prefix, no_neighbor_maximum_prefix_hidden_cmd,
8462 "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only] [force]]",
8463 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8464 "Maximum number of prefixes to accept from this peer\n"
8465 "maximum no. of prefix limit\n"
8466 "Threshold value (%) at which to generate a warning msg\n"
8467 "Restart bgp connection after limit is exceeded\n"
8468 "Restart interval in minutes\n"
8469 "Only give warning message when limit is exceeded\n"
8470 "Force checking all received routes not only accepted\n")
8471
8472 /* "neighbor accept-own" */
8473 DEFPY (neighbor_accept_own,
8474 neighbor_accept_own_cmd,
8475 "[no$no] neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor accept-own",
8476 NO_STR
8477 NEIGHBOR_STR
8478 NEIGHBOR_ADDR_STR2
8479 "Enable handling of self-originated VPN routes containing ACCEPT_OWN community\n")
8480 {
8481 struct peer *peer;
8482 afi_t afi = bgp_node_afi(vty);
8483 safi_t safi = bgp_node_safi(vty);
8484 int ret;
8485
8486 peer = peer_and_group_lookup_vty(vty, neighbor);
8487 if (!peer)
8488 return CMD_WARNING_CONFIG_FAILED;
8489
8490 if (no)
8491 ret = peer_af_flag_unset(peer, afi, safi, PEER_FLAG_ACCEPT_OWN);
8492 else
8493 ret = peer_af_flag_set(peer, afi, safi, PEER_FLAG_ACCEPT_OWN);
8494
8495 return bgp_vty_return(vty, ret);
8496 }
8497
8498 /* "neighbor soo" */
8499 DEFPY (neighbor_soo,
8500 neighbor_soo_cmd,
8501 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor soo ASN:NN_OR_IP-ADDRESS:NN$soo",
8502 NEIGHBOR_STR
8503 NEIGHBOR_ADDR_STR2
8504 "Set the Site-of-Origin (SoO) extended community\n"
8505 "VPN extended community\n")
8506 {
8507 struct peer *peer;
8508 afi_t afi = bgp_node_afi(vty);
8509 safi_t safi = bgp_node_safi(vty);
8510 struct ecommunity *ecomm_soo;
8511
8512 peer = peer_and_group_lookup_vty(vty, neighbor);
8513 if (!peer)
8514 return CMD_WARNING_CONFIG_FAILED;
8515
8516 ecomm_soo = ecommunity_str2com(soo, ECOMMUNITY_SITE_ORIGIN, 0);
8517 if (!ecomm_soo) {
8518 vty_out(vty, "%% Malformed SoO extended community\n");
8519 return CMD_WARNING;
8520 }
8521 ecommunity_str(ecomm_soo);
8522
8523 if (!ecommunity_match(peer->soo[afi][safi], ecomm_soo)) {
8524 ecommunity_free(&peer->soo[afi][safi]);
8525 peer->soo[afi][safi] = ecomm_soo;
8526 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_SOO);
8527 }
8528
8529 return bgp_vty_return(vty,
8530 peer_af_flag_set(peer, afi, safi, PEER_FLAG_SOO));
8531 }
8532
8533 DEFPY (no_neighbor_soo,
8534 no_neighbor_soo_cmd,
8535 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor soo [ASN:NN_OR_IP-ADDRESS:NN$soo]",
8536 NO_STR
8537 NEIGHBOR_STR
8538 NEIGHBOR_ADDR_STR2
8539 "Set the Site-of-Origin (SoO) extended community\n"
8540 "VPN extended community\n")
8541 {
8542 struct peer *peer;
8543 afi_t afi = bgp_node_afi(vty);
8544 safi_t safi = bgp_node_safi(vty);
8545
8546 peer = peer_and_group_lookup_vty(vty, neighbor);
8547 if (!peer)
8548 return CMD_WARNING_CONFIG_FAILED;
8549
8550 ecommunity_free(&peer->soo[afi][safi]);
8551
8552 return bgp_vty_return(
8553 vty, peer_af_flag_unset(peer, afi, safi, PEER_FLAG_SOO));
8554 }
8555
8556 /* "neighbor allowas-in" */
8557 DEFUN (neighbor_allowas_in,
8558 neighbor_allowas_in_cmd,
8559 "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8560 NEIGHBOR_STR
8561 NEIGHBOR_ADDR_STR2
8562 "Accept as-path with my AS present in it\n"
8563 "Number of occurrences of AS number\n"
8564 "Only accept my AS in the as-path if the route was originated in my AS\n")
8565 {
8566 int idx_peer = 1;
8567 int idx_number_origin = 3;
8568 int ret;
8569 int origin = 0;
8570 struct peer *peer;
8571 int allow_num = 0;
8572
8573 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8574 if (!peer)
8575 return CMD_WARNING_CONFIG_FAILED;
8576
8577 if (argc <= idx_number_origin)
8578 allow_num = 3;
8579 else {
8580 if (argv[idx_number_origin]->type == WORD_TKN)
8581 origin = 1;
8582 else
8583 allow_num = atoi(argv[idx_number_origin]->arg);
8584 }
8585
8586 ret = peer_allowas_in_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8587 allow_num, origin);
8588
8589 return bgp_vty_return(vty, ret);
8590 }
8591
8592 ALIAS_HIDDEN(
8593 neighbor_allowas_in, neighbor_allowas_in_hidden_cmd,
8594 "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8595 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8596 "Accept as-path with my AS present in it\n"
8597 "Number of occurrences of AS number\n"
8598 "Only accept my AS in the as-path if the route was originated in my AS\n")
8599
8600 DEFUN (no_neighbor_allowas_in,
8601 no_neighbor_allowas_in_cmd,
8602 "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8603 NO_STR
8604 NEIGHBOR_STR
8605 NEIGHBOR_ADDR_STR2
8606 "allow local ASN appears in aspath attribute\n"
8607 "Number of occurrences of AS number\n"
8608 "Only accept my AS in the as-path if the route was originated in my AS\n")
8609 {
8610 int idx_peer = 2;
8611 int ret;
8612 struct peer *peer;
8613
8614 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8615 if (!peer)
8616 return CMD_WARNING_CONFIG_FAILED;
8617
8618 ret = peer_allowas_in_unset(peer, bgp_node_afi(vty),
8619 bgp_node_safi(vty));
8620
8621 return bgp_vty_return(vty, ret);
8622 }
8623
8624 ALIAS_HIDDEN(
8625 no_neighbor_allowas_in, no_neighbor_allowas_in_hidden_cmd,
8626 "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
8627 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8628 "allow local ASN appears in aspath attribute\n"
8629 "Number of occurrences of AS number\n"
8630 "Only accept my AS in the as-path if the route was originated in my AS\n")
8631
8632 DEFUN (neighbor_ttl_security,
8633 neighbor_ttl_security_cmd,
8634 "neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
8635 NEIGHBOR_STR
8636 NEIGHBOR_ADDR_STR2
8637 "BGP ttl-security parameters\n"
8638 "Specify the maximum number of hops to the BGP peer\n"
8639 "Number of hops to BGP peer\n")
8640 {
8641 int idx_peer = 1;
8642 int idx_number = 4;
8643 struct peer *peer;
8644 int gtsm_hops;
8645
8646 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8647 if (!peer)
8648 return CMD_WARNING_CONFIG_FAILED;
8649
8650 gtsm_hops = strtoul(argv[idx_number]->arg, NULL, 10);
8651
8652 /*
8653 * If 'neighbor swpX', then this is for directly connected peers,
8654 * we should not accept a ttl-security hops value greater than 1.
8655 */
8656 if (peer->conf_if && (gtsm_hops > BGP_GTSM_HOPS_CONNECTED)) {
8657 vty_out(vty,
8658 "%s is directly connected peer, hops cannot exceed 1\n",
8659 argv[idx_peer]->arg);
8660 return CMD_WARNING_CONFIG_FAILED;
8661 }
8662
8663 return bgp_vty_return(vty, peer_ttl_security_hops_set(peer, gtsm_hops));
8664 }
8665
8666 DEFUN (no_neighbor_ttl_security,
8667 no_neighbor_ttl_security_cmd,
8668 "no neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
8669 NO_STR
8670 NEIGHBOR_STR
8671 NEIGHBOR_ADDR_STR2
8672 "BGP ttl-security parameters\n"
8673 "Specify the maximum number of hops to the BGP peer\n"
8674 "Number of hops to BGP peer\n")
8675 {
8676 int idx_peer = 2;
8677 struct peer *peer;
8678
8679 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8680 if (!peer)
8681 return CMD_WARNING_CONFIG_FAILED;
8682
8683 return bgp_vty_return(vty, peer_ttl_security_hops_unset(peer));
8684 }
8685
8686 /* disable-addpath-rx */
8687 DEFUN(neighbor_disable_addpath_rx,
8688 neighbor_disable_addpath_rx_cmd,
8689 "neighbor <A.B.C.D|X:X::X:X|WORD> disable-addpath-rx",
8690 NEIGHBOR_STR
8691 NEIGHBOR_ADDR_STR2
8692 "Do not accept additional paths\n")
8693 {
8694 char *peer_str = argv[1]->arg;
8695 struct peer *peer;
8696 afi_t afi = bgp_node_afi(vty);
8697 safi_t safi = bgp_node_safi(vty);
8698
8699 peer = peer_and_group_lookup_vty(vty, peer_str);
8700 if (!peer)
8701 return CMD_WARNING_CONFIG_FAILED;
8702
8703 return peer_af_flag_set_vty(vty, peer_str, afi, safi,
8704 PEER_FLAG_DISABLE_ADDPATH_RX);
8705 }
8706
8707 DEFUN(no_neighbor_disable_addpath_rx,
8708 no_neighbor_disable_addpath_rx_cmd,
8709 "no neighbor <A.B.C.D|X:X::X:X|WORD> disable-addpath-rx",
8710 NO_STR
8711 NEIGHBOR_STR
8712 NEIGHBOR_ADDR_STR2
8713 "Do not accept additional paths\n")
8714 {
8715 char *peer_str = argv[2]->arg;
8716 struct peer *peer;
8717 afi_t afi = bgp_node_afi(vty);
8718 safi_t safi = bgp_node_safi(vty);
8719
8720 peer = peer_and_group_lookup_vty(vty, peer_str);
8721 if (!peer)
8722 return CMD_WARNING_CONFIG_FAILED;
8723
8724 return peer_af_flag_unset_vty(vty, peer_str, afi, safi,
8725 PEER_FLAG_DISABLE_ADDPATH_RX);
8726 }
8727
8728 DEFUN (neighbor_addpath_tx_all_paths,
8729 neighbor_addpath_tx_all_paths_cmd,
8730 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8731 NEIGHBOR_STR
8732 NEIGHBOR_ADDR_STR2
8733 "Use addpath to advertise all paths to a neighbor\n")
8734 {
8735 int idx_peer = 1;
8736 struct peer *peer;
8737
8738 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8739 if (!peer)
8740 return CMD_WARNING_CONFIG_FAILED;
8741
8742 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8743 BGP_ADDPATH_ALL);
8744 return CMD_SUCCESS;
8745 }
8746
8747 ALIAS_HIDDEN(neighbor_addpath_tx_all_paths,
8748 neighbor_addpath_tx_all_paths_hidden_cmd,
8749 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8750 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8751 "Use addpath to advertise all paths to a neighbor\n")
8752
8753 DEFUN (no_neighbor_addpath_tx_all_paths,
8754 no_neighbor_addpath_tx_all_paths_cmd,
8755 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8756 NO_STR
8757 NEIGHBOR_STR
8758 NEIGHBOR_ADDR_STR2
8759 "Use addpath to advertise all paths to a neighbor\n")
8760 {
8761 int idx_peer = 2;
8762 struct peer *peer;
8763
8764 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8765 if (!peer)
8766 return CMD_WARNING_CONFIG_FAILED;
8767
8768 if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
8769 != BGP_ADDPATH_ALL) {
8770 vty_out(vty,
8771 "%% Peer not currently configured to transmit all paths.");
8772 return CMD_WARNING_CONFIG_FAILED;
8773 }
8774
8775 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8776 BGP_ADDPATH_NONE);
8777
8778 return CMD_SUCCESS;
8779 }
8780
8781 ALIAS_HIDDEN(no_neighbor_addpath_tx_all_paths,
8782 no_neighbor_addpath_tx_all_paths_hidden_cmd,
8783 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
8784 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8785 "Use addpath to advertise all paths to a neighbor\n")
8786
8787 DEFUN (neighbor_addpath_tx_bestpath_per_as,
8788 neighbor_addpath_tx_bestpath_per_as_cmd,
8789 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8790 NEIGHBOR_STR
8791 NEIGHBOR_ADDR_STR2
8792 "Use addpath to advertise the bestpath per each neighboring AS\n")
8793 {
8794 int idx_peer = 1;
8795 struct peer *peer;
8796
8797 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8798 if (!peer)
8799 return CMD_WARNING_CONFIG_FAILED;
8800
8801 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8802 BGP_ADDPATH_BEST_PER_AS);
8803
8804 return CMD_SUCCESS;
8805 }
8806
8807 ALIAS_HIDDEN(neighbor_addpath_tx_bestpath_per_as,
8808 neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
8809 "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8810 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8811 "Use addpath to advertise the bestpath per each neighboring AS\n")
8812
8813 DEFUN (no_neighbor_addpath_tx_bestpath_per_as,
8814 no_neighbor_addpath_tx_bestpath_per_as_cmd,
8815 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8816 NO_STR
8817 NEIGHBOR_STR
8818 NEIGHBOR_ADDR_STR2
8819 "Use addpath to advertise the bestpath per each neighboring AS\n")
8820 {
8821 int idx_peer = 2;
8822 struct peer *peer;
8823
8824 peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
8825 if (!peer)
8826 return CMD_WARNING_CONFIG_FAILED;
8827
8828 if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
8829 != BGP_ADDPATH_BEST_PER_AS) {
8830 vty_out(vty,
8831 "%% Peer not currently configured to transmit all best path per as.");
8832 return CMD_WARNING_CONFIG_FAILED;
8833 }
8834
8835 bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
8836 BGP_ADDPATH_NONE);
8837
8838 return CMD_SUCCESS;
8839 }
8840
8841 ALIAS_HIDDEN(no_neighbor_addpath_tx_bestpath_per_as,
8842 no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
8843 "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
8844 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
8845 "Use addpath to advertise the bestpath per each neighboring AS\n")
8846
8847 DEFPY(
8848 neighbor_aspath_loop_detection, neighbor_aspath_loop_detection_cmd,
8849 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor sender-as-path-loop-detection",
8850 NEIGHBOR_STR
8851 NEIGHBOR_ADDR_STR2
8852 "Detect AS loops before sending to neighbor\n")
8853 {
8854 struct peer *peer;
8855
8856 peer = peer_and_group_lookup_vty(vty, neighbor);
8857 if (!peer)
8858 return CMD_WARNING_CONFIG_FAILED;
8859
8860 peer->as_path_loop_detection = true;
8861
8862 return CMD_SUCCESS;
8863 }
8864
8865 DEFPY(
8866 no_neighbor_aspath_loop_detection,
8867 no_neighbor_aspath_loop_detection_cmd,
8868 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor sender-as-path-loop-detection",
8869 NO_STR
8870 NEIGHBOR_STR
8871 NEIGHBOR_ADDR_STR2
8872 "Detect AS loops before sending to neighbor\n")
8873 {
8874 struct peer *peer;
8875
8876 peer = peer_and_group_lookup_vty(vty, neighbor);
8877 if (!peer)
8878 return CMD_WARNING_CONFIG_FAILED;
8879
8880 peer->as_path_loop_detection = false;
8881
8882 return CMD_SUCCESS;
8883 }
8884
8885 DEFPY(neighbor_path_attribute_discard,
8886 neighbor_path_attribute_discard_cmd,
8887 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor path-attribute discard (1-255)...",
8888 NEIGHBOR_STR
8889 NEIGHBOR_ADDR_STR2
8890 "Manipulate path attributes from incoming UPDATE messages\n"
8891 "Drop specified attributes from incoming UPDATE messages\n"
8892 "Attribute number\n")
8893 {
8894 struct peer *peer;
8895 int idx = 0;
8896 char *discard_attrs = NULL;
8897
8898 peer = peer_and_group_lookup_vty(vty, neighbor);
8899 if (!peer)
8900 return CMD_WARNING_CONFIG_FAILED;
8901
8902 argv_find(argv, argc, "(1-255)", &idx);
8903 if (idx)
8904 discard_attrs = argv_concat(argv, argc, idx);
8905
8906 bgp_path_attribute_discard_vty(vty, peer, discard_attrs, true);
8907
8908 XFREE(MTYPE_TMP, discard_attrs);
8909
8910 return CMD_SUCCESS;
8911 }
8912
8913 DEFPY(no_neighbor_path_attribute_discard,
8914 no_neighbor_path_attribute_discard_cmd,
8915 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor path-attribute discard [(1-255)]",
8916 NO_STR
8917 NEIGHBOR_STR
8918 NEIGHBOR_ADDR_STR2
8919 "Manipulate path attributes from incoming UPDATE messages\n"
8920 "Drop specified attributes from incoming UPDATE messages\n"
8921 "Attribute number\n")
8922 {
8923 struct peer *peer;
8924 int idx = 0;
8925 char *discard_attrs = NULL;
8926
8927 peer = peer_and_group_lookup_vty(vty, neighbor);
8928 if (!peer)
8929 return CMD_WARNING_CONFIG_FAILED;
8930
8931 argv_find(argv, argc, "(1-255)", &idx);
8932 if (idx)
8933 discard_attrs = argv[idx]->arg;
8934
8935 bgp_path_attribute_discard_vty(vty, peer, discard_attrs, false);
8936
8937 XFREE(MTYPE_TMP, discard_attrs);
8938
8939 return CMD_SUCCESS;
8940 }
8941
8942 DEFPY(neighbor_path_attribute_treat_as_withdraw,
8943 neighbor_path_attribute_treat_as_withdraw_cmd,
8944 "neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor path-attribute treat-as-withdraw (1-255)...",
8945 NEIGHBOR_STR
8946 NEIGHBOR_ADDR_STR2
8947 "Manipulate path attributes from incoming UPDATE messages\n"
8948 "Treat-as-withdraw any incoming BGP UPDATE messages that contain the specified attribute\n"
8949 "Attribute number\n")
8950 {
8951 struct peer *peer;
8952 int idx = 0;
8953 char *withdraw_attrs = NULL;
8954
8955 peer = peer_and_group_lookup_vty(vty, neighbor);
8956 if (!peer)
8957 return CMD_WARNING_CONFIG_FAILED;
8958
8959 argv_find(argv, argc, "(1-255)", &idx);
8960 if (idx)
8961 withdraw_attrs = argv_concat(argv, argc, idx);
8962
8963 bgp_path_attribute_withdraw_vty(vty, peer, withdraw_attrs, true);
8964
8965 XFREE(MTYPE_TMP, withdraw_attrs);
8966
8967 return CMD_SUCCESS;
8968 }
8969
8970 DEFPY(no_neighbor_path_attribute_treat_as_withdraw,
8971 no_neighbor_path_attribute_treat_as_withdraw_cmd,
8972 "no neighbor <A.B.C.D|X:X::X:X|WORD>$neighbor path-attribute treat-as-withdraw (1-255)...",
8973 NO_STR
8974 NEIGHBOR_STR
8975 NEIGHBOR_ADDR_STR2
8976 "Manipulate path attributes from incoming UPDATE messages\n"
8977 "Treat-as-withdraw any incoming BGP UPDATE messages that contain the specified attribute\n"
8978 "Attribute number\n")
8979 {
8980 struct peer *peer;
8981 int idx = 0;
8982 char *withdraw_attrs = NULL;
8983
8984 peer = peer_and_group_lookup_vty(vty, neighbor);
8985 if (!peer)
8986 return CMD_WARNING_CONFIG_FAILED;
8987
8988 argv_find(argv, argc, "(1-255)", &idx);
8989 if (idx)
8990 withdraw_attrs = argv_concat(argv, argc, idx);
8991
8992 bgp_path_attribute_withdraw_vty(vty, peer, withdraw_attrs, false);
8993
8994 XFREE(MTYPE_TMP, withdraw_attrs);
8995
8996 return CMD_SUCCESS;
8997 }
8998
8999 static int set_ecom_list(struct vty *vty, int argc, struct cmd_token **argv,
9000 struct ecommunity **list, bool is_rt6)
9001 {
9002 struct ecommunity *ecom = NULL;
9003 struct ecommunity *ecomadd;
9004
9005 for (; argc; --argc, ++argv) {
9006 if (is_rt6)
9007 ecomadd = ecommunity_str2com_ipv6(argv[0]->arg,
9008 ECOMMUNITY_ROUTE_TARGET,
9009 0);
9010 else
9011 ecomadd = ecommunity_str2com(argv[0]->arg,
9012 ECOMMUNITY_ROUTE_TARGET,
9013 0);
9014 if (!ecomadd) {
9015 vty_out(vty, "Malformed community-list value\n");
9016 if (ecom)
9017 ecommunity_free(&ecom);
9018 return CMD_WARNING_CONFIG_FAILED;
9019 }
9020
9021 if (ecom) {
9022 ecommunity_merge(ecom, ecomadd);
9023 ecommunity_free(&ecomadd);
9024 } else {
9025 ecom = ecomadd;
9026 }
9027 }
9028
9029 if (*list) {
9030 ecommunity_free(&*list);
9031 }
9032 *list = ecom;
9033
9034 return CMD_SUCCESS;
9035 }
9036
9037 /*
9038 * v2vimport is true if we are handling a `import vrf ...` command
9039 */
9040 static afi_t vpn_policy_getafi(struct vty *vty, struct bgp *bgp, bool v2vimport)
9041 {
9042 afi_t afi;
9043
9044 switch (vty->node) {
9045 case BGP_IPV4_NODE:
9046 afi = AFI_IP;
9047 break;
9048 case BGP_IPV6_NODE:
9049 afi = AFI_IP6;
9050 break;
9051 default:
9052 vty_out(vty,
9053 "%% context error: valid only in address-family <ipv4|ipv6> unicast block\n");
9054 return AFI_MAX;
9055 }
9056
9057 if (!v2vimport) {
9058 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9059 BGP_CONFIG_VRF_TO_VRF_IMPORT)
9060 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9061 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
9062 vty_out(vty,
9063 "%% error: Please unconfigure import vrf commands before using vpn commands\n");
9064 return AFI_MAX;
9065 }
9066 } else {
9067 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9068 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)
9069 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9070 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
9071 vty_out(vty,
9072 "%% error: Please unconfigure vpn to vrf commands before using import vrf commands\n");
9073 return AFI_MAX;
9074 }
9075 }
9076 return afi;
9077 }
9078
9079 DEFPY (af_rd_vpn_export,
9080 af_rd_vpn_export_cmd,
9081 "[no] rd vpn export ASN:NN_OR_IP-ADDRESS:NN$rd_str",
9082 NO_STR
9083 "Specify route distinguisher\n"
9084 "Between current address-family and vpn\n"
9085 "For routes leaked from current address-family to vpn\n"
9086 "Route Distinguisher (<as-number>:<number> | <ip-address>:<number>)\n")
9087 {
9088 VTY_DECLVAR_CONTEXT(bgp, bgp);
9089 struct prefix_rd prd;
9090 int ret;
9091 afi_t afi;
9092 int idx = 0;
9093 bool yes = true;
9094
9095 if (argv_find(argv, argc, "no", &idx))
9096 yes = false;
9097
9098 if (yes) {
9099 ret = str2prefix_rd(rd_str, &prd);
9100 if (!ret) {
9101 vty_out(vty, "%% Malformed rd\n");
9102 return CMD_WARNING_CONFIG_FAILED;
9103 }
9104 }
9105
9106 afi = vpn_policy_getafi(vty, bgp, false);
9107 if (afi == AFI_MAX)
9108 return CMD_WARNING_CONFIG_FAILED;
9109
9110 /*
9111 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
9112 */
9113 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9114 bgp_get_default(), bgp);
9115
9116 if (yes) {
9117 bgp->vpn_policy[afi].tovpn_rd_pretty =
9118 XSTRDUP(MTYPE_BGP, rd_str);
9119 bgp->vpn_policy[afi].tovpn_rd = prd;
9120 SET_FLAG(bgp->vpn_policy[afi].flags,
9121 BGP_VPN_POLICY_TOVPN_RD_SET);
9122 } else {
9123 XFREE(MTYPE_BGP, bgp->vpn_policy[afi].tovpn_rd_pretty);
9124 UNSET_FLAG(bgp->vpn_policy[afi].flags,
9125 BGP_VPN_POLICY_TOVPN_RD_SET);
9126 }
9127
9128 /* post-change: re-export vpn routes */
9129 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9130 bgp_get_default(), bgp);
9131
9132 return CMD_SUCCESS;
9133 }
9134
9135 ALIAS (af_rd_vpn_export,
9136 af_no_rd_vpn_export_cmd,
9137 "no rd vpn export",
9138 NO_STR
9139 "Specify route distinguisher\n"
9140 "Between current address-family and vpn\n"
9141 "For routes leaked from current address-family to vpn\n")
9142
9143 DEFPY (af_label_vpn_export,
9144 af_label_vpn_export_cmd,
9145 "[no] label vpn export <(0-1048575)$label_val|auto$label_auto>",
9146 NO_STR
9147 "label value for VRF\n"
9148 "Between current address-family and vpn\n"
9149 "For routes leaked from current address-family to vpn\n"
9150 "Label Value <0-1048575>\n"
9151 "Automatically assign a label\n")
9152 {
9153 VTY_DECLVAR_CONTEXT(bgp, bgp);
9154 mpls_label_t label = MPLS_LABEL_NONE;
9155 afi_t afi;
9156 int idx = 0;
9157 bool yes = true;
9158
9159 if (argv_find(argv, argc, "no", &idx))
9160 yes = false;
9161
9162 /* If "no ...", squash trailing parameter */
9163 if (!yes)
9164 label_auto = NULL;
9165
9166 if (yes) {
9167 if (!label_auto)
9168 label = label_val; /* parser should force unsigned */
9169 }
9170
9171 afi = vpn_policy_getafi(vty, bgp, false);
9172 if (afi == AFI_MAX)
9173 return CMD_WARNING_CONFIG_FAILED;
9174
9175
9176 if (label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9177 BGP_VPN_POLICY_TOVPN_LABEL_AUTO))
9178 /* no change */
9179 return CMD_SUCCESS;
9180
9181 /*
9182 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
9183 */
9184 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9185 bgp_get_default(), bgp);
9186
9187 if (!label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9188 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
9189
9190 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
9191
9192 /*
9193 * label has previously been automatically
9194 * assigned by labelpool: release it
9195 *
9196 * NB if tovpn_label == MPLS_LABEL_NONE it
9197 * means the automatic assignment is in flight
9198 * and therefore the labelpool callback must
9199 * detect that the auto label is not needed.
9200 */
9201
9202 bgp_lp_release(LP_TYPE_VRF,
9203 &bgp->vpn_policy[afi],
9204 bgp->vpn_policy[afi].tovpn_label);
9205 }
9206 UNSET_FLAG(bgp->vpn_policy[afi].flags,
9207 BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
9208 }
9209
9210 bgp->vpn_policy[afi].tovpn_label = label;
9211 if (label_auto) {
9212 SET_FLAG(bgp->vpn_policy[afi].flags,
9213 BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
9214 bgp_lp_get(LP_TYPE_VRF, &bgp->vpn_policy[afi],
9215 vpn_leak_label_callback);
9216 }
9217
9218 /* post-change: re-export vpn routes */
9219 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9220 bgp_get_default(), bgp);
9221
9222 hook_call(bgp_snmp_update_last_changed, bgp);
9223 return CMD_SUCCESS;
9224 }
9225
9226 DEFPY (af_sid_vpn_export,
9227 af_sid_vpn_export_cmd,
9228 "[no] sid vpn export <(1-1048575)$sid_idx|auto$sid_auto>",
9229 NO_STR
9230 "sid value for VRF\n"
9231 "Between current address-family and vpn\n"
9232 "For routes leaked from current address-family to vpn\n"
9233 "Sid allocation index\n"
9234 "Automatically assign a label\n")
9235 {
9236 VTY_DECLVAR_CONTEXT(bgp, bgp);
9237 afi_t afi;
9238 int debug = 0;
9239 int idx = 0;
9240 bool yes = true;
9241
9242 if (argv_find(argv, argc, "no", &idx))
9243 yes = false;
9244 debug = (BGP_DEBUG(vpn, VPN_LEAK_TO_VRF) |
9245 BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF));
9246
9247 afi = vpn_policy_getafi(vty, bgp, false);
9248 if (afi == AFI_MAX)
9249 return CMD_WARNING_CONFIG_FAILED;
9250
9251 if (!yes) {
9252 /* implement me */
9253 vty_out(vty, "It's not implemented\n");
9254 return CMD_WARNING_CONFIG_FAILED;
9255 }
9256
9257 if (bgp->tovpn_sid_index != 0 ||
9258 CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)) {
9259 vty_out(vty,
9260 "per-vrf sid and per-af sid are mutually exclusive\n"
9261 "Failed: per-vrf sid is configured. Remove per-vrf sid before configuring per-af sid\n");
9262 return CMD_WARNING_CONFIG_FAILED;
9263 }
9264
9265 /* skip when it's already configured */
9266 if ((sid_idx != 0 && bgp->vpn_policy[afi].tovpn_sid_index != 0)
9267 || (sid_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9268 BGP_VPN_POLICY_TOVPN_SID_AUTO)))
9269 return CMD_SUCCESS;
9270
9271 /*
9272 * mode change between sid_idx and sid_auto isn't supported.
9273 * user must negate sid vpn export when they want to change the mode
9274 */
9275 if ((sid_auto && bgp->vpn_policy[afi].tovpn_sid_index != 0)
9276 || (sid_idx != 0 && CHECK_FLAG(bgp->vpn_policy[afi].flags,
9277 BGP_VPN_POLICY_TOVPN_SID_AUTO))) {
9278 vty_out(vty, "it's already configured as %s.\n",
9279 sid_auto ? "auto-mode" : "idx-mode");
9280 return CMD_WARNING_CONFIG_FAILED;
9281 }
9282
9283 /* pre-change */
9284 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9285 bgp_get_default(), bgp);
9286
9287 if (sid_auto) {
9288 /* SID allocation auto-mode */
9289 if (debug)
9290 zlog_debug("%s: auto sid alloc.", __func__);
9291 SET_FLAG(bgp->vpn_policy[afi].flags,
9292 BGP_VPN_POLICY_TOVPN_SID_AUTO);
9293 } else {
9294 /* SID allocation index-mode */
9295 if (debug)
9296 zlog_debug("%s: idx %ld sid alloc.", __func__, sid_idx);
9297 bgp->vpn_policy[afi].tovpn_sid_index = sid_idx;
9298 }
9299
9300 /* post-change */
9301 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9302 bgp_get_default(), bgp);
9303 return CMD_SUCCESS;
9304 }
9305
9306 DEFPY (bgp_sid_vpn_export,
9307 bgp_sid_vpn_export_cmd,
9308 "[no] sid vpn per-vrf export <(1-1048575)$sid_idx|auto$sid_auto>",
9309 NO_STR
9310 "sid value for VRF\n"
9311 "Between current vrf and vpn\n"
9312 "sid per-VRF (both IPv4 and IPv6 address families)\n"
9313 "For routes leaked from current vrf to vpn\n"
9314 "Sid allocation index\n"
9315 "Automatically assign a label\n")
9316 {
9317 VTY_DECLVAR_CONTEXT(bgp, bgp);
9318 int debug;
9319
9320 debug = (BGP_DEBUG(vpn, VPN_LEAK_TO_VRF) |
9321 BGP_DEBUG(vpn, VPN_LEAK_FROM_VRF));
9322
9323 if (no) {
9324 /* when per-VRF SID is not set, do nothing */
9325 if (bgp->tovpn_sid_index == 0 &&
9326 !CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO))
9327 return CMD_SUCCESS;
9328
9329 sid_idx = 0;
9330 sid_auto = false;
9331 bgp->tovpn_sid_index = 0;
9332 UNSET_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO);
9333 }
9334
9335 if (bgp->vpn_policy[AFI_IP].tovpn_sid_index != 0 ||
9336 CHECK_FLAG(bgp->vpn_policy[AFI_IP].flags,
9337 BGP_VPN_POLICY_TOVPN_SID_AUTO) ||
9338 bgp->vpn_policy[AFI_IP6].tovpn_sid_index != 0 ||
9339 CHECK_FLAG(bgp->vpn_policy[AFI_IP6].flags,
9340 BGP_VPN_POLICY_TOVPN_SID_AUTO)) {
9341 vty_out(vty,
9342 "per-vrf sid and per-af sid are mutually exclusive\n"
9343 "Failed: per-af sid is configured. Remove per-af sid before configuring per-vrf sid\n");
9344 return CMD_WARNING_CONFIG_FAILED;
9345 }
9346
9347 /* skip when it's already configured */
9348 if ((sid_idx != 0 && bgp->tovpn_sid_index != 0) ||
9349 (sid_auto && CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)))
9350 return CMD_SUCCESS;
9351
9352 /*
9353 * mode change between sid_idx and sid_auto isn't supported.
9354 * user must negate sid vpn export when they want to change the mode
9355 */
9356 if ((sid_auto && bgp->tovpn_sid_index != 0) ||
9357 (sid_idx != 0 &&
9358 CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO))) {
9359 vty_out(vty, "it's already configured as %s.\n",
9360 sid_auto ? "auto-mode" : "idx-mode");
9361 return CMD_WARNING_CONFIG_FAILED;
9362 }
9363
9364 /* pre-change */
9365 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP, bgp_get_default(),
9366 bgp);
9367 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6, bgp_get_default(),
9368 bgp);
9369
9370 if (sid_auto) {
9371 /* SID allocation auto-mode */
9372 if (debug)
9373 zlog_debug("%s: auto per-vrf sid alloc.", __func__);
9374 SET_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO);
9375 } else if (sid_idx != 0) {
9376 /* SID allocation index-mode */
9377 if (debug)
9378 zlog_debug("%s: idx %ld per-vrf sid alloc.", __func__,
9379 sid_idx);
9380 bgp->tovpn_sid_index = sid_idx;
9381 }
9382
9383 /* post-change */
9384 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP, bgp_get_default(),
9385 bgp);
9386 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
9387 bgp_get_default(), bgp);
9388
9389 return CMD_SUCCESS;
9390 }
9391
9392 ALIAS (af_label_vpn_export,
9393 af_no_label_vpn_export_cmd,
9394 "no label vpn export",
9395 NO_STR
9396 "label value for VRF\n"
9397 "Between current address-family and vpn\n"
9398 "For routes leaked from current address-family to vpn\n")
9399
9400 ALIAS (bgp_sid_vpn_export,
9401 no_bgp_sid_vpn_export_cmd,
9402 "no$no sid vpn per-vrf export",
9403 NO_STR
9404 "sid value for VRF\n"
9405 "Between current vrf and vpn\n"
9406 "sid per-VRF (both IPv4 and IPv6 address families)\n"
9407 "For routes leaked from current vrf to vpn\n")
9408
9409 DEFPY (af_nexthop_vpn_export,
9410 af_nexthop_vpn_export_cmd,
9411 "[no] nexthop vpn export [<A.B.C.D|X:X::X:X>$nexthop_su]",
9412 NO_STR
9413 "Specify next hop to use for VRF advertised prefixes\n"
9414 "Between current address-family and vpn\n"
9415 "For routes leaked from current address-family to vpn\n"
9416 "IPv4 prefix\n"
9417 "IPv6 prefix\n")
9418 {
9419 VTY_DECLVAR_CONTEXT(bgp, bgp);
9420 afi_t afi;
9421 struct prefix p;
9422
9423 if (!no) {
9424 if (!nexthop_su) {
9425 vty_out(vty, "%% Nexthop required\n");
9426 return CMD_WARNING_CONFIG_FAILED;
9427 }
9428 if (!sockunion2hostprefix(nexthop_su, &p))
9429 return CMD_WARNING_CONFIG_FAILED;
9430 }
9431
9432 afi = vpn_policy_getafi(vty, bgp, false);
9433 if (afi == AFI_MAX)
9434 return CMD_WARNING_CONFIG_FAILED;
9435
9436 /*
9437 * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
9438 */
9439 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9440 bgp_get_default(), bgp);
9441
9442 if (!no) {
9443 bgp->vpn_policy[afi].tovpn_nexthop = p;
9444 SET_FLAG(bgp->vpn_policy[afi].flags,
9445 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
9446 } else {
9447 UNSET_FLAG(bgp->vpn_policy[afi].flags,
9448 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
9449 }
9450
9451 /* post-change: re-export vpn routes */
9452 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
9453 bgp_get_default(), bgp);
9454
9455 return CMD_SUCCESS;
9456 }
9457
9458 static int vpn_policy_getdirs(struct vty *vty, const char *dstr, int *dodir)
9459 {
9460 if (!strcmp(dstr, "import")) {
9461 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
9462 } else if (!strcmp(dstr, "export")) {
9463 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
9464 } else if (!strcmp(dstr, "both")) {
9465 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
9466 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
9467 } else {
9468 vty_out(vty, "%% direction parse error\n");
9469 return CMD_WARNING_CONFIG_FAILED;
9470 }
9471 return CMD_SUCCESS;
9472 }
9473
9474 DEFPY (af_rt_vpn_imexport,
9475 af_rt_vpn_imexport_cmd,
9476 "[no] <rt|route-target> vpn <import|export|both>$direction_str RTLIST...",
9477 NO_STR
9478 "Specify route target list\n"
9479 "Specify route target list\n"
9480 "Between current address-family and vpn\n"
9481 "For routes leaked from vpn to current address-family: match any\n"
9482 "For routes leaked from current address-family to vpn: set\n"
9483 "both import: match any and export: set\n"
9484 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
9485 {
9486 VTY_DECLVAR_CONTEXT(bgp, bgp);
9487 int ret;
9488 struct ecommunity *ecom = NULL;
9489 int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
9490 enum vpn_policy_direction dir;
9491 afi_t afi;
9492 int idx = 0;
9493 bool yes = true;
9494
9495 if (argv_find(argv, argc, "no", &idx))
9496 yes = false;
9497
9498 afi = vpn_policy_getafi(vty, bgp, false);
9499 if (afi == AFI_MAX)
9500 return CMD_WARNING_CONFIG_FAILED;
9501
9502 ret = vpn_policy_getdirs(vty, direction_str, dodir);
9503 if (ret != CMD_SUCCESS)
9504 return ret;
9505
9506 if (yes) {
9507 if (!argv_find(argv, argc, "RTLIST", &idx)) {
9508 vty_out(vty, "%% Missing RTLIST\n");
9509 return CMD_WARNING_CONFIG_FAILED;
9510 }
9511 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom, false);
9512 if (ret != CMD_SUCCESS) {
9513 return ret;
9514 }
9515 }
9516
9517 for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
9518 if (!dodir[dir])
9519 continue;
9520
9521 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9522
9523 if (yes) {
9524 if (bgp->vpn_policy[afi].rtlist[dir])
9525 ecommunity_free(
9526 &bgp->vpn_policy[afi].rtlist[dir]);
9527 bgp->vpn_policy[afi].rtlist[dir] =
9528 ecommunity_dup(ecom);
9529 } else {
9530 if (bgp->vpn_policy[afi].rtlist[dir])
9531 ecommunity_free(
9532 &bgp->vpn_policy[afi].rtlist[dir]);
9533 bgp->vpn_policy[afi].rtlist[dir] = NULL;
9534 }
9535
9536 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9537 }
9538
9539 if (ecom)
9540 ecommunity_free(&ecom);
9541
9542 return CMD_SUCCESS;
9543 }
9544
9545 ALIAS (af_rt_vpn_imexport,
9546 af_no_rt_vpn_imexport_cmd,
9547 "no <rt|route-target> vpn <import|export|both>$direction_str",
9548 NO_STR
9549 "Specify route target list\n"
9550 "Specify route target list\n"
9551 "Between current address-family and vpn\n"
9552 "For routes leaked from vpn to current address-family\n"
9553 "For routes leaked from current address-family to vpn\n"
9554 "both import and export\n")
9555
9556 DEFPY (af_route_map_vpn_imexport,
9557 af_route_map_vpn_imexport_cmd,
9558 /* future: "route-map <vpn|evpn|vrf NAME> <import|export> RMAP" */
9559 "[no] route-map vpn <import|export>$direction_str RMAP$rmap_str",
9560 NO_STR
9561 "Specify route map\n"
9562 "Between current address-family and vpn\n"
9563 "For routes leaked from vpn to current address-family\n"
9564 "For routes leaked from current address-family to vpn\n"
9565 "name of route-map\n")
9566 {
9567 VTY_DECLVAR_CONTEXT(bgp, bgp);
9568 int ret;
9569 int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
9570 enum vpn_policy_direction dir;
9571 afi_t afi;
9572 int idx = 0;
9573 bool yes = true;
9574
9575 if (argv_find(argv, argc, "no", &idx))
9576 yes = false;
9577
9578 afi = vpn_policy_getafi(vty, bgp, false);
9579 if (afi == AFI_MAX)
9580 return CMD_WARNING_CONFIG_FAILED;
9581
9582 ret = vpn_policy_getdirs(vty, direction_str, dodir);
9583 if (ret != CMD_SUCCESS)
9584 return ret;
9585
9586 for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
9587 if (!dodir[dir])
9588 continue;
9589
9590 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9591
9592 if (yes) {
9593 if (bgp->vpn_policy[afi].rmap_name[dir])
9594 XFREE(MTYPE_ROUTE_MAP_NAME,
9595 bgp->vpn_policy[afi].rmap_name[dir]);
9596 bgp->vpn_policy[afi].rmap_name[dir] = XSTRDUP(
9597 MTYPE_ROUTE_MAP_NAME, rmap_str);
9598 bgp->vpn_policy[afi].rmap[dir] =
9599 route_map_lookup_warn_noexist(vty, rmap_str);
9600 if (!bgp->vpn_policy[afi].rmap[dir])
9601 return CMD_SUCCESS;
9602 } else {
9603 if (bgp->vpn_policy[afi].rmap_name[dir])
9604 XFREE(MTYPE_ROUTE_MAP_NAME,
9605 bgp->vpn_policy[afi].rmap_name[dir]);
9606 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
9607 bgp->vpn_policy[afi].rmap[dir] = NULL;
9608 }
9609
9610 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9611 }
9612
9613 return CMD_SUCCESS;
9614 }
9615
9616 ALIAS (af_route_map_vpn_imexport,
9617 af_no_route_map_vpn_imexport_cmd,
9618 "no route-map vpn <import|export>$direction_str",
9619 NO_STR
9620 "Specify route map\n"
9621 "Between current address-family and vpn\n"
9622 "For routes leaked from vpn to current address-family\n"
9623 "For routes leaked from current address-family to vpn\n")
9624
9625 DEFPY(af_import_vrf_route_map, af_import_vrf_route_map_cmd,
9626 "import vrf route-map RMAP$rmap_str",
9627 "Import routes from another VRF\n"
9628 "Vrf routes being filtered\n"
9629 "Specify route map\n"
9630 "name of route-map\n")
9631 {
9632 VTY_DECLVAR_CONTEXT(bgp, bgp);
9633 enum vpn_policy_direction dir = BGP_VPN_POLICY_DIR_FROMVPN;
9634 afi_t afi;
9635 struct bgp *bgp_default;
9636
9637 afi = vpn_policy_getafi(vty, bgp, true);
9638 if (afi == AFI_MAX)
9639 return CMD_WARNING_CONFIG_FAILED;
9640
9641 bgp_default = bgp_get_default();
9642 if (!bgp_default) {
9643 int32_t ret;
9644 as_t as = bgp->as;
9645
9646 /* Auto-create assuming the same AS */
9647 ret = bgp_get_vty(&bgp_default, &as, NULL,
9648 BGP_INSTANCE_TYPE_DEFAULT, NULL,
9649 ASNOTATION_UNDEFINED);
9650
9651 if (ret) {
9652 vty_out(vty,
9653 "VRF default is not configured as a bgp instance\n");
9654 return CMD_WARNING;
9655 }
9656 }
9657
9658 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9659
9660 if (bgp->vpn_policy[afi].rmap_name[dir])
9661 XFREE(MTYPE_ROUTE_MAP_NAME,
9662 bgp->vpn_policy[afi].rmap_name[dir]);
9663 bgp->vpn_policy[afi].rmap_name[dir] =
9664 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_str);
9665 bgp->vpn_policy[afi].rmap[dir] =
9666 route_map_lookup_warn_noexist(vty, rmap_str);
9667 if (!bgp->vpn_policy[afi].rmap[dir])
9668 return CMD_SUCCESS;
9669
9670 SET_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9671 BGP_CONFIG_VRF_TO_VRF_IMPORT);
9672
9673 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9674
9675 return CMD_SUCCESS;
9676 }
9677
9678 DEFPY(af_no_import_vrf_route_map, af_no_import_vrf_route_map_cmd,
9679 "no import vrf route-map [RMAP$rmap_str]",
9680 NO_STR
9681 "Import routes from another VRF\n"
9682 "Vrf routes being filtered\n"
9683 "Specify route map\n"
9684 "name of route-map\n")
9685 {
9686 VTY_DECLVAR_CONTEXT(bgp, bgp);
9687 enum vpn_policy_direction dir = BGP_VPN_POLICY_DIR_FROMVPN;
9688 afi_t afi;
9689
9690 afi = vpn_policy_getafi(vty, bgp, true);
9691 if (afi == AFI_MAX)
9692 return CMD_WARNING_CONFIG_FAILED;
9693
9694 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9695
9696 if (bgp->vpn_policy[afi].rmap_name[dir])
9697 XFREE(MTYPE_ROUTE_MAP_NAME,
9698 bgp->vpn_policy[afi].rmap_name[dir]);
9699 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
9700 bgp->vpn_policy[afi].rmap[dir] = NULL;
9701
9702 if (bgp->vpn_policy[afi].import_vrf->count == 0)
9703 UNSET_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
9704 BGP_CONFIG_VRF_TO_VRF_IMPORT);
9705
9706 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9707
9708 return CMD_SUCCESS;
9709 }
9710
9711 DEFPY(bgp_imexport_vrf, bgp_imexport_vrf_cmd,
9712 "[no] import vrf VIEWVRFNAME$import_name",
9713 NO_STR
9714 "Import routes from another VRF\n"
9715 "VRF to import from\n"
9716 "The name of the VRF\n")
9717 {
9718 VTY_DECLVAR_CONTEXT(bgp, bgp);
9719 struct listnode *node;
9720 struct bgp *vrf_bgp, *bgp_default;
9721 int32_t ret = 0;
9722 as_t as = bgp->as;
9723 bool remove = false;
9724 int32_t idx = 0;
9725 char *vname;
9726 enum bgp_instance_type bgp_type = BGP_INSTANCE_TYPE_VRF;
9727 safi_t safi;
9728 afi_t afi;
9729
9730 if (import_name == NULL) {
9731 vty_out(vty, "%% Missing import name\n");
9732 return CMD_WARNING;
9733 }
9734
9735 if (strcmp(import_name, "route-map") == 0) {
9736 vty_out(vty, "%% Must include route-map name\n");
9737 return CMD_WARNING;
9738 }
9739
9740 if (argv_find(argv, argc, "no", &idx))
9741 remove = true;
9742
9743 afi = vpn_policy_getafi(vty, bgp, true);
9744 if (afi == AFI_MAX)
9745 return CMD_WARNING_CONFIG_FAILED;
9746
9747 safi = bgp_node_safi(vty);
9748
9749 if (((BGP_INSTANCE_TYPE_DEFAULT == bgp->inst_type)
9750 && (strcmp(import_name, VRF_DEFAULT_NAME) == 0))
9751 || (bgp->name && (strcmp(import_name, bgp->name) == 0))) {
9752 vty_out(vty, "%% Cannot %s vrf %s into itself\n",
9753 remove ? "unimport" : "import", import_name);
9754 return CMD_WARNING;
9755 }
9756
9757 bgp_default = bgp_get_default();
9758 if (!bgp_default) {
9759 /* Auto-create assuming the same AS */
9760 ret = bgp_get_vty(&bgp_default, &as, NULL,
9761 BGP_INSTANCE_TYPE_DEFAULT, NULL,
9762 ASNOTATION_UNDEFINED);
9763
9764 if (ret) {
9765 vty_out(vty,
9766 "VRF default is not configured as a bgp instance\n");
9767 return CMD_WARNING;
9768 }
9769 }
9770
9771 vrf_bgp = bgp_lookup_by_name(import_name);
9772 if (!vrf_bgp) {
9773 if (strcmp(import_name, VRF_DEFAULT_NAME) == 0)
9774 vrf_bgp = bgp_default;
9775 else
9776 /* Auto-create assuming the same AS */
9777 ret = bgp_get_vty(&vrf_bgp, &as, import_name, bgp_type,
9778 NULL, ASNOTATION_UNDEFINED);
9779 if (ret) {
9780 vty_out(vty,
9781 "VRF %s is not configured as a bgp instance\n",
9782 import_name);
9783 return CMD_WARNING;
9784 }
9785 }
9786
9787 if (remove) {
9788 vrf_unimport_from_vrf(bgp, vrf_bgp, afi, safi);
9789 } else {
9790 /* Already importing from "import_vrf"? */
9791 for (ALL_LIST_ELEMENTS_RO(bgp->vpn_policy[afi].import_vrf, node,
9792 vname)) {
9793 if (strcmp(vname, import_name) == 0)
9794 return CMD_WARNING;
9795 }
9796
9797 vrf_import_from_vrf(bgp, vrf_bgp, afi, safi);
9798 }
9799
9800 return CMD_SUCCESS;
9801 }
9802
9803 /* This command is valid only in a bgp vrf instance or the default instance */
9804 DEFPY (bgp_imexport_vpn,
9805 bgp_imexport_vpn_cmd,
9806 "[no] <import|export>$direction_str vpn",
9807 NO_STR
9808 "Import routes to this address-family\n"
9809 "Export routes from this address-family\n"
9810 "to/from default instance VPN RIB\n")
9811 {
9812 VTY_DECLVAR_CONTEXT(bgp, bgp);
9813 int previous_state;
9814 afi_t afi;
9815 safi_t safi;
9816 int idx = 0;
9817 bool yes = true;
9818 int flag;
9819 enum vpn_policy_direction dir;
9820
9821 if (argv_find(argv, argc, "no", &idx))
9822 yes = false;
9823
9824 if (BGP_INSTANCE_TYPE_VRF != bgp->inst_type &&
9825 BGP_INSTANCE_TYPE_DEFAULT != bgp->inst_type) {
9826
9827 vty_out(vty, "%% import|export vpn valid only for bgp vrf or default instance\n");
9828 return CMD_WARNING_CONFIG_FAILED;
9829 }
9830
9831 afi = bgp_node_afi(vty);
9832 safi = bgp_node_safi(vty);
9833 if ((SAFI_UNICAST != safi) || ((AFI_IP != afi) && (AFI_IP6 != afi))) {
9834 vty_out(vty, "%% import|export vpn valid only for unicast ipv4|ipv6\n");
9835 return CMD_WARNING_CONFIG_FAILED;
9836 }
9837
9838 if (!strcmp(direction_str, "import")) {
9839 flag = BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT;
9840 dir = BGP_VPN_POLICY_DIR_FROMVPN;
9841 } else if (!strcmp(direction_str, "export")) {
9842 flag = BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT;
9843 dir = BGP_VPN_POLICY_DIR_TOVPN;
9844 } else {
9845 vty_out(vty, "%% unknown direction %s\n", direction_str);
9846 return CMD_WARNING_CONFIG_FAILED;
9847 }
9848
9849 previous_state = CHECK_FLAG(bgp->af_flags[afi][safi], flag);
9850
9851 if (yes) {
9852 SET_FLAG(bgp->af_flags[afi][safi], flag);
9853 if (!previous_state) {
9854 /* trigger export current vrf */
9855 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
9856 }
9857 } else {
9858 if (previous_state) {
9859 /* trigger un-export current vrf */
9860 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
9861 }
9862 UNSET_FLAG(bgp->af_flags[afi][safi], flag);
9863 }
9864
9865 hook_call(bgp_snmp_init_stats, bgp);
9866
9867 return CMD_SUCCESS;
9868 }
9869
9870 DEFPY (af_routetarget_import,
9871 af_routetarget_import_cmd,
9872 "[no] <rt|route-target|route-target6|rt6> redirect import RTLIST...",
9873 NO_STR
9874 "Specify route target list\n"
9875 "Specify route target list\n"
9876 "Specify route target list\n"
9877 "Specify route target list\n"
9878 "Flow-spec redirect type route target\n"
9879 "Import routes to this address-family\n"
9880 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN|IPV6:MN)\n")
9881 {
9882 VTY_DECLVAR_CONTEXT(bgp, bgp);
9883 int ret;
9884 struct ecommunity *ecom = NULL;
9885 afi_t afi;
9886 int idx = 0, idx_unused = 0;
9887 bool yes = true;
9888 bool rt6 = false;
9889
9890 if (argv_find(argv, argc, "no", &idx))
9891 yes = false;
9892
9893 if (argv_find(argv, argc, "rt6", &idx_unused) ||
9894 argv_find(argv, argc, "route-target6", &idx_unused))
9895 rt6 = true;
9896
9897 afi = vpn_policy_getafi(vty, bgp, false);
9898 if (afi == AFI_MAX)
9899 return CMD_WARNING_CONFIG_FAILED;
9900
9901 if (rt6 && afi != AFI_IP6)
9902 return CMD_WARNING_CONFIG_FAILED;
9903
9904 if (yes) {
9905 if (!argv_find(argv, argc, "RTLIST", &idx)) {
9906 vty_out(vty, "%% Missing RTLIST\n");
9907 return CMD_WARNING_CONFIG_FAILED;
9908 }
9909 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom, rt6);
9910 if (ret != CMD_SUCCESS)
9911 return ret;
9912 }
9913
9914 if (yes) {
9915 if (bgp->vpn_policy[afi].import_redirect_rtlist)
9916 ecommunity_free(&bgp->vpn_policy[afi]
9917 .import_redirect_rtlist);
9918 bgp->vpn_policy[afi].import_redirect_rtlist =
9919 ecommunity_dup(ecom);
9920 } else {
9921 if (bgp->vpn_policy[afi].import_redirect_rtlist)
9922 ecommunity_free(&bgp->vpn_policy[afi]
9923 .import_redirect_rtlist);
9924 bgp->vpn_policy[afi].import_redirect_rtlist = NULL;
9925 }
9926
9927 if (ecom)
9928 ecommunity_free(&ecom);
9929
9930 return CMD_SUCCESS;
9931 }
9932
9933 DEFUN_NOSH (address_family_ipv4_safi,
9934 address_family_ipv4_safi_cmd,
9935 "address-family ipv4 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
9936 "Enter Address Family command mode\n"
9937 BGP_AF_STR
9938 BGP_SAFI_WITH_LABEL_HELP_STR)
9939 {
9940
9941 if (argc == 3) {
9942 VTY_DECLVAR_CONTEXT(bgp, bgp);
9943 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
9944 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
9945 && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
9946 && safi != SAFI_EVPN) {
9947 vty_out(vty,
9948 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
9949 return CMD_WARNING_CONFIG_FAILED;
9950 }
9951 vty->node = bgp_node_type(AFI_IP, safi);
9952 } else
9953 vty->node = BGP_IPV4_NODE;
9954
9955 return CMD_SUCCESS;
9956 }
9957
9958 DEFUN_NOSH (address_family_ipv6_safi,
9959 address_family_ipv6_safi_cmd,
9960 "address-family ipv6 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
9961 "Enter Address Family command mode\n"
9962 BGP_AF_STR
9963 BGP_SAFI_WITH_LABEL_HELP_STR)
9964 {
9965 if (argc == 3) {
9966 VTY_DECLVAR_CONTEXT(bgp, bgp);
9967 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
9968 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
9969 && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
9970 && safi != SAFI_EVPN) {
9971 vty_out(vty,
9972 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
9973 return CMD_WARNING_CONFIG_FAILED;
9974 }
9975 vty->node = bgp_node_type(AFI_IP6, safi);
9976 } else
9977 vty->node = BGP_IPV6_NODE;
9978
9979 return CMD_SUCCESS;
9980 }
9981
9982 #ifdef KEEP_OLD_VPN_COMMANDS
9983 DEFUN_NOSH (address_family_vpnv4,
9984 address_family_vpnv4_cmd,
9985 "address-family vpnv4 [unicast]",
9986 "Enter Address Family command mode\n"
9987 BGP_AF_STR
9988 BGP_AF_MODIFIER_STR)
9989 {
9990 vty->node = BGP_VPNV4_NODE;
9991 return CMD_SUCCESS;
9992 }
9993
9994 DEFUN_NOSH (address_family_vpnv6,
9995 address_family_vpnv6_cmd,
9996 "address-family vpnv6 [unicast]",
9997 "Enter Address Family command mode\n"
9998 BGP_AF_STR
9999 BGP_AF_MODIFIER_STR)
10000 {
10001 vty->node = BGP_VPNV6_NODE;
10002 return CMD_SUCCESS;
10003 }
10004 #endif /* KEEP_OLD_VPN_COMMANDS */
10005
10006 DEFUN_NOSH (address_family_evpn,
10007 address_family_evpn_cmd,
10008 "address-family l2vpn evpn",
10009 "Enter Address Family command mode\n"
10010 BGP_AF_STR
10011 BGP_AF_MODIFIER_STR)
10012 {
10013 VTY_DECLVAR_CONTEXT(bgp, bgp);
10014 vty->node = BGP_EVPN_NODE;
10015 return CMD_SUCCESS;
10016 }
10017
10018 DEFUN_NOSH (bgp_segment_routing_srv6,
10019 bgp_segment_routing_srv6_cmd,
10020 "segment-routing srv6",
10021 "Segment-Routing configuration\n"
10022 "Segment-Routing SRv6 configuration\n")
10023 {
10024 VTY_DECLVAR_CONTEXT(bgp, bgp);
10025 bgp->srv6_enabled = true;
10026 vty->node = BGP_SRV6_NODE;
10027 return CMD_SUCCESS;
10028 }
10029
10030 DEFUN (no_bgp_segment_routing_srv6,
10031 no_bgp_segment_routing_srv6_cmd,
10032 "no segment-routing srv6",
10033 NO_STR
10034 "Segment-Routing configuration\n"
10035 "Segment-Routing SRv6 configuration\n")
10036 {
10037 VTY_DECLVAR_CONTEXT(bgp, bgp);
10038
10039 if (strlen(bgp->srv6_locator_name) > 0)
10040 if (bgp_srv6_locator_unset(bgp) < 0)
10041 return CMD_WARNING_CONFIG_FAILED;
10042
10043 bgp->srv6_enabled = false;
10044 return CMD_SUCCESS;
10045 }
10046
10047 DEFPY (bgp_srv6_locator,
10048 bgp_srv6_locator_cmd,
10049 "locator NAME$name",
10050 "Specify SRv6 locator\n"
10051 "Specify SRv6 locator\n")
10052 {
10053 VTY_DECLVAR_CONTEXT(bgp, bgp);
10054 int ret;
10055
10056 if (strlen(bgp->srv6_locator_name) > 0
10057 && strcmp(name, bgp->srv6_locator_name) != 0) {
10058 vty_out(vty, "srv6 locator is already configured\n");
10059 return CMD_WARNING_CONFIG_FAILED;
10060 }
10061
10062 snprintf(bgp->srv6_locator_name,
10063 sizeof(bgp->srv6_locator_name), "%s", name);
10064
10065 ret = bgp_zebra_srv6_manager_get_locator_chunk(name);
10066 if (ret < 0)
10067 return CMD_WARNING_CONFIG_FAILED;
10068
10069 return CMD_SUCCESS;
10070 }
10071
10072 DEFPY (no_bgp_srv6_locator,
10073 no_bgp_srv6_locator_cmd,
10074 "no locator NAME$name",
10075 NO_STR
10076 "Specify SRv6 locator\n"
10077 "Specify SRv6 locator\n")
10078 {
10079 VTY_DECLVAR_CONTEXT(bgp, bgp);
10080
10081 /* when locator isn't configured, do nothing */
10082 if (strlen(bgp->srv6_locator_name) < 1)
10083 return CMD_SUCCESS;
10084
10085 /* name validation */
10086 if (strcmp(name, bgp->srv6_locator_name) != 0) {
10087 vty_out(vty, "%% No srv6 locator is configured\n");
10088 return CMD_WARNING_CONFIG_FAILED;
10089 }
10090
10091 /* unset locator */
10092 if (bgp_srv6_locator_unset(bgp) < 0)
10093 return CMD_WARNING_CONFIG_FAILED;
10094
10095 return CMD_SUCCESS;
10096 }
10097
10098 DEFPY (show_bgp_srv6,
10099 show_bgp_srv6_cmd,
10100 "show bgp segment-routing srv6",
10101 SHOW_STR
10102 BGP_STR
10103 "BGP Segment Routing\n"
10104 "BGP Segment Routing SRv6\n")
10105 {
10106 struct bgp *bgp;
10107 struct listnode *node;
10108 struct srv6_locator_chunk *chunk;
10109 struct bgp_srv6_function *func;
10110
10111 bgp = bgp_get_default();
10112 if (!bgp)
10113 return CMD_SUCCESS;
10114
10115 vty_out(vty, "locator_name: %s\n", bgp->srv6_locator_name);
10116 vty_out(vty, "locator_chunks:\n");
10117 for (ALL_LIST_ELEMENTS_RO(bgp->srv6_locator_chunks, node, chunk)) {
10118 vty_out(vty, "- %pFX\n", &chunk->prefix);
10119 vty_out(vty, " block-length: %d\n", chunk->block_bits_length);
10120 vty_out(vty, " node-length: %d\n", chunk->node_bits_length);
10121 vty_out(vty, " func-length: %d\n",
10122 chunk->function_bits_length);
10123 vty_out(vty, " arg-length: %d\n", chunk->argument_bits_length);
10124 }
10125
10126 vty_out(vty, "functions:\n");
10127 for (ALL_LIST_ELEMENTS_RO(bgp->srv6_functions, node, func)) {
10128 vty_out(vty, "- sid: %pI6\n", &func->sid);
10129 vty_out(vty, " locator: %s\n", func->locator_name);
10130 }
10131
10132 vty_out(vty, "bgps:\n");
10133 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp)) {
10134 vty_out(vty, "- name: %s\n",
10135 bgp->name ? bgp->name : "default");
10136
10137 vty_out(vty, " vpn_policy[AFI_IP].tovpn_sid: %pI6\n",
10138 bgp->vpn_policy[AFI_IP].tovpn_sid);
10139 vty_out(vty, " vpn_policy[AFI_IP6].tovpn_sid: %pI6\n",
10140 bgp->vpn_policy[AFI_IP6].tovpn_sid);
10141 vty_out(vty, " per-vrf tovpn_sid: %pI6\n", bgp->tovpn_sid);
10142 }
10143
10144 return CMD_SUCCESS;
10145 }
10146
10147 DEFUN_NOSH (exit_address_family,
10148 exit_address_family_cmd,
10149 "exit-address-family",
10150 "Exit from Address Family configuration mode\n")
10151 {
10152 if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
10153 || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
10154 || vty->node == BGP_IPV6_NODE || vty->node == BGP_IPV6M_NODE
10155 || vty->node == BGP_IPV6L_NODE || vty->node == BGP_VPNV6_NODE
10156 || vty->node == BGP_EVPN_NODE
10157 || vty->node == BGP_FLOWSPECV4_NODE
10158 || vty->node == BGP_FLOWSPECV6_NODE)
10159 vty->node = BGP_NODE;
10160 return CMD_SUCCESS;
10161 }
10162
10163 /* Recalculate bestpath and re-advertise a prefix */
10164 static int bgp_clear_prefix(struct vty *vty, const char *view_name,
10165 const char *ip_str, afi_t afi, safi_t safi,
10166 struct prefix_rd *prd)
10167 {
10168 int ret;
10169 struct prefix match;
10170 struct bgp_dest *dest;
10171 struct bgp_dest *rm;
10172 struct bgp *bgp;
10173 struct bgp_table *table;
10174 struct bgp_table *rib;
10175
10176 /* BGP structure lookup. */
10177 if (view_name) {
10178 bgp = bgp_lookup_by_name(view_name);
10179 if (bgp == NULL) {
10180 vty_out(vty, "%% Can't find BGP instance %s\n",
10181 view_name);
10182 return CMD_WARNING;
10183 }
10184 } else {
10185 bgp = bgp_get_default();
10186 if (bgp == NULL) {
10187 vty_out(vty, "%% No BGP process is configured\n");
10188 return CMD_WARNING;
10189 }
10190 }
10191
10192 /* Check IP address argument. */
10193 ret = str2prefix(ip_str, &match);
10194 if (!ret) {
10195 vty_out(vty, "%% address is malformed\n");
10196 return CMD_WARNING;
10197 }
10198
10199 match.family = afi2family(afi);
10200 rib = bgp->rib[afi][safi];
10201
10202 if (safi == SAFI_MPLS_VPN) {
10203 for (dest = bgp_table_top(rib); dest;
10204 dest = bgp_route_next(dest)) {
10205 const struct prefix *dest_p = bgp_dest_get_prefix(dest);
10206
10207 if (prd && memcmp(dest_p->u.val, prd->val, 8) != 0)
10208 continue;
10209
10210 table = bgp_dest_get_bgp_table_info(dest);
10211 if (table == NULL)
10212 continue;
10213
10214 rm = bgp_node_match(table, &match);
10215 if (rm != NULL) {
10216 const struct prefix *rm_p =
10217 bgp_dest_get_prefix(rm);
10218
10219 if (rm_p->prefixlen == match.prefixlen) {
10220 SET_FLAG(rm->flags,
10221 BGP_NODE_USER_CLEAR);
10222 bgp_process(bgp, rm, afi, safi);
10223 }
10224 bgp_dest_unlock_node(rm);
10225 }
10226 }
10227 } else {
10228 dest = bgp_node_match(rib, &match);
10229 if (dest != NULL) {
10230 const struct prefix *dest_p = bgp_dest_get_prefix(dest);
10231
10232 if (dest_p->prefixlen == match.prefixlen) {
10233 SET_FLAG(dest->flags, BGP_NODE_USER_CLEAR);
10234 bgp_process(bgp, dest, afi, safi);
10235 }
10236 bgp_dest_unlock_node(dest);
10237 }
10238 }
10239
10240 return CMD_SUCCESS;
10241 }
10242
10243 /* one clear bgp command to rule them all */
10244 DEFUN (clear_ip_bgp_all,
10245 clear_ip_bgp_all_cmd,
10246 "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|ASNUM|external|peer-group PGNAME> [<soft [<in|out>]|in [prefix-filter]|out|message-stats>]",
10247 CLEAR_STR
10248 IP_STR
10249 BGP_STR
10250 BGP_INSTANCE_HELP_STR
10251 BGP_AFI_HELP_STR
10252 BGP_AF_STR
10253 BGP_SAFI_WITH_LABEL_HELP_STR
10254 BGP_AF_MODIFIER_STR
10255 "Clear all peers\n"
10256 "BGP IPv4 neighbor to clear\n"
10257 "BGP IPv6 neighbor to clear\n"
10258 "BGP neighbor on interface to clear\n"
10259 "Clear peers with the AS number in plain or dotted format\n"
10260 "Clear all external peers\n"
10261 "Clear all members of peer-group\n"
10262 "BGP peer-group name\n"
10263 BGP_SOFT_STR
10264 BGP_SOFT_IN_STR
10265 BGP_SOFT_OUT_STR
10266 BGP_SOFT_IN_STR
10267 "Push out prefix-list ORF and do inbound soft reconfig\n"
10268 BGP_SOFT_OUT_STR
10269 "Reset message statistics\n")
10270 {
10271 char *vrf = NULL;
10272
10273 afi_t afi = AFI_UNSPEC;
10274 safi_t safi = SAFI_UNSPEC;
10275 enum clear_sort clr_sort = clear_peer;
10276 enum bgp_clear_type clr_type;
10277 char *clr_arg = NULL;
10278
10279 int idx = 0;
10280
10281 /* clear [ip] bgp */
10282 if (argv_find(argv, argc, "ip", &idx))
10283 afi = AFI_IP;
10284
10285 /* [<vrf> VIEWVRFNAME] */
10286 if (argv_find(argv, argc, "vrf", &idx)) {
10287 vrf = argv[idx + 1]->arg;
10288 idx += 2;
10289 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
10290 vrf = NULL;
10291 } else if (argv_find(argv, argc, "view", &idx)) {
10292 /* [<view> VIEWVRFNAME] */
10293 vrf = argv[idx + 1]->arg;
10294 idx += 2;
10295 }
10296 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
10297 if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
10298 argv_find_and_parse_safi(argv, argc, &idx, &safi);
10299
10300 /* <*|A.B.C.D|X:X::X:X|WORD|ASNUM|external|peer-group PGNAME> */
10301 if (argv_find(argv, argc, "*", &idx)) {
10302 clr_sort = clear_all;
10303 } else if (argv_find(argv, argc, "A.B.C.D", &idx)) {
10304 clr_sort = clear_peer;
10305 clr_arg = argv[idx]->arg;
10306 } else if (argv_find(argv, argc, "X:X::X:X", &idx)) {
10307 clr_sort = clear_peer;
10308 clr_arg = argv[idx]->arg;
10309 } else if (argv_find(argv, argc, "peer-group", &idx)) {
10310 clr_sort = clear_group;
10311 idx++;
10312 clr_arg = argv[idx]->arg;
10313 } else if (argv_find(argv, argc, "PGNAME", &idx)) {
10314 clr_sort = clear_peer;
10315 clr_arg = argv[idx]->arg;
10316 } else if (argv_find(argv, argc, "WORD", &idx)) {
10317 clr_sort = clear_peer;
10318 clr_arg = argv[idx]->arg;
10319 } else if (argv_find(argv, argc, "ASNUM", &idx)) {
10320 clr_sort = clear_as;
10321 clr_arg = argv[idx]->arg;
10322 } else if (argv_find(argv, argc, "external", &idx)) {
10323 clr_sort = clear_external;
10324 }
10325
10326 /* [<soft [<in|out>]|in [prefix-filter]|out|message-stats>] */
10327 if (argv_find(argv, argc, "soft", &idx)) {
10328 if (argv_find(argv, argc, "in", &idx)
10329 || argv_find(argv, argc, "out", &idx))
10330 clr_type = strmatch(argv[idx]->text, "in")
10331 ? BGP_CLEAR_SOFT_IN
10332 : BGP_CLEAR_SOFT_OUT;
10333 else
10334 clr_type = BGP_CLEAR_SOFT_BOTH;
10335 } else if (argv_find(argv, argc, "in", &idx)) {
10336 clr_type = argv_find(argv, argc, "prefix-filter", &idx)
10337 ? BGP_CLEAR_SOFT_IN_ORF_PREFIX
10338 : BGP_CLEAR_SOFT_IN;
10339 } else if (argv_find(argv, argc, "out", &idx)) {
10340 clr_type = BGP_CLEAR_SOFT_OUT;
10341 } else if (argv_find(argv, argc, "message-stats", &idx)) {
10342 clr_type = BGP_CLEAR_MESSAGE_STATS;
10343 } else
10344 clr_type = BGP_CLEAR_SOFT_NONE;
10345
10346 return bgp_clear_vty(vty, vrf, afi, safi, clr_sort, clr_type, clr_arg);
10347 }
10348
10349 DEFUN (clear_ip_bgp_prefix,
10350 clear_ip_bgp_prefix_cmd,
10351 "clear [ip] bgp [<view|vrf> VIEWVRFNAME] prefix A.B.C.D/M",
10352 CLEAR_STR
10353 IP_STR
10354 BGP_STR
10355 BGP_INSTANCE_HELP_STR
10356 "Clear bestpath and re-advertise\n"
10357 "IPv4 prefix\n")
10358 {
10359 char *vrf = NULL;
10360 char *prefix = NULL;
10361
10362 int idx = 0;
10363
10364 /* [<view|vrf> VIEWVRFNAME] */
10365 if (argv_find(argv, argc, "vrf", &idx)) {
10366 vrf = argv[idx + 1]->arg;
10367 idx += 2;
10368 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
10369 vrf = NULL;
10370 } else if (argv_find(argv, argc, "view", &idx)) {
10371 /* [<view> VIEWVRFNAME] */
10372 vrf = argv[idx + 1]->arg;
10373 idx += 2;
10374 }
10375
10376 prefix = argv[argc - 1]->arg;
10377
10378 return bgp_clear_prefix(vty, vrf, prefix, AFI_IP, SAFI_UNICAST, NULL);
10379 }
10380
10381 DEFUN (clear_bgp_ipv6_safi_prefix,
10382 clear_bgp_ipv6_safi_prefix_cmd,
10383 "clear [ip] bgp ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
10384 CLEAR_STR
10385 IP_STR
10386 BGP_STR
10387 BGP_AF_STR
10388 BGP_SAFI_HELP_STR
10389 "Clear bestpath and re-advertise\n"
10390 "IPv6 prefix\n")
10391 {
10392 int idx_safi = 0;
10393 int idx_ipv6_prefix = 0;
10394 safi_t safi = SAFI_UNICAST;
10395 char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
10396 argv[idx_ipv6_prefix]->arg : NULL;
10397
10398 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
10399 return bgp_clear_prefix(
10400 vty, NULL, prefix, AFI_IP6,
10401 safi, NULL);
10402 }
10403
10404 DEFUN (clear_bgp_instance_ipv6_safi_prefix,
10405 clear_bgp_instance_ipv6_safi_prefix_cmd,
10406 "clear [ip] bgp <view|vrf> VIEWVRFNAME ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
10407 CLEAR_STR
10408 IP_STR
10409 BGP_STR
10410 BGP_INSTANCE_HELP_STR
10411 BGP_AF_STR
10412 BGP_SAFI_HELP_STR
10413 "Clear bestpath and re-advertise\n"
10414 "IPv6 prefix\n")
10415 {
10416 int idx_safi = 0;
10417 int idx_vrfview = 0;
10418 int idx_ipv6_prefix = 0;
10419 safi_t safi = SAFI_UNICAST;
10420 char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
10421 argv[idx_ipv6_prefix]->arg : NULL;
10422 char *vrfview = NULL;
10423
10424 /* [<view|vrf> VIEWVRFNAME] */
10425 if (argv_find(argv, argc, "vrf", &idx_vrfview)) {
10426 vrfview = argv[idx_vrfview + 1]->arg;
10427 if (vrfview && strmatch(vrfview, VRF_DEFAULT_NAME))
10428 vrfview = NULL;
10429 } else if (argv_find(argv, argc, "view", &idx_vrfview)) {
10430 /* [<view> VIEWVRFNAME] */
10431 vrfview = argv[idx_vrfview + 1]->arg;
10432 }
10433 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
10434
10435 return bgp_clear_prefix(
10436 vty, vrfview, prefix,
10437 AFI_IP6, safi, NULL);
10438 }
10439
10440 DEFUN (show_bgp_views,
10441 show_bgp_views_cmd,
10442 "show [ip] bgp views",
10443 SHOW_STR
10444 IP_STR
10445 BGP_STR
10446 "Show the defined BGP views\n")
10447 {
10448 struct list *inst = bm->bgp;
10449 struct listnode *node;
10450 struct bgp *bgp;
10451
10452 vty_out(vty, "Defined BGP views:\n");
10453 for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
10454 /* Skip VRFs. */
10455 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
10456 continue;
10457 vty_out(vty, "\t%s (AS%s)\n", bgp->name ? bgp->name : "(null)",
10458 bgp->as_pretty);
10459 }
10460
10461 return CMD_SUCCESS;
10462 }
10463
10464 static inline void calc_peers_cfgd_estbd(struct bgp *bgp, int *peers_cfgd,
10465 int *peers_estbd)
10466 {
10467 struct peer *peer;
10468 struct listnode *node;
10469
10470 *peers_cfgd = *peers_estbd = 0;
10471 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
10472 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10473 continue;
10474 (*peers_cfgd)++;
10475 if (peer_established(peer))
10476 (*peers_estbd)++;
10477 }
10478 }
10479
10480 static void print_bgp_vrfs(struct bgp *bgp, struct vty *vty, json_object *json,
10481 const char *type)
10482 {
10483 int peers_cfg, peers_estb;
10484
10485 calc_peers_cfgd_estbd(bgp, &peers_cfg, &peers_estb);
10486
10487 if (json) {
10488 int64_t vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
10489 ? -1
10490 : (int64_t)bgp->vrf_id;
10491 json_object_string_add(json, "type", type);
10492 json_object_int_add(json, "vrfId", vrf_id_ui);
10493 json_object_string_addf(json, "routerId", "%pI4",
10494 &bgp->router_id);
10495 json_object_int_add(json, "numConfiguredPeers", peers_cfg);
10496 json_object_int_add(json, "numEstablishedPeers", peers_estb);
10497 json_object_int_add(json, "l3vni", bgp->l3vni);
10498 json_object_string_addf(json, "rmac", "%pEA", &bgp->rmac);
10499 json_object_string_add(
10500 json, "interface",
10501 ifindex2ifname(bgp->l3vni_svi_ifindex, bgp->vrf_id));
10502 }
10503 }
10504
10505 static int show_bgp_vrfs_detail_common(struct vty *vty, struct bgp *bgp,
10506 json_object *json, const char *name,
10507 const char *type, bool use_vrf)
10508 {
10509 int peers_cfg, peers_estb;
10510
10511 calc_peers_cfgd_estbd(bgp, &peers_cfg, &peers_estb);
10512
10513 if (use_vrf) {
10514 if (json) {
10515 print_bgp_vrfs(bgp, vty, json, type);
10516 } else {
10517 vty_out(vty, "BGP instance %s VRF id %d\n",
10518 bgp->name_pretty,
10519 bgp->vrf_id == VRF_UNKNOWN ? -1
10520 : (int)bgp->vrf_id);
10521 vty_out(vty, "Router Id %pI4\n", &bgp->router_id);
10522 vty_out(vty,
10523 "Num Configured Peers %d, Established %d\n",
10524 peers_cfg, peers_estb);
10525 if (bgp->l3vni) {
10526 vty_out(vty,
10527 "L3VNI %u, L3VNI-SVI %s, Router MAC %pEA\n",
10528 bgp->l3vni,
10529 ifindex2ifname(bgp->l3vni_svi_ifindex,
10530 bgp->vrf_id),
10531 &bgp->rmac);
10532 }
10533 }
10534 } else {
10535 if (json) {
10536 print_bgp_vrfs(bgp, vty, json, type);
10537 } else {
10538 vty_out(vty, "%4s %-5d %-16pI4 %-9u %-10u %-37s\n",
10539 type,
10540 bgp->vrf_id == VRF_UNKNOWN ? -1
10541 : (int)bgp->vrf_id,
10542 &bgp->router_id, peers_cfg, peers_estb, name);
10543 vty_out(vty, "%11s %-16u %-21pEA %-20s\n", " ",
10544 bgp->l3vni, &bgp->rmac,
10545 ifindex2ifname(bgp->l3vni_svi_ifindex,
10546 bgp->vrf_id));
10547 }
10548 }
10549
10550 return CMD_SUCCESS;
10551 }
10552
10553 DEFPY (show_bgp_vrfs,
10554 show_bgp_vrfs_cmd,
10555 "show [ip] bgp vrfs [<VRFNAME$vrf_name>] [json]",
10556 SHOW_STR
10557 IP_STR
10558 BGP_STR
10559 "Show BGP VRFs\n"
10560 "Specific VRF name\n"
10561 JSON_STR)
10562 {
10563 struct list *inst = bm->bgp;
10564 struct listnode *node;
10565 struct bgp *bgp;
10566 bool uj = use_json(argc, argv);
10567 json_object *json = NULL;
10568 json_object *json_vrfs = NULL;
10569 json_object *json_vrf = NULL;
10570 int count = 0;
10571 const char *name = vrf_name;
10572 const char *type;
10573
10574 if (uj)
10575 json = json_object_new_object();
10576
10577 if (name) {
10578 if (strmatch(name, VRF_DEFAULT_NAME)) {
10579 bgp = bgp_get_default();
10580 type = "DFLT";
10581 } else {
10582 bgp = bgp_lookup_by_name(name);
10583 type = "VRF";
10584 }
10585 if (!bgp) {
10586 if (uj)
10587 vty_json(vty, json);
10588 else
10589 vty_out(vty,
10590 "%% Specified BGP instance not found\n");
10591
10592 return CMD_WARNING;
10593 }
10594 }
10595
10596 if (vrf_name) {
10597 if (uj)
10598 json_vrf = json_object_new_object();
10599
10600 show_bgp_vrfs_detail_common(vty, bgp, json_vrf, name, type,
10601 true);
10602
10603 if (uj) {
10604 json_object_object_add(json, name, json_vrf);
10605 vty_json(vty, json);
10606 }
10607
10608 return CMD_SUCCESS;
10609 }
10610
10611 if (uj)
10612 json_vrfs = json_object_new_object();
10613
10614 for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
10615 const char *name;
10616
10617 /* Skip Views. */
10618 if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
10619 continue;
10620
10621 count++;
10622 if (!uj && count == 1) {
10623 vty_out(vty,
10624 "%4s %-5s %-16s %9s %10s %-37s\n",
10625 "Type", "Id", "routerId", "#PeersCfg",
10626 "#PeersEstb", "Name");
10627 vty_out(vty, "%11s %-16s %-21s %-6s\n", " ",
10628 "L3-VNI", "RouterMAC", "Interface");
10629 }
10630 if (uj)
10631 json_vrf = json_object_new_object();
10632
10633 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
10634 name = VRF_DEFAULT_NAME;
10635 type = "DFLT";
10636 } else {
10637 name = bgp->name;
10638 type = "VRF";
10639 }
10640
10641 show_bgp_vrfs_detail_common(vty, bgp, json_vrf, name, type,
10642 false);
10643
10644 if (uj)
10645 json_object_object_add(json_vrfs, name, json_vrf);
10646 }
10647
10648 if (uj) {
10649 json_object_object_add(json, "vrfs", json_vrfs);
10650 json_object_int_add(json, "totalVrfs", count);
10651 vty_json(vty, json);
10652 } else {
10653 if (count)
10654 vty_out(vty,
10655 "\nTotal number of VRFs (including default): %d\n",
10656 count);
10657 }
10658
10659 return CMD_SUCCESS;
10660 }
10661
10662 DEFUN (show_bgp_mac_hash,
10663 show_bgp_mac_hash_cmd,
10664 "show bgp mac hash",
10665 SHOW_STR
10666 BGP_STR
10667 "Mac Address\n"
10668 "Mac Address database\n")
10669 {
10670 bgp_mac_dump_table(vty);
10671
10672 return CMD_SUCCESS;
10673 }
10674
10675 static void show_tip_entry(struct hash_bucket *bucket, void *args)
10676 {
10677 struct vty *vty = (struct vty *)args;
10678 struct tip_addr *tip = (struct tip_addr *)bucket->data;
10679
10680 vty_out(vty, "addr: %pI4, count: %d\n", &tip->addr, tip->refcnt);
10681 }
10682
10683 static void bgp_show_martian_nexthops(struct vty *vty, struct bgp *bgp)
10684 {
10685 vty_out(vty, "self nexthop database:\n");
10686 bgp_nexthop_show_address_hash(vty, bgp);
10687
10688 vty_out(vty, "Tunnel-ip database:\n");
10689 hash_iterate(bgp->tip_hash,
10690 (void (*)(struct hash_bucket *, void *))show_tip_entry,
10691 vty);
10692 }
10693
10694 DEFUN(show_bgp_martian_nexthop_db, show_bgp_martian_nexthop_db_cmd,
10695 "show bgp [<view|vrf> VIEWVRFNAME] martian next-hop",
10696 SHOW_STR BGP_STR BGP_INSTANCE_HELP_STR
10697 "martian next-hops\n"
10698 "martian next-hop database\n")
10699 {
10700 struct bgp *bgp = NULL;
10701 int idx = 0;
10702 char *name = NULL;
10703
10704 /* [<vrf> VIEWVRFNAME] */
10705 if (argv_find(argv, argc, "vrf", &idx)) {
10706 name = argv[idx + 1]->arg;
10707 if (name && strmatch(name, VRF_DEFAULT_NAME))
10708 name = NULL;
10709 } else if (argv_find(argv, argc, "view", &idx))
10710 /* [<view> VIEWVRFNAME] */
10711 name = argv[idx + 1]->arg;
10712 if (name)
10713 bgp = bgp_lookup_by_name(name);
10714 else
10715 bgp = bgp_get_default();
10716
10717 if (!bgp) {
10718 vty_out(vty, "%% No BGP process is configured\n");
10719 return CMD_WARNING;
10720 }
10721 bgp_show_martian_nexthops(vty, bgp);
10722
10723 return CMD_SUCCESS;
10724 }
10725
10726 DEFUN (show_bgp_memory,
10727 show_bgp_memory_cmd,
10728 "show [ip] bgp memory",
10729 SHOW_STR
10730 IP_STR
10731 BGP_STR
10732 "Global BGP memory statistics\n")
10733 {
10734 char memstrbuf[MTYPE_MEMSTR_LEN];
10735 unsigned long count;
10736
10737 /* RIB related usage stats */
10738 count = mtype_stats_alloc(MTYPE_BGP_NODE);
10739 vty_out(vty, "%ld RIB nodes, using %s of memory\n", count,
10740 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10741 count * sizeof(struct bgp_dest)));
10742
10743 count = mtype_stats_alloc(MTYPE_BGP_ROUTE);
10744 vty_out(vty, "%ld BGP routes, using %s of memory\n", count,
10745 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10746 count * sizeof(struct bgp_path_info)));
10747 if ((count = mtype_stats_alloc(MTYPE_BGP_ROUTE_EXTRA)))
10748 vty_out(vty, "%ld BGP route ancillaries, using %s of memory\n",
10749 count,
10750 mtype_memstr(
10751 memstrbuf, sizeof(memstrbuf),
10752 count * sizeof(struct bgp_path_info_extra)));
10753
10754 if ((count = mtype_stats_alloc(MTYPE_BGP_STATIC)))
10755 vty_out(vty, "%ld Static routes, using %s of memory\n", count,
10756 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10757 count * sizeof(struct bgp_static)));
10758
10759 if ((count = mtype_stats_alloc(MTYPE_BGP_PACKET)))
10760 vty_out(vty, "%ld Packets, using %s of memory\n", count,
10761 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10762 count * sizeof(struct bpacket)));
10763
10764 /* Adj-In/Out */
10765 if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_IN)))
10766 vty_out(vty, "%ld Adj-In entries, using %s of memory\n", count,
10767 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10768 count * sizeof(struct bgp_adj_in)));
10769 if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_OUT)))
10770 vty_out(vty, "%ld Adj-Out entries, using %s of memory\n", count,
10771 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10772 count * sizeof(struct bgp_adj_out)));
10773
10774 if ((count = mtype_stats_alloc(MTYPE_BGP_NEXTHOP_CACHE)))
10775 vty_out(vty, "%ld Nexthop cache entries, using %s of memory\n",
10776 count,
10777 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10778 count * sizeof(struct bgp_nexthop_cache)));
10779
10780 if ((count = mtype_stats_alloc(MTYPE_BGP_DAMP_INFO)))
10781 vty_out(vty, "%ld Dampening entries, using %s of memory\n",
10782 count,
10783 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10784 count * sizeof(struct bgp_damp_info)));
10785
10786 /* Attributes */
10787 count = attr_count();
10788 vty_out(vty, "%ld BGP attributes, using %s of memory\n", count,
10789 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10790 count * sizeof(struct attr)));
10791
10792 if ((count = attr_unknown_count()))
10793 vty_out(vty, "%ld unknown attributes\n", count);
10794
10795 /* AS_PATH attributes */
10796 count = aspath_count();
10797 vty_out(vty, "%ld BGP AS-PATH entries, using %s of memory\n", count,
10798 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10799 count * sizeof(struct aspath)));
10800
10801 count = mtype_stats_alloc(MTYPE_AS_SEG);
10802 vty_out(vty, "%ld BGP AS-PATH segments, using %s of memory\n", count,
10803 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10804 count * sizeof(struct assegment)));
10805
10806 /* Other attributes */
10807 if ((count = community_count()))
10808 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
10809 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10810 count * sizeof(struct community)));
10811 if ((count = mtype_stats_alloc(MTYPE_ECOMMUNITY)))
10812 vty_out(vty,
10813 "%ld BGP ext-community entries, using %s of memory\n",
10814 count,
10815 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10816 count * sizeof(struct ecommunity)));
10817 if ((count = mtype_stats_alloc(MTYPE_LCOMMUNITY)))
10818 vty_out(vty,
10819 "%ld BGP large-community entries, using %s of memory\n",
10820 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10821 count * sizeof(struct lcommunity)));
10822
10823 if ((count = mtype_stats_alloc(MTYPE_CLUSTER)))
10824 vty_out(vty, "%ld Cluster lists, using %s of memory\n", count,
10825 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10826 count * sizeof(struct cluster_list)));
10827
10828 /* Peer related usage */
10829 count = mtype_stats_alloc(MTYPE_BGP_PEER);
10830 vty_out(vty, "%ld peers, using %s of memory\n", count,
10831 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10832 count * sizeof(struct peer)));
10833
10834 if ((count = mtype_stats_alloc(MTYPE_PEER_GROUP)))
10835 vty_out(vty, "%ld peer groups, using %s of memory\n", count,
10836 mtype_memstr(memstrbuf, sizeof(memstrbuf),
10837 count * sizeof(struct peer_group)));
10838
10839 /* Other */
10840 if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
10841 vty_out(vty, "%ld compiled regexes, using %s of memory\n",
10842 count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
10843 count * sizeof(regex_t)));
10844 return CMD_SUCCESS;
10845 }
10846
10847 static void bgp_show_bestpath_json(struct bgp *bgp, json_object *json)
10848 {
10849 json_object *bestpath = json_object_new_object();
10850
10851 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE))
10852 json_object_string_add(bestpath, "asPath", "ignore");
10853
10854 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED))
10855 json_object_string_add(bestpath, "asPath", "confed");
10856
10857 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
10858 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MULTIPATH_RELAX_AS_SET))
10859 json_object_string_add(bestpath, "multiPathRelax",
10860 "as-set");
10861 else
10862 json_object_string_add(bestpath, "multiPathRelax",
10863 "true");
10864 } else
10865 json_object_string_add(bestpath, "multiPathRelax", "false");
10866
10867 if (CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
10868 json_object_boolean_true_add(bestpath, "peerTypeRelax");
10869
10870 if (CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID))
10871 json_object_string_add(bestpath, "compareRouterId", "true");
10872 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED)
10873 || CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST)) {
10874 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED))
10875 json_object_string_add(bestpath, "med", "confed");
10876 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST))
10877 json_object_string_add(bestpath, "med",
10878 "missing-as-worst");
10879 else
10880 json_object_string_add(bestpath, "med", "true");
10881 }
10882
10883 json_object_object_add(json, "bestPath", bestpath);
10884 }
10885
10886 /* Print the error code/subcode for why the peer is down */
10887 static void bgp_show_peer_reset(struct vty * vty, struct peer *peer,
10888 json_object *json_peer, bool use_json)
10889 {
10890 const char *code_str;
10891 const char *subcode_str;
10892
10893 if (use_json) {
10894 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND
10895 || peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10896 char errorcodesubcode_hexstr[5];
10897 char errorcodesubcode_str[256];
10898
10899 code_str = bgp_notify_code_str(peer->notify.code);
10900 subcode_str = bgp_notify_subcode_str(
10901 peer->notify.code,
10902 peer->notify.subcode);
10903
10904 snprintf(errorcodesubcode_hexstr,
10905 sizeof(errorcodesubcode_hexstr), "%02X%02X",
10906 peer->notify.code, peer->notify.subcode);
10907 json_object_string_add(json_peer,
10908 "lastErrorCodeSubcode",
10909 errorcodesubcode_hexstr);
10910 snprintf(errorcodesubcode_str, 255, "%s%s",
10911 code_str, subcode_str);
10912 json_object_string_add(json_peer,
10913 "lastNotificationReason",
10914 errorcodesubcode_str);
10915 json_object_boolean_add(json_peer,
10916 "lastNotificationHardReset",
10917 peer->notify.hard_reset);
10918 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10919 && peer->notify.code == BGP_NOTIFY_CEASE
10920 && (peer->notify.subcode
10921 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10922 || peer->notify.subcode
10923 == BGP_NOTIFY_CEASE_ADMIN_RESET)
10924 && peer->notify.length) {
10925 char msgbuf[1024];
10926 const char *msg_str;
10927
10928 msg_str = bgp_notify_admin_message(
10929 msgbuf, sizeof(msgbuf),
10930 (uint8_t *)peer->notify.data,
10931 peer->notify.length);
10932 if (msg_str)
10933 json_object_string_add(
10934 json_peer,
10935 "lastShutdownDescription",
10936 msg_str);
10937 }
10938
10939 }
10940 json_object_string_add(json_peer, "lastResetDueTo",
10941 peer_down_str[(int)peer->last_reset]);
10942 json_object_int_add(json_peer, "lastResetCode",
10943 peer->last_reset);
10944 json_object_string_add(json_peer, "softwareVersion",
10945 peer->soft_version ? peer->soft_version
10946 : "n/a");
10947 } else {
10948 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND
10949 || peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10950 code_str = bgp_notify_code_str(peer->notify.code);
10951 subcode_str =
10952 bgp_notify_subcode_str(peer->notify.code,
10953 peer->notify.subcode);
10954 vty_out(vty, " Notification %s (%s%s%s)\n",
10955 peer->last_reset == PEER_DOWN_NOTIFY_SEND
10956 ? "sent"
10957 : "received",
10958 code_str, subcode_str,
10959 peer->notify.hard_reset
10960 ? bgp_notify_subcode_str(
10961 BGP_NOTIFY_CEASE,
10962 BGP_NOTIFY_CEASE_HARD_RESET)
10963 : "");
10964 } else {
10965 vty_out(vty, " %s (%s)\n",
10966 peer_down_str[(int)peer->last_reset],
10967 peer->soft_version ? peer->soft_version
10968 : "n/a");
10969 }
10970 }
10971 }
10972
10973 static inline bool bgp_has_peer_failed(struct peer *peer, afi_t afi,
10974 safi_t safi)
10975 {
10976 return ((!peer_established(peer)) || !peer->afc_recv[afi][safi]);
10977 }
10978
10979 static void bgp_show_failed_summary(struct vty *vty, struct bgp *bgp,
10980 struct peer *peer, json_object *json_peer,
10981 int max_neighbor_width, bool use_json)
10982 {
10983 char timebuf[BGP_UPTIME_LEN], dn_flag[2];
10984 int len;
10985
10986 if (use_json) {
10987 if (peer_dynamic_neighbor(peer))
10988 json_object_boolean_true_add(json_peer,
10989 "dynamicPeer");
10990 if (peer->hostname)
10991 json_object_string_add(json_peer, "hostname",
10992 peer->hostname);
10993
10994 if (peer->domainname)
10995 json_object_string_add(json_peer, "domainname",
10996 peer->domainname);
10997 json_object_int_add(json_peer, "connectionsEstablished",
10998 peer->established);
10999 json_object_int_add(json_peer, "connectionsDropped",
11000 peer->dropped);
11001 peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
11002 use_json, json_peer);
11003 if (peer_established(peer))
11004 json_object_string_add(json_peer, "lastResetDueTo",
11005 "AFI/SAFI Not Negotiated");
11006 else
11007 bgp_show_peer_reset(NULL, peer, json_peer, true);
11008 } else {
11009 dn_flag[1] = '\0';
11010 dn_flag[0] = peer_dynamic_neighbor(peer) ? '*' : '\0';
11011 if (peer->hostname
11012 && CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME))
11013 len = vty_out(vty, "%s%s(%s)", dn_flag,
11014 peer->hostname, peer->host);
11015 else
11016 len = vty_out(vty, "%s%s", dn_flag, peer->host);
11017
11018 /* pad the neighbor column with spaces */
11019 if (len < max_neighbor_width)
11020 vty_out(vty, "%*s", max_neighbor_width - len,
11021 " ");
11022 vty_out(vty, "%7d %7d %9s", peer->established,
11023 peer->dropped,
11024 peer_uptime(peer->uptime, timebuf,
11025 BGP_UPTIME_LEN, 0, NULL));
11026 if (peer_established(peer))
11027 vty_out(vty, " AFI/SAFI Not Negotiated\n");
11028 else
11029 bgp_show_peer_reset(vty, peer, NULL,
11030 false);
11031 }
11032 }
11033
11034 /* Strip peer's description to the given size. */
11035 static char *bgp_peer_description_stripped(char *desc, uint32_t size)
11036 {
11037 static char stripped[BUFSIZ];
11038 uint32_t i = 0;
11039 uint32_t last_space = 0;
11040
11041 while (i < size) {
11042 if (*(desc + i) == 0) {
11043 stripped[i] = '\0';
11044 return stripped;
11045 }
11046 if (i != 0 && *(desc + i) == ' ' && last_space != i - 1)
11047 last_space = i;
11048 stripped[i] = *(desc + i);
11049 i++;
11050 }
11051
11052 if (last_space > size)
11053 stripped[size + 1] = '\0';
11054 else
11055 stripped[last_space] = '\0';
11056
11057 return stripped;
11058 }
11059
11060 /* Determine whether var peer should be filtered out of the summary. */
11061 static bool bgp_show_summary_is_peer_filtered(struct peer *peer,
11062 struct peer *fpeer, int as_type,
11063 as_t as)
11064 {
11065
11066 /* filter neighbor XXXX */
11067 if (fpeer && fpeer != peer)
11068 return true;
11069
11070 /* filter remote-as (internal|external) */
11071 if (as_type != AS_UNSPECIFIED) {
11072 if (peer->as_type == AS_SPECIFIED) {
11073 if (as_type == AS_INTERNAL) {
11074 if (peer->as != peer->local_as)
11075 return true;
11076 } else if (peer->as == peer->local_as)
11077 return true;
11078 } else if (as_type != peer->as_type)
11079 return true;
11080 } else if (as && as != peer->as) /* filter remote-as XXX */
11081 return true;
11082
11083 return false;
11084 }
11085
11086 /* Show BGP peer's summary information.
11087 *
11088 * Peer's description is stripped according to if `wide` option is given
11089 * or not.
11090 *
11091 * When adding new columns to `show bgp summary` output, please make
11092 * sure `Desc` is the lastest column to show because it can contain
11093 * whitespaces and the whole output will be tricky.
11094 */
11095 static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
11096 struct peer *fpeer, int as_type, as_t as,
11097 uint16_t show_flags)
11098 {
11099 struct peer *peer;
11100 struct listnode *node, *nnode;
11101 unsigned int count = 0, dn_count = 0;
11102 char timebuf[BGP_UPTIME_LEN], dn_flag[2];
11103 char neighbor_buf[VTY_BUFSIZ];
11104 int neighbor_col_default_width = 16;
11105 int len, failed_count = 0;
11106 unsigned int filtered_count = 0;
11107 int max_neighbor_width = 0;
11108 int pfx_rcd_safi;
11109 json_object *json = NULL;
11110 json_object *json_peer = NULL;
11111 json_object *json_peers = NULL;
11112 struct peer_af *paf;
11113 struct bgp_filter *filter;
11114 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11115 bool show_failed = CHECK_FLAG(show_flags, BGP_SHOW_OPT_FAILED);
11116 bool show_established =
11117 CHECK_FLAG(show_flags, BGP_SHOW_OPT_ESTABLISHED);
11118 bool show_wide = CHECK_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
11119 bool show_terse = CHECK_FLAG(show_flags, BGP_SHOW_OPT_TERSE);
11120
11121 /* labeled-unicast routes are installed in the unicast table so in order
11122 * to
11123 * display the correct PfxRcd value we must look at SAFI_UNICAST
11124 */
11125
11126 if (safi == SAFI_LABELED_UNICAST)
11127 pfx_rcd_safi = SAFI_UNICAST;
11128 else
11129 pfx_rcd_safi = safi;
11130
11131 if (use_json) {
11132 json = json_object_new_object();
11133 json_peers = json_object_new_object();
11134 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
11135 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11136 as_type, as)) {
11137 filtered_count++;
11138 count++;
11139 continue;
11140 }
11141
11142 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
11143 continue;
11144
11145 if (peer->afc[afi][safi]) {
11146 /* See if we have at least a single failed peer */
11147 if (bgp_has_peer_failed(peer, afi, safi))
11148 failed_count++;
11149 count++;
11150 }
11151 if (peer_dynamic_neighbor(peer))
11152 dn_count++;
11153 }
11154
11155 } else {
11156 /* Loop over all neighbors that will be displayed to determine
11157 * how many
11158 * characters are needed for the Neighbor column
11159 */
11160 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
11161 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11162 as_type, as)) {
11163 filtered_count++;
11164 count++;
11165 continue;
11166 }
11167
11168 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
11169 continue;
11170
11171 if (peer->afc[afi][safi]) {
11172 memset(dn_flag, '\0', sizeof(dn_flag));
11173 if (peer_dynamic_neighbor(peer))
11174 dn_flag[0] = '*';
11175
11176 if (peer->hostname
11177 && CHECK_FLAG(bgp->flags,
11178 BGP_FLAG_SHOW_HOSTNAME))
11179 snprintf(neighbor_buf,
11180 sizeof(neighbor_buf),
11181 "%s%s(%s) ", dn_flag,
11182 peer->hostname, peer->host);
11183 else
11184 snprintf(neighbor_buf,
11185 sizeof(neighbor_buf), "%s%s ",
11186 dn_flag, peer->host);
11187
11188 len = strlen(neighbor_buf);
11189
11190 if (len > max_neighbor_width)
11191 max_neighbor_width = len;
11192
11193 /* See if we have at least a single failed peer */
11194 if (bgp_has_peer_failed(peer, afi, safi))
11195 failed_count++;
11196 count++;
11197 }
11198 }
11199
11200 /* Originally we displayed the Neighbor column as 16
11201 * characters wide so make that the default
11202 */
11203 if (max_neighbor_width < neighbor_col_default_width)
11204 max_neighbor_width = neighbor_col_default_width;
11205 }
11206
11207 if (show_failed && !failed_count) {
11208 if (use_json) {
11209 json_object_int_add(json, "failedPeersCount", 0);
11210 json_object_int_add(json, "dynamicPeers", dn_count);
11211 json_object_int_add(json, "totalPeers", count);
11212
11213 vty_json(vty, json);
11214 } else {
11215 vty_out(vty, "%% No failed BGP neighbors found\n");
11216 }
11217 return CMD_SUCCESS;
11218 }
11219
11220 count = 0; /* Reset the value as its used again */
11221 filtered_count = 0;
11222 dn_count = 0;
11223 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
11224 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
11225 continue;
11226
11227 if (!peer->afc[afi][safi])
11228 continue;
11229
11230 if (!count) {
11231 unsigned long ents;
11232 char memstrbuf[MTYPE_MEMSTR_LEN];
11233 int64_t vrf_id_ui;
11234
11235 vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
11236 ? -1
11237 : (int64_t)bgp->vrf_id;
11238
11239 /* Usage summary and header */
11240 if (use_json) {
11241 json_object_string_addf(json, "routerId",
11242 "%pI4",
11243 &bgp->router_id);
11244 asn_asn2json(json, "as", bgp->as,
11245 bgp->asnotation);
11246 json_object_int_add(json, "vrfId", vrf_id_ui);
11247 json_object_string_add(
11248 json, "vrfName",
11249 (bgp->inst_type
11250 == BGP_INSTANCE_TYPE_DEFAULT)
11251 ? VRF_DEFAULT_NAME
11252 : bgp->name);
11253 } else {
11254 vty_out(vty,
11255 "BGP router identifier %pI4, local AS number %s vrf-id %d",
11256 &bgp->router_id, bgp->as_pretty,
11257 bgp->vrf_id == VRF_UNKNOWN
11258 ? -1
11259 : (int)bgp->vrf_id);
11260 vty_out(vty, "\n");
11261 }
11262
11263 if (bgp_update_delay_configured(bgp)) {
11264 if (use_json) {
11265 json_object_int_add(
11266 json, "updateDelayLimit",
11267 bgp->v_update_delay);
11268
11269 if (bgp->v_update_delay
11270 != bgp->v_establish_wait)
11271 json_object_int_add(
11272 json,
11273 "updateDelayEstablishWait",
11274 bgp->v_establish_wait);
11275
11276 if (bgp_update_delay_active(bgp)) {
11277 json_object_string_add(
11278 json,
11279 "updateDelayFirstNeighbor",
11280 bgp->update_delay_begin_time);
11281 json_object_boolean_true_add(
11282 json,
11283 "updateDelayInProgress");
11284 } else {
11285 if (bgp->update_delay_over) {
11286 json_object_string_add(
11287 json,
11288 "updateDelayFirstNeighbor",
11289 bgp->update_delay_begin_time);
11290 json_object_string_add(
11291 json,
11292 "updateDelayBestpathResumed",
11293 bgp->update_delay_end_time);
11294 json_object_string_add(
11295 json,
11296 "updateDelayZebraUpdateResume",
11297 bgp->update_delay_zebra_resume_time);
11298 json_object_string_add(
11299 json,
11300 "updateDelayPeerUpdateResume",
11301 bgp->update_delay_peers_resume_time);
11302 }
11303 }
11304 } else {
11305 vty_out(vty,
11306 "Read-only mode update-delay limit: %d seconds\n",
11307 bgp->v_update_delay);
11308 if (bgp->v_update_delay
11309 != bgp->v_establish_wait)
11310 vty_out(vty,
11311 " Establish wait: %d seconds\n",
11312 bgp->v_establish_wait);
11313
11314 if (bgp_update_delay_active(bgp)) {
11315 vty_out(vty,
11316 " First neighbor established: %s\n",
11317 bgp->update_delay_begin_time);
11318 vty_out(vty,
11319 " Delay in progress\n");
11320 } else {
11321 if (bgp->update_delay_over) {
11322 vty_out(vty,
11323 " First neighbor established: %s\n",
11324 bgp->update_delay_begin_time);
11325 vty_out(vty,
11326 " Best-paths resumed: %s\n",
11327 bgp->update_delay_end_time);
11328 vty_out(vty,
11329 " zebra update resumed: %s\n",
11330 bgp->update_delay_zebra_resume_time);
11331 vty_out(vty,
11332 " peers update resumed: %s\n",
11333 bgp->update_delay_peers_resume_time);
11334 }
11335 }
11336 }
11337 }
11338
11339 if (use_json) {
11340 if (bgp_maxmed_onstartup_configured(bgp)
11341 && bgp->maxmed_active)
11342 json_object_boolean_true_add(
11343 json, "maxMedOnStartup");
11344 if (bgp->v_maxmed_admin)
11345 json_object_boolean_true_add(
11346 json, "maxMedAdministrative");
11347
11348 json_object_int_add(
11349 json, "tableVersion",
11350 bgp_table_version(bgp->rib[afi][safi]));
11351
11352 ents = bgp_table_count(bgp->rib[afi][safi]);
11353 json_object_int_add(json, "ribCount", ents);
11354 json_object_int_add(
11355 json, "ribMemory",
11356 ents * sizeof(struct bgp_dest));
11357
11358 ents = bgp->af_peer_count[afi][safi];
11359 json_object_int_add(json, "peerCount", ents);
11360 json_object_int_add(json, "peerMemory",
11361 ents * sizeof(struct peer));
11362
11363 if ((ents = listcount(bgp->group))) {
11364 json_object_int_add(
11365 json, "peerGroupCount", ents);
11366 json_object_int_add(
11367 json, "peerGroupMemory",
11368 ents * sizeof(struct
11369 peer_group));
11370 }
11371
11372 if (CHECK_FLAG(bgp->af_flags[afi][safi],
11373 BGP_CONFIG_DAMPENING))
11374 json_object_boolean_true_add(
11375 json, "dampeningEnabled");
11376 } else {
11377 if (!show_terse) {
11378 if (bgp_maxmed_onstartup_configured(bgp)
11379 && bgp->maxmed_active)
11380 vty_out(vty,
11381 "Max-med on-startup active\n");
11382 if (bgp->v_maxmed_admin)
11383 vty_out(vty,
11384 "Max-med administrative active\n");
11385
11386 vty_out(vty,
11387 "BGP table version %" PRIu64
11388 "\n",
11389 bgp_table_version(
11390 bgp->rib[afi][safi]));
11391
11392 ents = bgp_table_count(
11393 bgp->rib[afi][safi]);
11394 vty_out(vty,
11395 "RIB entries %ld, using %s of memory\n",
11396 ents,
11397 mtype_memstr(
11398 memstrbuf,
11399 sizeof(memstrbuf),
11400 ents
11401 * sizeof(
11402 struct
11403 bgp_dest)));
11404
11405 /* Peer related usage */
11406 ents = bgp->af_peer_count[afi][safi];
11407 vty_out(vty,
11408 "Peers %ld, using %s of memory\n",
11409 ents,
11410 mtype_memstr(
11411 memstrbuf,
11412 sizeof(memstrbuf),
11413 ents
11414 * sizeof(
11415 struct
11416 peer)));
11417
11418 if ((ents = listcount(bgp->group)))
11419 vty_out(vty,
11420 "Peer groups %ld, using %s of memory\n",
11421 ents,
11422 mtype_memstr(
11423 memstrbuf,
11424 sizeof(memstrbuf),
11425 ents
11426 * sizeof(
11427 struct
11428 peer_group)));
11429
11430 if (CHECK_FLAG(bgp->af_flags[afi][safi],
11431 BGP_CONFIG_DAMPENING))
11432 vty_out(vty,
11433 "Dampening enabled.\n");
11434 }
11435 if (show_failed) {
11436 vty_out(vty, "\n");
11437
11438 /* Subtract 8 here because 'Neighbor' is
11439 * 8 characters */
11440 vty_out(vty, "Neighbor");
11441 vty_out(vty, "%*s",
11442 max_neighbor_width - 8, " ");
11443 vty_out(vty,
11444 BGP_SHOW_SUMMARY_HEADER_FAILED);
11445 }
11446 }
11447 }
11448
11449 paf = peer_af_find(peer, afi, safi);
11450 filter = &peer->filter[afi][safi];
11451
11452 count++;
11453 /* Works for both failed & successful cases */
11454 if (peer_dynamic_neighbor(peer))
11455 dn_count++;
11456
11457 if (use_json) {
11458 json_peer = NULL;
11459 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11460 as_type, as)) {
11461 filtered_count++;
11462 continue;
11463 }
11464 if (show_failed &&
11465 bgp_has_peer_failed(peer, afi, safi)) {
11466 json_peer = json_object_new_object();
11467 bgp_show_failed_summary(vty, bgp, peer,
11468 json_peer, 0, use_json);
11469 } else if (!show_failed) {
11470 if (show_established
11471 && bgp_has_peer_failed(peer, afi, safi)) {
11472 filtered_count++;
11473 continue;
11474 }
11475
11476 json_peer = json_object_new_object();
11477 if (peer_dynamic_neighbor(peer)) {
11478 json_object_boolean_true_add(json_peer,
11479 "dynamicPeer");
11480 }
11481
11482 if (peer->hostname)
11483 json_object_string_add(json_peer, "hostname",
11484 peer->hostname);
11485
11486 if (peer->domainname)
11487 json_object_string_add(json_peer, "domainname",
11488 peer->domainname);
11489
11490 asn_asn2json(json_peer, "remoteAs", peer->as,
11491 bgp->asnotation);
11492 asn_asn2json(json_peer, "localAs",
11493 peer->change_local_as
11494 ? peer->change_local_as
11495 : peer->local_as,
11496 bgp->asnotation);
11497 json_object_int_add(json_peer, "version", 4);
11498 json_object_int_add(json_peer, "msgRcvd",
11499 PEER_TOTAL_RX(peer));
11500 json_object_int_add(json_peer, "msgSent",
11501 PEER_TOTAL_TX(peer));
11502
11503 atomic_size_t outq_count, inq_count;
11504 outq_count = atomic_load_explicit(
11505 &peer->obuf->count,
11506 memory_order_relaxed);
11507 inq_count = atomic_load_explicit(
11508 &peer->ibuf->count,
11509 memory_order_relaxed);
11510
11511 json_object_int_add(json_peer, "tableVersion",
11512 peer->version[afi][safi]);
11513 json_object_int_add(json_peer, "outq",
11514 outq_count);
11515 json_object_int_add(json_peer, "inq",
11516 inq_count);
11517 peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
11518 use_json, json_peer);
11519
11520 json_object_int_add(json_peer, "pfxRcd",
11521 peer->pcount[afi][pfx_rcd_safi]);
11522
11523 if (paf && PAF_SUBGRP(paf))
11524 json_object_int_add(
11525 json_peer, "pfxSnt",
11526 (PAF_SUBGRP(paf))->scount);
11527 else
11528 json_object_int_add(json_peer, "pfxSnt",
11529 0);
11530
11531 /* BGP FSM state */
11532 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
11533 || CHECK_FLAG(peer->bgp->flags,
11534 BGP_FLAG_SHUTDOWN))
11535 json_object_string_add(json_peer,
11536 "state",
11537 "Idle (Admin)");
11538 else if (peer->afc_recv[afi][safi])
11539 json_object_string_add(
11540 json_peer, "state",
11541 lookup_msg(bgp_status_msg,
11542 peer->status, NULL));
11543 else if (CHECK_FLAG(
11544 peer->sflags,
11545 PEER_STATUS_PREFIX_OVERFLOW))
11546 json_object_string_add(json_peer,
11547 "state",
11548 "Idle (PfxCt)");
11549 else
11550 json_object_string_add(
11551 json_peer, "state",
11552 lookup_msg(bgp_status_msg,
11553 peer->status, NULL));
11554
11555 /* BGP peer state */
11556 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
11557 || CHECK_FLAG(peer->bgp->flags,
11558 BGP_FLAG_SHUTDOWN))
11559 json_object_string_add(json_peer,
11560 "peerState",
11561 "Admin");
11562 else if (CHECK_FLAG(
11563 peer->sflags,
11564 PEER_STATUS_PREFIX_OVERFLOW))
11565 json_object_string_add(json_peer,
11566 "peerState",
11567 "PfxCt");
11568 else if (CHECK_FLAG(peer->flags,
11569 PEER_FLAG_PASSIVE))
11570 json_object_string_add(json_peer,
11571 "peerState",
11572 "Passive");
11573 else if (CHECK_FLAG(peer->sflags,
11574 PEER_STATUS_NSF_WAIT))
11575 json_object_string_add(json_peer,
11576 "peerState",
11577 "NSF passive");
11578 else if (CHECK_FLAG(
11579 peer->bgp->flags,
11580 BGP_FLAG_EBGP_REQUIRES_POLICY)
11581 && (!bgp_inbound_policy_exists(peer,
11582 filter)
11583 || !bgp_outbound_policy_exists(
11584 peer, filter)))
11585 json_object_string_add(json_peer,
11586 "peerState",
11587 "Policy");
11588 else
11589 json_object_string_add(
11590 json_peer, "peerState", "OK");
11591
11592 json_object_int_add(json_peer, "connectionsEstablished",
11593 peer->established);
11594 json_object_int_add(json_peer, "connectionsDropped",
11595 peer->dropped);
11596 if (peer->desc)
11597 json_object_string_add(
11598 json_peer, "desc", peer->desc);
11599 }
11600 /* Avoid creating empty peer dicts in JSON */
11601 if (json_peer == NULL)
11602 continue;
11603
11604 if (peer->conf_if)
11605 json_object_string_add(json_peer, "idType",
11606 "interface");
11607 else if (peer->su.sa.sa_family == AF_INET)
11608 json_object_string_add(json_peer, "idType",
11609 "ipv4");
11610 else if (peer->su.sa.sa_family == AF_INET6)
11611 json_object_string_add(json_peer, "idType",
11612 "ipv6");
11613 json_object_object_add(json_peers, peer->host,
11614 json_peer);
11615 } else {
11616 if (bgp_show_summary_is_peer_filtered(peer, fpeer,
11617 as_type, as)) {
11618 filtered_count++;
11619 continue;
11620 }
11621 if (show_failed &&
11622 bgp_has_peer_failed(peer, afi, safi)) {
11623 bgp_show_failed_summary(vty, bgp, peer, NULL,
11624 max_neighbor_width,
11625 use_json);
11626 } else if (!show_failed) {
11627 if (show_established
11628 && bgp_has_peer_failed(peer, afi, safi)) {
11629 filtered_count++;
11630 continue;
11631 }
11632
11633 if ((count - filtered_count) == 1) {
11634 /* display headline before the first
11635 * neighbor line */
11636 vty_out(vty, "\n");
11637
11638 /* Subtract 8 here because 'Neighbor' is
11639 * 8 characters */
11640 vty_out(vty, "Neighbor");
11641 vty_out(vty, "%*s",
11642 max_neighbor_width - 8, " ");
11643 vty_out(vty,
11644 show_wide
11645 ? BGP_SHOW_SUMMARY_HEADER_ALL_WIDE
11646 : BGP_SHOW_SUMMARY_HEADER_ALL);
11647 }
11648
11649 memset(dn_flag, '\0', sizeof(dn_flag));
11650 if (peer_dynamic_neighbor(peer)) {
11651 dn_flag[0] = '*';
11652 }
11653
11654 if (peer->hostname
11655 && CHECK_FLAG(bgp->flags,
11656 BGP_FLAG_SHOW_HOSTNAME))
11657 len = vty_out(vty, "%s%s(%s)", dn_flag,
11658 peer->hostname,
11659 peer->host);
11660 else
11661 len = vty_out(vty, "%s%s", dn_flag, peer->host);
11662
11663 /* pad the neighbor column with spaces */
11664 if (len < max_neighbor_width)
11665 vty_out(vty, "%*s", max_neighbor_width - len,
11666 " ");
11667
11668 atomic_size_t outq_count, inq_count;
11669 outq_count = atomic_load_explicit(
11670 &peer->obuf->count,
11671 memory_order_relaxed);
11672 inq_count = atomic_load_explicit(
11673 &peer->ibuf->count,
11674 memory_order_relaxed);
11675
11676 vty_out(vty, "4 ");
11677 vty_out(vty, ASN_FORMAT_SPACE(bgp->asnotation),
11678 &peer->as);
11679 if (show_wide)
11680 vty_out(vty,
11681 ASN_FORMAT_SPACE(
11682 bgp->asnotation),
11683 peer->change_local_as
11684 ? &peer->change_local_as
11685 : &peer->local_as);
11686 vty_out(vty,
11687 " %9u %9u %8" PRIu64 " %4zu %4zu %8s",
11688 PEER_TOTAL_RX(peer),
11689 PEER_TOTAL_TX(peer),
11690 peer->version[afi][safi], inq_count,
11691 outq_count,
11692 peer_uptime(peer->uptime, timebuf,
11693 BGP_UPTIME_LEN, 0, NULL));
11694
11695 if (peer_established(peer)) {
11696 if (peer->afc_recv[afi][safi]) {
11697 if (CHECK_FLAG(
11698 bgp->flags,
11699 BGP_FLAG_EBGP_REQUIRES_POLICY)
11700 && !bgp_inbound_policy_exists(
11701 peer, filter))
11702 vty_out(vty, " %12s",
11703 "(Policy)");
11704 else
11705 vty_out(vty,
11706 " %12u",
11707 peer->pcount
11708 [afi]
11709 [pfx_rcd_safi]);
11710 } else {
11711 vty_out(vty, " NoNeg");
11712 }
11713
11714 if (paf && PAF_SUBGRP(paf)) {
11715 if (CHECK_FLAG(
11716 bgp->flags,
11717 BGP_FLAG_EBGP_REQUIRES_POLICY)
11718 && !bgp_outbound_policy_exists(
11719 peer, filter))
11720 vty_out(vty, " %8s",
11721 "(Policy)");
11722 else
11723 vty_out(vty,
11724 " %8u",
11725 (PAF_SUBGRP(
11726 paf))
11727 ->scount);
11728 } else {
11729 vty_out(vty, " NoNeg");
11730 }
11731 } else {
11732 if (CHECK_FLAG(peer->flags,
11733 PEER_FLAG_SHUTDOWN)
11734 || CHECK_FLAG(peer->bgp->flags,
11735 BGP_FLAG_SHUTDOWN))
11736 vty_out(vty, " Idle (Admin)");
11737 else if (CHECK_FLAG(
11738 peer->sflags,
11739 PEER_STATUS_PREFIX_OVERFLOW))
11740 vty_out(vty, " Idle (PfxCt)");
11741 else
11742 vty_out(vty, " %12s",
11743 lookup_msg(bgp_status_msg,
11744 peer->status, NULL));
11745
11746 vty_out(vty, " %8u", 0);
11747 }
11748 /* Make sure `Desc` column is the lastest in
11749 * the output.
11750 */
11751 if (peer->desc)
11752 vty_out(vty, " %s",
11753 bgp_peer_description_stripped(
11754 peer->desc,
11755 show_wide ? 64 : 20));
11756 else
11757 vty_out(vty, " N/A");
11758 vty_out(vty, "\n");
11759 }
11760
11761 }
11762 }
11763
11764 if (use_json) {
11765 json_object_object_add(json, "peers", json_peers);
11766 json_object_int_add(json, "failedPeers", failed_count);
11767 json_object_int_add(json, "displayedPeers",
11768 count - filtered_count);
11769 json_object_int_add(json, "totalPeers", count);
11770 json_object_int_add(json, "dynamicPeers", dn_count);
11771
11772 if (!show_failed)
11773 bgp_show_bestpath_json(bgp, json);
11774
11775 vty_json(vty, json);
11776 } else {
11777 if (count) {
11778 if (filtered_count == count)
11779 vty_out(vty, "\n%% No matching neighbor\n");
11780 else {
11781 if (show_failed)
11782 vty_out(vty, "\nDisplayed neighbors %d",
11783 failed_count);
11784 else if (as_type != AS_UNSPECIFIED || as
11785 || fpeer || show_established)
11786 vty_out(vty, "\nDisplayed neighbors %d",
11787 count - filtered_count);
11788
11789 vty_out(vty, "\nTotal number of neighbors %d\n",
11790 count);
11791 }
11792 } else {
11793 vty_out(vty, "No %s neighbor is configured\n",
11794 get_afi_safi_str(afi, safi, false));
11795 }
11796
11797 if (dn_count) {
11798 vty_out(vty, "* - dynamic neighbor\n");
11799 vty_out(vty, "%d dynamic neighbor(s), limit %d\n",
11800 dn_count, bgp->dynamic_neighbors_limit);
11801 }
11802 }
11803
11804 return CMD_SUCCESS;
11805 }
11806
11807 static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
11808 int safi, struct peer *fpeer, int as_type,
11809 as_t as, uint16_t show_flags)
11810 {
11811 int is_first = 1;
11812 int afi_wildcard = (afi == AFI_MAX);
11813 int safi_wildcard = (safi == SAFI_MAX);
11814 int is_wildcard = (afi_wildcard || safi_wildcard);
11815 bool nbr_output = false;
11816 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11817
11818 if (use_json && is_wildcard)
11819 vty_out(vty, "{\n");
11820 if (afi_wildcard)
11821 afi = 1; /* AFI_IP */
11822 while (afi < AFI_MAX) {
11823 if (safi_wildcard)
11824 safi = 1; /* SAFI_UNICAST */
11825 while (safi < SAFI_MAX) {
11826 if (bgp_afi_safi_peer_exists(bgp, afi, safi)) {
11827 nbr_output = true;
11828
11829 if (is_wildcard) {
11830 /*
11831 * So limit output to those afi/safi
11832 * pairs that
11833 * actualy have something interesting in
11834 * them
11835 */
11836 if (use_json) {
11837 if (!is_first)
11838 vty_out(vty, ",\n");
11839 else
11840 is_first = 0;
11841
11842 vty_out(vty, "\"%s\":",
11843 get_afi_safi_str(afi,
11844 safi,
11845 true));
11846 } else {
11847 vty_out(vty,
11848 "\n%s Summary (%s):\n",
11849 get_afi_safi_str(afi,
11850 safi,
11851 false),
11852 bgp->name_pretty);
11853 }
11854 }
11855 bgp_show_summary(vty, bgp, afi, safi, fpeer,
11856 as_type, as, show_flags);
11857 }
11858 safi++;
11859 if (!safi_wildcard)
11860 safi = SAFI_MAX;
11861 }
11862 afi++;
11863 if (!afi_wildcard)
11864 afi = AFI_MAX;
11865 }
11866
11867 if (use_json && is_wildcard)
11868 vty_out(vty, "}\n");
11869 else if (!nbr_output) {
11870 if (use_json)
11871 vty_out(vty, "{}\n");
11872 else
11873 vty_out(vty, "%% No BGP neighbors found in %s\n",
11874 bgp->name_pretty);
11875 }
11876 }
11877
11878 static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
11879 safi_t safi,
11880 const char *neighbor,
11881 int as_type, as_t as,
11882 uint16_t show_flags)
11883 {
11884 struct listnode *node, *nnode;
11885 struct bgp *bgp;
11886 struct peer *fpeer = NULL;
11887 int is_first = 1;
11888 bool nbr_output = false;
11889 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11890
11891 if (use_json)
11892 vty_out(vty, "{\n");
11893
11894 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
11895 nbr_output = true;
11896 if (use_json) {
11897 if (!is_first)
11898 vty_out(vty, ",\n");
11899 else
11900 is_first = 0;
11901
11902 vty_out(vty, "\"%s\":",
11903 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11904 ? VRF_DEFAULT_NAME
11905 : bgp->name);
11906 }
11907 if (neighbor) {
11908 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11909 use_json);
11910 if (!fpeer)
11911 continue;
11912 }
11913 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer, as_type,
11914 as, show_flags);
11915 }
11916
11917 if (use_json)
11918 vty_out(vty, "}\n");
11919 else if (!nbr_output)
11920 vty_out(vty, "%% BGP instance not found\n");
11921 }
11922
11923 int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
11924 safi_t safi, const char *neighbor, int as_type,
11925 as_t as, uint16_t show_flags)
11926 {
11927 struct bgp *bgp;
11928 bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
11929 struct peer *fpeer = NULL;
11930
11931 if (name) {
11932 if (strmatch(name, "all")) {
11933 bgp_show_all_instances_summary_vty(vty, afi, safi,
11934 neighbor, as_type,
11935 as, show_flags);
11936 return CMD_SUCCESS;
11937 } else {
11938 bgp = bgp_lookup_by_name(name);
11939
11940 if (!bgp) {
11941 if (use_json)
11942 vty_out(vty, "{}\n");
11943 else
11944 vty_out(vty,
11945 "%% BGP instance not found\n");
11946 return CMD_WARNING;
11947 }
11948
11949 if (neighbor) {
11950 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11951 use_json);
11952 if (!fpeer)
11953 return CMD_WARNING;
11954 }
11955 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer,
11956 as_type, as, show_flags);
11957 return CMD_SUCCESS;
11958 }
11959 }
11960
11961 bgp = bgp_get_default();
11962
11963 if (bgp) {
11964 if (neighbor) {
11965 fpeer = peer_lookup_in_view(vty, bgp, neighbor,
11966 use_json);
11967 if (!fpeer)
11968 return CMD_WARNING;
11969 }
11970 bgp_show_summary_afi_safi(vty, bgp, afi, safi, fpeer, as_type,
11971 as, show_flags);
11972 } else {
11973 if (use_json)
11974 vty_out(vty, "{}\n");
11975 else
11976 vty_out(vty, "%% BGP instance not found\n");
11977 return CMD_WARNING;
11978 }
11979
11980 return CMD_SUCCESS;
11981 }
11982
11983 /* `show [ip] bgp summary' commands. */
11984 DEFPY(show_ip_bgp_summary, show_ip_bgp_summary_cmd,
11985 "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR
11986 " [" BGP_SAFI_WITH_LABEL_CMD_STR
11987 "]] [all$all] summary [established|failed] [<neighbor <A.B.C.D|X:X::X:X|WORD>|remote-as <ASNUM|internal|external>>] [terse] [wide] [json$uj]",
11988 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
11989 BGP_SAFI_WITH_LABEL_HELP_STR
11990 "Display the entries for all address families\n"
11991 "Summary of BGP neighbor status\n"
11992 "Show only sessions in Established state\n"
11993 "Show only sessions not in Established state\n"
11994 "Show only the specified neighbor session\n"
11995 "Neighbor to display information about\n"
11996 "Neighbor to display information about\n"
11997 "Neighbor on BGP configured interface\n"
11998 "Show only the specified remote AS sessions\n" AS_STR
11999 "Internal (iBGP) AS sessions\n"
12000 "External (eBGP) AS sessions\n"
12001 "Shorten the information on BGP instances\n"
12002 "Increase table width for longer output\n" JSON_STR)
12003 {
12004 char *vrf = NULL;
12005 afi_t afi = AFI_MAX;
12006 safi_t safi = SAFI_MAX;
12007 as_t as = 0; /* 0 means AS filter not set */
12008 int as_type = AS_UNSPECIFIED;
12009 uint16_t show_flags = 0;
12010
12011 int idx = 0;
12012
12013 /* show [ip] bgp */
12014 if (!all && argv_find(argv, argc, "ip", &idx))
12015 afi = AFI_IP;
12016 /* [<vrf> VIEWVRFNAME] */
12017 if (argv_find(argv, argc, "vrf", &idx)) {
12018 vrf = argv[idx + 1]->arg;
12019 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
12020 vrf = NULL;
12021 } else if (argv_find(argv, argc, "view", &idx))
12022 /* [<view> VIEWVRFNAME] */
12023 vrf = argv[idx + 1]->arg;
12024 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
12025 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
12026 argv_find_and_parse_safi(argv, argc, &idx, &safi);
12027 }
12028
12029 if (argv_find(argv, argc, "failed", &idx))
12030 SET_FLAG(show_flags, BGP_SHOW_OPT_FAILED);
12031
12032 if (argv_find(argv, argc, "established", &idx))
12033 SET_FLAG(show_flags, BGP_SHOW_OPT_ESTABLISHED);
12034
12035 if (argv_find(argv, argc, "remote-as", &idx)) {
12036 if (argv[idx + 1]->arg[0] == 'i')
12037 as_type = AS_INTERNAL;
12038 else if (argv[idx + 1]->arg[0] == 'e')
12039 as_type = AS_EXTERNAL;
12040 else if (!asn_str2asn(argv[idx + 1]->arg, &as)) {
12041 vty_out(vty,
12042 "%% Invalid neighbor remote-as value: %s\n",
12043 argv[idx + 1]->arg);
12044 return CMD_SUCCESS;
12045 }
12046 }
12047
12048 if (argv_find(argv, argc, "terse", &idx))
12049 SET_FLAG(show_flags, BGP_SHOW_OPT_TERSE);
12050
12051 if (argv_find(argv, argc, "wide", &idx))
12052 SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
12053
12054 if (argv_find(argv, argc, "json", &idx))
12055 SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
12056
12057 return bgp_show_summary_vty(vty, vrf, afi, safi, neighbor, as_type, as,
12058 show_flags);
12059 }
12060
12061 const char *get_afi_safi_str(afi_t afi, safi_t safi, bool for_json)
12062 {
12063 if (for_json)
12064 return get_afi_safi_json_str(afi, safi);
12065 else
12066 return get_afi_safi_vty_str(afi, safi);
12067 }
12068
12069
12070 static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
12071 afi_t afi, safi_t safi,
12072 uint16_t adv_smcap, uint16_t adv_rmcap,
12073 uint16_t rcv_smcap, uint16_t rcv_rmcap,
12074 bool use_json, json_object *json_pref)
12075 {
12076 /* Send-Mode */
12077 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
12078 || CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap)) {
12079 if (use_json) {
12080 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
12081 && CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
12082 json_object_string_add(json_pref, "sendMode",
12083 "advertisedAndReceived");
12084 else if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
12085 json_object_string_add(json_pref, "sendMode",
12086 "advertised");
12087 else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
12088 json_object_string_add(json_pref, "sendMode",
12089 "received");
12090 } else {
12091 vty_out(vty, " Send-mode: ");
12092 if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
12093 vty_out(vty, "advertised");
12094 if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
12095 vty_out(vty, "%sreceived",
12096 CHECK_FLAG(p->af_cap[afi][safi],
12097 adv_smcap)
12098 ? ", "
12099 : "");
12100 vty_out(vty, "\n");
12101 }
12102 }
12103
12104 /* Receive-Mode */
12105 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
12106 || CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap)) {
12107 if (use_json) {
12108 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
12109 && CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
12110 json_object_string_add(json_pref, "recvMode",
12111 "advertisedAndReceived");
12112 else if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
12113 json_object_string_add(json_pref, "recvMode",
12114 "advertised");
12115 else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
12116 json_object_string_add(json_pref, "recvMode",
12117 "received");
12118 } else {
12119 vty_out(vty, " Receive-mode: ");
12120 if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
12121 vty_out(vty, "advertised");
12122 if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
12123 vty_out(vty, "%sreceived",
12124 CHECK_FLAG(p->af_cap[afi][safi],
12125 adv_rmcap)
12126 ? ", "
12127 : "");
12128 vty_out(vty, "\n");
12129 }
12130 }
12131 }
12132
12133 static void bgp_show_neighnor_graceful_restart_flags(struct vty *vty,
12134 struct peer *p,
12135 json_object *json)
12136 {
12137 bool rbit = false;
12138 bool nbit = false;
12139
12140 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)
12141 && (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
12142 && (peer_established(p))) {
12143 rbit = CHECK_FLAG(p->cap, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV);
12144 nbit = CHECK_FLAG(p->cap, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV);
12145 }
12146
12147 if (json) {
12148 json_object_boolean_add(json, "rBit", rbit);
12149 json_object_boolean_add(json, "nBit", nbit);
12150 } else {
12151 vty_out(vty, "\n R bit: %s", rbit ? "True" : "False");
12152 vty_out(vty, "\n N bit: %s\n", nbit ? "True" : "False");
12153 }
12154 }
12155
12156 static void bgp_show_neighbor_graceful_restart_remote_mode(struct vty *vty,
12157 struct peer *peer,
12158 json_object *json)
12159 {
12160 const char *mode = "NotApplicable";
12161
12162 if (!json)
12163 vty_out(vty, "\n Remote GR Mode: ");
12164
12165 if (CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV)
12166 && (peer_established(peer))) {
12167
12168 if ((peer->nsf_af_count == 0)
12169 && !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
12170
12171 mode = "Disable";
12172
12173 } else if (peer->nsf_af_count == 0
12174 && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
12175
12176 mode = "Helper";
12177
12178 } else if (peer->nsf_af_count != 0
12179 && CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
12180
12181 mode = "Restart";
12182 }
12183 }
12184
12185 if (json)
12186 json_object_string_add(json, "remoteGrMode", mode);
12187 else
12188 vty_out(vty, "%s\n", mode);
12189 }
12190
12191 static void bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
12192 struct peer *p,
12193 json_object *json)
12194 {
12195 const char *mode = "Invalid";
12196
12197 if (!json)
12198 vty_out(vty, " Local GR Mode: ");
12199
12200 if (bgp_peer_gr_mode_get(p) == PEER_HELPER)
12201 mode = "Helper";
12202 else if (bgp_peer_gr_mode_get(p) == PEER_GR)
12203 mode = "Restart";
12204 else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE)
12205 mode = "Disable";
12206 else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT) {
12207 if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_HELPER)
12208 mode = "Helper*";
12209 else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_GR)
12210 mode = "Restart*";
12211 else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_DISABLE)
12212 mode = "Disable*";
12213 else
12214 mode = "Invalid*";
12215 }
12216
12217 if (json)
12218 json_object_string_add(json, "localGrMode", mode);
12219 else
12220 vty_out(vty, "%s\n", mode);
12221 }
12222
12223 static void bgp_show_neighbor_graceful_restart_capability_per_afi_safi(
12224 struct vty *vty, struct peer *peer, json_object *json)
12225 {
12226 afi_t afi;
12227 safi_t safi;
12228 json_object *json_afi_safi = NULL;
12229 json_object *json_timer = NULL;
12230 json_object *json_endofrib_status = NULL;
12231 bool eor_flag = false;
12232
12233 FOREACH_AFI_SAFI_NSF (afi, safi) {
12234 if (!peer->afc[afi][safi])
12235 continue;
12236
12237 if (!CHECK_FLAG(peer->cap, PEER_CAP_RESTART_ADV) ||
12238 !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV))
12239 continue;
12240
12241 if (json) {
12242 json_afi_safi = json_object_new_object();
12243 json_endofrib_status = json_object_new_object();
12244 json_timer = json_object_new_object();
12245 }
12246
12247 if (peer->eor_stime[afi][safi] >= peer->pkt_stime[afi][safi])
12248 eor_flag = true;
12249 else
12250 eor_flag = false;
12251
12252 if (!json) {
12253 vty_out(vty, " %s:\n",
12254 get_afi_safi_str(afi, safi, false));
12255
12256 vty_out(vty, " F bit: ");
12257 }
12258
12259 if (peer->nsf[afi][safi] &&
12260 CHECK_FLAG(peer->af_cap[afi][safi],
12261 PEER_CAP_RESTART_AF_PRESERVE_RCV)) {
12262
12263 if (json) {
12264 json_object_boolean_true_add(json_afi_safi,
12265 "fBit");
12266 } else
12267 vty_out(vty, "True\n");
12268 } else {
12269 if (json)
12270 json_object_boolean_false_add(json_afi_safi,
12271 "fBit");
12272 else
12273 vty_out(vty, "False\n");
12274 }
12275
12276 if (!json)
12277 vty_out(vty, " End-of-RIB sent: ");
12278
12279 if (CHECK_FLAG(peer->af_sflags[afi][safi],
12280 PEER_STATUS_EOR_SEND)) {
12281 if (json) {
12282 json_object_boolean_true_add(
12283 json_endofrib_status, "endOfRibSend");
12284
12285 PRINT_EOR_JSON(eor_flag);
12286 } else {
12287 vty_out(vty, "Yes\n");
12288 vty_out(vty,
12289 " End-of-RIB sent after update: ");
12290
12291 PRINT_EOR(eor_flag);
12292 }
12293 } else {
12294 if (json) {
12295 json_object_boolean_false_add(
12296 json_endofrib_status, "endOfRibSend");
12297 json_object_boolean_false_add(
12298 json_endofrib_status,
12299 "endOfRibSentAfterUpdate");
12300 } else {
12301 vty_out(vty, "No\n");
12302 vty_out(vty,
12303 " End-of-RIB sent after update: ");
12304 vty_out(vty, "No\n");
12305 }
12306 }
12307
12308 if (!json)
12309 vty_out(vty, " End-of-RIB received: ");
12310
12311 if (CHECK_FLAG(peer->af_sflags[afi][safi],
12312 PEER_STATUS_EOR_RECEIVED)) {
12313 if (json)
12314 json_object_boolean_true_add(
12315 json_endofrib_status, "endOfRibRecv");
12316 else
12317 vty_out(vty, "Yes\n");
12318 } else {
12319 if (json)
12320 json_object_boolean_false_add(
12321 json_endofrib_status, "endOfRibRecv");
12322 else
12323 vty_out(vty, "No\n");
12324 }
12325
12326 if (json) {
12327 json_object_int_add(json_timer, "stalePathTimer",
12328 peer->bgp->stalepath_time);
12329
12330 if (peer->t_gr_stale != NULL) {
12331 json_object_int_add(json_timer,
12332 "stalePathTimerRemaining",
12333 thread_timer_remain_second(
12334 peer->t_gr_stale));
12335 }
12336
12337 /* Display Configured Selection
12338 * Deferral only when when
12339 * Gr mode is enabled.
12340 */
12341 if (CHECK_FLAG(peer->flags,
12342 PEER_FLAG_GRACEFUL_RESTART)) {
12343 json_object_int_add(json_timer,
12344 "selectionDeferralTimer",
12345 peer->bgp->stalepath_time);
12346 }
12347
12348 if (peer->bgp->gr_info[afi][safi].t_select_deferral !=
12349 NULL) {
12350
12351 json_object_int_add(
12352 json_timer,
12353 "selectionDeferralTimerRemaining",
12354 thread_timer_remain_second(
12355 peer->bgp->gr_info[afi][safi]
12356 .t_select_deferral));
12357 }
12358 } else {
12359 vty_out(vty, " Timers:\n");
12360 vty_out(vty,
12361 " Configured Stale Path Time(sec): %u\n",
12362 peer->bgp->stalepath_time);
12363
12364 if (peer->t_gr_stale != NULL)
12365 vty_out(vty,
12366 " Stale Path Remaining(sec): %ld\n",
12367 thread_timer_remain_second(
12368 peer->t_gr_stale));
12369 /* Display Configured Selection
12370 * Deferral only when when
12371 * Gr mode is enabled.
12372 */
12373 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
12374 vty_out(vty,
12375 " Configured Selection Deferral Time(sec): %u\n",
12376 peer->bgp->select_defer_time);
12377
12378 if (peer->bgp->gr_info[afi][safi].t_select_deferral !=
12379 NULL)
12380 vty_out(vty,
12381 " Selection Deferral Time Remaining(sec): %ld\n",
12382 thread_timer_remain_second(
12383 peer->bgp->gr_info[afi][safi]
12384 .t_select_deferral));
12385 }
12386 if (json) {
12387 json_object_object_add(json_afi_safi, "endOfRibStatus",
12388 json_endofrib_status);
12389 json_object_object_add(json_afi_safi, "timers",
12390 json_timer);
12391 json_object_object_add(
12392 json, get_afi_safi_str(afi, safi, true),
12393 json_afi_safi);
12394 }
12395 }
12396 }
12397
12398 static void bgp_show_neighbor_graceful_restart_time(struct vty *vty,
12399 struct peer *p,
12400 json_object *json)
12401 {
12402 if (json) {
12403 json_object *json_timer = NULL;
12404
12405 json_timer = json_object_new_object();
12406
12407 json_object_int_add(json_timer, "configuredRestartTimer",
12408 p->bgp->restart_time);
12409
12410 json_object_int_add(json_timer, "receivedRestartTimer",
12411 p->v_gr_restart);
12412
12413 if (p->t_gr_restart != NULL)
12414 json_object_int_add(
12415 json_timer, "restartTimerRemaining",
12416 thread_timer_remain_second(p->t_gr_restart));
12417
12418 json_object_object_add(json, "timers", json_timer);
12419 } else {
12420
12421 vty_out(vty, " Timers:\n");
12422 vty_out(vty, " Configured Restart Time(sec): %u\n",
12423 p->bgp->restart_time);
12424
12425 vty_out(vty, " Received Restart Time(sec): %u\n",
12426 p->v_gr_restart);
12427 if (p->t_gr_restart != NULL)
12428 vty_out(vty, " Restart Time Remaining(sec): %ld\n",
12429 thread_timer_remain_second(p->t_gr_restart));
12430 if (p->t_gr_restart != NULL) {
12431 vty_out(vty, " Restart Time Remaining(sec): %ld\n",
12432 thread_timer_remain_second(p->t_gr_restart));
12433 }
12434 }
12435 }
12436
12437 static void bgp_show_peer_gr_status(struct vty *vty, struct peer *p,
12438 json_object *json)
12439 {
12440 char dn_flag[2] = {0};
12441 /* '*' + v6 address of neighbor */
12442 char neighborAddr[INET6_ADDRSTRLEN + 1] = {0};
12443
12444 if (!p->conf_if && peer_dynamic_neighbor(p))
12445 dn_flag[0] = '*';
12446
12447 if (p->conf_if) {
12448 if (json)
12449 json_object_string_addf(json, "neighborAddr", "%pSU",
12450 &p->su);
12451 else
12452 vty_out(vty, "BGP neighbor on %s: %pSU\n", p->conf_if,
12453 &p->su);
12454 } else {
12455 snprintf(neighborAddr, sizeof(neighborAddr), "%s%s", dn_flag,
12456 p->host);
12457
12458 if (json)
12459 json_object_string_add(json, "neighborAddr",
12460 neighborAddr);
12461 else
12462 vty_out(vty, "BGP neighbor is %s\n", neighborAddr);
12463 }
12464
12465 /* more gr info in new format */
12466 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, json);
12467 }
12468
12469 static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
12470 safi_t safi, bool use_json,
12471 json_object *json_neigh)
12472 {
12473 struct bgp_filter *filter;
12474 struct peer_af *paf;
12475 char orf_pfx_name[BUFSIZ];
12476 int orf_pfx_count;
12477 json_object *json_af = NULL;
12478 json_object *json_prefA = NULL;
12479 json_object *json_prefB = NULL;
12480 json_object *json_addr = NULL;
12481 json_object *json_advmap = NULL;
12482
12483 if (use_json) {
12484 json_addr = json_object_new_object();
12485 json_af = json_object_new_object();
12486 filter = &p->filter[afi][safi];
12487
12488 if (peer_group_active(p))
12489 json_object_string_add(json_addr, "peerGroupMember",
12490 p->group->name);
12491
12492 paf = peer_af_find(p, afi, safi);
12493 if (paf && PAF_SUBGRP(paf)) {
12494 json_object_int_add(json_addr, "updateGroupId",
12495 PAF_UPDGRP(paf)->id);
12496 json_object_int_add(json_addr, "subGroupId",
12497 PAF_SUBGRP(paf)->id);
12498 json_object_int_add(json_addr, "packetQueueLength",
12499 bpacket_queue_virtual_length(paf));
12500 }
12501
12502 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12503 || CHECK_FLAG(p->af_cap[afi][safi],
12504 PEER_CAP_ORF_PREFIX_SM_RCV)
12505 || CHECK_FLAG(p->af_cap[afi][safi],
12506 PEER_CAP_ORF_PREFIX_RM_ADV)
12507 || CHECK_FLAG(p->af_cap[afi][safi],
12508 PEER_CAP_ORF_PREFIX_RM_RCV)) {
12509 json_object_int_add(json_af, "orfType",
12510 ORF_TYPE_PREFIX);
12511 json_prefA = json_object_new_object();
12512 bgp_show_peer_afi_orf_cap(vty, p, afi, safi,
12513 PEER_CAP_ORF_PREFIX_SM_ADV,
12514 PEER_CAP_ORF_PREFIX_RM_ADV,
12515 PEER_CAP_ORF_PREFIX_SM_RCV,
12516 PEER_CAP_ORF_PREFIX_RM_RCV,
12517 use_json, json_prefA);
12518 json_object_object_add(json_af, "orfPrefixList",
12519 json_prefA);
12520 }
12521
12522 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12523 || CHECK_FLAG(p->af_cap[afi][safi],
12524 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12525 || CHECK_FLAG(p->af_cap[afi][safi],
12526 PEER_CAP_ORF_PREFIX_RM_ADV)
12527 || CHECK_FLAG(p->af_cap[afi][safi],
12528 PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
12529 json_object_int_add(json_af, "orfOldType",
12530 ORF_TYPE_PREFIX_OLD);
12531 json_prefB = json_object_new_object();
12532 bgp_show_peer_afi_orf_cap(
12533 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12534 PEER_CAP_ORF_PREFIX_RM_ADV,
12535 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
12536 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json,
12537 json_prefB);
12538 json_object_object_add(json_af, "orfOldPrefixList",
12539 json_prefB);
12540 }
12541
12542 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12543 || CHECK_FLAG(p->af_cap[afi][safi],
12544 PEER_CAP_ORF_PREFIX_SM_RCV)
12545 || CHECK_FLAG(p->af_cap[afi][safi],
12546 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12547 || CHECK_FLAG(p->af_cap[afi][safi],
12548 PEER_CAP_ORF_PREFIX_RM_ADV)
12549 || CHECK_FLAG(p->af_cap[afi][safi],
12550 PEER_CAP_ORF_PREFIX_RM_RCV)
12551 || CHECK_FLAG(p->af_cap[afi][safi],
12552 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
12553 json_object_object_add(json_addr, "afDependentCap",
12554 json_af);
12555 else
12556 json_object_free(json_af);
12557
12558 snprintf(orf_pfx_name, sizeof(orf_pfx_name), "%s.%d.%d",
12559 p->host, afi, safi);
12560 orf_pfx_count = prefix_bgp_show_prefix_list(
12561 NULL, afi, orf_pfx_name, use_json);
12562
12563 if (CHECK_FLAG(p->af_sflags[afi][safi],
12564 PEER_STATUS_ORF_PREFIX_SEND)
12565 || orf_pfx_count) {
12566 if (CHECK_FLAG(p->af_sflags[afi][safi],
12567 PEER_STATUS_ORF_PREFIX_SEND))
12568 json_object_boolean_true_add(json_neigh,
12569 "orfSent");
12570 if (orf_pfx_count)
12571 json_object_int_add(json_addr, "orfRecvCounter",
12572 orf_pfx_count);
12573 }
12574 if (CHECK_FLAG(p->af_sflags[afi][safi],
12575 PEER_STATUS_ORF_WAIT_REFRESH))
12576 json_object_string_add(
12577 json_addr, "orfFirstUpdate",
12578 "deferredUntilORFOrRouteRefreshRecvd");
12579
12580 if (CHECK_FLAG(p->af_flags[afi][safi],
12581 PEER_FLAG_REFLECTOR_CLIENT))
12582 json_object_boolean_true_add(json_addr,
12583 "routeReflectorClient");
12584 if (CHECK_FLAG(p->af_flags[afi][safi],
12585 PEER_FLAG_RSERVER_CLIENT))
12586 json_object_boolean_true_add(json_addr,
12587 "routeServerClient");
12588 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
12589 json_object_boolean_true_add(json_addr,
12590 "inboundSoftConfigPermit");
12591
12592 if (CHECK_FLAG(p->af_flags[afi][safi],
12593 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
12594 json_object_boolean_true_add(
12595 json_addr,
12596 "privateAsNumsAllReplacedInUpdatesToNbr");
12597 else if (CHECK_FLAG(p->af_flags[afi][safi],
12598 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
12599 json_object_boolean_true_add(
12600 json_addr,
12601 "privateAsNumsReplacedInUpdatesToNbr");
12602 else if (CHECK_FLAG(p->af_flags[afi][safi],
12603 PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
12604 json_object_boolean_true_add(
12605 json_addr,
12606 "privateAsNumsAllRemovedInUpdatesToNbr");
12607 else if (CHECK_FLAG(p->af_flags[afi][safi],
12608 PEER_FLAG_REMOVE_PRIVATE_AS))
12609 json_object_boolean_true_add(
12610 json_addr,
12611 "privateAsNumsRemovedInUpdatesToNbr");
12612
12613 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN)) {
12614 if (CHECK_FLAG(p->af_flags[afi][safi],
12615 PEER_FLAG_ALLOWAS_IN_ORIGIN))
12616 json_object_boolean_true_add(json_addr,
12617 "allowAsInOrigin");
12618 else
12619 json_object_int_add(json_addr, "allowAsInCount",
12620 p->allowas_in[afi][safi]);
12621 }
12622
12623 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
12624 json_object_boolean_true_add(
12625 json_addr,
12626 bgp_addpath_names(p->addpath_type[afi][safi])
12627 ->type_json_name);
12628
12629 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
12630 json_object_string_add(json_addr,
12631 "overrideASNsInOutboundUpdates",
12632 "ifAspathEqualRemoteAs");
12633
12634 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
12635 || CHECK_FLAG(p->af_flags[afi][safi],
12636 PEER_FLAG_FORCE_NEXTHOP_SELF))
12637 json_object_boolean_true_add(json_addr,
12638 "routerAlwaysNextHop");
12639 if (CHECK_FLAG(p->af_flags[afi][safi],
12640 PEER_FLAG_AS_PATH_UNCHANGED))
12641 json_object_boolean_true_add(
12642 json_addr, "unchangedAsPathPropogatedToNbr");
12643 if (CHECK_FLAG(p->af_flags[afi][safi],
12644 PEER_FLAG_NEXTHOP_UNCHANGED))
12645 json_object_boolean_true_add(
12646 json_addr, "unchangedNextHopPropogatedToNbr");
12647 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
12648 json_object_boolean_true_add(
12649 json_addr, "unchangedMedPropogatedToNbr");
12650 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
12651 || CHECK_FLAG(p->af_flags[afi][safi],
12652 PEER_FLAG_SEND_EXT_COMMUNITY)) {
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 json_object_string_add(json_addr,
12658 "commAttriSentToNbr",
12659 "extendedAndStandard");
12660 else if (CHECK_FLAG(p->af_flags[afi][safi],
12661 PEER_FLAG_SEND_EXT_COMMUNITY))
12662 json_object_string_add(json_addr,
12663 "commAttriSentToNbr",
12664 "extended");
12665 else
12666 json_object_string_add(json_addr,
12667 "commAttriSentToNbr",
12668 "standard");
12669 }
12670 if (CHECK_FLAG(p->af_flags[afi][safi],
12671 PEER_FLAG_DEFAULT_ORIGINATE)) {
12672 if (p->default_rmap[afi][safi].name)
12673 json_object_string_add(
12674 json_addr, "defaultRouteMap",
12675 p->default_rmap[afi][safi].name);
12676
12677 if (paf && PAF_SUBGRP(paf)
12678 && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
12679 SUBGRP_STATUS_DEFAULT_ORIGINATE))
12680 json_object_boolean_true_add(json_addr,
12681 "defaultSent");
12682 else
12683 json_object_boolean_true_add(json_addr,
12684 "defaultNotSent");
12685 }
12686
12687 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
12688 if (is_evpn_enabled())
12689 json_object_boolean_true_add(
12690 json_addr, "advertiseAllVnis");
12691 }
12692
12693 if (filter->plist[FILTER_IN].name
12694 || filter->dlist[FILTER_IN].name
12695 || filter->aslist[FILTER_IN].name
12696 || filter->map[RMAP_IN].name)
12697 json_object_boolean_true_add(json_addr,
12698 "inboundPathPolicyConfig");
12699 if (filter->plist[FILTER_OUT].name
12700 || filter->dlist[FILTER_OUT].name
12701 || filter->aslist[FILTER_OUT].name
12702 || filter->map[RMAP_OUT].name || filter->usmap.name)
12703 json_object_boolean_true_add(
12704 json_addr, "outboundPathPolicyConfig");
12705
12706 /* prefix-list */
12707 if (filter->plist[FILTER_IN].name)
12708 json_object_string_add(json_addr,
12709 "incomingUpdatePrefixFilterList",
12710 filter->plist[FILTER_IN].name);
12711 if (filter->plist[FILTER_OUT].name)
12712 json_object_string_add(json_addr,
12713 "outgoingUpdatePrefixFilterList",
12714 filter->plist[FILTER_OUT].name);
12715
12716 /* distribute-list */
12717 if (filter->dlist[FILTER_IN].name)
12718 json_object_string_add(
12719 json_addr, "incomingUpdateNetworkFilterList",
12720 filter->dlist[FILTER_IN].name);
12721 if (filter->dlist[FILTER_OUT].name)
12722 json_object_string_add(
12723 json_addr, "outgoingUpdateNetworkFilterList",
12724 filter->dlist[FILTER_OUT].name);
12725
12726 /* filter-list. */
12727 if (filter->aslist[FILTER_IN].name)
12728 json_object_string_add(json_addr,
12729 "incomingUpdateAsPathFilterList",
12730 filter->aslist[FILTER_IN].name);
12731 if (filter->aslist[FILTER_OUT].name)
12732 json_object_string_add(json_addr,
12733 "outgoingUpdateAsPathFilterList",
12734 filter->aslist[FILTER_OUT].name);
12735
12736 /* route-map. */
12737 if (filter->map[RMAP_IN].name)
12738 json_object_string_add(
12739 json_addr, "routeMapForIncomingAdvertisements",
12740 filter->map[RMAP_IN].name);
12741 if (filter->map[RMAP_OUT].name)
12742 json_object_string_add(
12743 json_addr, "routeMapForOutgoingAdvertisements",
12744 filter->map[RMAP_OUT].name);
12745
12746 /* ebgp-requires-policy (inbound) */
12747 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12748 && !bgp_inbound_policy_exists(p, filter))
12749 json_object_string_add(
12750 json_addr, "inboundEbgpRequiresPolicy",
12751 "Inbound updates discarded due to missing policy");
12752
12753 /* ebgp-requires-policy (outbound) */
12754 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
12755 && (!bgp_outbound_policy_exists(p, filter)))
12756 json_object_string_add(
12757 json_addr, "outboundEbgpRequiresPolicy",
12758 "Outbound updates discarded due to missing policy");
12759
12760 /* unsuppress-map */
12761 if (filter->usmap.name)
12762 json_object_string_add(json_addr,
12763 "selectiveUnsuppressRouteMap",
12764 filter->usmap.name);
12765
12766 /* advertise-map */
12767 if (filter->advmap.aname) {
12768 json_advmap = json_object_new_object();
12769 json_object_string_add(json_advmap, "condition",
12770 filter->advmap.condition
12771 ? "EXIST"
12772 : "NON_EXIST");
12773 json_object_string_add(json_advmap, "conditionMap",
12774 filter->advmap.cname);
12775 json_object_string_add(json_advmap, "advertiseMap",
12776 filter->advmap.aname);
12777 json_object_string_add(
12778 json_advmap, "advertiseStatus",
12779 filter->advmap.update_type ==
12780 UPDATE_TYPE_ADVERTISE
12781 ? "Advertise"
12782 : "Withdraw");
12783 json_object_object_add(json_addr, "advertiseMap",
12784 json_advmap);
12785 }
12786
12787 /* Receive prefix count */
12788 json_object_int_add(json_addr, "acceptedPrefixCounter",
12789 p->pcount[afi][safi]);
12790 if (paf && PAF_SUBGRP(paf))
12791 json_object_int_add(json_addr, "sentPrefixCounter",
12792 (PAF_SUBGRP(paf))->scount);
12793
12794 /* Maximum prefix */
12795 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_OUT))
12796 json_object_int_add(json_addr, "prefixOutAllowedMax",
12797 p->pmax_out[afi][safi]);
12798
12799 /* Maximum prefix */
12800 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
12801 json_object_int_add(json_addr, "prefixAllowedMax",
12802 p->pmax[afi][safi]);
12803 if (CHECK_FLAG(p->af_flags[afi][safi],
12804 PEER_FLAG_MAX_PREFIX_WARNING))
12805 json_object_boolean_true_add(
12806 json_addr, "prefixAllowedMaxWarning");
12807 json_object_int_add(json_addr,
12808 "prefixAllowedWarningThresh",
12809 p->pmax_threshold[afi][safi]);
12810 if (p->pmax_restart[afi][safi])
12811 json_object_int_add(
12812 json_addr,
12813 "prefixAllowedRestartIntervalMsecs",
12814 p->pmax_restart[afi][safi] * 60000);
12815 }
12816 json_object_object_add(json_neigh,
12817 get_afi_safi_str(afi, safi, true),
12818 json_addr);
12819
12820 } else {
12821 filter = &p->filter[afi][safi];
12822
12823 vty_out(vty, " For address family: %s\n",
12824 get_afi_safi_str(afi, safi, false));
12825
12826 if (peer_group_active(p))
12827 vty_out(vty, " %s peer-group member\n",
12828 p->group->name);
12829
12830 paf = peer_af_find(p, afi, safi);
12831 if (paf && PAF_SUBGRP(paf)) {
12832 vty_out(vty, " Update group %" PRIu64", subgroup %" PRIu64 "\n",
12833 PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id);
12834 vty_out(vty, " Packet Queue length %d\n",
12835 bpacket_queue_virtual_length(paf));
12836 } else {
12837 vty_out(vty, " Not part of any update group\n");
12838 }
12839 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12840 || CHECK_FLAG(p->af_cap[afi][safi],
12841 PEER_CAP_ORF_PREFIX_SM_RCV)
12842 || CHECK_FLAG(p->af_cap[afi][safi],
12843 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12844 || CHECK_FLAG(p->af_cap[afi][safi],
12845 PEER_CAP_ORF_PREFIX_RM_ADV)
12846 || CHECK_FLAG(p->af_cap[afi][safi],
12847 PEER_CAP_ORF_PREFIX_RM_RCV)
12848 || CHECK_FLAG(p->af_cap[afi][safi],
12849 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
12850 vty_out(vty, " AF-dependant capabilities:\n");
12851
12852 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12853 || CHECK_FLAG(p->af_cap[afi][safi],
12854 PEER_CAP_ORF_PREFIX_SM_RCV)
12855 || CHECK_FLAG(p->af_cap[afi][safi],
12856 PEER_CAP_ORF_PREFIX_RM_ADV)
12857 || CHECK_FLAG(p->af_cap[afi][safi],
12858 PEER_CAP_ORF_PREFIX_RM_RCV)) {
12859 vty_out(vty,
12860 " Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
12861 ORF_TYPE_PREFIX);
12862 bgp_show_peer_afi_orf_cap(
12863 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12864 PEER_CAP_ORF_PREFIX_RM_ADV,
12865 PEER_CAP_ORF_PREFIX_SM_RCV,
12866 PEER_CAP_ORF_PREFIX_RM_RCV, use_json, NULL);
12867 }
12868 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
12869 || CHECK_FLAG(p->af_cap[afi][safi],
12870 PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
12871 || CHECK_FLAG(p->af_cap[afi][safi],
12872 PEER_CAP_ORF_PREFIX_RM_ADV)
12873 || CHECK_FLAG(p->af_cap[afi][safi],
12874 PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
12875 vty_out(vty,
12876 " Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
12877 ORF_TYPE_PREFIX_OLD);
12878 bgp_show_peer_afi_orf_cap(
12879 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
12880 PEER_CAP_ORF_PREFIX_RM_ADV,
12881 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
12882 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, NULL);
12883 }
12884
12885 snprintf(orf_pfx_name, sizeof(orf_pfx_name), "%s.%d.%d",
12886 p->host, afi, safi);
12887 orf_pfx_count = prefix_bgp_show_prefix_list(
12888 NULL, afi, orf_pfx_name, use_json);
12889
12890 if (CHECK_FLAG(p->af_sflags[afi][safi],
12891 PEER_STATUS_ORF_PREFIX_SEND)
12892 || orf_pfx_count) {
12893 vty_out(vty, " Outbound Route Filter (ORF):");
12894 if (CHECK_FLAG(p->af_sflags[afi][safi],
12895 PEER_STATUS_ORF_PREFIX_SEND))
12896 vty_out(vty, " sent;");
12897 if (orf_pfx_count)
12898 vty_out(vty, " received (%d entries)",
12899 orf_pfx_count);
12900 vty_out(vty, "\n");
12901 }
12902 if (CHECK_FLAG(p->af_sflags[afi][safi],
12903 PEER_STATUS_ORF_WAIT_REFRESH))
12904 vty_out(vty,
12905 " First update is deferred until ORF or ROUTE-REFRESH is received\n");
12906
12907 if (CHECK_FLAG(p->af_flags[afi][safi],
12908 PEER_FLAG_REFLECTOR_CLIENT))
12909 vty_out(vty, " Route-Reflector Client\n");
12910 if (CHECK_FLAG(p->af_flags[afi][safi],
12911 PEER_FLAG_RSERVER_CLIENT))
12912 vty_out(vty, " Route-Server Client\n");
12913 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
12914 vty_out(vty,
12915 " Inbound soft reconfiguration allowed\n");
12916
12917 if (CHECK_FLAG(p->af_flags[afi][safi],
12918 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
12919 vty_out(vty,
12920 " Private AS numbers (all) replaced in updates to this neighbor\n");
12921 else if (CHECK_FLAG(p->af_flags[afi][safi],
12922 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
12923 vty_out(vty,
12924 " Private AS numbers replaced in updates to this neighbor\n");
12925 else if (CHECK_FLAG(p->af_flags[afi][safi],
12926 PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
12927 vty_out(vty,
12928 " Private AS numbers (all) removed in updates to this neighbor\n");
12929 else if (CHECK_FLAG(p->af_flags[afi][safi],
12930 PEER_FLAG_REMOVE_PRIVATE_AS))
12931 vty_out(vty,
12932 " Private AS numbers removed in updates to this neighbor\n");
12933
12934 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN)) {
12935 if (CHECK_FLAG(p->af_flags[afi][safi],
12936 PEER_FLAG_ALLOWAS_IN_ORIGIN))
12937 vty_out(vty,
12938 " Local AS allowed as path origin\n");
12939 else
12940 vty_out(vty,
12941 " Local AS allowed in path, %d occurrences\n",
12942 p->allowas_in[afi][safi]);
12943 }
12944
12945 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
12946 vty_out(vty, " %s\n",
12947 bgp_addpath_names(p->addpath_type[afi][safi])
12948 ->human_description);
12949
12950 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
12951 vty_out(vty,
12952 " Override ASNs in outbound updates if aspath equals remote-as\n");
12953
12954 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
12955 || CHECK_FLAG(p->af_flags[afi][safi],
12956 PEER_FLAG_FORCE_NEXTHOP_SELF))
12957 vty_out(vty, " NEXT_HOP is always this router\n");
12958 if (CHECK_FLAG(p->af_flags[afi][safi],
12959 PEER_FLAG_AS_PATH_UNCHANGED))
12960 vty_out(vty,
12961 " AS_PATH is propagated unchanged to this neighbor\n");
12962 if (CHECK_FLAG(p->af_flags[afi][safi],
12963 PEER_FLAG_NEXTHOP_UNCHANGED))
12964 vty_out(vty,
12965 " NEXT_HOP is propagated unchanged to this neighbor\n");
12966 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
12967 vty_out(vty,
12968 " MED is propagated unchanged to this neighbor\n");
12969 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
12970 || CHECK_FLAG(p->af_flags[afi][safi],
12971 PEER_FLAG_SEND_EXT_COMMUNITY)
12972 || CHECK_FLAG(p->af_flags[afi][safi],
12973 PEER_FLAG_SEND_LARGE_COMMUNITY)) {
12974 vty_out(vty,
12975 " Community attribute sent to this neighbor");
12976 if (CHECK_FLAG(p->af_flags[afi][safi],
12977 PEER_FLAG_SEND_COMMUNITY)
12978 && CHECK_FLAG(p->af_flags[afi][safi],
12979 PEER_FLAG_SEND_EXT_COMMUNITY)
12980 && CHECK_FLAG(p->af_flags[afi][safi],
12981 PEER_FLAG_SEND_LARGE_COMMUNITY))
12982 vty_out(vty, "(all)\n");
12983 else if (CHECK_FLAG(p->af_flags[afi][safi],
12984 PEER_FLAG_SEND_LARGE_COMMUNITY))
12985 vty_out(vty, "(large)\n");
12986 else if (CHECK_FLAG(p->af_flags[afi][safi],
12987 PEER_FLAG_SEND_EXT_COMMUNITY))
12988 vty_out(vty, "(extended)\n");
12989 else
12990 vty_out(vty, "(standard)\n");
12991 }
12992 if (CHECK_FLAG(p->af_flags[afi][safi],
12993 PEER_FLAG_DEFAULT_ORIGINATE)) {
12994 vty_out(vty, " Default information originate,");
12995
12996 if (p->default_rmap[afi][safi].name)
12997 vty_out(vty, " default route-map %s%s,",
12998 p->default_rmap[afi][safi].map ? "*"
12999 : "",
13000 p->default_rmap[afi][safi].name);
13001 if (paf && PAF_SUBGRP(paf)
13002 && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
13003 SUBGRP_STATUS_DEFAULT_ORIGINATE))
13004 vty_out(vty, " default sent\n");
13005 else
13006 vty_out(vty, " default not sent\n");
13007 }
13008
13009 /* advertise-vni-all */
13010 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
13011 if (is_evpn_enabled())
13012 vty_out(vty, " advertise-all-vni\n");
13013 }
13014
13015 if (filter->plist[FILTER_IN].name
13016 || filter->dlist[FILTER_IN].name
13017 || filter->aslist[FILTER_IN].name
13018 || filter->map[RMAP_IN].name)
13019 vty_out(vty, " Inbound path policy configured\n");
13020 if (filter->plist[FILTER_OUT].name
13021 || filter->dlist[FILTER_OUT].name
13022 || filter->aslist[FILTER_OUT].name
13023 || filter->map[RMAP_OUT].name || filter->usmap.name)
13024 vty_out(vty, " Outbound path policy configured\n");
13025
13026 /* prefix-list */
13027 if (filter->plist[FILTER_IN].name)
13028 vty_out(vty,
13029 " Incoming update prefix filter list is %s%s\n",
13030 filter->plist[FILTER_IN].plist ? "*" : "",
13031 filter->plist[FILTER_IN].name);
13032 if (filter->plist[FILTER_OUT].name)
13033 vty_out(vty,
13034 " Outgoing update prefix filter list is %s%s\n",
13035 filter->plist[FILTER_OUT].plist ? "*" : "",
13036 filter->plist[FILTER_OUT].name);
13037
13038 /* distribute-list */
13039 if (filter->dlist[FILTER_IN].name)
13040 vty_out(vty,
13041 " Incoming update network filter list is %s%s\n",
13042 filter->dlist[FILTER_IN].alist ? "*" : "",
13043 filter->dlist[FILTER_IN].name);
13044 if (filter->dlist[FILTER_OUT].name)
13045 vty_out(vty,
13046 " Outgoing update network filter list is %s%s\n",
13047 filter->dlist[FILTER_OUT].alist ? "*" : "",
13048 filter->dlist[FILTER_OUT].name);
13049
13050 /* filter-list. */
13051 if (filter->aslist[FILTER_IN].name)
13052 vty_out(vty,
13053 " Incoming update AS path filter list is %s%s\n",
13054 filter->aslist[FILTER_IN].aslist ? "*" : "",
13055 filter->aslist[FILTER_IN].name);
13056 if (filter->aslist[FILTER_OUT].name)
13057 vty_out(vty,
13058 " Outgoing update AS path filter list is %s%s\n",
13059 filter->aslist[FILTER_OUT].aslist ? "*" : "",
13060 filter->aslist[FILTER_OUT].name);
13061
13062 /* route-map. */
13063 if (filter->map[RMAP_IN].name)
13064 vty_out(vty,
13065 " Route map for incoming advertisements is %s%s\n",
13066 filter->map[RMAP_IN].map ? "*" : "",
13067 filter->map[RMAP_IN].name);
13068 if (filter->map[RMAP_OUT].name)
13069 vty_out(vty,
13070 " Route map for outgoing advertisements is %s%s\n",
13071 filter->map[RMAP_OUT].map ? "*" : "",
13072 filter->map[RMAP_OUT].name);
13073
13074 /* ebgp-requires-policy (inbound) */
13075 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
13076 && !bgp_inbound_policy_exists(p, filter))
13077 vty_out(vty,
13078 " Inbound updates discarded due to missing policy\n");
13079
13080 /* ebgp-requires-policy (outbound) */
13081 if (CHECK_FLAG(p->bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
13082 && !bgp_outbound_policy_exists(p, filter))
13083 vty_out(vty,
13084 " Outbound updates discarded due to missing policy\n");
13085
13086 /* unsuppress-map */
13087 if (filter->usmap.name)
13088 vty_out(vty,
13089 " Route map for selective unsuppress is %s%s\n",
13090 filter->usmap.map ? "*" : "",
13091 filter->usmap.name);
13092
13093 /* advertise-map */
13094 if (filter->advmap.aname && filter->advmap.cname)
13095 vty_out(vty,
13096 " Condition %s, Condition-map %s%s, Advertise-map %s%s, status: %s\n",
13097 filter->advmap.condition ? "EXIST"
13098 : "NON_EXIST",
13099 filter->advmap.cmap ? "*" : "",
13100 filter->advmap.cname,
13101 filter->advmap.amap ? "*" : "",
13102 filter->advmap.aname,
13103 filter->advmap.update_type ==
13104 UPDATE_TYPE_ADVERTISE
13105 ? "Advertise"
13106 : "Withdraw");
13107
13108 /* Receive prefix count */
13109 vty_out(vty, " %u accepted prefixes\n",
13110 p->pcount[afi][safi]);
13111
13112 /* maximum-prefix-out */
13113 if (CHECK_FLAG(p->af_flags[afi][safi],
13114 PEER_FLAG_MAX_PREFIX_OUT))
13115 vty_out(vty,
13116 " Maximum allowed prefixes sent %u\n",
13117 p->pmax_out[afi][safi]);
13118
13119 /* Maximum prefix */
13120 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
13121 vty_out(vty,
13122 " Maximum prefixes allowed %u%s\n",
13123 p->pmax[afi][safi],
13124 CHECK_FLAG(p->af_flags[afi][safi],
13125 PEER_FLAG_MAX_PREFIX_WARNING)
13126 ? " (warning-only)"
13127 : "");
13128 vty_out(vty, " Threshold for warning message %d%%",
13129 p->pmax_threshold[afi][safi]);
13130 if (p->pmax_restart[afi][safi])
13131 vty_out(vty, ", restart interval %d min",
13132 p->pmax_restart[afi][safi]);
13133 vty_out(vty, "\n");
13134 }
13135
13136 vty_out(vty, "\n");
13137 }
13138 }
13139
13140 static void bgp_show_peer(struct vty *vty, struct peer *p, bool use_json,
13141 json_object *json)
13142 {
13143 struct bgp *bgp;
13144 char timebuf[BGP_UPTIME_LEN];
13145 char dn_flag[2];
13146 afi_t afi;
13147 safi_t safi;
13148 uint16_t i;
13149 uint8_t *msg;
13150 json_object *json_neigh = NULL;
13151 time_t epoch_tbuf;
13152 uint32_t sync_tcp_mss;
13153
13154 bgp = p->bgp;
13155
13156 if (use_json)
13157 json_neigh = json_object_new_object();
13158
13159 memset(dn_flag, '\0', sizeof(dn_flag));
13160 if (!p->conf_if && peer_dynamic_neighbor(p))
13161 dn_flag[0] = '*';
13162
13163 if (!use_json) {
13164 if (p->conf_if) /* Configured interface name. */
13165 vty_out(vty, "BGP neighbor on %s: %pSU, ", p->conf_if,
13166 &p->su);
13167 else /* Configured IP address. */
13168 vty_out(vty, "BGP neighbor is %s%s, ", dn_flag,
13169 p->host);
13170 }
13171
13172 if (use_json) {
13173 if (p->conf_if && BGP_PEER_SU_UNSPEC(p))
13174 json_object_string_add(json_neigh, "bgpNeighborAddr",
13175 "none");
13176 else if (p->conf_if && !BGP_PEER_SU_UNSPEC(p))
13177 json_object_string_addf(json_neigh, "bgpNeighborAddr",
13178 "%pSU", &p->su);
13179
13180 asn_asn2json(json_neigh, "remoteAs", p->as, bgp->asnotation);
13181
13182 if (p->change_local_as)
13183 asn_asn2json(json_neigh, "localAs", p->change_local_as,
13184 bgp->asnotation);
13185 else
13186 asn_asn2json(json_neigh, "localAs", p->local_as,
13187 bgp->asnotation);
13188
13189 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
13190 json_object_boolean_true_add(json_neigh,
13191 "localAsNoPrepend");
13192
13193 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS))
13194 json_object_boolean_true_add(json_neigh,
13195 "localAsReplaceAs");
13196 } else {
13197 if ((p->as_type == AS_SPECIFIED) ||
13198 (p->as_type == AS_EXTERNAL) ||
13199 (p->as_type == AS_INTERNAL)) {
13200 vty_out(vty, "remote AS ");
13201 vty_out(vty, ASN_FORMAT(bgp->asnotation), &p->as);
13202 vty_out(vty, ", ");
13203 } else
13204 vty_out(vty, "remote AS Unspecified, ");
13205 vty_out(vty, "local AS ");
13206 vty_out(vty, ASN_FORMAT(bgp->asnotation),
13207 p->change_local_as ? &p->change_local_as
13208 : &p->local_as);
13209 vty_out(vty, "%s%s, ",
13210 CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND)
13211 ? " no-prepend"
13212 : "",
13213 CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS)
13214 ? " replace-as"
13215 : "");
13216 }
13217 /* peer type internal or confed-internal */
13218 if ((p->as == p->local_as) || (p->as_type == AS_INTERNAL)) {
13219 if (use_json) {
13220 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
13221 json_object_boolean_true_add(
13222 json_neigh, "nbrConfedInternalLink");
13223 else
13224 json_object_boolean_true_add(json_neigh,
13225 "nbrInternalLink");
13226 } else {
13227 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
13228 vty_out(vty, "confed-internal link\n");
13229 else
13230 vty_out(vty, "internal link\n");
13231 }
13232 /* peer type external or confed-external */
13233 } else if (p->as || (p->as_type == AS_EXTERNAL)) {
13234 if (use_json) {
13235 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
13236 json_object_boolean_true_add(
13237 json_neigh, "nbrConfedExternalLink");
13238 else
13239 json_object_boolean_true_add(json_neigh,
13240 "nbrExternalLink");
13241 } else {
13242 if (bgp_confederation_peers_check(bgp, p->as))
13243 vty_out(vty, "confed-external link\n");
13244 else
13245 vty_out(vty, "external link\n");
13246 }
13247 } else {
13248 if (use_json)
13249 json_object_boolean_true_add(json_neigh,
13250 "nbrUnspecifiedLink");
13251 else
13252 vty_out(vty, "unspecified link\n");
13253 }
13254
13255 /* Roles */
13256 if (use_json) {
13257 json_object_string_add(json_neigh, "localRole",
13258 bgp_get_name_by_role(p->local_role));
13259 json_object_string_add(json_neigh, "remoteRole",
13260 bgp_get_name_by_role(p->remote_role));
13261 } else {
13262 vty_out(vty, " Local Role: %s\n",
13263 bgp_get_name_by_role(p->local_role));
13264 vty_out(vty, " Remote Role: %s\n",
13265 bgp_get_name_by_role(p->remote_role));
13266 }
13267
13268
13269 /* Description. */
13270 if (p->desc) {
13271 if (use_json)
13272 json_object_string_add(json_neigh, "nbrDesc", p->desc);
13273 else
13274 vty_out(vty, " Description: %s\n", p->desc);
13275 }
13276
13277 if (p->hostname) {
13278 if (use_json) {
13279 json_object_string_add(json_neigh, "hostname",
13280 p->hostname);
13281
13282 if (p->domainname)
13283 json_object_string_add(json_neigh, "domainname",
13284 p->domainname);
13285 } else {
13286 if (p->domainname && (p->domainname[0] != '\0'))
13287 vty_out(vty, "Hostname: %s.%s\n", p->hostname,
13288 p->domainname);
13289 else
13290 vty_out(vty, "Hostname: %s\n", p->hostname);
13291 }
13292 } else {
13293 if (use_json)
13294 json_object_string_add(json_neigh, "hostname",
13295 "Unknown");
13296 }
13297
13298 /* Peer-group */
13299 if (p->group) {
13300 if (use_json) {
13301 json_object_string_add(json_neigh, "peerGroup",
13302 p->group->name);
13303
13304 if (dn_flag[0]) {
13305 struct prefix prefix, *range = NULL;
13306
13307 if (sockunion2hostprefix(&(p->su), &prefix))
13308 range = peer_group_lookup_dynamic_neighbor_range(
13309 p->group, &prefix);
13310
13311 if (range) {
13312 json_object_string_addf(
13313 json_neigh,
13314 "peerSubnetRangeGroup", "%pFX",
13315 range);
13316 }
13317 }
13318 } else {
13319 vty_out(vty,
13320 " Member of peer-group %s for session parameters\n",
13321 p->group->name);
13322
13323 if (dn_flag[0]) {
13324 struct prefix prefix, *range = NULL;
13325
13326 if (sockunion2hostprefix(&(p->su), &prefix))
13327 range = peer_group_lookup_dynamic_neighbor_range(
13328 p->group, &prefix);
13329
13330 if (range) {
13331 vty_out(vty,
13332 " Belongs to the subnet range group: %pFX\n",
13333 range);
13334 }
13335 }
13336 }
13337 }
13338
13339 if (use_json) {
13340 /* Administrative shutdown. */
13341 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN)
13342 || CHECK_FLAG(p->bgp->flags, BGP_FLAG_SHUTDOWN))
13343 json_object_boolean_true_add(json_neigh,
13344 "adminShutDown");
13345
13346 /* BGP Version. */
13347 json_object_int_add(json_neigh, "bgpVersion", 4);
13348 json_object_string_addf(json_neigh, "remoteRouterId", "%pI4",
13349 &p->remote_id);
13350 json_object_string_addf(json_neigh, "localRouterId", "%pI4",
13351 &bgp->router_id);
13352
13353 /* Confederation */
13354 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
13355 && bgp_confederation_peers_check(bgp, p->as))
13356 json_object_boolean_true_add(json_neigh,
13357 "nbrCommonAdmin");
13358
13359 /* Status. */
13360 json_object_string_add(
13361 json_neigh, "bgpState",
13362 lookup_msg(bgp_status_msg, p->status, NULL));
13363
13364 if (peer_established(p)) {
13365 time_t uptime;
13366
13367 uptime = monotime(NULL);
13368 uptime -= p->uptime;
13369 epoch_tbuf = time(NULL) - uptime;
13370
13371 json_object_int_add(json_neigh, "bgpTimerUpMsec",
13372 uptime * 1000);
13373 json_object_string_add(json_neigh, "bgpTimerUpString",
13374 peer_uptime(p->uptime, timebuf,
13375 BGP_UPTIME_LEN, 0,
13376 NULL));
13377 json_object_int_add(json_neigh,
13378 "bgpTimerUpEstablishedEpoch",
13379 epoch_tbuf);
13380 }
13381
13382 else if (p->status == Active) {
13383 if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
13384 json_object_string_add(json_neigh, "bgpStateIs",
13385 "passive");
13386 else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
13387 json_object_string_add(json_neigh, "bgpStateIs",
13388 "passiveNSF");
13389 }
13390
13391 /* read timer */
13392 time_t uptime;
13393 struct tm tm;
13394
13395 uptime = monotime(NULL);
13396 uptime -= p->readtime;
13397 gmtime_r(&uptime, &tm);
13398
13399 json_object_int_add(json_neigh, "bgpTimerLastRead",
13400 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13401 + (tm.tm_hour * 3600000));
13402
13403 uptime = monotime(NULL);
13404 uptime -= p->last_write;
13405 gmtime_r(&uptime, &tm);
13406
13407 json_object_int_add(json_neigh, "bgpTimerLastWrite",
13408 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13409 + (tm.tm_hour * 3600000));
13410
13411 uptime = monotime(NULL);
13412 uptime -= p->update_time;
13413 gmtime_r(&uptime, &tm);
13414
13415 json_object_int_add(json_neigh, "bgpInUpdateElapsedTimeMsecs",
13416 (tm.tm_sec * 1000) + (tm.tm_min * 60000)
13417 + (tm.tm_hour * 3600000));
13418
13419 /* Configured timer values. */
13420 json_object_int_add(json_neigh,
13421 "bgpTimerConfiguredHoldTimeMsecs",
13422 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13423 ? p->holdtime * 1000
13424 : bgp->default_holdtime * 1000);
13425 json_object_int_add(json_neigh,
13426 "bgpTimerConfiguredKeepAliveIntervalMsecs",
13427 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13428 ? p->keepalive * 1000
13429 : bgp->default_keepalive * 1000);
13430 json_object_int_add(json_neigh, "bgpTimerHoldTimeMsecs",
13431 p->v_holdtime * 1000);
13432 json_object_int_add(json_neigh,
13433 "bgpTimerKeepAliveIntervalMsecs",
13434 p->v_keepalive * 1000);
13435 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER_DELAYOPEN)) {
13436 json_object_int_add(json_neigh,
13437 "bgpTimerDelayOpenTimeMsecs",
13438 p->v_delayopen * 1000);
13439 }
13440
13441 /* Configured and Synced tcp-mss value for peer */
13442 if (CHECK_FLAG(p->flags, PEER_FLAG_TCP_MSS)) {
13443 sync_tcp_mss = sockopt_tcp_mss_get(p->fd);
13444 json_object_int_add(json_neigh, "bgpTcpMssConfigured",
13445 p->tcp_mss);
13446 json_object_int_add(json_neigh, "bgpTcpMssSynced",
13447 sync_tcp_mss);
13448 }
13449
13450 /* Extended Optional Parameters Length for BGP OPEN Message */
13451 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(p))
13452 json_object_boolean_true_add(
13453 json_neigh, "extendedOptionalParametersLength");
13454 else
13455 json_object_boolean_false_add(
13456 json_neigh, "extendedOptionalParametersLength");
13457
13458 /* Conditional advertisements */
13459 json_object_int_add(
13460 json_neigh,
13461 "bgpTimerConfiguredConditionalAdvertisementsSec",
13462 bgp->condition_check_period);
13463 if (thread_is_scheduled(bgp->t_condition_check))
13464 json_object_int_add(
13465 json_neigh,
13466 "bgpTimerUntilConditionalAdvertisementsSec",
13467 thread_timer_remain_second(
13468 bgp->t_condition_check));
13469 } else {
13470 /* Administrative shutdown. */
13471 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN)
13472 || CHECK_FLAG(p->bgp->flags, BGP_FLAG_SHUTDOWN))
13473 vty_out(vty, " Administratively shut down\n");
13474
13475 /* BGP Version. */
13476 vty_out(vty, " BGP version 4");
13477 vty_out(vty, ", remote router ID %pI4", &p->remote_id);
13478 vty_out(vty, ", local router ID %pI4\n", &bgp->router_id);
13479
13480 /* Confederation */
13481 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
13482 && bgp_confederation_peers_check(bgp, p->as))
13483 vty_out(vty,
13484 " Neighbor under common administration\n");
13485
13486 /* Status. */
13487 vty_out(vty, " BGP state = %s",
13488 lookup_msg(bgp_status_msg, p->status, NULL));
13489
13490 if (peer_established(p))
13491 vty_out(vty, ", up for %8s",
13492 peer_uptime(p->uptime, timebuf, BGP_UPTIME_LEN,
13493 0, NULL));
13494
13495 else if (p->status == Active) {
13496 if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
13497 vty_out(vty, " (passive)");
13498 else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
13499 vty_out(vty, " (NSF passive)");
13500 }
13501 vty_out(vty, "\n");
13502
13503 /* read timer */
13504 vty_out(vty, " Last read %s",
13505 peer_uptime(p->readtime, timebuf, BGP_UPTIME_LEN, 0,
13506 NULL));
13507 vty_out(vty, ", Last write %s\n",
13508 peer_uptime(p->last_write, timebuf, BGP_UPTIME_LEN, 0,
13509 NULL));
13510
13511 /* Configured timer values. */
13512 vty_out(vty,
13513 " Hold time is %d seconds, keepalive interval is %d seconds\n",
13514 p->v_holdtime, p->v_keepalive);
13515 vty_out(vty, " Configured hold time is %d seconds",
13516 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13517 ? p->holdtime
13518 : bgp->default_holdtime);
13519 vty_out(vty, ", keepalive interval is %d seconds\n",
13520 CHECK_FLAG(p->flags, PEER_FLAG_TIMER)
13521 ? p->keepalive
13522 : bgp->default_keepalive);
13523 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER_DELAYOPEN))
13524 vty_out(vty,
13525 " Configured DelayOpenTime is %d seconds\n",
13526 p->delayopen);
13527
13528 /* Configured and synced tcp-mss value for peer */
13529 if (CHECK_FLAG(p->flags, PEER_FLAG_TCP_MSS)) {
13530 sync_tcp_mss = sockopt_tcp_mss_get(p->fd);
13531 vty_out(vty, " Configured tcp-mss is %d", p->tcp_mss);
13532 vty_out(vty, ", synced tcp-mss is %d\n", sync_tcp_mss);
13533 }
13534
13535 /* Extended Optional Parameters Length for BGP OPEN Message */
13536 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(p))
13537 vty_out(vty,
13538 " Extended Optional Parameters Length is enabled\n");
13539
13540 /* Conditional advertisements */
13541 vty_out(vty,
13542 " Configured conditional advertisements interval is %d seconds\n",
13543 bgp->condition_check_period);
13544 if (thread_is_scheduled(bgp->t_condition_check))
13545 vty_out(vty,
13546 " Time until conditional advertisements begin is %lu seconds\n",
13547 thread_timer_remain_second(
13548 bgp->t_condition_check));
13549 }
13550 /* Capability. */
13551 if (peer_established(p) &&
13552 (p->cap || peer_afc_advertised(p) || peer_afc_received(p))) {
13553 if (use_json) {
13554 json_object *json_cap = NULL;
13555
13556 json_cap = json_object_new_object();
13557
13558 /* AS4 */
13559 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV) ||
13560 CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
13561 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV) &&
13562 CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
13563 json_object_string_add(
13564 json_cap, "4byteAs",
13565 "advertisedAndReceived");
13566 else if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV))
13567 json_object_string_add(json_cap,
13568 "4byteAs",
13569 "advertised");
13570 else if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
13571 json_object_string_add(json_cap,
13572 "4byteAs",
13573 "received");
13574 }
13575
13576 /* Extended Message Support */
13577 if (CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_ADV) &&
13578 CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_RCV))
13579 json_object_string_add(json_cap,
13580 "extendedMessage",
13581 "advertisedAndReceived");
13582 else if (CHECK_FLAG(p->cap,
13583 PEER_CAP_EXTENDED_MESSAGE_ADV))
13584 json_object_string_add(json_cap,
13585 "extendedMessage",
13586 "advertised");
13587 else if (CHECK_FLAG(p->cap,
13588 PEER_CAP_EXTENDED_MESSAGE_RCV))
13589 json_object_string_add(json_cap,
13590 "extendedMessage",
13591 "received");
13592
13593 /* AddPath */
13594 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV) ||
13595 CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_ADV)) {
13596 json_object *json_add = NULL;
13597 const char *print_store;
13598
13599 json_add = json_object_new_object();
13600
13601 FOREACH_AFI_SAFI (afi, safi) {
13602 json_object *json_sub = NULL;
13603 json_sub = json_object_new_object();
13604 print_store = get_afi_safi_str(
13605 afi, safi, true);
13606
13607 if (CHECK_FLAG(
13608 p->af_cap[afi][safi],
13609 PEER_CAP_ADDPATH_AF_TX_ADV) ||
13610 CHECK_FLAG(
13611 p->af_cap[afi][safi],
13612 PEER_CAP_ADDPATH_AF_TX_RCV)) {
13613 if (CHECK_FLAG(
13614 p->af_cap[afi]
13615 [safi],
13616 PEER_CAP_ADDPATH_AF_TX_ADV) &&
13617 CHECK_FLAG(
13618 p->af_cap[afi]
13619 [safi],
13620 PEER_CAP_ADDPATH_AF_TX_RCV))
13621 json_object_boolean_true_add(
13622 json_sub,
13623 "txAdvertisedAndReceived");
13624 else if (
13625 CHECK_FLAG(
13626 p->af_cap[afi]
13627 [safi],
13628 PEER_CAP_ADDPATH_AF_TX_ADV))
13629 json_object_boolean_true_add(
13630 json_sub,
13631 "txAdvertised");
13632 else if (
13633 CHECK_FLAG(
13634 p->af_cap[afi]
13635 [safi],
13636 PEER_CAP_ADDPATH_AF_TX_RCV))
13637 json_object_boolean_true_add(
13638 json_sub,
13639 "txReceived");
13640 }
13641
13642 if (CHECK_FLAG(
13643 p->af_cap[afi][safi],
13644 PEER_CAP_ADDPATH_AF_RX_ADV) ||
13645 CHECK_FLAG(
13646 p->af_cap[afi][safi],
13647 PEER_CAP_ADDPATH_AF_RX_RCV)) {
13648 if (CHECK_FLAG(
13649 p->af_cap[afi]
13650 [safi],
13651 PEER_CAP_ADDPATH_AF_RX_ADV) &&
13652 CHECK_FLAG(
13653 p->af_cap[afi]
13654 [safi],
13655 PEER_CAP_ADDPATH_AF_RX_RCV))
13656 json_object_boolean_true_add(
13657 json_sub,
13658 "rxAdvertisedAndReceived");
13659 else if (
13660 CHECK_FLAG(
13661 p->af_cap[afi]
13662 [safi],
13663 PEER_CAP_ADDPATH_AF_RX_ADV))
13664 json_object_boolean_true_add(
13665 json_sub,
13666 "rxAdvertised");
13667 else if (
13668 CHECK_FLAG(
13669 p->af_cap[afi]
13670 [safi],
13671 PEER_CAP_ADDPATH_AF_RX_RCV))
13672 json_object_boolean_true_add(
13673 json_sub,
13674 "rxReceived");
13675 }
13676
13677 if (CHECK_FLAG(
13678 p->af_cap[afi][safi],
13679 PEER_CAP_ADDPATH_AF_TX_ADV) ||
13680 CHECK_FLAG(
13681 p->af_cap[afi][safi],
13682 PEER_CAP_ADDPATH_AF_TX_RCV) ||
13683 CHECK_FLAG(
13684 p->af_cap[afi][safi],
13685 PEER_CAP_ADDPATH_AF_RX_ADV) ||
13686 CHECK_FLAG(
13687 p->af_cap[afi][safi],
13688 PEER_CAP_ADDPATH_AF_RX_RCV))
13689 json_object_object_add(
13690 json_add, print_store,
13691 json_sub);
13692 else
13693 json_object_free(json_sub);
13694 }
13695
13696 json_object_object_add(json_cap, "addPath",
13697 json_add);
13698 }
13699
13700 /* Dynamic */
13701 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV) ||
13702 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV)) {
13703 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV) &&
13704 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV))
13705 json_object_string_add(
13706 json_cap, "dynamic",
13707 "advertisedAndReceived");
13708 else if (CHECK_FLAG(p->cap,
13709 PEER_CAP_DYNAMIC_ADV))
13710 json_object_string_add(json_cap,
13711 "dynamic",
13712 "advertised");
13713 else if (CHECK_FLAG(p->cap,
13714 PEER_CAP_DYNAMIC_RCV))
13715 json_object_string_add(json_cap,
13716 "dynamic",
13717 "received");
13718 }
13719
13720 /* Role */
13721 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV) ||
13722 CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV)) {
13723 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV) &&
13724 CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
13725 json_object_string_add(
13726 json_cap, "role",
13727 "advertisedAndReceived");
13728 else if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV))
13729 json_object_string_add(json_cap, "role",
13730 "advertised");
13731 else if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
13732 json_object_string_add(json_cap, "role",
13733 "received");
13734 }
13735
13736 /* Extended nexthop */
13737 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV) ||
13738 CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
13739 json_object *json_nxt = NULL;
13740 const char *print_store;
13741
13742
13743 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV) &&
13744 CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
13745 json_object_string_add(
13746 json_cap, "extendedNexthop",
13747 "advertisedAndReceived");
13748 else if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV))
13749 json_object_string_add(
13750 json_cap, "extendedNexthop",
13751 "advertised");
13752 else if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
13753 json_object_string_add(
13754 json_cap, "extendedNexthop",
13755 "received");
13756
13757 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)) {
13758 json_nxt = json_object_new_object();
13759
13760 for (safi = SAFI_UNICAST;
13761 safi < SAFI_MAX; safi++) {
13762 if (CHECK_FLAG(
13763 p->af_cap[AFI_IP]
13764 [safi],
13765 PEER_CAP_ENHE_AF_RCV)) {
13766 print_store =
13767 get_afi_safi_str(
13768 AFI_IP,
13769 safi,
13770 true);
13771 json_object_string_add(
13772 json_nxt,
13773 print_store,
13774 "recieved"); /* misspelled for compatibility */
13775 }
13776 }
13777 json_object_object_add(
13778 json_cap,
13779 "extendedNexthopFamililesByPeer",
13780 json_nxt);
13781 }
13782 }
13783
13784 /* Long-lived Graceful Restart */
13785 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV) ||
13786 CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV)) {
13787 json_object *json_llgr = NULL;
13788 const char *afi_safi_str;
13789
13790 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV) &&
13791 CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
13792 json_object_string_add(
13793 json_cap,
13794 "longLivedGracefulRestart",
13795 "advertisedAndReceived");
13796 else if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV))
13797 json_object_string_add(
13798 json_cap,
13799 "longLivedGracefulRestart",
13800 "advertised");
13801 else if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
13802 json_object_string_add(
13803 json_cap,
13804 "longLivedGracefulRestart",
13805 "received");
13806
13807 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV)) {
13808 json_llgr = json_object_new_object();
13809
13810 FOREACH_AFI_SAFI (afi, safi) {
13811 if (CHECK_FLAG(
13812 p->af_cap[afi]
13813 [safi],
13814 PEER_CAP_ENHE_AF_RCV)) {
13815 afi_safi_str =
13816 get_afi_safi_str(
13817 afi,
13818 safi,
13819 true);
13820 json_object_string_add(
13821 json_llgr,
13822 afi_safi_str,
13823 "received");
13824 }
13825 }
13826 json_object_object_add(
13827 json_cap,
13828 "longLivedGracefulRestartByPeer",
13829 json_llgr);
13830 }
13831 }
13832
13833 /* Route Refresh */
13834 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) ||
13835 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_NEW_RCV) ||
13836 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_OLD_RCV)) {
13837 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) &&
13838 (CHECK_FLAG(p->cap,
13839 PEER_CAP_REFRESH_NEW_RCV) ||
13840 CHECK_FLAG(p->cap,
13841 PEER_CAP_REFRESH_OLD_RCV))) {
13842 if (CHECK_FLAG(
13843 p->cap,
13844 PEER_CAP_REFRESH_OLD_RCV) &&
13845 CHECK_FLAG(
13846 p->cap,
13847 PEER_CAP_REFRESH_NEW_RCV))
13848 json_object_string_add(
13849 json_cap,
13850 "routeRefresh",
13851 "advertisedAndReceivedOldNew");
13852 else {
13853 if (CHECK_FLAG(
13854 p->cap,
13855 PEER_CAP_REFRESH_OLD_RCV))
13856 json_object_string_add(
13857 json_cap,
13858 "routeRefresh",
13859 "advertisedAndReceivedOld");
13860 else
13861 json_object_string_add(
13862 json_cap,
13863 "routeRefresh",
13864 "advertisedAndReceivedNew");
13865 }
13866 } else if (CHECK_FLAG(p->cap,
13867 PEER_CAP_REFRESH_ADV))
13868 json_object_string_add(json_cap,
13869 "routeRefresh",
13870 "advertised");
13871 else if (CHECK_FLAG(p->cap,
13872 PEER_CAP_REFRESH_NEW_RCV) ||
13873 CHECK_FLAG(p->cap,
13874 PEER_CAP_REFRESH_OLD_RCV))
13875 json_object_string_add(json_cap,
13876 "routeRefresh",
13877 "received");
13878 }
13879
13880 /* Enhanced Route Refresh */
13881 if (CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_ADV) ||
13882 CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_RCV)) {
13883 if (CHECK_FLAG(p->cap,
13884 PEER_CAP_ENHANCED_RR_ADV) &&
13885 CHECK_FLAG(p->cap,
13886 PEER_CAP_ENHANCED_RR_RCV))
13887 json_object_string_add(
13888 json_cap,
13889 "enhancedRouteRefresh",
13890 "advertisedAndReceived");
13891 else if (CHECK_FLAG(p->cap,
13892 PEER_CAP_ENHANCED_RR_ADV))
13893 json_object_string_add(
13894 json_cap,
13895 "enhancedRouteRefresh",
13896 "advertised");
13897 else if (CHECK_FLAG(p->cap,
13898 PEER_CAP_ENHANCED_RR_RCV))
13899 json_object_string_add(
13900 json_cap,
13901 "enhancedRouteRefresh",
13902 "received");
13903 }
13904
13905 /* Multiprotocol Extensions */
13906 json_object *json_multi = NULL;
13907
13908 json_multi = json_object_new_object();
13909
13910 FOREACH_AFI_SAFI (afi, safi) {
13911 if (p->afc_adv[afi][safi] ||
13912 p->afc_recv[afi][safi]) {
13913 json_object *json_exten = NULL;
13914 json_exten = json_object_new_object();
13915
13916 if (p->afc_adv[afi][safi] &&
13917 p->afc_recv[afi][safi])
13918 json_object_boolean_true_add(
13919 json_exten,
13920 "advertisedAndReceived");
13921 else if (p->afc_adv[afi][safi])
13922 json_object_boolean_true_add(
13923 json_exten,
13924 "advertised");
13925 else if (p->afc_recv[afi][safi])
13926 json_object_boolean_true_add(
13927 json_exten, "received");
13928
13929 json_object_object_add(
13930 json_multi,
13931 get_afi_safi_str(afi, safi,
13932 true),
13933 json_exten);
13934 }
13935 }
13936 json_object_object_add(json_cap,
13937 "multiprotocolExtensions",
13938 json_multi);
13939
13940 /* Hostname capabilities */
13941 json_object *json_hname = NULL;
13942
13943 json_hname = json_object_new_object();
13944
13945 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
13946 json_object_string_add(
13947 json_hname, "advHostName",
13948 bgp->peer_self->hostname
13949 ? bgp->peer_self->hostname
13950 : "n/a");
13951 json_object_string_add(
13952 json_hname, "advDomainName",
13953 bgp->peer_self->domainname
13954 ? bgp->peer_self->domainname
13955 : "n/a");
13956 }
13957
13958
13959 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
13960 json_object_string_add(
13961 json_hname, "rcvHostName",
13962 p->hostname ? p->hostname : "n/a");
13963 json_object_string_add(
13964 json_hname, "rcvDomainName",
13965 p->domainname ? p->domainname : "n/a");
13966 }
13967
13968 json_object_object_add(json_cap, "hostName",
13969 json_hname);
13970
13971 /* Software Version capability */
13972 json_object *json_soft_version = NULL;
13973
13974 json_soft_version = json_object_new_object();
13975
13976 if (CHECK_FLAG(p->cap, PEER_CAP_SOFT_VERSION_ADV))
13977 json_object_string_add(
13978 json_soft_version,
13979 "advertisedSoftwareVersion",
13980 cmd_software_version_get());
13981
13982 if (CHECK_FLAG(p->cap, PEER_CAP_SOFT_VERSION_RCV))
13983 json_object_string_add(
13984 json_soft_version,
13985 "receivedSoftwareVersion",
13986 p->soft_version ? p->soft_version
13987 : "n/a");
13988
13989 json_object_object_add(json_cap, "softwareVersion",
13990 json_soft_version);
13991
13992 /* Graceful Restart */
13993 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) ||
13994 CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)) {
13995 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV) &&
13996 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
13997 json_object_string_add(
13998 json_cap, "gracefulRestart",
13999 "advertisedAndReceived");
14000 else if (CHECK_FLAG(p->cap,
14001 PEER_CAP_RESTART_ADV))
14002 json_object_string_add(
14003 json_cap,
14004 "gracefulRestartCapability",
14005 "advertised");
14006 else if (CHECK_FLAG(p->cap,
14007 PEER_CAP_RESTART_RCV))
14008 json_object_string_add(
14009 json_cap,
14010 "gracefulRestartCapability",
14011 "received");
14012
14013 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14014 int restart_af_count = 0;
14015 json_object *json_restart = NULL;
14016 json_restart = json_object_new_object();
14017
14018 json_object_int_add(
14019 json_cap,
14020 "gracefulRestartRemoteTimerMsecs",
14021 p->v_gr_restart * 1000);
14022
14023 FOREACH_AFI_SAFI (afi, safi) {
14024 if (CHECK_FLAG(
14025 p->af_cap[afi]
14026 [safi],
14027 PEER_CAP_RESTART_AF_RCV)) {
14028 json_object *json_sub =
14029 NULL;
14030 json_sub =
14031 json_object_new_object();
14032
14033 if (CHECK_FLAG(
14034 p->af_cap
14035 [afi]
14036 [safi],
14037 PEER_CAP_RESTART_AF_PRESERVE_RCV))
14038 json_object_boolean_true_add(
14039 json_sub,
14040 "preserved");
14041 restart_af_count++;
14042 json_object_object_add(
14043 json_restart,
14044 get_afi_safi_str(
14045 afi,
14046 safi,
14047 true),
14048 json_sub);
14049 }
14050 }
14051 if (!restart_af_count) {
14052 json_object_string_add(
14053 json_cap,
14054 "addressFamiliesByPeer",
14055 "none");
14056 json_object_free(json_restart);
14057 } else
14058 json_object_object_add(
14059 json_cap,
14060 "addressFamiliesByPeer",
14061 json_restart);
14062 }
14063 }
14064 json_object_object_add(
14065 json_neigh, "neighborCapabilities", json_cap);
14066 } else {
14067 vty_out(vty, " Neighbor capabilities:\n");
14068
14069 /* AS4 */
14070 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV) ||
14071 CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
14072 vty_out(vty, " 4 Byte AS:");
14073 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV))
14074 vty_out(vty, " advertised");
14075 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV))
14076 vty_out(vty, " %sreceived",
14077 CHECK_FLAG(p->cap,
14078 PEER_CAP_AS4_ADV)
14079 ? "and "
14080 : "");
14081 vty_out(vty, "\n");
14082 }
14083
14084 /* Extended Message Support */
14085 if (CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_RCV) ||
14086 CHECK_FLAG(p->cap, PEER_CAP_EXTENDED_MESSAGE_ADV)) {
14087 vty_out(vty, " Extended Message:");
14088 if (CHECK_FLAG(p->cap,
14089 PEER_CAP_EXTENDED_MESSAGE_ADV))
14090 vty_out(vty, " advertised");
14091 if (CHECK_FLAG(p->cap,
14092 PEER_CAP_EXTENDED_MESSAGE_RCV))
14093 vty_out(vty, " %sreceived",
14094 CHECK_FLAG(
14095 p->cap,
14096 PEER_CAP_EXTENDED_MESSAGE_ADV)
14097 ? "and "
14098 : "");
14099 vty_out(vty, "\n");
14100 }
14101
14102 /* AddPath */
14103 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV) ||
14104 CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_ADV)) {
14105 vty_out(vty, " AddPath:\n");
14106
14107 FOREACH_AFI_SAFI (afi, safi) {
14108 if (CHECK_FLAG(
14109 p->af_cap[afi][safi],
14110 PEER_CAP_ADDPATH_AF_TX_ADV) ||
14111 CHECK_FLAG(
14112 p->af_cap[afi][safi],
14113 PEER_CAP_ADDPATH_AF_TX_RCV)) {
14114 vty_out(vty, " %s: TX ",
14115 get_afi_safi_str(
14116 afi, safi,
14117 false));
14118
14119 if (CHECK_FLAG(
14120 p->af_cap[afi]
14121 [safi],
14122 PEER_CAP_ADDPATH_AF_TX_ADV))
14123 vty_out(vty,
14124 "advertised");
14125
14126 if (CHECK_FLAG(
14127 p->af_cap[afi]
14128 [safi],
14129 PEER_CAP_ADDPATH_AF_TX_RCV))
14130 vty_out(vty,
14131 "%sreceived",
14132 CHECK_FLAG(
14133 p->af_cap
14134 [afi]
14135 [safi],
14136 PEER_CAP_ADDPATH_AF_TX_ADV)
14137 ? " and "
14138 : "");
14139
14140 vty_out(vty, "\n");
14141 }
14142
14143 if (CHECK_FLAG(
14144 p->af_cap[afi][safi],
14145 PEER_CAP_ADDPATH_AF_RX_ADV) ||
14146 CHECK_FLAG(
14147 p->af_cap[afi][safi],
14148 PEER_CAP_ADDPATH_AF_RX_RCV)) {
14149 vty_out(vty, " %s: RX ",
14150 get_afi_safi_str(
14151 afi, safi,
14152 false));
14153
14154 if (CHECK_FLAG(
14155 p->af_cap[afi]
14156 [safi],
14157 PEER_CAP_ADDPATH_AF_RX_ADV))
14158 vty_out(vty,
14159 "advertised");
14160
14161 if (CHECK_FLAG(
14162 p->af_cap[afi]
14163 [safi],
14164 PEER_CAP_ADDPATH_AF_RX_RCV))
14165 vty_out(vty,
14166 "%sreceived",
14167 CHECK_FLAG(
14168 p->af_cap
14169 [afi]
14170 [safi],
14171 PEER_CAP_ADDPATH_AF_RX_ADV)
14172 ? " and "
14173 : "");
14174
14175 vty_out(vty, "\n");
14176 }
14177 }
14178 }
14179
14180 /* Dynamic */
14181 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV) ||
14182 CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV)) {
14183 vty_out(vty, " Dynamic:");
14184 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_ADV))
14185 vty_out(vty, " advertised");
14186 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV))
14187 vty_out(vty, " %sreceived",
14188 CHECK_FLAG(p->cap,
14189 PEER_CAP_DYNAMIC_ADV)
14190 ? "and "
14191 : "");
14192 vty_out(vty, "\n");
14193 }
14194
14195 /* Role */
14196 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV) ||
14197 CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV)) {
14198 vty_out(vty, " Role:");
14199 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_ADV))
14200 vty_out(vty, " advertised");
14201 if (CHECK_FLAG(p->cap, PEER_CAP_ROLE_RCV))
14202 vty_out(vty, " %sreceived",
14203 CHECK_FLAG(p->cap,
14204 PEER_CAP_ROLE_ADV)
14205 ? "and "
14206 : "");
14207 vty_out(vty, "\n");
14208 }
14209
14210 /* Extended nexthop */
14211 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV) ||
14212 CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
14213 vty_out(vty, " Extended nexthop:");
14214 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV))
14215 vty_out(vty, " advertised");
14216 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV))
14217 vty_out(vty, " %sreceived",
14218 CHECK_FLAG(p->cap,
14219 PEER_CAP_ENHE_ADV)
14220 ? "and "
14221 : "");
14222 vty_out(vty, "\n");
14223
14224 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)) {
14225 vty_out(vty,
14226 " Address families by peer:\n ");
14227 for (safi = SAFI_UNICAST;
14228 safi < SAFI_MAX; safi++)
14229 if (CHECK_FLAG(
14230 p->af_cap[AFI_IP]
14231 [safi],
14232 PEER_CAP_ENHE_AF_RCV))
14233 vty_out(vty,
14234 " %s\n",
14235 get_afi_safi_str(
14236 AFI_IP,
14237 safi,
14238 false));
14239 }
14240 }
14241
14242 /* Long-lived Graceful Restart */
14243 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV) ||
14244 CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV)) {
14245 vty_out(vty,
14246 " Long-lived Graceful Restart:");
14247 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_ADV))
14248 vty_out(vty, " advertised");
14249 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV))
14250 vty_out(vty, " %sreceived",
14251 CHECK_FLAG(p->cap,
14252 PEER_CAP_LLGR_ADV)
14253 ? "and "
14254 : "");
14255 vty_out(vty, "\n");
14256
14257 if (CHECK_FLAG(p->cap, PEER_CAP_LLGR_RCV)) {
14258 vty_out(vty,
14259 " Address families by peer:\n");
14260 FOREACH_AFI_SAFI (afi, safi)
14261 if (CHECK_FLAG(
14262 p->af_cap[afi]
14263 [safi],
14264 PEER_CAP_LLGR_AF_RCV))
14265 vty_out(vty,
14266 " %s\n",
14267 get_afi_safi_str(
14268 afi,
14269 safi,
14270 false));
14271 }
14272 }
14273
14274 /* Route Refresh */
14275 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV) ||
14276 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_NEW_RCV) ||
14277 CHECK_FLAG(p->cap, PEER_CAP_REFRESH_OLD_RCV)) {
14278 vty_out(vty, " Route refresh:");
14279 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV))
14280 vty_out(vty, " advertised");
14281 if (CHECK_FLAG(p->cap,
14282 PEER_CAP_REFRESH_NEW_RCV) ||
14283 CHECK_FLAG(p->cap,
14284 PEER_CAP_REFRESH_OLD_RCV))
14285 vty_out(vty, " %sreceived(%s)",
14286 CHECK_FLAG(p->cap,
14287 PEER_CAP_REFRESH_ADV)
14288 ? "and "
14289 : "",
14290 (CHECK_FLAG(
14291 p->cap,
14292 PEER_CAP_REFRESH_OLD_RCV) &&
14293 CHECK_FLAG(
14294 p->cap,
14295 PEER_CAP_REFRESH_NEW_RCV))
14296 ? "old & new"
14297 : CHECK_FLAG(
14298 p->cap,
14299 PEER_CAP_REFRESH_OLD_RCV)
14300 ? "old"
14301 : "new");
14302
14303 vty_out(vty, "\n");
14304 }
14305
14306 /* Enhanced Route Refresh */
14307 if (CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_ADV) ||
14308 CHECK_FLAG(p->cap, PEER_CAP_ENHANCED_RR_RCV)) {
14309 vty_out(vty, " Enhanced Route Refresh:");
14310 if (CHECK_FLAG(p->cap,
14311 PEER_CAP_ENHANCED_RR_ADV))
14312 vty_out(vty, " advertised");
14313 if (CHECK_FLAG(p->cap,
14314 PEER_CAP_ENHANCED_RR_RCV))
14315 vty_out(vty, " %sreceived",
14316 CHECK_FLAG(p->cap,
14317 PEER_CAP_REFRESH_ADV)
14318 ? "and "
14319 : "");
14320 vty_out(vty, "\n");
14321 }
14322
14323 /* Multiprotocol Extensions */
14324 FOREACH_AFI_SAFI (afi, safi)
14325 if (p->afc_adv[afi][safi] ||
14326 p->afc_recv[afi][safi]) {
14327 vty_out(vty, " Address Family %s:",
14328 get_afi_safi_str(afi, safi,
14329 false));
14330 if (p->afc_adv[afi][safi])
14331 vty_out(vty, " advertised");
14332 if (p->afc_recv[afi][safi])
14333 vty_out(vty, " %sreceived",
14334 p->afc_adv[afi][safi]
14335 ? "and "
14336 : "");
14337 vty_out(vty, "\n");
14338 }
14339
14340 /* Hostname capability */
14341 vty_out(vty, " Hostname Capability:");
14342
14343 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
14344 vty_out(vty,
14345 " advertised (name: %s,domain name: %s)",
14346 bgp->peer_self->hostname
14347 ? bgp->peer_self->hostname
14348 : "n/a",
14349 bgp->peer_self->domainname
14350 ? bgp->peer_self->domainname
14351 : "n/a");
14352 } else {
14353 vty_out(vty, " not advertised");
14354 }
14355
14356 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
14357 vty_out(vty,
14358 " received (name: %s,domain name: %s)",
14359 p->hostname ? p->hostname : "n/a",
14360 p->domainname ? p->domainname : "n/a");
14361 } else {
14362 vty_out(vty, " not received");
14363 }
14364
14365 vty_out(vty, "\n");
14366
14367 /* Software Version capability */
14368 vty_out(vty, " Version Capability:");
14369
14370 if (CHECK_FLAG(p->cap, PEER_CAP_SOFT_VERSION_ADV)) {
14371 vty_out(vty,
14372 " advertised software version (%s)",
14373 cmd_software_version_get());
14374 } else
14375 vty_out(vty, " not advertised");
14376
14377 if (CHECK_FLAG(p->cap, PEER_CAP_SOFT_VERSION_RCV)) {
14378 vty_out(vty, " received software version (%s)",
14379 p->soft_version ? p->soft_version
14380 : "n/a");
14381 } else
14382 vty_out(vty, " not received");
14383
14384 vty_out(vty, "\n");
14385
14386 /* Graceful Restart */
14387 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) ||
14388 CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV)) {
14389 vty_out(vty,
14390 " Graceful Restart Capability:");
14391 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_ADV))
14392 vty_out(vty, " advertised");
14393 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV))
14394 vty_out(vty, " %sreceived",
14395 CHECK_FLAG(p->cap,
14396 PEER_CAP_RESTART_ADV)
14397 ? "and "
14398 : "");
14399 vty_out(vty, "\n");
14400
14401 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14402 int restart_af_count = 0;
14403
14404 vty_out(vty,
14405 " Remote Restart timer is %d seconds\n",
14406 p->v_gr_restart);
14407 vty_out(vty,
14408 " Address families by peer:\n ");
14409
14410 FOREACH_AFI_SAFI (afi, safi)
14411 if (CHECK_FLAG(
14412 p->af_cap[afi]
14413 [safi],
14414 PEER_CAP_RESTART_AF_RCV)) {
14415 vty_out(vty, "%s%s(%s)",
14416 restart_af_count
14417 ? ", "
14418 : "",
14419 get_afi_safi_str(
14420 afi,
14421 safi,
14422 false),
14423 CHECK_FLAG(
14424 p->af_cap
14425 [afi]
14426 [safi],
14427 PEER_CAP_RESTART_AF_PRESERVE_RCV)
14428 ? "preserved"
14429 : "not preserved");
14430 restart_af_count++;
14431 }
14432 if (!restart_af_count)
14433 vty_out(vty, "none");
14434 vty_out(vty, "\n");
14435 }
14436 } /* Graceful Restart */
14437 }
14438 }
14439
14440 /* graceful restart information */
14441 json_object *json_grace = NULL;
14442 json_object *json_grace_send = NULL;
14443 json_object *json_grace_recv = NULL;
14444 int eor_send_af_count = 0;
14445 int eor_receive_af_count = 0;
14446
14447 if (use_json) {
14448 json_grace = json_object_new_object();
14449 json_grace_send = json_object_new_object();
14450 json_grace_recv = json_object_new_object();
14451
14452 if ((peer_established(p)) &&
14453 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14454 FOREACH_AFI_SAFI (afi, safi) {
14455 if (CHECK_FLAG(p->af_sflags[afi][safi],
14456 PEER_STATUS_EOR_SEND)) {
14457 json_object_boolean_true_add(
14458 json_grace_send,
14459 get_afi_safi_str(afi, safi,
14460 true));
14461 eor_send_af_count++;
14462 }
14463 }
14464 FOREACH_AFI_SAFI (afi, safi) {
14465 if (CHECK_FLAG(p->af_sflags[afi][safi],
14466 PEER_STATUS_EOR_RECEIVED)) {
14467 json_object_boolean_true_add(
14468 json_grace_recv,
14469 get_afi_safi_str(afi, safi,
14470 true));
14471 eor_receive_af_count++;
14472 }
14473 }
14474 }
14475 json_object_object_add(json_grace, "endOfRibSend",
14476 json_grace_send);
14477 json_object_object_add(json_grace, "endOfRibRecv",
14478 json_grace_recv);
14479
14480
14481 if (p->t_gr_restart)
14482 json_object_int_add(
14483 json_grace, "gracefulRestartTimerMsecs",
14484 thread_timer_remain_second(p->t_gr_restart) *
14485 1000);
14486
14487 if (p->t_gr_stale)
14488 json_object_int_add(
14489 json_grace, "gracefulStalepathTimerMsecs",
14490 thread_timer_remain_second(p->t_gr_stale) *
14491 1000);
14492 /* more gr info in new format */
14493 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, json_grace);
14494 json_object_object_add(json_neigh, "gracefulRestartInfo",
14495 json_grace);
14496 } else {
14497 vty_out(vty, " Graceful restart information:\n");
14498 if ((peer_established(p)) &&
14499 CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)) {
14500
14501 vty_out(vty, " End-of-RIB send: ");
14502 FOREACH_AFI_SAFI (afi, safi) {
14503 if (CHECK_FLAG(p->af_sflags[afi][safi],
14504 PEER_STATUS_EOR_SEND)) {
14505 vty_out(vty, "%s%s",
14506 eor_send_af_count ? ", " : "",
14507 get_afi_safi_str(afi, safi,
14508 false));
14509 eor_send_af_count++;
14510 }
14511 }
14512 vty_out(vty, "\n");
14513 vty_out(vty, " End-of-RIB received: ");
14514 FOREACH_AFI_SAFI (afi, safi) {
14515 if (CHECK_FLAG(p->af_sflags[afi][safi],
14516 PEER_STATUS_EOR_RECEIVED)) {
14517 vty_out(vty, "%s%s",
14518 eor_receive_af_count ? ", "
14519 : "",
14520 get_afi_safi_str(afi, safi,
14521 false));
14522 eor_receive_af_count++;
14523 }
14524 }
14525 vty_out(vty, "\n");
14526 }
14527
14528 if (p->t_gr_restart)
14529 vty_out(vty,
14530 " The remaining time of restart timer is %ld\n",
14531 thread_timer_remain_second(p->t_gr_restart));
14532
14533 if (p->t_gr_stale)
14534 vty_out(vty,
14535 " The remaining time of stalepath timer is %ld\n",
14536 thread_timer_remain_second(p->t_gr_stale));
14537
14538 /* more gr info in new format */
14539 BGP_SHOW_PEER_GR_CAPABILITY(vty, p, NULL);
14540 }
14541
14542 if (use_json) {
14543 json_object *json_stat = NULL;
14544 json_stat = json_object_new_object();
14545 /* Packet counts. */
14546
14547 atomic_size_t outq_count, inq_count;
14548 outq_count = atomic_load_explicit(&p->obuf->count,
14549 memory_order_relaxed);
14550 inq_count = atomic_load_explicit(&p->ibuf->count,
14551 memory_order_relaxed);
14552
14553 json_object_int_add(json_stat, "depthInq",
14554 (unsigned long)inq_count);
14555 json_object_int_add(json_stat, "depthOutq",
14556 (unsigned long)outq_count);
14557 json_object_int_add(json_stat, "opensSent",
14558 atomic_load_explicit(&p->open_out,
14559 memory_order_relaxed));
14560 json_object_int_add(json_stat, "opensRecv",
14561 atomic_load_explicit(&p->open_in,
14562 memory_order_relaxed));
14563 json_object_int_add(json_stat, "notificationsSent",
14564 atomic_load_explicit(&p->notify_out,
14565 memory_order_relaxed));
14566 json_object_int_add(json_stat, "notificationsRecv",
14567 atomic_load_explicit(&p->notify_in,
14568 memory_order_relaxed));
14569 json_object_int_add(json_stat, "updatesSent",
14570 atomic_load_explicit(&p->update_out,
14571 memory_order_relaxed));
14572 json_object_int_add(json_stat, "updatesRecv",
14573 atomic_load_explicit(&p->update_in,
14574 memory_order_relaxed));
14575 json_object_int_add(json_stat, "keepalivesSent",
14576 atomic_load_explicit(&p->keepalive_out,
14577 memory_order_relaxed));
14578 json_object_int_add(json_stat, "keepalivesRecv",
14579 atomic_load_explicit(&p->keepalive_in,
14580 memory_order_relaxed));
14581 json_object_int_add(json_stat, "routeRefreshSent",
14582 atomic_load_explicit(&p->refresh_out,
14583 memory_order_relaxed));
14584 json_object_int_add(json_stat, "routeRefreshRecv",
14585 atomic_load_explicit(&p->refresh_in,
14586 memory_order_relaxed));
14587 json_object_int_add(json_stat, "capabilitySent",
14588 atomic_load_explicit(&p->dynamic_cap_out,
14589 memory_order_relaxed));
14590 json_object_int_add(json_stat, "capabilityRecv",
14591 atomic_load_explicit(&p->dynamic_cap_in,
14592 memory_order_relaxed));
14593 json_object_int_add(json_stat, "totalSent", PEER_TOTAL_TX(p));
14594 json_object_int_add(json_stat, "totalRecv", PEER_TOTAL_RX(p));
14595 json_object_object_add(json_neigh, "messageStats", json_stat);
14596 } else {
14597 atomic_size_t outq_count, inq_count, open_out, open_in,
14598 notify_out, notify_in, update_out, update_in,
14599 keepalive_out, keepalive_in, refresh_out, refresh_in,
14600 dynamic_cap_out, dynamic_cap_in;
14601 outq_count = atomic_load_explicit(&p->obuf->count,
14602 memory_order_relaxed);
14603 inq_count = atomic_load_explicit(&p->ibuf->count,
14604 memory_order_relaxed);
14605 open_out = atomic_load_explicit(&p->open_out,
14606 memory_order_relaxed);
14607 open_in =
14608 atomic_load_explicit(&p->open_in, memory_order_relaxed);
14609 notify_out = atomic_load_explicit(&p->notify_out,
14610 memory_order_relaxed);
14611 notify_in = atomic_load_explicit(&p->notify_in,
14612 memory_order_relaxed);
14613 update_out = atomic_load_explicit(&p->update_out,
14614 memory_order_relaxed);
14615 update_in = atomic_load_explicit(&p->update_in,
14616 memory_order_relaxed);
14617 keepalive_out = atomic_load_explicit(&p->keepalive_out,
14618 memory_order_relaxed);
14619 keepalive_in = atomic_load_explicit(&p->keepalive_in,
14620 memory_order_relaxed);
14621 refresh_out = atomic_load_explicit(&p->refresh_out,
14622 memory_order_relaxed);
14623 refresh_in = atomic_load_explicit(&p->refresh_in,
14624 memory_order_relaxed);
14625 dynamic_cap_out = atomic_load_explicit(&p->dynamic_cap_out,
14626 memory_order_relaxed);
14627 dynamic_cap_in = atomic_load_explicit(&p->dynamic_cap_in,
14628 memory_order_relaxed);
14629
14630 /* Packet counts. */
14631 vty_out(vty, " Message statistics:\n");
14632 vty_out(vty, " Inq depth is %zu\n", inq_count);
14633 vty_out(vty, " Outq depth is %zu\n", outq_count);
14634 vty_out(vty, " Sent Rcvd\n");
14635 vty_out(vty, " Opens: %10zu %10zu\n", open_out,
14636 open_in);
14637 vty_out(vty, " Notifications: %10zu %10zu\n", notify_out,
14638 notify_in);
14639 vty_out(vty, " Updates: %10zu %10zu\n", update_out,
14640 update_in);
14641 vty_out(vty, " Keepalives: %10zu %10zu\n", keepalive_out,
14642 keepalive_in);
14643 vty_out(vty, " Route Refresh: %10zu %10zu\n", refresh_out,
14644 refresh_in);
14645 vty_out(vty, " Capability: %10zu %10zu\n",
14646 dynamic_cap_out, dynamic_cap_in);
14647 vty_out(vty, " Total: %10u %10u\n",
14648 (uint32_t)PEER_TOTAL_TX(p), (uint32_t)PEER_TOTAL_RX(p));
14649 }
14650
14651 if (use_json) {
14652 /* advertisement-interval */
14653 json_object_int_add(json_neigh,
14654 "minBtwnAdvertisementRunsTimerMsecs",
14655 p->v_routeadv * 1000);
14656
14657 /* Update-source. */
14658 if (p->update_if || p->update_source) {
14659 if (p->update_if)
14660 json_object_string_add(json_neigh,
14661 "updateSource",
14662 p->update_if);
14663 else if (p->update_source)
14664 json_object_string_addf(json_neigh,
14665 "updateSource", "%pSU",
14666 p->update_source);
14667 }
14668 } else {
14669 /* advertisement-interval */
14670 vty_out(vty,
14671 " Minimum time between advertisement runs is %d seconds\n",
14672 p->v_routeadv);
14673
14674 /* Update-source. */
14675 if (p->update_if || p->update_source) {
14676 vty_out(vty, " Update source is ");
14677 if (p->update_if)
14678 vty_out(vty, "%s", p->update_if);
14679 else if (p->update_source)
14680 vty_out(vty, "%pSU", p->update_source);
14681 vty_out(vty, "\n");
14682 }
14683
14684 vty_out(vty, "\n");
14685 }
14686
14687 /* Address Family Information */
14688 json_object *json_hold = NULL;
14689
14690 if (use_json)
14691 json_hold = json_object_new_object();
14692
14693 FOREACH_AFI_SAFI (afi, safi)
14694 if (p->afc[afi][safi])
14695 bgp_show_peer_afi(vty, p, afi, safi, use_json,
14696 json_hold);
14697
14698 if (use_json) {
14699 json_object_object_add(json_neigh, "addressFamilyInfo",
14700 json_hold);
14701 json_object_int_add(json_neigh, "connectionsEstablished",
14702 p->established);
14703 json_object_int_add(json_neigh, "connectionsDropped",
14704 p->dropped);
14705 } else
14706 vty_out(vty, " Connections established %d; dropped %d\n",
14707 p->established, p->dropped);
14708
14709 if (!p->last_reset) {
14710 if (use_json)
14711 json_object_string_add(json_neigh, "lastReset",
14712 "never");
14713 else
14714 vty_out(vty, " Last reset never\n");
14715 } else {
14716 if (use_json) {
14717 time_t uptime;
14718 struct tm tm;
14719
14720 uptime = monotime(NULL);
14721 uptime -= p->resettime;
14722 gmtime_r(&uptime, &tm);
14723
14724 json_object_int_add(json_neigh, "lastResetTimerMsecs",
14725 (tm.tm_sec * 1000)
14726 + (tm.tm_min * 60000)
14727 + (tm.tm_hour * 3600000));
14728 bgp_show_peer_reset(NULL, p, json_neigh, true);
14729 } else {
14730 vty_out(vty, " Last reset %s, ",
14731 peer_uptime(p->resettime, timebuf,
14732 BGP_UPTIME_LEN, 0, NULL));
14733
14734 bgp_show_peer_reset(vty, p, NULL, false);
14735 if (p->last_reset_cause_size) {
14736 msg = p->last_reset_cause;
14737 vty_out(vty,
14738 " Message received that caused BGP to send a NOTIFICATION:\n ");
14739 for (i = 1; i <= p->last_reset_cause_size;
14740 i++) {
14741 vty_out(vty, "%02X", *msg++);
14742
14743 if (i != p->last_reset_cause_size) {
14744 if (i % 16 == 0) {
14745 vty_out(vty, "\n ");
14746 } else if (i % 4 == 0) {
14747 vty_out(vty, " ");
14748 }
14749 }
14750 }
14751 vty_out(vty, "\n");
14752 }
14753 }
14754 }
14755
14756 if (CHECK_FLAG(p->sflags, PEER_STATUS_PREFIX_OVERFLOW)) {
14757 if (use_json)
14758 json_object_boolean_true_add(json_neigh,
14759 "prefixesConfigExceedMax");
14760 else
14761 vty_out(vty,
14762 " Peer had exceeded the max. no. of prefixes configured.\n");
14763
14764 if (p->t_pmax_restart) {
14765 if (use_json) {
14766 json_object_boolean_true_add(
14767 json_neigh, "reducePrefixNumFrom");
14768 json_object_int_add(json_neigh,
14769 "restartInTimerMsec",
14770 thread_timer_remain_second(
14771 p->t_pmax_restart)
14772 * 1000);
14773 } else
14774 vty_out(vty,
14775 " Reduce the no. of prefix from %s, will restart in %ld seconds\n",
14776 p->host, thread_timer_remain_second(
14777 p->t_pmax_restart));
14778 } else {
14779 if (use_json)
14780 json_object_boolean_true_add(
14781 json_neigh,
14782 "reducePrefixNumAndClearIpBgp");
14783 else
14784 vty_out(vty,
14785 " Reduce the no. of prefix and clear ip bgp %s to restore peering\n",
14786 p->host);
14787 }
14788 }
14789
14790 /* EBGP Multihop and GTSM */
14791 if (p->sort != BGP_PEER_IBGP) {
14792 if (use_json) {
14793 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14794 json_object_int_add(json_neigh,
14795 "externalBgpNbrMaxHopsAway",
14796 p->gtsm_hops);
14797 else
14798 json_object_int_add(json_neigh,
14799 "externalBgpNbrMaxHopsAway",
14800 p->ttl);
14801 } else {
14802 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14803 vty_out(vty,
14804 " External BGP neighbor may be up to %d hops away.\n",
14805 p->gtsm_hops);
14806 else
14807 vty_out(vty,
14808 " External BGP neighbor may be up to %d hops away.\n",
14809 p->ttl);
14810 }
14811 } else {
14812 if (use_json) {
14813 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14814 json_object_int_add(json_neigh,
14815 "internalBgpNbrMaxHopsAway",
14816 p->gtsm_hops);
14817 else
14818 json_object_int_add(json_neigh,
14819 "internalBgpNbrMaxHopsAway",
14820 p->ttl);
14821 } else {
14822 if (p->gtsm_hops > BGP_GTSM_HOPS_DISABLED)
14823 vty_out(vty,
14824 " Internal BGP neighbor may be up to %d hops away.\n",
14825 p->gtsm_hops);
14826 else
14827 vty_out(vty,
14828 " Internal BGP neighbor may be up to %d hops away.\n",
14829 p->ttl);
14830 }
14831 }
14832
14833 /* Local address. */
14834 if (p->su_local) {
14835 if (use_json) {
14836 json_object_string_addf(json_neigh, "hostLocal", "%pSU",
14837 p->su_local);
14838 json_object_int_add(json_neigh, "portLocal",
14839 ntohs(p->su_local->sin.sin_port));
14840 } else
14841 vty_out(vty, "Local host: %pSU, Local port: %d\n",
14842 p->su_local, ntohs(p->su_local->sin.sin_port));
14843 } else {
14844 if (use_json) {
14845 json_object_string_add(json_neigh, "hostLocal",
14846 "Unknown");
14847 json_object_int_add(json_neigh, "portLocal", -1);
14848 }
14849 }
14850
14851 /* Remote address. */
14852 if (p->su_remote) {
14853 if (use_json) {
14854 json_object_string_addf(json_neigh, "hostForeign",
14855 "%pSU", p->su_remote);
14856 json_object_int_add(json_neigh, "portForeign",
14857 ntohs(p->su_remote->sin.sin_port));
14858 } else
14859 vty_out(vty, "Foreign host: %pSU, Foreign port: %d\n",
14860 p->su_remote,
14861 ntohs(p->su_remote->sin.sin_port));
14862 } else {
14863 if (use_json) {
14864 json_object_string_add(json_neigh, "hostForeign",
14865 "Unknown");
14866 json_object_int_add(json_neigh, "portForeign", -1);
14867 }
14868 }
14869
14870 /* Nexthop display. */
14871 if (p->su_local) {
14872 if (use_json) {
14873 json_object_string_addf(json_neigh, "nexthop", "%pI4",
14874 &p->nexthop.v4);
14875 json_object_string_addf(json_neigh, "nexthopGlobal",
14876 "%pI6", &p->nexthop.v6_global);
14877 json_object_string_addf(json_neigh, "nexthopLocal",
14878 "%pI6", &p->nexthop.v6_local);
14879 if (p->shared_network)
14880 json_object_string_add(json_neigh,
14881 "bgpConnection",
14882 "sharedNetwork");
14883 else
14884 json_object_string_add(json_neigh,
14885 "bgpConnection",
14886 "nonSharedNetwork");
14887 } else {
14888 vty_out(vty, "Nexthop: %pI4\n", &p->nexthop.v4);
14889 vty_out(vty, "Nexthop global: %pI6\n",
14890 &p->nexthop.v6_global);
14891 vty_out(vty, "Nexthop local: %pI6\n",
14892 &p->nexthop.v6_local);
14893 vty_out(vty, "BGP connection: %s\n",
14894 p->shared_network ? "shared network"
14895 : "non shared network");
14896 }
14897 } else {
14898 if (use_json) {
14899 json_object_string_add(json_neigh, "nexthop",
14900 "Unknown");
14901 json_object_string_add(json_neigh, "nexthopGlobal",
14902 "Unknown");
14903 json_object_string_add(json_neigh, "nexthopLocal",
14904 "Unknown");
14905 json_object_string_add(json_neigh, "bgpConnection",
14906 "Unknown");
14907 }
14908 }
14909
14910 /* Timer information. */
14911 if (use_json) {
14912 json_object_int_add(json_neigh, "connectRetryTimer",
14913 p->v_connect);
14914 if (peer_established(p)) {
14915 json_object_int_add(json_neigh, "estimatedRttInMsecs",
14916 p->rtt);
14917 if (CHECK_FLAG(p->flags, PEER_FLAG_RTT_SHUTDOWN)) {
14918 json_object_int_add(json_neigh,
14919 "shutdownRttInMsecs",
14920 p->rtt_expected);
14921 json_object_int_add(json_neigh,
14922 "shutdownRttAfterCount",
14923 p->rtt_keepalive_rcv);
14924 }
14925 }
14926 if (p->t_start)
14927 json_object_int_add(
14928 json_neigh, "nextStartTimerDueInMsecs",
14929 thread_timer_remain_second(p->t_start) * 1000);
14930 if (p->t_connect)
14931 json_object_int_add(
14932 json_neigh, "nextConnectTimerDueInMsecs",
14933 thread_timer_remain_second(p->t_connect)
14934 * 1000);
14935 if (p->t_routeadv) {
14936 json_object_int_add(json_neigh, "mraiInterval",
14937 p->v_routeadv);
14938 json_object_int_add(
14939 json_neigh, "mraiTimerExpireInMsecs",
14940 thread_timer_remain_second(p->t_routeadv)
14941 * 1000);
14942 }
14943 if (p->password)
14944 json_object_int_add(json_neigh, "authenticationEnabled",
14945 1);
14946
14947 if (p->t_read)
14948 json_object_string_add(json_neigh, "readThread", "on");
14949 else
14950 json_object_string_add(json_neigh, "readThread", "off");
14951
14952 if (CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON))
14953 json_object_string_add(json_neigh, "writeThread", "on");
14954 else
14955 json_object_string_add(json_neigh, "writeThread",
14956 "off");
14957 } else {
14958 vty_out(vty, "BGP Connect Retry Timer in Seconds: %d\n",
14959 p->v_connect);
14960 if (peer_established(p)) {
14961 vty_out(vty, "Estimated round trip time: %d ms\n",
14962 p->rtt);
14963 if (CHECK_FLAG(p->flags, PEER_FLAG_RTT_SHUTDOWN))
14964 vty_out(vty,
14965 "Shutdown when RTT > %dms, count > %u\n",
14966 p->rtt_expected, p->rtt_keepalive_rcv);
14967 }
14968 if (p->t_start)
14969 vty_out(vty, "Next start timer due in %ld seconds\n",
14970 thread_timer_remain_second(p->t_start));
14971 if (p->t_connect)
14972 vty_out(vty, "Next connect timer due in %ld seconds\n",
14973 thread_timer_remain_second(p->t_connect));
14974 if (p->t_routeadv)
14975 vty_out(vty,
14976 "MRAI (interval %u) timer expires in %ld seconds\n",
14977 p->v_routeadv,
14978 thread_timer_remain_second(p->t_routeadv));
14979 if (p->password)
14980 vty_out(vty, "Peer Authentication Enabled\n");
14981
14982 vty_out(vty, "Read thread: %s Write thread: %s FD used: %d\n",
14983 p->t_read ? "on" : "off",
14984 CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON)
14985 ? "on"
14986 : "off", p->fd);
14987 }
14988
14989 if (p->notify.code == BGP_NOTIFY_OPEN_ERR
14990 && p->notify.subcode == BGP_NOTIFY_OPEN_UNSUP_CAPBL)
14991 bgp_capability_vty_out(vty, p, use_json, json_neigh);
14992
14993 if (!use_json)
14994 vty_out(vty, "\n");
14995
14996 /* BFD information. */
14997 if (p->bfd_config)
14998 bgp_bfd_show_info(vty, p, json_neigh);
14999
15000 if (use_json) {
15001 if (p->conf_if) /* Configured interface name. */
15002 json_object_object_add(json, p->conf_if, json_neigh);
15003 else /* Configured IP address. */
15004 json_object_object_add(json, p->host, json_neigh);
15005 }
15006 }
15007
15008 static int bgp_show_neighbor_graceful_restart(struct vty *vty, struct bgp *bgp,
15009 enum show_type type,
15010 union sockunion *su,
15011 const char *conf_if, afi_t afi,
15012 json_object *json)
15013 {
15014 struct listnode *node, *nnode;
15015 struct peer *peer;
15016 bool found = false;
15017 safi_t safi = SAFI_UNICAST;
15018 json_object *json_neighbor = NULL;
15019
15020 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
15021
15022 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
15023 continue;
15024
15025 if ((peer->afc[afi][safi]) == 0)
15026 continue;
15027
15028 if (json)
15029 json_neighbor = json_object_new_object();
15030
15031 if (type == show_all) {
15032 bgp_show_peer_gr_status(vty, peer, json_neighbor);
15033
15034 if (json)
15035 json_object_object_add(json, peer->host,
15036 json_neighbor);
15037
15038 } else if (type == show_peer) {
15039 if (conf_if) {
15040 if ((peer->conf_if
15041 && !strcmp(peer->conf_if, conf_if))
15042 || (peer->hostname
15043 && !strcmp(peer->hostname, conf_if))) {
15044 found = true;
15045 bgp_show_peer_gr_status(vty, peer,
15046 json_neighbor);
15047 }
15048 } else {
15049 if (sockunion_same(&peer->su, su)) {
15050 found = true;
15051 bgp_show_peer_gr_status(vty, peer,
15052 json_neighbor);
15053 }
15054 }
15055 if (json) {
15056 if (found)
15057 json_object_object_add(json, peer->host,
15058 json_neighbor);
15059 else
15060 json_object_free(json_neighbor);
15061 }
15062 }
15063
15064 if (found)
15065 break;
15066 }
15067
15068 if (type == show_peer && !found) {
15069 if (json)
15070 json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
15071 else
15072 vty_out(vty, "%% No such neighbor\n");
15073 }
15074
15075 if (!json)
15076 vty_out(vty, "\n");
15077
15078 return CMD_SUCCESS;
15079 }
15080
15081 static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
15082 enum show_type type, union sockunion *su,
15083 const char *conf_if, bool use_json,
15084 json_object *json)
15085 {
15086 struct listnode *node, *nnode;
15087 struct peer *peer;
15088 int find = 0;
15089 bool nbr_output = false;
15090 afi_t afi = AFI_MAX;
15091 safi_t safi = SAFI_MAX;
15092
15093 if (type == show_ipv4_peer || type == show_ipv4_all) {
15094 afi = AFI_IP;
15095 } else if (type == show_ipv6_peer || type == show_ipv6_all) {
15096 afi = AFI_IP6;
15097 }
15098
15099 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
15100 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
15101 continue;
15102
15103 switch (type) {
15104 case show_all:
15105 bgp_show_peer(vty, peer, use_json, json);
15106 nbr_output = true;
15107 break;
15108 case show_peer:
15109 if (conf_if) {
15110 if ((peer->conf_if
15111 && !strcmp(peer->conf_if, conf_if))
15112 || (peer->hostname
15113 && !strcmp(peer->hostname, conf_if))) {
15114 find = 1;
15115 bgp_show_peer(vty, peer, use_json,
15116 json);
15117 }
15118 } else {
15119 if (sockunion_same(&peer->su, su)) {
15120 find = 1;
15121 bgp_show_peer(vty, peer, use_json,
15122 json);
15123 }
15124 }
15125 break;
15126 case show_ipv4_peer:
15127 case show_ipv6_peer:
15128 FOREACH_SAFI (safi) {
15129 if (peer->afc[afi][safi]) {
15130 if (conf_if) {
15131 if ((peer->conf_if
15132 && !strcmp(peer->conf_if, conf_if))
15133 || (peer->hostname
15134 && !strcmp(peer->hostname, conf_if))) {
15135 find = 1;
15136 bgp_show_peer(vty, peer, use_json,
15137 json);
15138 break;
15139 }
15140 } else {
15141 if (sockunion_same(&peer->su, su)) {
15142 find = 1;
15143 bgp_show_peer(vty, peer, use_json,
15144 json);
15145 break;
15146 }
15147 }
15148 }
15149 }
15150 break;
15151 case show_ipv4_all:
15152 case show_ipv6_all:
15153 FOREACH_SAFI (safi) {
15154 if (peer->afc[afi][safi]) {
15155 bgp_show_peer(vty, peer, use_json, json);
15156 nbr_output = true;
15157 break;
15158 }
15159 }
15160 break;
15161 }
15162 }
15163
15164 if ((type == show_peer || type == show_ipv4_peer ||
15165 type == show_ipv6_peer) && !find) {
15166 if (use_json)
15167 json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
15168 else
15169 vty_out(vty, "%% No such neighbor in this view/vrf\n");
15170 }
15171
15172 if (type != show_peer && type != show_ipv4_peer &&
15173 type != show_ipv6_peer && !nbr_output && !use_json)
15174 vty_out(vty, "%% No BGP neighbors found\n");
15175
15176 if (use_json) {
15177 vty_out(vty, "%s\n", json_object_to_json_string_ext(
15178 json, JSON_C_TO_STRING_PRETTY));
15179 } else {
15180 vty_out(vty, "\n");
15181 }
15182
15183 return CMD_SUCCESS;
15184 }
15185
15186 static void bgp_show_neighbor_graceful_restart_vty(struct vty *vty,
15187 enum show_type type,
15188 const char *ip_str,
15189 afi_t afi, json_object *json)
15190 {
15191
15192 int ret;
15193 struct bgp *bgp;
15194 union sockunion su;
15195
15196 bgp = bgp_get_default();
15197
15198 if (!bgp)
15199 return;
15200
15201 if (!json)
15202 bgp_show_global_graceful_restart_mode_vty(vty, bgp);
15203
15204 if (ip_str) {
15205 ret = str2sockunion(ip_str, &su);
15206 if (ret < 0)
15207 bgp_show_neighbor_graceful_restart(vty, bgp, type, NULL,
15208 ip_str, afi, json);
15209 else
15210 bgp_show_neighbor_graceful_restart(vty, bgp, type, &su,
15211 NULL, afi, json);
15212 } else
15213 bgp_show_neighbor_graceful_restart(vty, bgp, type, NULL, NULL,
15214 afi, json);
15215 }
15216
15217 static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
15218 enum show_type type,
15219 const char *ip_str,
15220 bool use_json)
15221 {
15222 struct listnode *node, *nnode;
15223 struct bgp *bgp;
15224 union sockunion su;
15225 json_object *json = NULL;
15226 int ret, is_first = 1;
15227 bool nbr_output = false;
15228
15229 if (use_json)
15230 vty_out(vty, "{\n");
15231
15232 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
15233 nbr_output = true;
15234 if (use_json) {
15235 if (!(json = json_object_new_object())) {
15236 flog_err(
15237 EC_BGP_JSON_MEM_ERROR,
15238 "Unable to allocate memory for JSON object");
15239 vty_out(vty,
15240 "{\"error\": {\"message:\": \"Unable to allocate memory for JSON object\"}}}\n");
15241 return;
15242 }
15243
15244 json_object_int_add(json, "vrfId",
15245 (bgp->vrf_id == VRF_UNKNOWN)
15246 ? -1
15247 : (int64_t)bgp->vrf_id);
15248 json_object_string_add(
15249 json, "vrfName",
15250 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15251 ? VRF_DEFAULT_NAME
15252 : bgp->name);
15253
15254 if (!is_first)
15255 vty_out(vty, ",\n");
15256 else
15257 is_first = 0;
15258
15259 vty_out(vty, "\"%s\":",
15260 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15261 ? VRF_DEFAULT_NAME
15262 : bgp->name);
15263 } else {
15264 vty_out(vty, "\nInstance %s:\n",
15265 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15266 ? VRF_DEFAULT_NAME
15267 : bgp->name);
15268 }
15269
15270 if (type == show_peer || type == show_ipv4_peer ||
15271 type == show_ipv6_peer) {
15272 ret = str2sockunion(ip_str, &su);
15273 if (ret < 0)
15274 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
15275 use_json, json);
15276 else
15277 bgp_show_neighbor(vty, bgp, type, &su, NULL,
15278 use_json, json);
15279 } else {
15280 bgp_show_neighbor(vty, bgp, type, NULL, NULL,
15281 use_json, json);
15282 }
15283 json_object_free(json);
15284 json = NULL;
15285 }
15286
15287 if (use_json)
15288 vty_out(vty, "}\n");
15289 else if (!nbr_output)
15290 vty_out(vty, "%% BGP instance not found\n");
15291 }
15292
15293 static int bgp_show_neighbor_vty(struct vty *vty, const char *name,
15294 enum show_type type, const char *ip_str,
15295 bool use_json)
15296 {
15297 int ret;
15298 struct bgp *bgp;
15299 union sockunion su;
15300 json_object *json = NULL;
15301
15302 if (name) {
15303 if (strmatch(name, "all")) {
15304 bgp_show_all_instances_neighbors_vty(vty, type, ip_str,
15305 use_json);
15306 return CMD_SUCCESS;
15307 } else {
15308 bgp = bgp_lookup_by_name(name);
15309 if (!bgp) {
15310 if (use_json) {
15311 json = json_object_new_object();
15312 vty_json(vty, json);
15313 } else
15314 vty_out(vty,
15315 "%% BGP instance not found\n");
15316
15317 return CMD_WARNING;
15318 }
15319 }
15320 } else {
15321 bgp = bgp_get_default();
15322 }
15323
15324 if (bgp) {
15325 json = json_object_new_object();
15326 if (ip_str) {
15327 ret = str2sockunion(ip_str, &su);
15328 if (ret < 0)
15329 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
15330 use_json, json);
15331 else
15332 bgp_show_neighbor(vty, bgp, type, &su, NULL,
15333 use_json, json);
15334 } else {
15335 bgp_show_neighbor(vty, bgp, type, NULL, NULL, use_json,
15336 json);
15337 }
15338 json_object_free(json);
15339 } else {
15340 if (use_json)
15341 vty_out(vty, "{}\n");
15342 else
15343 vty_out(vty, "%% BGP instance not found\n");
15344 }
15345
15346 return CMD_SUCCESS;
15347 }
15348
15349
15350
15351 /* "show [ip] bgp neighbors graceful-restart" commands. */
15352 DEFUN (show_ip_bgp_neighbors_graceful_restart,
15353 show_ip_bgp_neighbors_graceful_restart_cmd,
15354 "show bgp [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] graceful-restart [json]",
15355 SHOW_STR
15356 BGP_STR
15357 IP_STR
15358 IPV6_STR
15359 NEIGHBOR_STR
15360 "Neighbor to display information about\n"
15361 "Neighbor to display information about\n"
15362 "Neighbor on BGP configured interface\n"
15363 GR_SHOW
15364 JSON_STR)
15365 {
15366 char *sh_arg = NULL;
15367 enum show_type sh_type;
15368 int idx = 0;
15369 afi_t afi = AFI_MAX;
15370 bool uj = use_json(argc, argv);
15371
15372 if (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
15373 afi = AFI_MAX;
15374
15375 idx++;
15376
15377 if (argv_find(argv, argc, "A.B.C.D", &idx)
15378 || argv_find(argv, argc, "X:X::X:X", &idx)
15379 || argv_find(argv, argc, "WORD", &idx)) {
15380 sh_type = show_peer;
15381 sh_arg = argv[idx]->arg;
15382 } else
15383 sh_type = show_all;
15384
15385 if (!argv_find(argv, argc, "graceful-restart", &idx))
15386 return CMD_SUCCESS;
15387
15388
15389 return bgp_show_neighbor_graceful_restart_afi_all(vty, sh_type, sh_arg,
15390 afi, uj);
15391 }
15392
15393 /* "show [ip] bgp neighbors" commands. */
15394 DEFUN (show_ip_bgp_neighbors,
15395 show_ip_bgp_neighbors_cmd,
15396 "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] [json]",
15397 SHOW_STR
15398 IP_STR
15399 BGP_STR
15400 BGP_INSTANCE_HELP_STR
15401 BGP_AF_STR
15402 BGP_AF_STR
15403 "Detailed information on TCP and BGP neighbor connections\n"
15404 "Neighbor to display information about\n"
15405 "Neighbor to display information about\n"
15406 "Neighbor on BGP configured interface\n"
15407 JSON_STR)
15408 {
15409 char *vrf = NULL;
15410 char *sh_arg = NULL;
15411 enum show_type sh_type;
15412 afi_t afi = AFI_MAX;
15413
15414 bool uj = use_json(argc, argv);
15415
15416 int idx = 0;
15417
15418 /* [<vrf> VIEWVRFNAME] */
15419 if (argv_find(argv, argc, "vrf", &idx)) {
15420 vrf = argv[idx + 1]->arg;
15421 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15422 vrf = NULL;
15423 } else if (argv_find(argv, argc, "view", &idx))
15424 /* [<view> VIEWVRFNAME] */
15425 vrf = argv[idx + 1]->arg;
15426
15427 idx++;
15428
15429 if (argv_find(argv, argc, "ipv4", &idx)) {
15430 sh_type = show_ipv4_all;
15431 afi = AFI_IP;
15432 } else if (argv_find(argv, argc, "ipv6", &idx)) {
15433 sh_type = show_ipv6_all;
15434 afi = AFI_IP6;
15435 } else {
15436 sh_type = show_all;
15437 }
15438
15439 if (argv_find(argv, argc, "A.B.C.D", &idx)
15440 || argv_find(argv, argc, "X:X::X:X", &idx)
15441 || argv_find(argv, argc, "WORD", &idx)) {
15442 sh_type = show_peer;
15443 sh_arg = argv[idx]->arg;
15444 }
15445
15446 if (sh_type == show_peer && afi == AFI_IP) {
15447 sh_type = show_ipv4_peer;
15448 } else if (sh_type == show_peer && afi == AFI_IP6) {
15449 sh_type = show_ipv6_peer;
15450 }
15451
15452 return bgp_show_neighbor_vty(vty, vrf, sh_type, sh_arg, uj);
15453 }
15454
15455 /* Show BGP's AS paths internal data. There are both `show [ip] bgp
15456 paths' and `show ip mbgp paths'. Those functions results are the
15457 same.*/
15458 DEFUN (show_ip_bgp_paths,
15459 show_ip_bgp_paths_cmd,
15460 "show [ip] bgp ["BGP_SAFI_CMD_STR"] paths",
15461 SHOW_STR
15462 IP_STR
15463 BGP_STR
15464 BGP_SAFI_HELP_STR
15465 "Path information\n")
15466 {
15467 vty_out(vty, "Address Refcnt Path\n");
15468 aspath_print_all_vty(vty);
15469 return CMD_SUCCESS;
15470 }
15471
15472 #include "hash.h"
15473
15474 static void community_show_all_iterator(struct hash_bucket *bucket,
15475 struct vty *vty)
15476 {
15477 struct community *com;
15478
15479 com = (struct community *)bucket->data;
15480 vty_out(vty, "[%p] (%ld) %s\n", (void *)com, com->refcnt,
15481 community_str(com, false, false));
15482 }
15483
15484 /* Show BGP's community internal data. */
15485 DEFUN (show_ip_bgp_community_info,
15486 show_ip_bgp_community_info_cmd,
15487 "show [ip] bgp community-info",
15488 SHOW_STR
15489 IP_STR
15490 BGP_STR
15491 "List all bgp community information\n")
15492 {
15493 vty_out(vty, "Address Refcnt Community\n");
15494
15495 hash_iterate(community_hash(),
15496 (void (*)(struct hash_bucket *,
15497 void *))community_show_all_iterator,
15498 vty);
15499
15500 return CMD_SUCCESS;
15501 }
15502
15503 static void lcommunity_show_all_iterator(struct hash_bucket *bucket,
15504 struct vty *vty)
15505 {
15506 struct lcommunity *lcom;
15507
15508 lcom = (struct lcommunity *)bucket->data;
15509 vty_out(vty, "[%p] (%ld) %s\n", (void *)lcom, lcom->refcnt,
15510 lcommunity_str(lcom, false, false));
15511 }
15512
15513 /* Show BGP's community internal data. */
15514 DEFUN (show_ip_bgp_lcommunity_info,
15515 show_ip_bgp_lcommunity_info_cmd,
15516 "show ip bgp large-community-info",
15517 SHOW_STR
15518 IP_STR
15519 BGP_STR
15520 "List all bgp large-community information\n")
15521 {
15522 vty_out(vty, "Address Refcnt Large-community\n");
15523
15524 hash_iterate(lcommunity_hash(),
15525 (void (*)(struct hash_bucket *,
15526 void *))lcommunity_show_all_iterator,
15527 vty);
15528
15529 return CMD_SUCCESS;
15530 }
15531 /* Graceful Restart */
15532
15533 static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
15534 struct bgp *bgp)
15535 {
15536
15537
15538 vty_out(vty, "\n%s", SHOW_GR_HEADER);
15539
15540 enum global_mode bgp_global_gr_mode = bgp_global_gr_mode_get(bgp);
15541
15542 switch (bgp_global_gr_mode) {
15543
15544 case GLOBAL_HELPER:
15545 vty_out(vty, "Global BGP GR Mode : Helper\n");
15546 break;
15547
15548 case GLOBAL_GR:
15549 vty_out(vty, "Global BGP GR Mode : Restart\n");
15550 break;
15551
15552 case GLOBAL_DISABLE:
15553 vty_out(vty, "Global BGP GR Mode : Disable\n");
15554 break;
15555
15556 case GLOBAL_INVALID:
15557 vty_out(vty,
15558 "Global BGP GR Mode Invalid\n");
15559 break;
15560 }
15561 vty_out(vty, "\n");
15562 }
15563
15564 static int bgp_show_neighbor_graceful_restart_afi_all(struct vty *vty,
15565 enum show_type type,
15566 const char *ip_str,
15567 afi_t afi, bool use_json)
15568 {
15569 json_object *json = NULL;
15570
15571 if (use_json)
15572 json = json_object_new_object();
15573
15574 if ((afi == AFI_MAX) && (ip_str == NULL)) {
15575 afi = AFI_IP;
15576
15577 while ((afi != AFI_L2VPN) && (afi < AFI_MAX)) {
15578
15579 bgp_show_neighbor_graceful_restart_vty(
15580 vty, type, ip_str, afi, json);
15581 afi++;
15582 }
15583 } else if (afi != AFI_MAX) {
15584 bgp_show_neighbor_graceful_restart_vty(vty, type, ip_str, afi,
15585 json);
15586 } else {
15587 if (json)
15588 json_object_free(json);
15589 return CMD_ERR_INCOMPLETE;
15590 }
15591
15592 if (json)
15593 vty_json(vty, json);
15594
15595 return CMD_SUCCESS;
15596 }
15597 /* Graceful Restart */
15598
15599 DEFUN (show_ip_bgp_attr_info,
15600 show_ip_bgp_attr_info_cmd,
15601 "show [ip] bgp attribute-info",
15602 SHOW_STR
15603 IP_STR
15604 BGP_STR
15605 "List all bgp attribute information\n")
15606 {
15607 attr_show_all(vty);
15608 return CMD_SUCCESS;
15609 }
15610
15611 static int bgp_show_route_leak_vty(struct vty *vty, const char *name,
15612 afi_t afi, safi_t safi,
15613 bool use_json, json_object *json)
15614 {
15615 struct bgp *bgp;
15616 struct listnode *node;
15617 char *vname;
15618 char *ecom_str;
15619 enum vpn_policy_direction dir;
15620
15621 if (json) {
15622 json_object *json_import_vrfs = NULL;
15623 json_object *json_export_vrfs = NULL;
15624
15625 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
15626
15627 if (!bgp) {
15628 vty_json(vty, json);
15629
15630 return CMD_WARNING;
15631 }
15632
15633 /* Provide context for the block */
15634 json_object_string_add(json, "vrf", name ? name : "default");
15635 json_object_string_add(json, "afiSafi",
15636 get_afi_safi_str(afi, safi, true));
15637
15638 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15639 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
15640 json_object_string_add(json, "importFromVrfs", "none");
15641 json_object_string_add(json, "importRts", "none");
15642 } else {
15643 json_import_vrfs = json_object_new_array();
15644
15645 for (ALL_LIST_ELEMENTS_RO(
15646 bgp->vpn_policy[afi].import_vrf,
15647 node, vname))
15648 json_object_array_add(json_import_vrfs,
15649 json_object_new_string(vname));
15650
15651 json_object_object_add(json, "importFromVrfs",
15652 json_import_vrfs);
15653 dir = BGP_VPN_POLICY_DIR_FROMVPN;
15654 if (bgp->vpn_policy[afi].rtlist[dir]) {
15655 ecom_str = ecommunity_ecom2str(
15656 bgp->vpn_policy[afi].rtlist[dir],
15657 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15658 json_object_string_add(json, "importRts",
15659 ecom_str);
15660 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15661 } else
15662 json_object_string_add(json, "importRts",
15663 "none");
15664 }
15665
15666 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15667 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
15668 json_object_string_add(json, "exportToVrfs", "none");
15669 json_object_string_add(json, "routeDistinguisher",
15670 "none");
15671 json_object_string_add(json, "exportRts", "none");
15672 } else {
15673 json_export_vrfs = json_object_new_array();
15674
15675 for (ALL_LIST_ELEMENTS_RO(
15676 bgp->vpn_policy[afi].export_vrf,
15677 node, vname))
15678 json_object_array_add(json_export_vrfs,
15679 json_object_new_string(vname));
15680 json_object_object_add(json, "exportToVrfs",
15681 json_export_vrfs);
15682 json_object_string_addf(
15683 json, "routeDistinguisher", "%s",
15684 bgp->vpn_policy[afi].tovpn_rd_pretty);
15685 dir = BGP_VPN_POLICY_DIR_TOVPN;
15686 if (bgp->vpn_policy[afi].rtlist[dir]) {
15687 ecom_str = ecommunity_ecom2str(
15688 bgp->vpn_policy[afi].rtlist[dir],
15689 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15690 json_object_string_add(json, "exportRts",
15691 ecom_str);
15692 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15693 } else
15694 json_object_string_add(json, "exportRts",
15695 "none");
15696 }
15697
15698 if (use_json) {
15699 vty_json(vty, json);
15700 }
15701 } else {
15702 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
15703
15704 if (!bgp) {
15705 vty_out(vty, "%% No such BGP instance exist\n");
15706 return CMD_WARNING;
15707 }
15708
15709 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15710 BGP_CONFIG_VRF_TO_VRF_IMPORT))
15711 vty_out(vty,
15712 "This VRF is not importing %s routes from any other VRF\n",
15713 get_afi_safi_str(afi, safi, false));
15714 else {
15715 vty_out(vty,
15716 "This VRF is importing %s routes from the following VRFs:\n",
15717 get_afi_safi_str(afi, safi, false));
15718
15719 for (ALL_LIST_ELEMENTS_RO(
15720 bgp->vpn_policy[afi].import_vrf,
15721 node, vname))
15722 vty_out(vty, " %s\n", vname);
15723
15724 dir = BGP_VPN_POLICY_DIR_FROMVPN;
15725 ecom_str = NULL;
15726 if (bgp->vpn_policy[afi].rtlist[dir]) {
15727 ecom_str = ecommunity_ecom2str(
15728 bgp->vpn_policy[afi].rtlist[dir],
15729 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15730 vty_out(vty, "Import RT(s): %s\n", ecom_str);
15731
15732 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15733 } else
15734 vty_out(vty, "Import RT(s):\n");
15735 }
15736
15737 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
15738 BGP_CONFIG_VRF_TO_VRF_EXPORT))
15739 vty_out(vty,
15740 "This VRF is not exporting %s routes to any other VRF\n",
15741 get_afi_safi_str(afi, safi, false));
15742 else {
15743 vty_out(vty,
15744 "This VRF is exporting %s routes to the following VRFs:\n",
15745 get_afi_safi_str(afi, safi, false));
15746
15747 for (ALL_LIST_ELEMENTS_RO(
15748 bgp->vpn_policy[afi].export_vrf,
15749 node, vname))
15750 vty_out(vty, " %s\n", vname);
15751
15752 vty_out(vty, "RD: ");
15753 vty_out(vty, BGP_RD_AS_FORMAT(bgp->asnotation),
15754 &bgp->vpn_policy[afi].tovpn_rd);
15755 vty_out(vty, "\n");
15756
15757 dir = BGP_VPN_POLICY_DIR_TOVPN;
15758 if (bgp->vpn_policy[afi].rtlist[dir]) {
15759 ecom_str = ecommunity_ecom2str(
15760 bgp->vpn_policy[afi].rtlist[dir],
15761 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
15762 vty_out(vty, "Export RT: %s\n", ecom_str);
15763 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
15764 } else
15765 vty_out(vty, "Import RT(s):\n");
15766 }
15767 }
15768
15769 return CMD_SUCCESS;
15770 }
15771
15772 static int bgp_show_all_instance_route_leak_vty(struct vty *vty, afi_t afi,
15773 safi_t safi, bool use_json)
15774 {
15775 struct listnode *node, *nnode;
15776 struct bgp *bgp;
15777 char *vrf_name = NULL;
15778 json_object *json = NULL;
15779 json_object *json_vrf = NULL;
15780 json_object *json_vrfs = NULL;
15781
15782 if (use_json) {
15783 json = json_object_new_object();
15784 json_vrfs = json_object_new_object();
15785 }
15786
15787 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
15788
15789 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT)
15790 vrf_name = bgp->name;
15791
15792 if (use_json) {
15793 json_vrf = json_object_new_object();
15794 } else {
15795 vty_out(vty, "\nInstance %s:\n",
15796 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15797 ? VRF_DEFAULT_NAME : bgp->name);
15798 }
15799 bgp_show_route_leak_vty(vty, vrf_name, afi, safi, 0, json_vrf);
15800 if (use_json) {
15801 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15802 json_object_object_add(json_vrfs,
15803 VRF_DEFAULT_NAME, json_vrf);
15804 else
15805 json_object_object_add(json_vrfs, vrf_name,
15806 json_vrf);
15807 }
15808 }
15809
15810 if (use_json) {
15811 json_object_object_add(json, "vrfs", json_vrfs);
15812 vty_json(vty, json);
15813 }
15814
15815 return CMD_SUCCESS;
15816 }
15817
15818 /* "show [ip] bgp route-leak" command. */
15819 DEFUN (show_ip_bgp_route_leak,
15820 show_ip_bgp_route_leak_cmd,
15821 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] route-leak [json]",
15822 SHOW_STR
15823 IP_STR
15824 BGP_STR
15825 BGP_INSTANCE_HELP_STR
15826 BGP_AFI_HELP_STR
15827 BGP_SAFI_HELP_STR
15828 "Route leaking information\n"
15829 JSON_STR)
15830 {
15831 char *vrf = NULL;
15832 afi_t afi = AFI_MAX;
15833 safi_t safi = SAFI_MAX;
15834
15835 bool uj = use_json(argc, argv);
15836 int idx = 0;
15837 json_object *json = NULL;
15838
15839 /* show [ip] bgp */
15840 if (argv_find(argv, argc, "ip", &idx)) {
15841 afi = AFI_IP;
15842 safi = SAFI_UNICAST;
15843 }
15844 /* [vrf VIEWVRFNAME] */
15845 if (argv_find(argv, argc, "view", &idx)) {
15846 vty_out(vty,
15847 "%% This command is not applicable to BGP views\n");
15848 return CMD_WARNING;
15849 }
15850
15851 if (argv_find(argv, argc, "vrf", &idx)) {
15852 vrf = argv[idx + 1]->arg;
15853 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15854 vrf = NULL;
15855 }
15856 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
15857 if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
15858 argv_find_and_parse_safi(argv, argc, &idx, &safi);
15859
15860 if (!((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST)) {
15861 vty_out(vty,
15862 "%% This command is applicable only for unicast ipv4|ipv6\n");
15863 return CMD_WARNING;
15864 }
15865
15866 if (vrf && strmatch(vrf, "all"))
15867 return bgp_show_all_instance_route_leak_vty(vty, afi, safi, uj);
15868
15869 if (uj)
15870 json = json_object_new_object();
15871
15872 return bgp_show_route_leak_vty(vty, vrf, afi, safi, uj, json);
15873 }
15874
15875 static void bgp_show_all_instances_updgrps_vty(struct vty *vty, afi_t afi,
15876 safi_t safi, bool uj)
15877 {
15878 struct listnode *node, *nnode;
15879 struct bgp *bgp;
15880
15881 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
15882 if (!uj)
15883 vty_out(vty, "\nInstance %s:\n",
15884 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
15885 ? VRF_DEFAULT_NAME
15886 : bgp->name);
15887
15888 update_group_show(bgp, afi, safi, vty, 0, uj);
15889 }
15890 }
15891
15892 static int bgp_show_update_groups(struct vty *vty, const char *name, int afi,
15893 int safi, uint64_t subgrp_id, bool uj)
15894 {
15895 struct bgp *bgp;
15896
15897 if (name) {
15898 if (strmatch(name, "all")) {
15899 bgp_show_all_instances_updgrps_vty(vty, afi, safi, uj);
15900 return CMD_SUCCESS;
15901 } else {
15902 bgp = bgp_lookup_by_name(name);
15903 }
15904 } else {
15905 bgp = bgp_get_default();
15906 }
15907
15908 if (bgp)
15909 update_group_show(bgp, afi, safi, vty, subgrp_id, uj);
15910 return CMD_SUCCESS;
15911 }
15912
15913 DEFUN (show_ip_bgp_updgrps,
15914 show_ip_bgp_updgrps_cmd,
15915 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] update-groups [SUBGROUP-ID] [json]",
15916 SHOW_STR
15917 IP_STR
15918 BGP_STR
15919 BGP_INSTANCE_HELP_STR
15920 BGP_AFI_HELP_STR
15921 BGP_SAFI_WITH_LABEL_HELP_STR
15922 "Detailed info about dynamic update groups\n"
15923 "Specific subgroup to display detailed info for\n"
15924 JSON_STR)
15925 {
15926 char *vrf = NULL;
15927 afi_t afi = AFI_IP6;
15928 safi_t safi = SAFI_UNICAST;
15929 uint64_t subgrp_id = 0;
15930
15931 int idx = 0;
15932
15933 bool uj = use_json(argc, argv);
15934
15935 /* show [ip] bgp */
15936 if (argv_find(argv, argc, "ip", &idx))
15937 afi = AFI_IP;
15938 /* [<vrf> VIEWVRFNAME] */
15939 if (argv_find(argv, argc, "vrf", &idx)) {
15940 vrf = argv[idx + 1]->arg;
15941 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
15942 vrf = NULL;
15943 } else if (argv_find(argv, argc, "view", &idx))
15944 /* [<view> VIEWVRFNAME] */
15945 vrf = argv[idx + 1]->arg;
15946 /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
15947 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
15948 argv_find_and_parse_safi(argv, argc, &idx, &safi);
15949 }
15950
15951 /* get subgroup id, if provided */
15952 idx = argc - 1;
15953 if (argv[idx]->type == VARIABLE_TKN)
15954 subgrp_id = strtoull(argv[idx]->arg, NULL, 10);
15955
15956 return (bgp_show_update_groups(vty, vrf, afi, safi, subgrp_id, uj));
15957 }
15958
15959 DEFUN (show_bgp_instance_all_ipv6_updgrps,
15960 show_bgp_instance_all_ipv6_updgrps_cmd,
15961 "show [ip] bgp <view|vrf> all update-groups [json]",
15962 SHOW_STR
15963 IP_STR
15964 BGP_STR
15965 BGP_INSTANCE_ALL_HELP_STR
15966 "Detailed info about dynamic update groups\n"
15967 JSON_STR)
15968 {
15969 bool uj = use_json(argc, argv);
15970
15971 bgp_show_all_instances_updgrps_vty(vty, AFI_IP6, SAFI_UNICAST, uj);
15972 return CMD_SUCCESS;
15973 }
15974
15975 DEFUN (show_bgp_l2vpn_evpn_updgrps,
15976 show_bgp_l2vpn_evpn_updgrps_cmd,
15977 "show [ip] bgp l2vpn evpn update-groups",
15978 SHOW_STR
15979 IP_STR
15980 BGP_STR
15981 "l2vpn address family\n"
15982 "evpn sub-address family\n"
15983 "Detailed info about dynamic update groups\n")
15984 {
15985 char *vrf = NULL;
15986 uint64_t subgrp_id = 0;
15987
15988 bgp_show_update_groups(vty, vrf, AFI_L2VPN, SAFI_EVPN, subgrp_id, 0);
15989 return CMD_SUCCESS;
15990 }
15991
15992 DEFUN (show_bgp_updgrps_stats,
15993 show_bgp_updgrps_stats_cmd,
15994 "show [ip] bgp update-groups statistics",
15995 SHOW_STR
15996 IP_STR
15997 BGP_STR
15998 "Detailed info about dynamic update groups\n"
15999 "Statistics\n")
16000 {
16001 struct bgp *bgp;
16002
16003 bgp = bgp_get_default();
16004 if (bgp)
16005 update_group_show_stats(bgp, vty);
16006
16007 return CMD_SUCCESS;
16008 }
16009
16010 DEFUN (show_bgp_instance_updgrps_stats,
16011 show_bgp_instance_updgrps_stats_cmd,
16012 "show [ip] bgp <view|vrf> VIEWVRFNAME update-groups statistics",
16013 SHOW_STR
16014 IP_STR
16015 BGP_STR
16016 BGP_INSTANCE_HELP_STR
16017 "Detailed info about dynamic update groups\n"
16018 "Statistics\n")
16019 {
16020 int idx_word = 3;
16021 struct bgp *bgp;
16022
16023 bgp = bgp_lookup_by_name(argv[idx_word]->arg);
16024 if (bgp)
16025 update_group_show_stats(bgp, vty);
16026
16027 return CMD_SUCCESS;
16028 }
16029
16030 static void show_bgp_updgrps_adj_info_aux(struct vty *vty, const char *name,
16031 afi_t afi, safi_t safi,
16032 const char *what, uint64_t subgrp_id)
16033 {
16034 struct bgp *bgp;
16035
16036 if (name)
16037 bgp = bgp_lookup_by_name(name);
16038 else
16039 bgp = bgp_get_default();
16040
16041 if (bgp) {
16042 if (!strcmp(what, "advertise-queue"))
16043 update_group_show_adj_queue(bgp, afi, safi, vty,
16044 subgrp_id);
16045 else if (!strcmp(what, "advertised-routes"))
16046 update_group_show_advertised(bgp, afi, safi, vty,
16047 subgrp_id);
16048 else if (!strcmp(what, "packet-queue"))
16049 update_group_show_packet_queue(bgp, afi, safi, vty,
16050 subgrp_id);
16051 }
16052 }
16053
16054 DEFPY(show_ip_bgp_instance_updgrps_adj_s,
16055 show_ip_bgp_instance_updgrps_adj_s_cmd,
16056 "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",
16057 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
16058 BGP_SAFI_HELP_STR
16059 "Detailed info about dynamic update groups\n"
16060 "Specific subgroup to display info for\n"
16061 "Advertisement queue\n"
16062 "Announced routes\n"
16063 "Packet queue\n")
16064 {
16065 uint64_t subgrp_id = 0;
16066 afi_t afiz;
16067 safi_t safiz;
16068 if (sgid)
16069 subgrp_id = strtoull(sgid, NULL, 10);
16070
16071 if (!ip && !afi)
16072 afiz = AFI_IP6;
16073 if (!ip && afi)
16074 afiz = bgp_vty_afi_from_str(afi);
16075 if (ip && !afi)
16076 afiz = AFI_IP;
16077 if (ip && afi) {
16078 afiz = bgp_vty_afi_from_str(afi);
16079 if (afiz != AFI_IP)
16080 vty_out(vty,
16081 "%% Cannot specify both 'ip' and 'ipv6'\n");
16082 return CMD_WARNING;
16083 }
16084
16085 safiz = safi ? bgp_vty_safi_from_str(safi) : SAFI_UNICAST;
16086
16087 show_bgp_updgrps_adj_info_aux(vty, vrf, afiz, safiz, rtq, subgrp_id);
16088 return CMD_SUCCESS;
16089 }
16090
16091 static int bgp_show_one_peer_group(struct vty *vty, struct peer_group *group,
16092 json_object *json)
16093 {
16094 struct listnode *node, *nnode;
16095 struct prefix *range;
16096 struct peer *conf;
16097 struct peer *peer;
16098 afi_t afi;
16099 safi_t safi;
16100 const char *peer_status;
16101 int lr_count;
16102 int dynamic;
16103 bool af_cfgd;
16104 json_object *json_peer_group = NULL;
16105 json_object *json_peer_group_afc = NULL;
16106 json_object *json_peer_group_members = NULL;
16107 json_object *json_peer_group_dynamic = NULL;
16108 json_object *json_peer_group_dynamic_af = NULL;
16109 json_object *json_peer_group_ranges = NULL;
16110
16111 conf = group->conf;
16112
16113 if (json) {
16114 json_peer_group = json_object_new_object();
16115 json_peer_group_afc = json_object_new_array();
16116 }
16117
16118 if (conf->as_type == AS_SPECIFIED || conf->as_type == AS_EXTERNAL) {
16119 if (json)
16120 asn_asn2json(json_peer_group, "remoteAs", conf->as,
16121 bgp_get_asnotation(conf->bgp));
16122 else {
16123 vty_out(vty, "\nBGP peer-group %s, remote AS ",
16124 group->name);
16125 vty_out(vty, ASN_FORMAT(bgp_get_asnotation(conf->bgp)),
16126 &conf->as);
16127 vty_out(vty, "\n");
16128 }
16129 } else if (conf->as_type == AS_INTERNAL) {
16130 if (json)
16131 asn_asn2json(json, "remoteAs", group->bgp->as,
16132 group->bgp->asnotation);
16133 else
16134 vty_out(vty, "\nBGP peer-group %s, remote AS %s\n",
16135 group->name, group->bgp->as_pretty);
16136 } else {
16137 if (!json)
16138 vty_out(vty, "\nBGP peer-group %s\n", group->name);
16139 }
16140
16141 if ((group->bgp->as == conf->as) || (conf->as_type == AS_INTERNAL)) {
16142 if (json)
16143 json_object_string_add(json_peer_group, "type",
16144 "internal");
16145 else
16146 vty_out(vty, " Peer-group type is internal\n");
16147 } else {
16148 if (json)
16149 json_object_string_add(json_peer_group, "type",
16150 "external");
16151 else
16152 vty_out(vty, " Peer-group type is external\n");
16153 }
16154
16155 /* Display AFs configured. */
16156 if (!json)
16157 vty_out(vty, " Configured address-families:");
16158
16159 FOREACH_AFI_SAFI (afi, safi) {
16160 if (conf->afc[afi][safi]) {
16161 af_cfgd = true;
16162 if (json)
16163 json_object_array_add(
16164 json_peer_group_afc,
16165 json_object_new_string(get_afi_safi_str(
16166 afi, safi, false)));
16167 else
16168 vty_out(vty, " %s;",
16169 get_afi_safi_str(afi, safi, false));
16170 }
16171 }
16172
16173 if (json) {
16174 json_object_object_add(json_peer_group,
16175 "addressFamiliesConfigured",
16176 json_peer_group_afc);
16177 } else {
16178 if (!af_cfgd)
16179 vty_out(vty, " none\n");
16180 else
16181 vty_out(vty, "\n");
16182 }
16183
16184 /* Display listen ranges (for dynamic neighbors), if any */
16185 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
16186 lr_count = listcount(group->listen_range[afi]);
16187 if (lr_count) {
16188 if (json) {
16189 if (!json_peer_group_dynamic)
16190 json_peer_group_dynamic =
16191 json_object_new_object();
16192
16193 json_peer_group_dynamic_af =
16194 json_object_new_object();
16195 json_peer_group_ranges =
16196 json_object_new_array();
16197 json_object_int_add(json_peer_group_dynamic_af,
16198 "count", lr_count);
16199 } else {
16200 vty_out(vty, " %d %s listen range(s)\n",
16201 lr_count, afi2str(afi));
16202 }
16203
16204 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node,
16205 nnode, range)) {
16206 if (json) {
16207 char buf[BUFSIZ];
16208
16209 snprintfrr(buf, sizeof(buf), "%pFX",
16210 range);
16211
16212 json_object_array_add(
16213 json_peer_group_ranges,
16214 json_object_new_string(buf));
16215 } else {
16216 vty_out(vty, " %pFX\n", range);
16217 }
16218 }
16219
16220 if (json) {
16221 json_object_object_add(
16222 json_peer_group_dynamic_af, "ranges",
16223 json_peer_group_ranges);
16224
16225 json_object_object_add(
16226 json_peer_group_dynamic, afi2str(afi),
16227 json_peer_group_dynamic_af);
16228 }
16229 }
16230 }
16231
16232 if (json_peer_group_dynamic)
16233 json_object_object_add(json_peer_group, "dynamicRanges",
16234 json_peer_group_dynamic);
16235
16236 /* Display group members and their status */
16237 if (listcount(group->peer)) {
16238 if (json)
16239 json_peer_group_members = json_object_new_object();
16240 else
16241 vty_out(vty, " Peer-group members:\n");
16242 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
16243 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
16244 || CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHUTDOWN))
16245 peer_status = "Idle (Admin)";
16246 else if (CHECK_FLAG(peer->sflags,
16247 PEER_STATUS_PREFIX_OVERFLOW))
16248 peer_status = "Idle (PfxCt)";
16249 else
16250 peer_status = lookup_msg(bgp_status_msg,
16251 peer->status, NULL);
16252
16253 dynamic = peer_dynamic_neighbor(peer);
16254
16255 if (json) {
16256 json_object *json_peer_group_member =
16257 json_object_new_object();
16258
16259 json_object_string_add(json_peer_group_member,
16260 "status", peer_status);
16261
16262 if (dynamic)
16263 json_object_boolean_true_add(
16264 json_peer_group_member,
16265 "dynamic");
16266
16267 json_object_object_add(json_peer_group_members,
16268 peer->host,
16269 json_peer_group_member);
16270 } else {
16271 vty_out(vty, " %s %s %s \n", peer->host,
16272 dynamic ? "(dynamic)" : "",
16273 peer_status);
16274 }
16275 }
16276 if (json)
16277 json_object_object_add(json_peer_group, "members",
16278 json_peer_group_members);
16279 }
16280
16281 if (json)
16282 json_object_object_add(json, group->name, json_peer_group);
16283
16284 return CMD_SUCCESS;
16285 }
16286
16287 static int bgp_show_peer_group_vty(struct vty *vty, const char *name,
16288 const char *group_name, bool uj)
16289 {
16290 struct bgp *bgp;
16291 struct listnode *node, *nnode;
16292 struct peer_group *group;
16293 bool found = false;
16294 json_object *json = NULL;
16295
16296 if (uj)
16297 json = json_object_new_object();
16298
16299 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
16300
16301 if (!bgp) {
16302 if (uj)
16303 vty_json(vty, json);
16304 else
16305 vty_out(vty, "%% BGP instance not found\n");
16306
16307 return CMD_WARNING;
16308 }
16309
16310 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
16311 if (group_name) {
16312 if (strmatch(group->name, group_name)) {
16313 bgp_show_one_peer_group(vty, group, json);
16314 found = true;
16315 break;
16316 }
16317 } else {
16318 bgp_show_one_peer_group(vty, group, json);
16319 }
16320 }
16321
16322 if (group_name && !found && !uj)
16323 vty_out(vty, "%% No such peer-group\n");
16324
16325 if (uj)
16326 vty_json(vty, json);
16327
16328 return CMD_SUCCESS;
16329 }
16330
16331 DEFUN(show_ip_bgp_peer_groups, show_ip_bgp_peer_groups_cmd,
16332 "show [ip] bgp [<view|vrf> VIEWVRFNAME] peer-group [PGNAME] [json]",
16333 SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR
16334 "Detailed information on BGP peer groups\n"
16335 "Peer group name\n" JSON_STR)
16336 {
16337 char *vrf, *pg;
16338 int idx = 0;
16339 bool uj = use_json(argc, argv);
16340
16341 vrf = argv_find(argv, argc, "VIEWVRFNAME", &idx) ? argv[idx]->arg
16342 : NULL;
16343 pg = argv_find(argv, argc, "PGNAME", &idx) ? argv[idx]->arg : NULL;
16344
16345 return bgp_show_peer_group_vty(vty, vrf, pg, uj);
16346 }
16347
16348
16349 /* Redistribute VTY commands. */
16350
16351 DEFUN (bgp_redistribute_ipv4,
16352 bgp_redistribute_ipv4_cmd,
16353 "redistribute " FRR_IP_REDIST_STR_BGPD,
16354 "Redistribute information from another routing protocol\n"
16355 FRR_IP_REDIST_HELP_STR_BGPD)
16356 {
16357 VTY_DECLVAR_CONTEXT(bgp, bgp);
16358 int idx_protocol = 1;
16359 int type;
16360
16361 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16362 if (type < 0) {
16363 vty_out(vty, "%% Invalid route type\n");
16364 return CMD_WARNING_CONFIG_FAILED;
16365 }
16366
16367 bgp_redist_add(bgp, AFI_IP, type, 0);
16368 return bgp_redistribute_set(bgp, AFI_IP, type, 0, false);
16369 }
16370
16371 ALIAS_HIDDEN(
16372 bgp_redistribute_ipv4, bgp_redistribute_ipv4_hidden_cmd,
16373 "redistribute " FRR_IP_REDIST_STR_BGPD,
16374 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD)
16375
16376 DEFUN (bgp_redistribute_ipv4_rmap,
16377 bgp_redistribute_ipv4_rmap_cmd,
16378 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME",
16379 "Redistribute information from another routing protocol\n"
16380 FRR_IP_REDIST_HELP_STR_BGPD
16381 "Route map reference\n"
16382 "Pointer to route-map entries\n")
16383 {
16384 VTY_DECLVAR_CONTEXT(bgp, bgp);
16385 int idx_protocol = 1;
16386 int idx_word = 3;
16387 int type;
16388 struct bgp_redist *red;
16389 bool changed;
16390 struct route_map *route_map = route_map_lookup_warn_noexist(
16391 vty, argv[idx_word]->arg);
16392
16393 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16394 if (type < 0) {
16395 vty_out(vty, "%% Invalid route type\n");
16396 return CMD_WARNING_CONFIG_FAILED;
16397 }
16398
16399 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16400 changed =
16401 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16402 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16403 }
16404
16405 ALIAS_HIDDEN(
16406 bgp_redistribute_ipv4_rmap, bgp_redistribute_ipv4_rmap_hidden_cmd,
16407 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME",
16408 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16409 "Route map reference\n"
16410 "Pointer to route-map entries\n")
16411
16412 DEFUN (bgp_redistribute_ipv4_metric,
16413 bgp_redistribute_ipv4_metric_cmd,
16414 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
16415 "Redistribute information from another routing protocol\n"
16416 FRR_IP_REDIST_HELP_STR_BGPD
16417 "Metric for redistributed routes\n"
16418 "Default metric\n")
16419 {
16420 VTY_DECLVAR_CONTEXT(bgp, bgp);
16421 int idx_protocol = 1;
16422 int idx_number = 3;
16423 int type;
16424 uint32_t metric;
16425 struct bgp_redist *red;
16426 bool changed;
16427
16428 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16429 if (type < 0) {
16430 vty_out(vty, "%% Invalid route type\n");
16431 return CMD_WARNING_CONFIG_FAILED;
16432 }
16433 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16434
16435 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16436 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16437 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16438 }
16439
16440 ALIAS_HIDDEN(
16441 bgp_redistribute_ipv4_metric, bgp_redistribute_ipv4_metric_hidden_cmd,
16442 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
16443 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16444 "Metric for redistributed routes\n"
16445 "Default metric\n")
16446
16447 DEFUN (bgp_redistribute_ipv4_rmap_metric,
16448 bgp_redistribute_ipv4_rmap_metric_cmd,
16449 "redistribute " FRR_IP_REDIST_STR_BGPD " route-map RMAP_NAME metric (0-4294967295)",
16450 "Redistribute information from another routing protocol\n"
16451 FRR_IP_REDIST_HELP_STR_BGPD
16452 "Route map reference\n"
16453 "Pointer to route-map entries\n"
16454 "Metric for redistributed routes\n"
16455 "Default metric\n")
16456 {
16457 VTY_DECLVAR_CONTEXT(bgp, bgp);
16458 int idx_protocol = 1;
16459 int idx_word = 3;
16460 int idx_number = 5;
16461 int type;
16462 uint32_t metric;
16463 struct bgp_redist *red;
16464 bool changed;
16465 struct route_map *route_map =
16466 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16467
16468 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16469 if (type < 0) {
16470 vty_out(vty, "%% Invalid route type\n");
16471 return CMD_WARNING_CONFIG_FAILED;
16472 }
16473 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16474
16475 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16476 changed =
16477 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16478 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16479 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16480 }
16481
16482 ALIAS_HIDDEN(
16483 bgp_redistribute_ipv4_rmap_metric,
16484 bgp_redistribute_ipv4_rmap_metric_hidden_cmd,
16485 "redistribute " FRR_IP_REDIST_STR_BGPD
16486 " route-map RMAP_NAME metric (0-4294967295)",
16487 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16488 "Route map reference\n"
16489 "Pointer to route-map entries\n"
16490 "Metric for redistributed routes\n"
16491 "Default metric\n")
16492
16493 DEFUN (bgp_redistribute_ipv4_metric_rmap,
16494 bgp_redistribute_ipv4_metric_rmap_cmd,
16495 "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295) route-map RMAP_NAME",
16496 "Redistribute information from another routing protocol\n"
16497 FRR_IP_REDIST_HELP_STR_BGPD
16498 "Metric for redistributed routes\n"
16499 "Default metric\n"
16500 "Route map reference\n"
16501 "Pointer to route-map entries\n")
16502 {
16503 VTY_DECLVAR_CONTEXT(bgp, bgp);
16504 int idx_protocol = 1;
16505 int idx_number = 3;
16506 int idx_word = 5;
16507 int type;
16508 uint32_t metric;
16509 struct bgp_redist *red;
16510 bool changed;
16511 struct route_map *route_map =
16512 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16513
16514 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16515 if (type < 0) {
16516 vty_out(vty, "%% Invalid route type\n");
16517 return CMD_WARNING_CONFIG_FAILED;
16518 }
16519 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16520
16521 red = bgp_redist_add(bgp, AFI_IP, type, 0);
16522 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
16523 changed |=
16524 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16525 return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
16526 }
16527
16528 ALIAS_HIDDEN(
16529 bgp_redistribute_ipv4_metric_rmap,
16530 bgp_redistribute_ipv4_metric_rmap_hidden_cmd,
16531 "redistribute " FRR_IP_REDIST_STR_BGPD
16532 " metric (0-4294967295) route-map RMAP_NAME",
16533 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16534 "Metric for redistributed routes\n"
16535 "Default metric\n"
16536 "Route map reference\n"
16537 "Pointer to route-map entries\n")
16538
16539 DEFUN (bgp_redistribute_ipv4_ospf,
16540 bgp_redistribute_ipv4_ospf_cmd,
16541 "redistribute <ospf|table> (1-65535)",
16542 "Redistribute information from another routing protocol\n"
16543 "Open Shortest Path First (OSPFv2)\n"
16544 "Non-main Kernel Routing Table\n"
16545 "Instance ID/Table ID\n")
16546 {
16547 VTY_DECLVAR_CONTEXT(bgp, bgp);
16548 int idx_ospf_table = 1;
16549 int idx_number = 2;
16550 unsigned short instance;
16551 unsigned short protocol;
16552
16553 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16554
16555 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16556 protocol = ZEBRA_ROUTE_OSPF;
16557 else
16558 protocol = ZEBRA_ROUTE_TABLE;
16559
16560 bgp_redist_add(bgp, AFI_IP, protocol, instance);
16561 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, false);
16562 }
16563
16564 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf, bgp_redistribute_ipv4_ospf_hidden_cmd,
16565 "redistribute <ospf|table> (1-65535)",
16566 "Redistribute information from another routing protocol\n"
16567 "Open Shortest Path First (OSPFv2)\n"
16568 "Non-main Kernel Routing Table\n"
16569 "Instance ID/Table ID\n")
16570
16571 DEFUN (bgp_redistribute_ipv4_ospf_rmap,
16572 bgp_redistribute_ipv4_ospf_rmap_cmd,
16573 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME",
16574 "Redistribute information from another routing protocol\n"
16575 "Open Shortest Path First (OSPFv2)\n"
16576 "Non-main Kernel Routing Table\n"
16577 "Instance ID/Table ID\n"
16578 "Route map reference\n"
16579 "Pointer to route-map entries\n")
16580 {
16581 VTY_DECLVAR_CONTEXT(bgp, bgp);
16582 int idx_ospf_table = 1;
16583 int idx_number = 2;
16584 int idx_word = 4;
16585 struct bgp_redist *red;
16586 unsigned short instance;
16587 int protocol;
16588 bool changed;
16589 struct route_map *route_map =
16590 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16591
16592 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16593 protocol = ZEBRA_ROUTE_OSPF;
16594 else
16595 protocol = ZEBRA_ROUTE_TABLE;
16596
16597 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16598 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16599 changed =
16600 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16601 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16602 }
16603
16604 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_rmap,
16605 bgp_redistribute_ipv4_ospf_rmap_hidden_cmd,
16606 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME",
16607 "Redistribute information from another routing protocol\n"
16608 "Open Shortest Path First (OSPFv2)\n"
16609 "Non-main Kernel Routing Table\n"
16610 "Instance ID/Table ID\n"
16611 "Route map reference\n"
16612 "Pointer to route-map entries\n")
16613
16614 DEFUN (bgp_redistribute_ipv4_ospf_metric,
16615 bgp_redistribute_ipv4_ospf_metric_cmd,
16616 "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
16617 "Redistribute information from another routing protocol\n"
16618 "Open Shortest Path First (OSPFv2)\n"
16619 "Non-main Kernel Routing Table\n"
16620 "Instance ID/Table ID\n"
16621 "Metric for redistributed routes\n"
16622 "Default metric\n")
16623 {
16624 VTY_DECLVAR_CONTEXT(bgp, bgp);
16625 int idx_ospf_table = 1;
16626 int idx_number = 2;
16627 int idx_number_2 = 4;
16628 uint32_t metric;
16629 struct bgp_redist *red;
16630 unsigned short instance;
16631 int protocol;
16632 bool changed;
16633
16634 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16635 protocol = ZEBRA_ROUTE_OSPF;
16636 else
16637 protocol = ZEBRA_ROUTE_TABLE;
16638
16639 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16640 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16641
16642 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16643 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16644 metric);
16645 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16646 }
16647
16648 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_metric,
16649 bgp_redistribute_ipv4_ospf_metric_hidden_cmd,
16650 "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
16651 "Redistribute information from another routing protocol\n"
16652 "Open Shortest Path First (OSPFv2)\n"
16653 "Non-main Kernel Routing Table\n"
16654 "Instance ID/Table ID\n"
16655 "Metric for redistributed routes\n"
16656 "Default metric\n")
16657
16658 DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
16659 bgp_redistribute_ipv4_ospf_rmap_metric_cmd,
16660 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME metric (0-4294967295)",
16661 "Redistribute information from another routing protocol\n"
16662 "Open Shortest Path First (OSPFv2)\n"
16663 "Non-main Kernel Routing Table\n"
16664 "Instance ID/Table ID\n"
16665 "Route map reference\n"
16666 "Pointer to route-map entries\n"
16667 "Metric for redistributed routes\n"
16668 "Default metric\n")
16669 {
16670 VTY_DECLVAR_CONTEXT(bgp, bgp);
16671 int idx_ospf_table = 1;
16672 int idx_number = 2;
16673 int idx_word = 4;
16674 int idx_number_2 = 6;
16675 uint32_t metric;
16676 struct bgp_redist *red;
16677 unsigned short instance;
16678 int protocol;
16679 bool changed;
16680 struct route_map *route_map =
16681 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16682
16683 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16684 protocol = ZEBRA_ROUTE_OSPF;
16685 else
16686 protocol = ZEBRA_ROUTE_TABLE;
16687
16688 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16689 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16690
16691 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16692 changed =
16693 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16694 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16695 metric);
16696 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16697 }
16698
16699 ALIAS_HIDDEN(
16700 bgp_redistribute_ipv4_ospf_rmap_metric,
16701 bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd,
16702 "redistribute <ospf|table> (1-65535) route-map RMAP_NAME metric (0-4294967295)",
16703 "Redistribute information from another routing protocol\n"
16704 "Open Shortest Path First (OSPFv2)\n"
16705 "Non-main Kernel Routing Table\n"
16706 "Instance ID/Table ID\n"
16707 "Route map reference\n"
16708 "Pointer to route-map entries\n"
16709 "Metric for redistributed routes\n"
16710 "Default metric\n")
16711
16712 DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
16713 bgp_redistribute_ipv4_ospf_metric_rmap_cmd,
16714 "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map RMAP_NAME",
16715 "Redistribute information from another routing protocol\n"
16716 "Open Shortest Path First (OSPFv2)\n"
16717 "Non-main Kernel Routing Table\n"
16718 "Instance ID/Table ID\n"
16719 "Metric for redistributed routes\n"
16720 "Default metric\n"
16721 "Route map reference\n"
16722 "Pointer to route-map entries\n")
16723 {
16724 VTY_DECLVAR_CONTEXT(bgp, bgp);
16725 int idx_ospf_table = 1;
16726 int idx_number = 2;
16727 int idx_number_2 = 4;
16728 int idx_word = 6;
16729 uint32_t metric;
16730 struct bgp_redist *red;
16731 unsigned short instance;
16732 int protocol;
16733 bool changed;
16734 struct route_map *route_map =
16735 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16736
16737 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16738 protocol = ZEBRA_ROUTE_OSPF;
16739 else
16740 protocol = ZEBRA_ROUTE_TABLE;
16741
16742 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16743 metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
16744
16745 red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
16746 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
16747 metric);
16748 changed |=
16749 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16750 return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
16751 }
16752
16753 ALIAS_HIDDEN(
16754 bgp_redistribute_ipv4_ospf_metric_rmap,
16755 bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd,
16756 "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map RMAP_NAME",
16757 "Redistribute information from another routing protocol\n"
16758 "Open Shortest Path First (OSPFv2)\n"
16759 "Non-main Kernel Routing Table\n"
16760 "Instance ID/Table ID\n"
16761 "Metric for redistributed routes\n"
16762 "Default metric\n"
16763 "Route map reference\n"
16764 "Pointer to route-map entries\n")
16765
16766 DEFUN (no_bgp_redistribute_ipv4_ospf,
16767 no_bgp_redistribute_ipv4_ospf_cmd,
16768 "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map RMAP_NAME}]",
16769 NO_STR
16770 "Redistribute information from another routing protocol\n"
16771 "Open Shortest Path First (OSPFv2)\n"
16772 "Non-main Kernel Routing Table\n"
16773 "Instance ID/Table ID\n"
16774 "Metric for redistributed routes\n"
16775 "Default metric\n"
16776 "Route map reference\n"
16777 "Pointer to route-map entries\n")
16778 {
16779 VTY_DECLVAR_CONTEXT(bgp, bgp);
16780 int idx_ospf_table = 2;
16781 int idx_number = 3;
16782 unsigned short instance;
16783 int protocol;
16784
16785 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
16786 protocol = ZEBRA_ROUTE_OSPF;
16787 else
16788 protocol = ZEBRA_ROUTE_TABLE;
16789
16790 instance = strtoul(argv[idx_number]->arg, NULL, 10);
16791 return bgp_redistribute_unset(bgp, AFI_IP, protocol, instance);
16792 }
16793
16794 ALIAS_HIDDEN(
16795 no_bgp_redistribute_ipv4_ospf, no_bgp_redistribute_ipv4_ospf_hidden_cmd,
16796 "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map RMAP_NAME}]",
16797 NO_STR
16798 "Redistribute information from another routing protocol\n"
16799 "Open Shortest Path First (OSPFv2)\n"
16800 "Non-main Kernel Routing Table\n"
16801 "Instance ID/Table ID\n"
16802 "Metric for redistributed routes\n"
16803 "Default metric\n"
16804 "Route map reference\n"
16805 "Pointer to route-map entries\n")
16806
16807 DEFUN (no_bgp_redistribute_ipv4,
16808 no_bgp_redistribute_ipv4_cmd,
16809 "no redistribute " FRR_IP_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16810 NO_STR
16811 "Redistribute information from another routing protocol\n"
16812 FRR_IP_REDIST_HELP_STR_BGPD
16813 "Metric for redistributed routes\n"
16814 "Default metric\n"
16815 "Route map reference\n"
16816 "Pointer to route-map entries\n")
16817 {
16818 VTY_DECLVAR_CONTEXT(bgp, bgp);
16819 int idx_protocol = 2;
16820 int type;
16821
16822 type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
16823 if (type < 0) {
16824 vty_out(vty, "%% Invalid route type\n");
16825 return CMD_WARNING_CONFIG_FAILED;
16826 }
16827 return bgp_redistribute_unset(bgp, AFI_IP, type, 0);
16828 }
16829
16830 ALIAS_HIDDEN(
16831 no_bgp_redistribute_ipv4, no_bgp_redistribute_ipv4_hidden_cmd,
16832 "no redistribute " FRR_IP_REDIST_STR_BGPD
16833 " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16834 NO_STR
16835 "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
16836 "Metric for redistributed routes\n"
16837 "Default metric\n"
16838 "Route map reference\n"
16839 "Pointer to route-map entries\n")
16840
16841 DEFUN (bgp_redistribute_ipv6,
16842 bgp_redistribute_ipv6_cmd,
16843 "redistribute " FRR_IP6_REDIST_STR_BGPD,
16844 "Redistribute information from another routing protocol\n"
16845 FRR_IP6_REDIST_HELP_STR_BGPD)
16846 {
16847 VTY_DECLVAR_CONTEXT(bgp, bgp);
16848 int idx_protocol = 1;
16849 int type;
16850
16851 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16852 if (type < 0) {
16853 vty_out(vty, "%% Invalid route type\n");
16854 return CMD_WARNING_CONFIG_FAILED;
16855 }
16856
16857 bgp_redist_add(bgp, AFI_IP6, type, 0);
16858 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, false);
16859 }
16860
16861 DEFUN (bgp_redistribute_ipv6_rmap,
16862 bgp_redistribute_ipv6_rmap_cmd,
16863 "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map RMAP_NAME",
16864 "Redistribute information from another routing protocol\n"
16865 FRR_IP6_REDIST_HELP_STR_BGPD
16866 "Route map reference\n"
16867 "Pointer to route-map entries\n")
16868 {
16869 VTY_DECLVAR_CONTEXT(bgp, bgp);
16870 int idx_protocol = 1;
16871 int idx_word = 3;
16872 int type;
16873 struct bgp_redist *red;
16874 bool changed;
16875 struct route_map *route_map =
16876 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16877
16878 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16879 if (type < 0) {
16880 vty_out(vty, "%% Invalid route type\n");
16881 return CMD_WARNING_CONFIG_FAILED;
16882 }
16883
16884 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16885 changed =
16886 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16887 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16888 }
16889
16890 DEFUN (bgp_redistribute_ipv6_metric,
16891 bgp_redistribute_ipv6_metric_cmd,
16892 "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295)",
16893 "Redistribute information from another routing protocol\n"
16894 FRR_IP6_REDIST_HELP_STR_BGPD
16895 "Metric for redistributed routes\n"
16896 "Default metric\n")
16897 {
16898 VTY_DECLVAR_CONTEXT(bgp, bgp);
16899 int idx_protocol = 1;
16900 int idx_number = 3;
16901 int type;
16902 uint32_t metric;
16903 struct bgp_redist *red;
16904 bool changed;
16905
16906 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16907 if (type < 0) {
16908 vty_out(vty, "%% Invalid route type\n");
16909 return CMD_WARNING_CONFIG_FAILED;
16910 }
16911 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16912
16913 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16914 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
16915 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16916 }
16917
16918 DEFUN (bgp_redistribute_ipv6_rmap_metric,
16919 bgp_redistribute_ipv6_rmap_metric_cmd,
16920 "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map RMAP_NAME metric (0-4294967295)",
16921 "Redistribute information from another routing protocol\n"
16922 FRR_IP6_REDIST_HELP_STR_BGPD
16923 "Route map reference\n"
16924 "Pointer to route-map entries\n"
16925 "Metric for redistributed routes\n"
16926 "Default metric\n")
16927 {
16928 VTY_DECLVAR_CONTEXT(bgp, bgp);
16929 int idx_protocol = 1;
16930 int idx_word = 3;
16931 int idx_number = 5;
16932 int type;
16933 uint32_t metric;
16934 struct bgp_redist *red;
16935 bool changed;
16936 struct route_map *route_map =
16937 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16938
16939 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16940 if (type < 0) {
16941 vty_out(vty, "%% Invalid route type\n");
16942 return CMD_WARNING_CONFIG_FAILED;
16943 }
16944 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16945
16946 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16947 changed =
16948 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16949 changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP6, type,
16950 metric);
16951 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16952 }
16953
16954 DEFUN (bgp_redistribute_ipv6_metric_rmap,
16955 bgp_redistribute_ipv6_metric_rmap_cmd,
16956 "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295) route-map RMAP_NAME",
16957 "Redistribute information from another routing protocol\n"
16958 FRR_IP6_REDIST_HELP_STR_BGPD
16959 "Metric for redistributed routes\n"
16960 "Default metric\n"
16961 "Route map reference\n"
16962 "Pointer to route-map entries\n")
16963 {
16964 VTY_DECLVAR_CONTEXT(bgp, bgp);
16965 int idx_protocol = 1;
16966 int idx_number = 3;
16967 int idx_word = 5;
16968 int type;
16969 uint32_t metric;
16970 struct bgp_redist *red;
16971 bool changed;
16972 struct route_map *route_map =
16973 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
16974
16975 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
16976 if (type < 0) {
16977 vty_out(vty, "%% Invalid route type\n");
16978 return CMD_WARNING_CONFIG_FAILED;
16979 }
16980 metric = strtoul(argv[idx_number]->arg, NULL, 10);
16981
16982 red = bgp_redist_add(bgp, AFI_IP6, type, 0);
16983 changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, SAFI_UNICAST,
16984 metric);
16985 changed |=
16986 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
16987 return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
16988 }
16989
16990 DEFUN (no_bgp_redistribute_ipv6,
16991 no_bgp_redistribute_ipv6_cmd,
16992 "no redistribute " FRR_IP6_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map RMAP_NAME}]",
16993 NO_STR
16994 "Redistribute information from another routing protocol\n"
16995 FRR_IP6_REDIST_HELP_STR_BGPD
16996 "Metric for redistributed routes\n"
16997 "Default metric\n"
16998 "Route map reference\n"
16999 "Pointer to route-map entries\n")
17000 {
17001 VTY_DECLVAR_CONTEXT(bgp, bgp);
17002 int idx_protocol = 2;
17003 int type;
17004
17005 type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
17006 if (type < 0) {
17007 vty_out(vty, "%% Invalid route type\n");
17008 return CMD_WARNING_CONFIG_FAILED;
17009 }
17010
17011 return bgp_redistribute_unset(bgp, AFI_IP6, type, 0);
17012 }
17013
17014 /* Neighbor update tcp-mss. */
17015 static int peer_tcp_mss_vty(struct vty *vty, const char *peer_str,
17016 const char *tcp_mss_str)
17017 {
17018 struct peer *peer;
17019 uint32_t tcp_mss_val = 0;
17020
17021 peer = peer_and_group_lookup_vty(vty, peer_str);
17022 if (!peer)
17023 return CMD_WARNING_CONFIG_FAILED;
17024
17025 if (tcp_mss_str) {
17026 tcp_mss_val = strtoul(tcp_mss_str, NULL, 10);
17027 peer_tcp_mss_set(peer, tcp_mss_val);
17028 } else {
17029 peer_tcp_mss_unset(peer);
17030 }
17031
17032 return CMD_SUCCESS;
17033 }
17034
17035 DEFUN(neighbor_tcp_mss, neighbor_tcp_mss_cmd,
17036 "neighbor <A.B.C.D|X:X::X:X|WORD> tcp-mss (1-65535)",
17037 NEIGHBOR_STR NEIGHBOR_ADDR_STR2
17038 "TCP max segment size\n"
17039 "TCP MSS value\n")
17040 {
17041 int peer_index = 1;
17042 int mss_index = 3;
17043
17044 vty_out(vty,
17045 " Warning: Reset BGP session for tcp-mss value to take effect\n");
17046 return peer_tcp_mss_vty(vty, argv[peer_index]->arg,
17047 argv[mss_index]->arg);
17048 }
17049
17050 DEFUN(no_neighbor_tcp_mss, no_neighbor_tcp_mss_cmd,
17051 "no neighbor <A.B.C.D|X:X::X:X|WORD> tcp-mss [(1-65535)]",
17052 NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
17053 "TCP max segment size\n"
17054 "TCP MSS value\n")
17055 {
17056 int peer_index = 2;
17057
17058 vty_out(vty,
17059 " Warning: Reset BGP session for tcp-mss value to take effect\n");
17060 return peer_tcp_mss_vty(vty, argv[peer_index]->arg, NULL);
17061 }
17062
17063 DEFPY(bgp_retain_route_target, bgp_retain_route_target_cmd,
17064 "[no$no] bgp retain route-target all",
17065 NO_STR BGP_STR
17066 "Retain BGP updates\n"
17067 "Retain BGP updates based on route-target values\n"
17068 "Retain all BGP updates\n")
17069 {
17070 bool check;
17071 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
17072
17073 check = CHECK_FLAG(bgp->af_flags[bgp_node_afi(vty)][bgp_node_safi(vty)],
17074 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
17075 if (check != !no) {
17076 if (!no)
17077 SET_FLAG(bgp->af_flags[bgp_node_afi(vty)]
17078 [bgp_node_safi(vty)],
17079 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
17080 else
17081 UNSET_FLAG(bgp->af_flags[bgp_node_afi(vty)]
17082 [bgp_node_safi(vty)],
17083 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL);
17084 /* trigger a flush to re-sync with ADJ-RIB-in */
17085 bgp_clear(vty, bgp, bgp_node_afi(vty), bgp_node_safi(vty),
17086 clear_all, BGP_CLEAR_SOFT_IN, NULL);
17087 }
17088 return CMD_SUCCESS;
17089 }
17090
17091 static void bgp_config_write_redistribute(struct vty *vty, struct bgp *bgp,
17092 afi_t afi, safi_t safi)
17093 {
17094 int i;
17095
17096 /* Unicast redistribution only. */
17097 if (safi != SAFI_UNICAST)
17098 return;
17099
17100 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
17101 /* Redistribute BGP does not make sense. */
17102 if (i != ZEBRA_ROUTE_BGP) {
17103 struct list *red_list;
17104 struct listnode *node;
17105 struct bgp_redist *red;
17106
17107 red_list = bgp->redist[afi][i];
17108 if (!red_list)
17109 continue;
17110
17111 for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
17112 /* "redistribute" configuration. */
17113 vty_out(vty, " redistribute %s",
17114 zebra_route_string(i));
17115 if (red->instance)
17116 vty_out(vty, " %d", red->instance);
17117 if (red->redist_metric_flag)
17118 vty_out(vty, " metric %u",
17119 red->redist_metric);
17120 if (red->rmap.name)
17121 vty_out(vty, " route-map %s",
17122 red->rmap.name);
17123 vty_out(vty, "\n");
17124 }
17125 }
17126 }
17127 }
17128
17129 /* peer-group helpers for config-write */
17130
17131 bool peergroup_flag_check(struct peer *peer, uint64_t flag)
17132 {
17133 if (!peer_group_active(peer)) {
17134 if (CHECK_FLAG(peer->flags_invert, flag))
17135 return !CHECK_FLAG(peer->flags, flag);
17136 else
17137 return !!CHECK_FLAG(peer->flags, flag);
17138 }
17139
17140 return !!CHECK_FLAG(peer->flags_override, flag);
17141 }
17142
17143 static bool peergroup_af_flag_check(struct peer *peer, afi_t afi, safi_t safi,
17144 uint64_t flag)
17145 {
17146 if (!peer_group_active(peer)) {
17147 if (CHECK_FLAG(peer->af_flags_invert[afi][safi], flag))
17148 return !peer_af_flag_check(peer, afi, safi, flag);
17149 else
17150 return peer_af_flag_check(peer, afi, safi, flag);
17151 }
17152
17153 return !!CHECK_FLAG(peer->af_flags_override[afi][safi], flag);
17154 }
17155
17156 static bool peergroup_filter_check(struct peer *peer, afi_t afi, safi_t safi,
17157 uint8_t type, int direct)
17158 {
17159 struct bgp_filter *filter;
17160
17161 if (peer_group_active(peer))
17162 return !!CHECK_FLAG(peer->filter_override[afi][safi][direct],
17163 type);
17164
17165 filter = &peer->filter[afi][safi];
17166 switch (type) {
17167 case PEER_FT_DISTRIBUTE_LIST:
17168 return !!(filter->dlist[direct].name);
17169 case PEER_FT_FILTER_LIST:
17170 return !!(filter->aslist[direct].name);
17171 case PEER_FT_PREFIX_LIST:
17172 return !!(filter->plist[direct].name);
17173 case PEER_FT_ROUTE_MAP:
17174 return !!(filter->map[direct].name);
17175 case PEER_FT_UNSUPPRESS_MAP:
17176 return !!(filter->usmap.name);
17177 case PEER_FT_ADVERTISE_MAP:
17178 return !!(filter->advmap.aname
17179 && ((filter->advmap.condition == direct)
17180 && filter->advmap.cname));
17181 default:
17182 return false;
17183 }
17184 }
17185
17186 /* Return true if the addpath type is set for peer and different from
17187 * peer-group.
17188 */
17189 static bool peergroup_af_addpath_check(struct peer *peer, afi_t afi,
17190 safi_t safi)
17191 {
17192 enum bgp_addpath_strat type, g_type;
17193
17194 type = peer->addpath_type[afi][safi];
17195
17196 if (type != BGP_ADDPATH_NONE) {
17197 if (peer_group_active(peer)) {
17198 g_type = peer->group->conf->addpath_type[afi][safi];
17199
17200 if (type != g_type)
17201 return true;
17202 else
17203 return false;
17204 }
17205
17206 return true;
17207 }
17208
17209 return false;
17210 }
17211
17212 /* This is part of the address-family block (unicast only) */
17213 static void bgp_vpn_policy_config_write_afi(struct vty *vty, struct bgp *bgp,
17214 afi_t afi)
17215 {
17216 int indent = 2;
17217 uint32_t tovpn_sid_index = 0;
17218
17219 if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]) {
17220 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
17221 BGP_CONFIG_VRF_TO_VRF_IMPORT))
17222 vty_out(vty, "%*simport vrf route-map %s\n", indent, "",
17223 bgp->vpn_policy[afi]
17224 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
17225 else
17226 vty_out(vty, "%*sroute-map vpn import %s\n", indent, "",
17227 bgp->vpn_policy[afi]
17228 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
17229 }
17230 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
17231 BGP_CONFIG_VRF_TO_VRF_IMPORT)
17232 || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
17233 BGP_CONFIG_VRF_TO_VRF_EXPORT))
17234 return;
17235
17236 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
17237 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
17238
17239 vty_out(vty, "%*slabel vpn export %s\n", indent, "", "auto");
17240
17241 } else {
17242 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
17243 vty_out(vty, "%*slabel vpn export %u\n", indent, "",
17244 bgp->vpn_policy[afi].tovpn_label);
17245 }
17246 }
17247
17248 tovpn_sid_index = bgp->vpn_policy[afi].tovpn_sid_index;
17249 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
17250 BGP_VPN_POLICY_TOVPN_SID_AUTO)) {
17251 vty_out(vty, "%*ssid vpn export %s\n", indent, "", "auto");
17252 } else if (tovpn_sid_index != 0) {
17253 vty_out(vty, "%*ssid vpn export %d\n", indent, "",
17254 tovpn_sid_index);
17255 }
17256
17257 if (CHECK_FLAG(bgp->vpn_policy[afi].flags, BGP_VPN_POLICY_TOVPN_RD_SET))
17258 vty_out(vty, "%*srd vpn export %s\n", indent, "",
17259 bgp->vpn_policy[afi].tovpn_rd_pretty);
17260
17261 if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
17262 BGP_VPN_POLICY_TOVPN_NEXTHOP_SET)) {
17263
17264 char buf[PREFIX_STRLEN];
17265 if (inet_ntop(bgp->vpn_policy[afi].tovpn_nexthop.family,
17266 &bgp->vpn_policy[afi].tovpn_nexthop.u.prefix, buf,
17267 sizeof(buf))) {
17268
17269 vty_out(vty, "%*snexthop vpn export %s\n",
17270 indent, "", buf);
17271 }
17272 }
17273 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]
17274 && bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]
17275 && ecommunity_cmp(
17276 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
17277 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN])) {
17278
17279 char *b = ecommunity_ecom2str(
17280 bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN],
17281 ECOMMUNITY_FORMAT_ROUTE_MAP, ECOMMUNITY_ROUTE_TARGET);
17282 vty_out(vty, "%*srt vpn both %s\n", indent, "", b);
17283 XFREE(MTYPE_ECOMMUNITY_STR, b);
17284 } else {
17285 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]) {
17286 char *b = ecommunity_ecom2str(
17287 bgp->vpn_policy[afi]
17288 .rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
17289 ECOMMUNITY_FORMAT_ROUTE_MAP,
17290 ECOMMUNITY_ROUTE_TARGET);
17291 vty_out(vty, "%*srt vpn import %s\n", indent, "", b);
17292 XFREE(MTYPE_ECOMMUNITY_STR, b);
17293 }
17294 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]) {
17295 char *b = ecommunity_ecom2str(
17296 bgp->vpn_policy[afi]
17297 .rtlist[BGP_VPN_POLICY_DIR_TOVPN],
17298 ECOMMUNITY_FORMAT_ROUTE_MAP,
17299 ECOMMUNITY_ROUTE_TARGET);
17300 vty_out(vty, "%*srt vpn export %s\n", indent, "", b);
17301 XFREE(MTYPE_ECOMMUNITY_STR, b);
17302 }
17303 }
17304
17305 if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_TOVPN])
17306 vty_out(vty, "%*sroute-map vpn export %s\n", indent, "",
17307 bgp->vpn_policy[afi]
17308 .rmap_name[BGP_VPN_POLICY_DIR_TOVPN]);
17309
17310 if (bgp->vpn_policy[afi].import_redirect_rtlist) {
17311 char *b = ecommunity_ecom2str(
17312 bgp->vpn_policy[afi]
17313 .import_redirect_rtlist,
17314 ECOMMUNITY_FORMAT_ROUTE_MAP,
17315 ECOMMUNITY_ROUTE_TARGET);
17316
17317 if (bgp->vpn_policy[afi].import_redirect_rtlist->unit_size
17318 != ECOMMUNITY_SIZE)
17319 vty_out(vty, "%*srt6 redirect import %s\n",
17320 indent, "", b);
17321 else
17322 vty_out(vty, "%*srt redirect import %s\n",
17323 indent, "", b);
17324 XFREE(MTYPE_ECOMMUNITY_STR, b);
17325 }
17326 }
17327
17328 static void bgp_config_write_filter(struct vty *vty, struct peer *peer,
17329 afi_t afi, safi_t safi)
17330 {
17331 struct bgp_filter *filter;
17332 char *addr;
17333
17334 addr = peer->host;
17335 filter = &peer->filter[afi][safi];
17336
17337 /* distribute-list. */
17338 if (peergroup_filter_check(peer, afi, safi, PEER_FT_DISTRIBUTE_LIST,
17339 FILTER_IN))
17340 vty_out(vty, " neighbor %s distribute-list %s in\n", addr,
17341 filter->dlist[FILTER_IN].name);
17342
17343 if (peergroup_filter_check(peer, afi, safi, PEER_FT_DISTRIBUTE_LIST,
17344 FILTER_OUT))
17345 vty_out(vty, " neighbor %s distribute-list %s out\n", addr,
17346 filter->dlist[FILTER_OUT].name);
17347
17348 /* prefix-list. */
17349 if (peergroup_filter_check(peer, afi, safi, PEER_FT_PREFIX_LIST,
17350 FILTER_IN))
17351 vty_out(vty, " neighbor %s prefix-list %s in\n", addr,
17352 filter->plist[FILTER_IN].name);
17353
17354 if (peergroup_filter_check(peer, afi, safi, PEER_FT_PREFIX_LIST,
17355 FILTER_OUT))
17356 vty_out(vty, " neighbor %s prefix-list %s out\n", addr,
17357 filter->plist[FILTER_OUT].name);
17358
17359 /* route-map. */
17360 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ROUTE_MAP, RMAP_IN))
17361 vty_out(vty, " neighbor %s route-map %s in\n", addr,
17362 filter->map[RMAP_IN].name);
17363
17364 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ROUTE_MAP,
17365 RMAP_OUT))
17366 vty_out(vty, " neighbor %s route-map %s out\n", addr,
17367 filter->map[RMAP_OUT].name);
17368
17369 /* unsuppress-map */
17370 if (peergroup_filter_check(peer, afi, safi, PEER_FT_UNSUPPRESS_MAP, 0))
17371 vty_out(vty, " neighbor %s unsuppress-map %s\n", addr,
17372 filter->usmap.name);
17373
17374 /* advertise-map : always applied in OUT direction*/
17375 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ADVERTISE_MAP,
17376 CONDITION_NON_EXIST))
17377 vty_out(vty,
17378 " neighbor %s advertise-map %s non-exist-map %s\n",
17379 addr, filter->advmap.aname, filter->advmap.cname);
17380
17381 if (peergroup_filter_check(peer, afi, safi, PEER_FT_ADVERTISE_MAP,
17382 CONDITION_EXIST))
17383 vty_out(vty, " neighbor %s advertise-map %s exist-map %s\n",
17384 addr, filter->advmap.aname, filter->advmap.cname);
17385
17386 /* filter-list. */
17387 if (peergroup_filter_check(peer, afi, safi, PEER_FT_FILTER_LIST,
17388 FILTER_IN))
17389 vty_out(vty, " neighbor %s filter-list %s in\n", addr,
17390 filter->aslist[FILTER_IN].name);
17391
17392 if (peergroup_filter_check(peer, afi, safi, PEER_FT_FILTER_LIST,
17393 FILTER_OUT))
17394 vty_out(vty, " neighbor %s filter-list %s out\n", addr,
17395 filter->aslist[FILTER_OUT].name);
17396 }
17397
17398 /* BGP peer configuration display function. */
17399 static void bgp_config_write_peer_global(struct vty *vty, struct bgp *bgp,
17400 struct peer *peer)
17401 {
17402 struct peer *g_peer = NULL;
17403 char *addr;
17404 int if_pg_printed = false;
17405 int if_ras_printed = false;
17406
17407 /* Skip dynamic neighbors. */
17408 if (peer_dynamic_neighbor(peer))
17409 return;
17410
17411 if (peer->conf_if)
17412 addr = peer->conf_if;
17413 else
17414 addr = peer->host;
17415
17416 /************************************
17417 ****** Global to the neighbor ******
17418 ************************************/
17419 if (peer->conf_if) {
17420 if (CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
17421 vty_out(vty, " neighbor %s interface v6only", addr);
17422 else
17423 vty_out(vty, " neighbor %s interface", addr);
17424
17425 if (peer_group_active(peer)) {
17426 vty_out(vty, " peer-group %s", peer->group->name);
17427 if_pg_printed = true;
17428 } else if (peer->as_type == AS_SPECIFIED) {
17429 vty_out(vty, " remote-as %s", peer->as_pretty);
17430 if_ras_printed = true;
17431 } else if (peer->as_type == AS_INTERNAL) {
17432 vty_out(vty, " remote-as internal");
17433 if_ras_printed = true;
17434 } else if (peer->as_type == AS_EXTERNAL) {
17435 vty_out(vty, " remote-as external");
17436 if_ras_printed = true;
17437 }
17438
17439 vty_out(vty, "\n");
17440 }
17441
17442 /* remote-as and peer-group */
17443 /* peer is a member of a peer-group */
17444 if (peer_group_active(peer)) {
17445 g_peer = peer->group->conf;
17446
17447 if (g_peer->as_type == AS_UNSPECIFIED && !if_ras_printed) {
17448 if (peer->as_type == AS_SPECIFIED) {
17449 vty_out(vty, " neighbor %s remote-as %s\n",
17450 addr, peer->as_pretty);
17451 } else if (peer->as_type == AS_INTERNAL) {
17452 vty_out(vty,
17453 " neighbor %s remote-as internal\n",
17454 addr);
17455 } else if (peer->as_type == AS_EXTERNAL) {
17456 vty_out(vty,
17457 " neighbor %s remote-as external\n",
17458 addr);
17459 }
17460 }
17461
17462 /* For swpX peers we displayed the peer-group
17463 * via 'neighbor swpX interface peer-group PGNAME' */
17464 if (!if_pg_printed)
17465 vty_out(vty, " neighbor %s peer-group %s\n", addr,
17466 peer->group->name);
17467 }
17468
17469 /* peer is NOT a member of a peer-group */
17470 else {
17471 /* peer is a peer-group, declare the peer-group */
17472 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
17473 vty_out(vty, " neighbor %s peer-group\n", addr);
17474 }
17475
17476 if (!if_ras_printed) {
17477 if (peer->as_type == AS_SPECIFIED) {
17478 vty_out(vty, " neighbor %s remote-as %s\n",
17479 addr, peer->as_pretty);
17480 } else if (peer->as_type == AS_INTERNAL) {
17481 vty_out(vty,
17482 " neighbor %s remote-as internal\n",
17483 addr);
17484 } else if (peer->as_type == AS_EXTERNAL) {
17485 vty_out(vty,
17486 " neighbor %s remote-as external\n",
17487 addr);
17488 }
17489 }
17490 }
17491
17492 /* local-as */
17493 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS)) {
17494 vty_out(vty, " neighbor %s local-as %s", addr,
17495 peer->change_local_as_pretty);
17496 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND))
17497 vty_out(vty, " no-prepend");
17498 if (peergroup_flag_check(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS))
17499 vty_out(vty, " replace-as");
17500 vty_out(vty, "\n");
17501 }
17502
17503 /* description */
17504 if (peer->desc) {
17505 vty_out(vty, " neighbor %s description %s\n", addr, peer->desc);
17506 }
17507
17508 /* shutdown */
17509 if (peergroup_flag_check(peer, PEER_FLAG_SHUTDOWN)) {
17510 if (peer->tx_shutdown_message)
17511 vty_out(vty, " neighbor %s shutdown message %s\n", addr,
17512 peer->tx_shutdown_message);
17513 else
17514 vty_out(vty, " neighbor %s shutdown\n", addr);
17515 }
17516
17517 if (peergroup_flag_check(peer, PEER_FLAG_RTT_SHUTDOWN))
17518 vty_out(vty, " neighbor %s shutdown rtt %u count %u\n", addr,
17519 peer->rtt_expected, peer->rtt_keepalive_conf);
17520
17521 /* bfd */
17522 if (peer->bfd_config)
17523 bgp_bfd_peer_config_write(vty, peer, addr);
17524
17525 /* password */
17526 if (peergroup_flag_check(peer, PEER_FLAG_PASSWORD))
17527 vty_out(vty, " neighbor %s password %s\n", addr,
17528 peer->password);
17529
17530 /* neighbor solo */
17531 if (CHECK_FLAG(peer->flags, PEER_FLAG_LONESOUL)) {
17532 if (!peer_group_active(peer)) {
17533 vty_out(vty, " neighbor %s solo\n", addr);
17534 }
17535 }
17536
17537 /* BGP port */
17538 if (peer->port != BGP_PORT_DEFAULT) {
17539 vty_out(vty, " neighbor %s port %d\n", addr, peer->port);
17540 }
17541
17542 /* Local interface name */
17543 if (peer->ifname) {
17544 vty_out(vty, " neighbor %s interface %s\n", addr, peer->ifname);
17545 }
17546
17547 /* TCP max segment size */
17548 if (CHECK_FLAG(peer->flags, PEER_FLAG_TCP_MSS))
17549 vty_out(vty, " neighbor %s tcp-mss %d\n", addr, peer->tcp_mss);
17550
17551 /* passive */
17552 if (peergroup_flag_check(peer, PEER_FLAG_PASSIVE))
17553 vty_out(vty, " neighbor %s passive\n", addr);
17554
17555 /* ebgp-multihop */
17556 if (peer->sort != BGP_PEER_IBGP && peer->ttl != BGP_DEFAULT_TTL
17557 && !(peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED
17558 && peer->ttl == MAXTTL)) {
17559 if (!peer_group_active(peer) || g_peer->ttl != peer->ttl) {
17560 vty_out(vty, " neighbor %s ebgp-multihop %d\n", addr,
17561 peer->ttl);
17562 }
17563 }
17564
17565 /* aigp */
17566 if (peergroup_flag_check(peer, PEER_FLAG_AIGP))
17567 vty_out(vty, " neighbor %s aigp\n", addr);
17568
17569 /* graceful-shutdown */
17570 if (peergroup_flag_check(peer, PEER_FLAG_GRACEFUL_SHUTDOWN))
17571 vty_out(vty, " neighbor %s graceful-shutdown\n", addr);
17572
17573 /* role */
17574 if (peergroup_flag_check(peer, PEER_FLAG_ROLE) &&
17575 peer->local_role != ROLE_UNDEFINED)
17576 vty_out(vty, " neighbor %s local-role %s%s\n", addr,
17577 bgp_get_name_by_role(peer->local_role),
17578 CHECK_FLAG(peer->flags, PEER_FLAG_ROLE_STRICT_MODE)
17579 ? " strict-mode"
17580 : "");
17581
17582 /* ttl-security hops */
17583 if (peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED) {
17584 if (!peer_group_active(peer)
17585 || g_peer->gtsm_hops != peer->gtsm_hops) {
17586 vty_out(vty, " neighbor %s ttl-security hops %d\n",
17587 addr, peer->gtsm_hops);
17588 }
17589 }
17590
17591 /* disable-connected-check */
17592 if (peergroup_flag_check(peer, PEER_FLAG_DISABLE_CONNECTED_CHECK))
17593 vty_out(vty, " neighbor %s disable-connected-check\n", addr);
17594
17595 /* link-bw-encoding-ieee */
17596 if (peergroup_flag_check(peer, PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE))
17597 vty_out(vty, " neighbor %s disable-link-bw-encoding-ieee\n",
17598 addr);
17599
17600 /* extended-optional-parameters */
17601 if (peergroup_flag_check(peer, PEER_FLAG_EXTENDED_OPT_PARAMS))
17602 vty_out(vty, " neighbor %s extended-optional-parameters\n",
17603 addr);
17604
17605 /* enforce-first-as */
17606 if (peergroup_flag_check(peer, PEER_FLAG_ENFORCE_FIRST_AS))
17607 vty_out(vty, " neighbor %s enforce-first-as\n", addr);
17608
17609 /* update-source */
17610 if (peergroup_flag_check(peer, PEER_FLAG_UPDATE_SOURCE)) {
17611 if (peer->update_source)
17612 vty_out(vty, " neighbor %s update-source %pSU\n", addr,
17613 peer->update_source);
17614 else if (peer->update_if)
17615 vty_out(vty, " neighbor %s update-source %s\n", addr,
17616 peer->update_if);
17617 }
17618
17619 /* advertisement-interval */
17620 if (peergroup_flag_check(peer, PEER_FLAG_ROUTEADV))
17621 vty_out(vty, " neighbor %s advertisement-interval %u\n", addr,
17622 peer->routeadv);
17623
17624 /* timers */
17625 if (peergroup_flag_check(peer, PEER_FLAG_TIMER))
17626 vty_out(vty, " neighbor %s timers %u %u\n", addr,
17627 peer->keepalive, peer->holdtime);
17628
17629 /* timers connect */
17630 if (peergroup_flag_check(peer, PEER_FLAG_TIMER_CONNECT))
17631 vty_out(vty, " neighbor %s timers connect %u\n", addr,
17632 peer->connect);
17633 /* need special-case handling for changed default values due to
17634 * config profile / version (because there is no "timers bgp connect"
17635 * command, we need to save this per-peer :/)
17636 */
17637 else if (!peer_group_active(peer) && !peer->connect &&
17638 peer->bgp->default_connect_retry != SAVE_BGP_CONNECT_RETRY)
17639 vty_out(vty, " neighbor %s timers connect %u\n", addr,
17640 peer->bgp->default_connect_retry);
17641
17642 /* timers delayopen */
17643 if (peergroup_flag_check(peer, PEER_FLAG_TIMER_DELAYOPEN))
17644 vty_out(vty, " neighbor %s timers delayopen %u\n", addr,
17645 peer->delayopen);
17646 /* Save config even though flag is not set if default values have been
17647 * changed
17648 */
17649 else if (!peer_group_active(peer) && !peer->delayopen
17650 && peer->bgp->default_delayopen != BGP_DEFAULT_DELAYOPEN)
17651 vty_out(vty, " neighbor %s timers delayopen %u\n", addr,
17652 peer->bgp->default_delayopen);
17653
17654 /* capability dynamic */
17655 if (peergroup_flag_check(peer, PEER_FLAG_DYNAMIC_CAPABILITY))
17656 vty_out(vty, " neighbor %s capability dynamic\n", addr);
17657
17658 /* capability extended-nexthop */
17659 if (peergroup_flag_check(peer, PEER_FLAG_CAPABILITY_ENHE)) {
17660 if (CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE) &&
17661 !peer->conf_if)
17662 vty_out(vty,
17663 " no neighbor %s capability extended-nexthop\n",
17664 addr);
17665 else if (!peer->conf_if)
17666 vty_out(vty,
17667 " neighbor %s capability extended-nexthop\n",
17668 addr);
17669 }
17670
17671 /* capability software-version */
17672 if (peergroup_flag_check(peer, PEER_FLAG_CAPABILITY_SOFT_VERSION))
17673 vty_out(vty, " neighbor %s capability software-version\n",
17674 addr);
17675
17676 /* dont-capability-negotiation */
17677 if (peergroup_flag_check(peer, PEER_FLAG_DONT_CAPABILITY))
17678 vty_out(vty, " neighbor %s dont-capability-negotiate\n", addr);
17679
17680 /* override-capability */
17681 if (peergroup_flag_check(peer, PEER_FLAG_OVERRIDE_CAPABILITY))
17682 vty_out(vty, " neighbor %s override-capability\n", addr);
17683
17684 /* strict-capability-match */
17685 if (peergroup_flag_check(peer, PEER_FLAG_STRICT_CAP_MATCH))
17686 vty_out(vty, " neighbor %s strict-capability-match\n", addr);
17687
17688 /* Sender side AS path loop detection. */
17689 if (peer->as_path_loop_detection)
17690 vty_out(vty, " neighbor %s sender-as-path-loop-detection\n",
17691 addr);
17692
17693 /* path-attribute discard */
17694 char discard_attrs_str[BUFSIZ] = {0};
17695 bool discard_attrs = bgp_path_attribute_discard(
17696 peer, discard_attrs_str, sizeof(discard_attrs_str));
17697
17698 if (discard_attrs)
17699 vty_out(vty, " neighbor %s path-attribute discard %s\n", addr,
17700 discard_attrs_str);
17701
17702 /* path-attribute treat-as-withdraw */
17703 char withdraw_attrs_str[BUFSIZ] = {0};
17704 bool withdraw_attrs = bgp_path_attribute_treat_as_withdraw(
17705 peer, withdraw_attrs_str, sizeof(withdraw_attrs_str));
17706
17707 if (withdraw_attrs)
17708 vty_out(vty,
17709 " neighbor %s path-attribute treat-as-withdraw %s\n",
17710 addr, withdraw_attrs_str);
17711
17712 if (!CHECK_FLAG(peer->peer_gr_new_status_flag,
17713 PEER_GRACEFUL_RESTART_NEW_STATE_INHERIT)) {
17714
17715 if (CHECK_FLAG(peer->peer_gr_new_status_flag,
17716 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER)) {
17717 vty_out(vty,
17718 " neighbor %s graceful-restart-helper\n", addr);
17719 } else if (CHECK_FLAG(
17720 peer->peer_gr_new_status_flag,
17721 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART)) {
17722 vty_out(vty,
17723 " neighbor %s graceful-restart\n", addr);
17724 } else if (
17725 (!(CHECK_FLAG(peer->peer_gr_new_status_flag,
17726 PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
17727 && !(CHECK_FLAG(
17728 peer->peer_gr_new_status_flag,
17729 PEER_GRACEFUL_RESTART_NEW_STATE_RESTART)))) {
17730 vty_out(vty, " neighbor %s graceful-restart-disable\n",
17731 addr);
17732 }
17733 }
17734 }
17735
17736 /* BGP peer configuration display function. */
17737 static void bgp_config_write_peer_af(struct vty *vty, struct bgp *bgp,
17738 struct peer *peer, afi_t afi, safi_t safi)
17739 {
17740 struct peer *g_peer = NULL;
17741 char *addr;
17742 bool flag_scomm, flag_secomm, flag_slcomm;
17743
17744 /* Skip dynamic neighbors. */
17745 if (peer_dynamic_neighbor(peer))
17746 return;
17747
17748 if (peer->conf_if)
17749 addr = peer->conf_if;
17750 else
17751 addr = peer->host;
17752
17753 /************************************
17754 ****** Per AF to the neighbor ******
17755 ************************************/
17756 if (peer_group_active(peer)) {
17757 g_peer = peer->group->conf;
17758
17759 /* If the peer-group is active but peer is not, print a 'no
17760 * activate' */
17761 if (g_peer->afc[afi][safi] && !peer->afc[afi][safi]) {
17762 vty_out(vty, " no neighbor %s activate\n", addr);
17763 }
17764
17765 /* If the peer-group is not active but peer is, print an
17766 'activate' */
17767 else if (!g_peer->afc[afi][safi] && peer->afc[afi][safi]) {
17768 vty_out(vty, " neighbor %s activate\n", addr);
17769 }
17770 } else {
17771 if (peer->afc[afi][safi]) {
17772 if (safi == SAFI_ENCAP)
17773 vty_out(vty, " neighbor %s activate\n", addr);
17774 else if (!bgp->default_af[afi][safi])
17775 vty_out(vty, " neighbor %s activate\n", addr);
17776 } else {
17777 if (bgp->default_af[afi][safi])
17778 vty_out(vty, " no neighbor %s activate\n",
17779 addr);
17780 }
17781 }
17782
17783 /* addpath TX knobs */
17784 if (peergroup_af_addpath_check(peer, afi, safi)) {
17785 switch (peer->addpath_type[afi][safi]) {
17786 case BGP_ADDPATH_ALL:
17787 vty_out(vty, " neighbor %s addpath-tx-all-paths\n",
17788 addr);
17789 break;
17790 case BGP_ADDPATH_BEST_PER_AS:
17791 vty_out(vty,
17792 " neighbor %s addpath-tx-bestpath-per-AS\n",
17793 addr);
17794 break;
17795 case BGP_ADDPATH_MAX:
17796 case BGP_ADDPATH_NONE:
17797 break;
17798 }
17799 }
17800
17801 if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_DISABLE_ADDPATH_RX))
17802 vty_out(vty, " neighbor %s disable-addpath-rx\n", addr);
17803
17804 /* ORF capability. */
17805 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ORF_PREFIX_SM)
17806 || peergroup_af_flag_check(peer, afi, safi,
17807 PEER_FLAG_ORF_PREFIX_RM)) {
17808 vty_out(vty, " neighbor %s capability orf prefix-list", addr);
17809
17810 if (peergroup_af_flag_check(peer, afi, safi,
17811 PEER_FLAG_ORF_PREFIX_SM)
17812 && peergroup_af_flag_check(peer, afi, safi,
17813 PEER_FLAG_ORF_PREFIX_RM))
17814 vty_out(vty, " both");
17815 else if (peergroup_af_flag_check(peer, afi, safi,
17816 PEER_FLAG_ORF_PREFIX_SM))
17817 vty_out(vty, " send");
17818 else
17819 vty_out(vty, " receive");
17820 vty_out(vty, "\n");
17821 }
17822
17823 /* Route reflector client. */
17824 if (peergroup_af_flag_check(peer, afi, safi,
17825 PEER_FLAG_REFLECTOR_CLIENT)) {
17826 vty_out(vty, " neighbor %s route-reflector-client\n", addr);
17827 }
17828
17829 /* next-hop-self force */
17830 if (peergroup_af_flag_check(peer, afi, safi,
17831 PEER_FLAG_FORCE_NEXTHOP_SELF)) {
17832 vty_out(vty, " neighbor %s next-hop-self force\n", addr);
17833 }
17834
17835 /* next-hop-self */
17836 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_NEXTHOP_SELF)) {
17837 vty_out(vty, " neighbor %s next-hop-self\n", addr);
17838 }
17839
17840 /* remove-private-AS */
17841 if (peergroup_af_flag_check(peer, afi, safi,
17842 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE)) {
17843 vty_out(vty, " neighbor %s remove-private-AS all replace-AS\n",
17844 addr);
17845 }
17846
17847 else if (peergroup_af_flag_check(peer, afi, safi,
17848 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE)) {
17849 vty_out(vty, " neighbor %s remove-private-AS replace-AS\n",
17850 addr);
17851 }
17852
17853 else if (peergroup_af_flag_check(peer, afi, safi,
17854 PEER_FLAG_REMOVE_PRIVATE_AS_ALL)) {
17855 vty_out(vty, " neighbor %s remove-private-AS all\n", addr);
17856 }
17857
17858 else if (peergroup_af_flag_check(peer, afi, safi,
17859 PEER_FLAG_REMOVE_PRIVATE_AS)) {
17860 vty_out(vty, " neighbor %s remove-private-AS\n", addr);
17861 }
17862
17863 /* as-override */
17864 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_AS_OVERRIDE)) {
17865 vty_out(vty, " neighbor %s as-override\n", addr);
17866 }
17867
17868 /* send-community print. */
17869 flag_scomm = peergroup_af_flag_check(peer, afi, safi,
17870 PEER_FLAG_SEND_COMMUNITY);
17871 flag_secomm = peergroup_af_flag_check(peer, afi, safi,
17872 PEER_FLAG_SEND_EXT_COMMUNITY);
17873 flag_slcomm = peergroup_af_flag_check(peer, afi, safi,
17874 PEER_FLAG_SEND_LARGE_COMMUNITY);
17875
17876 if (flag_scomm && flag_secomm && flag_slcomm) {
17877 vty_out(vty, " no neighbor %s send-community all\n", addr);
17878 } else {
17879 if (flag_scomm)
17880 vty_out(vty, " no neighbor %s send-community\n", addr);
17881 if (flag_secomm)
17882 vty_out(vty,
17883 " no neighbor %s send-community extended\n",
17884 addr);
17885
17886 if (flag_slcomm)
17887 vty_out(vty, " no neighbor %s send-community large\n",
17888 addr);
17889 }
17890
17891 /* Default information */
17892 if (peergroup_af_flag_check(peer, afi, safi,
17893 PEER_FLAG_DEFAULT_ORIGINATE)) {
17894 vty_out(vty, " neighbor %s default-originate", addr);
17895
17896 if (peer->default_rmap[afi][safi].name)
17897 vty_out(vty, " route-map %s",
17898 peer->default_rmap[afi][safi].name);
17899
17900 vty_out(vty, "\n");
17901 }
17902
17903 /* Soft reconfiguration inbound. */
17904 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_SOFT_RECONFIG)) {
17905 vty_out(vty, " neighbor %s soft-reconfiguration inbound\n",
17906 addr);
17907 }
17908
17909 /* maximum-prefix. */
17910 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_MAX_PREFIX)) {
17911 vty_out(vty, " neighbor %s maximum-prefix %u", addr,
17912 peer->pmax[afi][safi]);
17913
17914 if (peer->pmax_threshold[afi][safi]
17915 != MAXIMUM_PREFIX_THRESHOLD_DEFAULT)
17916 vty_out(vty, " %u", peer->pmax_threshold[afi][safi]);
17917 if (peer_af_flag_check(peer, afi, safi,
17918 PEER_FLAG_MAX_PREFIX_WARNING))
17919 vty_out(vty, " warning-only");
17920 if (peer->pmax_restart[afi][safi])
17921 vty_out(vty, " restart %u",
17922 peer->pmax_restart[afi][safi]);
17923 if (peer_af_flag_check(peer, afi, safi,
17924 PEER_FLAG_MAX_PREFIX_FORCE))
17925 vty_out(vty, " force");
17926
17927 vty_out(vty, "\n");
17928 }
17929
17930 /* maximum-prefix-out */
17931 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_MAX_PREFIX_OUT))
17932 vty_out(vty, " neighbor %s maximum-prefix-out %u\n",
17933 addr, peer->pmax_out[afi][safi]);
17934
17935 /* Route server client. */
17936 if (peergroup_af_flag_check(peer, afi, safi,
17937 PEER_FLAG_RSERVER_CLIENT)) {
17938 vty_out(vty, " neighbor %s route-server-client\n", addr);
17939 }
17940
17941 /* Nexthop-local unchanged. */
17942 if (peergroup_af_flag_check(peer, afi, safi,
17943 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED)) {
17944 vty_out(vty, " neighbor %s nexthop-local unchanged\n", addr);
17945 }
17946
17947 /* allowas-in <1-10> */
17948 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ALLOWAS_IN)) {
17949 if (peer_af_flag_check(peer, afi, safi,
17950 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
17951 vty_out(vty, " neighbor %s allowas-in origin\n", addr);
17952 } else if (peer->allowas_in[afi][safi] == 3) {
17953 vty_out(vty, " neighbor %s allowas-in\n", addr);
17954 } else {
17955 vty_out(vty, " neighbor %s allowas-in %d\n", addr,
17956 peer->allowas_in[afi][safi]);
17957 }
17958 }
17959
17960 /* accept-own */
17961 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_ACCEPT_OWN))
17962 vty_out(vty, " neighbor %s accept-own\n", addr);
17963
17964 /* soo */
17965 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_SOO)) {
17966 char *soo_str = ecommunity_ecom2str(
17967 peer->soo[afi][safi], ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
17968
17969 vty_out(vty, " neighbor %s soo %s\n", addr, soo_str);
17970 XFREE(MTYPE_ECOMMUNITY_STR, soo_str);
17971 }
17972
17973 /* weight */
17974 if (peergroup_af_flag_check(peer, afi, safi, PEER_FLAG_WEIGHT))
17975 vty_out(vty, " neighbor %s weight %lu\n", addr,
17976 peer->weight[afi][safi]);
17977
17978 /* Filter. */
17979 bgp_config_write_filter(vty, peer, afi, safi);
17980
17981 /* atribute-unchanged. */
17982 if (peer_af_flag_check(peer, afi, safi, PEER_FLAG_AS_PATH_UNCHANGED)
17983 || (safi != SAFI_EVPN
17984 && peer_af_flag_check(peer, afi, safi,
17985 PEER_FLAG_NEXTHOP_UNCHANGED))
17986 || peer_af_flag_check(peer, afi, safi, PEER_FLAG_MED_UNCHANGED)) {
17987
17988 if (!peer_group_active(peer)
17989 || peergroup_af_flag_check(peer, afi, safi,
17990 PEER_FLAG_AS_PATH_UNCHANGED)
17991 || peergroup_af_flag_check(peer, afi, safi,
17992 PEER_FLAG_NEXTHOP_UNCHANGED)
17993 || peergroup_af_flag_check(peer, afi, safi,
17994 PEER_FLAG_MED_UNCHANGED)) {
17995
17996 vty_out(vty,
17997 " neighbor %s attribute-unchanged%s%s%s\n",
17998 addr,
17999 peer_af_flag_check(peer, afi, safi,
18000 PEER_FLAG_AS_PATH_UNCHANGED)
18001 ? " as-path"
18002 : "",
18003 peer_af_flag_check(peer, afi, safi,
18004 PEER_FLAG_NEXTHOP_UNCHANGED)
18005 ? " next-hop"
18006 : "",
18007 peer_af_flag_check(peer, afi, safi,
18008 PEER_FLAG_MED_UNCHANGED)
18009 ? " med"
18010 : "");
18011 }
18012 }
18013 }
18014
18015 static void bgp_vpn_config_write(struct vty *vty, struct bgp *bgp, afi_t afi,
18016 safi_t safi)
18017 {
18018 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
18019 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL))
18020 vty_out(vty, " no bgp retain route-target all\n");
18021 }
18022
18023 /* Address family based peer configuration display. */
18024 static void bgp_config_write_family(struct vty *vty, struct bgp *bgp, afi_t afi,
18025 safi_t safi)
18026 {
18027 struct peer *peer;
18028 struct peer_group *group;
18029 struct listnode *node, *nnode;
18030
18031
18032 vty_frame(vty, " !\n address-family ");
18033 if (afi == AFI_IP) {
18034 if (safi == SAFI_UNICAST)
18035 vty_frame(vty, "ipv4 unicast");
18036 else if (safi == SAFI_LABELED_UNICAST)
18037 vty_frame(vty, "ipv4 labeled-unicast");
18038 else if (safi == SAFI_MULTICAST)
18039 vty_frame(vty, "ipv4 multicast");
18040 else if (safi == SAFI_MPLS_VPN)
18041 vty_frame(vty, "ipv4 vpn");
18042 else if (safi == SAFI_ENCAP)
18043 vty_frame(vty, "ipv4 encap");
18044 else if (safi == SAFI_FLOWSPEC)
18045 vty_frame(vty, "ipv4 flowspec");
18046 } else if (afi == AFI_IP6) {
18047 if (safi == SAFI_UNICAST)
18048 vty_frame(vty, "ipv6 unicast");
18049 else if (safi == SAFI_LABELED_UNICAST)
18050 vty_frame(vty, "ipv6 labeled-unicast");
18051 else if (safi == SAFI_MULTICAST)
18052 vty_frame(vty, "ipv6 multicast");
18053 else if (safi == SAFI_MPLS_VPN)
18054 vty_frame(vty, "ipv6 vpn");
18055 else if (safi == SAFI_ENCAP)
18056 vty_frame(vty, "ipv6 encap");
18057 else if (safi == SAFI_FLOWSPEC)
18058 vty_frame(vty, "ipv6 flowspec");
18059 } else if (afi == AFI_L2VPN) {
18060 if (safi == SAFI_EVPN)
18061 vty_frame(vty, "l2vpn evpn");
18062 }
18063 vty_frame(vty, "\n");
18064
18065 bgp_config_write_distance(vty, bgp, afi, safi);
18066
18067 bgp_config_write_network(vty, bgp, afi, safi);
18068
18069 bgp_config_write_redistribute(vty, bgp, afi, safi);
18070
18071 /* BGP flag dampening. */
18072 if (CHECK_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
18073 bgp_config_write_damp(vty, afi, safi);
18074
18075 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group))
18076 bgp_config_write_peer_af(vty, bgp, group->conf, afi, safi);
18077
18078 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
18079 /* Do not display doppelganger peers */
18080 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
18081 bgp_config_write_peer_af(vty, bgp, peer, afi, safi);
18082 }
18083
18084 bgp_config_write_maxpaths(vty, bgp, afi, safi);
18085 bgp_config_write_table_map(vty, bgp, afi, safi);
18086
18087 if (safi == SAFI_EVPN)
18088 bgp_config_write_evpn_info(vty, bgp, afi, safi);
18089
18090 if (safi == SAFI_FLOWSPEC)
18091 bgp_fs_config_write_pbr(vty, bgp, afi, safi);
18092
18093 if (safi == SAFI_MPLS_VPN)
18094 bgp_vpn_config_write(vty, bgp, afi, safi);
18095
18096 if (safi == SAFI_UNICAST) {
18097 bgp_vpn_policy_config_write_afi(vty, bgp, afi);
18098 if (CHECK_FLAG(bgp->af_flags[afi][safi],
18099 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)) {
18100
18101 vty_out(vty, " export vpn\n");
18102 }
18103 if (CHECK_FLAG(bgp->af_flags[afi][safi],
18104 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
18105
18106 vty_out(vty, " import vpn\n");
18107 }
18108 if (CHECK_FLAG(bgp->af_flags[afi][safi],
18109 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
18110 char *name;
18111
18112 for (ALL_LIST_ELEMENTS_RO(
18113 bgp->vpn_policy[afi].import_vrf, node,
18114 name))
18115 vty_out(vty, " import vrf %s\n", name);
18116 }
18117 }
18118
18119 vty_endframe(vty, " exit-address-family\n");
18120 }
18121
18122 int bgp_config_write(struct vty *vty)
18123 {
18124 struct bgp *bgp;
18125 struct peer_group *group;
18126 struct peer *peer;
18127 struct listnode *node, *nnode;
18128 struct listnode *mnode, *mnnode;
18129 afi_t afi;
18130 safi_t safi;
18131 uint32_t tovpn_sid_index = 0;
18132
18133 if (bm->rmap_update_timer != RMAP_DEFAULT_UPDATE_TIMER)
18134 vty_out(vty, "bgp route-map delay-timer %u\n",
18135 bm->rmap_update_timer);
18136
18137 if (bm->v_update_delay != BGP_UPDATE_DELAY_DEF) {
18138 vty_out(vty, "bgp update-delay %d", bm->v_update_delay);
18139 if (bm->v_update_delay != bm->v_establish_wait)
18140 vty_out(vty, " %d", bm->v_establish_wait);
18141 vty_out(vty, "\n");
18142 }
18143
18144 if (bm->wait_for_fib)
18145 vty_out(vty, "bgp suppress-fib-pending\n");
18146
18147 if (CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
18148 vty_out(vty, "bgp graceful-shutdown\n");
18149
18150 /* No-RIB (Zebra) option flag configuration */
18151 if (bgp_option_check(BGP_OPT_NO_FIB))
18152 vty_out(vty, "bgp no-rib\n");
18153
18154 if (CHECK_FLAG(bm->flags, BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA))
18155 vty_out(vty, "bgp send-extra-data zebra\n");
18156
18157 /* BGP session DSCP value */
18158 if (bm->tcp_dscp != IPTOS_PREC_INTERNETCONTROL)
18159 vty_out(vty, "bgp session-dscp %u\n", bm->tcp_dscp >> 2);
18160
18161 /* BGP InQ limit */
18162 if (bm->inq_limit != BM_DEFAULT_Q_LIMIT)
18163 vty_out(vty, "bgp input-queue-limit %u\n", bm->inq_limit);
18164
18165 if (bm->outq_limit != BM_DEFAULT_Q_LIMIT)
18166 vty_out(vty, "bgp output-queue-limit %u\n", bm->outq_limit);
18167
18168 /* BGP configuration. */
18169 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp)) {
18170
18171 /* skip all auto created vrf as they dont have user config */
18172 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_AUTO))
18173 continue;
18174
18175 /* Router bgp ASN */
18176 vty_out(vty, "router bgp %s", bgp->as_pretty);
18177
18178 if (bgp->name)
18179 vty_out(vty, " %s %s",
18180 (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
18181 ? "view" : "vrf", bgp->name);
18182 if (CHECK_FLAG(bgp->config, BGP_CONFIG_ASNOTATION))
18183 vty_out(vty, " as-notation %s",
18184 asn_mode2str(bgp->asnotation));
18185
18186 vty_out(vty, "\n");
18187
18188 /* BGP fast-external-failover. */
18189 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
18190 vty_out(vty, " no bgp fast-external-failover\n");
18191
18192 /* BGP router ID. */
18193 if (bgp->router_id_static.s_addr != INADDR_ANY)
18194 vty_out(vty, " bgp router-id %pI4\n",
18195 &bgp->router_id_static);
18196
18197 /* Suppress fib pending */
18198 if (CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_FIB_PENDING))
18199 vty_out(vty, " bgp suppress-fib-pending\n");
18200
18201 /* BGP log-neighbor-changes. */
18202 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_LOG_NEIGHBOR_CHANGES)
18203 != SAVE_BGP_LOG_NEIGHBOR_CHANGES)
18204 vty_out(vty, " %sbgp log-neighbor-changes\n",
18205 CHECK_FLAG(bgp->flags,
18206 BGP_FLAG_LOG_NEIGHBOR_CHANGES)
18207 ? ""
18208 : "no ");
18209
18210 /* BGP configuration. */
18211 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED))
18212 vty_out(vty, " bgp always-compare-med\n");
18213
18214 /* RFC8212 default eBGP policy. */
18215 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY)
18216 != SAVE_BGP_EBGP_REQUIRES_POLICY)
18217 vty_out(vty, " %sbgp ebgp-requires-policy\n",
18218 CHECK_FLAG(bgp->flags,
18219 BGP_FLAG_EBGP_REQUIRES_POLICY)
18220 ? ""
18221 : "no ");
18222
18223 /* draft-ietf-idr-deprecate-as-set-confed-set */
18224 if (bgp->reject_as_sets)
18225 vty_out(vty, " bgp reject-as-sets\n");
18226
18227 /* Suppress duplicate updates if the route actually not changed
18228 */
18229 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES)
18230 != SAVE_BGP_SUPPRESS_DUPLICATES)
18231 vty_out(vty, " %sbgp suppress-duplicates\n",
18232 CHECK_FLAG(bgp->flags,
18233 BGP_FLAG_SUPPRESS_DUPLICATES)
18234 ? ""
18235 : "no ");
18236
18237 /* Send Hard Reset CEASE Notification for 'Administrative Reset'
18238 */
18239 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_HARD_ADMIN_RESET) !=
18240 SAVE_BGP_HARD_ADMIN_RESET)
18241 vty_out(vty, " %sbgp hard-administrative-reset\n",
18242 CHECK_FLAG(bgp->flags,
18243 BGP_FLAG_HARD_ADMIN_RESET)
18244 ? ""
18245 : "no ");
18246
18247 /* BGP default <afi>-<safi> */
18248 FOREACH_AFI_SAFI (afi, safi) {
18249 if (afi == AFI_IP && safi == SAFI_UNICAST) {
18250 if (!bgp->default_af[afi][safi])
18251 vty_out(vty, " no bgp default %s\n",
18252 get_bgp_default_af_flag(afi,
18253 safi));
18254 } else if (bgp->default_af[afi][safi])
18255 vty_out(vty, " bgp default %s\n",
18256 get_bgp_default_af_flag(afi, safi));
18257 }
18258
18259 /* BGP default local-preference. */
18260 if (bgp->default_local_pref != BGP_DEFAULT_LOCAL_PREF)
18261 vty_out(vty, " bgp default local-preference %u\n",
18262 bgp->default_local_pref);
18263
18264 /* BGP default show-hostname */
18265 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME)
18266 != SAVE_BGP_SHOW_HOSTNAME)
18267 vty_out(vty, " %sbgp default show-hostname\n",
18268 CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_HOSTNAME)
18269 ? ""
18270 : "no ");
18271
18272 /* BGP default show-nexthop-hostname */
18273 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME)
18274 != SAVE_BGP_SHOW_HOSTNAME)
18275 vty_out(vty, " %sbgp default show-nexthop-hostname\n",
18276 CHECK_FLAG(bgp->flags,
18277 BGP_FLAG_SHOW_NEXTHOP_HOSTNAME)
18278 ? ""
18279 : "no ");
18280
18281 /* BGP default subgroup-pkt-queue-max. */
18282 if (bgp->default_subgroup_pkt_queue_max
18283 != BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX)
18284 vty_out(vty, " bgp default subgroup-pkt-queue-max %u\n",
18285 bgp->default_subgroup_pkt_queue_max);
18286
18287 /* BGP client-to-client reflection. */
18288 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_CLIENT_TO_CLIENT))
18289 vty_out(vty, " no bgp client-to-client reflection\n");
18290
18291 /* BGP cluster ID. */
18292 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CLUSTER_ID))
18293 vty_out(vty, " bgp cluster-id %pI4\n",
18294 &bgp->cluster_id);
18295
18296 /* Disable ebgp connected nexthop check */
18297 if (CHECK_FLAG(bgp->flags, BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
18298 vty_out(vty,
18299 " bgp disable-ebgp-connected-route-check\n");
18300
18301 /* Confederation identifier*/
18302 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
18303 vty_out(vty, " bgp confederation identifier %s\n",
18304 bgp->confed_id_pretty);
18305
18306 /* Confederation peer */
18307 if (bgp->confed_peers_cnt > 0) {
18308 int i;
18309
18310 vty_out(vty, " bgp confederation peers");
18311
18312 for (i = 0; i < bgp->confed_peers_cnt; i++)
18313 vty_out(vty, " %s",
18314 bgp->confed_peers[i].as_pretty);
18315
18316 vty_out(vty, "\n");
18317 }
18318
18319 /* BGP deterministic-med. */
18320 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)
18321 != SAVE_BGP_DETERMINISTIC_MED)
18322 vty_out(vty, " %sbgp deterministic-med\n",
18323 CHECK_FLAG(bgp->flags,
18324 BGP_FLAG_DETERMINISTIC_MED)
18325 ? ""
18326 : "no ");
18327
18328 /* BGP update-delay. */
18329 bgp_config_write_update_delay(vty, bgp);
18330
18331 if (bgp->v_maxmed_onstartup
18332 != BGP_MAXMED_ONSTARTUP_UNCONFIGURED) {
18333 vty_out(vty, " bgp max-med on-startup %u",
18334 bgp->v_maxmed_onstartup);
18335 if (bgp->maxmed_onstartup_value
18336 != BGP_MAXMED_VALUE_DEFAULT)
18337 vty_out(vty, " %u",
18338 bgp->maxmed_onstartup_value);
18339 vty_out(vty, "\n");
18340 }
18341 if (bgp->v_maxmed_admin != BGP_MAXMED_ADMIN_UNCONFIGURED) {
18342 vty_out(vty, " bgp max-med administrative");
18343 if (bgp->maxmed_admin_value != BGP_MAXMED_VALUE_DEFAULT)
18344 vty_out(vty, " %u", bgp->maxmed_admin_value);
18345 vty_out(vty, "\n");
18346 }
18347
18348 /* write quanta */
18349 bgp_config_write_wpkt_quanta(vty, bgp);
18350 /* read quanta */
18351 bgp_config_write_rpkt_quanta(vty, bgp);
18352
18353 /* coalesce time */
18354 bgp_config_write_coalesce_time(vty, bgp);
18355
18356 /* BGP per-instance graceful-shutdown */
18357 /* BGP-wide settings and per-instance settings are mutually
18358 * exclusive.
18359 */
18360 if (!CHECK_FLAG(bm->flags, BM_FLAG_GRACEFUL_SHUTDOWN))
18361 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_SHUTDOWN))
18362 vty_out(vty, " bgp graceful-shutdown\n");
18363
18364 /* Long-lived Graceful Restart */
18365 if (bgp->llgr_stale_time != BGP_DEFAULT_LLGR_STALE_TIME)
18366 vty_out(vty,
18367 " bgp long-lived-graceful-restart stale-time %u\n",
18368 bgp->llgr_stale_time);
18369
18370 /* BGP graceful-restart. */
18371 if (bgp->stalepath_time != BGP_DEFAULT_STALEPATH_TIME)
18372 vty_out(vty,
18373 " bgp graceful-restart stalepath-time %u\n",
18374 bgp->stalepath_time);
18375
18376 if (bgp->restart_time != BGP_DEFAULT_RESTART_TIME)
18377 vty_out(vty, " bgp graceful-restart restart-time %u\n",
18378 bgp->restart_time);
18379
18380 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_GRACEFUL_NOTIFICATION) !=
18381 SAVE_BGP_GRACEFUL_NOTIFICATION)
18382 vty_out(vty, " %sbgp graceful-restart notification\n",
18383 CHECK_FLAG(bgp->flags,
18384 BGP_FLAG_GRACEFUL_NOTIFICATION)
18385 ? ""
18386 : "no ");
18387
18388 if (bgp->select_defer_time != BGP_DEFAULT_SELECT_DEFERRAL_TIME)
18389 vty_out(vty,
18390 " bgp graceful-restart select-defer-time %u\n",
18391 bgp->select_defer_time);
18392
18393 if (bgp_global_gr_mode_get(bgp) == GLOBAL_GR)
18394 vty_out(vty, " bgp graceful-restart\n");
18395
18396 if (bgp_global_gr_mode_get(bgp) == GLOBAL_DISABLE)
18397 vty_out(vty, " bgp graceful-restart-disable\n");
18398
18399 /* BGP graceful-restart Preserve State F bit. */
18400 if (CHECK_FLAG(bgp->flags, BGP_FLAG_GR_PRESERVE_FWD))
18401 vty_out(vty,
18402 " bgp graceful-restart preserve-fw-state\n");
18403
18404 /* BGP TCP keepalive */
18405 bgp_config_tcp_keepalive(vty, bgp);
18406
18407 /* Stale timer for RIB */
18408 if (bgp->rib_stale_time != BGP_DEFAULT_RIB_STALE_TIME)
18409 vty_out(vty,
18410 " bgp graceful-restart rib-stale-time %u\n",
18411 bgp->rib_stale_time);
18412
18413 /* BGP bestpath method. */
18414 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE))
18415 vty_out(vty, " bgp bestpath as-path ignore\n");
18416 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED))
18417 vty_out(vty, " bgp bestpath as-path confed\n");
18418
18419 if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
18420 if (CHECK_FLAG(bgp->flags,
18421 BGP_FLAG_MULTIPATH_RELAX_AS_SET)) {
18422 vty_out(vty,
18423 " bgp bestpath as-path multipath-relax as-set\n");
18424 } else {
18425 vty_out(vty,
18426 " bgp bestpath as-path multipath-relax\n");
18427 }
18428 }
18429
18430 if (CHECK_FLAG(bgp->flags, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
18431 vty_out(vty,
18432 " bgp route-reflector allow-outbound-policy\n");
18433 }
18434 if (CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID))
18435 vty_out(vty, " bgp bestpath compare-routerid\n");
18436 if (CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_AIGP))
18437 vty_out(vty, " bgp bestpath aigp\n");
18438 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED)
18439 || CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST)) {
18440 vty_out(vty, " bgp bestpath med");
18441 if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED))
18442 vty_out(vty, " confed");
18443 if (CHECK_FLAG(bgp->flags,
18444 BGP_FLAG_MED_MISSING_AS_WORST))
18445 vty_out(vty, " missing-as-worst");
18446 vty_out(vty, "\n");
18447 }
18448
18449 if (CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
18450 vty_out(vty,
18451 " bgp bestpath peer-type multipath-relax\n");
18452
18453 /* Link bandwidth handling. */
18454 if (bgp->lb_handling == BGP_LINK_BW_IGNORE_BW)
18455 vty_out(vty, " bgp bestpath bandwidth ignore\n");
18456 else if (bgp->lb_handling == BGP_LINK_BW_SKIP_MISSING)
18457 vty_out(vty, " bgp bestpath bandwidth skip-missing\n");
18458 else if (bgp->lb_handling == BGP_LINK_BW_DEFWT_4_MISSING)
18459 vty_out(vty, " bgp bestpath bandwidth default-weight-for-missing\n");
18460
18461 /* BGP network import check. */
18462 if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)
18463 != SAVE_BGP_IMPORT_CHECK)
18464 vty_out(vty, " %sbgp network import-check\n",
18465 CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)
18466 ? ""
18467 : "no ");
18468
18469 /* BGP timers configuration. */
18470 if (bgp->default_keepalive != SAVE_BGP_KEEPALIVE
18471 || bgp->default_holdtime != SAVE_BGP_HOLDTIME)
18472 vty_out(vty, " timers bgp %u %u\n",
18473 bgp->default_keepalive, bgp->default_holdtime);
18474
18475 /* BGP minimum holdtime configuration. */
18476 if (bgp->default_min_holdtime != SAVE_BGP_HOLDTIME
18477 && bgp->default_min_holdtime != 0)
18478 vty_out(vty, " bgp minimum-holdtime %u\n",
18479 bgp->default_min_holdtime);
18480
18481 /* Conditional advertisement timer configuration */
18482 if (bgp->condition_check_period
18483 != DEFAULT_CONDITIONAL_ROUTES_POLL_TIME)
18484 vty_out(vty,
18485 " bgp conditional-advertisement timer %u\n",
18486 bgp->condition_check_period);
18487
18488 /* peer-group */
18489 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
18490 bgp_config_write_peer_global(vty, bgp, group->conf);
18491 }
18492
18493 /* Normal neighbor configuration. */
18494 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
18495 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
18496 bgp_config_write_peer_global(vty, bgp, peer);
18497 }
18498
18499 /* listen range and limit for dynamic BGP neighbors */
18500 bgp_config_write_listen(vty, bgp);
18501
18502 /*
18503 * BGP default autoshutdown neighbors
18504 *
18505 * This must be placed after any peer and peer-group
18506 * configuration, to avoid setting all peers to shutdown after
18507 * a daemon restart, which is undesired behavior. (see #2286)
18508 */
18509 if (bgp->autoshutdown)
18510 vty_out(vty, " bgp default shutdown\n");
18511
18512 /* BGP instance administrative shutdown */
18513 if (CHECK_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN))
18514 vty_out(vty, " bgp shutdown\n");
18515
18516 if (bgp->allow_martian)
18517 vty_out(vty, " bgp allow-martian-nexthop\n");
18518
18519 if (bgp->fast_convergence)
18520 vty_out(vty, " bgp fast-convergence\n");
18521
18522 if (bgp->srv6_enabled) {
18523 vty_frame(vty, " !\n segment-routing srv6\n");
18524 if (strlen(bgp->srv6_locator_name))
18525 vty_out(vty, " locator %s\n",
18526 bgp->srv6_locator_name);
18527 vty_endframe(vty, " exit\n");
18528 }
18529
18530 tovpn_sid_index = bgp->tovpn_sid_index;
18531 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_TOVPN_SID_AUTO)) {
18532 vty_out(vty, " sid vpn per-vrf export auto\n");
18533 } else if (tovpn_sid_index != 0) {
18534 vty_out(vty, " sid vpn per-vrf export %d\n",
18535 tovpn_sid_index);
18536 }
18537
18538 /* IPv4 unicast configuration. */
18539 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_UNICAST);
18540
18541 /* IPv4 multicast configuration. */
18542 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_MULTICAST);
18543
18544 /* IPv4 labeled-unicast configuration. */
18545 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_LABELED_UNICAST);
18546
18547 /* IPv4 VPN configuration. */
18548 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_MPLS_VPN);
18549
18550 /* ENCAPv4 configuration. */
18551 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_ENCAP);
18552
18553 /* FLOWSPEC v4 configuration. */
18554 bgp_config_write_family(vty, bgp, AFI_IP, SAFI_FLOWSPEC);
18555
18556 /* IPv6 unicast configuration. */
18557 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_UNICAST);
18558
18559 /* IPv6 multicast configuration. */
18560 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_MULTICAST);
18561
18562 /* IPv6 labeled-unicast configuration. */
18563 bgp_config_write_family(vty, bgp, AFI_IP6,
18564 SAFI_LABELED_UNICAST);
18565
18566 /* IPv6 VPN configuration. */
18567 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_MPLS_VPN);
18568
18569 /* ENCAPv6 configuration. */
18570 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_ENCAP);
18571
18572 /* FLOWSPEC v6 configuration. */
18573 bgp_config_write_family(vty, bgp, AFI_IP6, SAFI_FLOWSPEC);
18574
18575 /* EVPN configuration. */
18576 bgp_config_write_family(vty, bgp, AFI_L2VPN, SAFI_EVPN);
18577
18578 hook_call(bgp_inst_config_write, bgp, vty);
18579
18580 #ifdef ENABLE_BGP_VNC
18581 bgp_rfapi_cfg_write(vty, bgp);
18582 #endif
18583
18584 vty_out(vty, "exit\n");
18585 vty_out(vty, "!\n");
18586 }
18587 return 0;
18588 }
18589
18590
18591 /* BGP node structure. */
18592 static struct cmd_node bgp_node = {
18593 .name = "bgp",
18594 .node = BGP_NODE,
18595 .parent_node = CONFIG_NODE,
18596 .prompt = "%s(config-router)# ",
18597 .config_write = bgp_config_write,
18598 };
18599
18600 static struct cmd_node bgp_ipv4_unicast_node = {
18601 .name = "bgp ipv4 unicast",
18602 .node = BGP_IPV4_NODE,
18603 .parent_node = BGP_NODE,
18604 .prompt = "%s(config-router-af)# ",
18605 .no_xpath = true,
18606 };
18607
18608 static struct cmd_node bgp_ipv4_multicast_node = {
18609 .name = "bgp ipv4 multicast",
18610 .node = BGP_IPV4M_NODE,
18611 .parent_node = BGP_NODE,
18612 .prompt = "%s(config-router-af)# ",
18613 .no_xpath = true,
18614 };
18615
18616 static struct cmd_node bgp_ipv4_labeled_unicast_node = {
18617 .name = "bgp ipv4 labeled unicast",
18618 .node = BGP_IPV4L_NODE,
18619 .parent_node = BGP_NODE,
18620 .prompt = "%s(config-router-af)# ",
18621 .no_xpath = true,
18622 };
18623
18624 static struct cmd_node bgp_ipv6_unicast_node = {
18625 .name = "bgp ipv6 unicast",
18626 .node = BGP_IPV6_NODE,
18627 .parent_node = BGP_NODE,
18628 .prompt = "%s(config-router-af)# ",
18629 .no_xpath = true,
18630 };
18631
18632 static struct cmd_node bgp_ipv6_multicast_node = {
18633 .name = "bgp ipv6 multicast",
18634 .node = BGP_IPV6M_NODE,
18635 .parent_node = BGP_NODE,
18636 .prompt = "%s(config-router-af)# ",
18637 .no_xpath = true,
18638 };
18639
18640 static struct cmd_node bgp_ipv6_labeled_unicast_node = {
18641 .name = "bgp ipv6 labeled unicast",
18642 .node = BGP_IPV6L_NODE,
18643 .parent_node = BGP_NODE,
18644 .prompt = "%s(config-router-af)# ",
18645 .no_xpath = true,
18646 };
18647
18648 static struct cmd_node bgp_vpnv4_node = {
18649 .name = "bgp vpnv4",
18650 .node = BGP_VPNV4_NODE,
18651 .parent_node = BGP_NODE,
18652 .prompt = "%s(config-router-af)# ",
18653 .no_xpath = true,
18654 };
18655
18656 static struct cmd_node bgp_vpnv6_node = {
18657 .name = "bgp vpnv6",
18658 .node = BGP_VPNV6_NODE,
18659 .parent_node = BGP_NODE,
18660 .prompt = "%s(config-router-af-vpnv6)# ",
18661 .no_xpath = true,
18662 };
18663
18664 static struct cmd_node bgp_evpn_node = {
18665 .name = "bgp evpn",
18666 .node = BGP_EVPN_NODE,
18667 .parent_node = BGP_NODE,
18668 .prompt = "%s(config-router-evpn)# ",
18669 .no_xpath = true,
18670 };
18671
18672 static struct cmd_node bgp_evpn_vni_node = {
18673 .name = "bgp evpn vni",
18674 .node = BGP_EVPN_VNI_NODE,
18675 .parent_node = BGP_EVPN_NODE,
18676 .prompt = "%s(config-router-af-vni)# ",
18677 };
18678
18679 static struct cmd_node bgp_flowspecv4_node = {
18680 .name = "bgp ipv4 flowspec",
18681 .node = BGP_FLOWSPECV4_NODE,
18682 .parent_node = BGP_NODE,
18683 .prompt = "%s(config-router-af)# ",
18684 .no_xpath = true,
18685 };
18686
18687 static struct cmd_node bgp_flowspecv6_node = {
18688 .name = "bgp ipv6 flowspec",
18689 .node = BGP_FLOWSPECV6_NODE,
18690 .parent_node = BGP_NODE,
18691 .prompt = "%s(config-router-af-vpnv6)# ",
18692 .no_xpath = true,
18693 };
18694
18695 static struct cmd_node bgp_srv6_node = {
18696 .name = "bgp srv6",
18697 .node = BGP_SRV6_NODE,
18698 .parent_node = BGP_NODE,
18699 .prompt = "%s(config-router-srv6)# ",
18700 };
18701
18702 static void community_list_vty(void);
18703
18704 static void bgp_ac_peergroup(vector comps, struct cmd_token *token)
18705 {
18706 struct bgp *bgp;
18707 struct peer_group *group;
18708 struct listnode *lnbgp, *lnpeer;
18709
18710 for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
18711 for (ALL_LIST_ELEMENTS_RO(bgp->group, lnpeer, group))
18712 vector_set(comps,
18713 XSTRDUP(MTYPE_COMPLETION, group->name));
18714 }
18715 }
18716
18717 static void bgp_ac_peer(vector comps, struct cmd_token *token)
18718 {
18719 struct bgp *bgp;
18720 struct peer *peer;
18721 struct listnode *lnbgp, *lnpeer;
18722
18723 for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
18724 for (ALL_LIST_ELEMENTS_RO(bgp->peer, lnpeer, peer)) {
18725 /* only provide suggestions on the appropriate input
18726 * token type,
18727 * they'll otherwise show up multiple times */
18728 enum cmd_token_type match_type;
18729 char *name = peer->host;
18730
18731 if (peer->conf_if) {
18732 match_type = VARIABLE_TKN;
18733 name = peer->conf_if;
18734 } else if (strchr(peer->host, ':'))
18735 match_type = IPV6_TKN;
18736 else
18737 match_type = IPV4_TKN;
18738
18739 if (token->type != match_type)
18740 continue;
18741
18742 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, name));
18743 }
18744 }
18745 }
18746
18747 static void bgp_ac_neighbor(vector comps, struct cmd_token *token)
18748 {
18749 bgp_ac_peer(comps, token);
18750
18751 if (token->type == VARIABLE_TKN)
18752 bgp_ac_peergroup(comps, token);
18753 }
18754
18755 static const struct cmd_variable_handler bgp_var_neighbor[] = {
18756 {.varname = "neighbor", .completions = bgp_ac_neighbor},
18757 {.varname = "neighbors", .completions = bgp_ac_neighbor},
18758 {.varname = "peer", .completions = bgp_ac_neighbor},
18759 {.completions = NULL}};
18760
18761 static const struct cmd_variable_handler bgp_var_peergroup[] = {
18762 {.tokenname = "PGNAME", .completions = bgp_ac_peergroup},
18763 {.completions = NULL} };
18764
18765 DEFINE_HOOK(bgp_config_end, (struct bgp *bgp), (bgp));
18766
18767 static struct thread *t_bgp_cfg;
18768
18769 bool bgp_config_inprocess(void)
18770 {
18771 return thread_is_scheduled(t_bgp_cfg);
18772 }
18773
18774 static void bgp_config_finish(struct thread *t)
18775 {
18776 struct listnode *node;
18777 struct bgp *bgp;
18778
18779 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp))
18780 hook_call(bgp_config_end, bgp);
18781 }
18782
18783 static void bgp_config_start(void)
18784 {
18785 #define BGP_PRE_CONFIG_MAX_WAIT_SECONDS 600
18786 THREAD_OFF(t_bgp_cfg);
18787 thread_add_timer(bm->master, bgp_config_finish, NULL,
18788 BGP_PRE_CONFIG_MAX_WAIT_SECONDS, &t_bgp_cfg);
18789 }
18790
18791 /* When we receive a hook the configuration is read,
18792 * we start a timer to make sure we postpone sending
18793 * EoR before route-maps are processed.
18794 * This is especially valid if using `bgp route-map delay-timer`.
18795 */
18796 static void bgp_config_end(void)
18797 {
18798 #define BGP_POST_CONFIG_DELAY_SECONDS 1
18799 uint32_t bgp_post_config_delay =
18800 thread_is_scheduled(bm->t_rmap_update)
18801 ? thread_timer_remain_second(bm->t_rmap_update)
18802 : BGP_POST_CONFIG_DELAY_SECONDS;
18803
18804 /* If BGP config processing thread isn't running, then
18805 * we can return and rely it's properly handled.
18806 */
18807 if (!bgp_config_inprocess())
18808 return;
18809
18810 THREAD_OFF(t_bgp_cfg);
18811
18812 /* Start a new timer to make sure we don't send EoR
18813 * before route-maps are processed.
18814 */
18815 thread_add_timer(bm->master, bgp_config_finish, NULL,
18816 bgp_post_config_delay, &t_bgp_cfg);
18817 }
18818
18819 static int config_write_interface_one(struct vty *vty, struct vrf *vrf)
18820 {
18821 int write = 0;
18822 struct interface *ifp;
18823 struct bgp_interface *iifp;
18824
18825 FOR_ALL_INTERFACES (vrf, ifp) {
18826 iifp = ifp->info;
18827 if (!iifp)
18828 continue;
18829
18830 if_vty_config_start(vty, ifp);
18831
18832 if (CHECK_FLAG(iifp->flags,
18833 BGP_INTERFACE_MPLS_BGP_FORWARDING)) {
18834 vty_out(vty, " mpls bgp forwarding\n");
18835 write++;
18836 }
18837
18838 if_vty_config_end(vty);
18839 }
18840
18841 return write;
18842 }
18843
18844 /* Configuration write function for bgpd. */
18845 static int config_write_interface(struct vty *vty)
18846 {
18847 int write = 0;
18848 struct vrf *vrf = NULL;
18849
18850 /* Display all VRF aware OSPF interface configuration */
18851 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
18852 write += config_write_interface_one(vty, vrf);
18853 }
18854
18855 return write;
18856 }
18857
18858 DEFPY(mpls_bgp_forwarding, mpls_bgp_forwarding_cmd,
18859 "[no$no] mpls bgp forwarding",
18860 NO_STR MPLS_STR BGP_STR
18861 "Enable MPLS forwarding for eBGP directly connected peers\n")
18862 {
18863 bool check;
18864 struct bgp_interface *iifp;
18865
18866 VTY_DECLVAR_CONTEXT(interface, ifp);
18867 iifp = ifp->info;
18868 if (!iifp) {
18869 vty_out(vty, "Interface %s not available\n", ifp->name);
18870 return CMD_WARNING_CONFIG_FAILED;
18871 }
18872 check = CHECK_FLAG(iifp->flags, BGP_INTERFACE_MPLS_BGP_FORWARDING);
18873 if (check != !no) {
18874 if (no)
18875 UNSET_FLAG(iifp->flags,
18876 BGP_INTERFACE_MPLS_BGP_FORWARDING);
18877 else
18878 SET_FLAG(iifp->flags,
18879 BGP_INTERFACE_MPLS_BGP_FORWARDING);
18880 /* trigger a nht update on eBGP sessions */
18881 if (if_is_operative(ifp))
18882 bgp_nht_ifp_up(ifp);
18883 }
18884 return CMD_SUCCESS;
18885 }
18886
18887 DEFPY (bgp_inq_limit,
18888 bgp_inq_limit_cmd,
18889 "bgp input-queue-limit (1-4294967295)$limit",
18890 BGP_STR
18891 "Set the BGP Input Queue limit for all peers when message parsing\n"
18892 "Input-Queue limit\n")
18893 {
18894 bm->inq_limit = limit;
18895
18896 return CMD_SUCCESS;
18897 }
18898
18899 DEFPY (no_bgp_inq_limit,
18900 no_bgp_inq_limit_cmd,
18901 "no bgp input-queue-limit [(1-4294967295)$limit]",
18902 NO_STR
18903 BGP_STR
18904 "Set the BGP Input Queue limit for all peers when message parsing\n"
18905 "Input-Queue limit\n")
18906 {
18907 bm->inq_limit = BM_DEFAULT_Q_LIMIT;
18908
18909 return CMD_SUCCESS;
18910 }
18911
18912 DEFPY (bgp_outq_limit,
18913 bgp_outq_limit_cmd,
18914 "bgp output-queue-limit (1-4294967295)$limit",
18915 BGP_STR
18916 "Set the BGP Output Queue limit for all peers when message parsing\n"
18917 "Output-Queue limit\n")
18918 {
18919 bm->outq_limit = limit;
18920
18921 return CMD_SUCCESS;
18922 }
18923
18924 DEFPY (no_bgp_outq_limit,
18925 no_bgp_outq_limit_cmd,
18926 "no bgp output-queue-limit [(1-4294967295)$limit]",
18927 NO_STR
18928 BGP_STR
18929 "Set the BGP Output Queue limit for all peers when message parsing\n"
18930 "Output-Queue limit\n")
18931 {
18932 bm->outq_limit = BM_DEFAULT_Q_LIMIT;
18933
18934 return CMD_SUCCESS;
18935 }
18936
18937
18938 /* Initialization of BGP interface. */
18939 static void bgp_vty_if_init(void)
18940 {
18941 /* Install interface node. */
18942 if_cmd_init(config_write_interface);
18943
18944 /* "mpls bgp forwarding" commands. */
18945 install_element(INTERFACE_NODE, &mpls_bgp_forwarding_cmd);
18946 }
18947
18948 void bgp_vty_init(void)
18949 {
18950 cmd_variable_handler_register(bgp_var_neighbor);
18951 cmd_variable_handler_register(bgp_var_peergroup);
18952
18953 cmd_init_config_callbacks(bgp_config_start, bgp_config_end);
18954
18955 /* Install bgp top node. */
18956 install_node(&bgp_node);
18957 install_node(&bgp_ipv4_unicast_node);
18958 install_node(&bgp_ipv4_multicast_node);
18959 install_node(&bgp_ipv4_labeled_unicast_node);
18960 install_node(&bgp_ipv6_unicast_node);
18961 install_node(&bgp_ipv6_multicast_node);
18962 install_node(&bgp_ipv6_labeled_unicast_node);
18963 install_node(&bgp_vpnv4_node);
18964 install_node(&bgp_vpnv6_node);
18965 install_node(&bgp_evpn_node);
18966 install_node(&bgp_evpn_vni_node);
18967 install_node(&bgp_flowspecv4_node);
18968 install_node(&bgp_flowspecv6_node);
18969 install_node(&bgp_srv6_node);
18970
18971 /* Install default VTY commands to new nodes. */
18972 install_default(BGP_NODE);
18973 install_default(BGP_IPV4_NODE);
18974 install_default(BGP_IPV4M_NODE);
18975 install_default(BGP_IPV4L_NODE);
18976 install_default(BGP_IPV6_NODE);
18977 install_default(BGP_IPV6M_NODE);
18978 install_default(BGP_IPV6L_NODE);
18979 install_default(BGP_VPNV4_NODE);
18980 install_default(BGP_VPNV6_NODE);
18981 install_default(BGP_FLOWSPECV4_NODE);
18982 install_default(BGP_FLOWSPECV6_NODE);
18983 install_default(BGP_EVPN_NODE);
18984 install_default(BGP_EVPN_VNI_NODE);
18985 install_default(BGP_SRV6_NODE);
18986
18987 /* "global bgp inq-limit command */
18988 install_element(CONFIG_NODE, &bgp_inq_limit_cmd);
18989 install_element(CONFIG_NODE, &no_bgp_inq_limit_cmd);
18990 install_element(CONFIG_NODE, &bgp_outq_limit_cmd);
18991 install_element(CONFIG_NODE, &no_bgp_outq_limit_cmd);
18992
18993 /* "bgp local-mac" hidden commands. */
18994 install_element(CONFIG_NODE, &bgp_local_mac_cmd);
18995 install_element(CONFIG_NODE, &no_bgp_local_mac_cmd);
18996
18997 /* "bgp suppress-fib-pending" global */
18998 install_element(CONFIG_NODE, &bgp_global_suppress_fib_pending_cmd);
18999
19000 /* bgp route-map delay-timer commands. */
19001 install_element(CONFIG_NODE, &bgp_set_route_map_delay_timer_cmd);
19002 install_element(CONFIG_NODE, &no_bgp_set_route_map_delay_timer_cmd);
19003
19004 install_element(BGP_NODE, &bgp_allow_martian_cmd);
19005
19006 /* bgp fast-convergence command */
19007 install_element(BGP_NODE, &bgp_fast_convergence_cmd);
19008 install_element(BGP_NODE, &no_bgp_fast_convergence_cmd);
19009
19010 /* global bgp update-delay command */
19011 install_element(CONFIG_NODE, &bgp_global_update_delay_cmd);
19012 install_element(CONFIG_NODE, &no_bgp_global_update_delay_cmd);
19013
19014 /* global bgp graceful-shutdown command */
19015 install_element(CONFIG_NODE, &bgp_graceful_shutdown_cmd);
19016 install_element(CONFIG_NODE, &no_bgp_graceful_shutdown_cmd);
19017
19018 /* Dummy commands (Currently not supported) */
19019 install_element(BGP_NODE, &no_synchronization_cmd);
19020 install_element(BGP_NODE, &no_auto_summary_cmd);
19021
19022 /* "router bgp" commands. */
19023 install_element(CONFIG_NODE, &router_bgp_cmd);
19024
19025 /* "no router bgp" commands. */
19026 install_element(CONFIG_NODE, &no_router_bgp_cmd);
19027
19028 /* "bgp session-dscp command */
19029 install_element(CONFIG_NODE, &bgp_session_dscp_cmd);
19030 install_element(CONFIG_NODE, &no_bgp_session_dscp_cmd);
19031
19032 /* "bgp router-id" commands. */
19033 install_element(BGP_NODE, &bgp_router_id_cmd);
19034 install_element(BGP_NODE, &no_bgp_router_id_cmd);
19035
19036 /* "bgp suppress-fib-pending" command */
19037 install_element(BGP_NODE, &bgp_suppress_fib_pending_cmd);
19038
19039 /* "bgp cluster-id" commands. */
19040 install_element(BGP_NODE, &bgp_cluster_id_cmd);
19041 install_element(BGP_NODE, &no_bgp_cluster_id_cmd);
19042
19043 /* "bgp no-rib" commands. */
19044 install_element(CONFIG_NODE, &bgp_norib_cmd);
19045 install_element(CONFIG_NODE, &no_bgp_norib_cmd);
19046
19047 install_element(CONFIG_NODE, &no_bgp_send_extra_data_cmd);
19048
19049 /* "bgp confederation" commands. */
19050 install_element(BGP_NODE, &bgp_confederation_identifier_cmd);
19051 install_element(BGP_NODE, &no_bgp_confederation_identifier_cmd);
19052
19053 /* "bgp confederation peers" commands. */
19054 install_element(BGP_NODE, &bgp_confederation_peers_cmd);
19055 install_element(BGP_NODE, &no_bgp_confederation_peers_cmd);
19056
19057 /* bgp max-med command */
19058 install_element(BGP_NODE, &bgp_maxmed_admin_cmd);
19059 install_element(BGP_NODE, &no_bgp_maxmed_admin_cmd);
19060 install_element(BGP_NODE, &bgp_maxmed_admin_medv_cmd);
19061 install_element(BGP_NODE, &bgp_maxmed_onstartup_cmd);
19062 install_element(BGP_NODE, &no_bgp_maxmed_onstartup_cmd);
19063
19064 /* "neighbor role" commands. */
19065 install_element(BGP_NODE, &neighbor_role_cmd);
19066 install_element(BGP_NODE, &neighbor_role_strict_cmd);
19067 install_element(BGP_NODE, &no_neighbor_role_cmd);
19068
19069 /* "neighbor aigp" commands. */
19070 install_element(BGP_NODE, &neighbor_aigp_cmd);
19071
19072 /* "neighbor graceful-shutdown" command */
19073 install_element(BGP_NODE, &neighbor_graceful_shutdown_cmd);
19074
19075 /* bgp disable-ebgp-connected-nh-check */
19076 install_element(BGP_NODE, &bgp_disable_connected_route_check_cmd);
19077 install_element(BGP_NODE, &no_bgp_disable_connected_route_check_cmd);
19078
19079 /* bgp update-delay command */
19080 install_element(BGP_NODE, &bgp_update_delay_cmd);
19081 install_element(BGP_NODE, &no_bgp_update_delay_cmd);
19082
19083 install_element(BGP_NODE, &bgp_wpkt_quanta_cmd);
19084 install_element(BGP_NODE, &bgp_rpkt_quanta_cmd);
19085
19086 install_element(BGP_NODE, &bgp_coalesce_time_cmd);
19087 install_element(BGP_NODE, &no_bgp_coalesce_time_cmd);
19088
19089 /* "maximum-paths" commands. */
19090 install_element(BGP_NODE, &bgp_maxpaths_hidden_cmd);
19091 install_element(BGP_NODE, &no_bgp_maxpaths_hidden_cmd);
19092 install_element(BGP_IPV4_NODE, &bgp_maxpaths_cmd);
19093 install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_cmd);
19094 install_element(BGP_IPV6_NODE, &bgp_maxpaths_cmd);
19095 install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_cmd);
19096 install_element(BGP_NODE, &bgp_maxpaths_ibgp_hidden_cmd);
19097 install_element(BGP_NODE, &bgp_maxpaths_ibgp_cluster_hidden_cmd);
19098 install_element(BGP_NODE, &no_bgp_maxpaths_ibgp_hidden_cmd);
19099 install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cmd);
19100 install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
19101 install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_ibgp_cmd);
19102 install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cmd);
19103 install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
19104 install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_ibgp_cmd);
19105
19106 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_cmd);
19107 install_element(BGP_IPV4L_NODE, &no_bgp_maxpaths_cmd);
19108 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_ibgp_cmd);
19109 install_element(BGP_IPV4L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
19110 install_element(BGP_IPV4L_NODE, &no_bgp_maxpaths_ibgp_cmd);
19111 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_cmd);
19112 install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_cmd);
19113 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cmd);
19114 install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
19115 install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_ibgp_cmd);
19116
19117 /* "timers bgp" commands. */
19118 install_element(BGP_NODE, &bgp_timers_cmd);
19119 install_element(BGP_NODE, &no_bgp_timers_cmd);
19120
19121 /* "minimum-holdtime" commands. */
19122 install_element(BGP_NODE, &bgp_minimum_holdtime_cmd);
19123 install_element(BGP_NODE, &no_bgp_minimum_holdtime_cmd);
19124
19125 /* route-map delay-timer commands - per instance for backwards compat.
19126 */
19127 install_element(BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
19128 install_element(BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
19129
19130 /* "bgp client-to-client reflection" commands */
19131 install_element(BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
19132 install_element(BGP_NODE, &bgp_client_to_client_reflection_cmd);
19133
19134 /* "bgp always-compare-med" commands */
19135 install_element(BGP_NODE, &bgp_always_compare_med_cmd);
19136 install_element(BGP_NODE, &no_bgp_always_compare_med_cmd);
19137
19138 /* bgp ebgp-requires-policy */
19139 install_element(BGP_NODE, &bgp_ebgp_requires_policy_cmd);
19140 install_element(BGP_NODE, &no_bgp_ebgp_requires_policy_cmd);
19141
19142 /* bgp suppress-duplicates */
19143 install_element(BGP_NODE, &bgp_suppress_duplicates_cmd);
19144 install_element(BGP_NODE, &no_bgp_suppress_duplicates_cmd);
19145
19146 /* bgp reject-as-sets */
19147 install_element(BGP_NODE, &bgp_reject_as_sets_cmd);
19148 install_element(BGP_NODE, &no_bgp_reject_as_sets_cmd);
19149
19150 /* "bgp deterministic-med" commands */
19151 install_element(BGP_NODE, &bgp_deterministic_med_cmd);
19152 install_element(BGP_NODE, &no_bgp_deterministic_med_cmd);
19153
19154 /* "bgp graceful-restart" command */
19155 install_element(BGP_NODE, &bgp_graceful_restart_cmd);
19156 install_element(BGP_NODE, &no_bgp_graceful_restart_cmd);
19157
19158 /* "bgp graceful-restart-disable" command */
19159 install_element(BGP_NODE, &bgp_graceful_restart_disable_cmd);
19160 install_element(BGP_NODE, &no_bgp_graceful_restart_disable_cmd);
19161
19162 /* "neighbor a:b:c:d graceful-restart" command */
19163 install_element(BGP_NODE, &bgp_neighbor_graceful_restart_set_cmd);
19164 install_element(BGP_NODE, &no_bgp_neighbor_graceful_restart_set_cmd);
19165
19166 /* "neighbor a:b:c:d graceful-restart-disable" command */
19167 install_element(BGP_NODE,
19168 &bgp_neighbor_graceful_restart_disable_set_cmd);
19169 install_element(BGP_NODE,
19170 &no_bgp_neighbor_graceful_restart_disable_set_cmd);
19171
19172 /* "neighbor a:b:c:d graceful-restart-helper" command */
19173 install_element(BGP_NODE,
19174 &bgp_neighbor_graceful_restart_helper_set_cmd);
19175 install_element(BGP_NODE,
19176 &no_bgp_neighbor_graceful_restart_helper_set_cmd);
19177
19178 install_element(BGP_NODE, &bgp_graceful_restart_stalepath_time_cmd);
19179 install_element(BGP_NODE, &no_bgp_graceful_restart_stalepath_time_cmd);
19180 install_element(BGP_NODE, &bgp_graceful_restart_restart_time_cmd);
19181 install_element(BGP_NODE, &no_bgp_graceful_restart_restart_time_cmd);
19182 install_element(BGP_NODE, &bgp_graceful_restart_select_defer_time_cmd);
19183 install_element(BGP_NODE,
19184 &no_bgp_graceful_restart_select_defer_time_cmd);
19185 install_element(BGP_NODE, &bgp_graceful_restart_preserve_fw_cmd);
19186 install_element(BGP_NODE, &no_bgp_graceful_restart_preserve_fw_cmd);
19187 install_element(BGP_NODE, &bgp_graceful_restart_notification_cmd);
19188
19189 install_element(BGP_NODE, &bgp_graceful_restart_disable_eor_cmd);
19190 install_element(BGP_NODE, &no_bgp_graceful_restart_disable_eor_cmd);
19191 install_element(BGP_NODE, &bgp_graceful_restart_rib_stale_time_cmd);
19192 install_element(BGP_NODE, &no_bgp_graceful_restart_rib_stale_time_cmd);
19193
19194 /* "bgp graceful-shutdown" commands */
19195 install_element(BGP_NODE, &bgp_graceful_shutdown_cmd);
19196 install_element(BGP_NODE, &no_bgp_graceful_shutdown_cmd);
19197
19198 /* "bgp hard-administrative-reset" commands */
19199 install_element(BGP_NODE, &bgp_administrative_reset_cmd);
19200
19201 /* "bgp long-lived-graceful-restart" commands */
19202 install_element(BGP_NODE, &bgp_llgr_stalepath_time_cmd);
19203 install_element(BGP_NODE, &no_bgp_llgr_stalepath_time_cmd);
19204
19205 /* "bgp fast-external-failover" commands */
19206 install_element(BGP_NODE, &bgp_fast_external_failover_cmd);
19207 install_element(BGP_NODE, &no_bgp_fast_external_failover_cmd);
19208
19209 /* "bgp bestpath aigp" commands */
19210 install_element(BGP_NODE, &bgp_bestpath_aigp_cmd);
19211
19212 /* "bgp bestpath compare-routerid" commands */
19213 install_element(BGP_NODE, &bgp_bestpath_compare_router_id_cmd);
19214 install_element(BGP_NODE, &no_bgp_bestpath_compare_router_id_cmd);
19215
19216 /* "bgp bestpath as-path ignore" commands */
19217 install_element(BGP_NODE, &bgp_bestpath_aspath_ignore_cmd);
19218 install_element(BGP_NODE, &no_bgp_bestpath_aspath_ignore_cmd);
19219
19220 /* "bgp bestpath as-path confed" commands */
19221 install_element(BGP_NODE, &bgp_bestpath_aspath_confed_cmd);
19222 install_element(BGP_NODE, &no_bgp_bestpath_aspath_confed_cmd);
19223
19224 /* "bgp bestpath as-path multipath-relax" commands */
19225 install_element(BGP_NODE, &bgp_bestpath_aspath_multipath_relax_cmd);
19226 install_element(BGP_NODE, &no_bgp_bestpath_aspath_multipath_relax_cmd);
19227
19228 /* "bgp bestpath peer-type multipath-relax" commands */
19229 install_element(BGP_NODE, &bgp_bestpath_peer_type_multipath_relax_cmd);
19230 install_element(BGP_NODE,
19231 &no_bgp_bestpath_peer_type_multipath_relax_cmd);
19232
19233 /* "bgp log-neighbor-changes" commands */
19234 install_element(BGP_NODE, &bgp_log_neighbor_changes_cmd);
19235 install_element(BGP_NODE, &no_bgp_log_neighbor_changes_cmd);
19236
19237 /* "bgp bestpath med" commands */
19238 install_element(BGP_NODE, &bgp_bestpath_med_cmd);
19239 install_element(BGP_NODE, &no_bgp_bestpath_med_cmd);
19240
19241 /* "bgp bestpath bandwidth" commands */
19242 install_element(BGP_NODE, &bgp_bestpath_bw_cmd);
19243 install_element(BGP_NODE, &no_bgp_bestpath_bw_cmd);
19244
19245 /* "no bgp default <afi>-<safi>" commands. */
19246 install_element(BGP_NODE, &bgp_default_afi_safi_cmd);
19247
19248 /* "bgp network import-check" commands. */
19249 install_element(BGP_NODE, &bgp_network_import_check_cmd);
19250 install_element(BGP_NODE, &bgp_network_import_check_exact_cmd);
19251 install_element(BGP_NODE, &no_bgp_network_import_check_cmd);
19252
19253 /* "bgp default local-preference" commands. */
19254 install_element(BGP_NODE, &bgp_default_local_preference_cmd);
19255 install_element(BGP_NODE, &no_bgp_default_local_preference_cmd);
19256
19257 /* bgp default show-hostname */
19258 install_element(BGP_NODE, &bgp_default_show_hostname_cmd);
19259 install_element(BGP_NODE, &no_bgp_default_show_hostname_cmd);
19260
19261 /* bgp default show-nexthop-hostname */
19262 install_element(BGP_NODE, &bgp_default_show_nexthop_hostname_cmd);
19263 install_element(BGP_NODE, &no_bgp_default_show_nexthop_hostname_cmd);
19264
19265 /* "bgp default subgroup-pkt-queue-max" commands. */
19266 install_element(BGP_NODE, &bgp_default_subgroup_pkt_queue_max_cmd);
19267 install_element(BGP_NODE, &no_bgp_default_subgroup_pkt_queue_max_cmd);
19268
19269 /* bgp ibgp-allow-policy-mods command */
19270 install_element(BGP_NODE, &bgp_rr_allow_outbound_policy_cmd);
19271 install_element(BGP_NODE, &no_bgp_rr_allow_outbound_policy_cmd);
19272
19273 /* "bgp listen limit" commands. */
19274 install_element(BGP_NODE, &bgp_listen_limit_cmd);
19275 install_element(BGP_NODE, &no_bgp_listen_limit_cmd);
19276
19277 /* "bgp listen range" commands. */
19278 install_element(BGP_NODE, &bgp_listen_range_cmd);
19279 install_element(BGP_NODE, &no_bgp_listen_range_cmd);
19280
19281 /* "bgp default shutdown" command */
19282 install_element(BGP_NODE, &bgp_default_shutdown_cmd);
19283
19284 /* "bgp shutdown" commands */
19285 install_element(BGP_NODE, &bgp_shutdown_cmd);
19286 install_element(BGP_NODE, &bgp_shutdown_msg_cmd);
19287 install_element(BGP_NODE, &no_bgp_shutdown_cmd);
19288 install_element(BGP_NODE, &no_bgp_shutdown_msg_cmd);
19289
19290 /* "neighbor remote-as" commands. */
19291 install_element(BGP_NODE, &neighbor_remote_as_cmd);
19292 install_element(BGP_NODE, &neighbor_interface_config_cmd);
19293 install_element(BGP_NODE, &neighbor_interface_config_v6only_cmd);
19294 install_element(BGP_NODE, &neighbor_interface_config_remote_as_cmd);
19295 install_element(BGP_NODE,
19296 &neighbor_interface_v6only_config_remote_as_cmd);
19297 install_element(BGP_NODE, &no_neighbor_cmd);
19298 install_element(BGP_NODE, &no_neighbor_interface_config_cmd);
19299
19300 /* "neighbor peer-group" commands. */
19301 install_element(BGP_NODE, &neighbor_peer_group_cmd);
19302 install_element(BGP_NODE, &no_neighbor_peer_group_cmd);
19303 install_element(BGP_NODE,
19304 &no_neighbor_interface_peer_group_remote_as_cmd);
19305
19306 /* "neighbor local-as" commands. */
19307 install_element(BGP_NODE, &neighbor_local_as_cmd);
19308 install_element(BGP_NODE, &neighbor_local_as_no_prepend_cmd);
19309 install_element(BGP_NODE, &neighbor_local_as_no_prepend_replace_as_cmd);
19310 install_element(BGP_NODE, &no_neighbor_local_as_cmd);
19311
19312 /* "neighbor solo" commands. */
19313 install_element(BGP_NODE, &neighbor_solo_cmd);
19314 install_element(BGP_NODE, &no_neighbor_solo_cmd);
19315
19316 /* "neighbor password" commands. */
19317 install_element(BGP_NODE, &neighbor_password_cmd);
19318 install_element(BGP_NODE, &no_neighbor_password_cmd);
19319
19320 /* "neighbor activate" commands. */
19321 install_element(BGP_NODE, &neighbor_activate_hidden_cmd);
19322 install_element(BGP_IPV4_NODE, &neighbor_activate_cmd);
19323 install_element(BGP_IPV4M_NODE, &neighbor_activate_cmd);
19324 install_element(BGP_IPV4L_NODE, &neighbor_activate_cmd);
19325 install_element(BGP_IPV6_NODE, &neighbor_activate_cmd);
19326 install_element(BGP_IPV6M_NODE, &neighbor_activate_cmd);
19327 install_element(BGP_IPV6L_NODE, &neighbor_activate_cmd);
19328 install_element(BGP_VPNV4_NODE, &neighbor_activate_cmd);
19329 install_element(BGP_VPNV6_NODE, &neighbor_activate_cmd);
19330 install_element(BGP_FLOWSPECV4_NODE, &neighbor_activate_cmd);
19331 install_element(BGP_FLOWSPECV6_NODE, &neighbor_activate_cmd);
19332 install_element(BGP_EVPN_NODE, &neighbor_activate_cmd);
19333
19334 /* "no neighbor activate" commands. */
19335 install_element(BGP_NODE, &no_neighbor_activate_hidden_cmd);
19336 install_element(BGP_IPV4_NODE, &no_neighbor_activate_cmd);
19337 install_element(BGP_IPV4M_NODE, &no_neighbor_activate_cmd);
19338 install_element(BGP_IPV4L_NODE, &no_neighbor_activate_cmd);
19339 install_element(BGP_IPV6_NODE, &no_neighbor_activate_cmd);
19340 install_element(BGP_IPV6M_NODE, &no_neighbor_activate_cmd);
19341 install_element(BGP_IPV6L_NODE, &no_neighbor_activate_cmd);
19342 install_element(BGP_VPNV4_NODE, &no_neighbor_activate_cmd);
19343 install_element(BGP_VPNV6_NODE, &no_neighbor_activate_cmd);
19344 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_activate_cmd);
19345 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_activate_cmd);
19346 install_element(BGP_EVPN_NODE, &no_neighbor_activate_cmd);
19347
19348 /* "neighbor peer-group" set commands. */
19349 install_element(BGP_NODE, &neighbor_set_peer_group_cmd);
19350 install_element(BGP_IPV4_NODE, &neighbor_set_peer_group_hidden_cmd);
19351 install_element(BGP_IPV4M_NODE, &neighbor_set_peer_group_hidden_cmd);
19352 install_element(BGP_IPV6_NODE, &neighbor_set_peer_group_hidden_cmd);
19353 install_element(BGP_IPV6M_NODE, &neighbor_set_peer_group_hidden_cmd);
19354 install_element(BGP_IPV6L_NODE, &neighbor_set_peer_group_hidden_cmd);
19355 install_element(BGP_VPNV4_NODE, &neighbor_set_peer_group_hidden_cmd);
19356 install_element(BGP_VPNV6_NODE, &neighbor_set_peer_group_hidden_cmd);
19357 install_element(BGP_FLOWSPECV4_NODE,
19358 &neighbor_set_peer_group_hidden_cmd);
19359 install_element(BGP_FLOWSPECV6_NODE,
19360 &neighbor_set_peer_group_hidden_cmd);
19361
19362 /* "no neighbor peer-group unset" commands. */
19363 install_element(BGP_NODE, &no_neighbor_set_peer_group_cmd);
19364 install_element(BGP_IPV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19365 install_element(BGP_IPV4M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19366 install_element(BGP_IPV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19367 install_element(BGP_IPV6M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19368 install_element(BGP_IPV6L_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19369 install_element(BGP_VPNV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19370 install_element(BGP_VPNV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
19371 install_element(BGP_FLOWSPECV4_NODE,
19372 &no_neighbor_set_peer_group_hidden_cmd);
19373 install_element(BGP_FLOWSPECV6_NODE,
19374 &no_neighbor_set_peer_group_hidden_cmd);
19375
19376 /* "neighbor softreconfiguration inbound" commands.*/
19377 install_element(BGP_NODE, &neighbor_soft_reconfiguration_hidden_cmd);
19378 install_element(BGP_NODE, &no_neighbor_soft_reconfiguration_hidden_cmd);
19379 install_element(BGP_IPV4_NODE, &neighbor_soft_reconfiguration_cmd);
19380 install_element(BGP_IPV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
19381 install_element(BGP_IPV4L_NODE, &neighbor_soft_reconfiguration_cmd);
19382 install_element(BGP_IPV4L_NODE, &no_neighbor_soft_reconfiguration_cmd);
19383 install_element(BGP_IPV4M_NODE, &neighbor_soft_reconfiguration_cmd);
19384 install_element(BGP_IPV4M_NODE, &no_neighbor_soft_reconfiguration_cmd);
19385 install_element(BGP_IPV6_NODE, &neighbor_soft_reconfiguration_cmd);
19386 install_element(BGP_IPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
19387 install_element(BGP_IPV6M_NODE, &neighbor_soft_reconfiguration_cmd);
19388 install_element(BGP_IPV6M_NODE, &no_neighbor_soft_reconfiguration_cmd);
19389 install_element(BGP_IPV6L_NODE, &neighbor_soft_reconfiguration_cmd);
19390 install_element(BGP_IPV6L_NODE, &no_neighbor_soft_reconfiguration_cmd);
19391 install_element(BGP_VPNV4_NODE, &neighbor_soft_reconfiguration_cmd);
19392 install_element(BGP_VPNV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
19393 install_element(BGP_VPNV6_NODE, &neighbor_soft_reconfiguration_cmd);
19394 install_element(BGP_VPNV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
19395 install_element(BGP_FLOWSPECV4_NODE,
19396 &neighbor_soft_reconfiguration_cmd);
19397 install_element(BGP_FLOWSPECV4_NODE,
19398 &no_neighbor_soft_reconfiguration_cmd);
19399 install_element(BGP_FLOWSPECV6_NODE,
19400 &neighbor_soft_reconfiguration_cmd);
19401 install_element(BGP_FLOWSPECV6_NODE,
19402 &no_neighbor_soft_reconfiguration_cmd);
19403 install_element(BGP_EVPN_NODE, &neighbor_soft_reconfiguration_cmd);
19404 install_element(BGP_EVPN_NODE, &no_neighbor_soft_reconfiguration_cmd);
19405
19406 /* "neighbor attribute-unchanged" commands. */
19407 install_element(BGP_NODE, &neighbor_attr_unchanged_hidden_cmd);
19408 install_element(BGP_NODE, &no_neighbor_attr_unchanged_hidden_cmd);
19409 install_element(BGP_IPV4_NODE, &neighbor_attr_unchanged_cmd);
19410 install_element(BGP_IPV4_NODE, &no_neighbor_attr_unchanged_cmd);
19411 install_element(BGP_IPV4M_NODE, &neighbor_attr_unchanged_cmd);
19412 install_element(BGP_IPV4M_NODE, &no_neighbor_attr_unchanged_cmd);
19413 install_element(BGP_IPV4L_NODE, &neighbor_attr_unchanged_cmd);
19414 install_element(BGP_IPV4L_NODE, &no_neighbor_attr_unchanged_cmd);
19415 install_element(BGP_IPV6_NODE, &neighbor_attr_unchanged_cmd);
19416 install_element(BGP_IPV6_NODE, &no_neighbor_attr_unchanged_cmd);
19417 install_element(BGP_IPV6M_NODE, &neighbor_attr_unchanged_cmd);
19418 install_element(BGP_IPV6M_NODE, &no_neighbor_attr_unchanged_cmd);
19419 install_element(BGP_IPV6L_NODE, &neighbor_attr_unchanged_cmd);
19420 install_element(BGP_IPV6L_NODE, &no_neighbor_attr_unchanged_cmd);
19421 install_element(BGP_VPNV4_NODE, &neighbor_attr_unchanged_cmd);
19422 install_element(BGP_VPNV4_NODE, &no_neighbor_attr_unchanged_cmd);
19423 install_element(BGP_VPNV6_NODE, &neighbor_attr_unchanged_cmd);
19424 install_element(BGP_VPNV6_NODE, &no_neighbor_attr_unchanged_cmd);
19425
19426 install_element(BGP_EVPN_NODE, &neighbor_attr_unchanged_cmd);
19427 install_element(BGP_EVPN_NODE, &no_neighbor_attr_unchanged_cmd);
19428
19429 install_element(BGP_FLOWSPECV4_NODE, &neighbor_attr_unchanged_cmd);
19430 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_attr_unchanged_cmd);
19431 install_element(BGP_FLOWSPECV6_NODE, &neighbor_attr_unchanged_cmd);
19432 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_attr_unchanged_cmd);
19433
19434 /* "nexthop-local unchanged" commands */
19435 install_element(BGP_IPV6_NODE, &neighbor_nexthop_local_unchanged_cmd);
19436 install_element(BGP_IPV6_NODE,
19437 &no_neighbor_nexthop_local_unchanged_cmd);
19438
19439 /* "neighbor next-hop-self" commands. */
19440 install_element(BGP_NODE, &neighbor_nexthop_self_hidden_cmd);
19441 install_element(BGP_NODE, &no_neighbor_nexthop_self_hidden_cmd);
19442 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_cmd);
19443 install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_cmd);
19444 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_cmd);
19445 install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_cmd);
19446 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_cmd);
19447 install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_cmd);
19448 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_cmd);
19449 install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_cmd);
19450 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_cmd);
19451 install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_cmd);
19452 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_cmd);
19453 install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_cmd);
19454 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_cmd);
19455 install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_cmd);
19456 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_cmd);
19457 install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_cmd);
19458 install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_cmd);
19459 install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_cmd);
19460
19461 /* "neighbor next-hop-self force" commands. */
19462 install_element(BGP_NODE, &neighbor_nexthop_self_force_hidden_cmd);
19463 install_element(BGP_NODE, &no_neighbor_nexthop_self_force_hidden_cmd);
19464 install_element(BGP_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19465 install_element(BGP_NODE, &no_neighbor_nexthop_self_all_hidden_cmd);
19466 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_force_cmd);
19467 install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_force_cmd);
19468 install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19469 install_element(BGP_IPV4_NODE,
19470 &no_neighbor_nexthop_self_all_hidden_cmd);
19471 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_force_cmd);
19472 install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_force_cmd);
19473 install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19474 install_element(BGP_IPV4M_NODE,
19475 &no_neighbor_nexthop_self_all_hidden_cmd);
19476 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_force_cmd);
19477 install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_force_cmd);
19478 install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19479 install_element(BGP_IPV4L_NODE,
19480 &no_neighbor_nexthop_self_all_hidden_cmd);
19481 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_force_cmd);
19482 install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_force_cmd);
19483 install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19484 install_element(BGP_IPV6_NODE,
19485 &no_neighbor_nexthop_self_all_hidden_cmd);
19486 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_force_cmd);
19487 install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_force_cmd);
19488 install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19489 install_element(BGP_IPV6M_NODE,
19490 &no_neighbor_nexthop_self_all_hidden_cmd);
19491 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_force_cmd);
19492 install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_force_cmd);
19493 install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19494 install_element(BGP_IPV6L_NODE,
19495 &no_neighbor_nexthop_self_all_hidden_cmd);
19496 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_force_cmd);
19497 install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_force_cmd);
19498 install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19499 install_element(BGP_VPNV4_NODE,
19500 &no_neighbor_nexthop_self_all_hidden_cmd);
19501 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_force_cmd);
19502 install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_force_cmd);
19503 install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
19504 install_element(BGP_VPNV6_NODE,
19505 &no_neighbor_nexthop_self_all_hidden_cmd);
19506 install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_force_cmd);
19507 install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_force_cmd);
19508
19509 /* "neighbor as-override" commands. */
19510 install_element(BGP_NODE, &neighbor_as_override_hidden_cmd);
19511 install_element(BGP_NODE, &no_neighbor_as_override_hidden_cmd);
19512 install_element(BGP_IPV4_NODE, &neighbor_as_override_cmd);
19513 install_element(BGP_IPV4_NODE, &no_neighbor_as_override_cmd);
19514 install_element(BGP_IPV4M_NODE, &neighbor_as_override_cmd);
19515 install_element(BGP_IPV4M_NODE, &no_neighbor_as_override_cmd);
19516 install_element(BGP_IPV4L_NODE, &neighbor_as_override_cmd);
19517 install_element(BGP_IPV4L_NODE, &no_neighbor_as_override_cmd);
19518 install_element(BGP_IPV6_NODE, &neighbor_as_override_cmd);
19519 install_element(BGP_IPV6_NODE, &no_neighbor_as_override_cmd);
19520 install_element(BGP_IPV6M_NODE, &neighbor_as_override_cmd);
19521 install_element(BGP_IPV6M_NODE, &no_neighbor_as_override_cmd);
19522 install_element(BGP_IPV6L_NODE, &neighbor_as_override_cmd);
19523 install_element(BGP_IPV6L_NODE, &no_neighbor_as_override_cmd);
19524 install_element(BGP_VPNV4_NODE, &neighbor_as_override_cmd);
19525 install_element(BGP_VPNV4_NODE, &no_neighbor_as_override_cmd);
19526 install_element(BGP_VPNV6_NODE, &neighbor_as_override_cmd);
19527 install_element(BGP_VPNV6_NODE, &no_neighbor_as_override_cmd);
19528
19529 /* "neighbor remove-private-AS" commands. */
19530 install_element(BGP_NODE, &neighbor_remove_private_as_hidden_cmd);
19531 install_element(BGP_NODE, &no_neighbor_remove_private_as_hidden_cmd);
19532 install_element(BGP_NODE, &neighbor_remove_private_as_all_hidden_cmd);
19533 install_element(BGP_NODE,
19534 &no_neighbor_remove_private_as_all_hidden_cmd);
19535 install_element(BGP_NODE,
19536 &neighbor_remove_private_as_replace_as_hidden_cmd);
19537 install_element(BGP_NODE,
19538 &no_neighbor_remove_private_as_replace_as_hidden_cmd);
19539 install_element(BGP_NODE,
19540 &neighbor_remove_private_as_all_replace_as_hidden_cmd);
19541 install_element(
19542 BGP_NODE,
19543 &no_neighbor_remove_private_as_all_replace_as_hidden_cmd);
19544 install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_cmd);
19545 install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_cmd);
19546 install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_all_cmd);
19547 install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_cmd);
19548 install_element(BGP_IPV4_NODE,
19549 &neighbor_remove_private_as_replace_as_cmd);
19550 install_element(BGP_IPV4_NODE,
19551 &no_neighbor_remove_private_as_replace_as_cmd);
19552 install_element(BGP_IPV4_NODE,
19553 &neighbor_remove_private_as_all_replace_as_cmd);
19554 install_element(BGP_IPV4_NODE,
19555 &no_neighbor_remove_private_as_all_replace_as_cmd);
19556 install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_cmd);
19557 install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_cmd);
19558 install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_all_cmd);
19559 install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_cmd);
19560 install_element(BGP_IPV4M_NODE,
19561 &neighbor_remove_private_as_replace_as_cmd);
19562 install_element(BGP_IPV4M_NODE,
19563 &no_neighbor_remove_private_as_replace_as_cmd);
19564 install_element(BGP_IPV4M_NODE,
19565 &neighbor_remove_private_as_all_replace_as_cmd);
19566 install_element(BGP_IPV4M_NODE,
19567 &no_neighbor_remove_private_as_all_replace_as_cmd);
19568 install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_cmd);
19569 install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_cmd);
19570 install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_all_cmd);
19571 install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_all_cmd);
19572 install_element(BGP_IPV4L_NODE,
19573 &neighbor_remove_private_as_replace_as_cmd);
19574 install_element(BGP_IPV4L_NODE,
19575 &no_neighbor_remove_private_as_replace_as_cmd);
19576 install_element(BGP_IPV4L_NODE,
19577 &neighbor_remove_private_as_all_replace_as_cmd);
19578 install_element(BGP_IPV4L_NODE,
19579 &no_neighbor_remove_private_as_all_replace_as_cmd);
19580 install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_cmd);
19581 install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_cmd);
19582 install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_all_cmd);
19583 install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_cmd);
19584 install_element(BGP_IPV6_NODE,
19585 &neighbor_remove_private_as_replace_as_cmd);
19586 install_element(BGP_IPV6_NODE,
19587 &no_neighbor_remove_private_as_replace_as_cmd);
19588 install_element(BGP_IPV6_NODE,
19589 &neighbor_remove_private_as_all_replace_as_cmd);
19590 install_element(BGP_IPV6_NODE,
19591 &no_neighbor_remove_private_as_all_replace_as_cmd);
19592 install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_cmd);
19593 install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_cmd);
19594 install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_all_cmd);
19595 install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_cmd);
19596 install_element(BGP_IPV6M_NODE,
19597 &neighbor_remove_private_as_replace_as_cmd);
19598 install_element(BGP_IPV6M_NODE,
19599 &no_neighbor_remove_private_as_replace_as_cmd);
19600 install_element(BGP_IPV6M_NODE,
19601 &neighbor_remove_private_as_all_replace_as_cmd);
19602 install_element(BGP_IPV6M_NODE,
19603 &no_neighbor_remove_private_as_all_replace_as_cmd);
19604 install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_cmd);
19605 install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_cmd);
19606 install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_all_cmd);
19607 install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_all_cmd);
19608 install_element(BGP_IPV6L_NODE,
19609 &neighbor_remove_private_as_replace_as_cmd);
19610 install_element(BGP_IPV6L_NODE,
19611 &no_neighbor_remove_private_as_replace_as_cmd);
19612 install_element(BGP_IPV6L_NODE,
19613 &neighbor_remove_private_as_all_replace_as_cmd);
19614 install_element(BGP_IPV6L_NODE,
19615 &no_neighbor_remove_private_as_all_replace_as_cmd);
19616 install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_cmd);
19617 install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_cmd);
19618 install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_all_cmd);
19619 install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_cmd);
19620 install_element(BGP_VPNV4_NODE,
19621 &neighbor_remove_private_as_replace_as_cmd);
19622 install_element(BGP_VPNV4_NODE,
19623 &no_neighbor_remove_private_as_replace_as_cmd);
19624 install_element(BGP_VPNV4_NODE,
19625 &neighbor_remove_private_as_all_replace_as_cmd);
19626 install_element(BGP_VPNV4_NODE,
19627 &no_neighbor_remove_private_as_all_replace_as_cmd);
19628 install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_cmd);
19629 install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_cmd);
19630 install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_all_cmd);
19631 install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_cmd);
19632 install_element(BGP_VPNV6_NODE,
19633 &neighbor_remove_private_as_replace_as_cmd);
19634 install_element(BGP_VPNV6_NODE,
19635 &no_neighbor_remove_private_as_replace_as_cmd);
19636 install_element(BGP_VPNV6_NODE,
19637 &neighbor_remove_private_as_all_replace_as_cmd);
19638 install_element(BGP_VPNV6_NODE,
19639 &no_neighbor_remove_private_as_all_replace_as_cmd);
19640
19641 /* "neighbor send-community" commands.*/
19642 install_element(BGP_NODE, &neighbor_send_community_hidden_cmd);
19643 install_element(BGP_NODE, &neighbor_send_community_type_hidden_cmd);
19644 install_element(BGP_NODE, &no_neighbor_send_community_hidden_cmd);
19645 install_element(BGP_NODE, &no_neighbor_send_community_type_hidden_cmd);
19646 install_element(BGP_IPV4_NODE, &neighbor_send_community_cmd);
19647 install_element(BGP_IPV4_NODE, &neighbor_send_community_type_cmd);
19648 install_element(BGP_IPV4_NODE, &no_neighbor_send_community_cmd);
19649 install_element(BGP_IPV4_NODE, &no_neighbor_send_community_type_cmd);
19650 install_element(BGP_IPV4M_NODE, &neighbor_send_community_cmd);
19651 install_element(BGP_IPV4M_NODE, &neighbor_send_community_type_cmd);
19652 install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_cmd);
19653 install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_type_cmd);
19654 install_element(BGP_IPV4L_NODE, &neighbor_send_community_cmd);
19655 install_element(BGP_IPV4L_NODE, &neighbor_send_community_type_cmd);
19656 install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_cmd);
19657 install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_type_cmd);
19658 install_element(BGP_IPV6_NODE, &neighbor_send_community_cmd);
19659 install_element(BGP_IPV6_NODE, &neighbor_send_community_type_cmd);
19660 install_element(BGP_IPV6_NODE, &no_neighbor_send_community_cmd);
19661 install_element(BGP_IPV6_NODE, &no_neighbor_send_community_type_cmd);
19662 install_element(BGP_IPV6M_NODE, &neighbor_send_community_cmd);
19663 install_element(BGP_IPV6M_NODE, &neighbor_send_community_type_cmd);
19664 install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_cmd);
19665 install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_type_cmd);
19666 install_element(BGP_IPV6L_NODE, &neighbor_send_community_cmd);
19667 install_element(BGP_IPV6L_NODE, &neighbor_send_community_type_cmd);
19668 install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_cmd);
19669 install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_type_cmd);
19670 install_element(BGP_VPNV4_NODE, &neighbor_send_community_cmd);
19671 install_element(BGP_VPNV4_NODE, &neighbor_send_community_type_cmd);
19672 install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_cmd);
19673 install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_type_cmd);
19674 install_element(BGP_VPNV6_NODE, &neighbor_send_community_cmd);
19675 install_element(BGP_VPNV6_NODE, &neighbor_send_community_type_cmd);
19676 install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_cmd);
19677 install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_type_cmd);
19678
19679 /* "neighbor route-reflector" commands.*/
19680 install_element(BGP_NODE, &neighbor_route_reflector_client_hidden_cmd);
19681 install_element(BGP_NODE,
19682 &no_neighbor_route_reflector_client_hidden_cmd);
19683 install_element(BGP_IPV4_NODE, &neighbor_route_reflector_client_cmd);
19684 install_element(BGP_IPV4_NODE, &no_neighbor_route_reflector_client_cmd);
19685 install_element(BGP_IPV4M_NODE, &neighbor_route_reflector_client_cmd);
19686 install_element(BGP_IPV4M_NODE,
19687 &no_neighbor_route_reflector_client_cmd);
19688 install_element(BGP_IPV4L_NODE, &neighbor_route_reflector_client_cmd);
19689 install_element(BGP_IPV4L_NODE,
19690 &no_neighbor_route_reflector_client_cmd);
19691 install_element(BGP_IPV6_NODE, &neighbor_route_reflector_client_cmd);
19692 install_element(BGP_IPV6_NODE, &no_neighbor_route_reflector_client_cmd);
19693 install_element(BGP_IPV6M_NODE, &neighbor_route_reflector_client_cmd);
19694 install_element(BGP_IPV6M_NODE,
19695 &no_neighbor_route_reflector_client_cmd);
19696 install_element(BGP_IPV6L_NODE, &neighbor_route_reflector_client_cmd);
19697 install_element(BGP_IPV6L_NODE,
19698 &no_neighbor_route_reflector_client_cmd);
19699 install_element(BGP_VPNV4_NODE, &neighbor_route_reflector_client_cmd);
19700 install_element(BGP_VPNV4_NODE,
19701 &no_neighbor_route_reflector_client_cmd);
19702 install_element(BGP_VPNV6_NODE, &neighbor_route_reflector_client_cmd);
19703 install_element(BGP_VPNV6_NODE,
19704 &no_neighbor_route_reflector_client_cmd);
19705 install_element(BGP_FLOWSPECV4_NODE,
19706 &neighbor_route_reflector_client_cmd);
19707 install_element(BGP_FLOWSPECV4_NODE,
19708 &no_neighbor_route_reflector_client_cmd);
19709 install_element(BGP_FLOWSPECV6_NODE,
19710 &neighbor_route_reflector_client_cmd);
19711 install_element(BGP_FLOWSPECV6_NODE,
19712 &no_neighbor_route_reflector_client_cmd);
19713 install_element(BGP_EVPN_NODE, &neighbor_route_reflector_client_cmd);
19714 install_element(BGP_EVPN_NODE, &no_neighbor_route_reflector_client_cmd);
19715
19716 /* "neighbor route-server" commands.*/
19717 install_element(BGP_NODE, &neighbor_route_server_client_hidden_cmd);
19718 install_element(BGP_NODE, &no_neighbor_route_server_client_hidden_cmd);
19719 install_element(BGP_IPV4_NODE, &neighbor_route_server_client_cmd);
19720 install_element(BGP_IPV4_NODE, &no_neighbor_route_server_client_cmd);
19721 install_element(BGP_IPV4M_NODE, &neighbor_route_server_client_cmd);
19722 install_element(BGP_IPV4M_NODE, &no_neighbor_route_server_client_cmd);
19723 install_element(BGP_IPV4L_NODE, &neighbor_route_server_client_cmd);
19724 install_element(BGP_IPV4L_NODE, &no_neighbor_route_server_client_cmd);
19725 install_element(BGP_IPV6_NODE, &neighbor_route_server_client_cmd);
19726 install_element(BGP_IPV6_NODE, &no_neighbor_route_server_client_cmd);
19727 install_element(BGP_IPV6M_NODE, &neighbor_route_server_client_cmd);
19728 install_element(BGP_IPV6M_NODE, &no_neighbor_route_server_client_cmd);
19729 install_element(BGP_IPV6L_NODE, &neighbor_route_server_client_cmd);
19730 install_element(BGP_IPV6L_NODE, &no_neighbor_route_server_client_cmd);
19731 install_element(BGP_VPNV4_NODE, &neighbor_route_server_client_cmd);
19732 install_element(BGP_VPNV4_NODE, &no_neighbor_route_server_client_cmd);
19733 install_element(BGP_VPNV6_NODE, &neighbor_route_server_client_cmd);
19734 install_element(BGP_VPNV6_NODE, &no_neighbor_route_server_client_cmd);
19735 install_element(BGP_EVPN_NODE, &neighbor_route_server_client_cmd);
19736 install_element(BGP_EVPN_NODE, &no_neighbor_route_server_client_cmd);
19737 install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_server_client_cmd);
19738 install_element(BGP_FLOWSPECV4_NODE,
19739 &no_neighbor_route_server_client_cmd);
19740 install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_server_client_cmd);
19741 install_element(BGP_FLOWSPECV6_NODE,
19742 &no_neighbor_route_server_client_cmd);
19743
19744 /* "neighbor disable-addpath-rx" commands. */
19745 install_element(BGP_IPV4_NODE, &neighbor_disable_addpath_rx_cmd);
19746 install_element(BGP_IPV4_NODE, &no_neighbor_disable_addpath_rx_cmd);
19747 install_element(BGP_IPV4M_NODE, &neighbor_disable_addpath_rx_cmd);
19748 install_element(BGP_IPV4M_NODE, &no_neighbor_disable_addpath_rx_cmd);
19749 install_element(BGP_IPV4L_NODE, &neighbor_disable_addpath_rx_cmd);
19750 install_element(BGP_IPV4L_NODE, &no_neighbor_disable_addpath_rx_cmd);
19751 install_element(BGP_IPV6_NODE, &neighbor_disable_addpath_rx_cmd);
19752 install_element(BGP_IPV6_NODE, &no_neighbor_disable_addpath_rx_cmd);
19753 install_element(BGP_IPV6M_NODE, &neighbor_disable_addpath_rx_cmd);
19754 install_element(BGP_IPV6M_NODE, &no_neighbor_disable_addpath_rx_cmd);
19755 install_element(BGP_IPV6L_NODE, &neighbor_disable_addpath_rx_cmd);
19756 install_element(BGP_IPV6L_NODE, &no_neighbor_disable_addpath_rx_cmd);
19757 install_element(BGP_VPNV4_NODE, &neighbor_disable_addpath_rx_cmd);
19758 install_element(BGP_VPNV4_NODE, &no_neighbor_disable_addpath_rx_cmd);
19759 install_element(BGP_VPNV6_NODE, &neighbor_disable_addpath_rx_cmd);
19760 install_element(BGP_VPNV6_NODE, &no_neighbor_disable_addpath_rx_cmd);
19761
19762 /* "neighbor addpath-tx-all-paths" commands.*/
19763 install_element(BGP_NODE, &neighbor_addpath_tx_all_paths_hidden_cmd);
19764 install_element(BGP_NODE, &no_neighbor_addpath_tx_all_paths_hidden_cmd);
19765 install_element(BGP_IPV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
19766 install_element(BGP_IPV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19767 install_element(BGP_IPV4M_NODE, &neighbor_addpath_tx_all_paths_cmd);
19768 install_element(BGP_IPV4M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19769 install_element(BGP_IPV4L_NODE, &neighbor_addpath_tx_all_paths_cmd);
19770 install_element(BGP_IPV4L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19771 install_element(BGP_IPV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
19772 install_element(BGP_IPV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19773 install_element(BGP_IPV6M_NODE, &neighbor_addpath_tx_all_paths_cmd);
19774 install_element(BGP_IPV6M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19775 install_element(BGP_IPV6L_NODE, &neighbor_addpath_tx_all_paths_cmd);
19776 install_element(BGP_IPV6L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19777 install_element(BGP_VPNV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
19778 install_element(BGP_VPNV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19779 install_element(BGP_VPNV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
19780 install_element(BGP_VPNV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
19781
19782 /* "neighbor addpath-tx-bestpath-per-AS" commands.*/
19783 install_element(BGP_NODE,
19784 &neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
19785 install_element(BGP_NODE,
19786 &no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
19787 install_element(BGP_IPV4_NODE,
19788 &neighbor_addpath_tx_bestpath_per_as_cmd);
19789 install_element(BGP_IPV4_NODE,
19790 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19791 install_element(BGP_IPV4M_NODE,
19792 &neighbor_addpath_tx_bestpath_per_as_cmd);
19793 install_element(BGP_IPV4M_NODE,
19794 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19795 install_element(BGP_IPV4L_NODE,
19796 &neighbor_addpath_tx_bestpath_per_as_cmd);
19797 install_element(BGP_IPV4L_NODE,
19798 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19799 install_element(BGP_IPV6_NODE,
19800 &neighbor_addpath_tx_bestpath_per_as_cmd);
19801 install_element(BGP_IPV6_NODE,
19802 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19803 install_element(BGP_IPV6M_NODE,
19804 &neighbor_addpath_tx_bestpath_per_as_cmd);
19805 install_element(BGP_IPV6M_NODE,
19806 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19807 install_element(BGP_IPV6L_NODE,
19808 &neighbor_addpath_tx_bestpath_per_as_cmd);
19809 install_element(BGP_IPV6L_NODE,
19810 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19811 install_element(BGP_VPNV4_NODE,
19812 &neighbor_addpath_tx_bestpath_per_as_cmd);
19813 install_element(BGP_VPNV4_NODE,
19814 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19815 install_element(BGP_VPNV6_NODE,
19816 &neighbor_addpath_tx_bestpath_per_as_cmd);
19817 install_element(BGP_VPNV6_NODE,
19818 &no_neighbor_addpath_tx_bestpath_per_as_cmd);
19819
19820 /* "neighbor sender-as-path-loop-detection" commands. */
19821 install_element(BGP_NODE, &neighbor_aspath_loop_detection_cmd);
19822 install_element(BGP_NODE, &no_neighbor_aspath_loop_detection_cmd);
19823
19824 /* "neighbor path-attribute discard" commands. */
19825 install_element(BGP_NODE, &neighbor_path_attribute_discard_cmd);
19826 install_element(BGP_NODE, &no_neighbor_path_attribute_discard_cmd);
19827
19828 /* "neighbor path-attribute treat-as-withdraw" commands. */
19829 install_element(BGP_NODE,
19830 &neighbor_path_attribute_treat_as_withdraw_cmd);
19831 install_element(BGP_NODE,
19832 &no_neighbor_path_attribute_treat_as_withdraw_cmd);
19833
19834 /* "neighbor passive" commands. */
19835 install_element(BGP_NODE, &neighbor_passive_cmd);
19836 install_element(BGP_NODE, &no_neighbor_passive_cmd);
19837
19838
19839 /* "neighbor shutdown" commands. */
19840 install_element(BGP_NODE, &neighbor_shutdown_cmd);
19841 install_element(BGP_NODE, &no_neighbor_shutdown_cmd);
19842 install_element(BGP_NODE, &neighbor_shutdown_msg_cmd);
19843 install_element(BGP_NODE, &no_neighbor_shutdown_msg_cmd);
19844 install_element(BGP_NODE, &neighbor_shutdown_rtt_cmd);
19845 install_element(BGP_NODE, &no_neighbor_shutdown_rtt_cmd);
19846
19847 /* "neighbor capability extended-nexthop" commands.*/
19848 install_element(BGP_NODE, &neighbor_capability_enhe_cmd);
19849 install_element(BGP_NODE, &no_neighbor_capability_enhe_cmd);
19850
19851 /* "neighbor capability software-version" commands.*/
19852 install_element(BGP_NODE, &neighbor_capability_software_version_cmd);
19853
19854 /* "neighbor capability orf prefix-list" commands.*/
19855 install_element(BGP_NODE, &neighbor_capability_orf_prefix_hidden_cmd);
19856 install_element(BGP_NODE,
19857 &no_neighbor_capability_orf_prefix_hidden_cmd);
19858 install_element(BGP_IPV4_NODE, &neighbor_capability_orf_prefix_cmd);
19859 install_element(BGP_IPV4_NODE, &no_neighbor_capability_orf_prefix_cmd);
19860 install_element(BGP_IPV4M_NODE, &neighbor_capability_orf_prefix_cmd);
19861 install_element(BGP_IPV4M_NODE, &no_neighbor_capability_orf_prefix_cmd);
19862 install_element(BGP_IPV4L_NODE, &neighbor_capability_orf_prefix_cmd);
19863 install_element(BGP_IPV4L_NODE, &no_neighbor_capability_orf_prefix_cmd);
19864 install_element(BGP_IPV6_NODE, &neighbor_capability_orf_prefix_cmd);
19865 install_element(BGP_IPV6_NODE, &no_neighbor_capability_orf_prefix_cmd);
19866 install_element(BGP_IPV6M_NODE, &neighbor_capability_orf_prefix_cmd);
19867 install_element(BGP_IPV6M_NODE, &no_neighbor_capability_orf_prefix_cmd);
19868 install_element(BGP_IPV6L_NODE, &neighbor_capability_orf_prefix_cmd);
19869 install_element(BGP_IPV6L_NODE, &no_neighbor_capability_orf_prefix_cmd);
19870
19871 /* "neighbor capability dynamic" commands.*/
19872 install_element(BGP_NODE, &neighbor_capability_dynamic_cmd);
19873 install_element(BGP_NODE, &no_neighbor_capability_dynamic_cmd);
19874
19875 /* "neighbor dont-capability-negotiate" commands. */
19876 install_element(BGP_NODE, &neighbor_dont_capability_negotiate_cmd);
19877 install_element(BGP_NODE, &no_neighbor_dont_capability_negotiate_cmd);
19878
19879 /* "neighbor ebgp-multihop" commands. */
19880 install_element(BGP_NODE, &neighbor_ebgp_multihop_cmd);
19881 install_element(BGP_NODE, &neighbor_ebgp_multihop_ttl_cmd);
19882 install_element(BGP_NODE, &no_neighbor_ebgp_multihop_cmd);
19883
19884 /* "neighbor disable-connected-check" commands. */
19885 install_element(BGP_NODE, &neighbor_disable_connected_check_cmd);
19886 install_element(BGP_NODE, &no_neighbor_disable_connected_check_cmd);
19887
19888 /* "neighbor disable-link-bw-encoding-ieee" commands. */
19889 install_element(BGP_NODE, &neighbor_disable_link_bw_encoding_ieee_cmd);
19890 install_element(BGP_NODE,
19891 &no_neighbor_disable_link_bw_encoding_ieee_cmd);
19892
19893 /* "neighbor extended-optional-parameters" commands. */
19894 install_element(BGP_NODE, &neighbor_extended_optional_parameters_cmd);
19895 install_element(BGP_NODE,
19896 &no_neighbor_extended_optional_parameters_cmd);
19897
19898 /* "neighbor enforce-first-as" commands. */
19899 install_element(BGP_NODE, &neighbor_enforce_first_as_cmd);
19900 install_element(BGP_NODE, &no_neighbor_enforce_first_as_cmd);
19901
19902 /* "neighbor description" commands. */
19903 install_element(BGP_NODE, &neighbor_description_cmd);
19904 install_element(BGP_NODE, &no_neighbor_description_cmd);
19905 install_element(BGP_NODE, &no_neighbor_description_comment_cmd);
19906
19907 /* "neighbor update-source" commands. "*/
19908 install_element(BGP_NODE, &neighbor_update_source_cmd);
19909 install_element(BGP_NODE, &no_neighbor_update_source_cmd);
19910
19911 /* "neighbor default-originate" commands. */
19912 install_element(BGP_NODE, &neighbor_default_originate_hidden_cmd);
19913 install_element(BGP_NODE, &neighbor_default_originate_rmap_hidden_cmd);
19914 install_element(BGP_NODE, &no_neighbor_default_originate_hidden_cmd);
19915 install_element(BGP_IPV4_NODE, &neighbor_default_originate_cmd);
19916 install_element(BGP_IPV4_NODE, &neighbor_default_originate_rmap_cmd);
19917 install_element(BGP_IPV4_NODE, &no_neighbor_default_originate_cmd);
19918 install_element(BGP_IPV4M_NODE, &neighbor_default_originate_cmd);
19919 install_element(BGP_IPV4M_NODE, &neighbor_default_originate_rmap_cmd);
19920 install_element(BGP_IPV4M_NODE, &no_neighbor_default_originate_cmd);
19921 install_element(BGP_IPV4L_NODE, &neighbor_default_originate_cmd);
19922 install_element(BGP_IPV4L_NODE, &neighbor_default_originate_rmap_cmd);
19923 install_element(BGP_IPV4L_NODE, &no_neighbor_default_originate_cmd);
19924 install_element(BGP_IPV6_NODE, &neighbor_default_originate_cmd);
19925 install_element(BGP_IPV6_NODE, &neighbor_default_originate_rmap_cmd);
19926 install_element(BGP_IPV6_NODE, &no_neighbor_default_originate_cmd);
19927 install_element(BGP_IPV6M_NODE, &neighbor_default_originate_cmd);
19928 install_element(BGP_IPV6M_NODE, &neighbor_default_originate_rmap_cmd);
19929 install_element(BGP_IPV6M_NODE, &no_neighbor_default_originate_cmd);
19930 install_element(BGP_IPV6L_NODE, &neighbor_default_originate_cmd);
19931 install_element(BGP_IPV6L_NODE, &neighbor_default_originate_rmap_cmd);
19932 install_element(BGP_IPV6L_NODE, &no_neighbor_default_originate_cmd);
19933
19934 /* "neighbor port" commands. */
19935 install_element(BGP_NODE, &neighbor_port_cmd);
19936 install_element(BGP_NODE, &no_neighbor_port_cmd);
19937
19938 /* "neighbor weight" commands. */
19939 install_element(BGP_NODE, &neighbor_weight_hidden_cmd);
19940 install_element(BGP_NODE, &no_neighbor_weight_hidden_cmd);
19941
19942 install_element(BGP_IPV4_NODE, &neighbor_weight_cmd);
19943 install_element(BGP_IPV4_NODE, &no_neighbor_weight_cmd);
19944 install_element(BGP_IPV4M_NODE, &neighbor_weight_cmd);
19945 install_element(BGP_IPV4M_NODE, &no_neighbor_weight_cmd);
19946 install_element(BGP_IPV4L_NODE, &neighbor_weight_cmd);
19947 install_element(BGP_IPV4L_NODE, &no_neighbor_weight_cmd);
19948 install_element(BGP_IPV6_NODE, &neighbor_weight_cmd);
19949 install_element(BGP_IPV6_NODE, &no_neighbor_weight_cmd);
19950 install_element(BGP_IPV6M_NODE, &neighbor_weight_cmd);
19951 install_element(BGP_IPV6M_NODE, &no_neighbor_weight_cmd);
19952 install_element(BGP_IPV6L_NODE, &neighbor_weight_cmd);
19953 install_element(BGP_IPV6L_NODE, &no_neighbor_weight_cmd);
19954 install_element(BGP_VPNV4_NODE, &neighbor_weight_cmd);
19955 install_element(BGP_VPNV4_NODE, &no_neighbor_weight_cmd);
19956 install_element(BGP_VPNV6_NODE, &neighbor_weight_cmd);
19957 install_element(BGP_VPNV6_NODE, &no_neighbor_weight_cmd);
19958
19959 /* "neighbor override-capability" commands. */
19960 install_element(BGP_NODE, &neighbor_override_capability_cmd);
19961 install_element(BGP_NODE, &no_neighbor_override_capability_cmd);
19962
19963 /* "neighbor strict-capability-match" commands. */
19964 install_element(BGP_NODE, &neighbor_strict_capability_cmd);
19965 install_element(BGP_NODE, &no_neighbor_strict_capability_cmd);
19966
19967 /* "neighbor timers" commands. */
19968 install_element(BGP_NODE, &neighbor_timers_cmd);
19969 install_element(BGP_NODE, &no_neighbor_timers_cmd);
19970
19971 /* "neighbor timers connect" commands. */
19972 install_element(BGP_NODE, &neighbor_timers_connect_cmd);
19973 install_element(BGP_NODE, &no_neighbor_timers_connect_cmd);
19974
19975 /* "neighbor timers delayopen" commands. */
19976 install_element(BGP_NODE, &neighbor_timers_delayopen_cmd);
19977 install_element(BGP_NODE, &no_neighbor_timers_delayopen_cmd);
19978
19979 /* "neighbor advertisement-interval" commands. */
19980 install_element(BGP_NODE, &neighbor_advertise_interval_cmd);
19981 install_element(BGP_NODE, &no_neighbor_advertise_interval_cmd);
19982
19983 /* "neighbor interface" commands. */
19984 install_element(BGP_NODE, &neighbor_interface_cmd);
19985 install_element(BGP_NODE, &no_neighbor_interface_cmd);
19986
19987 /* "neighbor distribute" commands. */
19988 install_element(BGP_NODE, &neighbor_distribute_list_hidden_cmd);
19989 install_element(BGP_NODE, &no_neighbor_distribute_list_hidden_cmd);
19990 install_element(BGP_IPV4_NODE, &neighbor_distribute_list_cmd);
19991 install_element(BGP_IPV4_NODE, &no_neighbor_distribute_list_cmd);
19992 install_element(BGP_IPV4M_NODE, &neighbor_distribute_list_cmd);
19993 install_element(BGP_IPV4M_NODE, &no_neighbor_distribute_list_cmd);
19994 install_element(BGP_IPV4L_NODE, &neighbor_distribute_list_cmd);
19995 install_element(BGP_IPV4L_NODE, &no_neighbor_distribute_list_cmd);
19996 install_element(BGP_IPV6_NODE, &neighbor_distribute_list_cmd);
19997 install_element(BGP_IPV6_NODE, &no_neighbor_distribute_list_cmd);
19998 install_element(BGP_IPV6M_NODE, &neighbor_distribute_list_cmd);
19999 install_element(BGP_IPV6M_NODE, &no_neighbor_distribute_list_cmd);
20000 install_element(BGP_IPV6L_NODE, &neighbor_distribute_list_cmd);
20001 install_element(BGP_IPV6L_NODE, &no_neighbor_distribute_list_cmd);
20002 install_element(BGP_VPNV4_NODE, &neighbor_distribute_list_cmd);
20003 install_element(BGP_VPNV4_NODE, &no_neighbor_distribute_list_cmd);
20004 install_element(BGP_VPNV6_NODE, &neighbor_distribute_list_cmd);
20005 install_element(BGP_VPNV6_NODE, &no_neighbor_distribute_list_cmd);
20006
20007 /* "neighbor prefix-list" commands. */
20008 install_element(BGP_NODE, &neighbor_prefix_list_hidden_cmd);
20009 install_element(BGP_NODE, &no_neighbor_prefix_list_hidden_cmd);
20010 install_element(BGP_IPV4_NODE, &neighbor_prefix_list_cmd);
20011 install_element(BGP_IPV4_NODE, &no_neighbor_prefix_list_cmd);
20012 install_element(BGP_IPV4M_NODE, &neighbor_prefix_list_cmd);
20013 install_element(BGP_IPV4M_NODE, &no_neighbor_prefix_list_cmd);
20014 install_element(BGP_IPV4L_NODE, &neighbor_prefix_list_cmd);
20015 install_element(BGP_IPV4L_NODE, &no_neighbor_prefix_list_cmd);
20016 install_element(BGP_IPV6_NODE, &neighbor_prefix_list_cmd);
20017 install_element(BGP_IPV6_NODE, &no_neighbor_prefix_list_cmd);
20018 install_element(BGP_IPV6M_NODE, &neighbor_prefix_list_cmd);
20019 install_element(BGP_IPV6M_NODE, &no_neighbor_prefix_list_cmd);
20020 install_element(BGP_IPV6L_NODE, &neighbor_prefix_list_cmd);
20021 install_element(BGP_IPV6L_NODE, &no_neighbor_prefix_list_cmd);
20022 install_element(BGP_VPNV4_NODE, &neighbor_prefix_list_cmd);
20023 install_element(BGP_VPNV4_NODE, &no_neighbor_prefix_list_cmd);
20024 install_element(BGP_VPNV6_NODE, &neighbor_prefix_list_cmd);
20025 install_element(BGP_VPNV6_NODE, &no_neighbor_prefix_list_cmd);
20026 install_element(BGP_FLOWSPECV4_NODE, &neighbor_prefix_list_cmd);
20027 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_prefix_list_cmd);
20028 install_element(BGP_FLOWSPECV6_NODE, &neighbor_prefix_list_cmd);
20029 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_prefix_list_cmd);
20030
20031 /* "neighbor filter-list" commands. */
20032 install_element(BGP_NODE, &neighbor_filter_list_hidden_cmd);
20033 install_element(BGP_NODE, &no_neighbor_filter_list_hidden_cmd);
20034 install_element(BGP_IPV4_NODE, &neighbor_filter_list_cmd);
20035 install_element(BGP_IPV4_NODE, &no_neighbor_filter_list_cmd);
20036 install_element(BGP_IPV4M_NODE, &neighbor_filter_list_cmd);
20037 install_element(BGP_IPV4M_NODE, &no_neighbor_filter_list_cmd);
20038 install_element(BGP_IPV4L_NODE, &neighbor_filter_list_cmd);
20039 install_element(BGP_IPV4L_NODE, &no_neighbor_filter_list_cmd);
20040 install_element(BGP_IPV6_NODE, &neighbor_filter_list_cmd);
20041 install_element(BGP_IPV6_NODE, &no_neighbor_filter_list_cmd);
20042 install_element(BGP_IPV6M_NODE, &neighbor_filter_list_cmd);
20043 install_element(BGP_IPV6M_NODE, &no_neighbor_filter_list_cmd);
20044 install_element(BGP_IPV6L_NODE, &neighbor_filter_list_cmd);
20045 install_element(BGP_IPV6L_NODE, &no_neighbor_filter_list_cmd);
20046 install_element(BGP_VPNV4_NODE, &neighbor_filter_list_cmd);
20047 install_element(BGP_VPNV4_NODE, &no_neighbor_filter_list_cmd);
20048 install_element(BGP_VPNV6_NODE, &neighbor_filter_list_cmd);
20049 install_element(BGP_VPNV6_NODE, &no_neighbor_filter_list_cmd);
20050 install_element(BGP_FLOWSPECV4_NODE, &neighbor_filter_list_cmd);
20051 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_filter_list_cmd);
20052 install_element(BGP_FLOWSPECV6_NODE, &neighbor_filter_list_cmd);
20053 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_filter_list_cmd);
20054
20055 /* "neighbor route-map" commands. */
20056 install_element(BGP_NODE, &neighbor_route_map_hidden_cmd);
20057 install_element(BGP_NODE, &no_neighbor_route_map_hidden_cmd);
20058 install_element(BGP_IPV4_NODE, &neighbor_route_map_cmd);
20059 install_element(BGP_IPV4_NODE, &no_neighbor_route_map_cmd);
20060 install_element(BGP_IPV4M_NODE, &neighbor_route_map_cmd);
20061 install_element(BGP_IPV4M_NODE, &no_neighbor_route_map_cmd);
20062 install_element(BGP_IPV4L_NODE, &neighbor_route_map_cmd);
20063 install_element(BGP_IPV4L_NODE, &no_neighbor_route_map_cmd);
20064 install_element(BGP_IPV6_NODE, &neighbor_route_map_cmd);
20065 install_element(BGP_IPV6_NODE, &no_neighbor_route_map_cmd);
20066 install_element(BGP_IPV6M_NODE, &neighbor_route_map_cmd);
20067 install_element(BGP_IPV6M_NODE, &no_neighbor_route_map_cmd);
20068 install_element(BGP_IPV6L_NODE, &neighbor_route_map_cmd);
20069 install_element(BGP_IPV6L_NODE, &no_neighbor_route_map_cmd);
20070 install_element(BGP_VPNV4_NODE, &neighbor_route_map_cmd);
20071 install_element(BGP_VPNV4_NODE, &no_neighbor_route_map_cmd);
20072 install_element(BGP_VPNV6_NODE, &neighbor_route_map_cmd);
20073 install_element(BGP_VPNV6_NODE, &no_neighbor_route_map_cmd);
20074 install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_map_cmd);
20075 install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_route_map_cmd);
20076 install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_map_cmd);
20077 install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_route_map_cmd);
20078 install_element(BGP_EVPN_NODE, &neighbor_route_map_cmd);
20079 install_element(BGP_EVPN_NODE, &no_neighbor_route_map_cmd);
20080
20081 /* "neighbor unsuppress-map" commands. */
20082 install_element(BGP_NODE, &neighbor_unsuppress_map_hidden_cmd);
20083 install_element(BGP_NODE, &no_neighbor_unsuppress_map_hidden_cmd);
20084 install_element(BGP_IPV4_NODE, &neighbor_unsuppress_map_cmd);
20085 install_element(BGP_IPV4_NODE, &no_neighbor_unsuppress_map_cmd);
20086 install_element(BGP_IPV4M_NODE, &neighbor_unsuppress_map_cmd);
20087 install_element(BGP_IPV4M_NODE, &no_neighbor_unsuppress_map_cmd);
20088 install_element(BGP_IPV4L_NODE, &neighbor_unsuppress_map_cmd);
20089 install_element(BGP_IPV4L_NODE, &no_neighbor_unsuppress_map_cmd);
20090 install_element(BGP_IPV6_NODE, &neighbor_unsuppress_map_cmd);
20091 install_element(BGP_IPV6_NODE, &no_neighbor_unsuppress_map_cmd);
20092 install_element(BGP_IPV6M_NODE, &neighbor_unsuppress_map_cmd);
20093 install_element(BGP_IPV6M_NODE, &no_neighbor_unsuppress_map_cmd);
20094 install_element(BGP_IPV6L_NODE, &neighbor_unsuppress_map_cmd);
20095 install_element(BGP_IPV6L_NODE, &no_neighbor_unsuppress_map_cmd);
20096 install_element(BGP_VPNV4_NODE, &neighbor_unsuppress_map_cmd);
20097 install_element(BGP_VPNV4_NODE, &no_neighbor_unsuppress_map_cmd);
20098 install_element(BGP_VPNV6_NODE, &neighbor_unsuppress_map_cmd);
20099 install_element(BGP_VPNV6_NODE, &no_neighbor_unsuppress_map_cmd);
20100
20101 /* "neighbor advertise-map" commands. */
20102 install_element(BGP_NODE, &bgp_condadv_period_cmd);
20103 install_element(BGP_NODE, &neighbor_advertise_map_hidden_cmd);
20104 install_element(BGP_IPV4_NODE, &neighbor_advertise_map_cmd);
20105 install_element(BGP_IPV4M_NODE, &neighbor_advertise_map_cmd);
20106 install_element(BGP_IPV4L_NODE, &neighbor_advertise_map_cmd);
20107 install_element(BGP_IPV6_NODE, &neighbor_advertise_map_cmd);
20108 install_element(BGP_IPV6M_NODE, &neighbor_advertise_map_cmd);
20109 install_element(BGP_IPV6L_NODE, &neighbor_advertise_map_cmd);
20110 install_element(BGP_VPNV4_NODE, &neighbor_advertise_map_cmd);
20111 install_element(BGP_VPNV6_NODE, &neighbor_advertise_map_cmd);
20112
20113 /* neighbor maximum-prefix-out commands. */
20114 install_element(BGP_NODE, &neighbor_maximum_prefix_out_cmd);
20115 install_element(BGP_NODE, &no_neighbor_maximum_prefix_out_cmd);
20116 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_out_cmd);
20117 install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_out_cmd);
20118 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_out_cmd);
20119 install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_out_cmd);
20120 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_out_cmd);
20121 install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_out_cmd);
20122 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_out_cmd);
20123 install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_out_cmd);
20124 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_out_cmd);
20125 install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_out_cmd);
20126 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_out_cmd);
20127 install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_out_cmd);
20128 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_out_cmd);
20129 install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_out_cmd);
20130 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_out_cmd);
20131 install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_out_cmd);
20132
20133 /* "neighbor maximum-prefix" commands. */
20134 install_element(BGP_NODE, &neighbor_maximum_prefix_hidden_cmd);
20135 install_element(BGP_NODE,
20136 &neighbor_maximum_prefix_threshold_hidden_cmd);
20137 install_element(BGP_NODE, &neighbor_maximum_prefix_warning_hidden_cmd);
20138 install_element(BGP_NODE,
20139 &neighbor_maximum_prefix_threshold_warning_hidden_cmd);
20140 install_element(BGP_NODE, &neighbor_maximum_prefix_restart_hidden_cmd);
20141 install_element(BGP_NODE,
20142 &neighbor_maximum_prefix_threshold_restart_hidden_cmd);
20143 install_element(BGP_NODE, &no_neighbor_maximum_prefix_hidden_cmd);
20144 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_cmd);
20145 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
20146 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_warning_cmd);
20147 install_element(BGP_IPV4_NODE,
20148 &neighbor_maximum_prefix_threshold_warning_cmd);
20149 install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_restart_cmd);
20150 install_element(BGP_IPV4_NODE,
20151 &neighbor_maximum_prefix_threshold_restart_cmd);
20152 install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_cmd);
20153 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_cmd);
20154 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_cmd);
20155 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_warning_cmd);
20156 install_element(BGP_IPV4M_NODE,
20157 &neighbor_maximum_prefix_threshold_warning_cmd);
20158 install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_restart_cmd);
20159 install_element(BGP_IPV4M_NODE,
20160 &neighbor_maximum_prefix_threshold_restart_cmd);
20161 install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_cmd);
20162 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_cmd);
20163 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_threshold_cmd);
20164 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_warning_cmd);
20165 install_element(BGP_IPV4L_NODE,
20166 &neighbor_maximum_prefix_threshold_warning_cmd);
20167 install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_restart_cmd);
20168 install_element(BGP_IPV4L_NODE,
20169 &neighbor_maximum_prefix_threshold_restart_cmd);
20170 install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_cmd);
20171 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_cmd);
20172 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
20173 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
20174 install_element(BGP_IPV6_NODE,
20175 &neighbor_maximum_prefix_threshold_warning_cmd);
20176 install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
20177 install_element(BGP_IPV6_NODE,
20178 &neighbor_maximum_prefix_threshold_restart_cmd);
20179 install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_cmd);
20180 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_cmd);
20181 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_cmd);
20182 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_warning_cmd);
20183 install_element(BGP_IPV6M_NODE,
20184 &neighbor_maximum_prefix_threshold_warning_cmd);
20185 install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_restart_cmd);
20186 install_element(BGP_IPV6M_NODE,
20187 &neighbor_maximum_prefix_threshold_restart_cmd);
20188 install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_cmd);
20189 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_cmd);
20190 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_threshold_cmd);
20191 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_warning_cmd);
20192 install_element(BGP_IPV6L_NODE,
20193 &neighbor_maximum_prefix_threshold_warning_cmd);
20194 install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_restart_cmd);
20195 install_element(BGP_IPV6L_NODE,
20196 &neighbor_maximum_prefix_threshold_restart_cmd);
20197 install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_cmd);
20198 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_cmd);
20199 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
20200 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_warning_cmd);
20201 install_element(BGP_VPNV4_NODE,
20202 &neighbor_maximum_prefix_threshold_warning_cmd);
20203 install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_restart_cmd);
20204 install_element(BGP_VPNV4_NODE,
20205 &neighbor_maximum_prefix_threshold_restart_cmd);
20206 install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_cmd);
20207 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_cmd);
20208 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
20209 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_warning_cmd);
20210 install_element(BGP_VPNV6_NODE,
20211 &neighbor_maximum_prefix_threshold_warning_cmd);
20212 install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_restart_cmd);
20213 install_element(BGP_VPNV6_NODE,
20214 &neighbor_maximum_prefix_threshold_restart_cmd);
20215 install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_cmd);
20216
20217 /* "neighbor allowas-in" */
20218 install_element(BGP_NODE, &neighbor_allowas_in_hidden_cmd);
20219 install_element(BGP_NODE, &no_neighbor_allowas_in_hidden_cmd);
20220 install_element(BGP_IPV4_NODE, &neighbor_allowas_in_cmd);
20221 install_element(BGP_IPV4_NODE, &no_neighbor_allowas_in_cmd);
20222 install_element(BGP_IPV4M_NODE, &neighbor_allowas_in_cmd);
20223 install_element(BGP_IPV4M_NODE, &no_neighbor_allowas_in_cmd);
20224 install_element(BGP_IPV4L_NODE, &neighbor_allowas_in_cmd);
20225 install_element(BGP_IPV4L_NODE, &no_neighbor_allowas_in_cmd);
20226 install_element(BGP_IPV6_NODE, &neighbor_allowas_in_cmd);
20227 install_element(BGP_IPV6_NODE, &no_neighbor_allowas_in_cmd);
20228 install_element(BGP_IPV6M_NODE, &neighbor_allowas_in_cmd);
20229 install_element(BGP_IPV6M_NODE, &no_neighbor_allowas_in_cmd);
20230 install_element(BGP_IPV6L_NODE, &neighbor_allowas_in_cmd);
20231 install_element(BGP_IPV6L_NODE, &no_neighbor_allowas_in_cmd);
20232 install_element(BGP_VPNV4_NODE, &neighbor_allowas_in_cmd);
20233 install_element(BGP_VPNV4_NODE, &no_neighbor_allowas_in_cmd);
20234 install_element(BGP_VPNV6_NODE, &neighbor_allowas_in_cmd);
20235 install_element(BGP_VPNV6_NODE, &no_neighbor_allowas_in_cmd);
20236 install_element(BGP_EVPN_NODE, &neighbor_allowas_in_cmd);
20237 install_element(BGP_EVPN_NODE, &no_neighbor_allowas_in_cmd);
20238
20239 /* neighbor accept-own */
20240 install_element(BGP_VPNV4_NODE, &neighbor_accept_own_cmd);
20241 install_element(BGP_VPNV6_NODE, &neighbor_accept_own_cmd);
20242
20243 /* "neighbor soo" */
20244 install_element(BGP_IPV4_NODE, &neighbor_soo_cmd);
20245 install_element(BGP_IPV4_NODE, &no_neighbor_soo_cmd);
20246 install_element(BGP_IPV4M_NODE, &neighbor_soo_cmd);
20247 install_element(BGP_IPV4M_NODE, &no_neighbor_soo_cmd);
20248 install_element(BGP_IPV4L_NODE, &neighbor_soo_cmd);
20249 install_element(BGP_IPV4L_NODE, &no_neighbor_soo_cmd);
20250 install_element(BGP_IPV6_NODE, &neighbor_soo_cmd);
20251 install_element(BGP_IPV6_NODE, &no_neighbor_soo_cmd);
20252 install_element(BGP_IPV6M_NODE, &neighbor_soo_cmd);
20253 install_element(BGP_IPV6M_NODE, &no_neighbor_soo_cmd);
20254 install_element(BGP_IPV6L_NODE, &neighbor_soo_cmd);
20255 install_element(BGP_IPV6L_NODE, &no_neighbor_soo_cmd);
20256 install_element(BGP_VPNV4_NODE, &neighbor_soo_cmd);
20257 install_element(BGP_VPNV4_NODE, &no_neighbor_soo_cmd);
20258 install_element(BGP_VPNV6_NODE, &neighbor_soo_cmd);
20259 install_element(BGP_VPNV6_NODE, &no_neighbor_soo_cmd);
20260 install_element(BGP_EVPN_NODE, &neighbor_soo_cmd);
20261 install_element(BGP_EVPN_NODE, &no_neighbor_soo_cmd);
20262
20263 /* address-family commands. */
20264 install_element(BGP_NODE, &address_family_ipv4_safi_cmd);
20265 install_element(BGP_NODE, &address_family_ipv6_safi_cmd);
20266 #ifdef KEEP_OLD_VPN_COMMANDS
20267 install_element(BGP_NODE, &address_family_vpnv4_cmd);
20268 install_element(BGP_NODE, &address_family_vpnv6_cmd);
20269 #endif /* KEEP_OLD_VPN_COMMANDS */
20270
20271 install_element(BGP_NODE, &address_family_evpn_cmd);
20272
20273 /* "exit-address-family" command. */
20274 install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
20275 install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
20276 install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
20277 install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
20278 install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
20279 install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
20280 install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
20281 install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
20282 install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
20283 install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
20284 install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
20285
20286 /* BGP retain all route-target */
20287 install_element(BGP_VPNV4_NODE, &bgp_retain_route_target_cmd);
20288 install_element(BGP_VPNV6_NODE, &bgp_retain_route_target_cmd);
20289
20290 /* "clear ip bgp commands" */
20291 install_element(ENABLE_NODE, &clear_ip_bgp_all_cmd);
20292
20293 /* clear ip bgp prefix */
20294 install_element(ENABLE_NODE, &clear_ip_bgp_prefix_cmd);
20295 install_element(ENABLE_NODE, &clear_bgp_ipv6_safi_prefix_cmd);
20296 install_element(ENABLE_NODE, &clear_bgp_instance_ipv6_safi_prefix_cmd);
20297
20298 /* "show [ip] bgp summary" commands. */
20299 install_element(VIEW_NODE, &show_bgp_instance_all_ipv6_updgrps_cmd);
20300 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_updgrps_cmd);
20301 install_element(VIEW_NODE, &show_bgp_instance_updgrps_stats_cmd);
20302 install_element(VIEW_NODE, &show_bgp_updgrps_stats_cmd);
20303 install_element(VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_s_cmd);
20304 install_element(VIEW_NODE, &show_ip_bgp_summary_cmd);
20305 install_element(VIEW_NODE, &show_ip_bgp_updgrps_cmd);
20306
20307 /* "show [ip] bgp neighbors" commands. */
20308 install_element(VIEW_NODE, &show_ip_bgp_neighbors_cmd);
20309
20310 install_element(VIEW_NODE, &show_ip_bgp_neighbors_graceful_restart_cmd);
20311
20312 /* "show [ip] bgp peer-group" commands. */
20313 install_element(VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
20314
20315 /* "show [ip] bgp paths" commands. */
20316 install_element(VIEW_NODE, &show_ip_bgp_paths_cmd);
20317
20318 /* "show [ip] bgp community" commands. */
20319 install_element(VIEW_NODE, &show_ip_bgp_community_info_cmd);
20320
20321 /* "show ip bgp large-community" commands. */
20322 install_element(VIEW_NODE, &show_ip_bgp_lcommunity_info_cmd);
20323 /* "show [ip] bgp attribute-info" commands. */
20324 install_element(VIEW_NODE, &show_ip_bgp_attr_info_cmd);
20325 /* "show [ip] bgp route-leak" command */
20326 install_element(VIEW_NODE, &show_ip_bgp_route_leak_cmd);
20327
20328 /* "redistribute" commands. */
20329 install_element(BGP_NODE, &bgp_redistribute_ipv4_hidden_cmd);
20330 install_element(BGP_NODE, &no_bgp_redistribute_ipv4_hidden_cmd);
20331 install_element(BGP_NODE, &bgp_redistribute_ipv4_rmap_hidden_cmd);
20332 install_element(BGP_NODE, &bgp_redistribute_ipv4_metric_hidden_cmd);
20333 install_element(BGP_NODE,
20334 &bgp_redistribute_ipv4_rmap_metric_hidden_cmd);
20335 install_element(BGP_NODE,
20336 &bgp_redistribute_ipv4_metric_rmap_hidden_cmd);
20337 install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_hidden_cmd);
20338 install_element(BGP_NODE, &no_bgp_redistribute_ipv4_ospf_hidden_cmd);
20339 install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_hidden_cmd);
20340 install_element(BGP_NODE,
20341 &bgp_redistribute_ipv4_ospf_metric_hidden_cmd);
20342 install_element(BGP_NODE,
20343 &bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd);
20344 install_element(BGP_NODE,
20345 &bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd);
20346 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_cmd);
20347 install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_cmd);
20348 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_cmd);
20349 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_cmd);
20350 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
20351 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
20352 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_cmd);
20353 install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
20354 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
20355 install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
20356 install_element(BGP_IPV4_NODE,
20357 &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
20358 install_element(BGP_IPV4_NODE,
20359 &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
20360 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_cmd);
20361 install_element(BGP_IPV6_NODE, &no_bgp_redistribute_ipv6_cmd);
20362 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_cmd);
20363 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_cmd);
20364 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_metric_cmd);
20365 install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_rmap_cmd);
20366
20367 /* import|export vpn [route-map RMAP_NAME] */
20368 install_element(BGP_IPV4_NODE, &bgp_imexport_vpn_cmd);
20369 install_element(BGP_IPV6_NODE, &bgp_imexport_vpn_cmd);
20370
20371 install_element(BGP_IPV4_NODE, &bgp_imexport_vrf_cmd);
20372 install_element(BGP_IPV6_NODE, &bgp_imexport_vrf_cmd);
20373
20374 /* ttl_security commands */
20375 install_element(BGP_NODE, &neighbor_ttl_security_cmd);
20376 install_element(BGP_NODE, &no_neighbor_ttl_security_cmd);
20377
20378 /* "bgp tcp-keepalive" commands */
20379 install_element(BGP_NODE, &bgp_tcp_keepalive_cmd);
20380 install_element(BGP_NODE, &no_bgp_tcp_keepalive_cmd);
20381
20382 /* "show [ip] bgp memory" commands. */
20383 install_element(VIEW_NODE, &show_bgp_memory_cmd);
20384
20385 /* "show bgp martian next-hop" */
20386 install_element(VIEW_NODE, &show_bgp_martian_nexthop_db_cmd);
20387
20388 install_element(VIEW_NODE, &show_bgp_mac_hash_cmd);
20389
20390 /* "show [ip] bgp views" commands. */
20391 install_element(VIEW_NODE, &show_bgp_views_cmd);
20392
20393 /* "show [ip] bgp vrfs" commands. */
20394 install_element(VIEW_NODE, &show_bgp_vrfs_cmd);
20395
20396 /* Community-list. */
20397 community_list_vty();
20398
20399 community_alias_vty();
20400
20401 /* vpn-policy commands */
20402 install_element(BGP_IPV4_NODE, &af_rd_vpn_export_cmd);
20403 install_element(BGP_IPV6_NODE, &af_rd_vpn_export_cmd);
20404 install_element(BGP_IPV4_NODE, &af_label_vpn_export_cmd);
20405 install_element(BGP_IPV6_NODE, &af_label_vpn_export_cmd);
20406 install_element(BGP_IPV4_NODE, &af_nexthop_vpn_export_cmd);
20407 install_element(BGP_IPV6_NODE, &af_nexthop_vpn_export_cmd);
20408 install_element(BGP_IPV4_NODE, &af_rt_vpn_imexport_cmd);
20409 install_element(BGP_IPV6_NODE, &af_rt_vpn_imexport_cmd);
20410 install_element(BGP_IPV4_NODE, &af_route_map_vpn_imexport_cmd);
20411 install_element(BGP_IPV6_NODE, &af_route_map_vpn_imexport_cmd);
20412 install_element(BGP_IPV4_NODE, &af_import_vrf_route_map_cmd);
20413 install_element(BGP_IPV6_NODE, &af_import_vrf_route_map_cmd);
20414
20415 install_element(BGP_IPV4_NODE, &af_routetarget_import_cmd);
20416 install_element(BGP_IPV6_NODE, &af_routetarget_import_cmd);
20417
20418 install_element(BGP_IPV4_NODE, &af_no_rd_vpn_export_cmd);
20419 install_element(BGP_IPV6_NODE, &af_no_rd_vpn_export_cmd);
20420 install_element(BGP_IPV4_NODE, &af_no_label_vpn_export_cmd);
20421 install_element(BGP_IPV6_NODE, &af_no_label_vpn_export_cmd);
20422 install_element(BGP_IPV4_NODE, &af_no_rt_vpn_imexport_cmd);
20423 install_element(BGP_IPV6_NODE, &af_no_rt_vpn_imexport_cmd);
20424 install_element(BGP_IPV4_NODE, &af_no_route_map_vpn_imexport_cmd);
20425 install_element(BGP_IPV6_NODE, &af_no_route_map_vpn_imexport_cmd);
20426 install_element(BGP_IPV4_NODE, &af_no_import_vrf_route_map_cmd);
20427 install_element(BGP_IPV6_NODE, &af_no_import_vrf_route_map_cmd);
20428
20429 /* tcp-mss command */
20430 install_element(BGP_NODE, &neighbor_tcp_mss_cmd);
20431 install_element(BGP_NODE, &no_neighbor_tcp_mss_cmd);
20432
20433 /* srv6 commands */
20434 install_element(VIEW_NODE, &show_bgp_srv6_cmd);
20435 install_element(BGP_NODE, &bgp_segment_routing_srv6_cmd);
20436 install_element(BGP_NODE, &no_bgp_segment_routing_srv6_cmd);
20437 install_element(BGP_SRV6_NODE, &bgp_srv6_locator_cmd);
20438 install_element(BGP_SRV6_NODE, &no_bgp_srv6_locator_cmd);
20439 install_element(BGP_IPV4_NODE, &af_sid_vpn_export_cmd);
20440 install_element(BGP_IPV6_NODE, &af_sid_vpn_export_cmd);
20441 install_element(BGP_NODE, &bgp_sid_vpn_export_cmd);
20442 install_element(BGP_NODE, &no_bgp_sid_vpn_export_cmd);
20443
20444 bgp_vty_if_init();
20445 }
20446
20447 #include "memory.h"
20448 #include "bgp_regex.h"
20449 #include "bgp_clist.h"
20450 #include "bgp_ecommunity.h"
20451
20452 /* VTY functions. */
20453
20454 /* Direction value to string conversion. */
20455 static const char *community_direct_str(int direct)
20456 {
20457 switch (direct) {
20458 case COMMUNITY_DENY:
20459 return "deny";
20460 case COMMUNITY_PERMIT:
20461 return "permit";
20462 default:
20463 return "unknown";
20464 }
20465 }
20466
20467 /* Display error string. */
20468 static void community_list_perror(struct vty *vty, int ret)
20469 {
20470 switch (ret) {
20471 case COMMUNITY_LIST_ERR_CANT_FIND_LIST:
20472 vty_out(vty, "%% Can't find community-list\n");
20473 break;
20474 case COMMUNITY_LIST_ERR_MALFORMED_VAL:
20475 vty_out(vty, "%% Malformed community-list value\n");
20476 break;
20477 case COMMUNITY_LIST_ERR_STANDARD_CONFLICT:
20478 vty_out(vty,
20479 "%% Community name conflict, previously defined as standard community\n");
20480 break;
20481 case COMMUNITY_LIST_ERR_EXPANDED_CONFLICT:
20482 vty_out(vty,
20483 "%% Community name conflict, previously defined as expanded community\n");
20484 break;
20485 }
20486 }
20487
20488 /* "community-list" keyword help string. */
20489 #define COMMUNITY_LIST_STR "Add a community list entry\n"
20490
20491 /*community-list standard */
20492 DEFUN (community_list_standard,
20493 bgp_community_list_standard_cmd,
20494 "bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20495 BGP_STR
20496 COMMUNITY_LIST_STR
20497 "Community list number (standard)\n"
20498 "Add an standard community-list entry\n"
20499 "Community list name\n"
20500 "Sequence number of an entry\n"
20501 "Sequence number\n"
20502 "Specify community to reject\n"
20503 "Specify community to accept\n"
20504 COMMUNITY_VAL_STR)
20505 {
20506 char *cl_name_or_number = NULL;
20507 char *seq = NULL;
20508 int direct = 0;
20509 int style = COMMUNITY_LIST_STANDARD;
20510 int idx = 0;
20511
20512 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20513 seq = argv[idx]->arg;
20514
20515 idx = 0;
20516 argv_find(argv, argc, "(1-99)", &idx);
20517 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20518 cl_name_or_number = argv[idx]->arg;
20519 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20520 : COMMUNITY_DENY;
20521 argv_find(argv, argc, "AA:NN", &idx);
20522 char *str = argv_concat(argv, argc, idx);
20523
20524 int ret = community_list_set(bgp_clist, cl_name_or_number, str, seq,
20525 direct, style);
20526
20527 XFREE(MTYPE_TMP, str);
20528
20529 if (ret < 0) {
20530 /* Display error string. */
20531 community_list_perror(vty, ret);
20532 return CMD_WARNING_CONFIG_FAILED;
20533 }
20534
20535 return CMD_SUCCESS;
20536 }
20537
20538 DEFUN (no_community_list_standard_all,
20539 no_bgp_community_list_standard_all_cmd,
20540 "no bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20541 NO_STR
20542 BGP_STR
20543 COMMUNITY_LIST_STR
20544 "Community list number (standard)\n"
20545 "Add an standard community-list entry\n"
20546 "Community list name\n"
20547 "Sequence number of an entry\n"
20548 "Sequence number\n"
20549 "Specify community to reject\n"
20550 "Specify community to accept\n"
20551 COMMUNITY_VAL_STR)
20552 {
20553 char *cl_name_or_number = NULL;
20554 char *str = NULL;
20555 int direct = 0;
20556 int style = COMMUNITY_LIST_STANDARD;
20557 char *seq = NULL;
20558 int idx = 0;
20559
20560 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20561 seq = argv[idx]->arg;
20562
20563 idx = 0;
20564 argv_find(argv, argc, "permit", &idx);
20565 argv_find(argv, argc, "deny", &idx);
20566
20567 if (idx) {
20568 direct = argv_find(argv, argc, "permit", &idx)
20569 ? COMMUNITY_PERMIT
20570 : COMMUNITY_DENY;
20571
20572 idx = 0;
20573 argv_find(argv, argc, "AA:NN", &idx);
20574 str = argv_concat(argv, argc, idx);
20575 }
20576
20577 idx = 0;
20578 argv_find(argv, argc, "(1-99)", &idx);
20579 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20580 cl_name_or_number = argv[idx]->arg;
20581
20582 int ret = community_list_unset(bgp_clist, cl_name_or_number, str, seq,
20583 direct, style);
20584
20585 XFREE(MTYPE_TMP, str);
20586
20587 if (ret < 0) {
20588 community_list_perror(vty, ret);
20589 return CMD_WARNING_CONFIG_FAILED;
20590 }
20591
20592 return CMD_SUCCESS;
20593 }
20594
20595 ALIAS(no_community_list_standard_all, no_bgp_community_list_standard_all_list_cmd,
20596 "no bgp community-list <(1-99)|standard COMMUNITY_LIST_NAME>",
20597 NO_STR BGP_STR COMMUNITY_LIST_STR
20598 "Community list number (standard)\n"
20599 "Add an standard community-list entry\n"
20600 "Community list name\n")
20601
20602 /*community-list expanded */
20603 DEFUN (community_list_expanded_all,
20604 bgp_community_list_expanded_all_cmd,
20605 "bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20606 BGP_STR
20607 COMMUNITY_LIST_STR
20608 "Community list number (expanded)\n"
20609 "Add an expanded community-list entry\n"
20610 "Community list name\n"
20611 "Sequence number of an entry\n"
20612 "Sequence number\n"
20613 "Specify community to reject\n"
20614 "Specify community to accept\n"
20615 COMMUNITY_VAL_STR)
20616 {
20617 char *cl_name_or_number = NULL;
20618 char *seq = NULL;
20619 int direct = 0;
20620 int style = COMMUNITY_LIST_EXPANDED;
20621 int idx = 0;
20622
20623 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20624 seq = argv[idx]->arg;
20625
20626 idx = 0;
20627
20628 argv_find(argv, argc, "(100-500)", &idx);
20629 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20630 cl_name_or_number = argv[idx]->arg;
20631 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20632 : COMMUNITY_DENY;
20633 argv_find(argv, argc, "AA:NN", &idx);
20634 char *str = argv_concat(argv, argc, idx);
20635
20636 int ret = community_list_set(bgp_clist, cl_name_or_number, str, seq,
20637 direct, style);
20638
20639 XFREE(MTYPE_TMP, str);
20640
20641 if (ret < 0) {
20642 /* Display error string. */
20643 community_list_perror(vty, ret);
20644 return CMD_WARNING_CONFIG_FAILED;
20645 }
20646
20647 return CMD_SUCCESS;
20648 }
20649
20650 DEFUN (no_community_list_expanded_all,
20651 no_bgp_community_list_expanded_all_cmd,
20652 "no bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
20653 NO_STR
20654 BGP_STR
20655 COMMUNITY_LIST_STR
20656 "Community list number (expanded)\n"
20657 "Add an expanded community-list entry\n"
20658 "Community list name\n"
20659 "Sequence number of an entry\n"
20660 "Sequence number\n"
20661 "Specify community to reject\n"
20662 "Specify community to accept\n"
20663 COMMUNITY_VAL_STR)
20664 {
20665 char *cl_name_or_number = NULL;
20666 char *seq = NULL;
20667 char *str = NULL;
20668 int direct = 0;
20669 int style = COMMUNITY_LIST_EXPANDED;
20670 int idx = 0;
20671
20672 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20673 seq = argv[idx]->arg;
20674
20675 idx = 0;
20676 argv_find(argv, argc, "permit", &idx);
20677 argv_find(argv, argc, "deny", &idx);
20678
20679 if (idx) {
20680 direct = argv_find(argv, argc, "permit", &idx)
20681 ? COMMUNITY_PERMIT
20682 : COMMUNITY_DENY;
20683
20684 idx = 0;
20685 argv_find(argv, argc, "AA:NN", &idx);
20686 str = argv_concat(argv, argc, idx);
20687 }
20688
20689 idx = 0;
20690 argv_find(argv, argc, "(100-500)", &idx);
20691 argv_find(argv, argc, "COMMUNITY_LIST_NAME", &idx);
20692 cl_name_or_number = argv[idx]->arg;
20693
20694 int ret = community_list_unset(bgp_clist, cl_name_or_number, str, seq,
20695 direct, style);
20696
20697 XFREE(MTYPE_TMP, str);
20698
20699 if (ret < 0) {
20700 community_list_perror(vty, ret);
20701 return CMD_WARNING_CONFIG_FAILED;
20702 }
20703
20704 return CMD_SUCCESS;
20705 }
20706
20707 ALIAS(no_community_list_expanded_all,
20708 no_bgp_community_list_expanded_all_list_cmd,
20709 "no bgp community-list <(100-500)|expanded COMMUNITY_LIST_NAME>",
20710 NO_STR BGP_STR COMMUNITY_LIST_STR
20711 "Community list number (expanded)\n"
20712 "Add an expanded community-list entry\n"
20713 "Community list name\n")
20714
20715 /* Return configuration string of community-list entry. */
20716 static const char *community_list_config_str(struct community_entry *entry)
20717 {
20718 const char *str;
20719
20720 if (entry->any)
20721 str = "";
20722 else {
20723 if (entry->style == COMMUNITY_LIST_STANDARD)
20724 str = community_str(entry->u.com, false, false);
20725 else if (entry->style == LARGE_COMMUNITY_LIST_STANDARD)
20726 str = lcommunity_str(entry->u.lcom, false, false);
20727 else
20728 str = entry->config;
20729 }
20730 return str;
20731 }
20732
20733 static void community_list_show(struct vty *vty, struct community_list *list)
20734 {
20735 struct community_entry *entry;
20736
20737 for (entry = list->head; entry; entry = entry->next) {
20738 if (entry == list->head) {
20739 if (all_digit(list->name))
20740 vty_out(vty, "Community %s list %s\n",
20741 entry->style == COMMUNITY_LIST_STANDARD
20742 ? "standard"
20743 : "(expanded) access",
20744 list->name);
20745 else
20746 vty_out(vty, "Named Community %s list %s\n",
20747 entry->style == COMMUNITY_LIST_STANDARD
20748 ? "standard"
20749 : "expanded",
20750 list->name);
20751 }
20752 if (entry->any)
20753 vty_out(vty, " %s\n",
20754 community_direct_str(entry->direct));
20755 else
20756 vty_out(vty, " %s %s\n",
20757 community_direct_str(entry->direct),
20758 community_list_config_str(entry));
20759 }
20760 }
20761
20762 DEFUN (show_community_list,
20763 show_bgp_community_list_cmd,
20764 "show bgp community-list",
20765 SHOW_STR
20766 BGP_STR
20767 "List community-list\n")
20768 {
20769 struct community_list *list;
20770 struct community_list_master *cm;
20771
20772 cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
20773 if (!cm)
20774 return CMD_SUCCESS;
20775
20776 for (list = cm->num.head; list; list = list->next)
20777 community_list_show(vty, list);
20778
20779 for (list = cm->str.head; list; list = list->next)
20780 community_list_show(vty, list);
20781
20782 return CMD_SUCCESS;
20783 }
20784
20785 DEFUN (show_community_list_arg,
20786 show_bgp_community_list_arg_cmd,
20787 "show bgp community-list <(1-500)|COMMUNITY_LIST_NAME> detail",
20788 SHOW_STR
20789 BGP_STR
20790 "List community-list\n"
20791 "Community-list number\n"
20792 "Community-list name\n"
20793 "Detailed information on community-list\n")
20794 {
20795 int idx_comm_list = 3;
20796 struct community_list *list;
20797
20798 list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
20799 COMMUNITY_LIST_MASTER);
20800 if (!list) {
20801 vty_out(vty, "%% Can't find community-list\n");
20802 return CMD_WARNING;
20803 }
20804
20805 community_list_show(vty, list);
20806
20807 return CMD_SUCCESS;
20808 }
20809
20810 /*
20811 * Large Community code.
20812 */
20813 static int lcommunity_list_set_vty(struct vty *vty, int argc,
20814 struct cmd_token **argv, int style,
20815 int reject_all_digit_name)
20816 {
20817 int ret;
20818 int direct;
20819 char *str;
20820 int idx = 0;
20821 char *cl_name;
20822 char *seq = NULL;
20823
20824 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20825 seq = argv[idx]->arg;
20826
20827 idx = 0;
20828 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
20829 : COMMUNITY_DENY;
20830
20831 /* All digit name check. */
20832 idx = 0;
20833 argv_find(argv, argc, "LCOMMUNITY_LIST_NAME", &idx);
20834 argv_find(argv, argc, "(1-99)", &idx);
20835 argv_find(argv, argc, "(100-500)", &idx);
20836 cl_name = argv[idx]->arg;
20837 if (reject_all_digit_name && all_digit(cl_name)) {
20838 vty_out(vty, "%% Community name cannot have all digits\n");
20839 return CMD_WARNING_CONFIG_FAILED;
20840 }
20841
20842 idx = 0;
20843 argv_find(argv, argc, "AA:BB:CC", &idx);
20844 argv_find(argv, argc, "LINE", &idx);
20845 /* Concat community string argument. */
20846 if (idx)
20847 str = argv_concat(argv, argc, idx);
20848 else
20849 str = NULL;
20850
20851 ret = lcommunity_list_set(bgp_clist, cl_name, str, seq, direct, style);
20852
20853 /* Free temporary community list string allocated by
20854 argv_concat(). */
20855 XFREE(MTYPE_TMP, str);
20856
20857 if (ret < 0) {
20858 community_list_perror(vty, ret);
20859 return CMD_WARNING_CONFIG_FAILED;
20860 }
20861 return CMD_SUCCESS;
20862 }
20863
20864 static int lcommunity_list_unset_vty(struct vty *vty, int argc,
20865 struct cmd_token **argv, int style)
20866 {
20867 int ret;
20868 int direct = 0;
20869 char *str = NULL;
20870 int idx = 0;
20871 char *seq = NULL;
20872
20873 if (argv_find(argv, argc, "(0-4294967295)", &idx))
20874 seq = argv[idx]->arg;
20875
20876 idx = 0;
20877 argv_find(argv, argc, "permit", &idx);
20878 argv_find(argv, argc, "deny", &idx);
20879
20880 if (idx) {
20881 /* Check the list direct. */
20882 if (strncmp(argv[idx]->arg, "p", 1) == 0)
20883 direct = COMMUNITY_PERMIT;
20884 else
20885 direct = COMMUNITY_DENY;
20886
20887 idx = 0;
20888 argv_find(argv, argc, "LINE", &idx);
20889 argv_find(argv, argc, "AA:AA:NN", &idx);
20890 /* Concat community string argument. */
20891 str = argv_concat(argv, argc, idx);
20892 }
20893
20894 idx = 0;
20895 argv_find(argv, argc, "(1-99)", &idx);
20896 argv_find(argv, argc, "(100-500)", &idx);
20897 argv_find(argv, argc, "LCOMMUNITY_LIST_NAME", &idx);
20898
20899 /* Unset community list. */
20900 ret = lcommunity_list_unset(bgp_clist, argv[idx]->arg, str, seq, direct,
20901 style);
20902
20903 /* Free temporary community list string allocated by
20904 argv_concat(). */
20905 XFREE(MTYPE_TMP, str);
20906
20907 if (ret < 0) {
20908 community_list_perror(vty, ret);
20909 return CMD_WARNING_CONFIG_FAILED;
20910 }
20911
20912 return CMD_SUCCESS;
20913 }
20914
20915 /* "large-community-list" keyword help string. */
20916 #define LCOMMUNITY_LIST_STR "Add a large community list entry\n"
20917 #define LCOMMUNITY_VAL_STR "large community in 'aa:bb:cc' format\n"
20918
20919 DEFUN (lcommunity_list_standard,
20920 bgp_lcommunity_list_standard_cmd,
20921 "bgp large-community-list (1-99) [seq (0-4294967295)] <deny|permit> AA:BB:CC...",
20922 BGP_STR
20923 LCOMMUNITY_LIST_STR
20924 "Large Community list number (standard)\n"
20925 "Sequence number of an entry\n"
20926 "Sequence number\n"
20927 "Specify large community to reject\n"
20928 "Specify large community to accept\n"
20929 LCOMMUNITY_VAL_STR)
20930 {
20931 return lcommunity_list_set_vty(vty, argc, argv,
20932 LARGE_COMMUNITY_LIST_STANDARD, 0);
20933 }
20934
20935 DEFUN (lcommunity_list_expanded,
20936 bgp_lcommunity_list_expanded_cmd,
20937 "bgp large-community-list (100-500) [seq (0-4294967295)] <deny|permit> LINE...",
20938 BGP_STR
20939 LCOMMUNITY_LIST_STR
20940 "Large Community list number (expanded)\n"
20941 "Sequence number of an entry\n"
20942 "Sequence number\n"
20943 "Specify large community to reject\n"
20944 "Specify large community to accept\n"
20945 "An ordered list as a regular-expression\n")
20946 {
20947 return lcommunity_list_set_vty(vty, argc, argv,
20948 LARGE_COMMUNITY_LIST_EXPANDED, 0);
20949 }
20950
20951 DEFUN (lcommunity_list_name_standard,
20952 bgp_lcommunity_list_name_standard_cmd,
20953 "bgp large-community-list standard LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> AA:BB:CC...",
20954 BGP_STR
20955 LCOMMUNITY_LIST_STR
20956 "Specify standard large-community-list\n"
20957 "Large Community list name\n"
20958 "Sequence number of an entry\n"
20959 "Sequence number\n"
20960 "Specify large community to reject\n"
20961 "Specify large community to accept\n"
20962 LCOMMUNITY_VAL_STR)
20963 {
20964 return lcommunity_list_set_vty(vty, argc, argv,
20965 LARGE_COMMUNITY_LIST_STANDARD, 1);
20966 }
20967
20968 DEFUN (lcommunity_list_name_expanded,
20969 bgp_lcommunity_list_name_expanded_cmd,
20970 "bgp large-community-list expanded LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> LINE...",
20971 BGP_STR
20972 LCOMMUNITY_LIST_STR
20973 "Specify expanded large-community-list\n"
20974 "Large Community list name\n"
20975 "Sequence number of an entry\n"
20976 "Sequence number\n"
20977 "Specify large community to reject\n"
20978 "Specify large community to accept\n"
20979 "An ordered list as a regular-expression\n")
20980 {
20981 return lcommunity_list_set_vty(vty, argc, argv,
20982 LARGE_COMMUNITY_LIST_EXPANDED, 1);
20983 }
20984
20985 DEFUN (no_lcommunity_list_all,
20986 no_bgp_lcommunity_list_all_cmd,
20987 "no bgp large-community-list <(1-99)|(100-500)|LCOMMUNITY_LIST_NAME>",
20988 NO_STR
20989 BGP_STR
20990 LCOMMUNITY_LIST_STR
20991 "Large Community list number (standard)\n"
20992 "Large Community list number (expanded)\n"
20993 "Large Community list name\n")
20994 {
20995 return lcommunity_list_unset_vty(vty, argc, argv,
20996 LARGE_COMMUNITY_LIST_STANDARD);
20997 }
20998
20999 DEFUN (no_lcommunity_list_name_standard_all,
21000 no_bgp_lcommunity_list_name_standard_all_cmd,
21001 "no bgp large-community-list standard LCOMMUNITY_LIST_NAME",
21002 NO_STR
21003 BGP_STR
21004 LCOMMUNITY_LIST_STR
21005 "Specify standard large-community-list\n"
21006 "Large Community list name\n")
21007 {
21008 return lcommunity_list_unset_vty(vty, argc, argv,
21009 LARGE_COMMUNITY_LIST_STANDARD);
21010 }
21011
21012 DEFUN (no_lcommunity_list_name_expanded_all,
21013 no_bgp_lcommunity_list_name_expanded_all_cmd,
21014 "no bgp large-community-list expanded LCOMMUNITY_LIST_NAME",
21015 NO_STR
21016 BGP_STR
21017 LCOMMUNITY_LIST_STR
21018 "Specify expanded large-community-list\n"
21019 "Large Community list name\n")
21020 {
21021 return lcommunity_list_unset_vty(vty, argc, argv,
21022 LARGE_COMMUNITY_LIST_EXPANDED);
21023 }
21024
21025 DEFUN (no_lcommunity_list_standard,
21026 no_bgp_lcommunity_list_standard_cmd,
21027 "no bgp large-community-list (1-99) [seq (0-4294967295)] <deny|permit> AA:AA:NN...",
21028 NO_STR
21029 BGP_STR
21030 LCOMMUNITY_LIST_STR
21031 "Large Community list number (standard)\n"
21032 "Sequence number of an entry\n"
21033 "Sequence number\n"
21034 "Specify large community to reject\n"
21035 "Specify large community to accept\n"
21036 LCOMMUNITY_VAL_STR)
21037 {
21038 return lcommunity_list_unset_vty(vty, argc, argv,
21039 LARGE_COMMUNITY_LIST_STANDARD);
21040 }
21041
21042 DEFUN (no_lcommunity_list_expanded,
21043 no_bgp_lcommunity_list_expanded_cmd,
21044 "no bgp large-community-list (100-500) [seq (0-4294967295)] <deny|permit> LINE...",
21045 NO_STR
21046 BGP_STR
21047 LCOMMUNITY_LIST_STR
21048 "Large Community list number (expanded)\n"
21049 "Sequence number of an entry\n"
21050 "Sequence number\n"
21051 "Specify large community to reject\n"
21052 "Specify large community to accept\n"
21053 "An ordered list as a regular-expression\n")
21054 {
21055 return lcommunity_list_unset_vty(vty, argc, argv,
21056 LARGE_COMMUNITY_LIST_EXPANDED);
21057 }
21058
21059 DEFUN (no_lcommunity_list_name_standard,
21060 no_bgp_lcommunity_list_name_standard_cmd,
21061 "no bgp large-community-list standard LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> AA:AA:NN...",
21062 NO_STR
21063 BGP_STR
21064 LCOMMUNITY_LIST_STR
21065 "Specify standard large-community-list\n"
21066 "Large Community list name\n"
21067 "Sequence number of an entry\n"
21068 "Sequence number\n"
21069 "Specify large community to reject\n"
21070 "Specify large community to accept\n"
21071 LCOMMUNITY_VAL_STR)
21072 {
21073 return lcommunity_list_unset_vty(vty, argc, argv,
21074 LARGE_COMMUNITY_LIST_STANDARD);
21075 }
21076
21077 DEFUN (no_lcommunity_list_name_expanded,
21078 no_bgp_lcommunity_list_name_expanded_cmd,
21079 "no bgp large-community-list expanded LCOMMUNITY_LIST_NAME [seq (0-4294967295)] <deny|permit> LINE...",
21080 NO_STR
21081 BGP_STR
21082 LCOMMUNITY_LIST_STR
21083 "Specify expanded large-community-list\n"
21084 "Large community list name\n"
21085 "Sequence number of an entry\n"
21086 "Sequence number\n"
21087 "Specify large community to reject\n"
21088 "Specify large community to accept\n"
21089 "An ordered list as a regular-expression\n")
21090 {
21091 return lcommunity_list_unset_vty(vty, argc, argv,
21092 LARGE_COMMUNITY_LIST_EXPANDED);
21093 }
21094
21095 static void lcommunity_list_show(struct vty *vty, struct community_list *list)
21096 {
21097 struct community_entry *entry;
21098
21099 for (entry = list->head; entry; entry = entry->next) {
21100 if (entry == list->head) {
21101 if (all_digit(list->name))
21102 vty_out(vty, "Large community %s list %s\n",
21103 entry->style ==
21104 LARGE_COMMUNITY_LIST_STANDARD
21105 ? "standard"
21106 : "(expanded) access",
21107 list->name);
21108 else
21109 vty_out(vty,
21110 "Named large community %s list %s\n",
21111 entry->style ==
21112 LARGE_COMMUNITY_LIST_STANDARD
21113 ? "standard"
21114 : "expanded",
21115 list->name);
21116 }
21117 if (entry->any)
21118 vty_out(vty, " %s\n",
21119 community_direct_str(entry->direct));
21120 else
21121 vty_out(vty, " %s %s\n",
21122 community_direct_str(entry->direct),
21123 community_list_config_str(entry));
21124 }
21125 }
21126
21127 DEFUN (show_lcommunity_list,
21128 show_bgp_lcommunity_list_cmd,
21129 "show bgp large-community-list",
21130 SHOW_STR
21131 BGP_STR
21132 "List large-community list\n")
21133 {
21134 struct community_list *list;
21135 struct community_list_master *cm;
21136
21137 cm = community_list_master_lookup(bgp_clist,
21138 LARGE_COMMUNITY_LIST_MASTER);
21139 if (!cm)
21140 return CMD_SUCCESS;
21141
21142 for (list = cm->num.head; list; list = list->next)
21143 lcommunity_list_show(vty, list);
21144
21145 for (list = cm->str.head; list; list = list->next)
21146 lcommunity_list_show(vty, list);
21147
21148 return CMD_SUCCESS;
21149 }
21150
21151 DEFUN (show_lcommunity_list_arg,
21152 show_bgp_lcommunity_list_arg_cmd,
21153 "show bgp large-community-list <(1-500)|LCOMMUNITY_LIST_NAME> detail",
21154 SHOW_STR
21155 BGP_STR
21156 "List large-community list\n"
21157 "Large-community-list number\n"
21158 "Large-community-list name\n"
21159 "Detailed information on large-community-list\n")
21160 {
21161 struct community_list *list;
21162
21163 list = community_list_lookup(bgp_clist, argv[3]->arg, 0,
21164 LARGE_COMMUNITY_LIST_MASTER);
21165 if (!list) {
21166 vty_out(vty, "%% Can't find large-community-list\n");
21167 return CMD_WARNING;
21168 }
21169
21170 lcommunity_list_show(vty, list);
21171
21172 return CMD_SUCCESS;
21173 }
21174
21175 /* "extcommunity-list" keyword help string. */
21176 #define EXTCOMMUNITY_LIST_STR "Add a extended community list entry\n"
21177 #define EXTCOMMUNITY_VAL_STR "Extended community attribute in 'rt aa:nn_or_IPaddr:nn' OR 'soo aa:nn_or_IPaddr:nn' format\n"
21178
21179 DEFUN (extcommunity_list_standard,
21180 bgp_extcommunity_list_standard_cmd,
21181 "bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
21182 BGP_STR
21183 EXTCOMMUNITY_LIST_STR
21184 "Extended Community list number (standard)\n"
21185 "Specify standard extcommunity-list\n"
21186 "Community list name\n"
21187 "Sequence number of an entry\n"
21188 "Sequence number\n"
21189 "Specify community to reject\n"
21190 "Specify community to accept\n"
21191 EXTCOMMUNITY_VAL_STR)
21192 {
21193 int style = EXTCOMMUNITY_LIST_STANDARD;
21194 int direct = 0;
21195 char *cl_number_or_name = NULL;
21196 char *seq = NULL;
21197
21198 int idx = 0;
21199
21200 argv_find(argv, argc, "(1-99)", &idx);
21201 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
21202 cl_number_or_name = argv[idx]->arg;
21203
21204 if (argv_find(argv, argc, "(0-4294967295)", &idx))
21205 seq = argv[idx]->arg;
21206
21207 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
21208 : COMMUNITY_DENY;
21209 argv_find(argv, argc, "AA:NN", &idx);
21210 char *str = argv_concat(argv, argc, idx);
21211
21212 int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str, seq,
21213 direct, style);
21214
21215 XFREE(MTYPE_TMP, str);
21216
21217 if (ret < 0) {
21218 community_list_perror(vty, ret);
21219 return CMD_WARNING_CONFIG_FAILED;
21220 }
21221
21222 return CMD_SUCCESS;
21223 }
21224
21225 DEFUN (extcommunity_list_name_expanded,
21226 bgp_extcommunity_list_name_expanded_cmd,
21227 "bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> LINE...",
21228 BGP_STR
21229 EXTCOMMUNITY_LIST_STR
21230 "Extended Community list number (expanded)\n"
21231 "Specify expanded extcommunity-list\n"
21232 "Extended Community list name\n"
21233 "Sequence number of an entry\n"
21234 "Sequence number\n"
21235 "Specify community to reject\n"
21236 "Specify community to accept\n"
21237 "An ordered list as a regular-expression\n")
21238 {
21239 int style = EXTCOMMUNITY_LIST_EXPANDED;
21240 int direct = 0;
21241 char *cl_number_or_name = NULL;
21242 char *seq = NULL;
21243 int idx = 0;
21244
21245 argv_find(argv, argc, "(100-500)", &idx);
21246 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
21247 cl_number_or_name = argv[idx]->arg;
21248
21249 if (argv_find(argv, argc, "(0-4294967295)", &idx))
21250 seq = argv[idx]->arg;
21251
21252 direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
21253 : COMMUNITY_DENY;
21254 argv_find(argv, argc, "LINE", &idx);
21255 char *str = argv_concat(argv, argc, idx);
21256
21257 int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str, seq,
21258 direct, style);
21259
21260 XFREE(MTYPE_TMP, str);
21261
21262 if (ret < 0) {
21263 community_list_perror(vty, ret);
21264 return CMD_WARNING_CONFIG_FAILED;
21265 }
21266
21267 return CMD_SUCCESS;
21268 }
21269
21270 DEFUN (no_extcommunity_list_standard_all,
21271 no_bgp_extcommunity_list_standard_all_cmd,
21272 "no bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> AA:NN...",
21273 NO_STR
21274 BGP_STR
21275 EXTCOMMUNITY_LIST_STR
21276 "Extended Community list number (standard)\n"
21277 "Specify standard extcommunity-list\n"
21278 "Community list name\n"
21279 "Sequence number of an entry\n"
21280 "Sequence number\n"
21281 "Specify community to reject\n"
21282 "Specify community to accept\n"
21283 EXTCOMMUNITY_VAL_STR)
21284 {
21285 int style = EXTCOMMUNITY_LIST_STANDARD;
21286 int direct = 0;
21287 char *cl_number_or_name = NULL;
21288 char *str = NULL;
21289 char *seq = NULL;
21290 int idx = 0;
21291
21292 if (argv_find(argv, argc, "(0-4294967295)", &idx))
21293 seq = argv[idx]->arg;
21294
21295 idx = 0;
21296 argv_find(argv, argc, "permit", &idx);
21297 argv_find(argv, argc, "deny", &idx);
21298 if (idx) {
21299 direct = argv_find(argv, argc, "permit", &idx)
21300 ? COMMUNITY_PERMIT
21301 : COMMUNITY_DENY;
21302
21303 idx = 0;
21304 argv_find(argv, argc, "AA:NN", &idx);
21305 str = argv_concat(argv, argc, idx);
21306 }
21307
21308 idx = 0;
21309 argv_find(argv, argc, "(1-99)", &idx);
21310 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
21311 cl_number_or_name = argv[idx]->arg;
21312
21313 int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
21314 seq, direct, style);
21315
21316 XFREE(MTYPE_TMP, str);
21317
21318 if (ret < 0) {
21319 community_list_perror(vty, ret);
21320 return CMD_WARNING_CONFIG_FAILED;
21321 }
21322
21323 return CMD_SUCCESS;
21324 }
21325
21326 ALIAS(no_extcommunity_list_standard_all,
21327 no_bgp_extcommunity_list_standard_all_list_cmd,
21328 "no bgp extcommunity-list <(1-99)|standard EXTCOMMUNITY_LIST_NAME>",
21329 NO_STR BGP_STR EXTCOMMUNITY_LIST_STR
21330 "Extended Community list number (standard)\n"
21331 "Specify standard extcommunity-list\n"
21332 "Community list name\n")
21333
21334 DEFUN (no_extcommunity_list_expanded_all,
21335 no_bgp_extcommunity_list_expanded_all_cmd,
21336 "no bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME> [seq (0-4294967295)] <deny|permit> LINE...",
21337 NO_STR
21338 BGP_STR
21339 EXTCOMMUNITY_LIST_STR
21340 "Extended Community list number (expanded)\n"
21341 "Specify expanded extcommunity-list\n"
21342 "Extended Community list name\n"
21343 "Sequence number of an entry\n"
21344 "Sequence number\n"
21345 "Specify community to reject\n"
21346 "Specify community to accept\n"
21347 "An ordered list as a regular-expression\n")
21348 {
21349 int style = EXTCOMMUNITY_LIST_EXPANDED;
21350 int direct = 0;
21351 char *cl_number_or_name = NULL;
21352 char *str = NULL;
21353 char *seq = NULL;
21354 int idx = 0;
21355
21356 if (argv_find(argv, argc, "(0-4294967295)", &idx))
21357 seq = argv[idx]->arg;
21358
21359 idx = 0;
21360 argv_find(argv, argc, "permit", &idx);
21361 argv_find(argv, argc, "deny", &idx);
21362
21363 if (idx) {
21364 direct = argv_find(argv, argc, "permit", &idx)
21365 ? COMMUNITY_PERMIT
21366 : COMMUNITY_DENY;
21367
21368 idx = 0;
21369 argv_find(argv, argc, "LINE", &idx);
21370 str = argv_concat(argv, argc, idx);
21371 }
21372
21373 idx = 0;
21374 argv_find(argv, argc, "(100-500)", &idx);
21375 argv_find(argv, argc, "EXTCOMMUNITY_LIST_NAME", &idx);
21376 cl_number_or_name = argv[idx]->arg;
21377
21378 int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
21379 seq, direct, style);
21380
21381 XFREE(MTYPE_TMP, str);
21382
21383 if (ret < 0) {
21384 community_list_perror(vty, ret);
21385 return CMD_WARNING_CONFIG_FAILED;
21386 }
21387
21388 return CMD_SUCCESS;
21389 }
21390
21391 ALIAS(no_extcommunity_list_expanded_all,
21392 no_bgp_extcommunity_list_expanded_all_list_cmd,
21393 "no bgp extcommunity-list <(100-500)|expanded EXTCOMMUNITY_LIST_NAME>",
21394 NO_STR BGP_STR EXTCOMMUNITY_LIST_STR
21395 "Extended Community list number (expanded)\n"
21396 "Specify expanded extcommunity-list\n"
21397 "Extended Community list name\n")
21398
21399 static void extcommunity_list_show(struct vty *vty, struct community_list *list)
21400 {
21401 struct community_entry *entry;
21402
21403 for (entry = list->head; entry; entry = entry->next) {
21404 if (entry == list->head) {
21405 if (all_digit(list->name))
21406 vty_out(vty, "Extended community %s list %s\n",
21407 entry->style == EXTCOMMUNITY_LIST_STANDARD
21408 ? "standard"
21409 : "(expanded) access",
21410 list->name);
21411 else
21412 vty_out(vty,
21413 "Named extended community %s list %s\n",
21414 entry->style == EXTCOMMUNITY_LIST_STANDARD
21415 ? "standard"
21416 : "expanded",
21417 list->name);
21418 }
21419 if (entry->any)
21420 vty_out(vty, " %s\n",
21421 community_direct_str(entry->direct));
21422 else
21423 vty_out(vty, " %s %s\n",
21424 community_direct_str(entry->direct),
21425 community_list_config_str(entry));
21426 }
21427 }
21428
21429 DEFUN (show_extcommunity_list,
21430 show_bgp_extcommunity_list_cmd,
21431 "show bgp extcommunity-list",
21432 SHOW_STR
21433 BGP_STR
21434 "List extended-community list\n")
21435 {
21436 struct community_list *list;
21437 struct community_list_master *cm;
21438
21439 cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
21440 if (!cm)
21441 return CMD_SUCCESS;
21442
21443 for (list = cm->num.head; list; list = list->next)
21444 extcommunity_list_show(vty, list);
21445
21446 for (list = cm->str.head; list; list = list->next)
21447 extcommunity_list_show(vty, list);
21448
21449 return CMD_SUCCESS;
21450 }
21451
21452 DEFUN (show_extcommunity_list_arg,
21453 show_bgp_extcommunity_list_arg_cmd,
21454 "show bgp extcommunity-list <(1-500)|EXTCOMMUNITY_LIST_NAME> detail",
21455 SHOW_STR
21456 BGP_STR
21457 "List extended-community list\n"
21458 "Extcommunity-list number\n"
21459 "Extcommunity-list name\n"
21460 "Detailed information on extcommunity-list\n")
21461 {
21462 int idx_comm_list = 3;
21463 struct community_list *list;
21464
21465 list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
21466 EXTCOMMUNITY_LIST_MASTER);
21467 if (!list) {
21468 vty_out(vty, "%% Can't find extcommunity-list\n");
21469 return CMD_WARNING;
21470 }
21471
21472 extcommunity_list_show(vty, list);
21473
21474 return CMD_SUCCESS;
21475 }
21476
21477 /* Display community-list and extcommunity-list configuration. */
21478 static int community_list_config_write(struct vty *vty)
21479 {
21480 struct community_list *list;
21481 struct community_entry *entry;
21482 struct community_list_master *cm;
21483 int write = 0;
21484
21485 /* Community-list. */
21486 cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
21487
21488 for (list = cm->num.head; list; list = list->next)
21489 for (entry = list->head; entry; entry = entry->next) {
21490 vty_out(vty,
21491 "bgp community-list %s seq %" PRId64 " %s %s\n",
21492 list->name, entry->seq,
21493 community_direct_str(entry->direct),
21494 community_list_config_str(entry));
21495 write++;
21496 }
21497 for (list = cm->str.head; list; list = list->next)
21498 for (entry = list->head; entry; entry = entry->next) {
21499 vty_out(vty,
21500 "bgp community-list %s %s seq %" PRId64 " %s %s\n",
21501 entry->style == COMMUNITY_LIST_STANDARD
21502 ? "standard"
21503 : "expanded",
21504 list->name, entry->seq,
21505 community_direct_str(entry->direct),
21506 community_list_config_str(entry));
21507 write++;
21508 }
21509
21510 /* Extcommunity-list. */
21511 cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
21512
21513 for (list = cm->num.head; list; list = list->next)
21514 for (entry = list->head; entry; entry = entry->next) {
21515 vty_out(vty,
21516 "bgp extcommunity-list %s seq %" PRId64 " %s %s\n",
21517 list->name, entry->seq,
21518 community_direct_str(entry->direct),
21519 community_list_config_str(entry));
21520 write++;
21521 }
21522 for (list = cm->str.head; list; list = list->next)
21523 for (entry = list->head; entry; entry = entry->next) {
21524 vty_out(vty,
21525 "bgp extcommunity-list %s %s seq %" PRId64" %s %s\n",
21526 entry->style == EXTCOMMUNITY_LIST_STANDARD
21527 ? "standard"
21528 : "expanded",
21529 list->name, entry->seq,
21530 community_direct_str(entry->direct),
21531 community_list_config_str(entry));
21532 write++;
21533 }
21534
21535
21536 /* lcommunity-list. */
21537 cm = community_list_master_lookup(bgp_clist,
21538 LARGE_COMMUNITY_LIST_MASTER);
21539
21540 for (list = cm->num.head; list; list = list->next)
21541 for (entry = list->head; entry; entry = entry->next) {
21542 vty_out(vty,
21543 "bgp large-community-list %s seq %" PRId64" %s %s\n",
21544 list->name, entry->seq,
21545 community_direct_str(entry->direct),
21546 community_list_config_str(entry));
21547 write++;
21548 }
21549 for (list = cm->str.head; list; list = list->next)
21550 for (entry = list->head; entry; entry = entry->next) {
21551 vty_out(vty,
21552 "bgp large-community-list %s %s seq %" PRId64" %s %s\n",
21553
21554 entry->style == LARGE_COMMUNITY_LIST_STANDARD
21555 ? "standard"
21556 : "expanded",
21557 list->name, entry->seq, community_direct_str(entry->direct),
21558 community_list_config_str(entry));
21559 write++;
21560 }
21561
21562 return write;
21563 }
21564
21565 static int community_list_config_write(struct vty *vty);
21566 static struct cmd_node community_list_node = {
21567 .name = "community list",
21568 .node = COMMUNITY_LIST_NODE,
21569 .prompt = "",
21570 .config_write = community_list_config_write,
21571 };
21572
21573 static void community_list_vty(void)
21574 {
21575 install_node(&community_list_node);
21576
21577 /* Community-list. */
21578 install_element(CONFIG_NODE, &bgp_community_list_standard_cmd);
21579 install_element(CONFIG_NODE, &bgp_community_list_expanded_all_cmd);
21580 install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_cmd);
21581 install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_list_cmd);
21582 install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_cmd);
21583 install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_list_cmd);
21584 install_element(VIEW_NODE, &show_bgp_community_list_cmd);
21585 install_element(VIEW_NODE, &show_bgp_community_list_arg_cmd);
21586
21587 /* Extcommunity-list. */
21588 install_element(CONFIG_NODE, &bgp_extcommunity_list_standard_cmd);
21589 install_element(CONFIG_NODE, &bgp_extcommunity_list_name_expanded_cmd);
21590 install_element(CONFIG_NODE, &no_bgp_extcommunity_list_standard_all_cmd);
21591 install_element(CONFIG_NODE,
21592 &no_bgp_extcommunity_list_standard_all_list_cmd);
21593 install_element(CONFIG_NODE, &no_bgp_extcommunity_list_expanded_all_cmd);
21594 install_element(CONFIG_NODE,
21595 &no_bgp_extcommunity_list_expanded_all_list_cmd);
21596 install_element(VIEW_NODE, &show_bgp_extcommunity_list_cmd);
21597 install_element(VIEW_NODE, &show_bgp_extcommunity_list_arg_cmd);
21598
21599 /* Large Community List */
21600 install_element(CONFIG_NODE, &bgp_lcommunity_list_standard_cmd);
21601 install_element(CONFIG_NODE, &bgp_lcommunity_list_expanded_cmd);
21602 install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard_cmd);
21603 install_element(CONFIG_NODE, &bgp_lcommunity_list_name_expanded_cmd);
21604 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_all_cmd);
21605 install_element(CONFIG_NODE,
21606 &no_bgp_lcommunity_list_name_standard_all_cmd);
21607 install_element(CONFIG_NODE,
21608 &no_bgp_lcommunity_list_name_expanded_all_cmd);
21609 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_cmd);
21610 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_expanded_cmd);
21611 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_standard_cmd);
21612 install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_expanded_cmd);
21613 install_element(VIEW_NODE, &show_bgp_lcommunity_list_cmd);
21614 install_element(VIEW_NODE, &show_bgp_lcommunity_list_arg_cmd);
21615
21616 bgp_community_list_command_completion_setup();
21617 }
21618
21619 static struct cmd_node community_alias_node = {
21620 .name = "community alias",
21621 .node = COMMUNITY_ALIAS_NODE,
21622 .prompt = "",
21623 .config_write = bgp_community_alias_write,
21624 };
21625
21626 void community_alias_vty(void)
21627 {
21628 install_node(&community_alias_node);
21629
21630 /* Community-list. */
21631 install_element(CONFIG_NODE, &bgp_community_alias_cmd);
21632
21633 bgp_community_alias_command_completion_setup();
21634 }
FRRouting mirror