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
17 along with GNU Zebra; see the file COPYING. If not, write to the Free
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
33 #include "bgpd/bgpd.h"
34 #include "bgpd/bgp_attr.h"
35 #include "bgpd/bgp_debug.h"
36 #include "bgpd/bgp_fsm.h"
37 #include "bgpd/bgp_packet.h"
38 #include "bgpd/bgp_open.h"
39 #include "bgpd/bgp_aspath.h"
40 #include "bgpd/bgp_vty.h"
42 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
43 negotiate remote peer supports extentions or not. But if
44 remote-peer doesn't supports negotiation process itself. We would
45 like to do manual configuration.
47 So there is many configurable point. First of all we want set each
48 peer whether we send capability negotiation to the peer or not.
49 Next, if we send capability to the peer we want to set my capabilty
50 inforation at each peer. */
53 bgp_capability_vty_out (struct vty
*vty
, struct peer
*peer
, u_char use_json
, json_object
*json_neigh
)
57 struct capability_mp_data mpc
;
58 struct capability_header
*hdr
;
59 json_object
*json_cap
= NULL
;
62 json_cap
= json_object_new_object();
64 pnt
= peer
->notify
.data
;
65 end
= pnt
+ peer
->notify
.length
;
69 if (pnt
+ sizeof (struct capability_mp_data
) + 2 > end
)
72 hdr
= (struct capability_header
*)pnt
;
73 if (pnt
+ hdr
->length
+ 2 > end
)
76 memcpy (&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
78 if (hdr
->code
== CAPABILITY_CODE_MP
)
82 switch (ntohs (mpc
.afi
))
85 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv4");
88 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv6");
91 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolAfiUnknown", ntohs (mpc
.afi
));
97 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "unicast");
100 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "multicast");
102 case SAFI_MPLS_LABELED_VPN
:
103 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "MPLS-labeled VPN");
106 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolSafiUnknown", mpc
.safi
);
112 vty_out (vty
, " Capability error for: Multi protocol ");
113 switch (ntohs (mpc
.afi
))
116 vty_out (vty
, "AFI IPv4, ");
119 vty_out (vty
, "AFI IPv6, ");
122 vty_out (vty
, "AFI Unknown %d, ", ntohs (mpc
.afi
));
128 vty_out (vty
, "SAFI Unicast");
131 vty_out (vty
, "SAFI Multicast");
133 case SAFI_MPLS_LABELED_VPN
:
134 vty_out (vty
, "SAFI MPLS-labeled VPN");
137 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
140 vty_out (vty
, "%s", VTY_NEWLINE
);
143 else if (hdr
->code
>= 128)
146 json_object_int_add(json_cap
, "capabilityErrorVendorSpecificCapabilityCode", hdr
->code
);
148 vty_out (vty
, " Capability error: vendor specific capability code %d",
154 json_object_int_add(json_cap
, "capabilityErrorUnknownCapabilityCode", hdr
->code
);
156 vty_out (vty
, " Capability error: unknown capability code %d",
159 pnt
+= hdr
->length
+ 2;
162 json_object_object_add(json_neigh
, "capabilityErrors", json_cap
);
166 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
168 mpc
->afi
= stream_getw (s
);
169 mpc
->reserved
= stream_getc (s
);
170 mpc
->safi
= stream_getc (s
);
174 bgp_afi_safi_valid_indices (afi_t afi
, safi_t
*safi
)
184 /* BGP MPLS-labeled VPN SAFI isn't contigious with others, remap */
185 case SAFI_MPLS_LABELED_VPN
:
186 *safi
= SAFI_MPLS_VPN
;
193 zlog_debug ("unknown afi/safi (%u/%u)", afi
, *safi
);
198 /* Set negotiated capability value. */
200 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
202 struct capability_mp_data mpc
;
203 struct stream
*s
= BGP_INPUT (peer
);
205 /* Verify length is 4 */
206 if (hdr
->length
!= 4)
208 zlog_warn("MP Cap: Received invalid length %d, non-multiple of 4",
213 bgp_capability_mp_data (s
, &mpc
);
215 if (bgp_debug_neighbor_events(peer
))
216 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
217 peer
->host
, mpc
.afi
, mpc
.safi
);
219 if (!bgp_afi_safi_valid_indices (mpc
.afi
, &mpc
.safi
))
222 /* Now safi remapped, and afi/safi are valid array indices */
223 peer
->afc_recv
[mpc
.afi
][mpc
.safi
] = 1;
225 if (peer
->afc
[mpc
.afi
][mpc
.safi
])
226 peer
->afc_nego
[mpc
.afi
][mpc
.safi
] = 1;
234 bgp_capability_orf_not_support (struct peer
*peer
, afi_t afi
, safi_t safi
,
235 u_char type
, u_char mode
)
237 if (bgp_debug_neighbor_events(peer
))
238 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
239 peer
->host
, afi
, safi
, type
, mode
);
242 static const struct message orf_type_str
[] =
244 { ORF_TYPE_PREFIX
, "Prefixlist" },
245 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
247 static const int orf_type_str_max
= array_size(orf_type_str
);
249 static const struct message orf_mode_str
[] =
251 { ORF_MODE_RECEIVE
, "Receive" },
252 { ORF_MODE_SEND
, "Send" },
253 { ORF_MODE_BOTH
, "Both" },
255 static const int orf_mode_str_max
= array_size(orf_mode_str
);
258 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
260 struct stream
*s
= BGP_INPUT (peer
);
261 struct capability_orf_entry entry
;
266 u_int16_t sm_cap
= 0; /* capability send-mode receive */
267 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
270 /* ORF Entry header */
271 bgp_capability_mp_data (s
, &entry
.mpc
);
272 entry
.num
= stream_getc (s
);
274 safi
= entry
.mpc
.safi
;
276 if (bgp_debug_neighbor_events(peer
))
277 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
278 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
280 /* Check AFI and SAFI. */
281 if (!bgp_afi_safi_valid_indices (entry
.mpc
.afi
, &safi
))
283 zlog_info ("%s Addr-family %d/%d not supported."
284 " Ignoring the ORF capability",
285 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
289 /* validate number field */
290 if (sizeof (struct capability_orf_entry
) + (entry
.num
* 2) > hdr
->length
)
292 zlog_info ("%s ORF Capability entry length error,"
293 " Cap length %u, num %u",
294 peer
->host
, hdr
->length
, entry
.num
);
295 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
299 for (i
= 0 ; i
< entry
.num
; i
++)
301 type
= stream_getc(s
);
302 mode
= stream_getc(s
);
304 /* ORF Mode error check */
309 case ORF_MODE_RECEIVE
:
312 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
315 /* ORF Type and afi/safi error checks */
316 /* capcode versus type */
319 case CAPABILITY_CODE_ORF
:
322 case ORF_TYPE_PREFIX
:
325 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
329 case CAPABILITY_CODE_ORF_OLD
:
332 case ORF_TYPE_PREFIX_OLD
:
335 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
340 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
345 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
346 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
347 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
349 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
353 if (bgp_debug_neighbor_events(peer
))
354 zlog_debug ("%s OPEN has %s ORF capability"
355 " as %s for afi/safi: %d/%d",
356 peer
->host
, LOOKUP (orf_type_str
, type
),
357 LOOKUP (orf_mode_str
, mode
),
358 entry
.mpc
.afi
, safi
);
360 if (hdr
->code
== CAPABILITY_CODE_ORF
)
362 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
363 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
365 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
367 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
368 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
372 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
379 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
380 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
383 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
385 case ORF_MODE_RECEIVE
:
386 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
394 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
396 struct stream
*s
= BGP_INPUT (peer
);
397 u_int16_t restart_flag_time
;
399 size_t end
= stream_get_getp (s
) + caphdr
->length
;
401 /* Verify length is a multiple of 4 */
402 if ((caphdr
->length
-2) % 4)
404 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
409 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
410 restart_flag_time
= stream_getw(s
);
411 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
413 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
416 UNSET_FLAG (restart_flag_time
, 0xF000);
417 peer
->v_gr_restart
= restart_flag_time
;
419 if (bgp_debug_neighbor_events(peer
))
421 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
422 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
423 peer
->host
, restart_bit
? " " : " not ",
427 while (stream_get_getp (s
) + 4 <= end
)
429 afi_t afi
= stream_getw (s
);
430 safi_t safi
= stream_getc (s
);
431 u_char flag
= stream_getc (s
);
433 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
435 if (bgp_debug_neighbor_events(peer
))
436 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
437 " Ignore the Graceful Restart capability for this AFI/SAFI",
438 peer
->host
, afi
, safi
);
440 else if (!peer
->afc
[afi
][safi
])
442 if (bgp_debug_neighbor_events(peer
))
443 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
444 " Ignore the Graceful Restart capability",
445 peer
->host
, afi
, safi
);
449 if (bgp_debug_neighbor_events(peer
))
450 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
451 afi_safi_print (afi
, safi
),
452 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
453 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
456 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
457 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
458 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
465 /* Unlike other capability parsing routines, this one returns 0 on error */
467 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
469 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
471 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
473 zlog_err ("%s AS4 capability has incorrect data length %d",
474 peer
->host
, hdr
->length
);
478 as_t as4
= stream_getl (BGP_INPUT(peer
));
480 if (BGP_DEBUG (as4
, AS4
))
481 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
487 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
489 struct stream
*s
= BGP_INPUT (peer
);
490 size_t end
= stream_get_getp (s
) + hdr
->length
;
492 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
494 /* Verify length is a multiple of 4 */
497 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
502 while (stream_get_getp (s
) + 4 <= end
)
504 afi_t afi
= stream_getw (s
);
505 safi_t safi
= stream_getc (s
);
506 u_char send_receive
= stream_getc (s
);
508 if (bgp_debug_neighbor_events(peer
))
509 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
510 peer
->host
, afi
, safi
,
511 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
512 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
514 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
516 if (bgp_debug_neighbor_events(peer
))
517 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
518 " Ignore the Addpath Attribute for this AFI/SAFI",
519 peer
->host
, afi
, safi
);
522 else if (!peer
->afc
[afi
][safi
])
524 if (bgp_debug_neighbor_events(peer
))
525 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
526 " Ignore the AddPath capability for this AFI/SAFI",
527 peer
->host
, afi
, safi
);
531 if (send_receive
& BGP_ADDPATH_RX
)
532 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
534 if (send_receive
& BGP_ADDPATH_TX
)
535 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
542 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
544 struct stream
*s
= BGP_INPUT (peer
);
545 size_t end
= stream_get_getp (s
) + hdr
->length
;
547 /* Verify length is a multiple of 4 */
550 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
555 while (stream_get_getp (s
) + 6 <= end
)
557 afi_t afi
= stream_getw (s
);
558 safi_t safi
= stream_getw (s
);
559 afi_t nh_afi
= stream_getw (s
);
561 if (bgp_debug_neighbor_events(peer
))
562 zlog_debug ("%s Received with value triple (afi/safi/next-hop afi): %u/%u/%u",
563 peer
->host
, afi
, safi
, nh_afi
);
565 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
568 if (afi
!= AFI_IP
|| nh_afi
!= AFI_IP6
)
570 zlog_warn ("%s Extended Next-hop capability, wrong afi/next-hop afi: %u/%u",
571 peer
->host
, afi
, nh_afi
);
575 /* Until SAFIs other than SAFI_UNICAST are supported */
576 if (safi
!= SAFI_UNICAST
)
577 zlog_warn ("%s Extended Next-hop capability came with unsupported SAFI: %u",
580 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
582 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
583 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
586 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
592 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
594 struct stream
*s
= BGP_INPUT (peer
);
595 char str
[BGP_MAX_HOSTNAME
+1];
596 size_t end
= stream_get_getp (s
) + hdr
->length
;
599 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
601 len
= stream_getc(s
);
602 if (stream_get_getp(s
) + len
> end
)
604 zlog_warn("%s: Received malformed hostname capability from peer %s",
605 __FUNCTION__
, peer
->host
);
609 if (len
> BGP_MAX_HOSTNAME
)
611 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
612 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
613 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
616 stream_get(str
, s
, len
);
622 if (peer
->hostname
!= NULL
)
623 XFREE(MTYPE_HOST
, peer
->hostname
);
625 if (peer
->domainname
!= NULL
)
627 XFREE(MTYPE_HOST
, peer
->domainname
);
628 peer
->domainname
= NULL
;
631 peer
->hostname
= XSTRDUP(MTYPE_HOST
, str
);
634 if (stream_get_getp(s
) +1 > end
)
636 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
637 __FUNCTION__
, peer
->host
);
641 len
= stream_getc(s
);
642 if (stream_get_getp(s
) + len
> end
)
644 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
645 __FUNCTION__
, peer
->host
);
649 if (len
> BGP_MAX_HOSTNAME
)
651 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
652 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
653 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
656 stream_get(str
, s
, len
);
661 peer
->domainname
= XSTRDUP(MTYPE_HOST
, str
);
664 if (bgp_debug_neighbor_events(peer
))
666 zlog_debug("%s received hostname %s, domainname %s",
667 peer
->host
, peer
->hostname
, peer
->domainname
);
673 static const struct message capcode_str
[] =
675 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
676 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
677 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
678 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
679 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
680 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
681 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
682 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
683 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
684 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
685 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
686 { CAPABILITY_CODE_FQDN
, "FQDN" },
688 static const int capcode_str_max
= array_size(capcode_str
);
690 /* Minimum sizes for length field of each cap (so not inc. the header) */
691 static const size_t cap_minsizes
[] =
693 [CAPABILITY_CODE_MP
] = sizeof (struct capability_mp_data
),
694 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
695 [CAPABILITY_CODE_ORF
] = sizeof (struct capability_orf_entry
),
696 [CAPABILITY_CODE_RESTART
] = sizeof (struct capability_gr
),
697 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
698 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
699 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
700 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
701 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
702 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
703 [CAPABILITY_CODE_ORF_OLD
] = sizeof (struct capability_orf_entry
),
704 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
708 * Parse given capability.
709 * XXX: This is reading into a stream, but not using stream API
711 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
712 * capabilities were encountered.
715 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
719 struct stream
*s
= BGP_INPUT (peer
);
720 size_t end
= stream_get_getp (s
) + length
;
722 assert (STREAM_READABLE (s
) >= length
);
724 while (stream_get_getp (s
) < end
)
727 u_char
*sp
= stream_pnt (s
);
728 struct capability_header caphdr
;
731 /* We need at least capability code and capability length. */
732 if (stream_get_getp(s
) + 2 > end
)
734 zlog_info ("%s Capability length error (< header)", peer
->host
);
735 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
739 caphdr
.code
= stream_getc (s
);
740 caphdr
.length
= stream_getc (s
);
741 start
= stream_get_getp (s
);
743 /* Capability length check sanity check. */
744 if (start
+ caphdr
.length
> end
)
746 zlog_info ("%s Capability length error (< length)", peer
->host
);
747 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
751 if (bgp_debug_neighbor_events(peer
))
752 zlog_debug ("%s OPEN has %s capability (%u), length %u",
754 LOOKUP (capcode_str
, caphdr
.code
),
755 caphdr
.code
, caphdr
.length
);
757 /* Length sanity check, type-specific, for known capabilities */
760 case CAPABILITY_CODE_MP
:
761 case CAPABILITY_CODE_REFRESH
:
762 case CAPABILITY_CODE_REFRESH_OLD
:
763 case CAPABILITY_CODE_ORF
:
764 case CAPABILITY_CODE_ORF_OLD
:
765 case CAPABILITY_CODE_RESTART
:
766 case CAPABILITY_CODE_AS4
:
767 case CAPABILITY_CODE_ADDPATH
:
768 case CAPABILITY_CODE_DYNAMIC
:
769 case CAPABILITY_CODE_DYNAMIC_OLD
:
770 case CAPABILITY_CODE_ENHE
:
771 case CAPABILITY_CODE_FQDN
:
773 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
775 zlog_info ("%s %s Capability length error: got %u,"
776 " expected at least %u",
778 LOOKUP (capcode_str
, caphdr
.code
),
780 (unsigned) cap_minsizes
[caphdr
.code
]);
781 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
784 /* we deliberately ignore unknown codes, see below */
791 case CAPABILITY_CODE_MP
:
795 /* Ignore capability when override-capability is set. */
796 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
798 /* Set negotiated value. */
799 ret
= bgp_capability_mp (peer
, &caphdr
);
801 /* Unsupported Capability. */
804 /* Store return data. */
805 memcpy (*error
, sp
, caphdr
.length
+ 2);
806 *error
+= caphdr
.length
+ 2;
808 ret
= 0; /* Don't return error for this */
812 case CAPABILITY_CODE_REFRESH
:
813 case CAPABILITY_CODE_REFRESH_OLD
:
815 /* BGP refresh capability */
816 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
817 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
819 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
822 case CAPABILITY_CODE_ORF
:
823 case CAPABILITY_CODE_ORF_OLD
:
824 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
826 case CAPABILITY_CODE_RESTART
:
827 ret
= bgp_capability_restart (peer
, &caphdr
);
829 case CAPABILITY_CODE_DYNAMIC
:
830 case CAPABILITY_CODE_DYNAMIC_OLD
:
831 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
833 case CAPABILITY_CODE_AS4
:
834 /* Already handled as a special-case parsing of the capabilities
835 * at the beginning of OPEN processing. So we care not a jot
836 * for the value really, only error case.
838 if (!bgp_capability_as4 (peer
, &caphdr
))
841 case CAPABILITY_CODE_ADDPATH
:
842 ret
= bgp_capability_addpath (peer
, &caphdr
);
844 case CAPABILITY_CODE_ENHE
:
845 ret
= bgp_capability_enhe (peer
, &caphdr
);
847 case CAPABILITY_CODE_FQDN
:
848 ret
= bgp_capability_hostname (peer
, &caphdr
);
851 if (caphdr
.code
> 128)
853 /* We don't send Notification for unknown vendor specific
854 capabilities. It seems reasonable for now... */
855 zlog_warn ("%s Vendor specific capability %d",
856 peer
->host
, caphdr
.code
);
860 zlog_warn ("%s unrecognized capability code: %d - ignored",
861 peer
->host
, caphdr
.code
);
862 memcpy (*error
, sp
, caphdr
.length
+ 2);
863 *error
+= caphdr
.length
+ 2;
869 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
872 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
874 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
875 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
876 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
878 stream_set_getp (s
, start
+ caphdr
.length
);
885 bgp_auth_parse (struct peer
*peer
, size_t length
)
887 bgp_notify_send (peer
,
889 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
894 strict_capability_same (struct peer
*peer
)
898 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
899 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
900 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
905 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
906 * Returns 0 if no as4 found, as4cap value otherwise.
909 peek_for_as4_capability (struct peer
*peer
, u_char length
)
911 struct stream
*s
= BGP_INPUT (peer
);
912 size_t orig_getp
= stream_get_getp (s
);
913 size_t end
= orig_getp
+ length
;
916 /* The full capability parser will better flag the error.. */
917 if (STREAM_READABLE(s
) < length
)
920 if (BGP_DEBUG (as4
, AS4
))
921 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
924 /* the error cases we DONT handle, we ONLY try to read as4 out of
925 * correctly formatted options.
927 while (stream_get_getp(s
) < end
)
932 /* Check the length. */
933 if (stream_get_getp (s
) + 2 > end
)
936 /* Fetch option type and length. */
937 opt_type
= stream_getc (s
);
938 opt_length
= stream_getc (s
);
940 /* Option length check. */
941 if (stream_get_getp (s
) + opt_length
> end
)
944 if (opt_type
== BGP_OPEN_OPT_CAP
)
946 unsigned long capd_start
= stream_get_getp (s
);
947 unsigned long capd_end
= capd_start
+ opt_length
;
949 assert (capd_end
<= end
);
951 while (stream_get_getp (s
) < capd_end
)
953 struct capability_header hdr
;
955 if (stream_get_getp (s
) + 2 > capd_end
)
958 hdr
.code
= stream_getc (s
);
959 hdr
.length
= stream_getc (s
);
961 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
964 if (hdr
.code
== CAPABILITY_CODE_AS4
)
966 if (BGP_DEBUG (as4
, AS4
))
967 zlog_info ("[AS4] found AS4 capability, about to parse");
968 as4
= bgp_capability_as4 (peer
, &hdr
);
972 stream_forward_getp (s
, hdr
.length
);
978 stream_set_getp (s
, orig_getp
);
985 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
988 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
992 u_char error_data
[BGP_MAX_PACKET_SIZE
];
993 struct stream
*s
= BGP_INPUT(peer
);
994 size_t end
= stream_get_getp (s
) + length
;
999 if (bgp_debug_neighbor_events(peer
))
1000 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1001 peer
->host
, length
);
1003 while (stream_get_getp(s
) < end
)
1008 /* Must have at least an OPEN option header */
1009 if (STREAM_READABLE(s
) < 2)
1011 zlog_info ("%s Option length error", peer
->host
);
1012 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1016 /* Fetch option type and length. */
1017 opt_type
= stream_getc (s
);
1018 opt_length
= stream_getc (s
);
1020 /* Option length check. */
1021 if (STREAM_READABLE (s
) < opt_length
)
1023 zlog_info ("%s Option length error", peer
->host
);
1024 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1028 if (bgp_debug_neighbor_events(peer
))
1029 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1030 peer
->host
, opt_type
,
1031 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1032 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1037 case BGP_OPEN_OPT_AUTH
:
1038 ret
= bgp_auth_parse (peer
, opt_length
);
1040 case BGP_OPEN_OPT_CAP
:
1041 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1044 bgp_notify_send (peer
,
1045 BGP_NOTIFY_OPEN_ERR
,
1046 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1051 /* Parse error. To accumulate all unsupported capability codes,
1052 bgp_capability_parse does not return -1 when encounter
1053 unsupported capability code. To detect that, please check
1054 error and erro_data pointer, like below. */
1059 /* All OPEN option is parsed. Check capability when strict compare
1061 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1063 /* If Unsupported Capability exists. */
1064 if (error
!= error_data
)
1066 bgp_notify_send_with_data (peer
,
1067 BGP_NOTIFY_OPEN_ERR
,
1068 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1069 error_data
, error
- error_data
);
1073 /* Check local capability does not negotiated with remote
1075 if (! strict_capability_same (peer
))
1077 bgp_notify_send (peer
,
1078 BGP_NOTIFY_OPEN_ERR
,
1079 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1084 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1086 if (*mp_capability
&&
1087 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1089 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1090 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1091 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1092 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1093 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
])
1095 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1096 "overlap with received MP capabilities",
1099 if (error
!= error_data
)
1100 bgp_notify_send_with_data (peer
,
1101 BGP_NOTIFY_OPEN_ERR
,
1102 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1103 error_data
, error
- error_data
);
1105 bgp_notify_send (peer
,
1106 BGP_NOTIFY_OPEN_ERR
,
1107 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1115 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1116 afi_t afi
, safi_t safi
, u_char code
)
1122 unsigned long numberp
;
1123 int number_of_orfs
= 0;
1125 if (safi
== SAFI_MPLS_VPN
)
1126 safi
= SAFI_MPLS_LABELED_VPN
;
1128 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1129 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1130 stream_putc (s
, 0); /* Capability Length */
1131 stream_putc (s
, code
); /* Capability Code */
1132 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1133 stream_putc (s
, 0); /* ORF Length */
1134 stream_putw (s
, afi
);
1136 stream_putc (s
, safi
);
1137 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1138 stream_putc (s
, 0); /* Number of ORFs */
1140 /* Address Prefix ORF */
1141 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1142 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1144 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1145 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1147 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1148 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1150 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1151 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1152 stream_putc (s
, ORF_MODE_BOTH
);
1154 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1156 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1157 stream_putc (s
, ORF_MODE_SEND
);
1161 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1162 stream_putc (s
, ORF_MODE_RECEIVE
);
1167 /* Total Number of ORFs. */
1168 stream_putc_at (s
, numberp
, number_of_orfs
);
1170 /* Total ORF Len. */
1171 orf_len
= stream_get_endp (s
) - orfp
- 1;
1172 stream_putc_at (s
, orfp
, orf_len
);
1174 /* Total Capability Len. */
1175 cap_len
= stream_get_endp (s
) - capp
- 1;
1176 stream_putc_at (s
, capp
, cap_len
);
1179 /* Fill in capability open option to the packet. */
1181 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1184 unsigned long cp
, capp
, rcapp
;
1188 u_int32_t restart_time
;
1189 u_char afi_safi_count
= 0;
1190 struct utsname names
;
1191 int adv_addpath_tx
= 0;
1193 /* Remember current pointer for Opt Parm Len. */
1194 cp
= stream_get_endp (s
);
1199 /* Do not send capability. */
1200 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1201 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1205 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
])
1207 peer
->afc_adv
[AFI_IP
][SAFI_UNICAST
] = 1;
1208 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1209 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1210 stream_putc (s
, CAPABILITY_CODE_MP
);
1211 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1212 stream_putw (s
, AFI_IP
);
1214 stream_putc (s
, SAFI_UNICAST
);
1216 /* IPv4 multicast. */
1217 if (peer
->afc
[AFI_IP
][SAFI_MULTICAST
])
1219 peer
->afc_adv
[AFI_IP
][SAFI_MULTICAST
] = 1;
1220 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1221 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1222 stream_putc (s
, CAPABILITY_CODE_MP
);
1223 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1224 stream_putw (s
, AFI_IP
);
1226 stream_putc (s
, SAFI_MULTICAST
);
1229 if (peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
])
1231 peer
->afc_adv
[AFI_IP
][SAFI_MPLS_VPN
] = 1;
1232 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1233 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1234 stream_putc (s
, CAPABILITY_CODE_MP
);
1235 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1236 stream_putw (s
, AFI_IP
);
1238 stream_putc (s
, SAFI_MPLS_LABELED_VPN
);
1241 /* Currently supporting RFC-5549 for Link-Local peering only */
1242 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1243 peer
->su
.sa
.sa_family
== AF_INET6
&&
1244 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
))
1246 /* RFC 5549 Extended Next Hop Encoding */
1247 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1248 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1249 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1250 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1251 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1252 /* Currently supporting for SAFI_UNICAST only */
1253 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_ADV
);
1254 stream_putw (s
, AFI_IP
);
1255 stream_putw (s
, SAFI_UNICAST
);
1256 stream_putw (s
, AFI_IP6
);
1258 if (CHECK_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_RCV
))
1259 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_NEGO
);
1262 if (peer
->afc
[AFI_IP6
][SAFI_UNICAST
])
1264 peer
->afc_adv
[AFI_IP6
][SAFI_UNICAST
] = 1;
1265 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1266 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1267 stream_putc (s
, CAPABILITY_CODE_MP
);
1268 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1269 stream_putw (s
, AFI_IP6
);
1271 stream_putc (s
, SAFI_UNICAST
);
1273 /* IPv6 multicast. */
1274 if (peer
->afc
[AFI_IP6
][SAFI_MULTICAST
])
1276 peer
->afc_adv
[AFI_IP6
][SAFI_MULTICAST
] = 1;
1277 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1278 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1279 stream_putc (s
, CAPABILITY_CODE_MP
);
1280 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1281 stream_putw (s
, AFI_IP6
);
1283 stream_putc (s
, SAFI_MULTICAST
);
1285 #endif /* HAVE_IPV6 */
1287 /* Route refresh. */
1288 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1289 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1290 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1291 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1292 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1293 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1294 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1295 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1296 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1299 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1300 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1301 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1302 stream_putc (s
, CAPABILITY_CODE_AS4
);
1303 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1304 if ( peer
->change_local_as
)
1305 local_as
= peer
->change_local_as
;
1307 local_as
= peer
->local_as
;
1308 stream_putl (s
, local_as
);
1311 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1312 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1313 if (peer
->afc
[afi
][safi
])
1317 /* Only advertise addpath TX if a feature that will use it is
1319 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
1323 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1324 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1325 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1326 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1327 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1329 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1330 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1331 if (peer
->afc
[afi
][safi
])
1333 stream_putw (s
, afi
);
1334 stream_putc (s
, safi
);
1338 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1339 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1340 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1344 stream_putc (s
, BGP_ADDPATH_RX
);
1345 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1346 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1350 /* ORF capability. */
1351 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1352 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1353 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1354 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1356 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1357 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1360 /* Dynamic capability. */
1361 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1363 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1364 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1365 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1366 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1367 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1368 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1369 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1370 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1371 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1374 /* Hostname capability */
1376 if (names
.nodename
[0] != '\0')
1378 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1379 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1380 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1381 stream_putc(s
, 0); /* dummy len for now */
1382 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1383 capp
= stream_get_endp(s
);
1384 stream_putc(s
, 0); /* dummy len for now */
1385 len
= strlen(names
.nodename
);
1386 if (len
> BGP_MAX_HOSTNAME
)
1387 len
= BGP_MAX_HOSTNAME
;
1389 stream_putc(s
, len
);
1390 stream_put(s
, names
.nodename
, len
);
1392 if ((names
.domainname
[0] != '\0') &&
1393 (strcmp(names
.domainname
, "(none)") != 0))
1395 len
= strlen(names
.domainname
);
1396 if (len
> BGP_MAX_HOSTNAME
)
1397 len
= BGP_MAX_HOSTNAME
;
1399 stream_putc(s
, len
);
1400 stream_put(s
, names
.domainname
, len
);
1405 stream_putc(s
, 0); /* 0 length */
1408 /* Set the lengths straight */
1409 len
= stream_get_endp(s
) - rcapp
- 1;
1410 stream_putc_at(s
, rcapp
, len
);
1411 len
= stream_get_endp(s
) - capp
- 1;
1412 stream_putc_at(s
, capp
, len
);
1414 if (bgp_debug_neighbor_events(peer
))
1415 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1416 peer
->host
, names
.nodename
, names
.domainname
);
1419 /* Sending base graceful-restart capability irrespective of the config */
1420 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1421 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1422 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1423 stream_putc (s
, 0); /* Capability Length */
1424 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1425 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1427 restart_time
= peer
->bgp
->restart_time
;
1428 if (peer
->bgp
->t_startup
)
1430 SET_FLAG (restart_time
, RESTART_R_BIT
);
1431 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1433 stream_putw (s
, restart_time
);
1435 /* Send address-family specific graceful-restart capability only when GR config
1437 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1439 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1440 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1441 if (peer
->afc
[afi
][safi
])
1443 stream_putw (s
, afi
);
1444 stream_putc (s
, safi
);
1445 stream_putc (s
, 0); //Forwarding is not retained as of now.
1449 /* Total Graceful restart capability Len. */
1450 len
= stream_get_endp (s
) - rcapp
- 1;
1451 stream_putc_at (s
, rcapp
, len
);
1453 /* Total Capability Len. */
1454 len
= stream_get_endp (s
) - capp
- 1;
1455 stream_putc_at (s
, capp
, len
);
1457 /* Total Opt Parm Len. */
1458 len
= stream_get_endp (s
) - cp
- 1;
1459 stream_putc_at (s
, cp
, len
);