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 int bgp_auth_parse(struct peer
*peer
, size_t length
)
1134 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1135 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
1139 static bool strict_capability_same(struct peer
*peer
)
1143 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
1144 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
1145 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
1151 static bool bgp_role_violation(struct peer
*peer
)
1153 uint8_t local_role
= peer
->local_role
;
1154 uint8_t remote_role
= peer
->remote_role
;
1156 if (local_role
!= ROLE_UNDEFINED
&& remote_role
!= ROLE_UNDEFINED
&&
1157 !((local_role
== ROLE_PEER
&& remote_role
== ROLE_PEER
) ||
1158 (local_role
== ROLE_PROVIDER
&& remote_role
== ROLE_CUSTOMER
) ||
1159 (local_role
== ROLE_CUSTOMER
&& remote_role
== ROLE_PROVIDER
) ||
1160 (local_role
== ROLE_RS_SERVER
&& remote_role
== ROLE_RS_CLIENT
) ||
1161 (local_role
== ROLE_RS_CLIENT
&&
1162 remote_role
== ROLE_RS_SERVER
))) {
1163 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1164 BGP_NOTIFY_OPEN_ROLE_MISMATCH
);
1167 if (remote_role
== ROLE_UNDEFINED
&&
1168 CHECK_FLAG(peer
->flags
, PEER_FLAG_ROLE_STRICT_MODE
)) {
1169 const char *err_msg
=
1170 "Strict mode. Please set the role on your side.";
1171 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1172 BGP_NOTIFY_OPEN_ROLE_MISMATCH
,
1173 (uint8_t *)err_msg
, strlen(err_msg
));
1180 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
1181 * Returns 0 if no as4 found, as4cap value otherwise.
1183 as_t
peek_for_as4_capability(struct peer
*peer
, uint16_t length
)
1185 struct stream
*s
= BGP_INPUT(peer
);
1186 size_t orig_getp
= stream_get_getp(s
);
1187 size_t end
= orig_getp
+ length
;
1190 if (BGP_DEBUG(as4
, AS4
))
1192 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u, peeking for as4",
1193 peer
->host
, length
);
1194 /* the error cases we DONT handle, we ONLY try to read as4 out of
1195 * correctly formatted options.
1197 while (stream_get_getp(s
) < end
) {
1199 uint16_t opt_length
;
1201 /* Ensure we can read the option type */
1202 if (stream_get_getp(s
) + 1 > end
)
1205 /* Fetch the option type */
1206 opt_type
= stream_getc(s
);
1209 * Check the length and fetch the opt_length
1210 * If the peer is BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer)
1211 * then we do a getw which is 2 bytes. So we need to
1212 * ensure that we can read that as well
1214 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1215 if (stream_get_getp(s
) + 2 > end
)
1218 opt_length
= stream_getw(s
);
1220 if (stream_get_getp(s
) + 1 > end
)
1223 opt_length
= stream_getc(s
);
1226 /* Option length check. */
1227 if (stream_get_getp(s
) + opt_length
> end
)
1230 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1231 unsigned long capd_start
= stream_get_getp(s
);
1232 unsigned long capd_end
= capd_start
+ opt_length
;
1234 assert(capd_end
<= end
);
1236 while (stream_get_getp(s
) < capd_end
) {
1237 struct capability_header hdr
;
1239 if (stream_get_getp(s
) + 2 > capd_end
)
1242 hdr
.code
= stream_getc(s
);
1243 hdr
.length
= stream_getc(s
);
1245 if ((stream_get_getp(s
) + hdr
.length
)
1249 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1250 if (BGP_DEBUG(as4
, AS4
))
1252 "[AS4] found AS4 capability, about to parse");
1253 as4
= bgp_capability_as4(peer
, &hdr
);
1257 stream_forward_getp(s
, hdr
.length
);
1263 stream_set_getp(s
, orig_getp
);
1268 * Parse open option.
1270 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1272 int bgp_open_option_parse(struct peer
*peer
, uint16_t length
,
1277 uint8_t error_data
[BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
];
1278 struct stream
*s
= BGP_INPUT(peer
);
1279 size_t end
= stream_get_getp(s
) + length
;
1283 if (bgp_debug_neighbor_events(peer
))
1284 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1285 peer
->host
, length
);
1287 /* Unset any previously received GR capability. */
1288 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
1290 while (stream_get_getp(s
) < end
) {
1292 uint16_t opt_length
;
1295 * Check that we can read the opt_type and fetch it
1297 if (STREAM_READABLE(s
) < 1) {
1298 zlog_info("%s Option length error", peer
->host
);
1299 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1300 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1303 opt_type
= stream_getc(s
);
1306 * Check the length of the stream to ensure that
1307 * FRR can properly read the opt_length. Then read it
1309 if (BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)) {
1310 if (STREAM_READABLE(s
) < 2) {
1311 zlog_info("%s Option length error", peer
->host
);
1312 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1313 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1317 opt_length
= stream_getw(s
);
1319 if (STREAM_READABLE(s
) < 1) {
1320 zlog_info("%s Option length error", peer
->host
);
1321 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1322 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1326 opt_length
= stream_getc(s
);
1329 /* Option length check. */
1330 if (STREAM_READABLE(s
) < opt_length
) {
1331 zlog_info("%s Option length error (%d)", peer
->host
,
1333 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1334 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1338 if (bgp_debug_neighbor_events(peer
))
1340 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1341 peer
->host
, opt_type
,
1342 opt_type
== BGP_OPEN_OPT_AUTH
1344 : opt_type
== BGP_OPEN_OPT_CAP
1350 case BGP_OPEN_OPT_AUTH
:
1351 ret
= bgp_auth_parse(peer
, opt_length
);
1353 case BGP_OPEN_OPT_CAP
:
1354 ret
= bgp_capability_parse(peer
, opt_length
,
1355 mp_capability
, &error
);
1358 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1359 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1364 /* Parse error. To accumulate all unsupported capability codes,
1365 bgp_capability_parse does not return -1 when encounter
1366 unsupported capability code. To detect that, please check
1367 error and erro_data pointer, like below. */
1372 /* All OPEN option is parsed. Check capability when strict compare
1374 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1375 /* If Unsupported Capability exists. */
1376 if (error
!= error_data
) {
1377 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1378 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1380 error
- error_data
);
1384 /* Check local capability does not negotiated with remote
1386 if (!strict_capability_same(peer
)) {
1387 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1388 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1393 /* Extended Message Support */
1394 peer
->max_packet_size
=
1395 (CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
)
1396 && CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
))
1397 ? BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE
1398 : BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1400 /* Check that roles are corresponding to each other */
1401 if (bgp_role_violation(peer
))
1404 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1407 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1408 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1409 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1410 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1411 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1412 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1413 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1414 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1415 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1416 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1417 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1418 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1419 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1420 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1421 flog_err(EC_BGP_PKT_OPEN
,
1422 "%s [Error] Configured AFI/SAFIs do not overlap with received MP capabilities",
1425 if (error
!= error_data
)
1426 bgp_notify_send_with_data(
1427 peer
, BGP_NOTIFY_OPEN_ERR
,
1428 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1429 error
- error_data
);
1431 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1432 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1439 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1440 afi_t afi
, safi_t safi
, uint8_t code
,
1441 bool ext_opt_params
)
1447 unsigned long numberp
;
1448 int number_of_orfs
= 0;
1449 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1450 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1452 /* Convert AFI, SAFI to values for packet. */
1453 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1455 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1456 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1457 ext_opt_params
? stream_putw(s
, 0)
1458 : stream_putc(s
, 0); /* Capability Length */
1459 stream_putc(s
, code
); /* Capability Code */
1460 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1461 stream_putc(s
, 0); /* ORF Length */
1462 stream_putw(s
, pkt_afi
);
1464 stream_putc(s
, pkt_safi
);
1465 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1466 stream_putc(s
, 0); /* Number of ORFs */
1468 /* Address Prefix ORF */
1469 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1470 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1471 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1473 : ORF_TYPE_PREFIX_OLD
));
1475 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1476 PEER_FLAG_ORF_PREFIX_SM
)
1477 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1478 PEER_FLAG_ORF_PREFIX_RM
)) {
1479 SET_FLAG(peer
->af_cap
[afi
][safi
],
1480 PEER_CAP_ORF_PREFIX_SM_ADV
);
1481 SET_FLAG(peer
->af_cap
[afi
][safi
],
1482 PEER_CAP_ORF_PREFIX_RM_ADV
);
1483 stream_putc(s
, ORF_MODE_BOTH
);
1484 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1485 PEER_FLAG_ORF_PREFIX_SM
)) {
1486 SET_FLAG(peer
->af_cap
[afi
][safi
],
1487 PEER_CAP_ORF_PREFIX_SM_ADV
);
1488 stream_putc(s
, ORF_MODE_SEND
);
1490 SET_FLAG(peer
->af_cap
[afi
][safi
],
1491 PEER_CAP_ORF_PREFIX_RM_ADV
);
1492 stream_putc(s
, ORF_MODE_RECEIVE
);
1497 /* Total Number of ORFs. */
1498 stream_putc_at(s
, numberp
, number_of_orfs
);
1500 /* Total ORF Len. */
1501 orf_len
= stream_get_endp(s
) - orfp
- 1;
1502 stream_putc_at(s
, orfp
, orf_len
);
1504 /* Total Capability Len. */
1505 cap_len
= stream_get_endp(s
) - capp
- 1;
1506 ext_opt_params
? stream_putw_at(s
, capp
, cap_len
)
1507 : stream_putc_at(s
, capp
, cap_len
);
1510 static void bgp_peer_send_gr_capability(struct stream
*s
, struct peer
*peer
,
1511 bool ext_opt_params
)
1514 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1517 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1518 uint32_t restart_time
;
1519 unsigned long capp
= 0;
1520 unsigned long rcapp
= 0;
1522 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
1523 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
))
1526 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1527 zlog_debug("[BGP_GR] Sending helper Capability for Peer :%s :",
1530 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1531 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1532 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1533 ext_opt_params
? stream_putw(s
, 0)
1534 : stream_putc(s
, 0); /* Capability Length */
1535 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1536 /* Set Restart Capability Len Pointer */
1537 rcapp
= stream_get_endp(s
);
1539 restart_time
= peer
->bgp
->restart_time
;
1540 if (peer
->bgp
->t_startup
) {
1541 SET_FLAG(restart_time
, GRACEFUL_RESTART_R_BIT
);
1542 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV
);
1543 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1544 zlog_debug("[BGP_GR] Sending R-Bit for peer: %s",
1548 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GRACEFUL_NOTIFICATION
)) {
1549 SET_FLAG(restart_time
, GRACEFUL_RESTART_N_BIT
);
1550 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_ADV
);
1551 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1552 zlog_debug("[BGP_GR] Sending N-Bit for peer: %s",
1556 stream_putw(s
, restart_time
);
1558 /* Send address-family specific graceful-restart capability
1559 * only when GR config is present
1561 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)) {
1562 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)
1563 && BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1564 zlog_debug("[BGP_GR] F bit Set");
1566 FOREACH_AFI_SAFI (afi
, safi
) {
1567 if (!peer
->afc
[afi
][safi
])
1570 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1572 "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
1575 /* Convert AFI, SAFI to values for
1578 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1580 stream_putw(s
, pkt_afi
);
1581 stream_putc(s
, pkt_safi
);
1582 if (CHECK_FLAG(peer
->bgp
->flags
,
1583 BGP_FLAG_GR_PRESERVE_FWD
))
1584 stream_putc(s
, GRACEFUL_RESTART_F_BIT
);
1590 /* Total Graceful restart capability Len. */
1591 len
= stream_get_endp(s
) - rcapp
- 1;
1592 stream_putc_at(s
, rcapp
, len
);
1594 /* Total Capability Len. */
1595 len
= stream_get_endp(s
) - capp
- 1;
1596 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1597 : stream_putc_at(s
, capp
, len
);
1600 static void bgp_peer_send_llgr_capability(struct stream
*s
, struct peer
*peer
,
1601 bool ext_opt_params
)
1604 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1607 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1608 unsigned long capp
= 0;
1609 unsigned long rcapp
= 0;
1611 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
))
1614 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_ADV
);
1616 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1617 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1618 ext_opt_params
? stream_putw(s
, 0)
1619 : stream_putc(s
, 0); /* Capability Length */
1620 stream_putc(s
, CAPABILITY_CODE_LLGR
);
1622 rcapp
= stream_get_endp(s
);
1625 FOREACH_AFI_SAFI (afi
, safi
) {
1626 if (!peer
->afc
[afi
][safi
])
1629 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1631 stream_putw(s
, pkt_afi
);
1632 stream_putc(s
, pkt_safi
);
1633 stream_putc(s
, LLGR_F_BIT
);
1634 stream_put3(s
, peer
->bgp
->llgr_stale_time
);
1636 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_ADV
);
1639 /* Total Long-lived Graceful Restart capability Len. */
1640 len
= stream_get_endp(s
) - rcapp
- 1;
1641 stream_putc_at(s
, rcapp
, len
);
1643 /* Total Capability Len. */
1644 len
= stream_get_endp(s
) - capp
- 1;
1645 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1646 : stream_putc_at(s
, capp
, len
);
1649 /* Fill in capability open option to the packet. */
1650 uint16_t bgp_open_capability(struct stream
*s
, struct peer
*peer
,
1651 bool ext_opt_params
)
1654 unsigned long cp
, capp
, rcapp
, eopl
= 0;
1655 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1658 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1660 uint8_t afi_safi_count
= 0;
1661 int adv_addpath_tx
= 0;
1663 /* Non-Ext OP Len. */
1664 cp
= stream_get_endp(s
);
1667 if (ext_opt_params
) {
1668 /* Non-Ext OP Len. */
1669 stream_putc_at(s
, cp
, BGP_OPEN_NON_EXT_OPT_LEN
);
1671 /* Non-Ext OP Type */
1672 stream_putc(s
, BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH
);
1674 /* Extended Opt. Parm. Length */
1675 eopl
= stream_get_endp(s
);
1679 /* Do not send capability. */
1680 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1681 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1684 /* MP capability for configured AFI, SAFI */
1685 FOREACH_AFI_SAFI (afi
, safi
) {
1686 if (peer
->afc
[afi
][safi
]) {
1687 /* Convert AFI, SAFI to values for packet. */
1688 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1691 peer
->afc_adv
[afi
][safi
] = 1;
1692 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1694 ? stream_putw(s
, CAPABILITY_CODE_MP_LEN
+ 2)
1695 : stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1696 stream_putc(s
, CAPABILITY_CODE_MP
);
1697 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1698 stream_putw(s
, pkt_afi
);
1700 stream_putc(s
, pkt_safi
);
1702 /* Extended nexthop capability - currently
1703 * supporting RFC-5549 for
1704 * Link-Local peering only
1706 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1707 && peer
->su
.sa
.sa_family
== AF_INET6
1709 && (safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
1710 || safi
== SAFI_LABELED_UNICAST
)) {
1711 /* RFC 5549 Extended Next Hop Encoding
1713 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1714 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1717 CAPABILITY_CODE_ENHE_LEN
1720 CAPABILITY_CODE_ENHE_LEN
1722 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1723 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1725 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1726 PEER_CAP_ENHE_AF_ADV
);
1727 stream_putw(s
, pkt_afi
);
1728 stream_putw(s
, pkt_safi
);
1729 stream_putw(s
, afi_int2iana(AFI_IP6
));
1731 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1732 PEER_CAP_ENHE_AF_RCV
))
1733 SET_FLAG(peer
->af_cap
[afi
][safi
],
1734 PEER_CAP_ENHE_AF_NEGO
);
1739 /* Route refresh. */
1740 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1741 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1742 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1743 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1744 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1745 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1746 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1747 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1748 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1749 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1750 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1752 /* Enhanced Route Refresh. */
1753 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_ADV
);
1754 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1755 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2)
1756 : stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2);
1757 stream_putc(s
, CAPABILITY_CODE_ENHANCED_RR
);
1758 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
);
1761 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1762 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1763 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_AS4_LEN
+ 2)
1764 : stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1765 stream_putc(s
, CAPABILITY_CODE_AS4
);
1766 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1767 if (peer
->change_local_as
)
1768 local_as
= peer
->change_local_as
;
1770 local_as
= peer
->local_as
;
1771 stream_putl(s
, local_as
);
1773 /* Extended Message Support */
1774 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
);
1775 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1776 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2)
1777 : stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2);
1778 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE
);
1779 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
);
1782 if (peer
->local_role
!= ROLE_UNDEFINED
) {
1783 SET_FLAG(peer
->cap
, PEER_CAP_ROLE_ADV
);
1784 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1785 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
+ 2);
1786 stream_putc(s
, CAPABILITY_CODE_ROLE
);
1787 stream_putc(s
, CAPABILITY_CODE_ROLE_LEN
);
1788 stream_putc(s
, peer
->local_role
);
1792 FOREACH_AFI_SAFI (afi
, safi
) {
1793 if (peer
->afc
[afi
][safi
]) {
1796 /* Only advertise addpath TX if a feature that
1799 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1804 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1805 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1807 ? stream_putw(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1809 : stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1811 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1812 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1814 FOREACH_AFI_SAFI (afi
, safi
) {
1815 if (peer
->afc
[afi
][safi
]) {
1816 bool adv_addpath_rx
=
1817 !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1818 PEER_FLAG_DISABLE_ADDPATH_RX
);
1821 /* Convert AFI, SAFI to values for packet. */
1822 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1825 stream_putw(s
, pkt_afi
);
1826 stream_putc(s
, pkt_safi
);
1828 if (adv_addpath_rx
) {
1829 SET_FLAG(flags
, BGP_ADDPATH_RX
);
1830 SET_FLAG(peer
->af_cap
[afi
][safi
],
1831 PEER_CAP_ADDPATH_AF_RX_ADV
);
1833 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1834 PEER_CAP_ADDPATH_AF_RX_ADV
);
1837 if (adv_addpath_tx
) {
1838 SET_FLAG(flags
, BGP_ADDPATH_TX
);
1839 SET_FLAG(peer
->af_cap
[afi
][safi
],
1840 PEER_CAP_ADDPATH_AF_TX_ADV
);
1842 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1843 PEER_CAP_ADDPATH_AF_TX_ADV
);
1846 stream_putc(s
, flags
);
1850 /* ORF capability. */
1851 FOREACH_AFI_SAFI (afi
, safi
) {
1852 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1853 PEER_FLAG_ORF_PREFIX_SM
)
1854 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1855 PEER_FLAG_ORF_PREFIX_RM
)) {
1856 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1857 CAPABILITY_CODE_ORF_OLD
,
1859 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1860 CAPABILITY_CODE_ORF
,
1865 /* Dynamic capability. */
1866 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1867 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1868 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1870 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1871 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1872 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1873 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1874 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1876 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1877 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1878 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1879 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1882 /* Hostname capability */
1883 if (cmd_hostname_get()) {
1884 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1885 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1886 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1887 ext_opt_params
? stream_putw(s
, 0)
1888 : stream_putc(s
, 0); /* Capability Length */
1889 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1890 capp
= stream_get_endp(s
);
1891 stream_putc(s
, 0); /* dummy len for now */
1892 len
= strlen(cmd_hostname_get());
1893 if (len
> BGP_MAX_HOSTNAME
)
1894 len
= BGP_MAX_HOSTNAME
;
1896 stream_putc(s
, len
);
1897 stream_put(s
, cmd_hostname_get(), len
);
1898 if (cmd_domainname_get()) {
1899 len
= strlen(cmd_domainname_get());
1900 if (len
> BGP_MAX_HOSTNAME
)
1901 len
= BGP_MAX_HOSTNAME
;
1903 stream_putc(s
, len
);
1904 stream_put(s
, cmd_domainname_get(), len
);
1906 stream_putc(s
, 0); /* 0 length */
1908 /* Set the lengths straight */
1909 len
= stream_get_endp(s
) - rcapp
- 1;
1910 ext_opt_params
? stream_putw_at(s
, rcapp
, len
- 1)
1911 : stream_putc_at(s
, rcapp
, len
);
1913 len
= stream_get_endp(s
) - capp
- 1;
1914 stream_putc_at(s
, capp
, len
);
1916 if (bgp_debug_neighbor_events(peer
))
1918 "%s Sending hostname cap with hn = %s, dn = %s",
1919 peer
->host
, cmd_hostname_get(),
1920 cmd_domainname_get());
1923 bgp_peer_send_gr_capability(s
, peer
, ext_opt_params
);
1924 bgp_peer_send_llgr_capability(s
, peer
, ext_opt_params
);
1926 /* Total Opt Parm Len. */
1927 len
= stream_get_endp(s
) - cp
- 1;
1929 if (ext_opt_params
) {
1930 len
= stream_get_endp(s
) - eopl
- 2;
1931 stream_putw_at(s
, eopl
, len
);
1933 stream_putc_at(s
, cp
, len
);