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."
336 " Ignoring the ORF capability",
337 peer
->host
, pkt_afi
, pkt_safi
);
344 /* validate number field */
345 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
347 "%s ORF Capability entry length error,"
348 " Cap length %u, num %u",
349 peer
->host
, hdr
->length
, num
);
350 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
351 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
355 for (i
= 0; i
< num
; i
++) {
356 type
= stream_getc(s
);
357 mode
= stream_getc(s
);
359 /* ORF Mode error check */
363 case ORF_MODE_RECEIVE
:
366 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
370 /* ORF Type and afi/safi error checks */
371 /* capcode versus type */
373 case CAPABILITY_CODE_ORF
:
375 case ORF_TYPE_PREFIX
:
378 bgp_capability_orf_not_support(
379 peer
, pkt_afi
, pkt_safi
, type
, mode
);
383 case CAPABILITY_CODE_ORF_OLD
:
385 case ORF_TYPE_PREFIX_OLD
:
388 bgp_capability_orf_not_support(
389 peer
, pkt_afi
, pkt_safi
, type
, mode
);
394 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
400 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
401 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
402 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
403 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
408 if (bgp_debug_neighbor_events(peer
))
410 "%s OPEN has %s ORF capability"
411 " as %s for afi/safi: %s/%s",
413 lookup_msg(orf_type_str
, type
, NULL
),
414 lookup_msg(orf_mode_str
, mode
, NULL
),
415 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
417 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
418 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
419 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
420 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
421 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
422 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
424 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
431 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
432 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
435 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
437 case ORF_MODE_RECEIVE
:
438 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
445 static int bgp_capability_restart(struct peer
*peer
,
446 struct capability_header
*caphdr
)
448 struct stream
*s
= BGP_INPUT(peer
);
449 uint16_t restart_flag_time
;
450 size_t end
= stream_get_getp(s
) + caphdr
->length
;
452 /* Verify length is a multiple of 4 */
453 if ((caphdr
->length
- 2) % 4) {
455 EC_BGP_CAPABILITY_INVALID_LENGTH
,
456 "Restart Cap: Received invalid length %d, non-multiple of 4",
461 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
462 restart_flag_time
= stream_getw(s
);
463 if (CHECK_FLAG(restart_flag_time
, RESTART_R_BIT
))
464 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
466 UNSET_FLAG(restart_flag_time
, 0xF000);
467 peer
->v_gr_restart
= restart_flag_time
;
469 if (bgp_debug_neighbor_events(peer
)) {
470 zlog_debug("%s OPEN has Graceful Restart capability",
472 zlog_debug("%s Peer has%srestarted. Restart Time : %d",
474 CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
)
480 while (stream_get_getp(s
) + 4 <= end
) {
483 iana_afi_t pkt_afi
= stream_getw(s
);
484 iana_safi_t pkt_safi
= stream_getc(s
);
485 uint8_t flag
= stream_getc(s
);
487 /* Convert AFI, SAFI to internal values, check. */
488 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
489 if (bgp_debug_neighbor_events(peer
))
491 "%s Addr-family %s/%s(afi/safi) not supported."
492 " Ignore the Graceful Restart capability for this AFI/SAFI",
493 peer
->host
, iana_afi2str(pkt_afi
),
494 iana_safi2str(pkt_safi
));
495 } else if (!peer
->afc
[afi
][safi
]) {
496 if (bgp_debug_neighbor_events(peer
))
498 "%s Addr-family %s/%s(afi/safi) not enabled."
499 " Ignore the Graceful Restart capability",
500 peer
->host
, iana_afi2str(pkt_afi
),
501 iana_safi2str(pkt_safi
));
503 if (bgp_debug_neighbor_events(peer
))
505 "%s Address family %s is%spreserved",
506 peer
->host
, get_afi_safi_str(afi
, safi
, false),
508 peer
->af_cap
[afi
][safi
],
509 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
513 SET_FLAG(peer
->af_cap
[afi
][safi
],
514 PEER_CAP_RESTART_AF_RCV
);
515 if (CHECK_FLAG(flag
, RESTART_F_BIT
))
516 SET_FLAG(peer
->af_cap
[afi
][safi
],
517 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
523 /* Unlike other capability parsing routines, this one returns 0 on error */
524 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
526 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
528 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
529 flog_err(EC_BGP_PKT_OPEN
,
530 "%s AS4 capability has incorrect data length %d",
531 peer
->host
, hdr
->length
);
535 as_t as4
= stream_getl(BGP_INPUT(peer
));
537 if (BGP_DEBUG(as4
, AS4
))
539 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
544 static int bgp_capability_addpath(struct peer
*peer
,
545 struct capability_header
*hdr
)
547 struct stream
*s
= BGP_INPUT(peer
);
548 size_t end
= stream_get_getp(s
) + hdr
->length
;
550 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
552 /* Verify length is a multiple of 4 */
553 if (hdr
->length
% 4) {
555 EC_BGP_CAPABILITY_INVALID_LENGTH
,
556 "Add Path: Received invalid length %d, non-multiple of 4",
561 while (stream_get_getp(s
) + 4 <= end
) {
564 iana_afi_t pkt_afi
= stream_getw(s
);
565 iana_safi_t pkt_safi
= stream_getc(s
);
566 uint8_t send_receive
= stream_getc(s
);
568 if (bgp_debug_neighbor_events(peer
))
570 "%s OPEN has AddPath CAP for afi/safi: %s/%s%s%s",
571 peer
->host
, iana_afi2str(pkt_afi
),
572 iana_safi2str(pkt_safi
),
573 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
575 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
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."
583 " Ignore the Addpath Attribute for this AFI/SAFI",
584 peer
->host
, iana_afi2str(pkt_afi
),
585 iana_safi2str(pkt_safi
));
587 } else if (!peer
->afc
[afi
][safi
]) {
588 if (bgp_debug_neighbor_events(peer
))
590 "%s Addr-family %s/%s(afi/safi) not enabled."
591 " Ignore the AddPath capability for this AFI/SAFI",
592 peer
->host
, iana_afi2str(pkt_afi
),
593 iana_safi2str(pkt_safi
));
597 if (send_receive
& BGP_ADDPATH_RX
)
598 SET_FLAG(peer
->af_cap
[afi
][safi
],
599 PEER_CAP_ADDPATH_AF_RX_RCV
);
601 if (send_receive
& BGP_ADDPATH_TX
)
602 SET_FLAG(peer
->af_cap
[afi
][safi
],
603 PEER_CAP_ADDPATH_AF_TX_RCV
);
609 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
611 struct stream
*s
= BGP_INPUT(peer
);
612 size_t end
= stream_get_getp(s
) + hdr
->length
;
614 /* Verify length is a multiple of 4 */
615 if (hdr
->length
% 6) {
617 EC_BGP_CAPABILITY_INVALID_LENGTH
,
618 "Extended NH: Received invalid length %d, non-multiple of 6",
623 while (stream_get_getp(s
) + 6 <= end
) {
624 iana_afi_t pkt_afi
= stream_getw(s
);
626 iana_safi_t pkt_safi
= stream_getw(s
);
628 iana_afi_t pkt_nh_afi
= stream_getw(s
);
631 if (bgp_debug_neighbor_events(peer
))
633 "%s Received with afi/safi/next-hop afi: %s/%s/%u",
634 peer
->host
, iana_afi2str(pkt_afi
),
635 iana_safi2str(pkt_safi
), pkt_nh_afi
);
637 /* Convert AFI, SAFI to internal values, check. */
638 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
639 if (bgp_debug_neighbor_events(peer
))
641 "%s Addr-family %s/%s(afi/safi) not supported."
642 " Ignore the ENHE Attribute for this AFI/SAFI",
643 peer
->host
, iana_afi2str(pkt_afi
),
644 iana_safi2str(pkt_safi
));
648 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
650 * the Nexthop AFI being IPv6. A future spec may introduce other
651 * possibilities, so we ignore other values with a log. Also,
653 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
656 nh_afi
= afi_iana2int(pkt_nh_afi
);
658 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
659 || !(safi
== SAFI_UNICAST
660 || safi
== SAFI_LABELED_UNICAST
)) {
662 EC_BGP_CAPABILITY_INVALID_DATA
,
663 "%s Unexpected afi/safi/next-hop afi: %s/%s/%u "
664 "in Extended Next-hop capability, ignoring",
665 peer
->host
, iana_afi2str(pkt_afi
),
666 iana_safi2str(pkt_safi
), pkt_nh_afi
);
670 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
672 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
673 SET_FLAG(peer
->af_cap
[afi
][safi
],
674 PEER_CAP_ENHE_AF_NEGO
);
677 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
682 static int bgp_capability_hostname(struct peer
*peer
,
683 struct capability_header
*hdr
)
685 struct stream
*s
= BGP_INPUT(peer
);
686 char str
[BGP_MAX_HOSTNAME
+ 1];
687 size_t end
= stream_get_getp(s
) + hdr
->length
;
690 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
692 len
= stream_getc(s
);
693 if (stream_get_getp(s
) + len
> end
) {
695 EC_BGP_CAPABILITY_INVALID_DATA
,
696 "%s: Received malformed hostname capability from peer %s",
697 __FUNCTION__
, peer
->host
);
701 if (len
> BGP_MAX_HOSTNAME
) {
702 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
703 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
704 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
706 stream_get(str
, s
, len
);
711 if (peer
->hostname
!= NULL
) {
712 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
713 peer
->hostname
= NULL
;
716 if (peer
->domainname
!= NULL
) {
717 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
718 peer
->domainname
= NULL
;
721 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
724 if (stream_get_getp(s
) + 1 > end
) {
726 EC_BGP_CAPABILITY_INVALID_DATA
,
727 "%s: Received invalid domain name len (hostname capability) from peer %s",
728 __FUNCTION__
, peer
->host
);
732 len
= stream_getc(s
);
733 if (stream_get_getp(s
) + len
> end
) {
735 EC_BGP_CAPABILITY_INVALID_DATA
,
736 "%s: Received runt domain name (hostname capability) from peer %s",
737 __FUNCTION__
, peer
->host
);
741 if (len
> BGP_MAX_HOSTNAME
) {
742 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
743 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
744 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
746 stream_get(str
, s
, len
);
750 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
753 if (bgp_debug_neighbor_events(peer
)) {
754 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
755 peer
->hostname
, peer
->domainname
);
761 static const struct message capcode_str
[] = {
762 {CAPABILITY_CODE_MP
, "MultiProtocol Extensions"},
763 {CAPABILITY_CODE_REFRESH
, "Route Refresh"},
764 {CAPABILITY_CODE_ORF
, "Cooperative Route Filtering"},
765 {CAPABILITY_CODE_RESTART
, "Graceful Restart"},
766 {CAPABILITY_CODE_AS4
, "4-octet AS number"},
767 {CAPABILITY_CODE_ADDPATH
, "AddPath"},
768 {CAPABILITY_CODE_DYNAMIC
, "Dynamic"},
769 {CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding"},
770 {CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)"},
771 {CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)"},
772 {CAPABILITY_CODE_ORF_OLD
, "ORF (Old)"},
773 {CAPABILITY_CODE_FQDN
, "FQDN"},
776 /* Minimum sizes for length field of each cap (so not inc. the header) */
777 static const size_t cap_minsizes
[] = {
778 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
779 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
780 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
781 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
782 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
783 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
784 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
785 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
786 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
787 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
788 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
789 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
792 /* value the capability must be a multiple of.
793 * 0-data capabilities won't be checked against this.
794 * Other capabilities whose data doesn't fall on convenient boundaries for this
795 * table should be set to 1.
797 static const size_t cap_modsizes
[] = {
798 [CAPABILITY_CODE_MP
] = 4,
799 [CAPABILITY_CODE_REFRESH
] = 1,
800 [CAPABILITY_CODE_ORF
] = 1,
801 [CAPABILITY_CODE_RESTART
] = 1,
802 [CAPABILITY_CODE_AS4
] = 4,
803 [CAPABILITY_CODE_ADDPATH
] = 4,
804 [CAPABILITY_CODE_DYNAMIC
] = 1,
805 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
806 [CAPABILITY_CODE_ENHE
] = 6,
807 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
808 [CAPABILITY_CODE_ORF_OLD
] = 1,
809 [CAPABILITY_CODE_FQDN
] = 1,
813 * Parse given capability.
814 * XXX: This is reading into a stream, but not using stream API
816 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
817 * capabilities were encountered.
819 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
820 int *mp_capability
, uint8_t **error
)
823 struct stream
*s
= BGP_INPUT(peer
);
824 size_t end
= stream_get_getp(s
) + length
;
826 assert(STREAM_READABLE(s
) >= length
);
828 while (stream_get_getp(s
) < end
) {
830 uint8_t *sp
= stream_pnt(s
);
831 struct capability_header caphdr
;
834 /* We need at least capability code and capability length. */
835 if (stream_get_getp(s
) + 2 > end
) {
836 zlog_info("%s Capability length error (< header)",
838 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
839 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
843 caphdr
.code
= stream_getc(s
);
844 caphdr
.length
= stream_getc(s
);
845 start
= stream_get_getp(s
);
847 /* Capability length check sanity check. */
848 if (start
+ caphdr
.length
> end
) {
849 zlog_info("%s Capability length error (< length)",
851 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
852 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
856 if (bgp_debug_neighbor_events(peer
))
857 zlog_debug("%s OPEN has %s capability (%u), length %u",
859 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
860 caphdr
.code
, caphdr
.length
);
862 /* Length sanity check, type-specific, for known capabilities */
863 switch (caphdr
.code
) {
864 case CAPABILITY_CODE_MP
:
865 case CAPABILITY_CODE_REFRESH
:
866 case CAPABILITY_CODE_REFRESH_OLD
:
867 case CAPABILITY_CODE_ORF
:
868 case CAPABILITY_CODE_ORF_OLD
:
869 case CAPABILITY_CODE_RESTART
:
870 case CAPABILITY_CODE_AS4
:
871 case CAPABILITY_CODE_ADDPATH
:
872 case CAPABILITY_CODE_DYNAMIC
:
873 case CAPABILITY_CODE_DYNAMIC_OLD
:
874 case CAPABILITY_CODE_ENHE
:
875 case CAPABILITY_CODE_FQDN
:
877 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
879 "%s %s Capability length error: got %u,"
880 " expected at least %u",
882 lookup_msg(capcode_str
, caphdr
.code
,
885 (unsigned)cap_minsizes
[caphdr
.code
]);
886 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
887 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
891 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
893 "%s %s Capability length error: got %u,"
894 " expected a multiple of %u",
896 lookup_msg(capcode_str
, caphdr
.code
,
899 (unsigned)cap_modsizes
[caphdr
.code
]);
900 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
901 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
904 /* we deliberately ignore unknown codes, see below */
909 switch (caphdr
.code
) {
910 case CAPABILITY_CODE_MP
: {
913 /* Ignore capability when override-capability is set. */
914 if (!CHECK_FLAG(peer
->flags
,
915 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
916 /* Set negotiated value. */
917 ret
= bgp_capability_mp(peer
, &caphdr
);
919 /* Unsupported Capability. */
921 /* Store return data. */
922 memcpy(*error
, sp
, caphdr
.length
+ 2);
923 *error
+= caphdr
.length
+ 2;
925 ret
= 0; /* Don't return error for this */
928 case CAPABILITY_CODE_REFRESH
:
929 case CAPABILITY_CODE_REFRESH_OLD
: {
930 /* BGP refresh capability */
931 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
932 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
934 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
936 case CAPABILITY_CODE_ORF
:
937 case CAPABILITY_CODE_ORF_OLD
:
938 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
940 case CAPABILITY_CODE_RESTART
:
941 ret
= bgp_capability_restart(peer
, &caphdr
);
943 case CAPABILITY_CODE_DYNAMIC
:
944 case CAPABILITY_CODE_DYNAMIC_OLD
:
945 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
947 case CAPABILITY_CODE_AS4
:
948 /* Already handled as a special-case parsing of the
950 * at the beginning of OPEN processing. So we care not a
952 * for the value really, only error case.
954 if (!bgp_capability_as4(peer
, &caphdr
))
957 case CAPABILITY_CODE_ADDPATH
:
958 ret
= bgp_capability_addpath(peer
, &caphdr
);
960 case CAPABILITY_CODE_ENHE
:
961 ret
= bgp_capability_enhe(peer
, &caphdr
);
963 case CAPABILITY_CODE_FQDN
:
964 ret
= bgp_capability_hostname(peer
, &caphdr
);
967 if (caphdr
.code
> 128) {
968 /* We don't send Notification for unknown vendor
970 capabilities. It seems reasonable for now...
972 flog_warn(EC_BGP_CAPABILITY_VENDOR
,
973 "%s Vendor specific capability %d",
974 peer
->host
, caphdr
.code
);
977 EC_BGP_CAPABILITY_UNKNOWN
,
978 "%s unrecognized capability code: %d - ignored",
979 peer
->host
, caphdr
.code
);
980 memcpy(*error
, sp
, caphdr
.length
+ 2);
981 *error
+= caphdr
.length
+ 2;
986 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
987 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
990 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
991 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
993 EC_BGP_CAPABILITY_INVALID_LENGTH
,
994 "%s Cap-parser for %s read past cap-length, %u!",
996 lookup_msg(capcode_str
, caphdr
.code
,
999 stream_set_getp(s
, start
+ caphdr
.length
);
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 int 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,"
1037 peer
->host
, length
);
1038 /* the error cases we DONT handle, we ONLY try to read as4 out of
1039 * correctly formatted options.
1041 while (stream_get_getp(s
) < end
) {
1045 /* Check the length. */
1046 if (stream_get_getp(s
) + 2 > end
)
1049 /* Fetch option type and length. */
1050 opt_type
= stream_getc(s
);
1051 opt_length
= stream_getc(s
);
1053 /* Option length check. */
1054 if (stream_get_getp(s
) + opt_length
> end
)
1057 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1058 unsigned long capd_start
= stream_get_getp(s
);
1059 unsigned long capd_end
= capd_start
+ opt_length
;
1061 assert(capd_end
<= end
);
1063 while (stream_get_getp(s
) < capd_end
) {
1064 struct capability_header hdr
;
1066 if (stream_get_getp(s
) + 2 > capd_end
)
1069 hdr
.code
= stream_getc(s
);
1070 hdr
.length
= stream_getc(s
);
1072 if ((stream_get_getp(s
) + hdr
.length
)
1076 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1077 if (BGP_DEBUG(as4
, AS4
))
1079 "[AS4] found AS4 capability, about to parse");
1080 as4
= bgp_capability_as4(peer
, &hdr
);
1084 stream_forward_getp(s
, hdr
.length
);
1090 stream_set_getp(s
, orig_getp
);
1095 * Parse open option.
1097 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1099 int bgp_open_option_parse(struct peer
*peer
, uint8_t length
, int *mp_capability
)
1103 uint8_t error_data
[BGP_MAX_PACKET_SIZE
];
1104 struct stream
*s
= BGP_INPUT(peer
);
1105 size_t end
= stream_get_getp(s
) + length
;
1109 if (bgp_debug_neighbor_events(peer
))
1110 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1111 peer
->host
, length
);
1113 while (stream_get_getp(s
) < end
) {
1117 /* Must have at least an OPEN option header */
1118 if (STREAM_READABLE(s
) < 2) {
1119 zlog_info("%s Option length error", peer
->host
);
1120 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1121 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1125 /* Fetch option type and length. */
1126 opt_type
= stream_getc(s
);
1127 opt_length
= stream_getc(s
);
1129 /* Option length check. */
1130 if (STREAM_READABLE(s
) < opt_length
) {
1131 zlog_info("%s Option length error", peer
->host
);
1132 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1133 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1137 if (bgp_debug_neighbor_events(peer
))
1139 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1140 peer
->host
, opt_type
,
1141 opt_type
== BGP_OPEN_OPT_AUTH
1143 : opt_type
== BGP_OPEN_OPT_CAP
1149 case BGP_OPEN_OPT_AUTH
:
1150 ret
= bgp_auth_parse(peer
, opt_length
);
1152 case BGP_OPEN_OPT_CAP
:
1153 ret
= bgp_capability_parse(peer
, opt_length
,
1154 mp_capability
, &error
);
1157 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1158 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1163 /* Parse error. To accumulate all unsupported capability codes,
1164 bgp_capability_parse does not return -1 when encounter
1165 unsupported capability code. To detect that, please check
1166 error and erro_data pointer, like below. */
1171 /* All OPEN option is parsed. Check capability when strict compare
1173 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1174 /* If Unsupported Capability exists. */
1175 if (error
!= error_data
) {
1176 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1177 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1179 error
- error_data
);
1183 /* Check local capability does not negotiated with remote
1185 if (!strict_capability_same(peer
)) {
1186 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1187 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1192 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1195 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1196 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1197 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1198 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1199 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1200 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1201 && !peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
1202 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1203 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1204 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1205 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1206 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1207 && !peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
1208 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1209 flog_err(EC_BGP_PKT_OPEN
,
1210 "%s [Error] Configured AFI/SAFIs do not "
1211 "overlap with received MP capabilities",
1214 if (error
!= error_data
)
1215 bgp_notify_send_with_data(
1216 peer
, BGP_NOTIFY_OPEN_ERR
,
1217 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1218 error
- error_data
);
1220 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1221 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1228 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1229 afi_t afi
, safi_t safi
, uint8_t code
)
1235 unsigned long numberp
;
1236 int number_of_orfs
= 0;
1238 iana_safi_t pkt_safi
;
1240 /* Convert AFI, SAFI to values for packet. */
1241 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1243 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1244 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1245 stream_putc(s
, 0); /* Capability Length */
1246 stream_putc(s
, code
); /* Capability Code */
1247 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1248 stream_putc(s
, 0); /* ORF Length */
1249 stream_putw(s
, pkt_afi
);
1251 stream_putc(s
, pkt_safi
);
1252 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1253 stream_putc(s
, 0); /* Number of ORFs */
1255 /* Address Prefix ORF */
1256 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1257 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1258 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1260 : ORF_TYPE_PREFIX_OLD
));
1262 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1263 PEER_FLAG_ORF_PREFIX_SM
)
1264 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1265 PEER_FLAG_ORF_PREFIX_RM
)) {
1266 SET_FLAG(peer
->af_cap
[afi
][safi
],
1267 PEER_CAP_ORF_PREFIX_SM_ADV
);
1268 SET_FLAG(peer
->af_cap
[afi
][safi
],
1269 PEER_CAP_ORF_PREFIX_RM_ADV
);
1270 stream_putc(s
, ORF_MODE_BOTH
);
1271 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1272 PEER_FLAG_ORF_PREFIX_SM
)) {
1273 SET_FLAG(peer
->af_cap
[afi
][safi
],
1274 PEER_CAP_ORF_PREFIX_SM_ADV
);
1275 stream_putc(s
, ORF_MODE_SEND
);
1277 SET_FLAG(peer
->af_cap
[afi
][safi
],
1278 PEER_CAP_ORF_PREFIX_RM_ADV
);
1279 stream_putc(s
, ORF_MODE_RECEIVE
);
1284 /* Total Number of ORFs. */
1285 stream_putc_at(s
, numberp
, number_of_orfs
);
1287 /* Total ORF Len. */
1288 orf_len
= stream_get_endp(s
) - orfp
- 1;
1289 stream_putc_at(s
, orfp
, orf_len
);
1291 /* Total Capability Len. */
1292 cap_len
= stream_get_endp(s
) - capp
- 1;
1293 stream_putc_at(s
, capp
, cap_len
);
1296 /* Fill in capability open option to the packet. */
1297 void bgp_open_capability(struct stream
*s
, struct peer
*peer
)
1300 unsigned long cp
, capp
, rcapp
;
1304 iana_safi_t pkt_safi
;
1306 uint32_t restart_time
;
1307 uint8_t afi_safi_count
= 0;
1308 int adv_addpath_tx
= 0;
1310 /* Remember current pointer for Opt Parm Len. */
1311 cp
= stream_get_endp(s
);
1316 /* Do not send capability. */
1317 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1318 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1321 /* MP capability for configured AFI, SAFI */
1322 FOREACH_AFI_SAFI (afi
, safi
) {
1323 if (peer
->afc
[afi
][safi
]) {
1324 /* Convert AFI, SAFI to values for packet. */
1325 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1328 peer
->afc_adv
[afi
][safi
] = 1;
1329 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1330 stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1331 stream_putc(s
, CAPABILITY_CODE_MP
);
1332 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1333 stream_putw(s
, pkt_afi
);
1335 stream_putc(s
, pkt_safi
);
1337 /* Extended nexthop capability - currently
1338 * supporting RFC-5549 for
1339 * Link-Local peering only
1341 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1342 && peer
->su
.sa
.sa_family
== AF_INET6
1344 && (safi
== SAFI_UNICAST
1345 || safi
== SAFI_LABELED_UNICAST
)) {
1346 /* RFC 5549 Extended Next Hop Encoding
1348 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1349 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1350 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1351 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1352 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1354 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1355 PEER_CAP_ENHE_AF_ADV
);
1356 stream_putw(s
, pkt_afi
);
1357 stream_putw(s
, pkt_safi
);
1358 stream_putw(s
, afi_int2iana(AFI_IP6
));
1360 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1361 PEER_CAP_ENHE_AF_RCV
))
1362 SET_FLAG(peer
->af_cap
[afi
][safi
],
1363 PEER_CAP_ENHE_AF_NEGO
);
1368 /* Route refresh. */
1369 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1370 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1371 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1372 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1373 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1374 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1375 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1376 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1377 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1380 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1381 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1382 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1383 stream_putc(s
, CAPABILITY_CODE_AS4
);
1384 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1385 if (peer
->change_local_as
)
1386 local_as
= peer
->change_local_as
;
1388 local_as
= peer
->local_as
;
1389 stream_putl(s
, local_as
);
1392 FOREACH_AFI_SAFI (afi
, safi
) {
1393 if (peer
->afc
[afi
][safi
]) {
1396 /* Only advertise addpath TX if a feature that
1399 if (peer
->addpath_type
[afi
][safi
] != BGP_ADDPATH_NONE
)
1404 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1405 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1406 stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1407 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1408 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1410 FOREACH_AFI_SAFI (afi
, safi
) {
1411 if (peer
->afc
[afi
][safi
]) {
1412 /* Convert AFI, SAFI to values for packet. */
1413 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1416 stream_putw(s
, pkt_afi
);
1417 stream_putc(s
, pkt_safi
);
1419 if (adv_addpath_tx
) {
1420 stream_putc(s
, BGP_ADDPATH_RX
| BGP_ADDPATH_TX
);
1421 SET_FLAG(peer
->af_cap
[afi
][safi
],
1422 PEER_CAP_ADDPATH_AF_RX_ADV
);
1423 SET_FLAG(peer
->af_cap
[afi
][safi
],
1424 PEER_CAP_ADDPATH_AF_TX_ADV
);
1426 stream_putc(s
, BGP_ADDPATH_RX
);
1427 SET_FLAG(peer
->af_cap
[afi
][safi
],
1428 PEER_CAP_ADDPATH_AF_RX_ADV
);
1429 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1430 PEER_CAP_ADDPATH_AF_TX_ADV
);
1435 /* ORF capability. */
1436 FOREACH_AFI_SAFI (afi
, safi
) {
1437 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1438 PEER_FLAG_ORF_PREFIX_SM
)
1439 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1440 PEER_FLAG_ORF_PREFIX_RM
)) {
1441 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1442 CAPABILITY_CODE_ORF_OLD
);
1443 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1444 CAPABILITY_CODE_ORF
);
1448 /* Dynamic capability. */
1449 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1450 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1451 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1452 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1453 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1454 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1455 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1456 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1457 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1458 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1461 /* Hostname capability */
1462 if (cmd_hostname_get()) {
1463 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1464 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1465 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1466 stream_putc(s
, 0); /* dummy len for now */
1467 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1468 capp
= stream_get_endp(s
);
1469 stream_putc(s
, 0); /* dummy len for now */
1470 len
= strlen(cmd_hostname_get());
1471 if (len
> BGP_MAX_HOSTNAME
)
1472 len
= BGP_MAX_HOSTNAME
;
1474 stream_putc(s
, len
);
1475 stream_put(s
, cmd_hostname_get(), len
);
1476 if (cmd_domainname_get()) {
1477 len
= strlen(cmd_domainname_get());
1478 if (len
> BGP_MAX_HOSTNAME
)
1479 len
= BGP_MAX_HOSTNAME
;
1481 stream_putc(s
, len
);
1482 stream_put(s
, cmd_domainname_get(), len
);
1484 stream_putc(s
, 0); /* 0 length */
1486 /* Set the lengths straight */
1487 len
= stream_get_endp(s
) - rcapp
- 1;
1488 stream_putc_at(s
, rcapp
, len
);
1489 len
= stream_get_endp(s
) - capp
- 1;
1490 stream_putc_at(s
, capp
, len
);
1492 if (bgp_debug_neighbor_events(peer
))
1494 "%s Sending hostname cap with hn = %s, dn = %s",
1495 peer
->host
, cmd_hostname_get(),
1496 cmd_domainname_get());
1499 /* Sending base graceful-restart capability irrespective of the config
1501 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1502 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1503 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1504 stream_putc(s
, 0); /* Capability Length */
1505 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1506 rcapp
= stream_get_endp(s
); /* Set Restart Capability Len Pointer */
1508 restart_time
= peer
->bgp
->restart_time
;
1509 if (peer
->bgp
->t_startup
) {
1510 SET_FLAG(restart_time
, RESTART_R_BIT
);
1511 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1513 stream_putw(s
, restart_time
);
1515 /* Send address-family specific graceful-restart capability only when GR
1518 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
)) {
1519 FOREACH_AFI_SAFI (afi
, safi
) {
1520 if (peer
->afc
[afi
][safi
]) {
1521 /* Convert AFI, SAFI to values for
1523 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1525 stream_putw(s
, pkt_afi
);
1526 stream_putc(s
, pkt_safi
);
1527 if (bgp_flag_check(peer
->bgp
,
1528 BGP_FLAG_GR_PRESERVE_FWD
))
1529 stream_putc(s
, RESTART_F_BIT
);
1536 /* Total Graceful restart capability Len. */
1537 len
= stream_get_endp(s
) - rcapp
- 1;
1538 stream_putc_at(s
, rcapp
, len
);
1540 /* Total Capability Len. */
1541 len
= stream_get_endp(s
) - capp
- 1;
1542 stream_putc_at(s
, capp
, len
);
1544 /* Total Opt Parm Len. */
1545 len
= stream_get_endp(s
) - cp
- 1;
1546 stream_putc_at(s
, cp
, len
);