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_fsm.h"
38 #include "bgpd/bgp_packet.h"
39 #include "bgpd/bgp_open.h"
40 #include "bgpd/bgp_aspath.h"
41 #include "bgpd/bgp_vty.h"
42 #include "bgpd/bgp_memory.h"
44 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
45 negotiate remote peer supports extentions or not. But if
46 remote-peer doesn't supports negotiation process itself. We would
47 like to do manual configuration.
49 So there is many configurable point. First of all we want set each
50 peer whether we send capability negotiation to the peer or not.
51 Next, if we send capability to the peer we want to set my capabilty
52 inforation at each peer. */
54 void bgp_capability_vty_out(struct vty
*vty
, struct peer
*peer
, u_char use_json
,
55 json_object
*json_neigh
)
59 struct capability_mp_data mpc
;
60 struct capability_header
*hdr
;
61 json_object
*json_cap
= NULL
;
64 json_cap
= json_object_new_object();
66 pnt
= peer
->notify
.data
;
67 end
= pnt
+ peer
->notify
.length
;
70 if (pnt
+ sizeof(struct capability_mp_data
) + 2 > end
)
73 hdr
= (struct capability_header
*)pnt
;
74 if (pnt
+ hdr
->length
+ 2 > end
)
77 memcpy(&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
79 if (hdr
->code
== CAPABILITY_CODE_MP
) {
83 bgp_map_afi_safi_iana2int(ntohs(mpc
.afi
), mpc
.safi
,
88 json_object_string_add(
90 "capabilityErrorMultiProtocolAfi",
94 json_object_string_add(
96 "capabilityErrorMultiProtocolAfi",
100 json_object_string_add(
102 "capabilityErrorMultiProtocolAfi",
108 "capabilityErrorMultiProtocolAfiUnknown",
114 json_object_string_add(
116 "capabilityErrorMultiProtocolSafi",
120 json_object_string_add(
122 "capabilityErrorMultiProtocolSafi",
125 case SAFI_LABELED_UNICAST
:
126 json_object_string_add(
128 "capabilityErrorMultiProtocolSafi",
132 json_object_string_add(
134 "capabilityErrorMultiProtocolSafi",
138 json_object_string_add(
140 "capabilityErrorMultiProtocolSafi",
144 json_object_string_add(
146 "capabilityErrorMultiProtocolSafi",
152 "capabilityErrorMultiProtocolSafiUnknown",
158 " Capability error for: Multi protocol ");
161 vty_out(vty
, "AFI IPv4, ");
164 vty_out(vty
, "AFI IPv6, ");
167 vty_out(vty
, "AFI L2VPN, ");
170 vty_out(vty
, "AFI Unknown %d, ",
176 vty_out(vty
, "SAFI Unicast");
179 vty_out(vty
, "SAFI Multicast");
181 case SAFI_LABELED_UNICAST
:
182 vty_out(vty
, "SAFI Labeled-unicast");
185 vty_out(vty
, "SAFI MPLS-labeled VPN");
188 vty_out(vty
, "SAFI ENCAP");
191 vty_out(vty
, "SAFI EVPN");
194 vty_out(vty
, "SAFI Unknown %d ",
200 } else if (hdr
->code
>= 128) {
204 "capabilityErrorVendorSpecificCapabilityCode",
208 " Capability error: vendor specific capability code %d",
214 "capabilityErrorUnknownCapabilityCode",
218 " Capability error: unknown capability code %d",
221 pnt
+= hdr
->length
+ 2;
224 json_object_object_add(json_neigh
, "capabilityErrors",
228 static void bgp_capability_mp_data(struct stream
*s
,
229 struct capability_mp_data
*mpc
)
231 mpc
->afi
= stream_getw(s
);
232 mpc
->reserved
= stream_getc(s
);
233 mpc
->safi
= stream_getc(s
);
236 /* Set negotiated capability value. */
237 static int bgp_capability_mp(struct peer
*peer
, struct capability_header
*hdr
)
239 struct capability_mp_data mpc
;
240 struct stream
*s
= BGP_INPUT(peer
);
244 /* Verify length is 4 */
245 if (hdr
->length
!= 4) {
247 "MP Cap: Received invalid length %d, non-multiple of 4",
252 bgp_capability_mp_data(s
, &mpc
);
254 if (bgp_debug_neighbor_events(peer
))
255 zlog_debug("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
256 peer
->host
, mpc
.afi
, mpc
.safi
);
258 /* Convert AFI, SAFI to internal values, check. */
259 if (bgp_map_afi_safi_iana2int(mpc
.afi
, mpc
.safi
, &afi
, &safi
))
262 /* Now safi remapped, and afi/safi are valid array indices */
263 peer
->afc_recv
[afi
][safi
] = 1;
265 if (peer
->afc
[afi
][safi
])
266 peer
->afc_nego
[afi
][safi
] = 1;
273 static void bgp_capability_orf_not_support(struct peer
*peer
, iana_afi_t afi
,
274 iana_safi_t safi
, u_char type
,
277 if (bgp_debug_neighbor_events(peer
))
279 "%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
280 peer
->host
, afi
, safi
, type
, mode
);
283 static const struct message orf_type_str
[] = {
284 {ORF_TYPE_PREFIX
, "Prefixlist"},
285 {ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)"},
288 static const struct message orf_mode_str
[] = {{ORF_MODE_RECEIVE
, "Receive"},
289 {ORF_MODE_SEND
, "Send"},
290 {ORF_MODE_BOTH
, "Both"},
293 static int bgp_capability_orf_entry(struct peer
*peer
,
294 struct capability_header
*hdr
)
296 struct stream
*s
= BGP_INPUT(peer
);
297 struct capability_mp_data mpc
;
301 iana_safi_t pkt_safi
;
305 u_int16_t sm_cap
= 0; /* capability send-mode receive */
306 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
309 /* ORF Entry header */
310 bgp_capability_mp_data(s
, &mpc
);
311 num
= stream_getc(s
);
315 if (bgp_debug_neighbor_events(peer
))
316 zlog_debug("%s ORF Cap entry for afi/safi: %u/%u", peer
->host
,
319 /* Convert AFI, SAFI to internal values, check. */
320 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
322 "%s Addr-family %d/%d not supported."
323 " Ignoring the ORF capability",
324 peer
->host
, pkt_afi
, pkt_safi
);
331 /* validate number field */
332 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
) {
334 "%s ORF Capability entry length error,"
335 " Cap length %u, num %u",
336 peer
->host
, hdr
->length
, num
);
337 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
338 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
342 for (i
= 0; i
< num
; i
++) {
343 type
= stream_getc(s
);
344 mode
= stream_getc(s
);
346 /* ORF Mode error check */
350 case ORF_MODE_RECEIVE
:
353 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
357 /* ORF Type and afi/safi error checks */
358 /* capcode versus type */
360 case CAPABILITY_CODE_ORF
:
362 case ORF_TYPE_PREFIX
:
365 bgp_capability_orf_not_support(
366 peer
, pkt_afi
, pkt_safi
, type
, mode
);
370 case CAPABILITY_CODE_ORF_OLD
:
372 case ORF_TYPE_PREFIX_OLD
:
375 bgp_capability_orf_not_support(
376 peer
, pkt_afi
, pkt_safi
, type
, mode
);
381 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
387 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
388 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
389 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
))) {
390 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
395 if (bgp_debug_neighbor_events(peer
))
397 "%s OPEN has %s ORF capability"
398 " as %s for afi/safi: %d/%d",
400 lookup_msg(orf_type_str
, type
, NULL
),
401 lookup_msg(orf_mode_str
, mode
, NULL
), pkt_afi
,
404 if (hdr
->code
== CAPABILITY_CODE_ORF
) {
405 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
406 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
407 } else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
) {
408 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
409 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
411 bgp_capability_orf_not_support(peer
, pkt_afi
, pkt_safi
,
418 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
419 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
422 SET_FLAG(peer
->af_cap
[afi
][safi
], sm_cap
);
424 case ORF_MODE_RECEIVE
:
425 SET_FLAG(peer
->af_cap
[afi
][safi
], rm_cap
);
432 static int bgp_capability_restart(struct peer
*peer
,
433 struct capability_header
*caphdr
)
435 struct stream
*s
= BGP_INPUT(peer
);
436 u_int16_t restart_flag_time
;
437 size_t end
= stream_get_getp(s
) + caphdr
->length
;
439 /* Verify length is a multiple of 4 */
440 if ((caphdr
->length
- 2) % 4) {
442 "Restart Cap: Received invalid length %d, non-multiple of 4",
447 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
);
448 restart_flag_time
= stream_getw(s
);
449 if (CHECK_FLAG(restart_flag_time
, RESTART_R_BIT
))
450 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
452 UNSET_FLAG(restart_flag_time
, 0xF000);
453 peer
->v_gr_restart
= restart_flag_time
;
455 if (bgp_debug_neighbor_events(peer
)) {
456 zlog_debug("%s OPEN has Graceful Restart capability",
458 zlog_debug("%s Peer has%srestarted. Restart Time : %d",
460 CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_RCV
)
466 while (stream_get_getp(s
) + 4 <= end
) {
469 iana_afi_t pkt_afi
= stream_getw(s
);
470 iana_safi_t pkt_safi
= stream_getc(s
);
471 u_char flag
= stream_getc(s
);
473 /* Convert AFI, SAFI to internal values, check. */
474 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
475 if (bgp_debug_neighbor_events(peer
))
477 "%s Addr-family %d/%d(afi/safi) not supported."
478 " Ignore the Graceful Restart capability for this AFI/SAFI",
479 peer
->host
, pkt_afi
, pkt_safi
);
480 } else if (!peer
->afc
[afi
][safi
]) {
481 if (bgp_debug_neighbor_events(peer
))
483 "%s Addr-family %d/%d(afi/safi) not enabled."
484 " Ignore the Graceful Restart capability",
485 peer
->host
, pkt_afi
, pkt_safi
);
487 if (bgp_debug_neighbor_events(peer
))
489 "%s Address family %s is%spreserved",
490 peer
->host
, afi_safi_print(afi
, safi
),
492 peer
->af_cap
[afi
][safi
],
493 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
497 SET_FLAG(peer
->af_cap
[afi
][safi
],
498 PEER_CAP_RESTART_AF_RCV
);
499 if (CHECK_FLAG(flag
, RESTART_F_BIT
))
500 SET_FLAG(peer
->af_cap
[afi
][safi
],
501 PEER_CAP_RESTART_AF_PRESERVE_RCV
);
507 /* Unlike other capability parsing routines, this one returns 0 on error */
508 static as_t
bgp_capability_as4(struct peer
*peer
, struct capability_header
*hdr
)
510 SET_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
);
512 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
) {
513 zlog_err("%s AS4 capability has incorrect data length %d",
514 peer
->host
, hdr
->length
);
518 as_t as4
= stream_getl(BGP_INPUT(peer
));
520 if (BGP_DEBUG(as4
, AS4
))
522 "%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
527 static int bgp_capability_addpath(struct peer
*peer
,
528 struct capability_header
*hdr
)
530 struct stream
*s
= BGP_INPUT(peer
);
531 size_t end
= stream_get_getp(s
) + hdr
->length
;
533 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_RCV
);
535 /* Verify length is a multiple of 4 */
536 if (hdr
->length
% 4) {
538 "Add Path: Received invalid length %d, non-multiple of 4",
543 while (stream_get_getp(s
) + 4 <= end
) {
546 iana_afi_t pkt_afi
= stream_getw(s
);
547 iana_safi_t pkt_safi
= stream_getc(s
);
548 u_char send_receive
= stream_getc(s
);
550 if (bgp_debug_neighbor_events(peer
))
552 "%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
553 peer
->host
, pkt_afi
, pkt_safi
,
554 (send_receive
& BGP_ADDPATH_RX
) ? ", receive"
556 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit"
559 /* Convert AFI, SAFI to internal values, check. */
560 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
561 if (bgp_debug_neighbor_events(peer
))
563 "%s Addr-family %d/%d(afi/safi) not supported."
564 " Ignore the Addpath Attribute for this AFI/SAFI",
565 peer
->host
, pkt_afi
, pkt_safi
);
567 } else if (!peer
->afc
[afi
][safi
]) {
568 if (bgp_debug_neighbor_events(peer
))
570 "%s Addr-family %d/%d(afi/safi) not enabled."
571 " Ignore the AddPath capability for this AFI/SAFI",
572 peer
->host
, pkt_afi
, pkt_safi
);
576 if (send_receive
& BGP_ADDPATH_RX
)
577 SET_FLAG(peer
->af_cap
[afi
][safi
],
578 PEER_CAP_ADDPATH_AF_RX_RCV
);
580 if (send_receive
& BGP_ADDPATH_TX
)
581 SET_FLAG(peer
->af_cap
[afi
][safi
],
582 PEER_CAP_ADDPATH_AF_TX_RCV
);
588 static int bgp_capability_enhe(struct peer
*peer
, struct capability_header
*hdr
)
590 struct stream
*s
= BGP_INPUT(peer
);
591 size_t end
= stream_get_getp(s
) + hdr
->length
;
593 /* Verify length is a multiple of 4 */
594 if (hdr
->length
% 6) {
596 "Extended NH: Received invalid length %d, non-multiple of 6",
601 while (stream_get_getp(s
) + 6 <= end
) {
602 iana_afi_t pkt_afi
= stream_getw(s
);
604 iana_safi_t pkt_safi
= stream_getw(s
);
606 iana_afi_t pkt_nh_afi
= stream_getw(s
);
609 if (bgp_debug_neighbor_events(peer
))
611 "%s Received with afi/safi/next-hop afi: %u/%u/%u",
612 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
614 /* Convert AFI, SAFI to internal values, check. */
615 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
616 if (bgp_debug_neighbor_events(peer
))
618 "%s Addr-family %d/%d(afi/safi) not supported."
619 " Ignore the ENHE Attribute for this AFI/SAFI",
620 peer
->host
, pkt_afi
, pkt_safi
);
624 /* RFC 5549 specifies use of this capability only for IPv4 AFI,
626 * the Nexthop AFI being IPv6. A future spec may introduce other
627 * possibilities, so we ignore other values with a log. Also,
629 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported
632 nh_afi
= afi_iana2int(pkt_nh_afi
);
634 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
635 || !(safi
== SAFI_UNICAST
636 || safi
== SAFI_LABELED_UNICAST
)) {
638 "%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
639 "in Extended Next-hop capability, ignoring",
640 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
644 SET_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
646 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
647 SET_FLAG(peer
->af_cap
[afi
][safi
],
648 PEER_CAP_ENHE_AF_NEGO
);
651 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_RCV
);
656 static int bgp_capability_hostname(struct peer
*peer
,
657 struct capability_header
*hdr
)
659 struct stream
*s
= BGP_INPUT(peer
);
660 char str
[BGP_MAX_HOSTNAME
+ 1];
661 size_t end
= stream_get_getp(s
) + hdr
->length
;
664 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
666 len
= stream_getc(s
);
667 if (stream_get_getp(s
) + len
> end
) {
669 "%s: Received malformed hostname capability from peer %s",
670 __FUNCTION__
, peer
->host
);
674 if (len
> BGP_MAX_HOSTNAME
) {
675 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
676 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
677 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
679 stream_get(str
, s
, len
);
684 if (peer
->hostname
!= NULL
) {
685 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
686 peer
->hostname
= NULL
;
689 if (peer
->domainname
!= NULL
) {
690 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
691 peer
->domainname
= NULL
;
694 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
697 if (stream_get_getp(s
) + 1 > end
) {
699 "%s: Received invalid domain name len (hostname capability) from peer %s",
700 __FUNCTION__
, peer
->host
);
704 len
= stream_getc(s
);
705 if (stream_get_getp(s
) + len
> end
) {
707 "%s: Received runt domain name (hostname capability) from peer %s",
708 __FUNCTION__
, peer
->host
);
712 if (len
> BGP_MAX_HOSTNAME
) {
713 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
714 stream_forward_getp(s
, len
- BGP_MAX_HOSTNAME
);
715 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
717 stream_get(str
, s
, len
);
721 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
724 if (bgp_debug_neighbor_events(peer
)) {
725 zlog_debug("%s received hostname %s, domainname %s", peer
->host
,
726 peer
->hostname
, peer
->domainname
);
732 static const struct message capcode_str
[] = {
733 {CAPABILITY_CODE_MP
, "MultiProtocol Extensions"},
734 {CAPABILITY_CODE_REFRESH
, "Route Refresh"},
735 {CAPABILITY_CODE_ORF
, "Cooperative Route Filtering"},
736 {CAPABILITY_CODE_RESTART
, "Graceful Restart"},
737 {CAPABILITY_CODE_AS4
, "4-octet AS number"},
738 {CAPABILITY_CODE_ADDPATH
, "AddPath"},
739 {CAPABILITY_CODE_DYNAMIC
, "Dynamic"},
740 {CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding"},
741 {CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)"},
742 {CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)"},
743 {CAPABILITY_CODE_ORF_OLD
, "ORF (Old)"},
744 {CAPABILITY_CODE_FQDN
, "FQDN"},
747 /* Minimum sizes for length field of each cap (so not inc. the header) */
748 static const size_t cap_minsizes
[] = {
749 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
750 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
751 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
752 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
753 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
754 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
755 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
756 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
757 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
758 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
759 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
760 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
763 /* value the capability must be a multiple of.
764 * 0-data capabilities won't be checked against this.
765 * Other capabilities whose data doesn't fall on convenient boundaries for this
766 * table should be set to 1.
768 static const size_t cap_modsizes
[] = {
769 [CAPABILITY_CODE_MP
] = 4,
770 [CAPABILITY_CODE_REFRESH
] = 1,
771 [CAPABILITY_CODE_ORF
] = 1,
772 [CAPABILITY_CODE_RESTART
] = 1,
773 [CAPABILITY_CODE_AS4
] = 4,
774 [CAPABILITY_CODE_ADDPATH
] = 4,
775 [CAPABILITY_CODE_DYNAMIC
] = 1,
776 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
777 [CAPABILITY_CODE_ENHE
] = 6,
778 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
779 [CAPABILITY_CODE_ORF_OLD
] = 1,
780 [CAPABILITY_CODE_FQDN
] = 1,
784 * Parse given capability.
785 * XXX: This is reading into a stream, but not using stream API
787 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
788 * capabilities were encountered.
790 static int bgp_capability_parse(struct peer
*peer
, size_t length
,
791 int *mp_capability
, u_char
**error
)
794 struct stream
*s
= BGP_INPUT(peer
);
795 size_t end
= stream_get_getp(s
) + length
;
797 assert(STREAM_READABLE(s
) >= length
);
799 while (stream_get_getp(s
) < end
) {
801 u_char
*sp
= stream_pnt(s
);
802 struct capability_header caphdr
;
805 /* We need at least capability code and capability length. */
806 if (stream_get_getp(s
) + 2 > end
) {
807 zlog_info("%s Capability length error (< header)",
809 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
810 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
814 caphdr
.code
= stream_getc(s
);
815 caphdr
.length
= stream_getc(s
);
816 start
= stream_get_getp(s
);
818 /* Capability length check sanity check. */
819 if (start
+ caphdr
.length
> end
) {
820 zlog_info("%s Capability length error (< length)",
822 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
823 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
827 if (bgp_debug_neighbor_events(peer
))
828 zlog_debug("%s OPEN has %s capability (%u), length %u",
830 lookup_msg(capcode_str
, caphdr
.code
, NULL
),
831 caphdr
.code
, caphdr
.length
);
833 /* Length sanity check, type-specific, for known capabilities */
834 switch (caphdr
.code
) {
835 case CAPABILITY_CODE_MP
:
836 case CAPABILITY_CODE_REFRESH
:
837 case CAPABILITY_CODE_REFRESH_OLD
:
838 case CAPABILITY_CODE_ORF
:
839 case CAPABILITY_CODE_ORF_OLD
:
840 case CAPABILITY_CODE_RESTART
:
841 case CAPABILITY_CODE_AS4
:
842 case CAPABILITY_CODE_ADDPATH
:
843 case CAPABILITY_CODE_DYNAMIC
:
844 case CAPABILITY_CODE_DYNAMIC_OLD
:
845 case CAPABILITY_CODE_ENHE
:
846 case CAPABILITY_CODE_FQDN
:
848 if (caphdr
.length
< cap_minsizes
[caphdr
.code
]) {
850 "%s %s Capability length error: got %u,"
851 " expected at least %u",
853 lookup_msg(capcode_str
, caphdr
.code
,
856 (unsigned)cap_minsizes
[caphdr
.code
]);
857 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
858 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
862 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0) {
864 "%s %s Capability length error: got %u,"
865 " expected a multiple of %u",
867 lookup_msg(capcode_str
, caphdr
.code
,
870 (unsigned)cap_modsizes
[caphdr
.code
]);
871 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
872 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
875 /* we deliberately ignore unknown codes, see below */
880 switch (caphdr
.code
) {
881 case CAPABILITY_CODE_MP
: {
884 /* Ignore capability when override-capability is set. */
885 if (!CHECK_FLAG(peer
->flags
,
886 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
887 /* Set negotiated value. */
888 ret
= bgp_capability_mp(peer
, &caphdr
);
890 /* Unsupported Capability. */
892 /* Store return data. */
893 memcpy(*error
, sp
, caphdr
.length
+ 2);
894 *error
+= caphdr
.length
+ 2;
896 ret
= 0; /* Don't return error for this */
899 case CAPABILITY_CODE_REFRESH
:
900 case CAPABILITY_CODE_REFRESH_OLD
: {
901 /* BGP refresh capability */
902 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
903 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
905 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
907 case CAPABILITY_CODE_ORF
:
908 case CAPABILITY_CODE_ORF_OLD
:
909 ret
= bgp_capability_orf_entry(peer
, &caphdr
);
911 case CAPABILITY_CODE_RESTART
:
912 ret
= bgp_capability_restart(peer
, &caphdr
);
914 case CAPABILITY_CODE_DYNAMIC
:
915 case CAPABILITY_CODE_DYNAMIC_OLD
:
916 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
918 case CAPABILITY_CODE_AS4
:
919 /* Already handled as a special-case parsing of the
921 * at the beginning of OPEN processing. So we care not a
923 * for the value really, only error case.
925 if (!bgp_capability_as4(peer
, &caphdr
))
928 case CAPABILITY_CODE_ADDPATH
:
929 ret
= bgp_capability_addpath(peer
, &caphdr
);
931 case CAPABILITY_CODE_ENHE
:
932 ret
= bgp_capability_enhe(peer
, &caphdr
);
934 case CAPABILITY_CODE_FQDN
:
935 ret
= bgp_capability_hostname(peer
, &caphdr
);
938 if (caphdr
.code
> 128) {
939 /* We don't send Notification for unknown vendor
941 capabilities. It seems reasonable for now...
943 zlog_warn("%s Vendor specific capability %d",
944 peer
->host
, caphdr
.code
);
947 "%s unrecognized capability code: %d - ignored",
948 peer
->host
, caphdr
.code
);
949 memcpy(*error
, sp
, caphdr
.length
+ 2);
950 *error
+= caphdr
.length
+ 2;
955 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
956 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
959 if (stream_get_getp(s
) != (start
+ caphdr
.length
)) {
960 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
962 "%s Cap-parser for %s read past cap-length, %u!",
964 lookup_msg(capcode_str
, caphdr
.code
,
967 stream_set_getp(s
, start
+ caphdr
.length
);
973 static int bgp_auth_parse(struct peer
*peer
, size_t length
)
975 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
976 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
980 static int strict_capability_same(struct peer
*peer
)
984 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
985 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
986 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
991 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
992 * Returns 0 if no as4 found, as4cap value otherwise.
994 as_t
peek_for_as4_capability(struct peer
*peer
, u_char length
)
996 struct stream
*s
= BGP_INPUT(peer
);
997 size_t orig_getp
= stream_get_getp(s
);
998 size_t end
= orig_getp
+ length
;
1001 if (BGP_DEBUG(as4
, AS4
))
1003 "%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
1005 peer
->host
, length
);
1006 /* the error cases we DONT handle, we ONLY try to read as4 out of
1007 * correctly formatted options.
1009 while (stream_get_getp(s
) < end
) {
1013 /* Check the length. */
1014 if (stream_get_getp(s
) + 2 > end
)
1017 /* Fetch option type and length. */
1018 opt_type
= stream_getc(s
);
1019 opt_length
= stream_getc(s
);
1021 /* Option length check. */
1022 if (stream_get_getp(s
) + opt_length
> end
)
1025 if (opt_type
== BGP_OPEN_OPT_CAP
) {
1026 unsigned long capd_start
= stream_get_getp(s
);
1027 unsigned long capd_end
= capd_start
+ opt_length
;
1029 assert(capd_end
<= end
);
1031 while (stream_get_getp(s
) < capd_end
) {
1032 struct capability_header hdr
;
1034 if (stream_get_getp(s
) + 2 > capd_end
)
1037 hdr
.code
= stream_getc(s
);
1038 hdr
.length
= stream_getc(s
);
1040 if ((stream_get_getp(s
) + hdr
.length
)
1044 if (hdr
.code
== CAPABILITY_CODE_AS4
) {
1045 if (BGP_DEBUG(as4
, AS4
))
1047 "[AS4] found AS4 capability, about to parse");
1048 as4
= bgp_capability_as4(peer
, &hdr
);
1052 stream_forward_getp(s
, hdr
.length
);
1058 stream_set_getp(s
, orig_getp
);
1063 * Parse open option.
1065 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1067 int bgp_open_option_parse(struct peer
*peer
, u_char length
, int *mp_capability
)
1071 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1072 struct stream
*s
= BGP_INPUT(peer
);
1073 size_t end
= stream_get_getp(s
) + length
;
1077 if (bgp_debug_neighbor_events(peer
))
1078 zlog_debug("%s rcv OPEN w/ OPTION parameter len: %u",
1079 peer
->host
, length
);
1081 while (stream_get_getp(s
) < end
) {
1085 /* Must have at least an OPEN option header */
1086 if (STREAM_READABLE(s
) < 2) {
1087 zlog_info("%s Option length error", peer
->host
);
1088 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1089 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1093 /* Fetch option type and length. */
1094 opt_type
= stream_getc(s
);
1095 opt_length
= stream_getc(s
);
1097 /* Option length check. */
1098 if (STREAM_READABLE(s
) < opt_length
) {
1099 zlog_info("%s Option length error", peer
->host
);
1100 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1101 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1105 if (bgp_debug_neighbor_events(peer
))
1107 "%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1108 peer
->host
, opt_type
,
1109 opt_type
== BGP_OPEN_OPT_AUTH
1111 : opt_type
== BGP_OPEN_OPT_CAP
1117 case BGP_OPEN_OPT_AUTH
:
1118 ret
= bgp_auth_parse(peer
, opt_length
);
1120 case BGP_OPEN_OPT_CAP
:
1121 ret
= bgp_capability_parse(peer
, opt_length
,
1122 mp_capability
, &error
);
1125 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1126 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1131 /* Parse error. To accumulate all unsupported capability codes,
1132 bgp_capability_parse does not return -1 when encounter
1133 unsupported capability code. To detect that, please check
1134 error and erro_data pointer, like below. */
1139 /* All OPEN option is parsed. Check capability when strict compare
1141 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
1142 /* If Unsupported Capability exists. */
1143 if (error
!= error_data
) {
1144 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1145 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1147 error
- error_data
);
1151 /* Check local capability does not negotiated with remote
1153 if (!strict_capability_same(peer
)) {
1154 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1155 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1160 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1163 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1164 if (!peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1165 && !peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1166 && !peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1167 && !peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1168 && !peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1169 && !peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1170 && !peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1171 && !peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1172 && !peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1173 && !peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1174 && !peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
]) {
1176 "%s [Error] Configured AFI/SAFIs do not "
1177 "overlap with received MP capabilities",
1180 if (error
!= error_data
)
1181 bgp_notify_send_with_data(
1182 peer
, BGP_NOTIFY_OPEN_ERR
,
1183 BGP_NOTIFY_OPEN_UNSUP_CAPBL
, error_data
,
1184 error
- error_data
);
1186 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1187 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1194 static void bgp_open_capability_orf(struct stream
*s
, struct peer
*peer
,
1195 afi_t afi
, safi_t safi
, u_char code
)
1201 unsigned long numberp
;
1202 int number_of_orfs
= 0;
1204 iana_safi_t pkt_safi
;
1206 /* Convert AFI, SAFI to values for packet. */
1207 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
1209 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1210 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1211 stream_putc(s
, 0); /* Capability Length */
1212 stream_putc(s
, code
); /* Capability Code */
1213 orfp
= stream_get_endp(s
); /* Set ORF Len Pointer */
1214 stream_putc(s
, 0); /* ORF Length */
1215 stream_putw(s
, pkt_afi
);
1217 stream_putc(s
, pkt_safi
);
1218 numberp
= stream_get_endp(s
); /* Set Number Pointer */
1219 stream_putc(s
, 0); /* Number of ORFs */
1221 /* Address Prefix ORF */
1222 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1223 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
)) {
1224 stream_putc(s
, (code
== CAPABILITY_CODE_ORF
1226 : ORF_TYPE_PREFIX_OLD
));
1228 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1229 PEER_FLAG_ORF_PREFIX_SM
)
1230 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1231 PEER_FLAG_ORF_PREFIX_RM
)) {
1232 SET_FLAG(peer
->af_cap
[afi
][safi
],
1233 PEER_CAP_ORF_PREFIX_SM_ADV
);
1234 SET_FLAG(peer
->af_cap
[afi
][safi
],
1235 PEER_CAP_ORF_PREFIX_RM_ADV
);
1236 stream_putc(s
, ORF_MODE_BOTH
);
1237 } else if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1238 PEER_FLAG_ORF_PREFIX_SM
)) {
1239 SET_FLAG(peer
->af_cap
[afi
][safi
],
1240 PEER_CAP_ORF_PREFIX_SM_ADV
);
1241 stream_putc(s
, ORF_MODE_SEND
);
1243 SET_FLAG(peer
->af_cap
[afi
][safi
],
1244 PEER_CAP_ORF_PREFIX_RM_ADV
);
1245 stream_putc(s
, ORF_MODE_RECEIVE
);
1250 /* Total Number of ORFs. */
1251 stream_putc_at(s
, numberp
, number_of_orfs
);
1253 /* Total ORF Len. */
1254 orf_len
= stream_get_endp(s
) - orfp
- 1;
1255 stream_putc_at(s
, orfp
, orf_len
);
1257 /* Total Capability Len. */
1258 cap_len
= stream_get_endp(s
) - capp
- 1;
1259 stream_putc_at(s
, capp
, cap_len
);
1262 /* Fill in capability open option to the packet. */
1263 void bgp_open_capability(struct stream
*s
, struct peer
*peer
)
1266 unsigned long cp
, capp
, rcapp
;
1270 iana_safi_t pkt_safi
;
1272 u_int32_t restart_time
;
1273 u_char afi_safi_count
= 0;
1274 int adv_addpath_tx
= 0;
1276 /* Remember current pointer for Opt Parm Len. */
1277 cp
= stream_get_endp(s
);
1282 /* Do not send capability. */
1283 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1284 || CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1287 /* MP capability for configured AFI, SAFI */
1288 FOREACH_AFI_SAFI (afi
, safi
) {
1289 if (peer
->afc
[afi
][safi
]) {
1290 /* Convert AFI, SAFI to values for packet. */
1291 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1294 peer
->afc_adv
[afi
][safi
] = 1;
1295 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1296 stream_putc(s
, CAPABILITY_CODE_MP_LEN
+ 2);
1297 stream_putc(s
, CAPABILITY_CODE_MP
);
1298 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
1299 stream_putw(s
, pkt_afi
);
1301 stream_putc(s
, pkt_safi
);
1303 /* Extended nexthop capability - currently
1304 * supporting RFC-5549 for
1305 * Link-Local peering only
1307 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)
1308 && peer
->su
.sa
.sa_family
== AF_INET6
1309 && IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
)
1311 && (safi
== SAFI_UNICAST
1312 || safi
== SAFI_LABELED_UNICAST
)) {
1313 /* RFC 5549 Extended Next Hop Encoding
1315 SET_FLAG(peer
->cap
, PEER_CAP_ENHE_ADV
);
1316 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1317 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1318 stream_putc(s
, CAPABILITY_CODE_ENHE
);
1319 stream_putc(s
, CAPABILITY_CODE_ENHE_LEN
);
1321 SET_FLAG(peer
->af_cap
[AFI_IP
][safi
],
1322 PEER_CAP_ENHE_AF_ADV
);
1323 stream_putw(s
, pkt_afi
);
1324 stream_putw(s
, pkt_safi
);
1325 stream_putw(s
, afi_int2iana(AFI_IP6
));
1327 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1328 PEER_CAP_ENHE_AF_RCV
))
1329 SET_FLAG(peer
->af_cap
[afi
][safi
],
1330 PEER_CAP_ENHE_AF_NEGO
);
1335 /* Route refresh. */
1336 SET_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
);
1337 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1338 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1339 stream_putc(s
, CAPABILITY_CODE_REFRESH_OLD
);
1340 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1341 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1342 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1343 stream_putc(s
, CAPABILITY_CODE_REFRESH
);
1344 stream_putc(s
, CAPABILITY_CODE_REFRESH_LEN
);
1347 SET_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
1348 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1349 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1350 stream_putc(s
, CAPABILITY_CODE_AS4
);
1351 stream_putc(s
, CAPABILITY_CODE_AS4_LEN
);
1352 if (peer
->change_local_as
)
1353 local_as
= peer
->change_local_as
;
1355 local_as
= peer
->local_as
;
1356 stream_putl(s
, local_as
);
1359 FOREACH_AFI_SAFI (afi
, safi
) {
1360 if (peer
->afc
[afi
][safi
]) {
1363 /* Only advertise addpath TX if a feature that
1366 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1367 PEER_FLAG_ADDPATH_TX_ALL_PATHS
)
1368 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1369 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1374 SET_FLAG(peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1375 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1376 stream_putc(s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1377 stream_putc(s
, CAPABILITY_CODE_ADDPATH
);
1378 stream_putc(s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1380 FOREACH_AFI_SAFI (afi
, safi
) {
1381 if (peer
->afc
[afi
][safi
]) {
1382 /* Convert AFI, SAFI to values for packet. */
1383 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1386 stream_putw(s
, pkt_afi
);
1387 stream_putc(s
, pkt_safi
);
1389 if (adv_addpath_tx
) {
1390 stream_putc(s
, BGP_ADDPATH_RX
| BGP_ADDPATH_TX
);
1391 SET_FLAG(peer
->af_cap
[afi
][safi
],
1392 PEER_CAP_ADDPATH_AF_RX_ADV
);
1393 SET_FLAG(peer
->af_cap
[afi
][safi
],
1394 PEER_CAP_ADDPATH_AF_TX_ADV
);
1396 stream_putc(s
, BGP_ADDPATH_RX
);
1397 SET_FLAG(peer
->af_cap
[afi
][safi
],
1398 PEER_CAP_ADDPATH_AF_RX_ADV
);
1399 UNSET_FLAG(peer
->af_cap
[afi
][safi
],
1400 PEER_CAP_ADDPATH_AF_TX_ADV
);
1405 /* ORF capability. */
1406 FOREACH_AFI_SAFI (afi
, safi
) {
1407 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1408 PEER_FLAG_ORF_PREFIX_SM
)
1409 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1410 PEER_FLAG_ORF_PREFIX_RM
)) {
1411 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1412 CAPABILITY_CODE_ORF_OLD
);
1413 bgp_open_capability_orf(s
, peer
, afi
, safi
,
1414 CAPABILITY_CODE_ORF
);
1418 /* Dynamic capability. */
1419 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
1420 SET_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1421 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1422 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1423 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1424 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1425 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1426 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1427 stream_putc(s
, CAPABILITY_CODE_DYNAMIC
);
1428 stream_putc(s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1431 /* Hostname capability */
1432 if (cmd_hostname_get()) {
1433 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1434 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1435 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1436 stream_putc(s
, 0); /* dummy len for now */
1437 stream_putc(s
, CAPABILITY_CODE_FQDN
);
1438 capp
= stream_get_endp(s
);
1439 stream_putc(s
, 0); /* dummy len for now */
1440 len
= strlen(cmd_hostname_get());
1441 if (len
> BGP_MAX_HOSTNAME
)
1442 len
= BGP_MAX_HOSTNAME
;
1444 stream_putc(s
, len
);
1445 stream_put(s
, cmd_hostname_get(), len
);
1446 if (cmd_domainname_get()) {
1447 len
= strlen(cmd_domainname_get());
1448 if (len
> BGP_MAX_HOSTNAME
)
1449 len
= BGP_MAX_HOSTNAME
;
1451 stream_putc(s
, len
);
1452 stream_put(s
, cmd_domainname_get(), len
);
1454 stream_putc(s
, 0); /* 0 length */
1456 /* Set the lengths straight */
1457 len
= stream_get_endp(s
) - rcapp
- 1;
1458 stream_putc_at(s
, rcapp
, len
);
1459 len
= stream_get_endp(s
) - capp
- 1;
1460 stream_putc_at(s
, capp
, len
);
1462 if (bgp_debug_neighbor_events(peer
))
1464 "%s Sending hostname cap with hn = %s, dn = %s",
1465 peer
->host
, cmd_hostname_get(),
1466 cmd_domainname_get());
1469 /* Sending base graceful-restart capability irrespective of the config
1471 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_ADV
);
1472 stream_putc(s
, BGP_OPEN_OPT_CAP
);
1473 capp
= stream_get_endp(s
); /* Set Capability Len Pointer */
1474 stream_putc(s
, 0); /* Capability Length */
1475 stream_putc(s
, CAPABILITY_CODE_RESTART
);
1476 rcapp
= stream_get_endp(s
); /* Set Restart Capability Len Pointer */
1478 restart_time
= peer
->bgp
->restart_time
;
1479 if (peer
->bgp
->t_startup
) {
1480 SET_FLAG(restart_time
, RESTART_R_BIT
);
1481 SET_FLAG(peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1483 stream_putw(s
, restart_time
);
1485 /* Send address-family specific graceful-restart capability only when GR
1488 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
)) {
1489 FOREACH_AFI_SAFI (afi
, safi
) {
1490 if (peer
->afc
[afi
][safi
]) {
1491 /* Convert AFI, SAFI to values for
1493 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
,
1495 stream_putw(s
, pkt_afi
);
1496 stream_putc(s
, pkt_safi
);
1497 if (bgp_flag_check(peer
->bgp
,
1498 BGP_FLAG_GR_PRESERVE_FWD
))
1499 stream_putc(s
, RESTART_F_BIT
);
1506 /* Total Graceful restart capability Len. */
1507 len
= stream_get_endp(s
) - rcapp
- 1;
1508 stream_putc_at(s
, rcapp
, len
);
1510 /* Total Capability Len. */
1511 len
= stream_get_endp(s
) - capp
- 1;
1512 stream_putc_at(s
, capp
, len
);
1514 /* Total Opt Parm Len. */
1515 len
= stream_get_endp(s
) - cp
- 1;
1516 stream_putc_at(s
, cp
, len
);