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
)
182 /* BGP MPLS-labeled VPN SAFI isn't contigious with others, remap */
183 case SAFI_MPLS_LABELED_VPN
:
184 *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 (CAPABILITY_CODE_ORF_LEN
+ (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_OPEN_ERR
, 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
;
398 size_t end
= stream_get_getp (s
) + caphdr
->length
;
400 /* Verify length is a multiple of 4 */
401 if ((caphdr
->length
-2) % 4)
403 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
408 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
409 restart_flag_time
= stream_getw(s
);
410 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
411 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
413 UNSET_FLAG (restart_flag_time
, 0xF000);
414 peer
->v_gr_restart
= restart_flag_time
;
416 if (bgp_debug_neighbor_events(peer
))
418 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
419 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
421 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
426 while (stream_get_getp (s
) + 4 <= end
)
428 afi_t afi
= stream_getw (s
);
429 safi_t safi
= stream_getc (s
);
430 u_char flag
= stream_getc (s
);
432 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
434 if (bgp_debug_neighbor_events(peer
))
435 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
436 " Ignore the Graceful Restart capability for this AFI/SAFI",
437 peer
->host
, afi
, safi
);
439 else if (!peer
->afc
[afi
][safi
])
441 if (bgp_debug_neighbor_events(peer
))
442 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
443 " Ignore the Graceful Restart capability",
444 peer
->host
, afi
, safi
);
448 if (bgp_debug_neighbor_events(peer
))
449 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
450 afi_safi_print (afi
, safi
),
451 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
452 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
455 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
456 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
457 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
464 /* Unlike other capability parsing routines, this one returns 0 on error */
466 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
468 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
470 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
472 zlog_err ("%s AS4 capability has incorrect data length %d",
473 peer
->host
, hdr
->length
);
477 as_t as4
= stream_getl (BGP_INPUT(peer
));
479 if (BGP_DEBUG (as4
, AS4
))
480 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
486 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
488 struct stream
*s
= BGP_INPUT (peer
);
489 size_t end
= stream_get_getp (s
) + hdr
->length
;
491 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
493 /* Verify length is a multiple of 4 */
496 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
501 while (stream_get_getp (s
) + 4 <= end
)
503 afi_t afi
= stream_getw (s
);
504 safi_t safi
= stream_getc (s
);
505 u_char send_receive
= stream_getc (s
);
507 if (bgp_debug_neighbor_events(peer
))
508 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
509 peer
->host
, afi
, safi
,
510 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
511 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
513 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
515 if (bgp_debug_neighbor_events(peer
))
516 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
517 " Ignore the Addpath Attribute for this AFI/SAFI",
518 peer
->host
, afi
, safi
);
521 else if (!peer
->afc
[afi
][safi
])
523 if (bgp_debug_neighbor_events(peer
))
524 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
525 " Ignore the AddPath capability for this AFI/SAFI",
526 peer
->host
, afi
, safi
);
530 if (send_receive
& BGP_ADDPATH_RX
)
531 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
533 if (send_receive
& BGP_ADDPATH_TX
)
534 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
541 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
543 struct stream
*s
= BGP_INPUT (peer
);
544 size_t end
= stream_get_getp (s
) + hdr
->length
;
546 /* Verify length is a multiple of 4 */
549 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
554 while (stream_get_getp (s
) + 6 <= end
)
556 afi_t afi
= stream_getw (s
);
557 safi_t safi
= stream_getw (s
);
558 afi_t nh_afi
= stream_getw (s
);
560 if (bgp_debug_neighbor_events(peer
))
561 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
562 peer
->host
, afi
, safi
, nh_afi
);
564 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
566 if (bgp_debug_neighbor_events(peer
))
567 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
568 " Ignore the ENHE Attribute for this AFI/SAFI",
569 peer
->host
, afi
, safi
);
573 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
574 * the Nexthop AFI being IPv6. A future spec may introduce other
575 * possibilities, so we ignore other values with a log. Also, only
576 * Unicast SAFI is currently supported (and expected).
578 if (afi
!= AFI_IP
|| safi
!= SAFI_UNICAST
|| nh_afi
!= AFI_IP6
)
580 zlog_warn ("%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
581 "in Extended Next-hop capability, ignoring",
582 peer
->host
, afi
, safi
, nh_afi
);
586 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
588 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
589 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
592 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
598 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
600 struct stream
*s
= BGP_INPUT (peer
);
601 char str
[BGP_MAX_HOSTNAME
+1];
602 size_t end
= stream_get_getp (s
) + hdr
->length
;
605 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
607 len
= stream_getc(s
);
608 if (stream_get_getp(s
) + len
> end
)
610 zlog_warn("%s: Received malformed hostname capability from peer %s",
611 __FUNCTION__
, peer
->host
);
615 if (len
> BGP_MAX_HOSTNAME
)
617 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
618 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
619 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
622 stream_get(str
, s
, len
);
628 if (peer
->hostname
!= NULL
)
630 XFREE(MTYPE_HOST
, peer
->hostname
);
631 peer
->hostname
= NULL
;
634 if (peer
->domainname
!= NULL
)
636 XFREE(MTYPE_HOST
, peer
->domainname
);
637 peer
->domainname
= NULL
;
640 peer
->hostname
= XSTRDUP(MTYPE_HOST
, str
);
643 if (stream_get_getp(s
) +1 > end
)
645 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
646 __FUNCTION__
, peer
->host
);
650 len
= stream_getc(s
);
651 if (stream_get_getp(s
) + len
> end
)
653 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
654 __FUNCTION__
, peer
->host
);
658 if (len
> BGP_MAX_HOSTNAME
)
660 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
661 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
662 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
665 stream_get(str
, s
, len
);
670 peer
->domainname
= XSTRDUP(MTYPE_HOST
, str
);
673 if (bgp_debug_neighbor_events(peer
))
675 zlog_debug("%s received hostname %s, domainname %s",
676 peer
->host
, peer
->hostname
, peer
->domainname
);
682 static const struct message capcode_str
[] =
684 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
685 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
686 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
687 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
688 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
689 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
690 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
691 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
692 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
693 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
694 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
695 { CAPABILITY_CODE_FQDN
, "FQDN" },
697 static const int capcode_str_max
= array_size(capcode_str
);
699 /* Minimum sizes for length field of each cap (so not inc. the header) */
700 static const size_t cap_minsizes
[] =
702 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
703 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
704 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
705 [CAPABILITY_CODE_RESTART
] = 6,
706 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
707 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
708 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
709 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
710 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
711 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
712 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
713 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
716 /* value the capability must be a multiple of.
717 * 0-data capabilities won't be checked against this.
718 * Other capabilities whose data doesn't fall on convenient boundaries for this
719 * table should be set to 1.
721 static const size_t cap_modsizes
[] =
723 [CAPABILITY_CODE_MP
] = 4,
724 [CAPABILITY_CODE_REFRESH
] = 1,
725 [CAPABILITY_CODE_ORF
] = 1,
726 [CAPABILITY_CODE_RESTART
] = 1,
727 [CAPABILITY_CODE_AS4
] = 4,
728 [CAPABILITY_CODE_DYNAMIC
] = 1,
729 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
730 [CAPABILITY_CODE_ORF_OLD
] = 1,
734 * Parse given capability.
735 * XXX: This is reading into a stream, but not using stream API
737 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
738 * capabilities were encountered.
741 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
745 struct stream
*s
= BGP_INPUT (peer
);
746 size_t end
= stream_get_getp (s
) + length
;
748 assert (STREAM_READABLE (s
) >= length
);
750 while (stream_get_getp (s
) < end
)
753 u_char
*sp
= stream_pnt (s
);
754 struct capability_header caphdr
;
757 /* We need at least capability code and capability length. */
758 if (stream_get_getp(s
) + 2 > end
)
760 zlog_info ("%s Capability length error (< header)", peer
->host
);
761 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
765 caphdr
.code
= stream_getc (s
);
766 caphdr
.length
= stream_getc (s
);
767 start
= stream_get_getp (s
);
769 /* Capability length check sanity check. */
770 if (start
+ caphdr
.length
> end
)
772 zlog_info ("%s Capability length error (< length)", peer
->host
);
773 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
777 if (bgp_debug_neighbor_events(peer
))
778 zlog_debug ("%s OPEN has %s capability (%u), length %u",
780 LOOKUP (capcode_str
, caphdr
.code
),
781 caphdr
.code
, caphdr
.length
);
783 /* Length sanity check, type-specific, for known capabilities */
786 case CAPABILITY_CODE_MP
:
787 case CAPABILITY_CODE_REFRESH
:
788 case CAPABILITY_CODE_REFRESH_OLD
:
789 case CAPABILITY_CODE_ORF
:
790 case CAPABILITY_CODE_ORF_OLD
:
791 case CAPABILITY_CODE_RESTART
:
792 case CAPABILITY_CODE_AS4
:
793 case CAPABILITY_CODE_ADDPATH
:
794 case CAPABILITY_CODE_DYNAMIC
:
795 case CAPABILITY_CODE_DYNAMIC_OLD
:
796 case CAPABILITY_CODE_ENHE
:
797 case CAPABILITY_CODE_FQDN
:
799 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
801 zlog_info ("%s %s Capability length error: got %u,"
802 " expected at least %u",
804 LOOKUP (capcode_str
, caphdr
.code
),
806 (unsigned) cap_minsizes
[caphdr
.code
]);
807 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
811 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
813 zlog_info ("%s %s Capability length error: got %u,"
814 " expected a multiple of %u",
816 LOOKUP (capcode_str
, caphdr
.code
),
818 (unsigned) cap_modsizes
[caphdr
.code
]);
819 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
820 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
823 /* we deliberately ignore unknown codes, see below */
830 case CAPABILITY_CODE_MP
:
834 /* Ignore capability when override-capability is set. */
835 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
837 /* Set negotiated value. */
838 ret
= bgp_capability_mp (peer
, &caphdr
);
840 /* Unsupported Capability. */
843 /* Store return data. */
844 memcpy (*error
, sp
, caphdr
.length
+ 2);
845 *error
+= caphdr
.length
+ 2;
847 ret
= 0; /* Don't return error for this */
851 case CAPABILITY_CODE_REFRESH
:
852 case CAPABILITY_CODE_REFRESH_OLD
:
854 /* BGP refresh capability */
855 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
856 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
858 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
861 case CAPABILITY_CODE_ORF
:
862 case CAPABILITY_CODE_ORF_OLD
:
863 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
865 case CAPABILITY_CODE_RESTART
:
866 ret
= bgp_capability_restart (peer
, &caphdr
);
868 case CAPABILITY_CODE_DYNAMIC
:
869 case CAPABILITY_CODE_DYNAMIC_OLD
:
870 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
872 case CAPABILITY_CODE_AS4
:
873 /* Already handled as a special-case parsing of the capabilities
874 * at the beginning of OPEN processing. So we care not a jot
875 * for the value really, only error case.
877 if (!bgp_capability_as4 (peer
, &caphdr
))
880 case CAPABILITY_CODE_ADDPATH
:
881 ret
= bgp_capability_addpath (peer
, &caphdr
);
883 case CAPABILITY_CODE_ENHE
:
884 ret
= bgp_capability_enhe (peer
, &caphdr
);
886 case CAPABILITY_CODE_FQDN
:
887 ret
= bgp_capability_hostname (peer
, &caphdr
);
890 if (caphdr
.code
> 128)
892 /* We don't send Notification for unknown vendor specific
893 capabilities. It seems reasonable for now... */
894 zlog_warn ("%s Vendor specific capability %d",
895 peer
->host
, caphdr
.code
);
899 zlog_warn ("%s unrecognized capability code: %d - ignored",
900 peer
->host
, caphdr
.code
);
901 memcpy (*error
, sp
, caphdr
.length
+ 2);
902 *error
+= caphdr
.length
+ 2;
908 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
911 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
913 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
914 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
915 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
917 stream_set_getp (s
, start
+ caphdr
.length
);
924 bgp_auth_parse (struct peer
*peer
, size_t length
)
926 bgp_notify_send (peer
,
928 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
933 strict_capability_same (struct peer
*peer
)
937 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
938 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
939 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
944 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
945 * Returns 0 if no as4 found, as4cap value otherwise.
948 peek_for_as4_capability (struct peer
*peer
, u_char length
)
950 struct stream
*s
= BGP_INPUT (peer
);
951 size_t orig_getp
= stream_get_getp (s
);
952 size_t end
= orig_getp
+ length
;
955 if (BGP_DEBUG (as4
, AS4
))
956 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
959 /* the error cases we DONT handle, we ONLY try to read as4 out of
960 * correctly formatted options.
962 while (stream_get_getp(s
) < end
)
967 /* Check the length. */
968 if (stream_get_getp (s
) + 2 > end
)
971 /* Fetch option type and length. */
972 opt_type
= stream_getc (s
);
973 opt_length
= stream_getc (s
);
975 /* Option length check. */
976 if (stream_get_getp (s
) + opt_length
> end
)
979 if (opt_type
== BGP_OPEN_OPT_CAP
)
981 unsigned long capd_start
= stream_get_getp (s
);
982 unsigned long capd_end
= capd_start
+ opt_length
;
984 assert (capd_end
<= end
);
986 while (stream_get_getp (s
) < capd_end
)
988 struct capability_header hdr
;
990 if (stream_get_getp (s
) + 2 > capd_end
)
993 hdr
.code
= stream_getc (s
);
994 hdr
.length
= stream_getc (s
);
996 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
999 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1001 if (BGP_DEBUG (as4
, AS4
))
1002 zlog_info ("[AS4] found AS4 capability, about to parse");
1003 as4
= bgp_capability_as4 (peer
, &hdr
);
1007 stream_forward_getp (s
, hdr
.length
);
1013 stream_set_getp (s
, orig_getp
);
1018 * Parse open option.
1020 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1023 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1027 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1028 struct stream
*s
= BGP_INPUT(peer
);
1029 size_t end
= stream_get_getp (s
) + length
;
1033 if (bgp_debug_neighbor_events(peer
))
1034 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1035 peer
->host
, length
);
1037 while (stream_get_getp(s
) < end
)
1042 /* Must have at least an OPEN option header */
1043 if (STREAM_READABLE(s
) < 2)
1045 zlog_info ("%s Option length error", peer
->host
);
1046 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1050 /* Fetch option type and length. */
1051 opt_type
= stream_getc (s
);
1052 opt_length
= stream_getc (s
);
1054 /* Option length check. */
1055 if (STREAM_READABLE (s
) < opt_length
)
1057 zlog_info ("%s Option length error", peer
->host
);
1058 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1062 if (bgp_debug_neighbor_events(peer
))
1063 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1064 peer
->host
, opt_type
,
1065 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1066 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1071 case BGP_OPEN_OPT_AUTH
:
1072 ret
= bgp_auth_parse (peer
, opt_length
);
1074 case BGP_OPEN_OPT_CAP
:
1075 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1078 bgp_notify_send (peer
,
1079 BGP_NOTIFY_OPEN_ERR
,
1080 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1085 /* Parse error. To accumulate all unsupported capability codes,
1086 bgp_capability_parse does not return -1 when encounter
1087 unsupported capability code. To detect that, please check
1088 error and erro_data pointer, like below. */
1093 /* All OPEN option is parsed. Check capability when strict compare
1095 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1097 /* If Unsupported Capability exists. */
1098 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
);
1107 /* Check local capability does not negotiated with remote
1109 if (! strict_capability_same (peer
))
1111 bgp_notify_send (peer
,
1112 BGP_NOTIFY_OPEN_ERR
,
1113 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1118 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1120 if (*mp_capability
&&
1121 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1123 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1124 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1125 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1126 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1127 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
])
1129 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1130 "overlap with received MP capabilities",
1133 if (error
!= error_data
)
1134 bgp_notify_send_with_data (peer
,
1135 BGP_NOTIFY_OPEN_ERR
,
1136 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1137 error_data
, error
- error_data
);
1139 bgp_notify_send (peer
,
1140 BGP_NOTIFY_OPEN_ERR
,
1141 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1149 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1150 afi_t afi
, safi_t safi
, u_char code
)
1156 unsigned long numberp
;
1157 int number_of_orfs
= 0;
1159 if (safi
== SAFI_MPLS_VPN
)
1160 safi
= SAFI_MPLS_LABELED_VPN
;
1162 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1163 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1164 stream_putc (s
, 0); /* Capability Length */
1165 stream_putc (s
, code
); /* Capability Code */
1166 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1167 stream_putc (s
, 0); /* ORF Length */
1168 stream_putw (s
, afi
);
1170 stream_putc (s
, safi
);
1171 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1172 stream_putc (s
, 0); /* Number of ORFs */
1174 /* Address Prefix ORF */
1175 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1176 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1178 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1179 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1181 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1182 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1184 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1185 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1186 stream_putc (s
, ORF_MODE_BOTH
);
1188 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1190 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1191 stream_putc (s
, ORF_MODE_SEND
);
1195 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1196 stream_putc (s
, ORF_MODE_RECEIVE
);
1201 /* Total Number of ORFs. */
1202 stream_putc_at (s
, numberp
, number_of_orfs
);
1204 /* Total ORF Len. */
1205 orf_len
= stream_get_endp (s
) - orfp
- 1;
1206 stream_putc_at (s
, orfp
, orf_len
);
1208 /* Total Capability Len. */
1209 cap_len
= stream_get_endp (s
) - capp
- 1;
1210 stream_putc_at (s
, capp
, cap_len
);
1213 /* Fill in capability open option to the packet. */
1215 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1218 unsigned long cp
, capp
, rcapp
;
1222 u_int32_t restart_time
;
1223 u_char afi_safi_count
= 0;
1224 struct utsname names
;
1225 int adv_addpath_tx
= 0;
1227 /* Remember current pointer for Opt Parm Len. */
1228 cp
= stream_get_endp (s
);
1233 /* Do not send capability. */
1234 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1235 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1239 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
])
1241 peer
->afc_adv
[AFI_IP
][SAFI_UNICAST
] = 1;
1242 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1243 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1244 stream_putc (s
, CAPABILITY_CODE_MP
);
1245 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1246 stream_putw (s
, AFI_IP
);
1248 stream_putc (s
, SAFI_UNICAST
);
1250 /* IPv4 multicast. */
1251 if (peer
->afc
[AFI_IP
][SAFI_MULTICAST
])
1253 peer
->afc_adv
[AFI_IP
][SAFI_MULTICAST
] = 1;
1254 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1255 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1256 stream_putc (s
, CAPABILITY_CODE_MP
);
1257 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1258 stream_putw (s
, AFI_IP
);
1260 stream_putc (s
, SAFI_MULTICAST
);
1263 if (peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
])
1265 peer
->afc_adv
[AFI_IP
][SAFI_MPLS_VPN
] = 1;
1266 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1267 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1268 stream_putc (s
, CAPABILITY_CODE_MP
);
1269 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1270 stream_putw (s
, AFI_IP
);
1272 stream_putc (s
, SAFI_MPLS_LABELED_VPN
);
1275 /* Currently supporting RFC-5549 for Link-Local peering only */
1276 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1277 peer
->su
.sa
.sa_family
== AF_INET6
&&
1278 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
))
1280 /* RFC 5549 Extended Next Hop Encoding */
1281 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1282 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1283 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1284 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1285 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1286 /* Currently supporting for SAFI_UNICAST only */
1287 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_ADV
);
1288 stream_putw (s
, AFI_IP
);
1289 stream_putw (s
, SAFI_UNICAST
);
1290 stream_putw (s
, AFI_IP6
);
1292 if (CHECK_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_RCV
))
1293 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_NEGO
);
1296 if (peer
->afc
[AFI_IP6
][SAFI_UNICAST
])
1298 peer
->afc_adv
[AFI_IP6
][SAFI_UNICAST
] = 1;
1299 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1300 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1301 stream_putc (s
, CAPABILITY_CODE_MP
);
1302 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1303 stream_putw (s
, AFI_IP6
);
1305 stream_putc (s
, SAFI_UNICAST
);
1307 /* IPv6 multicast. */
1308 if (peer
->afc
[AFI_IP6
][SAFI_MULTICAST
])
1310 peer
->afc_adv
[AFI_IP6
][SAFI_MULTICAST
] = 1;
1311 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1312 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1313 stream_putc (s
, CAPABILITY_CODE_MP
);
1314 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1315 stream_putw (s
, AFI_IP6
);
1317 stream_putc (s
, SAFI_MULTICAST
);
1319 #endif /* HAVE_IPV6 */
1321 /* Route refresh. */
1322 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1323 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1324 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1325 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1326 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1327 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1328 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1329 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1330 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1333 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1334 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1335 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1336 stream_putc (s
, CAPABILITY_CODE_AS4
);
1337 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1338 if ( peer
->change_local_as
)
1339 local_as
= peer
->change_local_as
;
1341 local_as
= peer
->local_as
;
1342 stream_putl (s
, local_as
);
1345 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1346 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1347 if (peer
->afc
[afi
][safi
])
1351 /* Only advertise addpath TX if a feature that will use it is
1353 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1354 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1358 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1359 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1360 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1361 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1362 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1364 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1365 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1366 if (peer
->afc
[afi
][safi
])
1368 stream_putw (s
, afi
);
1369 stream_putc (s
, safi
);
1373 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1374 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1375 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1379 stream_putc (s
, BGP_ADDPATH_RX
);
1380 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1381 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1385 /* ORF capability. */
1386 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1387 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1388 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1389 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1391 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1392 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1395 /* Dynamic capability. */
1396 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1398 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1399 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1400 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1401 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1402 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1403 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1404 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1405 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1406 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1409 /* Hostname capability */
1411 if (names
.nodename
[0] != '\0')
1413 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1414 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1415 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1416 stream_putc(s
, 0); /* dummy len for now */
1417 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1418 capp
= stream_get_endp(s
);
1419 stream_putc(s
, 0); /* dummy len for now */
1420 len
= strlen(names
.nodename
);
1421 if (len
> BGP_MAX_HOSTNAME
)
1422 len
= BGP_MAX_HOSTNAME
;
1424 stream_putc(s
, len
);
1425 stream_put(s
, names
.nodename
, len
);
1427 if ((names
.domainname
[0] != '\0') &&
1428 (strcmp(names
.domainname
, "(none)") != 0))
1430 len
= strlen(names
.domainname
);
1431 if (len
> BGP_MAX_HOSTNAME
)
1432 len
= BGP_MAX_HOSTNAME
;
1434 stream_putc(s
, len
);
1435 stream_put(s
, names
.domainname
, len
);
1440 stream_putc(s
, 0); /* 0 length */
1443 /* Set the lengths straight */
1444 len
= stream_get_endp(s
) - rcapp
- 1;
1445 stream_putc_at(s
, rcapp
, len
);
1446 len
= stream_get_endp(s
) - capp
- 1;
1447 stream_putc_at(s
, capp
, len
);
1449 if (bgp_debug_neighbor_events(peer
))
1450 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1451 peer
->host
, names
.nodename
, names
.domainname
);
1454 /* Sending base graceful-restart capability irrespective of the config */
1455 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1456 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1457 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1458 stream_putc (s
, 0); /* Capability Length */
1459 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1460 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1462 restart_time
= peer
->bgp
->restart_time
;
1463 if (peer
->bgp
->t_startup
)
1465 SET_FLAG (restart_time
, RESTART_R_BIT
);
1466 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1468 stream_putw (s
, restart_time
);
1470 /* Send address-family specific graceful-restart capability only when GR config
1472 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1474 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1475 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1476 if (peer
->afc
[afi
][safi
])
1478 stream_putw (s
, afi
);
1479 stream_putc (s
, safi
);
1480 stream_putc (s
, 0); //Forwarding is not retained as of now.
1484 /* Total Graceful restart capability Len. */
1485 len
= stream_get_endp (s
) - rcapp
- 1;
1486 stream_putc_at (s
, rcapp
, len
);
1488 /* Total Capability Len. */
1489 len
= stream_get_endp (s
) - capp
- 1;
1490 stream_putc_at (s
, capp
, len
);
1492 /* Total Opt Parm Len. */
1493 len
= stream_get_endp (s
) - cp
- 1;
1494 stream_putc_at (s
, cp
, len
);