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
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
)
84 switch (ntohs (mpc
.afi
))
87 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv4");
90 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv6");
93 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolAfiUnknown", ntohs (mpc
.afi
));
99 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "unicast");
102 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "multicast");
104 case SAFI_MPLS_LABELED_VPN
:
105 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "MPLS-labeled VPN");
108 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "encap");
111 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolSafiUnknown", mpc
.safi
);
117 vty_out (vty
, " Capability error for: Multi protocol ");
118 switch (ntohs (mpc
.afi
))
121 vty_out (vty
, "AFI IPv4, ");
124 vty_out (vty
, "AFI IPv6, ");
127 vty_out (vty
, "AFI Unknown %d, ", ntohs (mpc
.afi
));
133 vty_out (vty
, "SAFI Unicast");
136 vty_out (vty
, "SAFI Multicast");
138 case SAFI_MPLS_LABELED_VPN
:
139 vty_out (vty
, "SAFI MPLS-labeled VPN");
142 vty_out (vty
, "SAFI ENCAP");
145 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
148 vty_out (vty
, "%s", VTY_NEWLINE
);
151 else if (hdr
->code
>= 128)
154 json_object_int_add(json_cap
, "capabilityErrorVendorSpecificCapabilityCode", hdr
->code
);
156 vty_out (vty
, " Capability error: vendor specific capability code %d",
162 json_object_int_add(json_cap
, "capabilityErrorUnknownCapabilityCode", hdr
->code
);
164 vty_out (vty
, " Capability error: unknown capability code %d",
167 pnt
+= hdr
->length
+ 2;
170 json_object_object_add(json_neigh
, "capabilityErrors", json_cap
);
174 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
176 mpc
->afi
= stream_getw (s
);
177 mpc
->reserved
= stream_getc (s
);
178 mpc
->safi
= stream_getc (s
);
182 bgp_afi_safi_valid_indices (afi_t afi
, safi_t
*safi
)
190 /* BGP MPLS-labeled VPN SAFI isn't contigious with others, remap */
191 case SAFI_MPLS_LABELED_VPN
:
192 *safi
= SAFI_MPLS_VPN
;
205 zlog_debug ("unknown afi/safi (%u/%u)", afi
, *safi
);
210 /* Set negotiated capability value. */
212 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
214 struct capability_mp_data mpc
;
215 struct stream
*s
= BGP_INPUT (peer
);
217 /* Verify length is 4 */
218 if (hdr
->length
!= 4)
220 zlog_warn("MP Cap: Received invalid length %d, non-multiple of 4",
225 bgp_capability_mp_data (s
, &mpc
);
227 if (bgp_debug_neighbor_events(peer
))
228 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
229 peer
->host
, mpc
.afi
, mpc
.safi
);
231 if (!bgp_afi_safi_valid_indices (mpc
.afi
, &mpc
.safi
))
234 /* Now safi remapped, and afi/safi are valid array indices */
235 peer
->afc_recv
[mpc
.afi
][mpc
.safi
] = 1;
237 if (peer
->afc
[mpc
.afi
][mpc
.safi
])
238 peer
->afc_nego
[mpc
.afi
][mpc
.safi
] = 1;
246 bgp_capability_orf_not_support (struct peer
*peer
, afi_t afi
, safi_t safi
,
247 u_char type
, u_char mode
)
249 if (bgp_debug_neighbor_events(peer
))
250 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
251 peer
->host
, afi
, safi
, type
, mode
);
254 static const struct message orf_type_str
[] =
256 { ORF_TYPE_PREFIX
, "Prefixlist" },
257 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
259 static const int orf_type_str_max
= array_size(orf_type_str
);
261 static const struct message orf_mode_str
[] =
263 { ORF_MODE_RECEIVE
, "Receive" },
264 { ORF_MODE_SEND
, "Send" },
265 { ORF_MODE_BOTH
, "Both" },
267 static const int orf_mode_str_max
= array_size(orf_mode_str
);
270 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
272 struct stream
*s
= BGP_INPUT (peer
);
273 struct capability_orf_entry entry
;
278 u_int16_t sm_cap
= 0; /* capability send-mode receive */
279 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
282 /* ORF Entry header */
283 bgp_capability_mp_data (s
, &entry
.mpc
);
284 entry
.num
= stream_getc (s
);
286 safi
= entry
.mpc
.safi
;
288 if (bgp_debug_neighbor_events(peer
))
289 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
290 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
292 /* Check AFI and SAFI. */
293 if (!bgp_afi_safi_valid_indices (entry
.mpc
.afi
, &safi
))
295 zlog_info ("%s Addr-family %d/%d not supported."
296 " Ignoring the ORF capability",
297 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
301 /* validate number field */
302 if (CAPABILITY_CODE_ORF_LEN
+ (entry
.num
* 2) > hdr
->length
)
304 zlog_info ("%s ORF Capability entry length error,"
305 " Cap length %u, num %u",
306 peer
->host
, hdr
->length
, entry
.num
);
307 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
311 for (i
= 0 ; i
< entry
.num
; i
++)
313 type
= stream_getc(s
);
314 mode
= stream_getc(s
);
316 /* ORF Mode error check */
321 case ORF_MODE_RECEIVE
:
324 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
327 /* ORF Type and afi/safi error checks */
328 /* capcode versus type */
331 case CAPABILITY_CODE_ORF
:
334 case ORF_TYPE_PREFIX
:
337 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
341 case CAPABILITY_CODE_ORF_OLD
:
344 case ORF_TYPE_PREFIX_OLD
:
347 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
352 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
357 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
358 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
359 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
361 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
365 if (bgp_debug_neighbor_events(peer
))
366 zlog_debug ("%s OPEN has %s ORF capability"
367 " as %s for afi/safi: %d/%d",
368 peer
->host
, LOOKUP (orf_type_str
, type
),
369 LOOKUP (orf_mode_str
, mode
),
370 entry
.mpc
.afi
, safi
);
372 if (hdr
->code
== CAPABILITY_CODE_ORF
)
374 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
375 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
377 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
379 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
380 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
384 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
391 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
392 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
395 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
397 case ORF_MODE_RECEIVE
:
398 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
406 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
408 struct stream
*s
= BGP_INPUT (peer
);
409 u_int16_t restart_flag_time
;
410 size_t end
= stream_get_getp (s
) + caphdr
->length
;
412 /* Verify length is a multiple of 4 */
413 if ((caphdr
->length
-2) % 4)
415 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
420 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
421 restart_flag_time
= stream_getw(s
);
422 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
423 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
425 UNSET_FLAG (restart_flag_time
, 0xF000);
426 peer
->v_gr_restart
= restart_flag_time
;
428 if (bgp_debug_neighbor_events(peer
))
430 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
431 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
433 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
438 while (stream_get_getp (s
) + 4 <= end
)
440 afi_t afi
= stream_getw (s
);
441 safi_t safi
= stream_getc (s
);
442 u_char flag
= stream_getc (s
);
444 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
446 if (bgp_debug_neighbor_events(peer
))
447 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
448 " Ignore the Graceful Restart capability for this AFI/SAFI",
449 peer
->host
, afi
, safi
);
451 else if (!peer
->afc
[afi
][safi
])
453 if (bgp_debug_neighbor_events(peer
))
454 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
455 " Ignore the Graceful Restart capability",
456 peer
->host
, afi
, safi
);
460 if (bgp_debug_neighbor_events(peer
))
461 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
462 afi_safi_print (afi
, safi
),
463 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
464 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
467 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
468 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
469 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
476 /* Unlike other capability parsing routines, this one returns 0 on error */
478 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
480 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
482 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
484 zlog_err ("%s AS4 capability has incorrect data length %d",
485 peer
->host
, hdr
->length
);
489 as_t as4
= stream_getl (BGP_INPUT(peer
));
491 if (BGP_DEBUG (as4
, AS4
))
492 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
498 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
500 struct stream
*s
= BGP_INPUT (peer
);
501 size_t end
= stream_get_getp (s
) + hdr
->length
;
503 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
505 /* Verify length is a multiple of 4 */
508 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
513 while (stream_get_getp (s
) + 4 <= end
)
515 afi_t afi
= stream_getw (s
);
516 safi_t safi
= stream_getc (s
);
517 u_char send_receive
= stream_getc (s
);
519 if (bgp_debug_neighbor_events(peer
))
520 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
521 peer
->host
, afi
, safi
,
522 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
523 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
525 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
527 if (bgp_debug_neighbor_events(peer
))
528 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
529 " Ignore the Addpath Attribute for this AFI/SAFI",
530 peer
->host
, afi
, safi
);
533 else if (!peer
->afc
[afi
][safi
])
535 if (bgp_debug_neighbor_events(peer
))
536 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
537 " Ignore the AddPath capability for this AFI/SAFI",
538 peer
->host
, afi
, safi
);
542 if (send_receive
& BGP_ADDPATH_RX
)
543 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
545 if (send_receive
& BGP_ADDPATH_TX
)
546 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
553 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
555 struct stream
*s
= BGP_INPUT (peer
);
556 size_t end
= stream_get_getp (s
) + hdr
->length
;
558 /* Verify length is a multiple of 4 */
561 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
566 while (stream_get_getp (s
) + 6 <= end
)
568 afi_t afi
= stream_getw (s
);
569 safi_t safi
= stream_getw (s
);
570 afi_t nh_afi
= stream_getw (s
);
572 if (bgp_debug_neighbor_events(peer
))
573 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
574 peer
->host
, afi
, safi
, nh_afi
);
576 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
578 if (bgp_debug_neighbor_events(peer
))
579 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
580 " Ignore the ENHE Attribute for this AFI/SAFI",
581 peer
->host
, afi
, safi
);
585 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
586 * the Nexthop AFI being IPv6. A future spec may introduce other
587 * possibilities, so we ignore other values with a log. Also, only
588 * Unicast SAFI is currently supported (and expected).
590 if (afi
!= AFI_IP
|| safi
!= SAFI_UNICAST
|| nh_afi
!= AFI_IP6
)
592 zlog_warn ("%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
593 "in Extended Next-hop capability, ignoring",
594 peer
->host
, afi
, safi
, nh_afi
);
598 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
600 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
601 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
604 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
610 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
612 struct stream
*s
= BGP_INPUT (peer
);
613 char str
[BGP_MAX_HOSTNAME
+1];
614 size_t end
= stream_get_getp (s
) + hdr
->length
;
617 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
619 len
= stream_getc(s
);
620 if (stream_get_getp(s
) + len
> end
)
622 zlog_warn("%s: Received malformed hostname capability from peer %s",
623 __FUNCTION__
, peer
->host
);
627 if (len
> BGP_MAX_HOSTNAME
)
629 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
630 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
631 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
634 stream_get(str
, s
, len
);
640 if (peer
->hostname
!= NULL
)
642 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
643 peer
->hostname
= NULL
;
646 if (peer
->domainname
!= NULL
)
648 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
649 peer
->domainname
= NULL
;
652 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
655 if (stream_get_getp(s
) +1 > end
)
657 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
658 __FUNCTION__
, peer
->host
);
662 len
= stream_getc(s
);
663 if (stream_get_getp(s
) + len
> end
)
665 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
666 __FUNCTION__
, peer
->host
);
670 if (len
> BGP_MAX_HOSTNAME
)
672 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
673 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
674 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
677 stream_get(str
, s
, len
);
682 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
685 if (bgp_debug_neighbor_events(peer
))
687 zlog_debug("%s received hostname %s, domainname %s",
688 peer
->host
, peer
->hostname
, peer
->domainname
);
694 static const struct message capcode_str
[] =
696 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
697 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
698 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
699 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
700 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
701 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
702 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
703 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
704 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
705 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
706 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
707 { CAPABILITY_CODE_FQDN
, "FQDN" },
709 static const int capcode_str_max
= array_size(capcode_str
);
711 /* Minimum sizes for length field of each cap (so not inc. the header) */
712 static const size_t cap_minsizes
[] =
714 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
715 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
716 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
717 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
718 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
719 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
720 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
721 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
722 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
723 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
724 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
725 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
728 /* value the capability must be a multiple of.
729 * 0-data capabilities won't be checked against this.
730 * Other capabilities whose data doesn't fall on convenient boundaries for this
731 * table should be set to 1.
733 static const size_t cap_modsizes
[] =
735 [CAPABILITY_CODE_MP
] = 4,
736 [CAPABILITY_CODE_REFRESH
] = 1,
737 [CAPABILITY_CODE_ORF
] = 1,
738 [CAPABILITY_CODE_RESTART
] = 1,
739 [CAPABILITY_CODE_AS4
] = 4,
740 [CAPABILITY_CODE_ADDPATH
] = 4,
741 [CAPABILITY_CODE_DYNAMIC
] = 1,
742 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
743 [CAPABILITY_CODE_ENHE
] = 6,
744 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
745 [CAPABILITY_CODE_ORF_OLD
] = 1,
746 [CAPABILITY_CODE_FQDN
] = 1,
750 * Parse given capability.
751 * XXX: This is reading into a stream, but not using stream API
753 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
754 * capabilities were encountered.
757 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
761 struct stream
*s
= BGP_INPUT (peer
);
762 size_t end
= stream_get_getp (s
) + length
;
764 assert (STREAM_READABLE (s
) >= length
);
766 while (stream_get_getp (s
) < end
)
769 u_char
*sp
= stream_pnt (s
);
770 struct capability_header caphdr
;
773 /* We need at least capability code and capability length. */
774 if (stream_get_getp(s
) + 2 > end
)
776 zlog_info ("%s Capability length error (< header)", peer
->host
);
777 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
781 caphdr
.code
= stream_getc (s
);
782 caphdr
.length
= stream_getc (s
);
783 start
= stream_get_getp (s
);
785 /* Capability length check sanity check. */
786 if (start
+ caphdr
.length
> end
)
788 zlog_info ("%s Capability length error (< length)", peer
->host
);
789 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
793 if (bgp_debug_neighbor_events(peer
))
794 zlog_debug ("%s OPEN has %s capability (%u), length %u",
796 LOOKUP (capcode_str
, caphdr
.code
),
797 caphdr
.code
, caphdr
.length
);
799 /* Length sanity check, type-specific, for known capabilities */
802 case CAPABILITY_CODE_MP
:
803 case CAPABILITY_CODE_REFRESH
:
804 case CAPABILITY_CODE_REFRESH_OLD
:
805 case CAPABILITY_CODE_ORF
:
806 case CAPABILITY_CODE_ORF_OLD
:
807 case CAPABILITY_CODE_RESTART
:
808 case CAPABILITY_CODE_AS4
:
809 case CAPABILITY_CODE_ADDPATH
:
810 case CAPABILITY_CODE_DYNAMIC
:
811 case CAPABILITY_CODE_DYNAMIC_OLD
:
812 case CAPABILITY_CODE_ENHE
:
813 case CAPABILITY_CODE_FQDN
:
815 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
817 zlog_info ("%s %s Capability length error: got %u,"
818 " expected at least %u",
820 LOOKUP (capcode_str
, caphdr
.code
),
822 (unsigned) cap_minsizes
[caphdr
.code
]);
823 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
827 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
829 zlog_info ("%s %s Capability length error: got %u,"
830 " expected a multiple of %u",
832 LOOKUP (capcode_str
, caphdr
.code
),
834 (unsigned) cap_modsizes
[caphdr
.code
]);
835 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
836 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
839 /* we deliberately ignore unknown codes, see below */
846 case CAPABILITY_CODE_MP
:
850 /* Ignore capability when override-capability is set. */
851 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
853 /* Set negotiated value. */
854 ret
= bgp_capability_mp (peer
, &caphdr
);
856 /* Unsupported Capability. */
859 /* Store return data. */
860 memcpy (*error
, sp
, caphdr
.length
+ 2);
861 *error
+= caphdr
.length
+ 2;
863 ret
= 0; /* Don't return error for this */
867 case CAPABILITY_CODE_REFRESH
:
868 case CAPABILITY_CODE_REFRESH_OLD
:
870 /* BGP refresh capability */
871 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
872 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
874 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
877 case CAPABILITY_CODE_ORF
:
878 case CAPABILITY_CODE_ORF_OLD
:
879 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
881 case CAPABILITY_CODE_RESTART
:
882 ret
= bgp_capability_restart (peer
, &caphdr
);
884 case CAPABILITY_CODE_DYNAMIC
:
885 case CAPABILITY_CODE_DYNAMIC_OLD
:
886 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
888 case CAPABILITY_CODE_AS4
:
889 /* Already handled as a special-case parsing of the capabilities
890 * at the beginning of OPEN processing. So we care not a jot
891 * for the value really, only error case.
893 if (!bgp_capability_as4 (peer
, &caphdr
))
896 case CAPABILITY_CODE_ADDPATH
:
897 ret
= bgp_capability_addpath (peer
, &caphdr
);
899 case CAPABILITY_CODE_ENHE
:
900 ret
= bgp_capability_enhe (peer
, &caphdr
);
902 case CAPABILITY_CODE_FQDN
:
903 ret
= bgp_capability_hostname (peer
, &caphdr
);
906 if (caphdr
.code
> 128)
908 /* We don't send Notification for unknown vendor specific
909 capabilities. It seems reasonable for now... */
910 zlog_warn ("%s Vendor specific capability %d",
911 peer
->host
, caphdr
.code
);
915 zlog_warn ("%s unrecognized capability code: %d - ignored",
916 peer
->host
, caphdr
.code
);
917 memcpy (*error
, sp
, caphdr
.length
+ 2);
918 *error
+= caphdr
.length
+ 2;
924 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
927 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
929 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
930 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
931 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
933 stream_set_getp (s
, start
+ caphdr
.length
);
940 bgp_auth_parse (struct peer
*peer
, size_t length
)
942 bgp_notify_send (peer
,
944 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
949 strict_capability_same (struct peer
*peer
)
953 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
954 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
955 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
960 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
961 * Returns 0 if no as4 found, as4cap value otherwise.
964 peek_for_as4_capability (struct peer
*peer
, u_char length
)
966 struct stream
*s
= BGP_INPUT (peer
);
967 size_t orig_getp
= stream_get_getp (s
);
968 size_t end
= orig_getp
+ length
;
971 if (BGP_DEBUG (as4
, AS4
))
972 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
975 /* the error cases we DONT handle, we ONLY try to read as4 out of
976 * correctly formatted options.
978 while (stream_get_getp(s
) < end
)
983 /* Check the length. */
984 if (stream_get_getp (s
) + 2 > end
)
987 /* Fetch option type and length. */
988 opt_type
= stream_getc (s
);
989 opt_length
= stream_getc (s
);
991 /* Option length check. */
992 if (stream_get_getp (s
) + opt_length
> end
)
995 if (opt_type
== BGP_OPEN_OPT_CAP
)
997 unsigned long capd_start
= stream_get_getp (s
);
998 unsigned long capd_end
= capd_start
+ opt_length
;
1000 assert (capd_end
<= end
);
1002 while (stream_get_getp (s
) < capd_end
)
1004 struct capability_header hdr
;
1006 if (stream_get_getp (s
) + 2 > capd_end
)
1009 hdr
.code
= stream_getc (s
);
1010 hdr
.length
= stream_getc (s
);
1012 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
1015 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1017 if (BGP_DEBUG (as4
, AS4
))
1018 zlog_info ("[AS4] found AS4 capability, about to parse");
1019 as4
= bgp_capability_as4 (peer
, &hdr
);
1023 stream_forward_getp (s
, hdr
.length
);
1029 stream_set_getp (s
, orig_getp
);
1034 * Parse open option.
1036 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1039 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1043 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1044 struct stream
*s
= BGP_INPUT(peer
);
1045 size_t end
= stream_get_getp (s
) + length
;
1049 if (bgp_debug_neighbor_events(peer
))
1050 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1051 peer
->host
, length
);
1053 while (stream_get_getp(s
) < end
)
1058 /* Must have at least an OPEN option header */
1059 if (STREAM_READABLE(s
) < 2)
1061 zlog_info ("%s Option length error", peer
->host
);
1062 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1066 /* Fetch option type and length. */
1067 opt_type
= stream_getc (s
);
1068 opt_length
= stream_getc (s
);
1070 /* Option length check. */
1071 if (STREAM_READABLE (s
) < opt_length
)
1073 zlog_info ("%s Option length error", peer
->host
);
1074 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1078 if (bgp_debug_neighbor_events(peer
))
1079 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1080 peer
->host
, opt_type
,
1081 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1082 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1087 case BGP_OPEN_OPT_AUTH
:
1088 ret
= bgp_auth_parse (peer
, opt_length
);
1090 case BGP_OPEN_OPT_CAP
:
1091 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1094 bgp_notify_send (peer
,
1095 BGP_NOTIFY_OPEN_ERR
,
1096 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1101 /* Parse error. To accumulate all unsupported capability codes,
1102 bgp_capability_parse does not return -1 when encounter
1103 unsupported capability code. To detect that, please check
1104 error and erro_data pointer, like below. */
1109 /* All OPEN option is parsed. Check capability when strict compare
1111 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1113 /* If Unsupported Capability exists. */
1114 if (error
!= error_data
)
1116 bgp_notify_send_with_data (peer
,
1117 BGP_NOTIFY_OPEN_ERR
,
1118 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1119 error_data
, error
- error_data
);
1123 /* Check local capability does not negotiated with remote
1125 if (! strict_capability_same (peer
))
1127 bgp_notify_send (peer
,
1128 BGP_NOTIFY_OPEN_ERR
,
1129 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1134 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1136 if (*mp_capability
&&
1137 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1139 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1140 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1141 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1142 && ! peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1143 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1144 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1145 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1146 && ! peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
1148 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1149 "overlap with received MP capabilities",
1152 if (error
!= error_data
)
1153 bgp_notify_send_with_data (peer
,
1154 BGP_NOTIFY_OPEN_ERR
,
1155 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1156 error_data
, error
- error_data
);
1158 bgp_notify_send (peer
,
1159 BGP_NOTIFY_OPEN_ERR
,
1160 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1168 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1169 afi_t afi
, safi_t safi
, u_char code
)
1175 unsigned long numberp
;
1176 int number_of_orfs
= 0;
1178 if (safi
== SAFI_MPLS_VPN
)
1179 safi
= SAFI_MPLS_LABELED_VPN
;
1181 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1182 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1183 stream_putc (s
, 0); /* Capability Length */
1184 stream_putc (s
, code
); /* Capability Code */
1185 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1186 stream_putc (s
, 0); /* ORF Length */
1187 stream_putw (s
, afi
);
1189 stream_putc (s
, safi
);
1190 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1191 stream_putc (s
, 0); /* Number of ORFs */
1193 /* Address Prefix ORF */
1194 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1195 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1197 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1198 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1200 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1201 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1203 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1204 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1205 stream_putc (s
, ORF_MODE_BOTH
);
1207 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1209 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1210 stream_putc (s
, ORF_MODE_SEND
);
1214 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1215 stream_putc (s
, ORF_MODE_RECEIVE
);
1220 /* Total Number of ORFs. */
1221 stream_putc_at (s
, numberp
, number_of_orfs
);
1223 /* Total ORF Len. */
1224 orf_len
= stream_get_endp (s
) - orfp
- 1;
1225 stream_putc_at (s
, orfp
, orf_len
);
1227 /* Total Capability Len. */
1228 cap_len
= stream_get_endp (s
) - capp
- 1;
1229 stream_putc_at (s
, capp
, cap_len
);
1232 /* Fill in capability open option to the packet. */
1234 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1237 unsigned long cp
, capp
, rcapp
;
1241 u_int32_t restart_time
;
1242 u_char afi_safi_count
= 0;
1243 struct utsname names
;
1244 int adv_addpath_tx
= 0;
1246 /* Remember current pointer for Opt Parm Len. */
1247 cp
= stream_get_endp (s
);
1252 /* Do not send capability. */
1253 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1254 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1258 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
])
1260 peer
->afc_adv
[AFI_IP
][SAFI_UNICAST
] = 1;
1261 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1262 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1263 stream_putc (s
, CAPABILITY_CODE_MP
);
1264 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1265 stream_putw (s
, AFI_IP
);
1267 stream_putc (s
, SAFI_UNICAST
);
1269 /* IPv4 multicast. */
1270 if (peer
->afc
[AFI_IP
][SAFI_MULTICAST
])
1272 peer
->afc_adv
[AFI_IP
][SAFI_MULTICAST
] = 1;
1273 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1274 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1275 stream_putc (s
, CAPABILITY_CODE_MP
);
1276 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1277 stream_putw (s
, AFI_IP
);
1279 stream_putc (s
, SAFI_MULTICAST
);
1282 if (peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
])
1284 peer
->afc_adv
[AFI_IP
][SAFI_MPLS_VPN
] = 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
, AFI_IP
);
1291 stream_putc (s
, SAFI_MPLS_LABELED_VPN
);
1294 if (peer
->afc
[AFI_IP
][SAFI_ENCAP
])
1296 peer
->afc_adv
[AFI_IP
][SAFI_ENCAP
] = 1;
1297 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1298 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1299 stream_putc (s
, CAPABILITY_CODE_MP
);
1300 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1301 stream_putw (s
, AFI_IP
);
1303 stream_putc (s
, SAFI_ENCAP
);
1306 /* Currently supporting RFC-5549 for Link-Local peering only */
1307 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1308 peer
->su
.sa
.sa_family
== AF_INET6
&&
1309 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
))
1311 /* RFC 5549 Extended Next Hop Encoding */
1312 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1313 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1314 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1315 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1316 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1317 /* Currently supporting for SAFI_UNICAST only */
1318 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_ADV
);
1319 stream_putw (s
, AFI_IP
);
1320 stream_putw (s
, SAFI_UNICAST
);
1321 stream_putw (s
, AFI_IP6
);
1323 if (CHECK_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_RCV
))
1324 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_NEGO
);
1327 if (peer
->afc
[AFI_IP6
][SAFI_UNICAST
])
1329 peer
->afc_adv
[AFI_IP6
][SAFI_UNICAST
] = 1;
1330 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1331 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1332 stream_putc (s
, CAPABILITY_CODE_MP
);
1333 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1334 stream_putw (s
, AFI_IP6
);
1336 stream_putc (s
, SAFI_UNICAST
);
1338 /* IPv6 multicast. */
1339 if (peer
->afc
[AFI_IP6
][SAFI_MULTICAST
])
1341 peer
->afc_adv
[AFI_IP6
][SAFI_MULTICAST
] = 1;
1342 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1343 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1344 stream_putc (s
, CAPABILITY_CODE_MP
);
1345 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1346 stream_putw (s
, AFI_IP6
);
1348 stream_putc (s
, SAFI_MULTICAST
);
1351 if (peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
])
1353 peer
->afc_adv
[AFI_IP6
][SAFI_MPLS_VPN
] = 1;
1354 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1355 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1356 stream_putc (s
, CAPABILITY_CODE_MP
);
1357 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1358 stream_putw (s
, AFI_IP6
);
1360 stream_putc (s
, SAFI_MPLS_LABELED_VPN
);
1363 if (peer
->afc
[AFI_IP6
][SAFI_ENCAP
])
1365 peer
->afc_adv
[AFI_IP6
][SAFI_ENCAP
] = 1;
1366 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1367 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1368 stream_putc (s
, CAPABILITY_CODE_MP
);
1369 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1370 stream_putw (s
, AFI_IP6
);
1372 stream_putc (s
, SAFI_ENCAP
);
1374 #endif /* HAVE_IPV6 */
1376 /* Route refresh. */
1377 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1378 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1379 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1380 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1381 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1382 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1383 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1384 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1385 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1388 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1389 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1390 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1391 stream_putc (s
, CAPABILITY_CODE_AS4
);
1392 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1393 if ( peer
->change_local_as
)
1394 local_as
= peer
->change_local_as
;
1396 local_as
= peer
->local_as
;
1397 stream_putl (s
, local_as
);
1400 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1401 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1402 if (peer
->afc
[afi
][safi
])
1406 /* Only advertise addpath TX if a feature that will use it is
1408 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1409 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1413 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1414 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1415 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1416 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1417 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1419 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1420 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1421 if (peer
->afc
[afi
][safi
])
1423 stream_putw (s
, afi
);
1424 stream_putc (s
, safi
);
1428 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1429 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1430 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1434 stream_putc (s
, BGP_ADDPATH_RX
);
1435 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1436 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1440 /* ORF capability. */
1441 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1442 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1443 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1444 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1446 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1447 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1450 /* Dynamic capability. */
1451 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1453 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1454 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1455 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1456 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1457 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1458 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1459 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1460 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1461 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1464 /* Hostname capability */
1466 if (names
.nodename
[0] != '\0')
1468 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1469 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1470 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1471 stream_putc(s
, 0); /* dummy len for now */
1472 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1473 capp
= stream_get_endp(s
);
1474 stream_putc(s
, 0); /* dummy len for now */
1475 len
= strlen(names
.nodename
);
1476 if (len
> BGP_MAX_HOSTNAME
)
1477 len
= BGP_MAX_HOSTNAME
;
1479 stream_putc(s
, len
);
1480 stream_put(s
, names
.nodename
, len
);
1481 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1482 if ((names
.domainname
[0] != '\0') &&
1483 (strcmp(names
.domainname
, "(none)") != 0))
1485 len
= strlen(names
.domainname
);
1486 if (len
> BGP_MAX_HOSTNAME
)
1487 len
= BGP_MAX_HOSTNAME
;
1489 stream_putc(s
, len
);
1490 stream_put(s
, names
.domainname
, len
);
1495 stream_putc(s
, 0); /* 0 length */
1498 /* Set the lengths straight */
1499 len
= stream_get_endp(s
) - rcapp
- 1;
1500 stream_putc_at(s
, rcapp
, len
);
1501 len
= stream_get_endp(s
) - capp
- 1;
1502 stream_putc_at(s
, capp
, len
);
1504 if (bgp_debug_neighbor_events(peer
))
1505 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1506 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1507 peer
->host
, names
.nodename
, names
.domainname
);
1509 zlog_debug("%s Sending hostname cap with hn = %s", peer
->host
,
1514 /* Sending base graceful-restart capability irrespective of the config */
1515 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1516 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1517 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1518 stream_putc (s
, 0); /* Capability Length */
1519 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1520 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1522 restart_time
= peer
->bgp
->restart_time
;
1523 if (peer
->bgp
->t_startup
)
1525 SET_FLAG (restart_time
, RESTART_R_BIT
);
1526 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1528 stream_putw (s
, restart_time
);
1530 /* Send address-family specific graceful-restart capability only when GR config
1532 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1534 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1535 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1536 if (peer
->afc
[afi
][safi
])
1538 stream_putw (s
, afi
);
1539 stream_putc (s
, (safi
== SAFI_MPLS_VPN
) ? SAFI_MPLS_LABELED_VPN
: safi
);
1540 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
1541 stream_putc (s
, RESTART_F_BIT
);
1547 /* Total Graceful restart capability Len. */
1548 len
= stream_get_endp (s
) - rcapp
- 1;
1549 stream_putc_at (s
, rcapp
, len
);
1551 /* Total Capability Len. */
1552 len
= stream_get_endp (s
) - capp
- 1;
1553 stream_putc_at (s
, capp
, len
);
1555 /* Total Opt Parm Len. */
1556 len
= stream_get_endp (s
) - cp
- 1;
1557 stream_putc_at (s
, cp
, len
);