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 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
46 negotiate remote peer supports extentions or not. But if
47 remote-peer doesn't supports negotiation process itself. We would
48 like to do manual configuration.
50 So there is many configurable point. First of all we want set each
51 peer whether we send capability negotiation to the peer or not.
52 Next, if we send capability to the peer we want to set my capability
53 inforation at each peer. */
55 void bgp_capability_vty_out(struct vty
*vty
, struct peer
*peer
, bool use_json
,
56 json_object
*json_neigh
)
60 struct capability_mp_data mpc
;
61 struct capability_header
*hdr
;
62 json_object
*json_cap
= NULL
;
65 json_cap
= json_object_new_object();
67 pnt
= peer
->notify
.data
;
68 end
= pnt
+ peer
->notify
.length
;
71 if (pnt
+ sizeof(struct capability_mp_data
) + 2 > end
)
74 hdr
= (struct capability_header
*)pnt
;
75 if (pnt
+ hdr
->length
+ 2 > end
)
78 memcpy(&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
80 if (hdr
->code
== CAPABILITY_CODE_MP
) {
84 (void)bgp_map_afi_safi_iana2int(ntohs(mpc
.afi
),
85 mpc
.safi
, &afi
, &safi
);
90 json_object_string_add(
92 "capabilityErrorMultiProtocolAfi",
96 json_object_string_add(
98 "capabilityErrorMultiProtocolAfi",
102 json_object_string_add(
104 "capabilityErrorMultiProtocolAfi",
110 "capabilityErrorMultiProtocolAfiUnknown",
116 json_object_string_add(
118 "capabilityErrorMultiProtocolSafi",
122 json_object_string_add(
124 "capabilityErrorMultiProtocolSafi",
127 case SAFI_LABELED_UNICAST
:
128 json_object_string_add(
130 "capabilityErrorMultiProtocolSafi",
134 json_object_string_add(
136 "capabilityErrorMultiProtocolSafi",
140 json_object_string_add(
142 "capabilityErrorMultiProtocolSafi",
146 json_object_string_add(
148 "capabilityErrorMultiProtocolSafi",
152 json_object_string_add(
154 "capabilityErrorMultiProtocolSafi",
160 "capabilityErrorMultiProtocolSafiUnknown",
166 " Capability error for: Multi protocol ");
169 vty_out(vty
, "AFI IPv4, ");
172 vty_out(vty
, "AFI IPv6, ");
175 vty_out(vty
, "AFI L2VPN, ");
178 vty_out(vty
, "AFI Unknown %d, ",
184 vty_out(vty
, "SAFI Unicast");
187 vty_out(vty
, "SAFI Multicast");
189 case SAFI_LABELED_UNICAST
:
190 vty_out(vty
, "SAFI Labeled-unicast");
193 vty_out(vty
, "SAFI MPLS-labeled VPN");
196 vty_out(vty
, "SAFI ENCAP");
199 vty_out(vty
, "SAFI FLOWSPEC");
202 vty_out(vty
, "SAFI EVPN");
205 vty_out(vty
, "SAFI Unknown %d ",
211 } else if (hdr
->code
>= 128) {
215 "capabilityErrorVendorSpecificCapabilityCode",
219 " Capability error: vendor specific capability code %d",
225 "capabilityErrorUnknownCapabilityCode",
229 " Capability error: unknown capability code %d",
232 pnt
+= hdr
->length
+ 2;
235 json_object_object_add(json_neigh
, "capabilityErrors",
239 static void bgp_capability_mp_data(struct stream
*s
,
240 struct capability_mp_data
*mpc
)
242 mpc
->afi
= stream_getw(s
);
243 mpc
->reserved
= stream_getc(s
);
244 mpc
->safi
= stream_getc(s
);
247 /* Set negotiated capability value. */
248 static int bgp_capability_mp(struct peer
*peer
, struct capability_header
*hdr
)
250 struct capability_mp_data mpc
;
251 struct stream
*s
= BGP_INPUT(peer
);
255 /* Verify length is 4 */
256 if (hdr
->length
!= 4) {
258 EC_BGP_CAPABILITY_INVALID_LENGTH
,
259 "MP Cap: Received invalid length %d, non-multiple of 4",
264 bgp_capability_mp_data(s
, &mpc
);
266 if (bgp_debug_neighbor_events(peer
))
267 zlog_debug("%s OPEN has MP_EXT CAP for afi/safi: %s/%s",
268 peer
->host
, iana_afi2str(mpc
.afi
),
269 iana_safi2str(mpc
.safi
));
271 /* Convert AFI, SAFI to internal values, check. */
272 if (bgp_map_afi_safi_iana2int(mpc
.afi
, mpc
.safi
, &afi
, &safi
))
275 /* Now safi remapped, and afi/safi are valid array indices */
276 peer
->afc_recv
[afi
][safi
] = 1;
278 if (peer
->afc
[afi
][safi
])
279 peer
->afc_nego
[afi
][safi
] = 1;
286 static void bgp_capability_orf_not_support(struct peer
*peer
, iana_afi_t afi
,
287 iana_safi_t safi
, uint8_t type
,
290 if (bgp_debug_neighbor_events(peer
))
292 "%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
293 peer
->host
, afi
, safi
, type
, mode
);
296 static const struct message orf_type_str
[] = {
297 {ORF_TYPE_PREFIX
, "Prefixlist"},
298 {ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)"},
301 static const struct message orf_mode_str
[] = {{ORF_MODE_RECEIVE
, "Receive"},
302 {ORF_MODE_SEND
, "Send"},
303 {ORF_MODE_BOTH
, "Both"},
306 static int bgp_capability_orf_entry(struct peer
*peer
,
307 struct capability_header
*hdr
)
309 struct stream
*s
= BGP_INPUT(peer
);
310 struct capability_mp_data mpc
;
314 iana_safi_t pkt_safi
;
318 uint16_t sm_cap
= 0; /* capability send-mode receive */
319 uint16_t rm_cap
= 0; /* capability receive-mode receive */
322 /* ORF Entry header */
323 bgp_capability_mp_data(s
, &mpc
);
324 num
= stream_getc(s
);
328 if (bgp_debug_neighbor_events(peer
))
329 zlog_debug("%s ORF Cap entry for afi/safi: %s/%s", peer
->host
,
330 iana_afi2str(mpc
.afi
), iana_safi2str(mpc
.safi
));
332 /* Convert AFI, SAFI to internal values, check. */
333 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
335 "%s Addr-family %d/%d not supported. Ignoring the ORF capability",
336 peer
->host
, pkt_afi
, pkt_safi
);
343 /* validate number field */
344 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
346 "%s ORF Capability entry length error, Cap length %u, num %u",
347 peer
->host
, hdr
->length
, num
);
348 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
349 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
353 for (i
= 0; i
< num
; i
++) {
354 type
= stream_getc(s
);
355 mode
= stream_getc(s
);
357 /* ORF Mode error check */
361 case ORF_MODE_RECEIVE
:
364 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
368 /* ORF Type and afi/safi error checks */
369 /* capcode versus type */
371 case CAPABILITY_CODE_ORF
:
373 case ORF_TYPE_PREFIX
:
376 bgp_capability_orf_not_support(
377 peer
, pkt_afi
, pkt_safi
, type
, mode
);
381 case CAPABILITY_CODE_ORF_OLD
:
383 case ORF_TYPE_PREFIX_OLD
:
386 bgp_capability_orf_not_support(
387 peer
, pkt_afi
, pkt_safi
, type
, mode
);
392 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
398 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
399 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
400 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
401 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
406 if (bgp_debug_neighbor_events(peer
))
408 "%s OPEN has %s ORF capability as %s for afi/safi: %s/%s",
410 lookup_msg(orf_type_str
, type
, NULL
),
411 lookup_msg(orf_mode_str
, mode
, NULL
),
412 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
414 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
415 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
416 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
417 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
418 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
419 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
421 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
428 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
429 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
432 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
434 case ORF_MODE_RECEIVE
:
435 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
442 static int bgp_capability_restart(struct peer
*peer
,
443 struct capability_header
*caphdr
)
445 struct stream
*s
= BGP_INPUT(peer
);
446 uint16_t restart_flag_time
;
447 size_t end
= stream_get_getp(s
) + caphdr
->length
;
449 /* Verify length is a multiple of 4 */
450 if ((caphdr
->length
- 2) % 4) {
452 EC_BGP_CAPABILITY_INVALID_LENGTH
,
453 "Restart Cap: Received invalid length %d, non-multiple of 4",
458 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
459 restart_flag_time
= stream_getw(s
);
460 if (CHECK_FLAG(restart_flag_time
, RESTART_R_BIT
))
461 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
463 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
465 UNSET_FLAG(restart_flag_time
, 0xF000);
466 peer
->v_gr_restart
= restart_flag_time
;
468 if (bgp_debug_neighbor_events(peer
)) {
469 zlog_debug("%s OPEN has Graceful Restart capability",
471 zlog_debug("%s Peer has%srestarted. Restart Time : %d",
473 CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
)
479 while (stream_get_getp(s
) + 4 <= end
) {
482 iana_afi_t pkt_afi
= stream_getw(s
);
483 iana_safi_t pkt_safi
= stream_getc(s
);
484 uint8_t flag
= stream_getc(s
);
486 /* Convert AFI, SAFI to internal values, check. */
487 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
488 if (bgp_debug_neighbor_events(peer
))
490 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Graceful Restart capability for this AFI/SAFI",
491 peer
->host
, iana_afi2str(pkt_afi
),
492 iana_safi2str(pkt_safi
));
493 } else if (!peer
->afc
[afi
][safi
]) {
494 if (bgp_debug_neighbor_events(peer
))
496 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the Graceful Restart capability",
497 peer
->host
, iana_afi2str(pkt_afi
),
498 iana_safi2str(pkt_safi
));
500 if (bgp_debug_neighbor_events(peer
))
502 "%s Address family %s is%spreserved",
503 peer
->host
, get_afi_safi_str(afi
, safi
, false),
505 peer
->af_cap
[afi
][safi
],
506 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
510 SET_FLAG(peer
->af_cap
[afi
][safi
],
511 PEER_CAP_RESTART_AF_RCV
);
512 if (CHECK_FLAG(flag
, RESTART_F_BIT
))
513 SET_FLAG(peer
->af_cap
[afi
][safi
],
514 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
520 /* Unlike other capability parsing routines, this one returns 0 on error */
521 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
523 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
525 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
526 flog_err(EC_BGP_PKT_OPEN
,
527 "%s AS4 capability has incorrect data length %d",
528 peer
->host
, hdr
->length
);
532 as_t as4
= stream_getl(BGP_INPUT(peer
));
534 if (BGP_DEBUG(as4
, AS4
))
536 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
541 static int bgp_capability_addpath(struct peer
*peer
,
542 struct capability_header
*hdr
)
544 struct stream
*s
= BGP_INPUT(peer
);
545 size_t end
= stream_get_getp(s
) + hdr
->length
;
547 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
549 /* Verify length is a multiple of 4 */
550 if (hdr
->length
% 4) {
552 EC_BGP_CAPABILITY_INVALID_LENGTH
,
553 "Add Path: Received invalid length %d, non-multiple of 4",
558 while (stream_get_getp(s
) + 4 <= end
) {
561 iana_afi_t pkt_afi
= stream_getw(s
);
562 iana_safi_t pkt_safi
= stream_getc(s
);
563 uint8_t send_receive
= stream_getc(s
);
565 if (bgp_debug_neighbor_events(peer
))
567 "%s OPEN has AddPath CAP for afi/safi: %s/%s%s%s",
568 peer
->host
, iana_afi2str(pkt_afi
),
569 iana_safi2str(pkt_safi
),
570 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
572 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
575 /* Convert AFI, SAFI to internal values, check. */
576 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
577 if (bgp_debug_neighbor_events(peer
))
579 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the Addpath Attribute for this AFI/SAFI",
580 peer
->host
, iana_afi2str(pkt_afi
),
581 iana_safi2str(pkt_safi
));
583 } else if (!peer
->afc
[afi
][safi
]) {
584 if (bgp_debug_neighbor_events(peer
))
586 "%s Addr-family %s/%s(afi/safi) not enabled. Ignore the AddPath capability for this AFI/SAFI",
587 peer
->host
, iana_afi2str(pkt_afi
),
588 iana_safi2str(pkt_safi
));
592 if (send_receive
& BGP_ADDPATH_RX
)
593 SET_FLAG(peer
->af_cap
[afi
][safi
],
594 PEER_CAP_ADDPATH_AF_RX_RCV
);
596 if (send_receive
& BGP_ADDPATH_TX
)
597 SET_FLAG(peer
->af_cap
[afi
][safi
],
598 PEER_CAP_ADDPATH_AF_TX_RCV
);
604 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
606 struct stream
*s
= BGP_INPUT(peer
);
607 size_t end
= stream_get_getp(s
) + hdr
->length
;
609 /* Verify length is a multiple of 4 */
610 if (hdr
->length
% 6) {
612 EC_BGP_CAPABILITY_INVALID_LENGTH
,
613 "Extended NH: Received invalid length %d, non-multiple of 6",
618 while (stream_get_getp(s
) + 6 <= end
) {
619 iana_afi_t pkt_afi
= stream_getw(s
);
621 iana_safi_t pkt_safi
= stream_getw(s
);
623 iana_afi_t pkt_nh_afi
= stream_getw(s
);
626 if (bgp_debug_neighbor_events(peer
))
628 "%s Received with afi/safi/next-hop afi: %s/%s/%u",
629 peer
->host
, iana_afi2str(pkt_afi
),
630 iana_safi2str(pkt_safi
), pkt_nh_afi
);
632 /* Convert AFI, SAFI to internal values, check. */
633 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
634 if (bgp_debug_neighbor_events(peer
))
636 "%s Addr-family %s/%s(afi/safi) not supported. Ignore the ENHE Attribute for this AFI/SAFI",
637 peer
->host
, iana_afi2str(pkt_afi
),
638 iana_safi2str(pkt_safi
));
642 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
644 * the Nexthop AFI being IPv6. A future spec may introduce other
645 * possibilities, so we ignore other values with a log. Also,
647 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
650 nh_afi
= afi_iana2int(pkt_nh_afi
);
652 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
653 || !(safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
654 || safi
== SAFI_LABELED_UNICAST
)) {
656 EC_BGP_CAPABILITY_INVALID_DATA
,
657 "%s Unexpected afi/safi/next-hop afi: %s/%s/%u in Extended Next-hop capability, ignoring",
658 peer
->host
, iana_afi2str(pkt_afi
),
659 iana_safi2str(pkt_safi
), pkt_nh_afi
);
663 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
665 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
666 SET_FLAG(peer
->af_cap
[afi
][safi
],
667 PEER_CAP_ENHE_AF_NEGO
);
670 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
675 static int bgp_capability_hostname(struct peer
*peer
,
676 struct capability_header
*hdr
)
678 struct stream
*s
= BGP_INPUT(peer
);
679 char str
[BGP_MAX_HOSTNAME
+ 1];
680 size_t end
= stream_get_getp(s
) + hdr
->length
;
683 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
685 len
= stream_getc(s
);
686 if (stream_get_getp(s
) + len
> end
) {
688 EC_BGP_CAPABILITY_INVALID_DATA
,
689 "%s: Received malformed hostname capability from peer %s",
690 __func__
, peer
->host
);
694 if (len
> BGP_MAX_HOSTNAME
) {
695 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
696 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
697 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
699 stream_get(str
, s
, len
);
704 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
705 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
707 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
710 if (stream_get_getp(s
) + 1 > end
) {
712 EC_BGP_CAPABILITY_INVALID_DATA
,
713 "%s: Received invalid domain name len (hostname capability) from peer %s",
714 __func__
, peer
->host
);
718 len
= stream_getc(s
);
719 if (stream_get_getp(s
) + len
> end
) {
721 EC_BGP_CAPABILITY_INVALID_DATA
,
722 "%s: Received runt domain name (hostname capability) from peer %s",
723 __func__
, peer
->host
);
727 if (len
> BGP_MAX_HOSTNAME
) {
728 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
729 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
730 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
732 stream_get(str
, s
, len
);
737 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
739 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
742 if (bgp_debug_neighbor_events(peer
)) {
743 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
744 peer
->hostname
, peer
->domainname
);
750 static const struct message capcode_str
[] = {
751 {CAPABILITY_CODE_MP
, "MultiProtocol Extensions"},
752 {CAPABILITY_CODE_REFRESH
, "Route Refresh"},
753 {CAPABILITY_CODE_ORF
, "Cooperative Route Filtering"},
754 {CAPABILITY_CODE_RESTART
, "Graceful Restart"},
755 {CAPABILITY_CODE_AS4
, "4-octet AS number"},
756 {CAPABILITY_CODE_ADDPATH
, "AddPath"},
757 {CAPABILITY_CODE_DYNAMIC
, "Dynamic"},
758 {CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding"},
759 {CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)"},
760 {CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)"},
761 {CAPABILITY_CODE_ORF_OLD
, "ORF (Old)"},
762 {CAPABILITY_CODE_FQDN
, "FQDN"},
763 {CAPABILITY_CODE_ENHANCED_RR
, "Enhanced Route Refresh"},
766 /* Minimum sizes for length field of each cap (so not inc. the header) */
767 static const size_t cap_minsizes
[] = {
768 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
769 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
770 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
771 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
772 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
773 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
774 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
775 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
776 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
777 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
778 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
779 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
780 [CAPABILITY_CODE_ENHANCED_RR
] = CAPABILITY_CODE_ENHANCED_LEN
,
783 /* value the capability must be a multiple of.
784 * 0-data capabilities won't be checked against this.
785 * Other capabilities whose data doesn't fall on convenient boundaries for this
786 * table should be set to 1.
788 static const size_t cap_modsizes
[] = {
789 [CAPABILITY_CODE_MP
] = 4,
790 [CAPABILITY_CODE_REFRESH
] = 1,
791 [CAPABILITY_CODE_ORF
] = 1,
792 [CAPABILITY_CODE_RESTART
] = 1,
793 [CAPABILITY_CODE_AS4
] = 4,
794 [CAPABILITY_CODE_ADDPATH
] = 4,
795 [CAPABILITY_CODE_DYNAMIC
] = 1,
796 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
797 [CAPABILITY_CODE_ENHE
] = 6,
798 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
799 [CAPABILITY_CODE_ORF_OLD
] = 1,
800 [CAPABILITY_CODE_FQDN
] = 1,
801 [CAPABILITY_CODE_ENHANCED_RR
] = 1,
805 * Parse given capability.
806 * XXX: This is reading into a stream, but not using stream API
808 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
809 * capabilities were encountered.
811 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
812 int *mp_capability
, uint8_t **error
)
815 struct stream
*s
= BGP_INPUT(peer
);
816 size_t end
= stream_get_getp(s
) + length
;
817 uint16_t restart_flag_time
= 0;
819 assert(STREAM_READABLE(s
) >= length
);
821 while (stream_get_getp(s
) < end
) {
823 uint8_t *sp
= stream_pnt(s
);
824 struct capability_header caphdr
;
827 /* We need at least capability code and capability length. */
828 if (stream_get_getp(s
) + 2 > end
) {
829 zlog_info("%s Capability length error (< header)",
831 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
832 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
836 caphdr
.code
= stream_getc(s
);
837 caphdr
.length
= stream_getc(s
);
838 start
= stream_get_getp(s
);
840 /* Capability length check sanity check. */
841 if (start
+ caphdr
.length
> end
) {
842 zlog_info("%s Capability length error (< length)",
844 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
845 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
849 if (bgp_debug_neighbor_events(peer
))
850 zlog_debug("%s OPEN has %s capability (%u), length %u",
852 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
853 caphdr
.code
, caphdr
.length
);
855 /* Length sanity check, type-specific, for known capabilities */
856 switch (caphdr
.code
) {
857 case CAPABILITY_CODE_MP
:
858 case CAPABILITY_CODE_REFRESH
:
859 case CAPABILITY_CODE_REFRESH_OLD
:
860 case CAPABILITY_CODE_ORF
:
861 case CAPABILITY_CODE_ORF_OLD
:
862 case CAPABILITY_CODE_RESTART
:
863 case CAPABILITY_CODE_AS4
:
864 case CAPABILITY_CODE_ADDPATH
:
865 case CAPABILITY_CODE_DYNAMIC
:
866 case CAPABILITY_CODE_DYNAMIC_OLD
:
867 case CAPABILITY_CODE_ENHE
:
868 case CAPABILITY_CODE_FQDN
:
869 case CAPABILITY_CODE_ENHANCED_RR
:
871 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
873 "%s %s Capability length error: got %u, expected at least %u",
875 lookup_msg(capcode_str
, caphdr
.code
,
878 (unsigned)cap_minsizes
[caphdr
.code
]);
879 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
880 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
884 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
886 "%s %s Capability length error: got %u, expected a multiple of %u",
888 lookup_msg(capcode_str
, caphdr
.code
,
891 (unsigned)cap_modsizes
[caphdr
.code
]);
892 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
893 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
896 /* we deliberately ignore unknown codes, see below */
901 switch (caphdr
.code
) {
902 case CAPABILITY_CODE_MP
: {
905 /* Ignore capability when override-capability is set. */
906 if (!CHECK_FLAG(peer
->flags
,
907 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
908 /* Set negotiated value. */
909 ret
= bgp_capability_mp(peer
, &caphdr
);
911 /* Unsupported Capability. */
913 /* Store return data. */
914 memcpy(*error
, sp
, caphdr
.length
+ 2);
915 *error
+= caphdr
.length
+ 2;
917 ret
= 0; /* Don't return error for this */
920 case CAPABILITY_CODE_ENHANCED_RR
:
921 case CAPABILITY_CODE_REFRESH
:
922 case CAPABILITY_CODE_REFRESH_OLD
: {
923 /* BGP refresh capability */
924 if (caphdr
.code
== CAPABILITY_CODE_ENHANCED_RR
)
925 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_RCV
);
926 else if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
927 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
929 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
931 case CAPABILITY_CODE_ORF
:
932 case CAPABILITY_CODE_ORF_OLD
:
933 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
935 case CAPABILITY_CODE_RESTART
:
936 ret
= bgp_capability_restart(peer
, &caphdr
);
938 case CAPABILITY_CODE_DYNAMIC
:
939 case CAPABILITY_CODE_DYNAMIC_OLD
:
940 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
942 case CAPABILITY_CODE_AS4
:
943 /* Already handled as a special-case parsing of the
945 * at the beginning of OPEN processing. So we care not a
947 * for the value really, only error case.
949 if (!bgp_capability_as4(peer
, &caphdr
))
952 case CAPABILITY_CODE_ADDPATH
:
953 ret
= bgp_capability_addpath(peer
, &caphdr
);
955 case CAPABILITY_CODE_ENHE
:
956 ret
= bgp_capability_enhe(peer
, &caphdr
);
958 case CAPABILITY_CODE_FQDN
:
959 ret
= bgp_capability_hostname(peer
, &caphdr
);
962 if (caphdr
.code
> 128) {
963 /* We don't send Notification for unknown vendor
965 capabilities. It seems reasonable for now...
967 flog_warn(EC_BGP_CAPABILITY_VENDOR
,
968 "%s Vendor specific capability %d",
969 peer
->host
, caphdr
.code
);
972 EC_BGP_CAPABILITY_UNKNOWN
,
973 "%s unrecognized capability code: %d - ignored",
974 peer
->host
, caphdr
.code
);
975 memcpy(*error
, sp
, caphdr
.length
+ 2);
976 *error
+= caphdr
.length
+ 2;
981 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
982 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
985 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
986 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
988 EC_BGP_CAPABILITY_INVALID_LENGTH
,
989 "%s Cap-parser for %s read past cap-length, %u!",
991 lookup_msg(capcode_str
, caphdr
.code
,
994 stream_set_getp(s
, start
+ caphdr
.length
);
997 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
998 UNSET_FLAG(restart_flag_time
, 0xF000);
999 peer
->v_gr_restart
= restart_flag_time
;
1005 static int bgp_auth_parse(struct peer
*peer
, size_t length
)
1007 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1008 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
1012 static bool strict_capability_same(struct peer
*peer
)
1016 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
1017 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
1018 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
1023 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
1024 * Returns 0 if no as4 found, as4cap value otherwise.
1026 as_t
peek_for_as4_capability(struct peer
*peer
, uint8_t length
)
1028 struct stream
*s
= BGP_INPUT(peer
);
1029 size_t orig_getp
= stream_get_getp(s
);
1030 size_t end
= orig_getp
+ length
;
1033 if (BGP_DEBUG(as4
, AS4
))
1035 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u, peeking for as4",
1036 peer
->host
, length
);
1037 /* the error cases we DONT handle, we ONLY try to read as4 out of
1038 * correctly formatted options.
1040 while (stream_get_getp(s
) < end
) {
1044 /* Check the length. */
1045 if (stream_get_getp(s
) + 2 > end
)
1048 /* Fetch option type and length. */
1049 opt_type
= stream_getc(s
);
1050 opt_length
= stream_getc(s
);
1052 /* Option length check. */
1053 if (stream_get_getp(s
) + opt_length
> end
)
1056 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1057 unsigned long capd_start
= stream_get_getp(s
);
1058 unsigned long capd_end
= capd_start
+ opt_length
;
1060 assert(capd_end
<= end
);
1062 while (stream_get_getp(s
) < capd_end
) {
1063 struct capability_header hdr
;
1065 if (stream_get_getp(s
) + 2 > capd_end
)
1068 hdr
.code
= stream_getc(s
);
1069 hdr
.length
= stream_getc(s
);
1071 if ((stream_get_getp(s
) + hdr
.length
)
1075 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1076 if (BGP_DEBUG(as4
, AS4
))
1078 "[AS4] found AS4 capability, about to parse");
1079 as4
= bgp_capability_as4(peer
, &hdr
);
1083 stream_forward_getp(s
, hdr
.length
);
1089 stream_set_getp(s
, orig_getp
);
1094 * Parse open option.
1096 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1098 int bgp_open_option_parse(struct peer
*peer
, uint8_t length
, int *mp_capability
)
1102 uint8_t error_data
[BGP_MAX_PACKET_SIZE
];
1103 struct stream
*s
= BGP_INPUT(peer
);
1104 size_t end
= stream_get_getp(s
) + length
;
1108 if (bgp_debug_neighbor_events(peer
))
1109 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1110 peer
->host
, length
);
1112 /* Unset any previously received GR capability. */
1113 UNSET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
1115 while (stream_get_getp(s
) < end
) {
1119 /* Must have at least an OPEN option header */
1120 if (STREAM_READABLE(s
) < 2) {
1121 zlog_info("%s Option length error", peer
->host
);
1122 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1123 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1127 /* Fetch option type and length. */
1128 opt_type
= stream_getc(s
);
1129 opt_length
= stream_getc(s
);
1131 /* Option length check. */
1132 if (STREAM_READABLE(s
) < opt_length
) {
1133 zlog_info("%s Option length error", peer
->host
);
1134 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1135 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1139 if (bgp_debug_neighbor_events(peer
))
1141 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1142 peer
->host
, opt_type
,
1143 opt_type
== BGP_OPEN_OPT_AUTH
1145 : opt_type
== BGP_OPEN_OPT_CAP
1151 case BGP_OPEN_OPT_AUTH
:
1152 ret
= bgp_auth_parse(peer
, opt_length
);
1154 case BGP_OPEN_OPT_CAP
:
1155 ret
= bgp_capability_parse(peer
, opt_length
,
1156 mp_capability
, &error
);
1159 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1160 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1165 /* Parse error. To accumulate all unsupported capability codes,
1166 bgp_capability_parse does not return -1 when encounter
1167 unsupported capability code. To detect that, please check
1168 error and erro_data pointer, like below. */
1173 /* All OPEN option is parsed. Check capability when strict compare
1175 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1176 /* If Unsupported Capability exists. */
1177 if (error
!= error_data
) {
1178 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1179 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1181 error
- error_data
);
1185 /* Check local capability does not negotiated with remote
1187 if (!strict_capability_same(peer
)) {
1188 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1189 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1194 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1197 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1198 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1199 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1200 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1201 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1202 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1203 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1204 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1205 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1206 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1207 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1208 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1209 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1210 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1211 flog_err(EC_BGP_PKT_OPEN
,
1212 "%s [Error] Configured AFI/SAFIs do not overlap with received MP capabilities",
1215 if (error
!= error_data
)
1216 bgp_notify_send_with_data(
1217 peer
, BGP_NOTIFY_OPEN_ERR
,
1218 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1219 error
- error_data
);
1221 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1222 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1229 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1230 afi_t afi
, safi_t safi
, uint8_t code
)
1236 unsigned long numberp
;
1237 int number_of_orfs
= 0;
1239 iana_safi_t pkt_safi
;
1241 /* Convert AFI, SAFI to values for packet. */
1242 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1244 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1245 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1246 stream_putc(s
, 0); /* Capability Length */
1247 stream_putc(s
, code
); /* Capability Code */
1248 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1249 stream_putc(s
, 0); /* ORF Length */
1250 stream_putw(s
, pkt_afi
);
1252 stream_putc(s
, pkt_safi
);
1253 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1254 stream_putc(s
, 0); /* Number of ORFs */
1256 /* Address Prefix ORF */
1257 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1258 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1259 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1261 : ORF_TYPE_PREFIX_OLD
));
1263 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1264 PEER_FLAG_ORF_PREFIX_SM
)
1265 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1266 PEER_FLAG_ORF_PREFIX_RM
)) {
1267 SET_FLAG(peer
->af_cap
[afi
][safi
],
1268 PEER_CAP_ORF_PREFIX_SM_ADV
);
1269 SET_FLAG(peer
->af_cap
[afi
][safi
],
1270 PEER_CAP_ORF_PREFIX_RM_ADV
);
1271 stream_putc(s
, ORF_MODE_BOTH
);
1272 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1273 PEER_FLAG_ORF_PREFIX_SM
)) {
1274 SET_FLAG(peer
->af_cap
[afi
][safi
],
1275 PEER_CAP_ORF_PREFIX_SM_ADV
);
1276 stream_putc(s
, ORF_MODE_SEND
);
1278 SET_FLAG(peer
->af_cap
[afi
][safi
],
1279 PEER_CAP_ORF_PREFIX_RM_ADV
);
1280 stream_putc(s
, ORF_MODE_RECEIVE
);
1285 /* Total Number of ORFs. */
1286 stream_putc_at(s
, numberp
, number_of_orfs
);
1288 /* Total ORF Len. */
1289 orf_len
= stream_get_endp(s
) - orfp
- 1;
1290 stream_putc_at(s
, orfp
, orf_len
);
1292 /* Total Capability Len. */
1293 cap_len
= stream_get_endp(s
) - capp
- 1;
1294 stream_putc_at(s
, capp
, cap_len
);
1297 static void bgp_peer_send_gr_capability(struct stream
*s
, struct peer
*peer
,
1304 iana_safi_t pkt_safi
;
1305 uint32_t restart_time
;
1306 unsigned long capp
= 0;
1307 unsigned long rcapp
= 0;
1309 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)
1310 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART_HELPER
))
1313 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1314 zlog_debug("[BGP_GR] Sending helper Capability for Peer :%s :",
1317 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1318 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1319 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1320 stream_putc(s
, 0); /* Capability Length */
1321 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1322 /* Set Restart Capability Len Pointer */
1323 rcapp
= stream_get_endp(s
);
1325 restart_time
= peer
->bgp
->restart_time
;
1326 if (peer
->bgp
->t_startup
) {
1327 SET_FLAG(restart_time
, RESTART_R_BIT
);
1328 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1330 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1331 zlog_debug("[BGP_GR] Sending R-Bit for Peer :%s :",
1335 stream_putw(s
, restart_time
);
1337 /* Send address-family specific graceful-restart capability
1338 * only when GR config is present
1340 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
)) {
1341 if (CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_GR_PRESERVE_FWD
)
1342 && BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1343 zlog_debug("[BGP_GR] F bit Set");
1345 FOREACH_AFI_SAFI (afi
, safi
) {
1346 if (!peer
->afc
[afi
][safi
])
1349 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1351 "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
1354 /* Convert AFI, SAFI to values for
1357 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1359 stream_putw(s
, pkt_afi
);
1360 stream_putc(s
, pkt_safi
);
1361 if (CHECK_FLAG(peer
->bgp
->flags
,
1362 BGP_FLAG_GR_PRESERVE_FWD
))
1363 stream_putc(s
, RESTART_F_BIT
);
1369 /* Total Graceful restart capability Len. */
1370 len
= stream_get_endp(s
) - rcapp
- 1;
1371 stream_putc_at(s
, rcapp
, len
);
1373 /* Total Capability Len. */
1374 len
= stream_get_endp(s
) - capp
- 1;
1375 stream_putc_at(s
, capp
, len
);
1378 /* Fill in capability open option to the packet. */
1379 void bgp_open_capability(struct stream
*s
, struct peer
*peer
)
1382 unsigned long cp
, capp
, rcapp
;
1386 iana_safi_t pkt_safi
;
1388 uint8_t afi_safi_count
= 0;
1389 int adv_addpath_tx
= 0;
1391 /* Remember current pointer for Opt Parm Len. */
1392 cp
= stream_get_endp(s
);
1397 /* Do not send capability. */
1398 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1399 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1402 /* MP capability for configured AFI, SAFI */
1403 FOREACH_AFI_SAFI (afi
, safi
) {
1404 if (peer
->afc
[afi
][safi
]) {
1405 /* Convert AFI, SAFI to values for packet. */
1406 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1409 peer
->afc_adv
[afi
][safi
] = 1;
1410 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1411 stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1412 stream_putc(s
, CAPABILITY_CODE_MP
);
1413 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1414 stream_putw(s
, pkt_afi
);
1416 stream_putc(s
, pkt_safi
);
1418 /* Extended nexthop capability - currently
1419 * supporting RFC-5549 for
1420 * Link-Local peering only
1422 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1423 && peer
->su
.sa
.sa_family
== AF_INET6
1425 && (safi
== SAFI_UNICAST
|| safi
== SAFI_MPLS_VPN
1426 || safi
== SAFI_LABELED_UNICAST
)) {
1427 /* RFC 5549 Extended Next Hop Encoding
1429 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1430 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1431 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1432 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1433 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1435 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1436 PEER_CAP_ENHE_AF_ADV
);
1437 stream_putw(s
, pkt_afi
);
1438 stream_putw(s
, pkt_safi
);
1439 stream_putw(s
, afi_int2iana(AFI_IP6
));
1441 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1442 PEER_CAP_ENHE_AF_RCV
))
1443 SET_FLAG(peer
->af_cap
[afi
][safi
],
1444 PEER_CAP_ENHE_AF_NEGO
);
1449 /* Route refresh. */
1450 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1451 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1452 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1453 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1454 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1455 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1456 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1457 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1458 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1460 /* Enhanced Route Refresh. */
1461 SET_FLAG(peer
->cap
, PEER_CAP_ENHANCED_RR_ADV
);
1462 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1463 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
+ 2);
1464 stream_putc(s
, CAPABILITY_CODE_ENHANCED_RR
);
1465 stream_putc(s
, CAPABILITY_CODE_ENHANCED_LEN
);
1468 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1469 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1470 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1471 stream_putc(s
, CAPABILITY_CODE_AS4
);
1472 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1473 if (peer
->change_local_as
)
1474 local_as
= peer
->change_local_as
;
1476 local_as
= peer
->local_as
;
1477 stream_putl(s
, local_as
);
1480 FOREACH_AFI_SAFI (afi
, safi
) {
1481 if (peer
->afc
[afi
][safi
]) {
1484 /* Only advertise addpath TX if a feature that
1487 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1492 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1493 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1494 stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1495 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1496 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1498 FOREACH_AFI_SAFI (afi
, safi
) {
1499 if (peer
->afc
[afi
][safi
]) {
1500 /* Convert AFI, SAFI to values for packet. */
1501 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1504 stream_putw(s
, pkt_afi
);
1505 stream_putc(s
, pkt_safi
);
1507 if (adv_addpath_tx
) {
1508 stream_putc(s
, BGP_ADDPATH_RX
| BGP_ADDPATH_TX
);
1509 SET_FLAG(peer
->af_cap
[afi
][safi
],
1510 PEER_CAP_ADDPATH_AF_RX_ADV
);
1511 SET_FLAG(peer
->af_cap
[afi
][safi
],
1512 PEER_CAP_ADDPATH_AF_TX_ADV
);
1514 stream_putc(s
, BGP_ADDPATH_RX
);
1515 SET_FLAG(peer
->af_cap
[afi
][safi
],
1516 PEER_CAP_ADDPATH_AF_RX_ADV
);
1517 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1518 PEER_CAP_ADDPATH_AF_TX_ADV
);
1523 /* ORF capability. */
1524 FOREACH_AFI_SAFI (afi
, safi
) {
1525 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1526 PEER_FLAG_ORF_PREFIX_SM
)
1527 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1528 PEER_FLAG_ORF_PREFIX_RM
)) {
1529 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1530 CAPABILITY_CODE_ORF_OLD
);
1531 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1532 CAPABILITY_CODE_ORF
);
1536 /* Dynamic capability. */
1537 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1538 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1539 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1540 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1541 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1542 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1543 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1544 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1545 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1546 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1549 /* Hostname capability */
1550 if (cmd_hostname_get()) {
1551 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1552 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1553 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1554 stream_putc(s
, 0); /* dummy len for now */
1555 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1556 capp
= stream_get_endp(s
);
1557 stream_putc(s
, 0); /* dummy len for now */
1558 len
= strlen(cmd_hostname_get());
1559 if (len
> BGP_MAX_HOSTNAME
)
1560 len
= BGP_MAX_HOSTNAME
;
1562 stream_putc(s
, len
);
1563 stream_put(s
, cmd_hostname_get(), len
);
1564 if (cmd_domainname_get()) {
1565 len
= strlen(cmd_domainname_get());
1566 if (len
> BGP_MAX_HOSTNAME
)
1567 len
= BGP_MAX_HOSTNAME
;
1569 stream_putc(s
, len
);
1570 stream_put(s
, cmd_domainname_get(), len
);
1572 stream_putc(s
, 0); /* 0 length */
1574 /* Set the lengths straight */
1575 len
= stream_get_endp(s
) - rcapp
- 1;
1576 stream_putc_at(s
, rcapp
, len
);
1577 len
= stream_get_endp(s
) - capp
- 1;
1578 stream_putc_at(s
, capp
, len
);
1580 if (bgp_debug_neighbor_events(peer
))
1582 "%s Sending hostname cap with hn = %s, dn = %s",
1583 peer
->host
, cmd_hostname_get(),
1584 cmd_domainname_get());
1587 bgp_peer_send_gr_capability(s
, peer
, cp
);
1589 /* Total Opt Parm Len. */
1590 len
= stream_get_endp(s
) - cp
- 1;
1591 stream_putc_at(s
, cp
, len
);