1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* BGP open message handling
3 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
19 #include "bgpd/bgpd.h"
20 #include "bgpd/bgp_attr.h"
21 #include "bgpd/bgp_debug.h"
22 #include "bgpd/bgp_errors.h"
23 #include "bgpd/bgp_fsm.h"
24 #include "bgpd/bgp_packet.h"
25 #include "bgpd/bgp_open.h"
26 #include "bgpd/bgp_aspath.h"
27 #include "bgpd/bgp_vty.h"
28 #include "bgpd/bgp_memory.h"
30 static const struct message capcode_str
[] = {
31 {CAPABILITY_CODE_MP
, "MultiProtocol Extensions"},
32 {CAPABILITY_CODE_REFRESH
, "Route Refresh"},
33 {CAPABILITY_CODE_ORF
, "Cooperative Route Filtering"},
34 {CAPABILITY_CODE_RESTART
, "Graceful Restart"},
35 {CAPABILITY_CODE_AS4
, "4-octet AS number"},
36 {CAPABILITY_CODE_ADDPATH
, "AddPath"},
37 {CAPABILITY_CODE_DYNAMIC
, "Dynamic"},
38 {CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding"},
39 {CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)"},
40 {CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)"},
41 {CAPABILITY_CODE_ORF_OLD
, "ORF (Old)"},
42 {CAPABILITY_CODE_FQDN
, "FQDN"},
43 {CAPABILITY_CODE_ENHANCED_RR
, "Enhanced Route Refresh"},
44 {CAPABILITY_CODE_EXT_MESSAGE
, "BGP Extended Message"},
45 {CAPABILITY_CODE_LLGR
, "Long-lived BGP Graceful Restart"},
46 {CAPABILITY_CODE_ROLE
, "Role"},
47 {CAPABILITY_CODE_SOFT_VERSION
, "Software Version"},
50 /* Minimum sizes for length field of each cap (so not inc. the header) */
51 static const size_t cap_minsizes
[] = {
52 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
53 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
54 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
55 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
56 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
57 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
58 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
59 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
60 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
61 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
62 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
63 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
64 [CAPABILITY_CODE_ENHANCED_RR
] = CAPABILITY_CODE_ENHANCED_LEN
,
65 [CAPABILITY_CODE_EXT_MESSAGE
] = CAPABILITY_CODE_EXT_MESSAGE_LEN
,
66 [CAPABILITY_CODE_LLGR
] = CAPABILITY_CODE_LLGR_LEN
,
67 [CAPABILITY_CODE_ROLE
] = CAPABILITY_CODE_ROLE_LEN
,
68 [CAPABILITY_CODE_SOFT_VERSION
] = CAPABILITY_CODE_SOFT_VERSION_LEN
,
71 /* value the capability must be a multiple of.
72 * 0-data capabilities won't be checked against this.
73 * Other capabilities whose data doesn't fall on convenient boundaries for this
74 * table should be set to 1.
76 static const size_t cap_modsizes
[] = {
77 [CAPABILITY_CODE_MP
] = 4,
78 [CAPABILITY_CODE_REFRESH
] = 1,
79 [CAPABILITY_CODE_ORF
] = 1,
80 [CAPABILITY_CODE_RESTART
] = 1,
81 [CAPABILITY_CODE_AS4
] = 4,
82 [CAPABILITY_CODE_ADDPATH
] = 4,
83 [CAPABILITY_CODE_DYNAMIC
] = 1,
84 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
85 [CAPABILITY_CODE_ENHE
] = 6,
86 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
87 [CAPABILITY_CODE_ORF_OLD
] = 1,
88 [CAPABILITY_CODE_FQDN
] = 1,
89 [CAPABILITY_CODE_ENHANCED_RR
] = 1,
90 [CAPABILITY_CODE_EXT_MESSAGE
] = 1,
91 [CAPABILITY_CODE_LLGR
] = 1,
92 [CAPABILITY_CODE_ROLE
] = 1,
93 [CAPABILITY_CODE_SOFT_VERSION
] = 1,
96 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
97 negotiate remote peer supports extentions or not. But if
98 remote-peer doesn't supports negotiation process itself. We would
99 like to do manual configuration.
101 So there is many configurable point. First of all we want set each
102 peer whether we send capability negotiation to the peer or not.
103 Next, if we send capability to the peer we want to set my capability
104 inforation at each peer. */
106 void bgp_capability_vty_out(struct vty
*vty
, struct peer
*peer
, bool use_json
,
107 json_object
*json_neigh
)
111 struct capability_mp_data mpc
;
112 struct capability_header
*hdr
;
113 json_object
*json_cap
= NULL
;
116 json_cap
= json_object_new_object();
118 pnt
= peer
->notify
.data
;
119 end
= pnt
+ peer
->notify
.length
;
122 if (pnt
+ sizeof(struct capability_mp_data
) + 2 > end
)
125 hdr
= (struct capability_header
*)pnt
;
126 if (pnt
+ hdr
->length
+ 2 > end
)
129 memcpy(&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
131 if (hdr
->code
== CAPABILITY_CODE_MP
) {
135 (void)bgp_map_afi_safi_iana2int(ntohs(mpc
.afi
),
136 mpc
.safi
, &afi
, &safi
);
141 json_object_string_add(
143 "capabilityErrorMultiProtocolAfi",
147 json_object_string_add(
149 "capabilityErrorMultiProtocolAfi",
153 json_object_string_add(
155 "capabilityErrorMultiProtocolAfi",
162 "capabilityErrorMultiProtocolAfiUnknown",
168 json_object_string_add(
170 "capabilityErrorMultiProtocolSafi",
174 json_object_string_add(
176 "capabilityErrorMultiProtocolSafi",
179 case SAFI_LABELED_UNICAST
:
180 json_object_string_add(
182 "capabilityErrorMultiProtocolSafi",
186 json_object_string_add(
188 "capabilityErrorMultiProtocolSafi",
192 json_object_string_add(
194 "capabilityErrorMultiProtocolSafi",
198 json_object_string_add(
200 "capabilityErrorMultiProtocolSafi",
204 json_object_string_add(
206 "capabilityErrorMultiProtocolSafi",
213 "capabilityErrorMultiProtocolSafiUnknown",
219 " Capability error for: Multi protocol ");
222 vty_out(vty
, "AFI IPv4, ");
225 vty_out(vty
, "AFI IPv6, ");
228 vty_out(vty
, "AFI L2VPN, ");
232 vty_out(vty
, "AFI Unknown %d, ",
238 vty_out(vty
, "SAFI Unicast");
241 vty_out(vty
, "SAFI Multicast");
243 case SAFI_LABELED_UNICAST
:
244 vty_out(vty
, "SAFI Labeled-unicast");
247 vty_out(vty
, "SAFI MPLS-labeled VPN");
250 vty_out(vty
, "SAFI ENCAP");
253 vty_out(vty
, "SAFI FLOWSPEC");
256 vty_out(vty
, "SAFI EVPN");
260 vty_out(vty
, "SAFI Unknown %d ",
266 } else if (hdr
->code
>= 128) {
270 "capabilityErrorVendorSpecificCapabilityCode",
274 " Capability error: vendor specific capability code %d",
280 "capabilityErrorUnknownCapabilityCode",
284 " Capability error: unknown capability code %d",
287 pnt
+= hdr
->length
+ 2;
290 json_object_object_add(json_neigh
, "capabilityErrors",
294 static void bgp_capability_mp_data(struct stream
*s
,
295 struct capability_mp_data
*mpc
)
297 mpc
->afi
= stream_getw(s
);
298 mpc
->reserved
= stream_getc(s
);
299 mpc
->safi
= stream_getc(s
);
302 /* Set negotiated capability value. */
303 static int bgp_capability_mp(struct peer
*peer
, struct capability_header
*hdr
)
305 struct capability_mp_data mpc
;
306 struct stream
*s
= BGP_INPUT(peer
);
310 /* Verify length is 4 */
311 if (hdr
->length
!= 4) {
313 EC_BGP_CAPABILITY_INVALID_LENGTH
,
314 "MP Cap: Received invalid length %d, non-multiple of 4",
319 bgp_capability_mp_data(s
, &mpc
);
321 if (bgp_debug_neighbor_events(peer
))
322 zlog_debug("%s OPEN has %s capability for afi/safi: %s/%s",
323 peer
->host
, lookup_msg(capcode_str
, hdr
->code
, NULL
),
324 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
326 /* Convert AFI, SAFI to internal values, check. */
327 if (bgp_map_afi_safi_iana2int(mpc
.afi
, mpc
.safi
, &afi
, &safi
))
330 /* Now safi remapped, and afi/safi are valid array indices */
331 peer
->afc_recv
[afi
][safi
] = 1;
333 if (peer
->afc
[afi
][safi
])
334 peer
->afc_nego
[afi
][safi
] = 1;
341 static void bgp_capability_orf_not_support(struct peer
*peer
, iana_afi_t afi
,
342 iana_safi_t safi
, uint8_t type
,
345 if (bgp_debug_neighbor_events(peer
))
347 "%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
348 peer
->host
, afi
, safi
, type
, mode
);
351 static const struct message orf_type_str
[] = {
352 {ORF_TYPE_RESERVED
, "Reserved"},
353 {ORF_TYPE_PREFIX
, "Prefixlist"},
354 {ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)"},
357 static const struct message orf_mode_str
[] = {{ORF_MODE_RECEIVE
, "Receive"},
358 {ORF_MODE_SEND
, "Send"},
359 {ORF_MODE_BOTH
, "Both"},
362 static int bgp_capability_orf_entry(struct peer
*peer
,
363 struct capability_header
*hdr
)
365 struct stream
*s
= BGP_INPUT(peer
);
366 struct capability_mp_data mpc
;
370 iana_safi_t pkt_safi
;
374 uint16_t sm_cap
= 0; /* capability send-mode receive */
375 uint16_t rm_cap
= 0; /* capability receive-mode receive */
378 /* ORF Entry header */
379 bgp_capability_mp_data(s
, &mpc
);
380 num
= stream_getc(s
);
384 if (bgp_debug_neighbor_events(peer
))
385 zlog_debug("%s ORF Cap entry for afi/safi: %s/%s", peer
->host
,
386 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
388 /* Convert AFI, SAFI to internal values, check. */
389 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
391 "%s Addr-family %d/%d not supported. Ignoring the ORF capability",
392 peer
->host
, pkt_afi
, pkt_safi
);
399 /* validate number field */
400 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
402 "%s ORF Capability entry length error, Cap length %u, num %u",
403 peer
->host
, hdr
->length
, num
);
404 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
405 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
409 for (i
= 0; i
< num
; i
++) {
410 type
= stream_getc(s
);
411 mode
= stream_getc(s
);
413 /* ORF Mode error check */
417 case ORF_MODE_RECEIVE
:
420 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
424 /* ORF Type and afi/safi error checks */
425 /* capcode versus type */
427 case CAPABILITY_CODE_ORF
:
429 case ORF_TYPE_RESERVED
:
430 if (bgp_debug_neighbor_events(peer
))
432 "%s Addr-family %d/%d has reserved ORF type, ignoring",
433 peer
->host
, afi
, safi
);
435 case ORF_TYPE_PREFIX
:
438 bgp_capability_orf_not_support(
439 peer
, pkt_afi
, pkt_safi
, type
, mode
);
443 case CAPABILITY_CODE_ORF_OLD
:
445 case ORF_TYPE_RESERVED
:
446 if (bgp_debug_neighbor_events(peer
))
448 "%s Addr-family %d/%d has reserved ORF type, ignoring",
449 peer
->host
, afi
, safi
);
451 case ORF_TYPE_PREFIX_OLD
:
454 bgp_capability_orf_not_support(
455 peer
, pkt_afi
, pkt_safi
, type
, mode
);
460 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
466 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
467 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
468 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
469 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
474 if (bgp_debug_neighbor_events(peer
))
476 "%s OPEN has %s ORF capability as %s for afi/safi: %s/%s",
478 lookup_msg(orf_type_str
, type
, NULL
),
479 lookup_msg(orf_mode_str
, mode
, NULL
),
480 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
482 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
483 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
484 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
485 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
486 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
487 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
489 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
496 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
497 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
500 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
502 case ORF_MODE_RECEIVE
:
503 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
510 static int bgp_capability_restart(struct peer
*peer
,
511 struct capability_header
*caphdr
)
513 struct stream
*s
= BGP_INPUT(peer
);
514 uint16_t restart_flag_time
;
515 size_t end
= stream_get_getp(s
) + caphdr
->length
;
517 /* Verify length is a multiple of 4 */
518 if ((caphdr
->length
- 2) % 4) {
520 EC_BGP_CAPABILITY_INVALID_LENGTH
,
521 "Restart Cap: Received invalid length %d, non-multiple of 4",
526 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
527 restart_flag_time
= stream_getw(s
);
529 /* The most significant bit is defined in [RFC4724] as
530 * the Restart State ("R") bit.
532 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_R_BIT
))
533 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
535 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
537 /* The second most significant bit is defined in this
538 * document as the Graceful Notification ("N") bit.
540 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_N_BIT
))
541 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
543 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
545 UNSET_FLAG(restart_flag_time
, 0xF000);
546 peer
->v_gr_restart
= restart_flag_time
;
548 if (bgp_debug_neighbor_events(peer
)) {
550 "%s Peer has%srestarted. Restart Time: %d, N-bit set: %s",
552 CHECK_FLAG(peer
->cap
,
553 PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
)
557 CHECK_FLAG(peer
->cap
,
558 PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
)
563 while (stream_get_getp(s
) + 4 <= end
) {
566 iana_afi_t pkt_afi
= stream_getw(s
);
567 iana_safi_t pkt_safi
= stream_getc(s
);
568 uint8_t flag
= stream_getc(s
);
570 /* Convert AFI, SAFI to internal values, check. */
571 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
572 if (bgp_debug_neighbor_events(peer
))
574 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Graceful Restart capability for this AFI/SAFI",
575 peer
->host
, iana_afi2str(pkt_afi
),
576 iana_safi2str(pkt_safi
));
577 } else if (!peer
->afc
[afi
][safi
]) {
578 if (bgp_debug_neighbor_events(peer
))
580 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Graceful Restart capability",
581 peer
->host
, iana_afi2str(pkt_afi
),
582 iana_safi2str(pkt_safi
));
584 if (bgp_debug_neighbor_events(peer
))
586 "%s Address family %s is%spreserved",
587 peer
->host
, get_afi_safi_str(afi
, safi
, false),
589 peer
->af_cap
[afi
][safi
],
590 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
594 SET_FLAG(peer
->af_cap
[afi
][safi
],
595 PEER_CAP_RESTART_AF_RCV
);
596 if (CHECK_FLAG(flag
, GRACEFUL_RESTART_F_BIT
))
597 SET_FLAG(peer
->af_cap
[afi
][safi
],
598 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
604 static int bgp_capability_llgr(struct peer
*peer
,
605 struct capability_header
*caphdr
)
607 struct stream
*s
= BGP_INPUT(peer
);
608 size_t end
= stream_get_getp(s
) + caphdr
->length
;
610 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_RCV
);
612 while (stream_get_getp(s
) + 4 <= end
) {
615 iana_afi_t pkt_afi
= stream_getw(s
);
616 iana_safi_t pkt_safi
= stream_getc(s
);
617 uint8_t flags
= stream_getc(s
);
618 uint32_t stale_time
= stream_get3(s
);
620 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
621 if (bgp_debug_neighbor_events(peer
))
623 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Long-lived Graceful Restart capability for this AFI/SAFI",
624 peer
->host
, iana_afi2str(pkt_afi
),
625 iana_safi2str(pkt_safi
));
626 } else if (!peer
->afc
[afi
][safi
]
627 || !CHECK_FLAG(peer
->af_cap
[afi
][safi
],
628 PEER_CAP_RESTART_AF_RCV
)) {
629 if (bgp_debug_neighbor_events(peer
))
631 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Long-lived Graceful Restart capability",
632 peer
->host
, iana_afi2str(pkt_afi
),
633 iana_safi2str(pkt_safi
));
635 if (bgp_debug_neighbor_events(peer
))
637 "%s Addr-family %s/%s(afi/safi) Long-lived Graceful Restart capability stale time %u sec",
638 peer
->host
, iana_afi2str(pkt_afi
),
639 iana_safi2str(pkt_safi
), stale_time
);
641 peer
->llgr
[afi
][safi
].flags
= flags
;
642 peer
->llgr
[afi
][safi
].stale_time
=
643 MIN(stale_time
, peer
->bgp
->llgr_stale_time
);
644 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_RCV
);
651 /* Unlike other capability parsing routines, this one returns 0 on error */
652 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
654 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
656 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
657 flog_err(EC_BGP_PKT_OPEN
,
658 "%s AS4 capability has incorrect data length %d",
659 peer
->host
, hdr
->length
);
663 as_t as4
= stream_getl(BGP_INPUT(peer
));
665 if (BGP_DEBUG(as4
, AS4
))
667 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
672 static int bgp_capability_ext_message(struct peer
*peer
,
673 struct capability_header
*hdr
)
675 if (hdr
->length
!= CAPABILITY_CODE_EXT_MESSAGE_LEN
) {
678 "%s: BGP Extended Message capability has incorrect data length %d",
679 peer
->host
, hdr
->length
);
683 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
);
688 static int bgp_capability_addpath(struct peer
*peer
,
689 struct capability_header
*hdr
)
691 struct stream
*s
= BGP_INPUT(peer
);
692 size_t end
= stream_get_getp(s
) + hdr
->length
;
694 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
696 /* Verify length is a multiple of 4 */
697 if (hdr
->length
% 4) {
699 EC_BGP_CAPABILITY_INVALID_LENGTH
,
700 "Add Path: Received invalid length %d, non-multiple of 4",
705 while (stream_get_getp(s
) + 4 <= end
) {
708 iana_afi_t pkt_afi
= stream_getw(s
);
709 iana_safi_t pkt_safi
= stream_getc(s
);
710 uint8_t send_receive
= stream_getc(s
);
712 if (bgp_debug_neighbor_events(peer
))
714 "%s OPEN has %s capability for afi/safi: %s/%s%s%s",
716 lookup_msg(capcode_str
, hdr
->code
, NULL
),
717 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
),
718 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
720 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
723 /* Convert AFI, SAFI to internal values, check. */
724 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
725 if (bgp_debug_neighbor_events(peer
))
727 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Addpath Attribute for this AFI/SAFI",
728 peer
->host
, iana_afi2str(pkt_afi
),
729 iana_safi2str(pkt_safi
));
731 } else if (!peer
->afc
[afi
][safi
]) {
732 if (bgp_debug_neighbor_events(peer
))
734 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the AddPath capability for this AFI/SAFI",
735 peer
->host
, iana_afi2str(pkt_afi
),
736 iana_safi2str(pkt_safi
));
740 if (send_receive
& BGP_ADDPATH_RX
)
741 SET_FLAG(peer
->af_cap
[afi
][safi
],
742 PEER_CAP_ADDPATH_AF_RX_RCV
);
744 if (send_receive
& BGP_ADDPATH_TX
)
745 SET_FLAG(peer
->af_cap
[afi
][safi
],
746 PEER_CAP_ADDPATH_AF_TX_RCV
);
752 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
754 struct stream
*s
= BGP_INPUT(peer
);
755 size_t end
= stream_get_getp(s
) + hdr
->length
;
757 /* Verify length is a multiple of 4 */
758 if (hdr
->length
% 6) {
760 EC_BGP_CAPABILITY_INVALID_LENGTH
,
761 "Extended NH: Received invalid length %d, non-multiple of 6",
766 while (stream_get_getp(s
) + 6 <= end
) {
767 iana_afi_t pkt_afi
= stream_getw(s
);
769 iana_safi_t pkt_safi
= stream_getw(s
);
771 iana_afi_t pkt_nh_afi
= stream_getw(s
);
774 if (bgp_debug_neighbor_events(peer
))
776 "%s Received with afi/safi/next-hop afi: %s/%s/%u",
777 peer
->host
, iana_afi2str(pkt_afi
),
778 iana_safi2str(pkt_safi
), pkt_nh_afi
);
780 /* Convert AFI, SAFI to internal values, check. */
781 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
782 if (bgp_debug_neighbor_events(peer
))
784 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the ENHE Attribute for this AFI/SAFI",
785 peer
->host
, iana_afi2str(pkt_afi
),
786 iana_safi2str(pkt_safi
));
790 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
792 * the Nexthop AFI being IPv6. A future spec may introduce other
793 * possibilities, so we ignore other values with a log. Also,
795 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
798 nh_afi
= afi_iana2int(pkt_nh_afi
);
800 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
801 || !(safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
802 || safi
== SAFI_LABELED_UNICAST
)) {
804 EC_BGP_CAPABILITY_INVALID_DATA
,
805 "%s Unexpected afi/safi/next-hop afi: %s/%s/%u in Extended Next-hop capability, ignoring",
806 peer
->host
, iana_afi2str(pkt_afi
),
807 iana_safi2str(pkt_safi
), pkt_nh_afi
);
811 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
813 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
814 SET_FLAG(peer
->af_cap
[afi
][safi
],
815 PEER_CAP_ENHE_AF_NEGO
);
818 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
823 static int bgp_capability_hostname(struct peer
*peer
,
824 struct capability_header
*hdr
)
826 struct stream
*s
= BGP_INPUT(peer
);
827 char str
[BGP_MAX_HOSTNAME
+ 1];
828 size_t end
= stream_get_getp(s
) + hdr
->length
;
831 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
833 len
= stream_getc(s
);
834 if (stream_get_getp(s
) + len
> end
) {
836 EC_BGP_CAPABILITY_INVALID_DATA
,
837 "%s: Received malformed hostname capability from peer %s",
838 __func__
, peer
->host
);
842 if (len
> BGP_MAX_HOSTNAME
) {
843 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
844 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
845 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
847 stream_get(str
, s
, len
);
852 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
853 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
855 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
858 if (stream_get_getp(s
) + 1 > end
) {
860 EC_BGP_CAPABILITY_INVALID_DATA
,
861 "%s: Received invalid domain name len (hostname capability) from peer %s",
862 __func__
, peer
->host
);
866 len
= stream_getc(s
);
867 if (stream_get_getp(s
) + len
> end
) {
869 EC_BGP_CAPABILITY_INVALID_DATA
,
870 "%s: Received runt domain name (hostname capability) from peer %s",
871 __func__
, peer
->host
);
875 if (len
> BGP_MAX_HOSTNAME
) {
876 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
877 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
878 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
880 stream_get(str
, s
, len
);
885 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
887 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
890 if (bgp_debug_neighbor_events(peer
)) {
891 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
892 peer
->hostname
, peer
->domainname
);
898 static int bgp_capability_role(struct peer
*peer
, struct capability_header
*hdr
)
900 SET_FLAG(peer
->cap
, PEER_CAP_ROLE_RCV
);
901 if (hdr
->length
!= CAPABILITY_CODE_ROLE_LEN
) {
902 flog_warn(EC_BGP_CAPABILITY_INVALID_LENGTH
,
903 "Role: Received invalid length %d", hdr
->length
);
906 uint8_t role
= stream_getc(BGP_INPUT(peer
));
908 peer
->remote_role
= role
;
912 static int bgp_capability_software_version(struct peer
*peer
,
913 struct capability_header
*hdr
)
915 struct stream
*s
= BGP_INPUT(peer
);
916 char str
[BGP_MAX_SOFT_VERSION
+ 1];
917 size_t end
= stream_get_getp(s
) + hdr
->length
;
920 SET_FLAG(peer
->cap
, PEER_CAP_SOFT_VERSION_RCV
);
922 len
= stream_getc(s
);
923 if (stream_get_getp(s
) + len
> end
) {
925 EC_BGP_CAPABILITY_INVALID_DATA
,
926 "%s: Received malformed Software Version capability from peer %s",
927 __func__
, peer
->host
);
932 stream_get(str
, s
, len
);
935 XFREE(MTYPE_BGP_SOFT_VERSION
, peer
->soft_version
);
937 peer
->soft_version
= XSTRDUP(MTYPE_BGP_SOFT_VERSION
, str
);
939 if (bgp_debug_neighbor_events(peer
))
940 zlog_debug("%s sent Software Version: %s", peer
->host
,
948 * Parse given capability.
949 * XXX: This is reading into a stream, but not using stream API
951 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
952 * capabilities were encountered.
954 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
955 int *mp_capability
, uint8_t **error
)
958 struct stream
*s
= BGP_INPUT(peer
);
959 size_t end
= stream_get_getp(s
) + length
;
960 uint16_t restart_flag_time
= 0;
962 assert(STREAM_READABLE(s
) >= length
);
964 while (stream_get_getp(s
) < end
) {
966 uint8_t *sp
= stream_pnt(s
);
967 struct capability_header caphdr
;
970 /* We need at least capability code and capability length. */
971 if (stream_get_getp(s
) + 2 > end
) {
972 zlog_info("%s Capability length error (< header)",
974 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
975 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
979 caphdr
.code
= stream_getc(s
);
980 caphdr
.length
= stream_getc(s
);
981 start
= stream_get_getp(s
);
983 /* Capability length check sanity check. */
984 if (start
+ caphdr
.length
> end
) {
985 zlog_info("%s Capability length error (< length)",
987 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
988 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
992 if (bgp_debug_neighbor_events(peer
))
993 zlog_debug("%s OPEN has %s capability (%u), length %u",
995 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
996 caphdr
.code
, caphdr
.length
);
998 /* Length sanity check, type-specific, for known capabilities */
999 switch (caphdr
.code
) {
1000 case CAPABILITY_CODE_MP
:
1001 case CAPABILITY_CODE_REFRESH
:
1002 case CAPABILITY_CODE_REFRESH_OLD
:
1003 case CAPABILITY_CODE_ORF
:
1004 case CAPABILITY_CODE_ORF_OLD
:
1005 case CAPABILITY_CODE_RESTART
:
1006 case CAPABILITY_CODE_AS4
:
1007 case CAPABILITY_CODE_ADDPATH
:
1008 case CAPABILITY_CODE_DYNAMIC
:
1009 case CAPABILITY_CODE_DYNAMIC_OLD
:
1010 case CAPABILITY_CODE_ENHE
:
1011 case CAPABILITY_CODE_FQDN
:
1012 case CAPABILITY_CODE_ENHANCED_RR
:
1013 case CAPABILITY_CODE_EXT_MESSAGE
:
1014 case CAPABILITY_CODE_ROLE
:
1015 case CAPABILITY_CODE_SOFT_VERSION
:
1017 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
1019 "%s %s Capability length error: got %u, expected at least %u",
1021 lookup_msg(capcode_str
, caphdr
.code
,
1024 (unsigned)cap_minsizes
[caphdr
.code
]);
1025 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1026 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1030 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
1032 "%s %s Capability length error: got %u, expected a multiple of %u",
1034 lookup_msg(capcode_str
, caphdr
.code
,
1037 (unsigned)cap_modsizes
[caphdr
.code
]);
1038 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1039 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1042 /* we deliberately ignore unknown codes, see below */
1047 switch (caphdr
.code
) {
1048 case CAPABILITY_CODE_MP
: {
1051 /* Ignore capability when override-capability is set. */
1052 if (!CHECK_FLAG(peer
->flags
,
1053 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1054 /* Set negotiated value. */
1055 ret
= bgp_capability_mp(peer
, &caphdr
);
1057 /* Unsupported Capability. */
1059 /* Store return data. */
1060 memcpy(*error
, sp
, caphdr
.length
+ 2);
1061 *error
+= caphdr
.length
+ 2;
1063 ret
= 0; /* Don't return error for this */
1066 case CAPABILITY_CODE_ENHANCED_RR
:
1067 case CAPABILITY_CODE_REFRESH
:
1068 case CAPABILITY_CODE_REFRESH_OLD
: {
1069 /* BGP refresh capability */
1070 if (caphdr
.code
== CAPABILITY_CODE_ENHANCED_RR
)
1071 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_RCV
);
1072 else if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
1073 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
1075 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
1077 case CAPABILITY_CODE_ORF
:
1078 case CAPABILITY_CODE_ORF_OLD
:
1079 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
1081 case CAPABILITY_CODE_RESTART
:
1082 ret
= bgp_capability_restart(peer
, &caphdr
);
1084 case CAPABILITY_CODE_LLGR
:
1085 ret
= bgp_capability_llgr(peer
, &caphdr
);
1087 case CAPABILITY_CODE_DYNAMIC
:
1088 case CAPABILITY_CODE_DYNAMIC_OLD
:
1089 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
1091 case CAPABILITY_CODE_AS4
:
1092 /* Already handled as a special-case parsing of the
1094 * at the beginning of OPEN processing. So we care not a
1096 * for the value really, only error case.
1098 if (!bgp_capability_as4(peer
, &caphdr
))
1101 case CAPABILITY_CODE_ADDPATH
:
1102 ret
= bgp_capability_addpath(peer
, &caphdr
);
1104 case CAPABILITY_CODE_ENHE
:
1105 ret
= bgp_capability_enhe(peer
, &caphdr
);
1107 case CAPABILITY_CODE_EXT_MESSAGE
:
1108 ret
= bgp_capability_ext_message(peer
, &caphdr
);
1110 case CAPABILITY_CODE_FQDN
:
1111 ret
= bgp_capability_hostname(peer
, &caphdr
);
1113 case CAPABILITY_CODE_ROLE
:
1114 ret
= bgp_capability_role(peer
, &caphdr
);
1116 case CAPABILITY_CODE_SOFT_VERSION
:
1117 ret
= bgp_capability_software_version(peer
, &caphdr
);
1120 if (caphdr
.code
> 128) {
1121 /* We don't send Notification for unknown vendor
1123 capabilities. It seems reasonable for now...
1125 flog_warn(EC_BGP_CAPABILITY_VENDOR
,
1126 "%s Vendor specific capability %d",
1127 peer
->host
, caphdr
.code
);
1130 EC_BGP_CAPABILITY_UNKNOWN
,
1131 "%s unrecognized capability code: %d - ignored",
1132 peer
->host
, caphdr
.code
);
1133 memcpy(*error
, sp
, caphdr
.length
+ 2);
1134 *error
+= caphdr
.length
+ 2;
1139 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1140 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1143 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
1144 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
1146 EC_BGP_CAPABILITY_INVALID_LENGTH
,
1147 "%s Cap-parser for %s read past cap-length, %u!",
1149 lookup_msg(capcode_str
, caphdr
.code
,
1152 stream_set_getp(s
, start
+ caphdr
.length
);
1155 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
1156 UNSET_FLAG(restart_flag_time
, 0xF000);
1157 peer
->v_gr_restart
= restart_flag_time
;
1163 static bool strict_capability_same(struct peer
*peer
)
1167 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
1168 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
1169 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
1175 static bool bgp_role_violation(struct peer
*peer
)
1177 uint8_t local_role
= peer
->local_role
;
1178 uint8_t remote_role
= peer
->remote_role
;
1180 if (local_role
!= ROLE_UNDEFINED
&& remote_role
!= ROLE_UNDEFINED
&&
1181 !((local_role
== ROLE_PEER
&& remote_role
== ROLE_PEER
) ||
1182 (local_role
== ROLE_PROVIDER
&& remote_role
== ROLE_CUSTOMER
) ||
1183 (local_role
== ROLE_CUSTOMER
&& remote_role
== ROLE_PROVIDER
) ||
1184 (local_role
== ROLE_RS_SERVER
&& remote_role
== ROLE_RS_CLIENT
) ||
1185 (local_role
== ROLE_RS_CLIENT
&&
1186 remote_role
== ROLE_RS_SERVER
))) {
1187 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1188 BGP_NOTIFY_OPEN_ROLE_MISMATCH
);
1191 if (remote_role
== ROLE_UNDEFINED
&&
1192 CHECK_FLAG(peer
->flags
, PEER_FLAG_ROLE_STRICT_MODE
)) {
1193 const char *err_msg
=
1194 "Strict mode. Please set the role on your side.";
1195 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1196 BGP_NOTIFY_OPEN_ROLE_MISMATCH
,
1197 (uint8_t *)err_msg
, strlen(err_msg
));
1204 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
1205 * Returns 0 if no as4 found, as4cap value otherwise.
1207 as_t
peek_for_as4_capability(struct peer
*peer
, uint16_t length
)
1209 struct stream
*s
= BGP_INPUT(peer
);
1210 size_t orig_getp
= stream_get_getp(s
);
1211 size_t end
= orig_getp
+ length
;
1214 if (BGP_DEBUG(as4
, AS4
))
1216 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u, peeking for as4",
1217 peer
->host
, length
);
1218 /* the error cases we DONT handle, we ONLY try to read as4 out of
1219 * correctly formatted options.
1221 while (stream_get_getp(s
) < end
) {
1223 uint16_t opt_length
;
1225 /* Ensure we can read the option type */
1226 if (stream_get_getp(s
) + 1 > end
)
1229 /* Fetch the option type */
1230 opt_type
= stream_getc(s
);
1233 * Check the length and fetch the opt_length
1234 * If the peer is BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer)
1235 * then we do a getw which is 2 bytes. So we need to
1236 * ensure that we can read that as well
1238 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1239 if (stream_get_getp(s
) + 2 > end
)
1242 opt_length
= stream_getw(s
);
1244 if (stream_get_getp(s
) + 1 > end
)
1247 opt_length
= stream_getc(s
);
1250 /* Option length check. */
1251 if (stream_get_getp(s
) + opt_length
> end
)
1254 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1255 unsigned long capd_start
= stream_get_getp(s
);
1256 unsigned long capd_end
= capd_start
+ opt_length
;
1258 assert(capd_end
<= end
);
1260 while (stream_get_getp(s
) < capd_end
) {
1261 struct capability_header hdr
;
1263 if (stream_get_getp(s
) + 2 > capd_end
)
1266 hdr
.code
= stream_getc(s
);
1267 hdr
.length
= stream_getc(s
);
1269 if ((stream_get_getp(s
) + hdr
.length
)
1273 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1274 if (BGP_DEBUG(as4
, AS4
))
1276 "[AS4] found AS4 capability, about to parse");
1277 as4
= bgp_capability_as4(peer
, &hdr
);
1281 stream_forward_getp(s
, hdr
.length
);
1287 stream_set_getp(s
, orig_getp
);
1292 * Parse open option.
1294 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1296 int bgp_open_option_parse(struct peer
*peer
, uint16_t length
,
1301 uint8_t error_data
[BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
];
1302 struct stream
*s
= BGP_INPUT(peer
);
1303 size_t end
= stream_get_getp(s
) + length
;
1307 if (bgp_debug_neighbor_events(peer
))
1308 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1309 peer
->host
, length
);
1311 /* Unset any previously received GR capability. */
1312 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
1314 while (stream_get_getp(s
) < end
) {
1316 uint16_t opt_length
;
1319 * Check that we can read the opt_type and fetch it
1321 if (STREAM_READABLE(s
) < 1) {
1322 zlog_info("%s Option length error", peer
->host
);
1323 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1324 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1327 opt_type
= stream_getc(s
);
1330 * Check the length of the stream to ensure that
1331 * FRR can properly read the opt_length. Then read it
1333 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1334 if (STREAM_READABLE(s
) < 2) {
1335 zlog_info("%s Option length error", peer
->host
);
1336 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1337 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1341 opt_length
= stream_getw(s
);
1343 if (STREAM_READABLE(s
) < 1) {
1344 zlog_info("%s Option length error", peer
->host
);
1345 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1346 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1350 opt_length
= stream_getc(s
);
1353 /* Option length check. */
1354 if (STREAM_READABLE(s
) < opt_length
) {
1355 zlog_info("%s Option length error (%d)", peer
->host
,
1357 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1358 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1362 if (bgp_debug_neighbor_events(peer
))
1364 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1365 peer
->host
, opt_type
,
1366 opt_type
== BGP_OPEN_OPT_CAP
? "Capability"
1371 case BGP_OPEN_OPT_CAP
:
1372 ret
= bgp_capability_parse(peer
, opt_length
,
1373 mp_capability
, &error
);
1376 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1377 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1382 /* Parse error. To accumulate all unsupported capability codes,
1383 bgp_capability_parse does not return -1 when encounter
1384 unsupported capability code. To detect that, please check
1385 error and erro_data pointer, like below. */
1390 /* All OPEN option is parsed. Check capability when strict compare
1392 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1393 /* If Unsupported Capability exists. */
1394 if (error
!= error_data
) {
1395 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1396 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1398 error
- error_data
);
1402 /* Check local capability does not negotiated with remote
1404 if (!strict_capability_same(peer
)) {
1405 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1406 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1411 /* Extended Message Support */
1412 peer
->max_packet_size
=
1413 (CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
)
1414 && CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
))
1415 ? BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE
1416 : BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1418 /* Check that roles are corresponding to each other */
1419 if (bgp_role_violation(peer
))
1422 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1425 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1426 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1427 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1428 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1429 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1430 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1431 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1432 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1433 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1434 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1435 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1436 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1437 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1438 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1439 flog_err(EC_BGP_PKT_OPEN
,
1440 "%s [Error] Configured AFI/SAFIs do not overlap with received MP capabilities",
1443 if (error
!= error_data
)
1444 bgp_notify_send_with_data(
1445 peer
, BGP_NOTIFY_OPEN_ERR
,
1446 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1447 error
- error_data
);
1449 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1450 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1457 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1458 afi_t afi
, safi_t safi
, uint8_t code
,
1459 bool ext_opt_params
)
1465 unsigned long numberp
;
1466 int number_of_orfs
= 0;
1467 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1468 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1470 /* Convert AFI, SAFI to values for packet. */
1471 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1473 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1474 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1475 ext_opt_params
? stream_putw(s
, 0)
1476 : stream_putc(s
, 0); /* Capability Length */
1477 stream_putc(s
, code
); /* Capability Code */
1478 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1479 stream_putc(s
, 0); /* ORF Length */
1480 stream_putw(s
, pkt_afi
);
1482 stream_putc(s
, pkt_safi
);
1483 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1484 stream_putc(s
, 0); /* Number of ORFs */
1486 /* Address Prefix ORF */
1487 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1488 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1489 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1491 : ORF_TYPE_PREFIX_OLD
));
1493 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1494 PEER_FLAG_ORF_PREFIX_SM
)
1495 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1496 PEER_FLAG_ORF_PREFIX_RM
)) {
1497 SET_FLAG(peer
->af_cap
[afi
][safi
],
1498 PEER_CAP_ORF_PREFIX_SM_ADV
);
1499 SET_FLAG(peer
->af_cap
[afi
][safi
],
1500 PEER_CAP_ORF_PREFIX_RM_ADV
);
1501 stream_putc(s
, ORF_MODE_BOTH
);
1502 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1503 PEER_FLAG_ORF_PREFIX_SM
)) {
1504 SET_FLAG(peer
->af_cap
[afi
][safi
],
1505 PEER_CAP_ORF_PREFIX_SM_ADV
);
1506 stream_putc(s
, ORF_MODE_SEND
);
1508 SET_FLAG(peer
->af_cap
[afi
][safi
],
1509 PEER_CAP_ORF_PREFIX_RM_ADV
);
1510 stream_putc(s
, ORF_MODE_RECEIVE
);
1515 /* Total Number of ORFs. */
1516 stream_putc_at(s
, numberp
, number_of_orfs
);
1518 /* Total ORF Len. */
1519 orf_len
= stream_get_endp(s
) - orfp
- 1;
1520 stream_putc_at(s
, orfp
, orf_len
);
1522 /* Total Capability Len. */
1523 cap_len
= stream_get_endp(s
) - capp
- 1;
1524 ext_opt_params
? stream_putw_at(s
, capp
, cap_len
)
1525 : stream_putc_at(s
, capp
, cap_len
);
1528 static void bgp_peer_send_gr_capability(struct stream
*s
, struct peer
*peer
,
1529 bool ext_opt_params
)
1532 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1535 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1536 uint32_t restart_time
;
1537 unsigned long capp
= 0;
1538 unsigned long rcapp
= 0;
1540 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
1541 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
))
1544 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1545 zlog_debug("[BGP_GR] Sending helper Capability for Peer :%s :",
1548 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1549 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1550 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1551 ext_opt_params
? stream_putw(s
, 0)
1552 : stream_putc(s
, 0); /* Capability Length */
1553 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1554 /* Set Restart Capability Len Pointer */
1555 rcapp
= stream_get_endp(s
);
1557 restart_time
= peer
->bgp
->restart_time
;
1558 if (peer
->bgp
->t_startup
) {
1559 SET_FLAG(restart_time
, GRACEFUL_RESTART_R_BIT
);
1560 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV
);
1561 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1562 zlog_debug("[BGP_GR] Sending R-Bit for peer: %s",
1566 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GRACEFUL_NOTIFICATION
)) {
1567 SET_FLAG(restart_time
, GRACEFUL_RESTART_N_BIT
);
1568 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_ADV
);
1569 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1570 zlog_debug("[BGP_GR] Sending N-Bit for peer: %s",
1574 stream_putw(s
, restart_time
);
1576 /* Send address-family specific graceful-restart capability
1577 * only when GR config is present
1579 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)) {
1580 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)
1581 && BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1582 zlog_debug("[BGP_GR] F bit Set");
1584 FOREACH_AFI_SAFI (afi
, safi
) {
1585 if (!peer
->afc
[afi
][safi
])
1588 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1590 "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
1593 /* Convert AFI, SAFI to values for
1596 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1598 stream_putw(s
, pkt_afi
);
1599 stream_putc(s
, pkt_safi
);
1600 if (CHECK_FLAG(peer
->bgp
->flags
,
1601 BGP_FLAG_GR_PRESERVE_FWD
))
1602 stream_putc(s
, GRACEFUL_RESTART_F_BIT
);
1608 /* Total Graceful restart capability Len. */
1609 len
= stream_get_endp(s
) - rcapp
- 1;
1610 stream_putc_at(s
, rcapp
, len
);
1612 /* Total Capability Len. */
1613 len
= stream_get_endp(s
) - capp
- 1;
1614 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1615 : stream_putc_at(s
, capp
, len
);
1618 static void bgp_peer_send_llgr_capability(struct stream
*s
, struct peer
*peer
,
1619 bool ext_opt_params
)
1622 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1625 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1626 unsigned long capp
= 0;
1627 unsigned long rcapp
= 0;
1629 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
))
1632 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_ADV
);
1634 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1635 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1636 ext_opt_params
? stream_putw(s
, 0)
1637 : stream_putc(s
, 0); /* Capability Length */
1638 stream_putc(s
, CAPABILITY_CODE_LLGR
);
1640 rcapp
= stream_get_endp(s
);
1643 FOREACH_AFI_SAFI (afi
, safi
) {
1644 if (!peer
->afc
[afi
][safi
])
1647 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1649 stream_putw(s
, pkt_afi
);
1650 stream_putc(s
, pkt_safi
);
1651 stream_putc(s
, LLGR_F_BIT
);
1652 stream_put3(s
, peer
->bgp
->llgr_stale_time
);
1654 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_ADV
);
1657 /* Total Long-lived Graceful Restart capability Len. */
1658 len
= stream_get_endp(s
) - rcapp
- 1;
1659 stream_putc_at(s
, rcapp
, len
);
1661 /* Total Capability Len. */
1662 len
= stream_get_endp(s
) - capp
- 1;
1663 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1664 : stream_putc_at(s
, capp
, len
);
1667 /* Fill in capability open option to the packet. */
1668 uint16_t bgp_open_capability(struct stream
*s
, struct peer
*peer
,
1669 bool ext_opt_params
)
1672 unsigned long cp
, capp
, rcapp
, eopl
= 0;
1673 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1676 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1678 uint8_t afi_safi_count
= 0;
1679 bool adv_addpath_tx
= false;
1681 /* Non-Ext OP Len. */
1682 cp
= stream_get_endp(s
);
1685 if (ext_opt_params
) {
1686 /* Non-Ext OP Len. */
1687 stream_putc_at(s
, cp
, BGP_OPEN_NON_EXT_OPT_LEN
);
1689 /* Non-Ext OP Type */
1690 stream_putc(s
, BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH
);
1692 /* Extended Opt. Parm. Length */
1693 eopl
= stream_get_endp(s
);
1697 /* Do not send capability. */
1698 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1699 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1702 /* MP capability for configured AFI, SAFI */
1703 FOREACH_AFI_SAFI (afi
, safi
) {
1704 if (peer
->afc
[afi
][safi
]) {
1705 /* Convert AFI, SAFI to values for packet. */
1706 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1709 peer
->afc_adv
[afi
][safi
] = 1;
1710 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1712 ? stream_putw(s
, CAPABILITY_CODE_MP_LEN
+ 2)
1713 : stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1714 stream_putc(s
, CAPABILITY_CODE_MP
);
1715 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1716 stream_putw(s
, pkt_afi
);
1718 stream_putc(s
, pkt_safi
);
1720 /* Extended nexthop capability - currently
1721 * supporting RFC-5549 for
1722 * Link-Local peering only
1724 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1725 && peer
->su
.sa
.sa_family
== AF_INET6
1727 && (safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
1728 || safi
== SAFI_LABELED_UNICAST
)) {
1729 /* RFC 5549 Extended Next Hop Encoding
1731 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1732 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1735 CAPABILITY_CODE_ENHE_LEN
1738 CAPABILITY_CODE_ENHE_LEN
1740 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1741 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1743 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1744 PEER_CAP_ENHE_AF_ADV
);
1745 stream_putw(s
, pkt_afi
);
1746 stream_putw(s
, pkt_safi
);
1747 stream_putw(s
, afi_int2iana(AFI_IP6
));
1749 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1750 PEER_CAP_ENHE_AF_RCV
))
1751 SET_FLAG(peer
->af_cap
[afi
][safi
],
1752 PEER_CAP_ENHE_AF_NEGO
);
1757 /* Route refresh. */
1758 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1759 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1760 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1761 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1762 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1763 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1764 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1765 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1766 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1767 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1768 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1770 /* Enhanced Route Refresh. */
1771 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_ADV
);
1772 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1773 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2)
1774 : stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2);
1775 stream_putc(s
, CAPABILITY_CODE_ENHANCED_RR
);
1776 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
);
1779 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1780 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1781 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_AS4_LEN
+ 2)
1782 : stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1783 stream_putc(s
, CAPABILITY_CODE_AS4
);
1784 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1785 if (peer
->change_local_as
)
1786 local_as
= peer
->change_local_as
;
1788 local_as
= peer
->local_as
;
1789 stream_putl(s
, local_as
);
1791 /* Extended Message Support */
1792 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
);
1793 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1794 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2)
1795 : stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2);
1796 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE
);
1797 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
);
1800 if (peer
->local_role
!= ROLE_UNDEFINED
) {
1801 SET_FLAG(peer
->cap
, PEER_CAP_ROLE_ADV
);
1802 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1803 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
+ 2);
1804 stream_putc(s
, CAPABILITY_CODE_ROLE
);
1805 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
);
1806 stream_putc(s
, peer
->local_role
);
1810 FOREACH_AFI_SAFI (afi
, safi
) {
1811 if (peer
->afc
[afi
][safi
]) {
1814 /* Only advertise addpath TX if a feature that
1817 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1818 adv_addpath_tx
= true;
1820 /* If we have enabled labeled unicast, we MUST check
1821 * against unicast SAFI because addpath IDs are
1822 * allocated under unicast SAFI, the same as the RIB
1823 * is managed in unicast SAFI.
1825 if (safi
== SAFI_LABELED_UNICAST
)
1826 if (peer
->addpath_type
[afi
][SAFI_UNICAST
] !=
1828 adv_addpath_tx
= true;
1832 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1833 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1835 ? stream_putw(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1837 : stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1839 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1840 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1842 FOREACH_AFI_SAFI (afi
, safi
) {
1843 if (peer
->afc
[afi
][safi
]) {
1844 bool adv_addpath_rx
=
1845 !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1846 PEER_FLAG_DISABLE_ADDPATH_RX
);
1849 /* Convert AFI, SAFI to values for packet. */
1850 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1853 stream_putw(s
, pkt_afi
);
1854 stream_putc(s
, pkt_safi
);
1856 if (adv_addpath_rx
) {
1857 SET_FLAG(flags
, BGP_ADDPATH_RX
);
1858 SET_FLAG(peer
->af_cap
[afi
][safi
],
1859 PEER_CAP_ADDPATH_AF_RX_ADV
);
1861 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1862 PEER_CAP_ADDPATH_AF_RX_ADV
);
1865 if (adv_addpath_tx
) {
1866 SET_FLAG(flags
, BGP_ADDPATH_TX
);
1867 SET_FLAG(peer
->af_cap
[afi
][safi
],
1868 PEER_CAP_ADDPATH_AF_TX_ADV
);
1869 if (safi
== SAFI_LABELED_UNICAST
)
1871 peer
->af_cap
[afi
][SAFI_UNICAST
],
1872 PEER_CAP_ADDPATH_AF_TX_ADV
);
1874 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1875 PEER_CAP_ADDPATH_AF_TX_ADV
);
1878 stream_putc(s
, flags
);
1882 /* ORF capability. */
1883 FOREACH_AFI_SAFI (afi
, safi
) {
1884 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1885 PEER_FLAG_ORF_PREFIX_SM
)
1886 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1887 PEER_FLAG_ORF_PREFIX_RM
)) {
1888 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1889 CAPABILITY_CODE_ORF_OLD
,
1891 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1892 CAPABILITY_CODE_ORF
,
1897 /* Dynamic capability. */
1898 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1899 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1900 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1902 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1903 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1904 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1905 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1906 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1908 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1909 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1910 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1911 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1914 /* Hostname capability */
1915 if (cmd_hostname_get()) {
1916 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1917 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1918 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1919 ext_opt_params
? stream_putw(s
, 0)
1920 : stream_putc(s
, 0); /* Capability Length */
1921 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1922 capp
= stream_get_endp(s
);
1923 stream_putc(s
, 0); /* dummy len for now */
1924 len
= strlen(cmd_hostname_get());
1925 if (len
> BGP_MAX_HOSTNAME
)
1926 len
= BGP_MAX_HOSTNAME
;
1928 stream_putc(s
, len
);
1929 stream_put(s
, cmd_hostname_get(), len
);
1930 if (cmd_domainname_get()) {
1931 len
= strlen(cmd_domainname_get());
1932 if (len
> BGP_MAX_HOSTNAME
)
1933 len
= BGP_MAX_HOSTNAME
;
1935 stream_putc(s
, len
);
1936 stream_put(s
, cmd_domainname_get(), len
);
1938 stream_putc(s
, 0); /* 0 length */
1940 /* Set the lengths straight */
1941 len
= stream_get_endp(s
) - rcapp
- 1;
1942 ext_opt_params
? stream_putw_at(s
, rcapp
, len
- 1)
1943 : stream_putc_at(s
, rcapp
, len
);
1945 len
= stream_get_endp(s
) - capp
- 1;
1946 stream_putc_at(s
, capp
, len
);
1948 if (bgp_debug_neighbor_events(peer
))
1950 "%s Sending hostname cap with hn = %s, dn = %s",
1951 peer
->host
, cmd_hostname_get(),
1952 cmd_domainname_get());
1955 bgp_peer_send_gr_capability(s
, peer
, ext_opt_params
);
1956 bgp_peer_send_llgr_capability(s
, peer
, ext_opt_params
);
1958 /* Software Version capability
1959 * An implementation is REQUIRED Extended Optional Parameters
1960 * Length for BGP OPEN Message support as defined in [RFC9072].
1961 * The inclusion of the Software Version Capability is OPTIONAL.
1962 * If an implementation supports the inclusion of the capability,
1963 * the implementation MUST include a configuration switch to enable
1964 * or disable its use, and that switch MUST be off by default.
1966 if (peergroup_flag_check(peer
, PEER_FLAG_CAPABILITY_SOFT_VERSION
) ||
1967 peer
->sort
== BGP_PEER_IBGP
) {
1968 SET_FLAG(peer
->cap
, PEER_CAP_SOFT_VERSION_ADV
);
1969 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1970 rcapp
= stream_get_endp(s
);
1971 ext_opt_params
? stream_putw(s
, 0)
1972 : stream_putc(s
, 0); /* Capability Length */
1973 stream_putc(s
, CAPABILITY_CODE_SOFT_VERSION
);
1974 capp
= stream_get_endp(s
);
1975 stream_putc(s
, 0); /* dummy placeholder len */
1977 /* The Capability Length SHOULD be no greater than 64.
1978 * This is the limit to allow other capabilities as much
1979 * space as they require.
1981 len
= strlen(cmd_software_version_get());
1982 if (len
> BGP_MAX_SOFT_VERSION
)
1983 len
= BGP_MAX_SOFT_VERSION
;
1985 stream_putc(s
, len
);
1986 stream_put(s
, cmd_software_version_get(), len
);
1988 /* Software Version capability Len. */
1989 len
= stream_get_endp(s
) - rcapp
- 1;
1990 ext_opt_params
? stream_putw_at(s
, rcapp
, len
- 1)
1991 : stream_putc_at(s
, rcapp
, len
);
1993 /* Total Capability Len. */
1994 len
= stream_get_endp(s
) - capp
- 1;
1995 stream_putc_at(s
, capp
, len
);
1997 if (bgp_debug_neighbor_events(peer
))
1998 zlog_debug("%s Sending Software Version cap, value: %s",
1999 peer
->host
, cmd_software_version_get());
2002 /* Total Opt Parm Len. */
2003 len
= stream_get_endp(s
) - cp
- 1;
2005 if (ext_opt_params
) {
2006 len
= stream_get_endp(s
) - eopl
- 2;
2007 stream_putw_at(s
, eopl
, len
);
2009 stream_putc_at(s
, cp
, len
);