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
)
85 bgp_map_afi_safi_iana2int (ntohs(mpc
.afi
), mpc
.safi
, &afi
, &safi
);
91 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv4");
94 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolAfi", "IPv6");
97 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolAfiUnknown", ntohs (mpc
.afi
));
103 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "unicast");
106 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "multicast");
109 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "MPLS-labeled VPN");
112 json_object_string_add(json_cap
, "capabilityErrorMultiProtocolSafi", "encap");
115 json_object_int_add(json_cap
, "capabilityErrorMultiProtocolSafiUnknown", mpc
.safi
);
121 vty_out (vty
, " Capability error for: Multi protocol ");
125 vty_out (vty
, "AFI IPv4, ");
128 vty_out (vty
, "AFI IPv6, ");
131 vty_out (vty
, "AFI Unknown %d, ", ntohs (mpc
.afi
));
137 vty_out (vty
, "SAFI Unicast");
140 vty_out (vty
, "SAFI Multicast");
143 vty_out (vty
, "SAFI MPLS-labeled VPN");
146 vty_out (vty
, "SAFI ENCAP");
149 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
152 vty_out (vty
, "%s", VTY_NEWLINE
);
155 else if (hdr
->code
>= 128)
158 json_object_int_add(json_cap
, "capabilityErrorVendorSpecificCapabilityCode", hdr
->code
);
160 vty_out (vty
, " Capability error: vendor specific capability code %d",
166 json_object_int_add(json_cap
, "capabilityErrorUnknownCapabilityCode", hdr
->code
);
168 vty_out (vty
, " Capability error: unknown capability code %d",
171 pnt
+= hdr
->length
+ 2;
174 json_object_object_add(json_neigh
, "capabilityErrors", json_cap
);
178 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
180 mpc
->afi
= stream_getw (s
);
181 mpc
->reserved
= stream_getc (s
);
182 mpc
->safi
= stream_getc (s
);
185 /* Set negotiated capability value. */
187 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
189 struct capability_mp_data mpc
;
190 struct stream
*s
= BGP_INPUT (peer
);
192 /* Verify length is 4 */
193 if (hdr
->length
!= 4)
195 zlog_warn("MP Cap: Received invalid length %d, non-multiple of 4",
200 bgp_capability_mp_data (s
, &mpc
);
202 if (bgp_debug_neighbor_events(peer
))
203 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
204 peer
->host
, mpc
.afi
, mpc
.safi
);
206 /* Convert AFI, SAFI to internal values, check. */
207 if (bgp_map_afi_safi_iana2int (mpc
.afi
, mpc
.safi
, &mpc
.afi
, &mpc
.safi
))
210 /* Now safi remapped, and afi/safi are valid array indices */
211 peer
->afc_recv
[mpc
.afi
][mpc
.safi
] = 1;
213 if (peer
->afc
[mpc
.afi
][mpc
.safi
])
214 peer
->afc_nego
[mpc
.afi
][mpc
.safi
] = 1;
222 bgp_capability_orf_not_support (struct peer
*peer
, afi_t afi
, safi_t safi
,
223 u_char type
, u_char mode
)
225 if (bgp_debug_neighbor_events(peer
))
226 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
227 peer
->host
, afi
, safi
, type
, mode
);
230 static const struct message orf_type_str
[] =
232 { ORF_TYPE_PREFIX
, "Prefixlist" },
233 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
235 static const int orf_type_str_max
= array_size(orf_type_str
);
237 static const struct message orf_mode_str
[] =
239 { ORF_MODE_RECEIVE
, "Receive" },
240 { ORF_MODE_SEND
, "Send" },
241 { ORF_MODE_BOTH
, "Both" },
243 static const int orf_mode_str_max
= array_size(orf_mode_str
);
246 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
248 struct stream
*s
= BGP_INPUT (peer
);
249 struct capability_orf_entry entry
;
251 safi_t pkt_safi
, safi
;
254 u_int16_t sm_cap
= 0; /* capability send-mode receive */
255 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
258 /* ORF Entry header */
259 bgp_capability_mp_data (s
, &entry
.mpc
);
260 entry
.num
= stream_getc (s
);
261 pkt_afi
= entry
.mpc
.afi
;
262 pkt_safi
= entry
.mpc
.safi
;
264 if (bgp_debug_neighbor_events(peer
))
265 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
266 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
268 /* Convert AFI, SAFI to internal values, check. */
269 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
271 zlog_info ("%s Addr-family %d/%d not supported."
272 " Ignoring the ORF capability",
273 peer
->host
, pkt_afi
, pkt_safi
);
278 entry
.mpc
.safi
= safi
;
280 /* validate number field */
281 if (CAPABILITY_CODE_ORF_LEN
+ (entry
.num
* 2) > hdr
->length
)
283 zlog_info ("%s ORF Capability entry length error,"
284 " Cap length %u, num %u",
285 peer
->host
, hdr
->length
, entry
.num
);
286 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
290 for (i
= 0 ; i
< entry
.num
; i
++)
292 type
= stream_getc(s
);
293 mode
= stream_getc(s
);
295 /* ORF Mode error check */
300 case ORF_MODE_RECEIVE
:
303 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
306 /* ORF Type and afi/safi error checks */
307 /* capcode versus type */
310 case CAPABILITY_CODE_ORF
:
313 case ORF_TYPE_PREFIX
:
316 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
320 case CAPABILITY_CODE_ORF_OLD
:
323 case ORF_TYPE_PREFIX_OLD
:
326 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
331 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
336 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
337 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
338 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
340 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
344 if (bgp_debug_neighbor_events(peer
))
345 zlog_debug ("%s OPEN has %s ORF capability"
346 " as %s for afi/safi: %d/%d",
347 peer
->host
, LOOKUP (orf_type_str
, type
),
348 LOOKUP (orf_mode_str
, mode
),
351 if (hdr
->code
== CAPABILITY_CODE_ORF
)
353 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
354 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
356 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
358 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
359 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
363 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
370 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
371 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
374 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
376 case ORF_MODE_RECEIVE
:
377 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
385 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
387 struct stream
*s
= BGP_INPUT (peer
);
388 u_int16_t restart_flag_time
;
389 size_t end
= stream_get_getp (s
) + caphdr
->length
;
391 /* Verify length is a multiple of 4 */
392 if ((caphdr
->length
-2) % 4)
394 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
399 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
400 restart_flag_time
= stream_getw(s
);
401 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
402 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
404 UNSET_FLAG (restart_flag_time
, 0xF000);
405 peer
->v_gr_restart
= restart_flag_time
;
407 if (bgp_debug_neighbor_events(peer
))
409 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
410 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
412 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
417 while (stream_get_getp (s
) + 4 <= end
)
421 afi_t pkt_afi
= stream_getw (s
);
422 safi_t pkt_safi
= stream_getc (s
);
423 u_char flag
= stream_getc (s
);
425 /* Convert AFI, SAFI to internal values, check. */
426 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
428 if (bgp_debug_neighbor_events(peer
))
429 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
430 " Ignore the Graceful Restart capability for this AFI/SAFI",
431 peer
->host
, pkt_afi
, pkt_safi
);
433 else if (!peer
->afc
[afi
][safi
])
435 if (bgp_debug_neighbor_events(peer
))
436 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
437 " Ignore the Graceful Restart capability",
438 peer
->host
, pkt_afi
, pkt_safi
);
442 if (bgp_debug_neighbor_events(peer
))
443 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
444 afi_safi_print (afi
, safi
),
445 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
446 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
449 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
450 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
451 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
458 /* Unlike other capability parsing routines, this one returns 0 on error */
460 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
462 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
464 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
466 zlog_err ("%s AS4 capability has incorrect data length %d",
467 peer
->host
, hdr
->length
);
471 as_t as4
= stream_getl (BGP_INPUT(peer
));
473 if (BGP_DEBUG (as4
, AS4
))
474 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
480 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
482 struct stream
*s
= BGP_INPUT (peer
);
483 size_t end
= stream_get_getp (s
) + hdr
->length
;
485 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
487 /* Verify length is a multiple of 4 */
490 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
495 while (stream_get_getp (s
) + 4 <= end
)
499 afi_t pkt_afi
= stream_getw (s
);
500 safi_t pkt_safi
= stream_getc (s
);
501 u_char send_receive
= stream_getc (s
);
503 if (bgp_debug_neighbor_events(peer
))
504 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
505 peer
->host
, pkt_afi
, pkt_safi
,
506 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
507 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
509 /* Convert AFI, SAFI to internal values, check. */
510 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
512 if (bgp_debug_neighbor_events(peer
))
513 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
514 " Ignore the Addpath Attribute for this AFI/SAFI",
515 peer
->host
, pkt_afi
, pkt_safi
);
518 else if (!peer
->afc
[afi
][safi
])
520 if (bgp_debug_neighbor_events(peer
))
521 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
522 " Ignore the AddPath capability for this AFI/SAFI",
523 peer
->host
, pkt_afi
, pkt_safi
);
527 if (send_receive
& BGP_ADDPATH_RX
)
528 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_RCV
);
530 if (send_receive
& BGP_ADDPATH_TX
)
531 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_RCV
);
538 bgp_capability_enhe (struct peer
*peer
, struct capability_header
*hdr
)
540 struct stream
*s
= BGP_INPUT (peer
);
541 size_t end
= stream_get_getp (s
) + hdr
->length
;
543 /* Verify length is a multiple of 4 */
546 zlog_warn("Extended NH: Received invalid length %d, non-multiple of 6",
551 while (stream_get_getp (s
) + 6 <= end
)
553 afi_t afi
, pkt_afi
= stream_getw (s
);
554 safi_t safi
, pkt_safi
= stream_getw (s
);
555 afi_t nh_afi
, pkt_nh_afi
= stream_getw (s
);
557 if (bgp_debug_neighbor_events(peer
))
558 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
559 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
561 /* Convert AFI, SAFI to internal values, check. */
562 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
564 if (bgp_debug_neighbor_events(peer
))
565 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
566 " Ignore the ENHE Attribute for this AFI/SAFI",
567 peer
->host
, pkt_afi
, pkt_safi
);
571 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
572 * the Nexthop AFI being IPv6. A future spec may introduce other
573 * possibilities, so we ignore other values with a log. Also, only
574 * Unicast SAFI is currently supported (and expected).
576 nh_afi
= afi_iana2int (pkt_nh_afi
);
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
, pkt_afi
, pkt_safi
, pkt_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_BGP_PEER_HOST
, peer
->hostname
);
631 peer
->hostname
= NULL
;
634 if (peer
->domainname
!= NULL
)
636 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
637 peer
->domainname
= NULL
;
640 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_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_BGP_PEER_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
] = CAPABILITY_CODE_RESTART_LEN
,
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_ADDPATH
] = 4,
729 [CAPABILITY_CODE_DYNAMIC
] = 1,
730 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
731 [CAPABILITY_CODE_ENHE
] = 6,
732 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
733 [CAPABILITY_CODE_ORF_OLD
] = 1,
734 [CAPABILITY_CODE_FQDN
] = 1,
738 * Parse given capability.
739 * XXX: This is reading into a stream, but not using stream API
741 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
742 * capabilities were encountered.
745 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
749 struct stream
*s
= BGP_INPUT (peer
);
750 size_t end
= stream_get_getp (s
) + length
;
752 assert (STREAM_READABLE (s
) >= length
);
754 while (stream_get_getp (s
) < end
)
757 u_char
*sp
= stream_pnt (s
);
758 struct capability_header caphdr
;
761 /* We need at least capability code and capability length. */
762 if (stream_get_getp(s
) + 2 > end
)
764 zlog_info ("%s Capability length error (< header)", peer
->host
);
765 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
769 caphdr
.code
= stream_getc (s
);
770 caphdr
.length
= stream_getc (s
);
771 start
= stream_get_getp (s
);
773 /* Capability length check sanity check. */
774 if (start
+ caphdr
.length
> end
)
776 zlog_info ("%s Capability length error (< length)", peer
->host
);
777 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
781 if (bgp_debug_neighbor_events(peer
))
782 zlog_debug ("%s OPEN has %s capability (%u), length %u",
784 LOOKUP (capcode_str
, caphdr
.code
),
785 caphdr
.code
, caphdr
.length
);
787 /* Length sanity check, type-specific, for known capabilities */
790 case CAPABILITY_CODE_MP
:
791 case CAPABILITY_CODE_REFRESH
:
792 case CAPABILITY_CODE_REFRESH_OLD
:
793 case CAPABILITY_CODE_ORF
:
794 case CAPABILITY_CODE_ORF_OLD
:
795 case CAPABILITY_CODE_RESTART
:
796 case CAPABILITY_CODE_AS4
:
797 case CAPABILITY_CODE_ADDPATH
:
798 case CAPABILITY_CODE_DYNAMIC
:
799 case CAPABILITY_CODE_DYNAMIC_OLD
:
800 case CAPABILITY_CODE_ENHE
:
801 case CAPABILITY_CODE_FQDN
:
803 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
805 zlog_info ("%s %s Capability length error: got %u,"
806 " expected at least %u",
808 LOOKUP (capcode_str
, caphdr
.code
),
810 (unsigned) cap_minsizes
[caphdr
.code
]);
811 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
815 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
817 zlog_info ("%s %s Capability length error: got %u,"
818 " expected a multiple of %u",
820 LOOKUP (capcode_str
, caphdr
.code
),
822 (unsigned) cap_modsizes
[caphdr
.code
]);
823 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
824 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
827 /* we deliberately ignore unknown codes, see below */
834 case CAPABILITY_CODE_MP
:
838 /* Ignore capability when override-capability is set. */
839 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
841 /* Set negotiated value. */
842 ret
= bgp_capability_mp (peer
, &caphdr
);
844 /* Unsupported Capability. */
847 /* Store return data. */
848 memcpy (*error
, sp
, caphdr
.length
+ 2);
849 *error
+= caphdr
.length
+ 2;
851 ret
= 0; /* Don't return error for this */
855 case CAPABILITY_CODE_REFRESH
:
856 case CAPABILITY_CODE_REFRESH_OLD
:
858 /* BGP refresh capability */
859 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
860 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
862 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
865 case CAPABILITY_CODE_ORF
:
866 case CAPABILITY_CODE_ORF_OLD
:
867 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
869 case CAPABILITY_CODE_RESTART
:
870 ret
= bgp_capability_restart (peer
, &caphdr
);
872 case CAPABILITY_CODE_DYNAMIC
:
873 case CAPABILITY_CODE_DYNAMIC_OLD
:
874 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
876 case CAPABILITY_CODE_AS4
:
877 /* Already handled as a special-case parsing of the capabilities
878 * at the beginning of OPEN processing. So we care not a jot
879 * for the value really, only error case.
881 if (!bgp_capability_as4 (peer
, &caphdr
))
884 case CAPABILITY_CODE_ADDPATH
:
885 ret
= bgp_capability_addpath (peer
, &caphdr
);
887 case CAPABILITY_CODE_ENHE
:
888 ret
= bgp_capability_enhe (peer
, &caphdr
);
890 case CAPABILITY_CODE_FQDN
:
891 ret
= bgp_capability_hostname (peer
, &caphdr
);
894 if (caphdr
.code
> 128)
896 /* We don't send Notification for unknown vendor specific
897 capabilities. It seems reasonable for now... */
898 zlog_warn ("%s Vendor specific capability %d",
899 peer
->host
, caphdr
.code
);
903 zlog_warn ("%s unrecognized capability code: %d - ignored",
904 peer
->host
, caphdr
.code
);
905 memcpy (*error
, sp
, caphdr
.length
+ 2);
906 *error
+= caphdr
.length
+ 2;
912 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
915 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
917 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
918 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
919 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
921 stream_set_getp (s
, start
+ caphdr
.length
);
928 bgp_auth_parse (struct peer
*peer
, size_t length
)
930 bgp_notify_send (peer
,
932 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
937 strict_capability_same (struct peer
*peer
)
941 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
942 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
943 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
948 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
949 * Returns 0 if no as4 found, as4cap value otherwise.
952 peek_for_as4_capability (struct peer
*peer
, u_char length
)
954 struct stream
*s
= BGP_INPUT (peer
);
955 size_t orig_getp
= stream_get_getp (s
);
956 size_t end
= orig_getp
+ length
;
959 if (BGP_DEBUG (as4
, AS4
))
960 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
963 /* the error cases we DONT handle, we ONLY try to read as4 out of
964 * correctly formatted options.
966 while (stream_get_getp(s
) < end
)
971 /* Check the length. */
972 if (stream_get_getp (s
) + 2 > end
)
975 /* Fetch option type and length. */
976 opt_type
= stream_getc (s
);
977 opt_length
= stream_getc (s
);
979 /* Option length check. */
980 if (stream_get_getp (s
) + opt_length
> end
)
983 if (opt_type
== BGP_OPEN_OPT_CAP
)
985 unsigned long capd_start
= stream_get_getp (s
);
986 unsigned long capd_end
= capd_start
+ opt_length
;
988 assert (capd_end
<= end
);
990 while (stream_get_getp (s
) < capd_end
)
992 struct capability_header hdr
;
994 if (stream_get_getp (s
) + 2 > capd_end
)
997 hdr
.code
= stream_getc (s
);
998 hdr
.length
= stream_getc (s
);
1000 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
1003 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1005 if (BGP_DEBUG (as4
, AS4
))
1006 zlog_info ("[AS4] found AS4 capability, about to parse");
1007 as4
= bgp_capability_as4 (peer
, &hdr
);
1011 stream_forward_getp (s
, hdr
.length
);
1017 stream_set_getp (s
, orig_getp
);
1022 * Parse open option.
1024 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1027 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1031 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1032 struct stream
*s
= BGP_INPUT(peer
);
1033 size_t end
= stream_get_getp (s
) + length
;
1037 if (bgp_debug_neighbor_events(peer
))
1038 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1039 peer
->host
, length
);
1041 while (stream_get_getp(s
) < end
)
1046 /* Must have at least an OPEN option header */
1047 if (STREAM_READABLE(s
) < 2)
1049 zlog_info ("%s Option length error", peer
->host
);
1050 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1054 /* Fetch option type and length. */
1055 opt_type
= stream_getc (s
);
1056 opt_length
= stream_getc (s
);
1058 /* Option length check. */
1059 if (STREAM_READABLE (s
) < opt_length
)
1061 zlog_info ("%s Option length error", peer
->host
);
1062 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1066 if (bgp_debug_neighbor_events(peer
))
1067 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1068 peer
->host
, opt_type
,
1069 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1070 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1075 case BGP_OPEN_OPT_AUTH
:
1076 ret
= bgp_auth_parse (peer
, opt_length
);
1078 case BGP_OPEN_OPT_CAP
:
1079 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1082 bgp_notify_send (peer
,
1083 BGP_NOTIFY_OPEN_ERR
,
1084 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1089 /* Parse error. To accumulate all unsupported capability codes,
1090 bgp_capability_parse does not return -1 when encounter
1091 unsupported capability code. To detect that, please check
1092 error and erro_data pointer, like below. */
1097 /* All OPEN option is parsed. Check capability when strict compare
1099 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1101 /* If Unsupported Capability exists. */
1102 if (error
!= error_data
)
1104 bgp_notify_send_with_data (peer
,
1105 BGP_NOTIFY_OPEN_ERR
,
1106 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1107 error_data
, error
- error_data
);
1111 /* Check local capability does not negotiated with remote
1113 if (! strict_capability_same (peer
))
1115 bgp_notify_send (peer
,
1116 BGP_NOTIFY_OPEN_ERR
,
1117 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1122 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1124 if (*mp_capability
&&
1125 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1127 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1128 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1129 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1130 && ! peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1131 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1132 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1133 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1134 && ! peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
1136 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1137 "overlap with received MP capabilities",
1140 if (error
!= error_data
)
1141 bgp_notify_send_with_data (peer
,
1142 BGP_NOTIFY_OPEN_ERR
,
1143 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1144 error_data
, error
- error_data
);
1146 bgp_notify_send (peer
,
1147 BGP_NOTIFY_OPEN_ERR
,
1148 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1156 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1157 afi_t afi
, safi_t safi
, u_char code
)
1163 unsigned long numberp
;
1164 int number_of_orfs
= 0;
1168 /* Convert AFI, SAFI to values for packet. */
1169 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1171 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1172 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1173 stream_putc (s
, 0); /* Capability Length */
1174 stream_putc (s
, code
); /* Capability Code */
1175 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1176 stream_putc (s
, 0); /* ORF Length */
1177 stream_putw (s
, pkt_afi
);
1179 stream_putc (s
, pkt_safi
);
1180 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1181 stream_putc (s
, 0); /* Number of ORFs */
1183 /* Address Prefix ORF */
1184 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1185 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1187 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1188 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1190 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1191 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1193 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1194 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1195 stream_putc (s
, ORF_MODE_BOTH
);
1197 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1199 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1200 stream_putc (s
, ORF_MODE_SEND
);
1204 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1205 stream_putc (s
, ORF_MODE_RECEIVE
);
1210 /* Total Number of ORFs. */
1211 stream_putc_at (s
, numberp
, number_of_orfs
);
1213 /* Total ORF Len. */
1214 orf_len
= stream_get_endp (s
) - orfp
- 1;
1215 stream_putc_at (s
, orfp
, orf_len
);
1217 /* Total Capability Len. */
1218 cap_len
= stream_get_endp (s
) - capp
- 1;
1219 stream_putc_at (s
, capp
, cap_len
);
1222 /* Fill in capability open option to the packet. */
1224 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1227 unsigned long cp
, capp
, rcapp
;
1229 safi_t safi
, pkt_safi
;
1231 u_int32_t restart_time
;
1232 u_char afi_safi_count
= 0;
1233 struct utsname names
;
1234 int adv_addpath_tx
= 0;
1236 /* Remember current pointer for Opt Parm Len. */
1237 cp
= stream_get_endp (s
);
1242 /* Do not send capability. */
1243 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1244 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1247 /* MP capability for configured AFI, SAFI */
1248 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1249 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1251 if (peer
->afc
[afi
][safi
])
1253 /* Convert AFI, SAFI to values for packet. */
1254 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1256 peer
->afc_adv
[afi
][safi
] = 1;
1257 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1258 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1259 stream_putc (s
, CAPABILITY_CODE_MP
);
1260 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1261 stream_putw (s
, pkt_afi
);
1263 stream_putc (s
, pkt_safi
);
1267 /* Extended nexthop capability - currently supporting RFC-5549 for
1268 * Link-Local peering only
1270 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
) &&
1271 peer
->su
.sa
.sa_family
== AF_INET6
&&
1272 IN6_IS_ADDR_LINKLOCAL(&peer
->su
.sin6
.sin6_addr
))
1274 /* RFC 5549 Extended Next Hop Encoding */
1275 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_ADV
);
1276 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1277 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
+ 2);
1278 stream_putc (s
, CAPABILITY_CODE_ENHE
);
1279 stream_putc (s
, CAPABILITY_CODE_ENHE_LEN
);
1280 /* Currently supporting for SAFI_UNICAST only */
1281 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_ADV
);
1282 stream_putw (s
, AFI_IP
);
1283 stream_putw (s
, SAFI_UNICAST
);
1284 stream_putw (s
, AFI_IP6
);
1286 if (CHECK_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_RCV
))
1287 SET_FLAG (peer
->af_cap
[AFI_IP
][SAFI_UNICAST
], PEER_CAP_ENHE_AF_NEGO
);
1290 /* Route refresh. */
1291 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1292 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1293 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1294 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1295 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1296 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1297 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1298 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1299 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1302 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1303 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1304 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1305 stream_putc (s
, CAPABILITY_CODE_AS4
);
1306 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1307 if ( peer
->change_local_as
)
1308 local_as
= peer
->change_local_as
;
1310 local_as
= peer
->local_as
;
1311 stream_putl (s
, local_as
);
1314 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1315 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1316 if (peer
->afc
[afi
][safi
])
1320 /* Only advertise addpath TX if a feature that will use it is
1322 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1323 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1327 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1328 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1329 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1330 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1331 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1333 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1334 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1335 if (peer
->afc
[afi
][safi
])
1337 /* Convert AFI, SAFI to values for packet. */
1338 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1340 stream_putw (s
, pkt_afi
);
1341 stream_putc (s
, pkt_safi
);
1345 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1346 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1347 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1351 stream_putc (s
, BGP_ADDPATH_RX
);
1352 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1353 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1357 /* ORF capability. */
1358 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1359 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1360 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1361 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1363 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1364 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1367 /* Dynamic capability. */
1368 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1370 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1371 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1372 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1373 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1374 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1375 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1376 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1377 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1378 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1381 /* Hostname capability */
1383 if (names
.nodename
[0] != '\0')
1385 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1386 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1387 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1388 stream_putc(s
, 0); /* dummy len for now */
1389 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1390 capp
= stream_get_endp(s
);
1391 stream_putc(s
, 0); /* dummy len for now */
1392 len
= strlen(names
.nodename
);
1393 if (len
> BGP_MAX_HOSTNAME
)
1394 len
= BGP_MAX_HOSTNAME
;
1396 stream_putc(s
, len
);
1397 stream_put(s
, names
.nodename
, len
);
1398 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1399 if ((names
.domainname
[0] != '\0') &&
1400 (strcmp(names
.domainname
, "(none)") != 0))
1402 len
= strlen(names
.domainname
);
1403 if (len
> BGP_MAX_HOSTNAME
)
1404 len
= BGP_MAX_HOSTNAME
;
1406 stream_putc(s
, len
);
1407 stream_put(s
, names
.domainname
, len
);
1412 stream_putc(s
, 0); /* 0 length */
1415 /* Set the lengths straight */
1416 len
= stream_get_endp(s
) - rcapp
- 1;
1417 stream_putc_at(s
, rcapp
, len
);
1418 len
= stream_get_endp(s
) - capp
- 1;
1419 stream_putc_at(s
, capp
, len
);
1421 if (bgp_debug_neighbor_events(peer
))
1422 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1423 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1424 peer
->host
, names
.nodename
, names
.domainname
);
1426 zlog_debug("%s Sending hostname cap with hn = %s", peer
->host
,
1431 /* Sending base graceful-restart capability irrespective of the config */
1432 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1433 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1434 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1435 stream_putc (s
, 0); /* Capability Length */
1436 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1437 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1439 restart_time
= peer
->bgp
->restart_time
;
1440 if (peer
->bgp
->t_startup
)
1442 SET_FLAG (restart_time
, RESTART_R_BIT
);
1443 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1445 stream_putw (s
, restart_time
);
1447 /* Send address-family specific graceful-restart capability only when GR config
1449 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1451 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1452 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1453 if (peer
->afc
[afi
][safi
])
1455 /* Convert AFI, SAFI to values for packet. */
1456 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1457 stream_putw (s
, pkt_afi
);
1458 stream_putc (s
, pkt_safi
);
1459 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
1460 stream_putc (s
, RESTART_F_BIT
);
1466 /* Total Graceful restart capability Len. */
1467 len
= stream_get_endp (s
) - rcapp
- 1;
1468 stream_putc_at (s
, rcapp
, len
);
1470 /* Total Capability Len. */
1471 len
= stream_get_endp (s
) - capp
- 1;
1472 stream_putc_at (s
, capp
, len
);
1474 /* Total Opt Parm Len. */
1475 len
= stream_get_endp (s
) - cp
- 1;
1476 stream_putc_at (s
, cp
, len
);