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_mp_data mpc
;
273 safi_t pkt_safi
, safi
;
276 u_int16_t sm_cap
= 0; /* capability send-mode receive */
277 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
280 /* ORF Entry header */
281 bgp_capability_mp_data (s
, &mpc
);
282 num
= stream_getc (s
);
286 if (bgp_debug_neighbor_events(peer
))
287 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
288 peer
->host
, mpc
.afi
, mpc
.safi
);
290 /* Convert AFI, SAFI to internal values, check. */
291 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
293 zlog_info ("%s Addr-family %d/%d not supported."
294 " Ignoring the ORF capability",
295 peer
->host
, pkt_afi
, pkt_safi
);
302 /* validate number field */
303 if (CAPABILITY_CODE_ORF_LEN
+ (num
* 2) > hdr
->length
)
305 zlog_info ("%s ORF Capability entry length error,"
306 " Cap length %u, num %u",
307 peer
->host
, hdr
->length
, num
);
308 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
312 for (i
= 0 ; i
< num
; i
++)
314 type
= stream_getc(s
);
315 mode
= stream_getc(s
);
317 /* ORF Mode error check */
322 case ORF_MODE_RECEIVE
:
325 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
328 /* ORF Type and afi/safi error checks */
329 /* capcode versus type */
332 case CAPABILITY_CODE_ORF
:
335 case ORF_TYPE_PREFIX
:
338 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
342 case CAPABILITY_CODE_ORF_OLD
:
345 case ORF_TYPE_PREFIX_OLD
:
348 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
353 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
358 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
359 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
360 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
362 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
366 if (bgp_debug_neighbor_events(peer
))
367 zlog_debug ("%s OPEN has %s ORF capability"
368 " as %s for afi/safi: %d/%d",
369 peer
->host
, LOOKUP (orf_type_str
, type
),
370 LOOKUP (orf_mode_str
, mode
),
373 if (hdr
->code
== CAPABILITY_CODE_ORF
)
375 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
376 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
378 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
380 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
381 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
385 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
392 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
393 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
396 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
398 case ORF_MODE_RECEIVE
:
399 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
407 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
409 struct stream
*s
= BGP_INPUT (peer
);
410 u_int16_t restart_flag_time
;
411 size_t end
= stream_get_getp (s
) + caphdr
->length
;
413 /* Verify length is a multiple of 4 */
414 if ((caphdr
->length
-2) % 4)
416 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
421 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
422 restart_flag_time
= stream_getw(s
);
423 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
424 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
426 UNSET_FLAG (restart_flag_time
, 0xF000);
427 peer
->v_gr_restart
= restart_flag_time
;
429 if (bgp_debug_neighbor_events(peer
))
431 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
432 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
434 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
439 while (stream_get_getp (s
) + 4 <= end
)
443 iana_afi_t pkt_afi
= stream_getw (s
);
444 safi_t pkt_safi
= stream_getc (s
);
445 u_char flag
= stream_getc (s
);
447 /* Convert AFI, SAFI to internal values, check. */
448 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
450 if (bgp_debug_neighbor_events(peer
))
451 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
452 " Ignore the Graceful Restart capability for this AFI/SAFI",
453 peer
->host
, pkt_afi
, pkt_safi
);
455 else if (!peer
->afc
[afi
][safi
])
457 if (bgp_debug_neighbor_events(peer
))
458 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
459 " Ignore the Graceful Restart capability",
460 peer
->host
, pkt_afi
, pkt_safi
);
464 if (bgp_debug_neighbor_events(peer
))
465 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
466 afi_safi_print (afi
, safi
),
467 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
468 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
471 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
472 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
473 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
480 /* Unlike other capability parsing routines, this one returns 0 on error */
482 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
484 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
486 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
488 zlog_err ("%s AS4 capability has incorrect data length %d",
489 peer
->host
, hdr
->length
);
493 as_t as4
= stream_getl (BGP_INPUT(peer
));
495 if (BGP_DEBUG (as4
, AS4
))
496 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
502 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
504 struct stream
*s
= BGP_INPUT (peer
);
505 size_t end
= stream_get_getp (s
) + hdr
->length
;
507 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
509 /* Verify length is a multiple of 4 */
512 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
517 while (stream_get_getp (s
) + 4 <= end
)
521 iana_afi_t pkt_afi
= stream_getw (s
);
522 safi_t pkt_safi
= stream_getc (s
);
523 u_char send_receive
= stream_getc (s
);
525 if (bgp_debug_neighbor_events(peer
))
526 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
527 peer
->host
, pkt_afi
, pkt_safi
,
528 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
529 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
531 /* Convert AFI, SAFI to internal values, check. */
532 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
534 if (bgp_debug_neighbor_events(peer
))
535 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
536 " Ignore the Addpath Attribute for this AFI/SAFI",
537 peer
->host
, pkt_afi
, pkt_safi
);
540 else if (!peer
->afc
[afi
][safi
])
542 if (bgp_debug_neighbor_events(peer
))
543 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
544 " Ignore the AddPath capability for this AFI/SAFI",
545 peer
->host
, pkt_afi
, pkt_safi
);
549 if (send_receive
& BGP_ADDPATH_RX
)
550 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
552 if (send_receive
& BGP_ADDPATH_TX
)
553 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
560 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
562 struct stream
*s
= BGP_INPUT (peer
);
563 size_t end
= stream_get_getp (s
) + hdr
->length
;
565 /* Verify length is a multiple of 4 */
568 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
573 while (stream_get_getp (s
) + 6 <= end
)
575 iana_afi_t pkt_afi
= stream_getw (s
);
577 safi_t safi
, pkt_safi
= stream_getw (s
);
578 iana_afi_t pkt_nh_afi
= stream_getw (s
);
581 if (bgp_debug_neighbor_events(peer
))
582 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
583 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
585 /* Convert AFI, SAFI to internal values, check. */
586 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
588 if (bgp_debug_neighbor_events(peer
))
589 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
590 " Ignore the ENHE Attribute for this AFI/SAFI",
591 peer
->host
, pkt_afi
, pkt_safi
);
595 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
596 * the Nexthop AFI being IPv6. A future spec may introduce other
597 * possibilities, so we ignore other values with a log. Also, only
598 * SAFI_UNICAST and SAFI_LABELED_UNICAST are currently supported (and expected).
600 nh_afi
= afi_iana2int (pkt_nh_afi
);
602 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
|| !(safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
))
604 zlog_warn ("%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
605 "in Extended Next-hop capability, ignoring",
606 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
610 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
612 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
613 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
616 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
622 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
624 struct stream
*s
= BGP_INPUT (peer
);
625 char str
[BGP_MAX_HOSTNAME
+1];
626 size_t end
= stream_get_getp (s
) + hdr
->length
;
629 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
631 len
= stream_getc(s
);
632 if (stream_get_getp(s
) + len
> end
)
634 zlog_warn("%s: Received malformed hostname capability from peer %s",
635 __FUNCTION__
, peer
->host
);
639 if (len
> BGP_MAX_HOSTNAME
)
641 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
642 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
643 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
646 stream_get(str
, s
, len
);
652 if (peer
->hostname
!= NULL
)
654 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
655 peer
->hostname
= NULL
;
658 if (peer
->domainname
!= NULL
)
660 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
661 peer
->domainname
= NULL
;
664 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
667 if (stream_get_getp(s
) +1 > end
)
669 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
670 __FUNCTION__
, peer
->host
);
674 len
= stream_getc(s
);
675 if (stream_get_getp(s
) + len
> end
)
677 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
678 __FUNCTION__
, peer
->host
);
682 if (len
> BGP_MAX_HOSTNAME
)
684 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
685 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
686 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
689 stream_get(str
, s
, len
);
694 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
697 if (bgp_debug_neighbor_events(peer
))
699 zlog_debug("%s received hostname %s, domainname %s",
700 peer
->host
, peer
->hostname
, peer
->domainname
);
706 static const struct message capcode_str
[] =
708 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
709 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
710 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
711 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
712 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
713 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
714 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
715 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
716 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
717 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
718 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
719 { CAPABILITY_CODE_FQDN
, "FQDN" },
721 static const int capcode_str_max
= array_size(capcode_str
);
723 /* Minimum sizes for length field of each cap (so not inc. the header) */
724 static const size_t cap_minsizes
[] =
726 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
727 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
728 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
729 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
730 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
731 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
732 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
733 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
734 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
735 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
736 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
737 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
740 /* value the capability must be a multiple of.
741 * 0-data capabilities won't be checked against this.
742 * Other capabilities whose data doesn't fall on convenient boundaries for this
743 * table should be set to 1.
745 static const size_t cap_modsizes
[] =
747 [CAPABILITY_CODE_MP
] = 4,
748 [CAPABILITY_CODE_REFRESH
] = 1,
749 [CAPABILITY_CODE_ORF
] = 1,
750 [CAPABILITY_CODE_RESTART
] = 1,
751 [CAPABILITY_CODE_AS4
] = 4,
752 [CAPABILITY_CODE_ADDPATH
] = 4,
753 [CAPABILITY_CODE_DYNAMIC
] = 1,
754 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
755 [CAPABILITY_CODE_ENHE
] = 6,
756 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
757 [CAPABILITY_CODE_ORF_OLD
] = 1,
758 [CAPABILITY_CODE_FQDN
] = 1,
762 * Parse given capability.
763 * XXX: This is reading into a stream, but not using stream API
765 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
766 * capabilities were encountered.
769 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
773 struct stream
*s
= BGP_INPUT (peer
);
774 size_t end
= stream_get_getp (s
) + length
;
776 assert (STREAM_READABLE (s
) >= length
);
778 while (stream_get_getp (s
) < end
)
781 u_char
*sp
= stream_pnt (s
);
782 struct capability_header caphdr
;
785 /* We need at least capability code and capability length. */
786 if (stream_get_getp(s
) + 2 > end
)
788 zlog_info ("%s Capability length error (< header)", peer
->host
);
789 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
793 caphdr
.code
= stream_getc (s
);
794 caphdr
.length
= stream_getc (s
);
795 start
= stream_get_getp (s
);
797 /* Capability length check sanity check. */
798 if (start
+ caphdr
.length
> end
)
800 zlog_info ("%s Capability length error (< length)", peer
->host
);
801 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
805 if (bgp_debug_neighbor_events(peer
))
806 zlog_debug ("%s OPEN has %s capability (%u), length %u",
808 LOOKUP (capcode_str
, caphdr
.code
),
809 caphdr
.code
, caphdr
.length
);
811 /* Length sanity check, type-specific, for known capabilities */
814 case CAPABILITY_CODE_MP
:
815 case CAPABILITY_CODE_REFRESH
:
816 case CAPABILITY_CODE_REFRESH_OLD
:
817 case CAPABILITY_CODE_ORF
:
818 case CAPABILITY_CODE_ORF_OLD
:
819 case CAPABILITY_CODE_RESTART
:
820 case CAPABILITY_CODE_AS4
:
821 case CAPABILITY_CODE_ADDPATH
:
822 case CAPABILITY_CODE_DYNAMIC
:
823 case CAPABILITY_CODE_DYNAMIC_OLD
:
824 case CAPABILITY_CODE_ENHE
:
825 case CAPABILITY_CODE_FQDN
:
827 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
829 zlog_info ("%s %s Capability length error: got %u,"
830 " expected at least %u",
832 LOOKUP (capcode_str
, caphdr
.code
),
834 (unsigned) cap_minsizes
[caphdr
.code
]);
835 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
839 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
841 zlog_info ("%s %s Capability length error: got %u,"
842 " expected a multiple of %u",
844 LOOKUP (capcode_str
, caphdr
.code
),
846 (unsigned) cap_modsizes
[caphdr
.code
]);
847 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
848 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
851 /* we deliberately ignore unknown codes, see below */
858 case CAPABILITY_CODE_MP
:
862 /* Ignore capability when override-capability is set. */
863 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
865 /* Set negotiated value. */
866 ret
= bgp_capability_mp (peer
, &caphdr
);
868 /* Unsupported Capability. */
871 /* Store return data. */
872 memcpy (*error
, sp
, caphdr
.length
+ 2);
873 *error
+= caphdr
.length
+ 2;
875 ret
= 0; /* Don't return error for this */
879 case CAPABILITY_CODE_REFRESH
:
880 case CAPABILITY_CODE_REFRESH_OLD
:
882 /* BGP refresh capability */
883 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
884 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
886 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
889 case CAPABILITY_CODE_ORF
:
890 case CAPABILITY_CODE_ORF_OLD
:
891 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
893 case CAPABILITY_CODE_RESTART
:
894 ret
= bgp_capability_restart (peer
, &caphdr
);
896 case CAPABILITY_CODE_DYNAMIC
:
897 case CAPABILITY_CODE_DYNAMIC_OLD
:
898 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
900 case CAPABILITY_CODE_AS4
:
901 /* Already handled as a special-case parsing of the capabilities
902 * at the beginning of OPEN processing. So we care not a jot
903 * for the value really, only error case.
905 if (!bgp_capability_as4 (peer
, &caphdr
))
908 case CAPABILITY_CODE_ADDPATH
:
909 ret
= bgp_capability_addpath (peer
, &caphdr
);
911 case CAPABILITY_CODE_ENHE
:
912 ret
= bgp_capability_enhe (peer
, &caphdr
);
914 case CAPABILITY_CODE_FQDN
:
915 ret
= bgp_capability_hostname (peer
, &caphdr
);
918 if (caphdr
.code
> 128)
920 /* We don't send Notification for unknown vendor specific
921 capabilities. It seems reasonable for now... */
922 zlog_warn ("%s Vendor specific capability %d",
923 peer
->host
, caphdr
.code
);
927 zlog_warn ("%s unrecognized capability code: %d - ignored",
928 peer
->host
, caphdr
.code
);
929 memcpy (*error
, sp
, caphdr
.length
+ 2);
930 *error
+= caphdr
.length
+ 2;
936 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
939 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
941 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
942 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
943 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
945 stream_set_getp (s
, start
+ caphdr
.length
);
952 bgp_auth_parse (struct peer
*peer
, size_t length
)
954 bgp_notify_send (peer
,
956 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
961 strict_capability_same (struct peer
*peer
)
965 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
966 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
967 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
972 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
973 * Returns 0 if no as4 found, as4cap value otherwise.
976 peek_for_as4_capability (struct peer
*peer
, u_char length
)
978 struct stream
*s
= BGP_INPUT (peer
);
979 size_t orig_getp
= stream_get_getp (s
);
980 size_t end
= orig_getp
+ length
;
983 if (BGP_DEBUG (as4
, AS4
))
984 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
987 /* the error cases we DONT handle, we ONLY try to read as4 out of
988 * correctly formatted options.
990 while (stream_get_getp(s
) < end
)
995 /* Check the length. */
996 if (stream_get_getp (s
) + 2 > end
)
999 /* Fetch option type and length. */
1000 opt_type
= stream_getc (s
);
1001 opt_length
= stream_getc (s
);
1003 /* Option length check. */
1004 if (stream_get_getp (s
) + opt_length
> end
)
1007 if (opt_type
== BGP_OPEN_OPT_CAP
)
1009 unsigned long capd_start
= stream_get_getp (s
);
1010 unsigned long capd_end
= capd_start
+ opt_length
;
1012 assert (capd_end
<= end
);
1014 while (stream_get_getp (s
) < capd_end
)
1016 struct capability_header hdr
;
1018 if (stream_get_getp (s
) + 2 > capd_end
)
1021 hdr
.code
= stream_getc (s
);
1022 hdr
.length
= stream_getc (s
);
1024 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
1027 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1029 if (BGP_DEBUG (as4
, AS4
))
1030 zlog_info ("[AS4] found AS4 capability, about to parse");
1031 as4
= bgp_capability_as4 (peer
, &hdr
);
1035 stream_forward_getp (s
, hdr
.length
);
1041 stream_set_getp (s
, orig_getp
);
1046 * Parse open option.
1048 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1051 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1055 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1056 struct stream
*s
= BGP_INPUT(peer
);
1057 size_t end
= stream_get_getp (s
) + length
;
1061 if (bgp_debug_neighbor_events(peer
))
1062 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1063 peer
->host
, length
);
1065 while (stream_get_getp(s
) < end
)
1070 /* Must have at least an OPEN option header */
1071 if (STREAM_READABLE(s
) < 2)
1073 zlog_info ("%s Option length error", peer
->host
);
1074 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1078 /* Fetch option type and length. */
1079 opt_type
= stream_getc (s
);
1080 opt_length
= stream_getc (s
);
1082 /* Option length check. */
1083 if (STREAM_READABLE (s
) < opt_length
)
1085 zlog_info ("%s Option length error", peer
->host
);
1086 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1090 if (bgp_debug_neighbor_events(peer
))
1091 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1092 peer
->host
, opt_type
,
1093 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1094 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1099 case BGP_OPEN_OPT_AUTH
:
1100 ret
= bgp_auth_parse (peer
, opt_length
);
1102 case BGP_OPEN_OPT_CAP
:
1103 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1106 bgp_notify_send (peer
,
1107 BGP_NOTIFY_OPEN_ERR
,
1108 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1113 /* Parse error. To accumulate all unsupported capability codes,
1114 bgp_capability_parse does not return -1 when encounter
1115 unsupported capability code. To detect that, please check
1116 error and erro_data pointer, like below. */
1121 /* All OPEN option is parsed. Check capability when strict compare
1123 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1125 /* If Unsupported Capability exists. */
1126 if (error
!= error_data
)
1128 bgp_notify_send_with_data (peer
,
1129 BGP_NOTIFY_OPEN_ERR
,
1130 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1131 error_data
, error
- error_data
);
1135 /* Check local capability does not negotiated with remote
1137 if (! strict_capability_same (peer
))
1139 bgp_notify_send (peer
,
1140 BGP_NOTIFY_OPEN_ERR
,
1141 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1146 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1148 if (*mp_capability
&&
1149 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1151 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1152 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1153 && ! peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1154 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1155 && ! peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1156 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1157 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1158 && ! peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1159 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1160 && ! peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
1161 && ! peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
1163 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1164 "overlap with received MP capabilities",
1167 if (error
!= error_data
)
1168 bgp_notify_send_with_data (peer
,
1169 BGP_NOTIFY_OPEN_ERR
,
1170 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1171 error_data
, error
- error_data
);
1173 bgp_notify_send (peer
,
1174 BGP_NOTIFY_OPEN_ERR
,
1175 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1183 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1184 afi_t afi
, safi_t safi
, u_char code
)
1190 unsigned long numberp
;
1191 int number_of_orfs
= 0;
1195 /* Convert AFI, SAFI to values for packet. */
1196 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1198 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1199 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1200 stream_putc (s
, 0); /* Capability Length */
1201 stream_putc (s
, code
); /* Capability Code */
1202 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1203 stream_putc (s
, 0); /* ORF Length */
1204 stream_putw (s
, pkt_afi
);
1206 stream_putc (s
, pkt_safi
);
1207 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1208 stream_putc (s
, 0); /* Number of ORFs */
1210 /* Address Prefix ORF */
1211 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1212 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1214 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1215 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1217 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1218 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1220 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1221 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1222 stream_putc (s
, ORF_MODE_BOTH
);
1224 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1226 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1227 stream_putc (s
, ORF_MODE_SEND
);
1231 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1232 stream_putc (s
, ORF_MODE_RECEIVE
);
1237 /* Total Number of ORFs. */
1238 stream_putc_at (s
, numberp
, number_of_orfs
);
1240 /* Total ORF Len. */
1241 orf_len
= stream_get_endp (s
) - orfp
- 1;
1242 stream_putc_at (s
, orfp
, orf_len
);
1244 /* Total Capability Len. */
1245 cap_len
= stream_get_endp (s
) - capp
- 1;
1246 stream_putc_at (s
, capp
, cap_len
);
1249 /* Fill in capability open option to the packet. */
1251 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1254 unsigned long cp
, capp
, rcapp
;
1257 safi_t safi
, pkt_safi
;
1259 u_int32_t restart_time
;
1260 u_char afi_safi_count
= 0;
1261 struct utsname names
;
1262 int adv_addpath_tx
= 0;
1264 /* Remember current pointer for Opt Parm Len. */
1265 cp
= stream_get_endp (s
);
1270 /* Do not send capability. */
1271 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1272 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1275 /* MP capability for configured AFI, SAFI */
1276 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1277 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1279 if (peer
->afc
[afi
][safi
])
1281 /* Convert AFI, SAFI to values for packet. */
1282 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1284 peer
->afc_adv
[afi
][safi
] = 1;
1285 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1286 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1287 stream_putc (s
, CAPABILITY_CODE_MP
);
1288 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1289 stream_putw (s
, pkt_afi
);
1291 stream_putc (s
, pkt_safi
);
1293 /* Extended nexthop capability - currently supporting RFC-5549 for
1294 * Link-Local peering only
1296 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1297 peer
->su
.sa
.sa_family
== AF_INET6
&&
1298 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
) &&
1300 (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
))
1302 /* RFC 5549 Extended Next Hop Encoding */
1303 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1304 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1305 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1306 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1307 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1309 SET_FLAG (peer
->af_cap
[AFI_IP
][safi
], PEER_CAP_ENHE_AF_ADV
);
1310 stream_putw (s
, pkt_afi
);
1311 stream_putw (s
, pkt_safi
);
1312 stream_putw (s
, afi_int2iana(AFI_IP6
));
1314 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
))
1315 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
1320 /* Route refresh. */
1321 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1322 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1323 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1324 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1325 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1326 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1327 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1328 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1329 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1332 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1333 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1334 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1335 stream_putc (s
, CAPABILITY_CODE_AS4
);
1336 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1337 if ( peer
->change_local_as
)
1338 local_as
= peer
->change_local_as
;
1340 local_as
= peer
->local_as
;
1341 stream_putl (s
, local_as
);
1344 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1345 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1346 if (peer
->afc
[afi
][safi
])
1350 /* Only advertise addpath TX if a feature that will use it is
1352 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1353 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1357 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1358 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1359 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1360 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1361 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1363 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1364 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1365 if (peer
->afc
[afi
][safi
])
1367 /* Convert AFI, SAFI to values for packet. */
1368 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1370 stream_putw (s
, pkt_afi
);
1371 stream_putc (s
, pkt_safi
);
1375 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1376 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1377 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1381 stream_putc (s
, BGP_ADDPATH_RX
);
1382 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1383 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1387 /* ORF capability. */
1388 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1389 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1390 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1391 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1393 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1394 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1397 /* Dynamic capability. */
1398 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1400 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1401 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1402 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1403 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1404 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1405 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1406 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1407 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1408 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1411 /* Hostname capability */
1413 if (names
.nodename
[0] != '\0')
1415 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1416 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1417 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1418 stream_putc(s
, 0); /* dummy len for now */
1419 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1420 capp
= stream_get_endp(s
);
1421 stream_putc(s
, 0); /* dummy len for now */
1422 len
= strlen(names
.nodename
);
1423 if (len
> BGP_MAX_HOSTNAME
)
1424 len
= BGP_MAX_HOSTNAME
;
1426 stream_putc(s
, len
);
1427 stream_put(s
, names
.nodename
, len
);
1428 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1429 if ((names
.domainname
[0] != '\0') &&
1430 (strcmp(names
.domainname
, "(none)") != 0))
1432 len
= strlen(names
.domainname
);
1433 if (len
> BGP_MAX_HOSTNAME
)
1434 len
= BGP_MAX_HOSTNAME
;
1436 stream_putc(s
, len
);
1437 stream_put(s
, names
.domainname
, len
);
1442 stream_putc(s
, 0); /* 0 length */
1445 /* Set the lengths straight */
1446 len
= stream_get_endp(s
) - rcapp
- 1;
1447 stream_putc_at(s
, rcapp
, len
);
1448 len
= stream_get_endp(s
) - capp
- 1;
1449 stream_putc_at(s
, capp
, len
);
1451 if (bgp_debug_neighbor_events(peer
))
1452 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1453 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1454 peer
->host
, names
.nodename
, names
.domainname
);
1456 zlog_debug("%s Sending hostname cap with hn = %s", peer
->host
,
1461 /* Sending base graceful-restart capability irrespective of the config */
1462 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1463 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1464 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1465 stream_putc (s
, 0); /* Capability Length */
1466 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1467 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1469 restart_time
= peer
->bgp
->restart_time
;
1470 if (peer
->bgp
->t_startup
)
1472 SET_FLAG (restart_time
, RESTART_R_BIT
);
1473 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1475 stream_putw (s
, restart_time
);
1477 /* Send address-family specific graceful-restart capability only when GR config
1479 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1481 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1482 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1483 if (peer
->afc
[afi
][safi
])
1485 /* Convert AFI, SAFI to values for packet. */
1486 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1487 stream_putw (s
, pkt_afi
);
1488 stream_putc (s
, pkt_safi
);
1489 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
1490 stream_putc (s
, RESTART_F_BIT
);
1496 /* Total Graceful restart capability Len. */
1497 len
= stream_get_endp (s
) - rcapp
- 1;
1498 stream_putc_at (s
, rcapp
, len
);
1500 /* Total Capability Len. */
1501 len
= stream_get_endp (s
) - capp
- 1;
1502 stream_putc_at (s
, capp
, len
);
1504 /* Total Opt Parm Len. */
1505 len
= stream_get_endp (s
) - cp
- 1;
1506 stream_putc_at (s
, cp
, len
);