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. */
55 bgp_capability_vty_out (struct vty
*vty
, struct peer
*peer
, u_char use_json
, 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
;
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
)
85 bgp_map_afi_safi_iana2int (ntohs(mpc
.afi
), mpc
.safi
, &afi
, &safi
);
91 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv4");
94 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv6");
97 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "L2VPN");
100 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolAfiUnknown", ntohs (mpc
.afi
));
106 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "unicast");
109 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "multicast");
111 case SAFI_LABELED_UNICAST
:
112 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "labeled-unicast");
115 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "MPLS-labeled VPN");
118 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "encap");
121 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "EVPN");
124 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolSafiUnknown", mpc
.safi
);
130 vty_out (vty
, " Capability error for: Multi protocol ");
134 vty_out (vty
, "AFI IPv4, ");
137 vty_out (vty
, "AFI IPv6, ");
140 vty_out (vty
, "AFI L2VPN, ");
143 vty_out (vty
, "AFI Unknown %d, ", ntohs (mpc
.afi
));
149 vty_out (vty
, "SAFI Unicast");
152 vty_out (vty
, "SAFI Multicast");
154 case SAFI_LABELED_UNICAST
:
155 vty_out (vty
, "SAFI Labeled-unicast");
158 vty_out (vty
, "SAFI MPLS-labeled VPN");
161 vty_out (vty
, "SAFI ENCAP");
164 vty_out (vty
, "SAFI EVPN");
167 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
170 vty_out (vty
, "%s", VTY_NEWLINE
);
173 else if (hdr
->code
>= 128)
176 json_object_int_add(json_cap
, "capabilityErrorVendorSpecificCapabilityCode", hdr
->code
);
178 vty_out (vty
, " Capability error: vendor specific capability code %d",
184 json_object_int_add(json_cap
, "capabilityErrorUnknownCapabilityCode", hdr
->code
);
186 vty_out (vty
, " Capability error: unknown capability code %d",
189 pnt
+= hdr
->length
+ 2;
192 json_object_object_add(json_neigh
, "capabilityErrors", json_cap
);
196 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
198 mpc
->afi
= stream_getw (s
);
199 mpc
->reserved
= stream_getc (s
);
200 mpc
->safi
= stream_getc (s
);
203 /* Set negotiated capability value. */
205 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
207 struct capability_mp_data mpc
;
208 struct stream
*s
= BGP_INPUT (peer
);
212 /* Verify length is 4 */
213 if (hdr
->length
!= 4)
215 zlog_warn("MP Cap: Received invalid length %d, non-multiple of 4",
220 bgp_capability_mp_data (s
, &mpc
);
222 if (bgp_debug_neighbor_events(peer
))
223 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
224 peer
->host
, mpc
.afi
, mpc
.safi
);
226 /* Convert AFI, SAFI to internal values, check. */
227 if (bgp_map_afi_safi_iana2int (mpc
.afi
, mpc
.safi
, &afi
, &safi
))
230 /* Now safi remapped, and afi/safi are valid array indices */
231 peer
->afc_recv
[afi
][safi
] = 1;
233 if (peer
->afc
[afi
][safi
])
234 peer
->afc_nego
[afi
][safi
] = 1;
242 bgp_capability_orf_not_support (struct peer
*peer
, iana_afi_t afi
, safi_t safi
,
243 u_char type
, u_char mode
)
245 if (bgp_debug_neighbor_events(peer
))
246 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
247 peer
->host
, afi
, safi
, type
, mode
);
250 static const struct message orf_type_str
[] =
252 { ORF_TYPE_PREFIX
, "Prefixlist" },
253 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
255 static const int orf_type_str_max
= array_size(orf_type_str
);
257 static const struct message orf_mode_str
[] =
259 { ORF_MODE_RECEIVE
, "Receive" },
260 { ORF_MODE_SEND
, "Send" },
261 { ORF_MODE_BOTH
, "Both" },
263 static const int orf_mode_str_max
= array_size(orf_mode_str
);
266 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
268 struct stream
*s
= BGP_INPUT (peer
);
269 struct capability_orf_entry entry
;
272 safi_t pkt_safi
, safi
;
275 u_int16_t sm_cap
= 0; /* capability send-mode receive */
276 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
279 /* ORF Entry header */
280 bgp_capability_mp_data (s
, &entry
.mpc
);
281 entry
.num
= stream_getc (s
);
282 pkt_afi
= entry
.mpc
.afi
;
283 pkt_safi
= entry
.mpc
.safi
;
285 if (bgp_debug_neighbor_events(peer
))
286 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
287 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
289 /* Convert AFI, SAFI to internal values, check. */
290 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
292 zlog_info ("%s Addr-family %d/%d not supported."
293 " Ignoring the ORF capability",
294 peer
->host
, pkt_afi
, pkt_safi
);
298 entry
.mpc
.afi
= pkt_afi
;
299 entry
.mpc
.safi
= safi
;
301 /* validate number field */
302 if (CAPABILITY_CODE_ORF_LEN
+ (entry
.num
* 2) > hdr
->length
)
304 zlog_info ("%s ORF Capability entry length error,"
305 " Cap length %u, num %u",
306 peer
->host
, hdr
->length
, entry
.num
);
307 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
311 for (i
= 0 ; i
< entry
.num
; i
++)
313 type
= stream_getc(s
);
314 mode
= stream_getc(s
);
316 /* ORF Mode error check */
321 case ORF_MODE_RECEIVE
:
324 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
327 /* ORF Type and afi/safi error checks */
328 /* capcode versus type */
331 case CAPABILITY_CODE_ORF
:
334 case ORF_TYPE_PREFIX
:
337 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
341 case CAPABILITY_CODE_ORF_OLD
:
344 case ORF_TYPE_PREFIX_OLD
:
347 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
352 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
357 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
358 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
359 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
361 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
365 if (bgp_debug_neighbor_events(peer
))
366 zlog_debug ("%s OPEN has %s ORF capability"
367 " as %s for afi/safi: %d/%d",
368 peer
->host
, LOOKUP (orf_type_str
, type
),
369 LOOKUP (orf_mode_str
, mode
),
372 if (hdr
->code
== CAPABILITY_CODE_ORF
)
374 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
375 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
377 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
379 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
380 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
384 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
391 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
392 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
395 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
397 case ORF_MODE_RECEIVE
:
398 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
406 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
408 struct stream
*s
= BGP_INPUT (peer
);
409 u_int16_t restart_flag_time
;
410 size_t end
= stream_get_getp (s
) + caphdr
->length
;
412 /* Verify length is a multiple of 4 */
413 if ((caphdr
->length
-2) % 4)
415 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
420 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
421 restart_flag_time
= stream_getw(s
);
422 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
423 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
425 UNSET_FLAG (restart_flag_time
, 0xF000);
426 peer
->v_gr_restart
= restart_flag_time
;
428 if (bgp_debug_neighbor_events(peer
))
430 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
431 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
433 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
438 while (stream_get_getp (s
) + 4 <= end
)
442 iana_afi_t pkt_afi
= stream_getw (s
);
443 safi_t pkt_safi
= stream_getc (s
);
444 u_char flag
= stream_getc (s
);
446 /* Convert AFI, SAFI to internal values, check. */
447 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
449 if (bgp_debug_neighbor_events(peer
))
450 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
451 " Ignore the Graceful Restart capability for this AFI/SAFI",
452 peer
->host
, pkt_afi
, pkt_safi
);
454 else if (!peer
->afc
[afi
][safi
])
456 if (bgp_debug_neighbor_events(peer
))
457 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
458 " Ignore the Graceful Restart capability",
459 peer
->host
, pkt_afi
, pkt_safi
);
463 if (bgp_debug_neighbor_events(peer
))
464 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
465 afi_safi_print (afi
, safi
),
466 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
467 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
470 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
471 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
472 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
479 /* Unlike other capability parsing routines, this one returns 0 on error */
481 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
483 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
485 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
487 zlog_err ("%s AS4 capability has incorrect data length %d",
488 peer
->host
, hdr
->length
);
492 as_t as4
= stream_getl (BGP_INPUT(peer
));
494 if (BGP_DEBUG (as4
, AS4
))
495 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
501 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
503 struct stream
*s
= BGP_INPUT (peer
);
504 size_t end
= stream_get_getp (s
) + hdr
->length
;
506 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
508 /* Verify length is a multiple of 4 */
511 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
516 while (stream_get_getp (s
) + 4 <= end
)
520 iana_afi_t pkt_afi
= stream_getw (s
);
521 safi_t pkt_safi
= stream_getc (s
);
522 u_char send_receive
= stream_getc (s
);
524 if (bgp_debug_neighbor_events(peer
))
525 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
526 peer
->host
, pkt_afi
, pkt_safi
,
527 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
528 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
530 /* Convert AFI, SAFI to internal values, check. */
531 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
533 if (bgp_debug_neighbor_events(peer
))
534 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
535 " Ignore the Addpath Attribute for this AFI/SAFI",
536 peer
->host
, pkt_afi
, pkt_safi
);
539 else if (!peer
->afc
[afi
][safi
])
541 if (bgp_debug_neighbor_events(peer
))
542 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
543 " Ignore the AddPath capability for this AFI/SAFI",
544 peer
->host
, pkt_afi
, pkt_safi
);
548 if (send_receive
& BGP_ADDPATH_RX
)
549 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
551 if (send_receive
& BGP_ADDPATH_TX
)
552 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
559 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
561 struct stream
*s
= BGP_INPUT (peer
);
562 size_t end
= stream_get_getp (s
) + hdr
->length
;
564 /* Verify length is a multiple of 4 */
567 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
572 while (stream_get_getp (s
) + 6 <= end
)
574 iana_afi_t pkt_afi
= stream_getw (s
);
576 safi_t safi
, pkt_safi
= stream_getw (s
);
577 iana_afi_t pkt_nh_afi
= stream_getw (s
);
580 if (bgp_debug_neighbor_events(peer
))
581 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
582 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
584 /* Convert AFI, SAFI to internal values, check. */
585 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
587 if (bgp_debug_neighbor_events(peer
))
588 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
589 " Ignore the ENHE Attribute for this AFI/SAFI",
590 peer
->host
, pkt_afi
, pkt_safi
);
594 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
595 * the Nexthop AFI being IPv6. A future spec may introduce other
596 * possibilities, so we ignore other values with a log. Also, only
597 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported (and expected).
599 nh_afi
= afi_iana2int (pkt_nh_afi
);
601 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
|| !(safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
))
603 zlog_warn ("%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
604 "in Extended Next-hop capability, ignoring",
605 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
609 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
611 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
612 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
615 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
621 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
623 struct stream
*s
= BGP_INPUT (peer
);
624 char str
[BGP_MAX_HOSTNAME
+1];
625 size_t end
= stream_get_getp (s
) + hdr
->length
;
628 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
630 len
= stream_getc(s
);
631 if (stream_get_getp(s
) + len
> end
)
633 zlog_warn("%s: Received malformed hostname capability from peer %s",
634 __FUNCTION__
, peer
->host
);
638 if (len
> BGP_MAX_HOSTNAME
)
640 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
641 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
642 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
645 stream_get(str
, s
, len
);
651 if (peer
->hostname
!= NULL
)
653 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
654 peer
->hostname
= NULL
;
657 if (peer
->domainname
!= NULL
)
659 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
660 peer
->domainname
= NULL
;
663 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
666 if (stream_get_getp(s
) +1 > end
)
668 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
669 __FUNCTION__
, peer
->host
);
673 len
= stream_getc(s
);
674 if (stream_get_getp(s
) + len
> end
)
676 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
677 __FUNCTION__
, peer
->host
);
681 if (len
> BGP_MAX_HOSTNAME
)
683 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
684 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
685 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
688 stream_get(str
, s
, len
);
693 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
696 if (bgp_debug_neighbor_events(peer
))
698 zlog_debug("%s received hostname %s, domainname %s",
699 peer
->host
, peer
->hostname
, peer
->domainname
);
705 static const struct message capcode_str
[] =
707 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
708 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
709 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
710 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
711 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
712 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
713 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
714 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
715 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
716 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
717 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
718 { CAPABILITY_CODE_FQDN
, "FQDN" },
720 static const int capcode_str_max
= array_size(capcode_str
);
722 /* Minimum sizes for length field of each cap (so not inc. the header) */
723 static const size_t cap_minsizes
[] =
725 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
726 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
727 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
728 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
729 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
730 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
731 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
732 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
733 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
734 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
735 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
736 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
739 /* value the capability must be a multiple of.
740 * 0-data capabilities won't be checked against this.
741 * Other capabilities whose data doesn't fall on convenient boundaries for this
742 * table should be set to 1.
744 static const size_t cap_modsizes
[] =
746 [CAPABILITY_CODE_MP
] = 4,
747 [CAPABILITY_CODE_REFRESH
] = 1,
748 [CAPABILITY_CODE_ORF
] = 1,
749 [CAPABILITY_CODE_RESTART
] = 1,
750 [CAPABILITY_CODE_AS4
] = 4,
751 [CAPABILITY_CODE_ADDPATH
] = 4,
752 [CAPABILITY_CODE_DYNAMIC
] = 1,
753 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
754 [CAPABILITY_CODE_ENHE
] = 6,
755 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
756 [CAPABILITY_CODE_ORF_OLD
] = 1,
757 [CAPABILITY_CODE_FQDN
] = 1,
761 * Parse given capability.
762 * XXX: This is reading into a stream, but not using stream API
764 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
765 * capabilities were encountered.
768 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
772 struct stream
*s
= BGP_INPUT (peer
);
773 size_t end
= stream_get_getp (s
) + length
;
775 assert (STREAM_READABLE (s
) >= length
);
777 while (stream_get_getp (s
) < end
)
780 u_char
*sp
= stream_pnt (s
);
781 struct capability_header caphdr
;
784 /* We need at least capability code and capability length. */
785 if (stream_get_getp(s
) + 2 > end
)
787 zlog_info ("%s Capability length error (< header)", peer
->host
);
788 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
792 caphdr
.code
= stream_getc (s
);
793 caphdr
.length
= stream_getc (s
);
794 start
= stream_get_getp (s
);
796 /* Capability length check sanity check. */
797 if (start
+ caphdr
.length
> end
)
799 zlog_info ("%s Capability length error (< length)", peer
->host
);
800 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
804 if (bgp_debug_neighbor_events(peer
))
805 zlog_debug ("%s OPEN has %s capability (%u), length %u",
807 LOOKUP (capcode_str
, caphdr
.code
),
808 caphdr
.code
, caphdr
.length
);
810 /* Length sanity check, type-specific, for known capabilities */
813 case CAPABILITY_CODE_MP
:
814 case CAPABILITY_CODE_REFRESH
:
815 case CAPABILITY_CODE_REFRESH_OLD
:
816 case CAPABILITY_CODE_ORF
:
817 case CAPABILITY_CODE_ORF_OLD
:
818 case CAPABILITY_CODE_RESTART
:
819 case CAPABILITY_CODE_AS4
:
820 case CAPABILITY_CODE_ADDPATH
:
821 case CAPABILITY_CODE_DYNAMIC
:
822 case CAPABILITY_CODE_DYNAMIC_OLD
:
823 case CAPABILITY_CODE_ENHE
:
824 case CAPABILITY_CODE_FQDN
:
826 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
828 zlog_info ("%s %s Capability length error: got %u,"
829 " expected at least %u",
831 LOOKUP (capcode_str
, caphdr
.code
),
833 (unsigned) cap_minsizes
[caphdr
.code
]);
834 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
838 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
840 zlog_info ("%s %s Capability length error: got %u,"
841 " expected a multiple of %u",
843 LOOKUP (capcode_str
, caphdr
.code
),
845 (unsigned) cap_modsizes
[caphdr
.code
]);
846 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
847 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
850 /* we deliberately ignore unknown codes, see below */
857 case CAPABILITY_CODE_MP
:
861 /* Ignore capability when override-capability is set. */
862 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
864 /* Set negotiated value. */
865 ret
= bgp_capability_mp (peer
, &caphdr
);
867 /* Unsupported Capability. */
870 /* Store return data. */
871 memcpy (*error
, sp
, caphdr
.length
+ 2);
872 *error
+= caphdr
.length
+ 2;
874 ret
= 0; /* Don't return error for this */
878 case CAPABILITY_CODE_REFRESH
:
879 case CAPABILITY_CODE_REFRESH_OLD
:
881 /* BGP refresh capability */
882 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
883 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
885 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
888 case CAPABILITY_CODE_ORF
:
889 case CAPABILITY_CODE_ORF_OLD
:
890 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
892 case CAPABILITY_CODE_RESTART
:
893 ret
= bgp_capability_restart (peer
, &caphdr
);
895 case CAPABILITY_CODE_DYNAMIC
:
896 case CAPABILITY_CODE_DYNAMIC_OLD
:
897 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
899 case CAPABILITY_CODE_AS4
:
900 /* Already handled as a special-case parsing of the capabilities
901 * at the beginning of OPEN processing. So we care not a jot
902 * for the value really, only error case.
904 if (!bgp_capability_as4 (peer
, &caphdr
))
907 case CAPABILITY_CODE_ADDPATH
:
908 ret
= bgp_capability_addpath (peer
, &caphdr
);
910 case CAPABILITY_CODE_ENHE
:
911 ret
= bgp_capability_enhe (peer
, &caphdr
);
913 case CAPABILITY_CODE_FQDN
:
914 ret
= bgp_capability_hostname (peer
, &caphdr
);
917 if (caphdr
.code
> 128)
919 /* We don't send Notification for unknown vendor specific
920 capabilities. It seems reasonable for now... */
921 zlog_warn ("%s Vendor specific capability %d",
922 peer
->host
, caphdr
.code
);
926 zlog_warn ("%s unrecognized capability code: %d - ignored",
927 peer
->host
, caphdr
.code
);
928 memcpy (*error
, sp
, caphdr
.length
+ 2);
929 *error
+= caphdr
.length
+ 2;
935 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
938 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
940 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
941 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
942 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
944 stream_set_getp (s
, start
+ caphdr
.length
);
951 bgp_auth_parse (struct peer
*peer
, size_t length
)
953 bgp_notify_send (peer
,
955 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
960 strict_capability_same (struct peer
*peer
)
964 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
965 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
966 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
971 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
972 * Returns 0 if no as4 found, as4cap value otherwise.
975 peek_for_as4_capability (struct peer
*peer
, u_char length
)
977 struct stream
*s
= BGP_INPUT (peer
);
978 size_t orig_getp
= stream_get_getp (s
);
979 size_t end
= orig_getp
+ length
;
982 if (BGP_DEBUG (as4
, AS4
))
983 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
986 /* the error cases we DONT handle, we ONLY try to read as4 out of
987 * correctly formatted options.
989 while (stream_get_getp(s
) < end
)
994 /* Check the length. */
995 if (stream_get_getp (s
) + 2 > end
)
998 /* Fetch option type and length. */
999 opt_type
= stream_getc (s
);
1000 opt_length
= stream_getc (s
);
1002 /* Option length check. */
1003 if (stream_get_getp (s
) + opt_length
> end
)
1006 if (opt_type
== BGP_OPEN_OPT_CAP
)
1008 unsigned long capd_start
= stream_get_getp (s
);
1009 unsigned long capd_end
= capd_start
+ opt_length
;
1011 assert (capd_end
<= end
);
1013 while (stream_get_getp (s
) < capd_end
)
1015 struct capability_header hdr
;
1017 if (stream_get_getp (s
) + 2 > capd_end
)
1020 hdr
.code
= stream_getc (s
);
1021 hdr
.length
= stream_getc (s
);
1023 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
1026 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1028 if (BGP_DEBUG (as4
, AS4
))
1029 zlog_info ("[AS4] found AS4 capability, about to parse");
1030 as4
= bgp_capability_as4 (peer
, &hdr
);
1034 stream_forward_getp (s
, hdr
.length
);
1040 stream_set_getp (s
, orig_getp
);
1045 * Parse open option.
1047 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1050 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1054 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1055 struct stream
*s
= BGP_INPUT(peer
);
1056 size_t end
= stream_get_getp (s
) + length
;
1060 if (bgp_debug_neighbor_events(peer
))
1061 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1062 peer
->host
, length
);
1064 while (stream_get_getp(s
) < end
)
1069 /* Must have at least an OPEN option header */
1070 if (STREAM_READABLE(s
) < 2)
1072 zlog_info ("%s Option length error", peer
->host
);
1073 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1077 /* Fetch option type and length. */
1078 opt_type
= stream_getc (s
);
1079 opt_length
= stream_getc (s
);
1081 /* Option length check. */
1082 if (STREAM_READABLE (s
) < opt_length
)
1084 zlog_info ("%s Option length error", peer
->host
);
1085 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1089 if (bgp_debug_neighbor_events(peer
))
1090 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1091 peer
->host
, opt_type
,
1092 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1093 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1098 case BGP_OPEN_OPT_AUTH
:
1099 ret
= bgp_auth_parse (peer
, opt_length
);
1101 case BGP_OPEN_OPT_CAP
:
1102 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1105 bgp_notify_send (peer
,
1106 BGP_NOTIFY_OPEN_ERR
,
1107 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1112 /* Parse error. To accumulate all unsupported capability codes,
1113 bgp_capability_parse does not return -1 when encounter
1114 unsupported capability code. To detect that, please check
1115 error and erro_data pointer, like below. */
1120 /* All OPEN option is parsed. Check capability when strict compare
1122 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1124 /* If Unsupported Capability exists. */
1125 if (error
!= error_data
)
1127 bgp_notify_send_with_data (peer
,
1128 BGP_NOTIFY_OPEN_ERR
,
1129 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1130 error_data
, error
- error_data
);
1134 /* Check local capability does not negotiated with remote
1136 if (! strict_capability_same (peer
))
1138 bgp_notify_send (peer
,
1139 BGP_NOTIFY_OPEN_ERR
,
1140 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1145 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1147 if (*mp_capability
&&
1148 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1150 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1151 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1152 && ! peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1153 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1154 && ! peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1155 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1156 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1157 && ! peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1158 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1159 && ! peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1160 && ! peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
1162 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1163 "overlap with received MP capabilities",
1166 if (error
!= error_data
)
1167 bgp_notify_send_with_data (peer
,
1168 BGP_NOTIFY_OPEN_ERR
,
1169 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1170 error_data
, error
- error_data
);
1172 bgp_notify_send (peer
,
1173 BGP_NOTIFY_OPEN_ERR
,
1174 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1182 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1183 afi_t afi
, safi_t safi
, u_char code
)
1189 unsigned long numberp
;
1190 int number_of_orfs
= 0;
1194 /* Convert AFI, SAFI to values for packet. */
1195 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1197 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1198 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1199 stream_putc (s
, 0); /* Capability Length */
1200 stream_putc (s
, code
); /* Capability Code */
1201 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1202 stream_putc (s
, 0); /* ORF Length */
1203 stream_putw (s
, pkt_afi
);
1205 stream_putc (s
, pkt_safi
);
1206 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1207 stream_putc (s
, 0); /* Number of ORFs */
1209 /* Address Prefix ORF */
1210 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1211 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1213 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1214 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1216 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1217 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1219 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1220 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1221 stream_putc (s
, ORF_MODE_BOTH
);
1223 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1225 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1226 stream_putc (s
, ORF_MODE_SEND
);
1230 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1231 stream_putc (s
, ORF_MODE_RECEIVE
);
1236 /* Total Number of ORFs. */
1237 stream_putc_at (s
, numberp
, number_of_orfs
);
1239 /* Total ORF Len. */
1240 orf_len
= stream_get_endp (s
) - orfp
- 1;
1241 stream_putc_at (s
, orfp
, orf_len
);
1243 /* Total Capability Len. */
1244 cap_len
= stream_get_endp (s
) - capp
- 1;
1245 stream_putc_at (s
, capp
, cap_len
);
1248 /* Fill in capability open option to the packet. */
1250 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1253 unsigned long cp
, capp
, rcapp
;
1256 safi_t safi
, pkt_safi
;
1258 u_int32_t restart_time
;
1259 u_char afi_safi_count
= 0;
1260 struct utsname names
;
1261 int adv_addpath_tx
= 0;
1263 /* Remember current pointer for Opt Parm Len. */
1264 cp
= stream_get_endp (s
);
1269 /* Do not send capability. */
1270 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1271 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1274 /* MP capability for configured AFI, SAFI */
1275 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1276 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1278 if (peer
->afc
[afi
][safi
])
1280 /* Convert AFI, SAFI to values for packet. */
1281 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1283 peer
->afc_adv
[afi
][safi
] = 1;
1284 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1285 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1286 stream_putc (s
, CAPABILITY_CODE_MP
);
1287 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1288 stream_putw (s
, pkt_afi
);
1290 stream_putc (s
, pkt_safi
);
1292 /* Extended nexthop capability - currently supporting RFC-5549 for
1293 * Link-Local peering only
1295 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1296 peer
->su
.sa
.sa_family
== AF_INET6
&&
1297 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
) &&
1299 (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
))
1301 /* RFC 5549 Extended Next Hop Encoding */
1302 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1303 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1304 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1305 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1306 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1308 SET_FLAG (peer
->af_cap
[AFI_IP
][safi
], PEER_CAP_ENHE_AF_ADV
);
1309 stream_putw (s
, pkt_afi
);
1310 stream_putw (s
, pkt_safi
);
1311 stream_putw (s
, afi_int2iana(AFI_IP6
));
1313 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
))
1314 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
1319 /* Route refresh. */
1320 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1321 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1322 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1323 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1324 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1325 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1326 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1327 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1328 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1331 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1332 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1333 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1334 stream_putc (s
, CAPABILITY_CODE_AS4
);
1335 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1336 if ( peer
->change_local_as
)
1337 local_as
= peer
->change_local_as
;
1339 local_as
= peer
->local_as
;
1340 stream_putl (s
, local_as
);
1343 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1344 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1345 if (peer
->afc
[afi
][safi
])
1349 /* Only advertise addpath TX if a feature that will use it is
1351 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1352 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1356 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1357 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1358 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1359 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1360 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1362 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1363 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1364 if (peer
->afc
[afi
][safi
])
1366 /* Convert AFI, SAFI to values for packet. */
1367 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1369 stream_putw (s
, pkt_afi
);
1370 stream_putc (s
, pkt_safi
);
1374 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1375 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1376 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1380 stream_putc (s
, BGP_ADDPATH_RX
);
1381 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1382 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1386 /* ORF capability. */
1387 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1388 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1389 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1390 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1392 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1393 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1396 /* Dynamic capability. */
1397 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1399 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1400 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1401 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1402 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1403 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1404 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1405 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1406 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1407 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1410 /* Hostname capability */
1412 if (names
.nodename
[0] != '\0')
1414 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1415 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1416 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1417 stream_putc(s
, 0); /* dummy len for now */
1418 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1419 capp
= stream_get_endp(s
);
1420 stream_putc(s
, 0); /* dummy len for now */
1421 len
= strlen(names
.nodename
);
1422 if (len
> BGP_MAX_HOSTNAME
)
1423 len
= BGP_MAX_HOSTNAME
;
1425 stream_putc(s
, len
);
1426 stream_put(s
, names
.nodename
, len
);
1427 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1428 if ((names
.domainname
[0] != '\0') &&
1429 (strcmp(names
.domainname
, "(none)") != 0))
1431 len
= strlen(names
.domainname
);
1432 if (len
> BGP_MAX_HOSTNAME
)
1433 len
= BGP_MAX_HOSTNAME
;
1435 stream_putc(s
, len
);
1436 stream_put(s
, names
.domainname
, len
);
1441 stream_putc(s
, 0); /* 0 length */
1444 /* Set the lengths straight */
1445 len
= stream_get_endp(s
) - rcapp
- 1;
1446 stream_putc_at(s
, rcapp
, len
);
1447 len
= stream_get_endp(s
) - capp
- 1;
1448 stream_putc_at(s
, capp
, len
);
1450 if (bgp_debug_neighbor_events(peer
))
1451 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1452 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1453 peer
->host
, names
.nodename
, names
.domainname
);
1455 zlog_debug("%s Sending hostname cap with hn = %s", peer
->host
,
1460 /* Sending base graceful-restart capability irrespective of the config */
1461 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1462 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1463 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1464 stream_putc (s
, 0); /* Capability Length */
1465 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1466 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1468 restart_time
= peer
->bgp
->restart_time
;
1469 if (peer
->bgp
->t_startup
)
1471 SET_FLAG (restart_time
, RESTART_R_BIT
);
1472 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1474 stream_putw (s
, restart_time
);
1476 /* Send address-family specific graceful-restart capability only when GR config
1478 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1480 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1481 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1482 if (peer
->afc
[afi
][safi
])
1484 /* Convert AFI, SAFI to values for packet. */
1485 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1486 stream_putw (s
, pkt_afi
);
1487 stream_putc (s
, pkt_safi
);
1488 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
1489 stream_putc (s
, RESTART_F_BIT
);
1495 /* Total Graceful restart capability Len. */
1496 len
= stream_get_endp (s
) - rcapp
- 1;
1497 stream_putc_at (s
, rcapp
, len
);
1499 /* Total Capability Len. */
1500 len
= stream_get_endp (s
) - capp
- 1;
1501 stream_putc_at (s
, capp
, len
);
1503 /* Total Opt Parm Len. */
1504 len
= stream_get_endp (s
) - cp
- 1;
1505 stream_putc_at (s
, cp
, len
);