1 /* BGP open message handling
2 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "bgpd/bgpd.h"
35 #include "bgpd/bgp_attr.h"
36 #include "bgpd/bgp_debug.h"
37 #include "bgpd/bgp_errors.h"
38 #include "bgpd/bgp_fsm.h"
39 #include "bgpd/bgp_packet.h"
40 #include "bgpd/bgp_open.h"
41 #include "bgpd/bgp_aspath.h"
42 #include "bgpd/bgp_vty.h"
43 #include "bgpd/bgp_memory.h"
45 static const struct message capcode_str
[] = {
46 {CAPABILITY_CODE_MP
, "MultiProtocol Extensions"},
47 {CAPABILITY_CODE_REFRESH
, "Route Refresh"},
48 {CAPABILITY_CODE_ORF
, "Cooperative Route Filtering"},
49 {CAPABILITY_CODE_RESTART
, "Graceful Restart"},
50 {CAPABILITY_CODE_AS4
, "4-octet AS number"},
51 {CAPABILITY_CODE_ADDPATH
, "AddPath"},
52 {CAPABILITY_CODE_DYNAMIC
, "Dynamic"},
53 {CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding"},
54 {CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)"},
55 {CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)"},
56 {CAPABILITY_CODE_ORF_OLD
, "ORF (Old)"},
57 {CAPABILITY_CODE_FQDN
, "FQDN"},
58 {CAPABILITY_CODE_ENHANCED_RR
, "Enhanced Route Refresh"},
59 {CAPABILITY_CODE_EXT_MESSAGE
, "BGP Extended Message"},
60 {CAPABILITY_CODE_LLGR
, "Long-lived BGP Graceful Restart"},
61 {CAPABILITY_CODE_ROLE
, "Role"},
64 /* Minimum sizes for length field of each cap (so not inc. the header) */
65 static const size_t cap_minsizes
[] = {
66 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
67 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
68 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
69 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
70 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
71 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
72 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
73 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
74 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
75 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
76 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
77 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
78 [CAPABILITY_CODE_ENHANCED_RR
] = CAPABILITY_CODE_ENHANCED_LEN
,
79 [CAPABILITY_CODE_EXT_MESSAGE
] = CAPABILITY_CODE_EXT_MESSAGE_LEN
,
80 [CAPABILITY_CODE_LLGR
] = CAPABILITY_CODE_LLGR_LEN
,
81 [CAPABILITY_CODE_ROLE
] = CAPABILITY_CODE_ROLE_LEN
,
84 /* value the capability must be a multiple of.
85 * 0-data capabilities won't be checked against this.
86 * Other capabilities whose data doesn't fall on convenient boundaries for this
87 * table should be set to 1.
89 static const size_t cap_modsizes
[] = {
90 [CAPABILITY_CODE_MP
] = 4,
91 [CAPABILITY_CODE_REFRESH
] = 1,
92 [CAPABILITY_CODE_ORF
] = 1,
93 [CAPABILITY_CODE_RESTART
] = 1,
94 [CAPABILITY_CODE_AS4
] = 4,
95 [CAPABILITY_CODE_ADDPATH
] = 4,
96 [CAPABILITY_CODE_DYNAMIC
] = 1,
97 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
98 [CAPABILITY_CODE_ENHE
] = 6,
99 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
100 [CAPABILITY_CODE_ORF_OLD
] = 1,
101 [CAPABILITY_CODE_FQDN
] = 1,
102 [CAPABILITY_CODE_ENHANCED_RR
] = 1,
103 [CAPABILITY_CODE_EXT_MESSAGE
] = 1,
104 [CAPABILITY_CODE_LLGR
] = 1,
105 [CAPABILITY_CODE_ROLE
] = 1,
108 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
109 negotiate remote peer supports extentions or not. But if
110 remote-peer doesn't supports negotiation process itself. We would
111 like to do manual configuration.
113 So there is many configurable point. First of all we want set each
114 peer whether we send capability negotiation to the peer or not.
115 Next, if we send capability to the peer we want to set my capability
116 inforation at each peer. */
118 void bgp_capability_vty_out(struct vty
*vty
, struct peer
*peer
, bool use_json
,
119 json_object
*json_neigh
)
123 struct capability_mp_data mpc
;
124 struct capability_header
*hdr
;
125 json_object
*json_cap
= NULL
;
128 json_cap
= json_object_new_object();
130 pnt
= peer
->notify
.data
;
131 end
= pnt
+ peer
->notify
.length
;
134 if (pnt
+ sizeof(struct capability_mp_data
) + 2 > end
)
137 hdr
= (struct capability_header
*)pnt
;
138 if (pnt
+ hdr
->length
+ 2 > end
)
141 memcpy(&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
143 if (hdr
->code
== CAPABILITY_CODE_MP
) {
147 (void)bgp_map_afi_safi_iana2int(ntohs(mpc
.afi
),
148 mpc
.safi
, &afi
, &safi
);
153 json_object_string_add(
155 "capabilityErrorMultiProtocolAfi",
159 json_object_string_add(
161 "capabilityErrorMultiProtocolAfi",
165 json_object_string_add(
167 "capabilityErrorMultiProtocolAfi",
173 "capabilityErrorMultiProtocolAfiUnknown",
179 json_object_string_add(
181 "capabilityErrorMultiProtocolSafi",
185 json_object_string_add(
187 "capabilityErrorMultiProtocolSafi",
190 case SAFI_LABELED_UNICAST
:
191 json_object_string_add(
193 "capabilityErrorMultiProtocolSafi",
197 json_object_string_add(
199 "capabilityErrorMultiProtocolSafi",
203 json_object_string_add(
205 "capabilityErrorMultiProtocolSafi",
209 json_object_string_add(
211 "capabilityErrorMultiProtocolSafi",
215 json_object_string_add(
217 "capabilityErrorMultiProtocolSafi",
223 "capabilityErrorMultiProtocolSafiUnknown",
229 " Capability error for: Multi protocol ");
232 vty_out(vty
, "AFI IPv4, ");
235 vty_out(vty
, "AFI IPv6, ");
238 vty_out(vty
, "AFI L2VPN, ");
241 vty_out(vty
, "AFI Unknown %d, ",
247 vty_out(vty
, "SAFI Unicast");
250 vty_out(vty
, "SAFI Multicast");
252 case SAFI_LABELED_UNICAST
:
253 vty_out(vty
, "SAFI Labeled-unicast");
256 vty_out(vty
, "SAFI MPLS-labeled VPN");
259 vty_out(vty
, "SAFI ENCAP");
262 vty_out(vty
, "SAFI FLOWSPEC");
265 vty_out(vty
, "SAFI EVPN");
268 vty_out(vty
, "SAFI Unknown %d ",
274 } else if (hdr
->code
>= 128) {
278 "capabilityErrorVendorSpecificCapabilityCode",
282 " Capability error: vendor specific capability code %d",
288 "capabilityErrorUnknownCapabilityCode",
292 " Capability error: unknown capability code %d",
295 pnt
+= hdr
->length
+ 2;
298 json_object_object_add(json_neigh
, "capabilityErrors",
302 static void bgp_capability_mp_data(struct stream
*s
,
303 struct capability_mp_data
*mpc
)
305 mpc
->afi
= stream_getw(s
);
306 mpc
->reserved
= stream_getc(s
);
307 mpc
->safi
= stream_getc(s
);
310 /* Set negotiated capability value. */
311 static int bgp_capability_mp(struct peer
*peer
, struct capability_header
*hdr
)
313 struct capability_mp_data mpc
;
314 struct stream
*s
= BGP_INPUT(peer
);
318 /* Verify length is 4 */
319 if (hdr
->length
!= 4) {
321 EC_BGP_CAPABILITY_INVALID_LENGTH
,
322 "MP Cap: Received invalid length %d, non-multiple of 4",
327 bgp_capability_mp_data(s
, &mpc
);
329 if (bgp_debug_neighbor_events(peer
))
330 zlog_debug("%s OPEN has %s capability for afi/safi: %s/%s",
331 peer
->host
, lookup_msg(capcode_str
, hdr
->code
, NULL
),
332 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
334 /* Convert AFI, SAFI to internal values, check. */
335 if (bgp_map_afi_safi_iana2int(mpc
.afi
, mpc
.safi
, &afi
, &safi
))
338 /* Now safi remapped, and afi/safi are valid array indices */
339 peer
->afc_recv
[afi
][safi
] = 1;
341 if (peer
->afc
[afi
][safi
])
342 peer
->afc_nego
[afi
][safi
] = 1;
349 static void bgp_capability_orf_not_support(struct peer
*peer
, iana_afi_t afi
,
350 iana_safi_t safi
, uint8_t type
,
353 if (bgp_debug_neighbor_events(peer
))
355 "%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
356 peer
->host
, afi
, safi
, type
, mode
);
359 static const struct message orf_type_str
[] = {
360 {ORF_TYPE_RESERVED
, "Reserved"},
361 {ORF_TYPE_PREFIX
, "Prefixlist"},
362 {ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)"},
365 static const struct message orf_mode_str
[] = {{ORF_MODE_RECEIVE
, "Receive"},
366 {ORF_MODE_SEND
, "Send"},
367 {ORF_MODE_BOTH
, "Both"},
370 static int bgp_capability_orf_entry(struct peer
*peer
,
371 struct capability_header
*hdr
)
373 struct stream
*s
= BGP_INPUT(peer
);
374 struct capability_mp_data mpc
;
378 iana_safi_t pkt_safi
;
382 uint16_t sm_cap
= 0; /* capability send-mode receive */
383 uint16_t rm_cap
= 0; /* capability receive-mode receive */
386 /* ORF Entry header */
387 bgp_capability_mp_data(s
, &mpc
);
388 num
= stream_getc(s
);
392 if (bgp_debug_neighbor_events(peer
))
393 zlog_debug("%s ORF Cap entry for afi/safi: %s/%s", peer
->host
,
394 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
396 /* Convert AFI, SAFI to internal values, check. */
397 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
399 "%s Addr-family %d/%d not supported. Ignoring the ORF capability",
400 peer
->host
, pkt_afi
, pkt_safi
);
407 /* validate number field */
408 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
410 "%s ORF Capability entry length error, Cap length %u, num %u",
411 peer
->host
, hdr
->length
, num
);
412 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
413 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
417 for (i
= 0; i
< num
; i
++) {
418 type
= stream_getc(s
);
419 mode
= stream_getc(s
);
421 /* ORF Mode error check */
425 case ORF_MODE_RECEIVE
:
428 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
432 /* ORF Type and afi/safi error checks */
433 /* capcode versus type */
435 case CAPABILITY_CODE_ORF
:
437 case ORF_TYPE_RESERVED
:
438 if (bgp_debug_neighbor_events(peer
))
440 "%s Addr-family %d/%d has reserved ORF type, ignoring",
441 peer
->host
, afi
, safi
);
443 case ORF_TYPE_PREFIX
:
446 bgp_capability_orf_not_support(
447 peer
, pkt_afi
, pkt_safi
, type
, mode
);
451 case CAPABILITY_CODE_ORF_OLD
:
453 case ORF_TYPE_RESERVED
:
454 if (bgp_debug_neighbor_events(peer
))
456 "%s Addr-family %d/%d has reserved ORF type, ignoring",
457 peer
->host
, afi
, safi
);
459 case ORF_TYPE_PREFIX_OLD
:
462 bgp_capability_orf_not_support(
463 peer
, pkt_afi
, pkt_safi
, type
, mode
);
468 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
474 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
475 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
476 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
477 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
482 if (bgp_debug_neighbor_events(peer
))
484 "%s OPEN has %s ORF capability as %s for afi/safi: %s/%s",
486 lookup_msg(orf_type_str
, type
, NULL
),
487 lookup_msg(orf_mode_str
, mode
, NULL
),
488 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
490 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
491 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
492 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
493 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
494 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
495 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
497 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
504 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
505 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
508 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
510 case ORF_MODE_RECEIVE
:
511 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
518 static int bgp_capability_restart(struct peer
*peer
,
519 struct capability_header
*caphdr
)
521 struct stream
*s
= BGP_INPUT(peer
);
522 uint16_t restart_flag_time
;
523 size_t end
= stream_get_getp(s
) + caphdr
->length
;
525 /* Verify length is a multiple of 4 */
526 if ((caphdr
->length
- 2) % 4) {
528 EC_BGP_CAPABILITY_INVALID_LENGTH
,
529 "Restart Cap: Received invalid length %d, non-multiple of 4",
534 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
535 restart_flag_time
= stream_getw(s
);
537 /* The most significant bit is defined in [RFC4724] as
538 * the Restart State ("R") bit.
540 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_R_BIT
))
541 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
543 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
545 /* The second most significant bit is defined in this
546 * document as the Graceful Notification ("N") bit.
548 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_N_BIT
))
549 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
551 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
553 UNSET_FLAG(restart_flag_time
, 0xF000);
554 peer
->v_gr_restart
= restart_flag_time
;
556 if (bgp_debug_neighbor_events(peer
)) {
558 "%s Peer has%srestarted. Restart Time: %d, N-bit set: %s",
560 CHECK_FLAG(peer
->cap
,
561 PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
)
565 CHECK_FLAG(peer
->cap
,
566 PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
)
571 while (stream_get_getp(s
) + 4 <= end
) {
574 iana_afi_t pkt_afi
= stream_getw(s
);
575 iana_safi_t pkt_safi
= stream_getc(s
);
576 uint8_t flag
= stream_getc(s
);
578 /* Convert AFI, SAFI to internal values, check. */
579 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
580 if (bgp_debug_neighbor_events(peer
))
582 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Graceful Restart capability for this AFI/SAFI",
583 peer
->host
, iana_afi2str(pkt_afi
),
584 iana_safi2str(pkt_safi
));
585 } else if (!peer
->afc
[afi
][safi
]) {
586 if (bgp_debug_neighbor_events(peer
))
588 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Graceful Restart capability",
589 peer
->host
, iana_afi2str(pkt_afi
),
590 iana_safi2str(pkt_safi
));
592 if (bgp_debug_neighbor_events(peer
))
594 "%s Address family %s is%spreserved",
595 peer
->host
, get_afi_safi_str(afi
, safi
, false),
597 peer
->af_cap
[afi
][safi
],
598 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
602 SET_FLAG(peer
->af_cap
[afi
][safi
],
603 PEER_CAP_RESTART_AF_RCV
);
604 if (CHECK_FLAG(flag
, GRACEFUL_RESTART_F_BIT
))
605 SET_FLAG(peer
->af_cap
[afi
][safi
],
606 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
612 static int bgp_capability_llgr(struct peer
*peer
,
613 struct capability_header
*caphdr
)
615 struct stream
*s
= BGP_INPUT(peer
);
616 size_t end
= stream_get_getp(s
) + caphdr
->length
;
618 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_RCV
);
620 while (stream_get_getp(s
) + 4 <= end
) {
623 iana_afi_t pkt_afi
= stream_getw(s
);
624 iana_safi_t pkt_safi
= stream_getc(s
);
625 uint8_t flags
= stream_getc(s
);
626 uint32_t stale_time
= stream_get3(s
);
628 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
629 if (bgp_debug_neighbor_events(peer
))
631 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Long-lived Graceful Restart capability for this AFI/SAFI",
632 peer
->host
, iana_afi2str(pkt_afi
),
633 iana_safi2str(pkt_safi
));
634 } else if (!peer
->afc
[afi
][safi
]
635 || !CHECK_FLAG(peer
->af_cap
[afi
][safi
],
636 PEER_CAP_RESTART_AF_RCV
)) {
637 if (bgp_debug_neighbor_events(peer
))
639 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Long-lived Graceful Restart capability",
640 peer
->host
, iana_afi2str(pkt_afi
),
641 iana_safi2str(pkt_safi
));
643 if (bgp_debug_neighbor_events(peer
))
645 "%s Addr-family %s/%s(afi/safi) Long-lived Graceful Restart capability stale time %u sec",
646 peer
->host
, iana_afi2str(pkt_afi
),
647 iana_safi2str(pkt_safi
), stale_time
);
649 peer
->llgr
[afi
][safi
].flags
= flags
;
650 peer
->llgr
[afi
][safi
].stale_time
=
651 MIN(stale_time
, peer
->bgp
->llgr_stale_time
);
652 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_RCV
);
659 /* Unlike other capability parsing routines, this one returns 0 on error */
660 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
662 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
664 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
665 flog_err(EC_BGP_PKT_OPEN
,
666 "%s AS4 capability has incorrect data length %d",
667 peer
->host
, hdr
->length
);
671 as_t as4
= stream_getl(BGP_INPUT(peer
));
673 if (BGP_DEBUG(as4
, AS4
))
675 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
680 static int bgp_capability_ext_message(struct peer
*peer
,
681 struct capability_header
*hdr
)
683 if (hdr
->length
!= CAPABILITY_CODE_EXT_MESSAGE_LEN
) {
686 "%s: BGP Extended Message capability has incorrect data length %d",
687 peer
->host
, hdr
->length
);
691 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
);
696 static int bgp_capability_addpath(struct peer
*peer
,
697 struct capability_header
*hdr
)
699 struct stream
*s
= BGP_INPUT(peer
);
700 size_t end
= stream_get_getp(s
) + hdr
->length
;
702 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
704 /* Verify length is a multiple of 4 */
705 if (hdr
->length
% 4) {
707 EC_BGP_CAPABILITY_INVALID_LENGTH
,
708 "Add Path: Received invalid length %d, non-multiple of 4",
713 while (stream_get_getp(s
) + 4 <= end
) {
716 iana_afi_t pkt_afi
= stream_getw(s
);
717 iana_safi_t pkt_safi
= stream_getc(s
);
718 uint8_t send_receive
= stream_getc(s
);
720 if (bgp_debug_neighbor_events(peer
))
722 "%s OPEN has %s capability for afi/safi: %s/%s%s%s",
724 lookup_msg(capcode_str
, hdr
->code
, NULL
),
725 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
),
726 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
728 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
731 /* Convert AFI, SAFI to internal values, check. */
732 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
733 if (bgp_debug_neighbor_events(peer
))
735 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Addpath Attribute for this AFI/SAFI",
736 peer
->host
, iana_afi2str(pkt_afi
),
737 iana_safi2str(pkt_safi
));
739 } else if (!peer
->afc
[afi
][safi
]) {
740 if (bgp_debug_neighbor_events(peer
))
742 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the AddPath capability for this AFI/SAFI",
743 peer
->host
, iana_afi2str(pkt_afi
),
744 iana_safi2str(pkt_safi
));
748 if (send_receive
& BGP_ADDPATH_RX
)
749 SET_FLAG(peer
->af_cap
[afi
][safi
],
750 PEER_CAP_ADDPATH_AF_RX_RCV
);
752 if (send_receive
& BGP_ADDPATH_TX
)
753 SET_FLAG(peer
->af_cap
[afi
][safi
],
754 PEER_CAP_ADDPATH_AF_TX_RCV
);
760 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
762 struct stream
*s
= BGP_INPUT(peer
);
763 size_t end
= stream_get_getp(s
) + hdr
->length
;
765 /* Verify length is a multiple of 4 */
766 if (hdr
->length
% 6) {
768 EC_BGP_CAPABILITY_INVALID_LENGTH
,
769 "Extended NH: Received invalid length %d, non-multiple of 6",
774 while (stream_get_getp(s
) + 6 <= end
) {
775 iana_afi_t pkt_afi
= stream_getw(s
);
777 iana_safi_t pkt_safi
= stream_getw(s
);
779 iana_afi_t pkt_nh_afi
= stream_getw(s
);
782 if (bgp_debug_neighbor_events(peer
))
784 "%s Received with afi/safi/next-hop afi: %s/%s/%u",
785 peer
->host
, iana_afi2str(pkt_afi
),
786 iana_safi2str(pkt_safi
), pkt_nh_afi
);
788 /* Convert AFI, SAFI to internal values, check. */
789 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
790 if (bgp_debug_neighbor_events(peer
))
792 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the ENHE Attribute for this AFI/SAFI",
793 peer
->host
, iana_afi2str(pkt_afi
),
794 iana_safi2str(pkt_safi
));
798 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
800 * the Nexthop AFI being IPv6. A future spec may introduce other
801 * possibilities, so we ignore other values with a log. Also,
803 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
806 nh_afi
= afi_iana2int(pkt_nh_afi
);
808 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
809 || !(safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
810 || safi
== SAFI_LABELED_UNICAST
)) {
812 EC_BGP_CAPABILITY_INVALID_DATA
,
813 "%s Unexpected afi/safi/next-hop afi: %s/%s/%u in Extended Next-hop capability, ignoring",
814 peer
->host
, iana_afi2str(pkt_afi
),
815 iana_safi2str(pkt_safi
), pkt_nh_afi
);
819 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
821 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
822 SET_FLAG(peer
->af_cap
[afi
][safi
],
823 PEER_CAP_ENHE_AF_NEGO
);
826 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
831 static int bgp_capability_hostname(struct peer
*peer
,
832 struct capability_header
*hdr
)
834 struct stream
*s
= BGP_INPUT(peer
);
835 char str
[BGP_MAX_HOSTNAME
+ 1];
836 size_t end
= stream_get_getp(s
) + hdr
->length
;
839 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
841 len
= stream_getc(s
);
842 if (stream_get_getp(s
) + len
> end
) {
844 EC_BGP_CAPABILITY_INVALID_DATA
,
845 "%s: Received malformed hostname capability from peer %s",
846 __func__
, peer
->host
);
850 if (len
> BGP_MAX_HOSTNAME
) {
851 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
852 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
853 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
855 stream_get(str
, s
, len
);
860 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
861 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
863 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
866 if (stream_get_getp(s
) + 1 > end
) {
868 EC_BGP_CAPABILITY_INVALID_DATA
,
869 "%s: Received invalid domain name len (hostname capability) from peer %s",
870 __func__
, peer
->host
);
874 len
= stream_getc(s
);
875 if (stream_get_getp(s
) + len
> end
) {
877 EC_BGP_CAPABILITY_INVALID_DATA
,
878 "%s: Received runt domain name (hostname capability) from peer %s",
879 __func__
, peer
->host
);
883 if (len
> BGP_MAX_HOSTNAME
) {
884 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
885 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
886 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
888 stream_get(str
, s
, len
);
893 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
895 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
898 if (bgp_debug_neighbor_events(peer
)) {
899 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
900 peer
->hostname
, peer
->domainname
);
906 static int bgp_capability_role(struct peer
*peer
, struct capability_header
*hdr
)
908 SET_FLAG(peer
->cap
, PEER_CAP_ROLE_RCV
);
909 if (hdr
->length
!= CAPABILITY_CODE_ROLE_LEN
) {
910 flog_warn(EC_BGP_CAPABILITY_INVALID_LENGTH
,
911 "Role: Received invalid length %d", hdr
->length
);
914 uint8_t role
= stream_getc(BGP_INPUT(peer
));
916 peer
->remote_role
= role
;
921 * Parse given capability.
922 * XXX: This is reading into a stream, but not using stream API
924 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
925 * capabilities were encountered.
927 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
928 int *mp_capability
, uint8_t **error
)
931 struct stream
*s
= BGP_INPUT(peer
);
932 size_t end
= stream_get_getp(s
) + length
;
933 uint16_t restart_flag_time
= 0;
935 assert(STREAM_READABLE(s
) >= length
);
937 while (stream_get_getp(s
) < end
) {
939 uint8_t *sp
= stream_pnt(s
);
940 struct capability_header caphdr
;
943 /* We need at least capability code and capability length. */
944 if (stream_get_getp(s
) + 2 > end
) {
945 zlog_info("%s Capability length error (< header)",
947 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
948 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
952 caphdr
.code
= stream_getc(s
);
953 caphdr
.length
= stream_getc(s
);
954 start
= stream_get_getp(s
);
956 /* Capability length check sanity check. */
957 if (start
+ caphdr
.length
> end
) {
958 zlog_info("%s Capability length error (< length)",
960 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
961 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
965 if (bgp_debug_neighbor_events(peer
))
966 zlog_debug("%s OPEN has %s capability (%u), length %u",
968 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
969 caphdr
.code
, caphdr
.length
);
971 /* Length sanity check, type-specific, for known capabilities */
972 switch (caphdr
.code
) {
973 case CAPABILITY_CODE_MP
:
974 case CAPABILITY_CODE_REFRESH
:
975 case CAPABILITY_CODE_REFRESH_OLD
:
976 case CAPABILITY_CODE_ORF
:
977 case CAPABILITY_CODE_ORF_OLD
:
978 case CAPABILITY_CODE_RESTART
:
979 case CAPABILITY_CODE_AS4
:
980 case CAPABILITY_CODE_ADDPATH
:
981 case CAPABILITY_CODE_DYNAMIC
:
982 case CAPABILITY_CODE_DYNAMIC_OLD
:
983 case CAPABILITY_CODE_ENHE
:
984 case CAPABILITY_CODE_FQDN
:
985 case CAPABILITY_CODE_ENHANCED_RR
:
986 case CAPABILITY_CODE_EXT_MESSAGE
:
987 case CAPABILITY_CODE_ROLE
:
989 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
991 "%s %s Capability length error: got %u, expected at least %u",
993 lookup_msg(capcode_str
, caphdr
.code
,
996 (unsigned)cap_minsizes
[caphdr
.code
]);
997 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
998 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1002 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
1004 "%s %s Capability length error: got %u, expected a multiple of %u",
1006 lookup_msg(capcode_str
, caphdr
.code
,
1009 (unsigned)cap_modsizes
[caphdr
.code
]);
1010 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1011 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1014 /* we deliberately ignore unknown codes, see below */
1019 switch (caphdr
.code
) {
1020 case CAPABILITY_CODE_MP
: {
1023 /* Ignore capability when override-capability is set. */
1024 if (!CHECK_FLAG(peer
->flags
,
1025 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1026 /* Set negotiated value. */
1027 ret
= bgp_capability_mp(peer
, &caphdr
);
1029 /* Unsupported Capability. */
1031 /* Store return data. */
1032 memcpy(*error
, sp
, caphdr
.length
+ 2);
1033 *error
+= caphdr
.length
+ 2;
1035 ret
= 0; /* Don't return error for this */
1038 case CAPABILITY_CODE_ENHANCED_RR
:
1039 case CAPABILITY_CODE_REFRESH
:
1040 case CAPABILITY_CODE_REFRESH_OLD
: {
1041 /* BGP refresh capability */
1042 if (caphdr
.code
== CAPABILITY_CODE_ENHANCED_RR
)
1043 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_RCV
);
1044 else if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
1045 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
1047 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
1049 case CAPABILITY_CODE_ORF
:
1050 case CAPABILITY_CODE_ORF_OLD
:
1051 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
1053 case CAPABILITY_CODE_RESTART
:
1054 ret
= bgp_capability_restart(peer
, &caphdr
);
1056 case CAPABILITY_CODE_LLGR
:
1057 ret
= bgp_capability_llgr(peer
, &caphdr
);
1059 case CAPABILITY_CODE_DYNAMIC
:
1060 case CAPABILITY_CODE_DYNAMIC_OLD
:
1061 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
1063 case CAPABILITY_CODE_AS4
:
1064 /* Already handled as a special-case parsing of the
1066 * at the beginning of OPEN processing. So we care not a
1068 * for the value really, only error case.
1070 if (!bgp_capability_as4(peer
, &caphdr
))
1073 case CAPABILITY_CODE_ADDPATH
:
1074 ret
= bgp_capability_addpath(peer
, &caphdr
);
1076 case CAPABILITY_CODE_ENHE
:
1077 ret
= bgp_capability_enhe(peer
, &caphdr
);
1079 case CAPABILITY_CODE_EXT_MESSAGE
:
1080 ret
= bgp_capability_ext_message(peer
, &caphdr
);
1082 case CAPABILITY_CODE_FQDN
:
1083 ret
= bgp_capability_hostname(peer
, &caphdr
);
1085 case CAPABILITY_CODE_ROLE
:
1086 ret
= bgp_capability_role(peer
, &caphdr
);
1089 if (caphdr
.code
> 128) {
1090 /* We don't send Notification for unknown vendor
1092 capabilities. It seems reasonable for now...
1094 flog_warn(EC_BGP_CAPABILITY_VENDOR
,
1095 "%s Vendor specific capability %d",
1096 peer
->host
, caphdr
.code
);
1099 EC_BGP_CAPABILITY_UNKNOWN
,
1100 "%s unrecognized capability code: %d - ignored",
1101 peer
->host
, caphdr
.code
);
1102 memcpy(*error
, sp
, caphdr
.length
+ 2);
1103 *error
+= caphdr
.length
+ 2;
1108 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1109 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1112 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
1113 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
1115 EC_BGP_CAPABILITY_INVALID_LENGTH
,
1116 "%s Cap-parser for %s read past cap-length, %u!",
1118 lookup_msg(capcode_str
, caphdr
.code
,
1121 stream_set_getp(s
, start
+ caphdr
.length
);
1124 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
1125 UNSET_FLAG(restart_flag_time
, 0xF000);
1126 peer
->v_gr_restart
= restart_flag_time
;
1132 static bool strict_capability_same(struct peer
*peer
)
1136 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
1137 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
1138 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
1144 static bool bgp_role_violation(struct peer
*peer
)
1146 uint8_t local_role
= peer
->local_role
;
1147 uint8_t remote_role
= peer
->remote_role
;
1149 if (local_role
!= ROLE_UNDEFINED
&& remote_role
!= ROLE_UNDEFINED
&&
1150 !((local_role
== ROLE_PEER
&& remote_role
== ROLE_PEER
) ||
1151 (local_role
== ROLE_PROVIDER
&& remote_role
== ROLE_CUSTOMER
) ||
1152 (local_role
== ROLE_CUSTOMER
&& remote_role
== ROLE_PROVIDER
) ||
1153 (local_role
== ROLE_RS_SERVER
&& remote_role
== ROLE_RS_CLIENT
) ||
1154 (local_role
== ROLE_RS_CLIENT
&&
1155 remote_role
== ROLE_RS_SERVER
))) {
1156 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1157 BGP_NOTIFY_OPEN_ROLE_MISMATCH
);
1160 if (remote_role
== ROLE_UNDEFINED
&&
1161 CHECK_FLAG(peer
->flags
, PEER_FLAG_ROLE_STRICT_MODE
)) {
1162 const char *err_msg
=
1163 "Strict mode. Please set the role on your side.";
1164 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1165 BGP_NOTIFY_OPEN_ROLE_MISMATCH
,
1166 (uint8_t *)err_msg
, strlen(err_msg
));
1173 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
1174 * Returns 0 if no as4 found, as4cap value otherwise.
1176 as_t
peek_for_as4_capability(struct peer
*peer
, uint16_t length
)
1178 struct stream
*s
= BGP_INPUT(peer
);
1179 size_t orig_getp
= stream_get_getp(s
);
1180 size_t end
= orig_getp
+ length
;
1183 if (BGP_DEBUG(as4
, AS4
))
1185 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u, peeking for as4",
1186 peer
->host
, length
);
1187 /* the error cases we DONT handle, we ONLY try to read as4 out of
1188 * correctly formatted options.
1190 while (stream_get_getp(s
) < end
) {
1192 uint16_t opt_length
;
1194 /* Ensure we can read the option type */
1195 if (stream_get_getp(s
) + 1 > end
)
1198 /* Fetch the option type */
1199 opt_type
= stream_getc(s
);
1202 * Check the length and fetch the opt_length
1203 * If the peer is BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer)
1204 * then we do a getw which is 2 bytes. So we need to
1205 * ensure that we can read that as well
1207 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1208 if (stream_get_getp(s
) + 2 > end
)
1211 opt_length
= stream_getw(s
);
1213 if (stream_get_getp(s
) + 1 > end
)
1216 opt_length
= stream_getc(s
);
1219 /* Option length check. */
1220 if (stream_get_getp(s
) + opt_length
> end
)
1223 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1224 unsigned long capd_start
= stream_get_getp(s
);
1225 unsigned long capd_end
= capd_start
+ opt_length
;
1227 assert(capd_end
<= end
);
1229 while (stream_get_getp(s
) < capd_end
) {
1230 struct capability_header hdr
;
1232 if (stream_get_getp(s
) + 2 > capd_end
)
1235 hdr
.code
= stream_getc(s
);
1236 hdr
.length
= stream_getc(s
);
1238 if ((stream_get_getp(s
) + hdr
.length
)
1242 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1243 if (BGP_DEBUG(as4
, AS4
))
1245 "[AS4] found AS4 capability, about to parse");
1246 as4
= bgp_capability_as4(peer
, &hdr
);
1250 stream_forward_getp(s
, hdr
.length
);
1256 stream_set_getp(s
, orig_getp
);
1261 * Parse open option.
1263 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1265 int bgp_open_option_parse(struct peer
*peer
, uint16_t length
,
1270 uint8_t error_data
[BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
];
1271 struct stream
*s
= BGP_INPUT(peer
);
1272 size_t end
= stream_get_getp(s
) + length
;
1276 if (bgp_debug_neighbor_events(peer
))
1277 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1278 peer
->host
, length
);
1280 /* Unset any previously received GR capability. */
1281 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
1283 while (stream_get_getp(s
) < end
) {
1285 uint16_t opt_length
;
1288 * Check that we can read the opt_type and fetch it
1290 if (STREAM_READABLE(s
) < 1) {
1291 zlog_info("%s Option length error", peer
->host
);
1292 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1293 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1296 opt_type
= stream_getc(s
);
1299 * Check the length of the stream to ensure that
1300 * FRR can properly read the opt_length. Then read it
1302 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1303 if (STREAM_READABLE(s
) < 2) {
1304 zlog_info("%s Option length error", peer
->host
);
1305 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1306 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1310 opt_length
= stream_getw(s
);
1312 if (STREAM_READABLE(s
) < 1) {
1313 zlog_info("%s Option length error", peer
->host
);
1314 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1315 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1319 opt_length
= stream_getc(s
);
1322 /* Option length check. */
1323 if (STREAM_READABLE(s
) < opt_length
) {
1324 zlog_info("%s Option length error (%d)", peer
->host
,
1326 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1327 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1331 if (bgp_debug_neighbor_events(peer
))
1333 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1334 peer
->host
, opt_type
,
1335 opt_type
== BGP_OPEN_OPT_CAP
? "Capability"
1340 case BGP_OPEN_OPT_CAP
:
1341 ret
= bgp_capability_parse(peer
, opt_length
,
1342 mp_capability
, &error
);
1345 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1346 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1351 /* Parse error. To accumulate all unsupported capability codes,
1352 bgp_capability_parse does not return -1 when encounter
1353 unsupported capability code. To detect that, please check
1354 error and erro_data pointer, like below. */
1359 /* All OPEN option is parsed. Check capability when strict compare
1361 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1362 /* If Unsupported Capability exists. */
1363 if (error
!= error_data
) {
1364 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1365 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1367 error
- error_data
);
1371 /* Check local capability does not negotiated with remote
1373 if (!strict_capability_same(peer
)) {
1374 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1375 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1380 /* Extended Message Support */
1381 peer
->max_packet_size
=
1382 (CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
)
1383 && CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
))
1384 ? BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE
1385 : BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1387 /* Check that roles are corresponding to each other */
1388 if (bgp_role_violation(peer
))
1391 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1394 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1395 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1396 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1397 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1398 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1399 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1400 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1401 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1402 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1403 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1404 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1405 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1406 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1407 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1408 flog_err(EC_BGP_PKT_OPEN
,
1409 "%s [Error] Configured AFI/SAFIs do not overlap with received MP capabilities",
1412 if (error
!= error_data
)
1413 bgp_notify_send_with_data(
1414 peer
, BGP_NOTIFY_OPEN_ERR
,
1415 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1416 error
- error_data
);
1418 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1419 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1426 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1427 afi_t afi
, safi_t safi
, uint8_t code
,
1428 bool ext_opt_params
)
1434 unsigned long numberp
;
1435 int number_of_orfs
= 0;
1436 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1437 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1439 /* Convert AFI, SAFI to values for packet. */
1440 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1442 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1443 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1444 ext_opt_params
? stream_putw(s
, 0)
1445 : stream_putc(s
, 0); /* Capability Length */
1446 stream_putc(s
, code
); /* Capability Code */
1447 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1448 stream_putc(s
, 0); /* ORF Length */
1449 stream_putw(s
, pkt_afi
);
1451 stream_putc(s
, pkt_safi
);
1452 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1453 stream_putc(s
, 0); /* Number of ORFs */
1455 /* Address Prefix ORF */
1456 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1457 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1458 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1460 : ORF_TYPE_PREFIX_OLD
));
1462 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1463 PEER_FLAG_ORF_PREFIX_SM
)
1464 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1465 PEER_FLAG_ORF_PREFIX_RM
)) {
1466 SET_FLAG(peer
->af_cap
[afi
][safi
],
1467 PEER_CAP_ORF_PREFIX_SM_ADV
);
1468 SET_FLAG(peer
->af_cap
[afi
][safi
],
1469 PEER_CAP_ORF_PREFIX_RM_ADV
);
1470 stream_putc(s
, ORF_MODE_BOTH
);
1471 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1472 PEER_FLAG_ORF_PREFIX_SM
)) {
1473 SET_FLAG(peer
->af_cap
[afi
][safi
],
1474 PEER_CAP_ORF_PREFIX_SM_ADV
);
1475 stream_putc(s
, ORF_MODE_SEND
);
1477 SET_FLAG(peer
->af_cap
[afi
][safi
],
1478 PEER_CAP_ORF_PREFIX_RM_ADV
);
1479 stream_putc(s
, ORF_MODE_RECEIVE
);
1484 /* Total Number of ORFs. */
1485 stream_putc_at(s
, numberp
, number_of_orfs
);
1487 /* Total ORF Len. */
1488 orf_len
= stream_get_endp(s
) - orfp
- 1;
1489 stream_putc_at(s
, orfp
, orf_len
);
1491 /* Total Capability Len. */
1492 cap_len
= stream_get_endp(s
) - capp
- 1;
1493 ext_opt_params
? stream_putw_at(s
, capp
, cap_len
)
1494 : stream_putc_at(s
, capp
, cap_len
);
1497 static void bgp_peer_send_gr_capability(struct stream
*s
, struct peer
*peer
,
1498 bool ext_opt_params
)
1501 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1504 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1505 uint32_t restart_time
;
1506 unsigned long capp
= 0;
1507 unsigned long rcapp
= 0;
1509 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
1510 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
))
1513 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1514 zlog_debug("[BGP_GR] Sending helper Capability for Peer :%s :",
1517 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1518 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1519 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1520 ext_opt_params
? stream_putw(s
, 0)
1521 : stream_putc(s
, 0); /* Capability Length */
1522 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1523 /* Set Restart Capability Len Pointer */
1524 rcapp
= stream_get_endp(s
);
1526 restart_time
= peer
->bgp
->restart_time
;
1527 if (peer
->bgp
->t_startup
) {
1528 SET_FLAG(restart_time
, GRACEFUL_RESTART_R_BIT
);
1529 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV
);
1530 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1531 zlog_debug("[BGP_GR] Sending R-Bit for peer: %s",
1535 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GRACEFUL_NOTIFICATION
)) {
1536 SET_FLAG(restart_time
, GRACEFUL_RESTART_N_BIT
);
1537 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_ADV
);
1538 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1539 zlog_debug("[BGP_GR] Sending N-Bit for peer: %s",
1543 stream_putw(s
, restart_time
);
1545 /* Send address-family specific graceful-restart capability
1546 * only when GR config is present
1548 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)) {
1549 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)
1550 && BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1551 zlog_debug("[BGP_GR] F bit Set");
1553 FOREACH_AFI_SAFI (afi
, safi
) {
1554 if (!peer
->afc
[afi
][safi
])
1557 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1559 "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
1562 /* Convert AFI, SAFI to values for
1565 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1567 stream_putw(s
, pkt_afi
);
1568 stream_putc(s
, pkt_safi
);
1569 if (CHECK_FLAG(peer
->bgp
->flags
,
1570 BGP_FLAG_GR_PRESERVE_FWD
))
1571 stream_putc(s
, GRACEFUL_RESTART_F_BIT
);
1577 /* Total Graceful restart capability Len. */
1578 len
= stream_get_endp(s
) - rcapp
- 1;
1579 stream_putc_at(s
, rcapp
, len
);
1581 /* Total Capability Len. */
1582 len
= stream_get_endp(s
) - capp
- 1;
1583 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1584 : stream_putc_at(s
, capp
, len
);
1587 static void bgp_peer_send_llgr_capability(struct stream
*s
, struct peer
*peer
,
1588 bool ext_opt_params
)
1591 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1594 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1595 unsigned long capp
= 0;
1596 unsigned long rcapp
= 0;
1598 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
))
1601 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_ADV
);
1603 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1604 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1605 ext_opt_params
? stream_putw(s
, 0)
1606 : stream_putc(s
, 0); /* Capability Length */
1607 stream_putc(s
, CAPABILITY_CODE_LLGR
);
1609 rcapp
= stream_get_endp(s
);
1612 FOREACH_AFI_SAFI (afi
, safi
) {
1613 if (!peer
->afc
[afi
][safi
])
1616 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1618 stream_putw(s
, pkt_afi
);
1619 stream_putc(s
, pkt_safi
);
1620 stream_putc(s
, LLGR_F_BIT
);
1621 stream_put3(s
, peer
->bgp
->llgr_stale_time
);
1623 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_ADV
);
1626 /* Total Long-lived Graceful Restart capability Len. */
1627 len
= stream_get_endp(s
) - rcapp
- 1;
1628 stream_putc_at(s
, rcapp
, len
);
1630 /* Total Capability Len. */
1631 len
= stream_get_endp(s
) - capp
- 1;
1632 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1633 : stream_putc_at(s
, capp
, len
);
1636 /* Fill in capability open option to the packet. */
1637 uint16_t bgp_open_capability(struct stream
*s
, struct peer
*peer
,
1638 bool ext_opt_params
)
1641 unsigned long cp
, capp
, rcapp
, eopl
= 0;
1642 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1645 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1647 uint8_t afi_safi_count
= 0;
1648 bool adv_addpath_tx
= false;
1650 /* Non-Ext OP Len. */
1651 cp
= stream_get_endp(s
);
1654 if (ext_opt_params
) {
1655 /* Non-Ext OP Len. */
1656 stream_putc_at(s
, cp
, BGP_OPEN_NON_EXT_OPT_LEN
);
1658 /* Non-Ext OP Type */
1659 stream_putc(s
, BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH
);
1661 /* Extended Opt. Parm. Length */
1662 eopl
= stream_get_endp(s
);
1666 /* Do not send capability. */
1667 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1668 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1671 /* MP capability for configured AFI, SAFI */
1672 FOREACH_AFI_SAFI (afi
, safi
) {
1673 if (peer
->afc
[afi
][safi
]) {
1674 /* Convert AFI, SAFI to values for packet. */
1675 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1678 peer
->afc_adv
[afi
][safi
] = 1;
1679 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1681 ? stream_putw(s
, CAPABILITY_CODE_MP_LEN
+ 2)
1682 : stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1683 stream_putc(s
, CAPABILITY_CODE_MP
);
1684 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1685 stream_putw(s
, pkt_afi
);
1687 stream_putc(s
, pkt_safi
);
1689 /* Extended nexthop capability - currently
1690 * supporting RFC-5549 for
1691 * Link-Local peering only
1693 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1694 && peer
->su
.sa
.sa_family
== AF_INET6
1696 && (safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
1697 || safi
== SAFI_LABELED_UNICAST
)) {
1698 /* RFC 5549 Extended Next Hop Encoding
1700 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1701 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1704 CAPABILITY_CODE_ENHE_LEN
1707 CAPABILITY_CODE_ENHE_LEN
1709 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1710 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1712 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1713 PEER_CAP_ENHE_AF_ADV
);
1714 stream_putw(s
, pkt_afi
);
1715 stream_putw(s
, pkt_safi
);
1716 stream_putw(s
, afi_int2iana(AFI_IP6
));
1718 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1719 PEER_CAP_ENHE_AF_RCV
))
1720 SET_FLAG(peer
->af_cap
[afi
][safi
],
1721 PEER_CAP_ENHE_AF_NEGO
);
1726 /* Route refresh. */
1727 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1728 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1729 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1730 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1731 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1732 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1733 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1734 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1735 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1736 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1737 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1739 /* Enhanced Route Refresh. */
1740 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_ADV
);
1741 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1742 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2)
1743 : stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2);
1744 stream_putc(s
, CAPABILITY_CODE_ENHANCED_RR
);
1745 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
);
1748 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1749 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1750 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_AS4_LEN
+ 2)
1751 : stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1752 stream_putc(s
, CAPABILITY_CODE_AS4
);
1753 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1754 if (peer
->change_local_as
)
1755 local_as
= peer
->change_local_as
;
1757 local_as
= peer
->local_as
;
1758 stream_putl(s
, local_as
);
1760 /* Extended Message Support */
1761 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
);
1762 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1763 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2)
1764 : stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2);
1765 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE
);
1766 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
);
1769 if (peer
->local_role
!= ROLE_UNDEFINED
) {
1770 SET_FLAG(peer
->cap
, PEER_CAP_ROLE_ADV
);
1771 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1772 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
+ 2);
1773 stream_putc(s
, CAPABILITY_CODE_ROLE
);
1774 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
);
1775 stream_putc(s
, peer
->local_role
);
1779 FOREACH_AFI_SAFI (afi
, safi
) {
1780 if (peer
->afc
[afi
][safi
]) {
1783 /* Only advertise addpath TX if a feature that
1786 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1787 adv_addpath_tx
= true;
1789 /* If we have enabled labeled unicast, we MUST check
1790 * against unicast SAFI because addpath IDs are
1791 * allocated under unicast SAFI, the same as the RIB
1792 * is managed in unicast SAFI.
1794 if (safi
== SAFI_LABELED_UNICAST
)
1795 if (peer
->addpath_type
[afi
][SAFI_UNICAST
] !=
1797 adv_addpath_tx
= true;
1801 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1802 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1804 ? stream_putw(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1806 : stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1808 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1809 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1811 FOREACH_AFI_SAFI (afi
, safi
) {
1812 if (peer
->afc
[afi
][safi
]) {
1813 bool adv_addpath_rx
=
1814 !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1815 PEER_FLAG_DISABLE_ADDPATH_RX
);
1818 /* Convert AFI, SAFI to values for packet. */
1819 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1822 stream_putw(s
, pkt_afi
);
1823 stream_putc(s
, pkt_safi
);
1825 if (adv_addpath_rx
) {
1826 SET_FLAG(flags
, BGP_ADDPATH_RX
);
1827 SET_FLAG(peer
->af_cap
[afi
][safi
],
1828 PEER_CAP_ADDPATH_AF_RX_ADV
);
1830 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1831 PEER_CAP_ADDPATH_AF_RX_ADV
);
1834 if (adv_addpath_tx
) {
1835 SET_FLAG(flags
, BGP_ADDPATH_TX
);
1836 SET_FLAG(peer
->af_cap
[afi
][safi
],
1837 PEER_CAP_ADDPATH_AF_TX_ADV
);
1838 if (safi
== SAFI_LABELED_UNICAST
)
1840 peer
->af_cap
[afi
][SAFI_UNICAST
],
1841 PEER_CAP_ADDPATH_AF_TX_ADV
);
1843 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1844 PEER_CAP_ADDPATH_AF_TX_ADV
);
1847 stream_putc(s
, flags
);
1851 /* ORF capability. */
1852 FOREACH_AFI_SAFI (afi
, safi
) {
1853 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1854 PEER_FLAG_ORF_PREFIX_SM
)
1855 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1856 PEER_FLAG_ORF_PREFIX_RM
)) {
1857 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1858 CAPABILITY_CODE_ORF_OLD
,
1860 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1861 CAPABILITY_CODE_ORF
,
1866 /* Dynamic capability. */
1867 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1868 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1869 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1871 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1872 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1873 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1874 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1875 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1877 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1878 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1879 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1880 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1883 /* Hostname capability */
1884 if (cmd_hostname_get()) {
1885 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1886 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1887 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1888 ext_opt_params
? stream_putw(s
, 0)
1889 : stream_putc(s
, 0); /* Capability Length */
1890 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1891 capp
= stream_get_endp(s
);
1892 stream_putc(s
, 0); /* dummy len for now */
1893 len
= strlen(cmd_hostname_get());
1894 if (len
> BGP_MAX_HOSTNAME
)
1895 len
= BGP_MAX_HOSTNAME
;
1897 stream_putc(s
, len
);
1898 stream_put(s
, cmd_hostname_get(), len
);
1899 if (cmd_domainname_get()) {
1900 len
= strlen(cmd_domainname_get());
1901 if (len
> BGP_MAX_HOSTNAME
)
1902 len
= BGP_MAX_HOSTNAME
;
1904 stream_putc(s
, len
);
1905 stream_put(s
, cmd_domainname_get(), len
);
1907 stream_putc(s
, 0); /* 0 length */
1909 /* Set the lengths straight */
1910 len
= stream_get_endp(s
) - rcapp
- 1;
1911 ext_opt_params
? stream_putw_at(s
, rcapp
, len
- 1)
1912 : stream_putc_at(s
, rcapp
, len
);
1914 len
= stream_get_endp(s
) - capp
- 1;
1915 stream_putc_at(s
, capp
, len
);
1917 if (bgp_debug_neighbor_events(peer
))
1919 "%s Sending hostname cap with hn = %s, dn = %s",
1920 peer
->host
, cmd_hostname_get(),
1921 cmd_domainname_get());
1924 bgp_peer_send_gr_capability(s
, peer
, ext_opt_params
);
1925 bgp_peer_send_llgr_capability(s
, peer
, ext_opt_params
);
1927 /* Total Opt Parm Len. */
1928 len
= stream_get_endp(s
) - cp
- 1;
1930 if (ext_opt_params
) {
1931 len
= stream_get_endp(s
) - eopl
- 2;
1932 stream_putw_at(s
, eopl
, len
);
1934 stream_putc_at(s
, cp
, len
);