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"},
63 /* Minimum sizes for length field of each cap (so not inc. the header) */
64 static const size_t cap_minsizes
[] = {
65 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
66 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
67 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
68 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
69 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
70 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
71 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
72 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
73 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
74 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
75 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
76 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
77 [CAPABILITY_CODE_ENHANCED_RR
] = CAPABILITY_CODE_ENHANCED_LEN
,
78 [CAPABILITY_CODE_EXT_MESSAGE
] = CAPABILITY_CODE_EXT_MESSAGE_LEN
,
79 [CAPABILITY_CODE_LLGR
] = CAPABILITY_CODE_LLGR_LEN
,
82 /* value the capability must be a multiple of.
83 * 0-data capabilities won't be checked against this.
84 * Other capabilities whose data doesn't fall on convenient boundaries for this
85 * table should be set to 1.
87 static const size_t cap_modsizes
[] = {
88 [CAPABILITY_CODE_MP
] = 4,
89 [CAPABILITY_CODE_REFRESH
] = 1,
90 [CAPABILITY_CODE_ORF
] = 1,
91 [CAPABILITY_CODE_RESTART
] = 1,
92 [CAPABILITY_CODE_AS4
] = 4,
93 [CAPABILITY_CODE_ADDPATH
] = 4,
94 [CAPABILITY_CODE_DYNAMIC
] = 1,
95 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
96 [CAPABILITY_CODE_ENHE
] = 6,
97 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
98 [CAPABILITY_CODE_ORF_OLD
] = 1,
99 [CAPABILITY_CODE_FQDN
] = 1,
100 [CAPABILITY_CODE_ENHANCED_RR
] = 1,
101 [CAPABILITY_CODE_EXT_MESSAGE
] = 1,
102 [CAPABILITY_CODE_LLGR
] = 1,
105 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
106 negotiate remote peer supports extentions or not. But if
107 remote-peer doesn't supports negotiation process itself. We would
108 like to do manual configuration.
110 So there is many configurable point. First of all we want set each
111 peer whether we send capability negotiation to the peer or not.
112 Next, if we send capability to the peer we want to set my capability
113 inforation at each peer. */
115 void bgp_capability_vty_out(struct vty
*vty
, struct peer
*peer
, bool use_json
,
116 json_object
*json_neigh
)
120 struct capability_mp_data mpc
;
121 struct capability_header
*hdr
;
122 json_object
*json_cap
= NULL
;
125 json_cap
= json_object_new_object();
127 pnt
= peer
->notify
.data
;
128 end
= pnt
+ peer
->notify
.length
;
131 if (pnt
+ sizeof(struct capability_mp_data
) + 2 > end
)
134 hdr
= (struct capability_header
*)pnt
;
135 if (pnt
+ hdr
->length
+ 2 > end
)
138 memcpy(&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
140 if (hdr
->code
== CAPABILITY_CODE_MP
) {
144 (void)bgp_map_afi_safi_iana2int(ntohs(mpc
.afi
),
145 mpc
.safi
, &afi
, &safi
);
150 json_object_string_add(
152 "capabilityErrorMultiProtocolAfi",
156 json_object_string_add(
158 "capabilityErrorMultiProtocolAfi",
162 json_object_string_add(
164 "capabilityErrorMultiProtocolAfi",
170 "capabilityErrorMultiProtocolAfiUnknown",
176 json_object_string_add(
178 "capabilityErrorMultiProtocolSafi",
182 json_object_string_add(
184 "capabilityErrorMultiProtocolSafi",
187 case SAFI_LABELED_UNICAST
:
188 json_object_string_add(
190 "capabilityErrorMultiProtocolSafi",
194 json_object_string_add(
196 "capabilityErrorMultiProtocolSafi",
200 json_object_string_add(
202 "capabilityErrorMultiProtocolSafi",
206 json_object_string_add(
208 "capabilityErrorMultiProtocolSafi",
212 json_object_string_add(
214 "capabilityErrorMultiProtocolSafi",
220 "capabilityErrorMultiProtocolSafiUnknown",
226 " Capability error for: Multi protocol ");
229 vty_out(vty
, "AFI IPv4, ");
232 vty_out(vty
, "AFI IPv6, ");
235 vty_out(vty
, "AFI L2VPN, ");
238 vty_out(vty
, "AFI Unknown %d, ",
244 vty_out(vty
, "SAFI Unicast");
247 vty_out(vty
, "SAFI Multicast");
249 case SAFI_LABELED_UNICAST
:
250 vty_out(vty
, "SAFI Labeled-unicast");
253 vty_out(vty
, "SAFI MPLS-labeled VPN");
256 vty_out(vty
, "SAFI ENCAP");
259 vty_out(vty
, "SAFI FLOWSPEC");
262 vty_out(vty
, "SAFI EVPN");
265 vty_out(vty
, "SAFI Unknown %d ",
271 } else if (hdr
->code
>= 128) {
275 "capabilityErrorVendorSpecificCapabilityCode",
279 " Capability error: vendor specific capability code %d",
285 "capabilityErrorUnknownCapabilityCode",
289 " Capability error: unknown capability code %d",
292 pnt
+= hdr
->length
+ 2;
295 json_object_object_add(json_neigh
, "capabilityErrors",
299 static void bgp_capability_mp_data(struct stream
*s
,
300 struct capability_mp_data
*mpc
)
302 mpc
->afi
= stream_getw(s
);
303 mpc
->reserved
= stream_getc(s
);
304 mpc
->safi
= stream_getc(s
);
307 /* Set negotiated capability value. */
308 static int bgp_capability_mp(struct peer
*peer
, struct capability_header
*hdr
)
310 struct capability_mp_data mpc
;
311 struct stream
*s
= BGP_INPUT(peer
);
315 /* Verify length is 4 */
316 if (hdr
->length
!= 4) {
318 EC_BGP_CAPABILITY_INVALID_LENGTH
,
319 "MP Cap: Received invalid length %d, non-multiple of 4",
324 bgp_capability_mp_data(s
, &mpc
);
326 if (bgp_debug_neighbor_events(peer
))
327 zlog_debug("%s OPEN has %s capability for afi/safi: %s/%s",
328 peer
->host
, lookup_msg(capcode_str
, hdr
->code
, NULL
),
329 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
331 /* Convert AFI, SAFI to internal values, check. */
332 if (bgp_map_afi_safi_iana2int(mpc
.afi
, mpc
.safi
, &afi
, &safi
))
335 /* Now safi remapped, and afi/safi are valid array indices */
336 peer
->afc_recv
[afi
][safi
] = 1;
338 if (peer
->afc
[afi
][safi
])
339 peer
->afc_nego
[afi
][safi
] = 1;
346 static void bgp_capability_orf_not_support(struct peer
*peer
, iana_afi_t afi
,
347 iana_safi_t safi
, uint8_t type
,
350 if (bgp_debug_neighbor_events(peer
))
352 "%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
353 peer
->host
, afi
, safi
, type
, mode
);
356 static const struct message orf_type_str
[] = {
357 {ORF_TYPE_PREFIX
, "Prefixlist"},
358 {ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)"},
361 static const struct message orf_mode_str
[] = {{ORF_MODE_RECEIVE
, "Receive"},
362 {ORF_MODE_SEND
, "Send"},
363 {ORF_MODE_BOTH
, "Both"},
366 static int bgp_capability_orf_entry(struct peer
*peer
,
367 struct capability_header
*hdr
)
369 struct stream
*s
= BGP_INPUT(peer
);
370 struct capability_mp_data mpc
;
374 iana_safi_t pkt_safi
;
378 uint16_t sm_cap
= 0; /* capability send-mode receive */
379 uint16_t rm_cap
= 0; /* capability receive-mode receive */
382 /* ORF Entry header */
383 bgp_capability_mp_data(s
, &mpc
);
384 num
= stream_getc(s
);
388 if (bgp_debug_neighbor_events(peer
))
389 zlog_debug("%s ORF Cap entry for afi/safi: %s/%s", peer
->host
,
390 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
392 /* Convert AFI, SAFI to internal values, check. */
393 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
395 "%s Addr-family %d/%d not supported. Ignoring the ORF capability",
396 peer
->host
, pkt_afi
, pkt_safi
);
403 /* validate number field */
404 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
406 "%s ORF Capability entry length error, Cap length %u, num %u",
407 peer
->host
, hdr
->length
, num
);
408 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
409 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
413 for (i
= 0; i
< num
; i
++) {
414 type
= stream_getc(s
);
415 mode
= stream_getc(s
);
417 /* ORF Mode error check */
421 case ORF_MODE_RECEIVE
:
424 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
428 /* ORF Type and afi/safi error checks */
429 /* capcode versus type */
431 case CAPABILITY_CODE_ORF
:
433 case ORF_TYPE_PREFIX
:
436 bgp_capability_orf_not_support(
437 peer
, pkt_afi
, pkt_safi
, type
, mode
);
441 case CAPABILITY_CODE_ORF_OLD
:
443 case ORF_TYPE_PREFIX_OLD
:
446 bgp_capability_orf_not_support(
447 peer
, pkt_afi
, pkt_safi
, type
, mode
);
452 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
458 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
459 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
460 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
461 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
466 if (bgp_debug_neighbor_events(peer
))
468 "%s OPEN has %s ORF capability as %s for afi/safi: %s/%s",
470 lookup_msg(orf_type_str
, type
, NULL
),
471 lookup_msg(orf_mode_str
, mode
, NULL
),
472 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
474 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
475 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
476 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
477 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
478 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
479 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
481 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
488 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
489 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
492 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
494 case ORF_MODE_RECEIVE
:
495 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
502 static int bgp_capability_restart(struct peer
*peer
,
503 struct capability_header
*caphdr
)
505 struct stream
*s
= BGP_INPUT(peer
);
506 uint16_t restart_flag_time
;
507 size_t end
= stream_get_getp(s
) + caphdr
->length
;
509 /* Verify length is a multiple of 4 */
510 if ((caphdr
->length
- 2) % 4) {
512 EC_BGP_CAPABILITY_INVALID_LENGTH
,
513 "Restart Cap: Received invalid length %d, non-multiple of 4",
518 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
519 restart_flag_time
= stream_getw(s
);
521 /* The most significant bit is defined in [RFC4724] as
522 * the Restart State ("R") bit.
524 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_R_BIT
))
525 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
527 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
);
529 /* The second most significant bit is defined in this
530 * document as the Graceful Notification ("N") bit.
532 if (CHECK_FLAG(restart_flag_time
, GRACEFUL_RESTART_N_BIT
))
533 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
535 UNSET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
);
537 UNSET_FLAG(restart_flag_time
, 0xF000);
538 peer
->v_gr_restart
= restart_flag_time
;
540 if (bgp_debug_neighbor_events(peer
)) {
542 "%s Peer has%srestarted. Restart Time: %d, N-bit set: %s",
544 CHECK_FLAG(peer
->cap
,
545 PEER_CAP_GRACEFUL_RESTART_R_BIT_RCV
)
549 CHECK_FLAG(peer
->cap
,
550 PEER_CAP_GRACEFUL_RESTART_N_BIT_RCV
)
555 while (stream_get_getp(s
) + 4 <= end
) {
558 iana_afi_t pkt_afi
= stream_getw(s
);
559 iana_safi_t pkt_safi
= stream_getc(s
);
560 uint8_t flag
= stream_getc(s
);
562 /* Convert AFI, SAFI to internal values, check. */
563 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
564 if (bgp_debug_neighbor_events(peer
))
566 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Graceful Restart capability for this AFI/SAFI",
567 peer
->host
, iana_afi2str(pkt_afi
),
568 iana_safi2str(pkt_safi
));
569 } else if (!peer
->afc
[afi
][safi
]) {
570 if (bgp_debug_neighbor_events(peer
))
572 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Graceful Restart capability",
573 peer
->host
, iana_afi2str(pkt_afi
),
574 iana_safi2str(pkt_safi
));
576 if (bgp_debug_neighbor_events(peer
))
578 "%s Address family %s is%spreserved",
579 peer
->host
, get_afi_safi_str(afi
, safi
, false),
581 peer
->af_cap
[afi
][safi
],
582 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
586 SET_FLAG(peer
->af_cap
[afi
][safi
],
587 PEER_CAP_RESTART_AF_RCV
);
588 if (CHECK_FLAG(flag
, GRACEFUL_RESTART_F_BIT
))
589 SET_FLAG(peer
->af_cap
[afi
][safi
],
590 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
596 static int bgp_capability_llgr(struct peer
*peer
,
597 struct capability_header
*caphdr
)
599 struct stream
*s
= BGP_INPUT(peer
);
600 size_t end
= stream_get_getp(s
) + caphdr
->length
;
602 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_RCV
);
604 while (stream_get_getp(s
) + 4 <= end
) {
607 iana_afi_t pkt_afi
= stream_getw(s
);
608 iana_safi_t pkt_safi
= stream_getc(s
);
609 uint8_t flags
= stream_getc(s
);
610 uint32_t stale_time
= stream_get3(s
);
612 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
613 if (bgp_debug_neighbor_events(peer
))
615 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Long-lived Graceful Restart capability for this AFI/SAFI",
616 peer
->host
, iana_afi2str(pkt_afi
),
617 iana_safi2str(pkt_safi
));
618 } else if (!peer
->afc
[afi
][safi
]
619 || !CHECK_FLAG(peer
->af_cap
[afi
][safi
],
620 PEER_CAP_RESTART_AF_RCV
)) {
621 if (bgp_debug_neighbor_events(peer
))
623 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Long-lived Graceful Restart capability",
624 peer
->host
, iana_afi2str(pkt_afi
),
625 iana_safi2str(pkt_safi
));
627 if (bgp_debug_neighbor_events(peer
))
629 "%s Addr-family %s/%s(afi/safi) Long-lived Graceful Restart capability stale time %u sec",
630 peer
->host
, iana_afi2str(pkt_afi
),
631 iana_safi2str(pkt_safi
), stale_time
);
633 peer
->llgr
[afi
][safi
].flags
= flags
;
634 peer
->llgr
[afi
][safi
].stale_time
=
635 MIN(stale_time
, peer
->bgp
->llgr_stale_time
);
636 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_RCV
);
643 /* Unlike other capability parsing routines, this one returns 0 on error */
644 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
646 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
648 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
649 flog_err(EC_BGP_PKT_OPEN
,
650 "%s AS4 capability has incorrect data length %d",
651 peer
->host
, hdr
->length
);
655 as_t as4
= stream_getl(BGP_INPUT(peer
));
657 if (BGP_DEBUG(as4
, AS4
))
659 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
664 static int bgp_capability_ext_message(struct peer
*peer
,
665 struct capability_header
*hdr
)
667 if (hdr
->length
!= CAPABILITY_CODE_EXT_MESSAGE_LEN
) {
670 "%s: BGP Extended Message capability has incorrect data length %d",
671 peer
->host
, hdr
->length
);
675 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
);
680 static int bgp_capability_addpath(struct peer
*peer
,
681 struct capability_header
*hdr
)
683 struct stream
*s
= BGP_INPUT(peer
);
684 size_t end
= stream_get_getp(s
) + hdr
->length
;
686 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
688 /* Verify length is a multiple of 4 */
689 if (hdr
->length
% 4) {
691 EC_BGP_CAPABILITY_INVALID_LENGTH
,
692 "Add Path: Received invalid length %d, non-multiple of 4",
697 while (stream_get_getp(s
) + 4 <= end
) {
700 iana_afi_t pkt_afi
= stream_getw(s
);
701 iana_safi_t pkt_safi
= stream_getc(s
);
702 uint8_t send_receive
= stream_getc(s
);
704 if (bgp_debug_neighbor_events(peer
))
706 "%s OPEN has %s capability for afi/safi: %s/%s%s%s",
708 lookup_msg(capcode_str
, hdr
->code
, NULL
),
709 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
),
710 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
712 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
715 /* Convert AFI, SAFI to internal values, check. */
716 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
717 if (bgp_debug_neighbor_events(peer
))
719 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Addpath Attribute for this AFI/SAFI",
720 peer
->host
, iana_afi2str(pkt_afi
),
721 iana_safi2str(pkt_safi
));
723 } else if (!peer
->afc
[afi
][safi
]) {
724 if (bgp_debug_neighbor_events(peer
))
726 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the AddPath capability for this AFI/SAFI",
727 peer
->host
, iana_afi2str(pkt_afi
),
728 iana_safi2str(pkt_safi
));
732 if (send_receive
& BGP_ADDPATH_RX
)
733 SET_FLAG(peer
->af_cap
[afi
][safi
],
734 PEER_CAP_ADDPATH_AF_RX_RCV
);
736 if (send_receive
& BGP_ADDPATH_TX
)
737 SET_FLAG(peer
->af_cap
[afi
][safi
],
738 PEER_CAP_ADDPATH_AF_TX_RCV
);
744 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
746 struct stream
*s
= BGP_INPUT(peer
);
747 size_t end
= stream_get_getp(s
) + hdr
->length
;
749 /* Verify length is a multiple of 4 */
750 if (hdr
->length
% 6) {
752 EC_BGP_CAPABILITY_INVALID_LENGTH
,
753 "Extended NH: Received invalid length %d, non-multiple of 6",
758 while (stream_get_getp(s
) + 6 <= end
) {
759 iana_afi_t pkt_afi
= stream_getw(s
);
761 iana_safi_t pkt_safi
= stream_getw(s
);
763 iana_afi_t pkt_nh_afi
= stream_getw(s
);
766 if (bgp_debug_neighbor_events(peer
))
768 "%s Received with afi/safi/next-hop afi: %s/%s/%u",
769 peer
->host
, iana_afi2str(pkt_afi
),
770 iana_safi2str(pkt_safi
), pkt_nh_afi
);
772 /* Convert AFI, SAFI to internal values, check. */
773 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
774 if (bgp_debug_neighbor_events(peer
))
776 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the ENHE Attribute for this AFI/SAFI",
777 peer
->host
, iana_afi2str(pkt_afi
),
778 iana_safi2str(pkt_safi
));
782 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
784 * the Nexthop AFI being IPv6. A future spec may introduce other
785 * possibilities, so we ignore other values with a log. Also,
787 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
790 nh_afi
= afi_iana2int(pkt_nh_afi
);
792 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
793 || !(safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
794 || safi
== SAFI_LABELED_UNICAST
)) {
796 EC_BGP_CAPABILITY_INVALID_DATA
,
797 "%s Unexpected afi/safi/next-hop afi: %s/%s/%u in Extended Next-hop capability, ignoring",
798 peer
->host
, iana_afi2str(pkt_afi
),
799 iana_safi2str(pkt_safi
), pkt_nh_afi
);
803 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
805 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
806 SET_FLAG(peer
->af_cap
[afi
][safi
],
807 PEER_CAP_ENHE_AF_NEGO
);
810 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
815 static int bgp_capability_hostname(struct peer
*peer
,
816 struct capability_header
*hdr
)
818 struct stream
*s
= BGP_INPUT(peer
);
819 char str
[BGP_MAX_HOSTNAME
+ 1];
820 size_t end
= stream_get_getp(s
) + hdr
->length
;
823 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
825 len
= stream_getc(s
);
826 if (stream_get_getp(s
) + len
> end
) {
828 EC_BGP_CAPABILITY_INVALID_DATA
,
829 "%s: Received malformed hostname capability from peer %s",
830 __func__
, peer
->host
);
834 if (len
> BGP_MAX_HOSTNAME
) {
835 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
836 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
837 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
839 stream_get(str
, s
, len
);
844 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
845 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
847 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
850 if (stream_get_getp(s
) + 1 > end
) {
852 EC_BGP_CAPABILITY_INVALID_DATA
,
853 "%s: Received invalid domain name len (hostname capability) from peer %s",
854 __func__
, peer
->host
);
858 len
= stream_getc(s
);
859 if (stream_get_getp(s
) + len
> end
) {
861 EC_BGP_CAPABILITY_INVALID_DATA
,
862 "%s: Received runt domain name (hostname capability) from peer %s",
863 __func__
, peer
->host
);
867 if (len
> BGP_MAX_HOSTNAME
) {
868 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
869 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
870 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
872 stream_get(str
, s
, len
);
877 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
879 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
882 if (bgp_debug_neighbor_events(peer
)) {
883 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
884 peer
->hostname
, peer
->domainname
);
891 * Parse given capability.
892 * XXX: This is reading into a stream, but not using stream API
894 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
895 * capabilities were encountered.
897 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
898 int *mp_capability
, uint8_t **error
)
901 struct stream
*s
= BGP_INPUT(peer
);
902 size_t end
= stream_get_getp(s
) + length
;
903 uint16_t restart_flag_time
= 0;
905 assert(STREAM_READABLE(s
) >= length
);
907 while (stream_get_getp(s
) < end
) {
909 uint8_t *sp
= stream_pnt(s
);
910 struct capability_header caphdr
;
913 /* We need at least capability code and capability length. */
914 if (stream_get_getp(s
) + 2 > end
) {
915 zlog_info("%s Capability length error (< header)",
917 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
918 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
922 caphdr
.code
= stream_getc(s
);
923 caphdr
.length
= stream_getc(s
);
924 start
= stream_get_getp(s
);
926 /* Capability length check sanity check. */
927 if (start
+ caphdr
.length
> end
) {
928 zlog_info("%s Capability length error (< length)",
930 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
931 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
935 if (bgp_debug_neighbor_events(peer
))
936 zlog_debug("%s OPEN has %s capability (%u), length %u",
938 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
939 caphdr
.code
, caphdr
.length
);
941 /* Length sanity check, type-specific, for known capabilities */
942 switch (caphdr
.code
) {
943 case CAPABILITY_CODE_MP
:
944 case CAPABILITY_CODE_REFRESH
:
945 case CAPABILITY_CODE_REFRESH_OLD
:
946 case CAPABILITY_CODE_ORF
:
947 case CAPABILITY_CODE_ORF_OLD
:
948 case CAPABILITY_CODE_RESTART
:
949 case CAPABILITY_CODE_AS4
:
950 case CAPABILITY_CODE_ADDPATH
:
951 case CAPABILITY_CODE_DYNAMIC
:
952 case CAPABILITY_CODE_DYNAMIC_OLD
:
953 case CAPABILITY_CODE_ENHE
:
954 case CAPABILITY_CODE_FQDN
:
955 case CAPABILITY_CODE_ENHANCED_RR
:
956 case CAPABILITY_CODE_EXT_MESSAGE
:
958 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
960 "%s %s Capability length error: got %u, expected at least %u",
962 lookup_msg(capcode_str
, caphdr
.code
,
965 (unsigned)cap_minsizes
[caphdr
.code
]);
966 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
967 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
971 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
973 "%s %s Capability length error: got %u, expected a multiple of %u",
975 lookup_msg(capcode_str
, caphdr
.code
,
978 (unsigned)cap_modsizes
[caphdr
.code
]);
979 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
980 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
983 /* we deliberately ignore unknown codes, see below */
988 switch (caphdr
.code
) {
989 case CAPABILITY_CODE_MP
: {
992 /* Ignore capability when override-capability is set. */
993 if (!CHECK_FLAG(peer
->flags
,
994 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
995 /* Set negotiated value. */
996 ret
= bgp_capability_mp(peer
, &caphdr
);
998 /* Unsupported Capability. */
1000 /* Store return data. */
1001 memcpy(*error
, sp
, caphdr
.length
+ 2);
1002 *error
+= caphdr
.length
+ 2;
1004 ret
= 0; /* Don't return error for this */
1007 case CAPABILITY_CODE_ENHANCED_RR
:
1008 case CAPABILITY_CODE_REFRESH
:
1009 case CAPABILITY_CODE_REFRESH_OLD
: {
1010 /* BGP refresh capability */
1011 if (caphdr
.code
== CAPABILITY_CODE_ENHANCED_RR
)
1012 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_RCV
);
1013 else if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
1014 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
1016 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
1018 case CAPABILITY_CODE_ORF
:
1019 case CAPABILITY_CODE_ORF_OLD
:
1020 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
1022 case CAPABILITY_CODE_RESTART
:
1023 ret
= bgp_capability_restart(peer
, &caphdr
);
1025 case CAPABILITY_CODE_LLGR
:
1026 ret
= bgp_capability_llgr(peer
, &caphdr
);
1028 case CAPABILITY_CODE_DYNAMIC
:
1029 case CAPABILITY_CODE_DYNAMIC_OLD
:
1030 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
1032 case CAPABILITY_CODE_AS4
:
1033 /* Already handled as a special-case parsing of the
1035 * at the beginning of OPEN processing. So we care not a
1037 * for the value really, only error case.
1039 if (!bgp_capability_as4(peer
, &caphdr
))
1042 case CAPABILITY_CODE_ADDPATH
:
1043 ret
= bgp_capability_addpath(peer
, &caphdr
);
1045 case CAPABILITY_CODE_ENHE
:
1046 ret
= bgp_capability_enhe(peer
, &caphdr
);
1048 case CAPABILITY_CODE_EXT_MESSAGE
:
1049 ret
= bgp_capability_ext_message(peer
, &caphdr
);
1051 case CAPABILITY_CODE_FQDN
:
1052 ret
= bgp_capability_hostname(peer
, &caphdr
);
1055 if (caphdr
.code
> 128) {
1056 /* We don't send Notification for unknown vendor
1058 capabilities. It seems reasonable for now...
1060 flog_warn(EC_BGP_CAPABILITY_VENDOR
,
1061 "%s Vendor specific capability %d",
1062 peer
->host
, caphdr
.code
);
1065 EC_BGP_CAPABILITY_UNKNOWN
,
1066 "%s unrecognized capability code: %d - ignored",
1067 peer
->host
, caphdr
.code
);
1068 memcpy(*error
, sp
, caphdr
.length
+ 2);
1069 *error
+= caphdr
.length
+ 2;
1074 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1075 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1078 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
1079 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
1081 EC_BGP_CAPABILITY_INVALID_LENGTH
,
1082 "%s Cap-parser for %s read past cap-length, %u!",
1084 lookup_msg(capcode_str
, caphdr
.code
,
1087 stream_set_getp(s
, start
+ caphdr
.length
);
1090 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
1091 UNSET_FLAG(restart_flag_time
, 0xF000);
1092 peer
->v_gr_restart
= restart_flag_time
;
1098 static int bgp_auth_parse(struct peer
*peer
, size_t length
)
1100 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1101 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
1105 static bool strict_capability_same(struct peer
*peer
)
1109 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
1110 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
1111 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
1116 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
1117 * Returns 0 if no as4 found, as4cap value otherwise.
1119 as_t
peek_for_as4_capability(struct peer
*peer
, uint16_t length
)
1121 struct stream
*s
= BGP_INPUT(peer
);
1122 size_t orig_getp
= stream_get_getp(s
);
1123 size_t end
= orig_getp
+ length
;
1126 if (BGP_DEBUG(as4
, AS4
))
1128 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u, peeking for as4",
1129 peer
->host
, length
);
1130 /* the error cases we DONT handle, we ONLY try to read as4 out of
1131 * correctly formatted options.
1133 while (stream_get_getp(s
) < end
) {
1135 uint16_t opt_length
;
1137 /* Check the length. */
1138 if (stream_get_getp(s
) + 2 > end
)
1141 /* Fetch option type and length. */
1142 opt_type
= stream_getc(s
);
1143 opt_length
= BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)
1147 /* Option length check. */
1148 if (stream_get_getp(s
) + opt_length
> end
)
1151 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1152 unsigned long capd_start
= stream_get_getp(s
);
1153 unsigned long capd_end
= capd_start
+ opt_length
;
1155 assert(capd_end
<= end
);
1157 while (stream_get_getp(s
) < capd_end
) {
1158 struct capability_header hdr
;
1160 if (stream_get_getp(s
) + 2 > capd_end
)
1163 hdr
.code
= stream_getc(s
);
1164 hdr
.length
= stream_getc(s
);
1166 if ((stream_get_getp(s
) + hdr
.length
)
1170 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1171 if (BGP_DEBUG(as4
, AS4
))
1173 "[AS4] found AS4 capability, about to parse");
1174 as4
= bgp_capability_as4(peer
, &hdr
);
1178 stream_forward_getp(s
, hdr
.length
);
1184 stream_set_getp(s
, orig_getp
);
1189 * Parse open option.
1191 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1193 int bgp_open_option_parse(struct peer
*peer
, uint16_t length
,
1198 uint8_t error_data
[BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
];
1199 struct stream
*s
= BGP_INPUT(peer
);
1200 size_t end
= stream_get_getp(s
) + length
;
1204 if (bgp_debug_neighbor_events(peer
))
1205 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1206 peer
->host
, length
);
1208 /* Unset any previously received GR capability. */
1209 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
1211 while (stream_get_getp(s
) < end
) {
1213 uint16_t opt_length
;
1215 /* Must have at least an OPEN option header */
1216 if (STREAM_READABLE(s
) < 2) {
1217 zlog_info("%s Option length error", peer
->host
);
1218 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1219 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1223 /* Fetch option type and length. */
1224 opt_type
= stream_getc(s
);
1225 opt_length
= BGP_OPEN_EXT_OPT_PARAMS_CAPABLE(peer
)
1229 /* Option length check. */
1230 if (STREAM_READABLE(s
) < opt_length
) {
1231 zlog_info("%s Option length error (%d)", peer
->host
,
1233 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1234 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1238 if (bgp_debug_neighbor_events(peer
))
1240 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1241 peer
->host
, opt_type
,
1242 opt_type
== BGP_OPEN_OPT_AUTH
1244 : opt_type
== BGP_OPEN_OPT_CAP
1250 case BGP_OPEN_OPT_AUTH
:
1251 ret
= bgp_auth_parse(peer
, opt_length
);
1253 case BGP_OPEN_OPT_CAP
:
1254 ret
= bgp_capability_parse(peer
, opt_length
,
1255 mp_capability
, &error
);
1258 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1259 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1264 /* Parse error. To accumulate all unsupported capability codes,
1265 bgp_capability_parse does not return -1 when encounter
1266 unsupported capability code. To detect that, please check
1267 error and erro_data pointer, like below. */
1272 /* All OPEN option is parsed. Check capability when strict compare
1274 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1275 /* If Unsupported Capability exists. */
1276 if (error
!= error_data
) {
1277 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1278 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1280 error
- error_data
);
1284 /* Check local capability does not negotiated with remote
1286 if (!strict_capability_same(peer
)) {
1287 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1288 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1293 /* Extended Message Support */
1294 peer
->max_packet_size
=
1295 (CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_RCV
)
1296 && CHECK_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
))
1297 ? BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE
1298 : BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1300 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1303 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1304 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1305 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1306 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1307 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1308 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1309 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1310 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1311 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1312 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1313 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1314 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1315 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1316 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1317 flog_err(EC_BGP_PKT_OPEN
,
1318 "%s [Error] Configured AFI/SAFIs do not overlap with received MP capabilities",
1321 if (error
!= error_data
)
1322 bgp_notify_send_with_data(
1323 peer
, BGP_NOTIFY_OPEN_ERR
,
1324 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1325 error
- error_data
);
1327 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1328 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1335 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1336 afi_t afi
, safi_t safi
, uint8_t code
,
1337 bool ext_opt_params
)
1343 unsigned long numberp
;
1344 int number_of_orfs
= 0;
1345 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1346 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1348 /* Convert AFI, SAFI to values for packet. */
1349 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1351 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1352 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1353 ext_opt_params
? stream_putw(s
, 0)
1354 : stream_putc(s
, 0); /* Capability Length */
1355 stream_putc(s
, code
); /* Capability Code */
1356 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1357 stream_putc(s
, 0); /* ORF Length */
1358 stream_putw(s
, pkt_afi
);
1360 stream_putc(s
, pkt_safi
);
1361 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1362 stream_putc(s
, 0); /* Number of ORFs */
1364 /* Address Prefix ORF */
1365 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1366 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1367 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1369 : ORF_TYPE_PREFIX_OLD
));
1371 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1372 PEER_FLAG_ORF_PREFIX_SM
)
1373 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1374 PEER_FLAG_ORF_PREFIX_RM
)) {
1375 SET_FLAG(peer
->af_cap
[afi
][safi
],
1376 PEER_CAP_ORF_PREFIX_SM_ADV
);
1377 SET_FLAG(peer
->af_cap
[afi
][safi
],
1378 PEER_CAP_ORF_PREFIX_RM_ADV
);
1379 stream_putc(s
, ORF_MODE_BOTH
);
1380 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1381 PEER_FLAG_ORF_PREFIX_SM
)) {
1382 SET_FLAG(peer
->af_cap
[afi
][safi
],
1383 PEER_CAP_ORF_PREFIX_SM_ADV
);
1384 stream_putc(s
, ORF_MODE_SEND
);
1386 SET_FLAG(peer
->af_cap
[afi
][safi
],
1387 PEER_CAP_ORF_PREFIX_RM_ADV
);
1388 stream_putc(s
, ORF_MODE_RECEIVE
);
1393 /* Total Number of ORFs. */
1394 stream_putc_at(s
, numberp
, number_of_orfs
);
1396 /* Total ORF Len. */
1397 orf_len
= stream_get_endp(s
) - orfp
- 1;
1398 stream_putc_at(s
, orfp
, orf_len
);
1400 /* Total Capability Len. */
1401 cap_len
= stream_get_endp(s
) - capp
- 1;
1402 ext_opt_params
? stream_putw_at(s
, capp
, cap_len
)
1403 : stream_putc_at(s
, capp
, cap_len
);
1406 static void bgp_peer_send_gr_capability(struct stream
*s
, struct peer
*peer
,
1407 bool ext_opt_params
)
1410 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1413 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1414 uint32_t restart_time
;
1415 unsigned long capp
= 0;
1416 unsigned long rcapp
= 0;
1418 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
1419 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
))
1422 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1423 zlog_debug("[BGP_GR] Sending helper Capability for Peer :%s :",
1426 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1427 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1428 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1429 ext_opt_params
? stream_putw(s
, 0)
1430 : stream_putc(s
, 0); /* Capability Length */
1431 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1432 /* Set Restart Capability Len Pointer */
1433 rcapp
= stream_get_endp(s
);
1435 restart_time
= peer
->bgp
->restart_time
;
1436 if (peer
->bgp
->t_startup
) {
1437 SET_FLAG(restart_time
, GRACEFUL_RESTART_R_BIT
);
1438 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_R_BIT_ADV
);
1439 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1440 zlog_debug("[BGP_GR] Sending R-Bit for peer: %s",
1444 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GRACEFUL_NOTIFICATION
)) {
1445 SET_FLAG(restart_time
, GRACEFUL_RESTART_N_BIT
);
1446 SET_FLAG(peer
->cap
, PEER_CAP_GRACEFUL_RESTART_N_BIT_ADV
);
1447 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1448 zlog_debug("[BGP_GR] Sending N-Bit for peer: %s",
1452 stream_putw(s
, restart_time
);
1454 /* Send address-family specific graceful-restart capability
1455 * only when GR config is present
1457 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)) {
1458 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)
1459 && BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1460 zlog_debug("[BGP_GR] F bit Set");
1462 FOREACH_AFI_SAFI (afi
, safi
) {
1463 if (!peer
->afc
[afi
][safi
])
1466 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1468 "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
1471 /* Convert AFI, SAFI to values for
1474 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1476 stream_putw(s
, pkt_afi
);
1477 stream_putc(s
, pkt_safi
);
1478 if (CHECK_FLAG(peer
->bgp
->flags
,
1479 BGP_FLAG_GR_PRESERVE_FWD
))
1480 stream_putc(s
, GRACEFUL_RESTART_F_BIT
);
1486 /* Total Graceful restart capability Len. */
1487 len
= stream_get_endp(s
) - rcapp
- 1;
1488 stream_putc_at(s
, rcapp
, len
);
1490 /* Total Capability Len. */
1491 len
= stream_get_endp(s
) - capp
- 1;
1492 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1493 : stream_putc_at(s
, capp
, len
);
1496 static void bgp_peer_send_llgr_capability(struct stream
*s
, struct peer
*peer
,
1497 bool ext_opt_params
)
1500 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1503 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1504 unsigned long capp
= 0;
1505 unsigned long rcapp
= 0;
1507 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
))
1510 SET_FLAG(peer
->cap
, PEER_CAP_LLGR_ADV
);
1512 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1513 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1514 ext_opt_params
? stream_putw(s
, 0)
1515 : stream_putc(s
, 0); /* Capability Length */
1516 stream_putc(s
, CAPABILITY_CODE_LLGR
);
1518 rcapp
= stream_get_endp(s
);
1521 FOREACH_AFI_SAFI (afi
, safi
) {
1522 if (!peer
->afc
[afi
][safi
])
1525 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1527 stream_putw(s
, pkt_afi
);
1528 stream_putc(s
, pkt_safi
);
1529 stream_putc(s
, LLGR_F_BIT
);
1530 stream_put3(s
, peer
->bgp
->llgr_stale_time
);
1532 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_LLGR_AF_ADV
);
1535 /* Total Long-lived Graceful Restart capability Len. */
1536 len
= stream_get_endp(s
) - rcapp
- 1;
1537 stream_putc_at(s
, rcapp
, len
);
1539 /* Total Capability Len. */
1540 len
= stream_get_endp(s
) - capp
- 1;
1541 ext_opt_params
? stream_putw_at(s
, capp
, len
- 1)
1542 : stream_putc_at(s
, capp
, len
);
1545 /* Fill in capability open option to the packet. */
1546 uint16_t bgp_open_capability(struct stream
*s
, struct peer
*peer
,
1547 bool ext_opt_params
)
1550 unsigned long cp
, capp
, rcapp
, eopl
= 0;
1551 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
1554 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
1556 uint8_t afi_safi_count
= 0;
1557 int adv_addpath_tx
= 0;
1559 /* Non-Ext OP Len. */
1560 cp
= stream_get_endp(s
);
1563 if (ext_opt_params
) {
1564 /* Non-Ext OP Len. */
1565 stream_putc_at(s
, cp
, BGP_OPEN_NON_EXT_OPT_LEN
);
1567 /* Non-Ext OP Type */
1568 stream_putc(s
, BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH
);
1570 /* Extended Opt. Parm. Length */
1571 eopl
= stream_get_endp(s
);
1575 /* Do not send capability. */
1576 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1577 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1580 /* MP capability for configured AFI, SAFI */
1581 FOREACH_AFI_SAFI (afi
, safi
) {
1582 if (peer
->afc
[afi
][safi
]) {
1583 /* Convert AFI, SAFI to values for packet. */
1584 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1587 peer
->afc_adv
[afi
][safi
] = 1;
1588 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1590 ? stream_putw(s
, CAPABILITY_CODE_MP_LEN
+ 2)
1591 : stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1592 stream_putc(s
, CAPABILITY_CODE_MP
);
1593 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1594 stream_putw(s
, pkt_afi
);
1596 stream_putc(s
, pkt_safi
);
1598 /* Extended nexthop capability - currently
1599 * supporting RFC-5549 for
1600 * Link-Local peering only
1602 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1603 && peer
->su
.sa
.sa_family
== AF_INET6
1605 && (safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
1606 || safi
== SAFI_LABELED_UNICAST
)) {
1607 /* RFC 5549 Extended Next Hop Encoding
1609 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1610 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1613 CAPABILITY_CODE_ENHE_LEN
1616 CAPABILITY_CODE_ENHE_LEN
1618 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1619 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1621 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1622 PEER_CAP_ENHE_AF_ADV
);
1623 stream_putw(s
, pkt_afi
);
1624 stream_putw(s
, pkt_safi
);
1625 stream_putw(s
, afi_int2iana(AFI_IP6
));
1627 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1628 PEER_CAP_ENHE_AF_RCV
))
1629 SET_FLAG(peer
->af_cap
[afi
][safi
],
1630 PEER_CAP_ENHE_AF_NEGO
);
1635 /* Route refresh. */
1636 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1637 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1638 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1639 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1640 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1641 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1642 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1643 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2)
1644 : stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1645 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1646 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1648 /* Enhanced Route Refresh. */
1649 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_ADV
);
1650 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1651 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2)
1652 : stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2);
1653 stream_putc(s
, CAPABILITY_CODE_ENHANCED_RR
);
1654 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
);
1657 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1658 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1659 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_AS4_LEN
+ 2)
1660 : stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1661 stream_putc(s
, CAPABILITY_CODE_AS4
);
1662 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1663 if (peer
->change_local_as
)
1664 local_as
= peer
->change_local_as
;
1666 local_as
= peer
->local_as
;
1667 stream_putl(s
, local_as
);
1669 /* Extended Message Support */
1670 SET_FLAG(peer
->cap
, PEER_CAP_EXTENDED_MESSAGE_ADV
);
1671 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1672 ext_opt_params
? stream_putw(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2)
1673 : stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
+ 2);
1674 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE
);
1675 stream_putc(s
, CAPABILITY_CODE_EXT_MESSAGE_LEN
);
1678 FOREACH_AFI_SAFI (afi
, safi
) {
1679 if (peer
->afc
[afi
][safi
]) {
1682 /* Only advertise addpath TX if a feature that
1685 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1690 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1691 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1693 ? stream_putw(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1695 : stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
)
1697 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1698 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1700 FOREACH_AFI_SAFI (afi
, safi
) {
1701 if (peer
->afc
[afi
][safi
]) {
1702 bool adv_addpath_rx
=
1703 !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1704 PEER_FLAG_DISABLE_ADDPATH_RX
);
1707 /* Convert AFI, SAFI to values for packet. */
1708 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1711 stream_putw(s
, pkt_afi
);
1712 stream_putc(s
, pkt_safi
);
1714 if (adv_addpath_rx
) {
1715 SET_FLAG(flags
, BGP_ADDPATH_RX
);
1716 SET_FLAG(peer
->af_cap
[afi
][safi
],
1717 PEER_CAP_ADDPATH_AF_RX_ADV
);
1719 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1720 PEER_CAP_ADDPATH_AF_RX_ADV
);
1723 if (adv_addpath_tx
) {
1724 SET_FLAG(flags
, BGP_ADDPATH_TX
);
1725 SET_FLAG(peer
->af_cap
[afi
][safi
],
1726 PEER_CAP_ADDPATH_AF_TX_ADV
);
1728 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1729 PEER_CAP_ADDPATH_AF_TX_ADV
);
1732 stream_putc(s
, flags
);
1736 /* ORF capability. */
1737 FOREACH_AFI_SAFI (afi
, safi
) {
1738 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1739 PEER_FLAG_ORF_PREFIX_SM
)
1740 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1741 PEER_FLAG_ORF_PREFIX_RM
)) {
1742 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1743 CAPABILITY_CODE_ORF_OLD
,
1745 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1746 CAPABILITY_CODE_ORF
,
1751 /* Dynamic capability. */
1752 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1753 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1754 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1756 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1757 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1758 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1759 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1760 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1762 ? stream_putw(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2)
1763 : stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1764 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1765 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1768 /* Hostname capability */
1769 if (cmd_hostname_get()) {
1770 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1771 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1772 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1773 ext_opt_params
? stream_putw(s
, 0)
1774 : stream_putc(s
, 0); /* Capability Length */
1775 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1776 capp
= stream_get_endp(s
);
1777 stream_putc(s
, 0); /* dummy len for now */
1778 len
= strlen(cmd_hostname_get());
1779 if (len
> BGP_MAX_HOSTNAME
)
1780 len
= BGP_MAX_HOSTNAME
;
1782 stream_putc(s
, len
);
1783 stream_put(s
, cmd_hostname_get(), len
);
1784 if (cmd_domainname_get()) {
1785 len
= strlen(cmd_domainname_get());
1786 if (len
> BGP_MAX_HOSTNAME
)
1787 len
= BGP_MAX_HOSTNAME
;
1789 stream_putc(s
, len
);
1790 stream_put(s
, cmd_domainname_get(), len
);
1792 stream_putc(s
, 0); /* 0 length */
1794 /* Set the lengths straight */
1795 len
= stream_get_endp(s
) - rcapp
- 1;
1796 ext_opt_params
? stream_putw_at(s
, rcapp
, len
- 1)
1797 : stream_putc_at(s
, rcapp
, len
);
1799 len
= stream_get_endp(s
) - capp
- 1;
1800 stream_putc_at(s
, capp
, len
);
1802 if (bgp_debug_neighbor_events(peer
))
1804 "%s Sending hostname cap with hn = %s, dn = %s",
1805 peer
->host
, cmd_hostname_get(),
1806 cmd_domainname_get());
1809 bgp_peer_send_gr_capability(s
, peer
, ext_opt_params
);
1810 bgp_peer_send_llgr_capability(s
, peer
, ext_opt_params
);
1812 /* Total Opt Parm Len. */
1813 len
= stream_get_endp(s
) - cp
- 1;
1815 if (ext_opt_params
) {
1816 len
= stream_get_endp(s
) - eopl
- 2;
1817 stream_putw_at(s
, eopl
, len
);
1819 stream_putc_at(s
, cp
, len
);