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
);
194 /* Verify length is 4 */
195 if (hdr
->length
!= 4)
197 zlog_warn("MP Cap: Received invalid length %d, non-multiple of 4",
202 bgp_capability_mp_data (s
, &mpc
);
204 if (bgp_debug_neighbor_events(peer
))
205 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
206 peer
->host
, mpc
.afi
, mpc
.safi
);
208 /* Convert AFI, SAFI to internal values, check. */
209 if (bgp_map_afi_safi_iana2int (mpc
.afi
, mpc
.safi
, &afi
, &safi
))
212 /* Now safi remapped, and afi/safi are valid array indices */
213 peer
->afc_recv
[afi
][safi
] = 1;
215 if (peer
->afc
[afi
][safi
])
216 peer
->afc_nego
[afi
][safi
] = 1;
224 bgp_capability_orf_not_support (struct peer
*peer
, iana_afi_t afi
, safi_t safi
,
225 u_char type
, u_char mode
)
227 if (bgp_debug_neighbor_events(peer
))
228 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
229 peer
->host
, afi
, safi
, type
, mode
);
232 static const struct message orf_type_str
[] =
234 { ORF_TYPE_PREFIX
, "Prefixlist" },
235 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
237 static const int orf_type_str_max
= array_size(orf_type_str
);
239 static const struct message orf_mode_str
[] =
241 { ORF_MODE_RECEIVE
, "Receive" },
242 { ORF_MODE_SEND
, "Send" },
243 { ORF_MODE_BOTH
, "Both" },
245 static const int orf_mode_str_max
= array_size(orf_mode_str
);
248 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
250 struct stream
*s
= BGP_INPUT (peer
);
251 struct capability_orf_entry entry
;
254 safi_t pkt_safi
, safi
;
257 u_int16_t sm_cap
= 0; /* capability send-mode receive */
258 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
261 /* ORF Entry header */
262 bgp_capability_mp_data (s
, &entry
.mpc
);
263 entry
.num
= stream_getc (s
);
264 pkt_afi
= entry
.mpc
.afi
;
265 pkt_safi
= entry
.mpc
.safi
;
267 if (bgp_debug_neighbor_events(peer
))
268 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
269 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
271 /* Convert AFI, SAFI to internal values, check. */
272 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
274 zlog_info ("%s Addr-family %d/%d not supported."
275 " Ignoring the ORF capability",
276 peer
->host
, pkt_afi
, pkt_safi
);
280 entry
.mpc
.afi
= pkt_afi
;
281 entry
.mpc
.safi
= safi
;
283 /* validate number field */
284 if (CAPABILITY_CODE_ORF_LEN
+ (entry
.num
* 2) > hdr
->length
)
286 zlog_info ("%s ORF Capability entry length error,"
287 " Cap length %u, num %u",
288 peer
->host
, hdr
->length
, entry
.num
);
289 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
293 for (i
= 0 ; i
< entry
.num
; i
++)
295 type
= stream_getc(s
);
296 mode
= stream_getc(s
);
298 /* ORF Mode error check */
303 case ORF_MODE_RECEIVE
:
306 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
309 /* ORF Type and afi/safi error checks */
310 /* capcode versus type */
313 case CAPABILITY_CODE_ORF
:
316 case ORF_TYPE_PREFIX
:
319 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
323 case CAPABILITY_CODE_ORF_OLD
:
326 case ORF_TYPE_PREFIX_OLD
:
329 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
334 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
339 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
340 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
341 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
343 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
347 if (bgp_debug_neighbor_events(peer
))
348 zlog_debug ("%s OPEN has %s ORF capability"
349 " as %s for afi/safi: %d/%d",
350 peer
->host
, LOOKUP (orf_type_str
, type
),
351 LOOKUP (orf_mode_str
, mode
),
354 if (hdr
->code
== CAPABILITY_CODE_ORF
)
356 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
357 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
359 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
361 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
362 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
366 bgp_capability_orf_not_support (peer
, pkt_afi
, pkt_safi
, type
, mode
);
373 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
374 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
377 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
379 case ORF_MODE_RECEIVE
:
380 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
388 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
390 struct stream
*s
= BGP_INPUT (peer
);
391 u_int16_t restart_flag_time
;
392 size_t end
= stream_get_getp (s
) + caphdr
->length
;
394 /* Verify length is a multiple of 4 */
395 if ((caphdr
->length
-2) % 4)
397 zlog_warn("Restart Cap: Received invalid length %d, non-multiple of 4",
402 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
403 restart_flag_time
= stream_getw(s
);
404 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
405 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
);
407 UNSET_FLAG (restart_flag_time
, 0xF000);
408 peer
->v_gr_restart
= restart_flag_time
;
410 if (bgp_debug_neighbor_events(peer
))
412 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
413 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
415 CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_RCV
) ? " "
420 while (stream_get_getp (s
) + 4 <= end
)
424 iana_afi_t pkt_afi
= stream_getw (s
);
425 safi_t pkt_safi
= stream_getc (s
);
426 u_char flag
= stream_getc (s
);
428 /* Convert AFI, SAFI to internal values, check. */
429 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
431 if (bgp_debug_neighbor_events(peer
))
432 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
433 " Ignore the Graceful Restart capability for this AFI/SAFI",
434 peer
->host
, pkt_afi
, pkt_safi
);
436 else if (!peer
->afc
[afi
][safi
])
438 if (bgp_debug_neighbor_events(peer
))
439 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
440 " Ignore the Graceful Restart capability",
441 peer
->host
, pkt_afi
, pkt_safi
);
445 if (bgp_debug_neighbor_events(peer
))
446 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
447 afi_safi_print (afi
, safi
),
448 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
449 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
452 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
453 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
454 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
461 /* Unlike other capability parsing routines, this one returns 0 on error */
463 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
465 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
467 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
469 zlog_err ("%s AS4 capability has incorrect data length %d",
470 peer
->host
, hdr
->length
);
474 as_t as4
= stream_getl (BGP_INPUT(peer
));
476 if (BGP_DEBUG (as4
, AS4
))
477 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
483 bgp_capability_addpath (struct peer
*peer
, struct capability_header
*hdr
)
485 struct stream
*s
= BGP_INPUT (peer
);
486 size_t end
= stream_get_getp (s
) + hdr
->length
;
488 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_RCV
);
490 /* Verify length is a multiple of 4 */
493 zlog_warn("Add Path: Received invalid length %d, non-multiple of 4",
498 while (stream_get_getp (s
) + 4 <= end
)
502 iana_afi_t pkt_afi
= stream_getw (s
);
503 safi_t pkt_safi
= stream_getc (s
);
504 u_char send_receive
= stream_getc (s
);
506 if (bgp_debug_neighbor_events(peer
))
507 zlog_debug ("%s OPEN has AddPath CAP for afi/safi: %u/%u%s%s",
508 peer
->host
, pkt_afi
, pkt_safi
,
509 (send_receive
& BGP_ADDPATH_RX
) ? ", receive" : "",
510 (send_receive
& BGP_ADDPATH_TX
) ? ", transmit" : "");
512 /* Convert AFI, SAFI to internal values, check. */
513 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &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
, pkt_afi
, pkt_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
, pkt_afi
, pkt_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 iana_afi_t pkt_afi
= stream_getw (s
);
558 safi_t safi
, pkt_safi
= stream_getw (s
);
559 iana_afi_t pkt_nh_afi
= stream_getw (s
);
562 if (bgp_debug_neighbor_events(peer
))
563 zlog_debug ("%s Received with afi/safi/next-hop afi: %u/%u/%u",
564 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
566 /* Convert AFI, SAFI to internal values, check. */
567 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
569 if (bgp_debug_neighbor_events(peer
))
570 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
571 " Ignore the ENHE Attribute for this AFI/SAFI",
572 peer
->host
, pkt_afi
, pkt_safi
);
576 /* RFC 5549 specifies use of this capability only for IPv4 AFI, with
577 * the Nexthop AFI being IPv6. A future spec may introduce other
578 * possibilities, so we ignore other values with a log. Also, only
579 * Unicast SAFI is currently supported (and expected).
581 nh_afi
= afi_iana2int (pkt_nh_afi
);
583 if (afi
!= AFI_IP
|| safi
!= SAFI_UNICAST
|| nh_afi
!= AFI_IP6
)
585 zlog_warn ("%s Unexpected afi/safi/next-hop afi: %u/%u/%u "
586 "in Extended Next-hop capability, ignoring",
587 peer
->host
, pkt_afi
, pkt_safi
, pkt_nh_afi
);
591 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_RCV
);
593 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_ADV
))
594 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ENHE_AF_NEGO
);
597 SET_FLAG (peer
->cap
, PEER_CAP_ENHE_RCV
);
603 bgp_capability_hostname (struct peer
*peer
, struct capability_header
*hdr
)
605 struct stream
*s
= BGP_INPUT (peer
);
606 char str
[BGP_MAX_HOSTNAME
+1];
607 size_t end
= stream_get_getp (s
) + hdr
->length
;
610 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_RCV
);
612 len
= stream_getc(s
);
613 if (stream_get_getp(s
) + len
> end
)
615 zlog_warn("%s: Received malformed hostname capability from peer %s",
616 __FUNCTION__
, peer
->host
);
620 if (len
> BGP_MAX_HOSTNAME
)
622 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
623 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
624 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
627 stream_get(str
, s
, len
);
633 if (peer
->hostname
!= NULL
)
635 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
636 peer
->hostname
= NULL
;
639 if (peer
->domainname
!= NULL
)
641 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
642 peer
->domainname
= NULL
;
645 peer
->hostname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
648 if (stream_get_getp(s
) +1 > end
)
650 zlog_warn("%s: Received invalid domain name len (hostname capability) from peer %s",
651 __FUNCTION__
, peer
->host
);
655 len
= stream_getc(s
);
656 if (stream_get_getp(s
) + len
> end
)
658 zlog_warn("%s: Received runt domain name (hostname capability) from peer %s",
659 __FUNCTION__
, peer
->host
);
663 if (len
> BGP_MAX_HOSTNAME
)
665 stream_get(str
, s
, BGP_MAX_HOSTNAME
);
666 stream_forward_getp(s
, len
-BGP_MAX_HOSTNAME
);
667 len
= BGP_MAX_HOSTNAME
; /* to set the '\0' below */
670 stream_get(str
, s
, len
);
675 peer
->domainname
= XSTRDUP(MTYPE_BGP_PEER_HOST
, str
);
678 if (bgp_debug_neighbor_events(peer
))
680 zlog_debug("%s received hostname %s, domainname %s",
681 peer
->host
, peer
->hostname
, peer
->domainname
);
687 static const struct message capcode_str
[] =
689 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
690 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
691 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
692 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
693 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
694 { CAPABILITY_CODE_ADDPATH
, "AddPath" },
695 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
696 { CAPABILITY_CODE_ENHE
, "Extended Next Hop Encoding" },
697 { CAPABILITY_CODE_DYNAMIC_OLD
, "Dynamic (Old)" },
698 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
699 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
700 { CAPABILITY_CODE_FQDN
, "FQDN" },
702 static const int capcode_str_max
= array_size(capcode_str
);
704 /* Minimum sizes for length field of each cap (so not inc. the header) */
705 static const size_t cap_minsizes
[] =
707 [CAPABILITY_CODE_MP
] = CAPABILITY_CODE_MP_LEN
,
708 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
709 [CAPABILITY_CODE_ORF
] = CAPABILITY_CODE_ORF_LEN
,
710 [CAPABILITY_CODE_RESTART
] = CAPABILITY_CODE_RESTART_LEN
,
711 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
712 [CAPABILITY_CODE_ADDPATH
] = CAPABILITY_CODE_ADDPATH_LEN
,
713 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
714 [CAPABILITY_CODE_DYNAMIC_OLD
] = CAPABILITY_CODE_DYNAMIC_LEN
,
715 [CAPABILITY_CODE_ENHE
] = CAPABILITY_CODE_ENHE_LEN
,
716 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
717 [CAPABILITY_CODE_ORF_OLD
] = CAPABILITY_CODE_ORF_LEN
,
718 [CAPABILITY_CODE_FQDN
] = CAPABILITY_CODE_MIN_FQDN_LEN
,
721 /* value the capability must be a multiple of.
722 * 0-data capabilities won't be checked against this.
723 * Other capabilities whose data doesn't fall on convenient boundaries for this
724 * table should be set to 1.
726 static const size_t cap_modsizes
[] =
728 [CAPABILITY_CODE_MP
] = 4,
729 [CAPABILITY_CODE_REFRESH
] = 1,
730 [CAPABILITY_CODE_ORF
] = 1,
731 [CAPABILITY_CODE_RESTART
] = 1,
732 [CAPABILITY_CODE_AS4
] = 4,
733 [CAPABILITY_CODE_ADDPATH
] = 4,
734 [CAPABILITY_CODE_DYNAMIC
] = 1,
735 [CAPABILITY_CODE_DYNAMIC_OLD
] = 1,
736 [CAPABILITY_CODE_ENHE
] = 6,
737 [CAPABILITY_CODE_REFRESH_OLD
] = 1,
738 [CAPABILITY_CODE_ORF_OLD
] = 1,
739 [CAPABILITY_CODE_FQDN
] = 1,
743 * Parse given capability.
744 * XXX: This is reading into a stream, but not using stream API
746 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
747 * capabilities were encountered.
750 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
754 struct stream
*s
= BGP_INPUT (peer
);
755 size_t end
= stream_get_getp (s
) + length
;
757 assert (STREAM_READABLE (s
) >= length
);
759 while (stream_get_getp (s
) < end
)
762 u_char
*sp
= stream_pnt (s
);
763 struct capability_header caphdr
;
766 /* We need at least capability code and capability length. */
767 if (stream_get_getp(s
) + 2 > end
)
769 zlog_info ("%s Capability length error (< header)", peer
->host
);
770 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
774 caphdr
.code
= stream_getc (s
);
775 caphdr
.length
= stream_getc (s
);
776 start
= stream_get_getp (s
);
778 /* Capability length check sanity check. */
779 if (start
+ caphdr
.length
> end
)
781 zlog_info ("%s Capability length error (< length)", peer
->host
);
782 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
786 if (bgp_debug_neighbor_events(peer
))
787 zlog_debug ("%s OPEN has %s capability (%u), length %u",
789 LOOKUP (capcode_str
, caphdr
.code
),
790 caphdr
.code
, caphdr
.length
);
792 /* Length sanity check, type-specific, for known capabilities */
795 case CAPABILITY_CODE_MP
:
796 case CAPABILITY_CODE_REFRESH
:
797 case CAPABILITY_CODE_REFRESH_OLD
:
798 case CAPABILITY_CODE_ORF
:
799 case CAPABILITY_CODE_ORF_OLD
:
800 case CAPABILITY_CODE_RESTART
:
801 case CAPABILITY_CODE_AS4
:
802 case CAPABILITY_CODE_ADDPATH
:
803 case CAPABILITY_CODE_DYNAMIC
:
804 case CAPABILITY_CODE_DYNAMIC_OLD
:
805 case CAPABILITY_CODE_ENHE
:
806 case CAPABILITY_CODE_FQDN
:
808 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
810 zlog_info ("%s %s Capability length error: got %u,"
811 " expected at least %u",
813 LOOKUP (capcode_str
, caphdr
.code
),
815 (unsigned) cap_minsizes
[caphdr
.code
]);
816 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
820 && caphdr
.length
% cap_modsizes
[caphdr
.code
] != 0)
822 zlog_info ("%s %s Capability length error: got %u,"
823 " expected a multiple of %u",
825 LOOKUP (capcode_str
, caphdr
.code
),
827 (unsigned) cap_modsizes
[caphdr
.code
]);
828 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
829 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
832 /* we deliberately ignore unknown codes, see below */
839 case CAPABILITY_CODE_MP
:
843 /* Ignore capability when override-capability is set. */
844 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
846 /* Set negotiated value. */
847 ret
= bgp_capability_mp (peer
, &caphdr
);
849 /* Unsupported Capability. */
852 /* Store return data. */
853 memcpy (*error
, sp
, caphdr
.length
+ 2);
854 *error
+= caphdr
.length
+ 2;
856 ret
= 0; /* Don't return error for this */
860 case CAPABILITY_CODE_REFRESH
:
861 case CAPABILITY_CODE_REFRESH_OLD
:
863 /* BGP refresh capability */
864 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
865 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
867 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
870 case CAPABILITY_CODE_ORF
:
871 case CAPABILITY_CODE_ORF_OLD
:
872 ret
= bgp_capability_orf_entry (peer
, &caphdr
);
874 case CAPABILITY_CODE_RESTART
:
875 ret
= bgp_capability_restart (peer
, &caphdr
);
877 case CAPABILITY_CODE_DYNAMIC
:
878 case CAPABILITY_CODE_DYNAMIC_OLD
:
879 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
881 case CAPABILITY_CODE_AS4
:
882 /* Already handled as a special-case parsing of the capabilities
883 * at the beginning of OPEN processing. So we care not a jot
884 * for the value really, only error case.
886 if (!bgp_capability_as4 (peer
, &caphdr
))
889 case CAPABILITY_CODE_ADDPATH
:
890 ret
= bgp_capability_addpath (peer
, &caphdr
);
892 case CAPABILITY_CODE_ENHE
:
893 ret
= bgp_capability_enhe (peer
, &caphdr
);
895 case CAPABILITY_CODE_FQDN
:
896 ret
= bgp_capability_hostname (peer
, &caphdr
);
899 if (caphdr
.code
> 128)
901 /* We don't send Notification for unknown vendor specific
902 capabilities. It seems reasonable for now... */
903 zlog_warn ("%s Vendor specific capability %d",
904 peer
->host
, caphdr
.code
);
908 zlog_warn ("%s unrecognized capability code: %d - ignored",
909 peer
->host
, caphdr
.code
);
910 memcpy (*error
, sp
, caphdr
.length
+ 2);
911 *error
+= caphdr
.length
+ 2;
917 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
920 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
922 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
923 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
924 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
926 stream_set_getp (s
, start
+ caphdr
.length
);
933 bgp_auth_parse (struct peer
*peer
, size_t length
)
935 bgp_notify_send (peer
,
937 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
942 strict_capability_same (struct peer
*peer
)
946 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
947 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
948 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
953 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
954 * Returns 0 if no as4 found, as4cap value otherwise.
957 peek_for_as4_capability (struct peer
*peer
, u_char length
)
959 struct stream
*s
= BGP_INPUT (peer
);
960 size_t orig_getp
= stream_get_getp (s
);
961 size_t end
= orig_getp
+ length
;
964 if (BGP_DEBUG (as4
, AS4
))
965 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
968 /* the error cases we DONT handle, we ONLY try to read as4 out of
969 * correctly formatted options.
971 while (stream_get_getp(s
) < end
)
976 /* Check the length. */
977 if (stream_get_getp (s
) + 2 > end
)
980 /* Fetch option type and length. */
981 opt_type
= stream_getc (s
);
982 opt_length
= stream_getc (s
);
984 /* Option length check. */
985 if (stream_get_getp (s
) + opt_length
> end
)
988 if (opt_type
== BGP_OPEN_OPT_CAP
)
990 unsigned long capd_start
= stream_get_getp (s
);
991 unsigned long capd_end
= capd_start
+ opt_length
;
993 assert (capd_end
<= end
);
995 while (stream_get_getp (s
) < capd_end
)
997 struct capability_header hdr
;
999 if (stream_get_getp (s
) + 2 > capd_end
)
1002 hdr
.code
= stream_getc (s
);
1003 hdr
.length
= stream_getc (s
);
1005 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
1008 if (hdr
.code
== CAPABILITY_CODE_AS4
)
1010 if (BGP_DEBUG (as4
, AS4
))
1011 zlog_info ("[AS4] found AS4 capability, about to parse");
1012 as4
= bgp_capability_as4 (peer
, &hdr
);
1016 stream_forward_getp (s
, hdr
.length
);
1022 stream_set_getp (s
, orig_getp
);
1027 * Parse open option.
1029 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
1032 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
1036 u_char error_data
[BGP_MAX_PACKET_SIZE
];
1037 struct stream
*s
= BGP_INPUT(peer
);
1038 size_t end
= stream_get_getp (s
) + length
;
1042 if (bgp_debug_neighbor_events(peer
))
1043 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
1044 peer
->host
, length
);
1046 while (stream_get_getp(s
) < end
)
1051 /* Must have at least an OPEN option header */
1052 if (STREAM_READABLE(s
) < 2)
1054 zlog_info ("%s Option length error", peer
->host
);
1055 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1059 /* Fetch option type and length. */
1060 opt_type
= stream_getc (s
);
1061 opt_length
= stream_getc (s
);
1063 /* Option length check. */
1064 if (STREAM_READABLE (s
) < opt_length
)
1066 zlog_info ("%s Option length error", peer
->host
);
1067 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
, BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1071 if (bgp_debug_neighbor_events(peer
))
1072 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
1073 peer
->host
, opt_type
,
1074 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
1075 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
1080 case BGP_OPEN_OPT_AUTH
:
1081 ret
= bgp_auth_parse (peer
, opt_length
);
1083 case BGP_OPEN_OPT_CAP
:
1084 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
1087 bgp_notify_send (peer
,
1088 BGP_NOTIFY_OPEN_ERR
,
1089 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
1094 /* Parse error. To accumulate all unsupported capability codes,
1095 bgp_capability_parse does not return -1 when encounter
1096 unsupported capability code. To detect that, please check
1097 error and erro_data pointer, like below. */
1102 /* All OPEN option is parsed. Check capability when strict compare
1104 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
1106 /* If Unsupported Capability exists. */
1107 if (error
!= error_data
)
1109 bgp_notify_send_with_data (peer
,
1110 BGP_NOTIFY_OPEN_ERR
,
1111 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1112 error_data
, error
- error_data
);
1116 /* Check local capability does not negotiated with remote
1118 if (! strict_capability_same (peer
))
1120 bgp_notify_send (peer
,
1121 BGP_NOTIFY_OPEN_ERR
,
1122 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1127 /* Check there are no common AFI/SAFIs and send Unsupported Capability
1129 if (*mp_capability
&&
1130 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1132 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1133 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1134 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1135 && ! peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
1136 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1137 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1138 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1139 && ! peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
1141 zlog_err ("%s [Error] Configured AFI/SAFIs do not "
1142 "overlap with received MP capabilities",
1145 if (error
!= error_data
)
1146 bgp_notify_send_with_data (peer
,
1147 BGP_NOTIFY_OPEN_ERR
,
1148 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
1149 error_data
, error
- error_data
);
1151 bgp_notify_send (peer
,
1152 BGP_NOTIFY_OPEN_ERR
,
1153 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
1161 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
1162 afi_t afi
, safi_t safi
, u_char code
)
1168 unsigned long numberp
;
1169 int number_of_orfs
= 0;
1173 /* Convert AFI, SAFI to values for packet. */
1174 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1176 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1177 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1178 stream_putc (s
, 0); /* Capability Length */
1179 stream_putc (s
, code
); /* Capability Code */
1180 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
1181 stream_putc (s
, 0); /* ORF Length */
1182 stream_putw (s
, pkt_afi
);
1184 stream_putc (s
, pkt_safi
);
1185 numberp
= stream_get_endp (s
); /* Set Number Pointer */
1186 stream_putc (s
, 0); /* Number of ORFs */
1188 /* Address Prefix ORF */
1189 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1190 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1192 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
1193 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
1195 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1196 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1198 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1199 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1200 stream_putc (s
, ORF_MODE_BOTH
);
1202 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
1204 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
1205 stream_putc (s
, ORF_MODE_SEND
);
1209 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
1210 stream_putc (s
, ORF_MODE_RECEIVE
);
1215 /* Total Number of ORFs. */
1216 stream_putc_at (s
, numberp
, number_of_orfs
);
1218 /* Total ORF Len. */
1219 orf_len
= stream_get_endp (s
) - orfp
- 1;
1220 stream_putc_at (s
, orfp
, orf_len
);
1222 /* Total Capability Len. */
1223 cap_len
= stream_get_endp (s
) - capp
- 1;
1224 stream_putc_at (s
, capp
, cap_len
);
1227 /* Fill in capability open option to the packet. */
1229 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
1232 unsigned long cp
, capp
, rcapp
;
1235 safi_t safi
, pkt_safi
;
1237 u_int32_t restart_time
;
1238 u_char afi_safi_count
= 0;
1239 struct utsname names
;
1240 int adv_addpath_tx
= 0;
1242 /* Remember current pointer for Opt Parm Len. */
1243 cp
= stream_get_endp (s
);
1248 /* Do not send capability. */
1249 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
1250 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
1253 /* MP capability for configured AFI, SAFI */
1254 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1255 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1257 if (peer
->afc
[afi
][safi
])
1259 /* Convert AFI, SAFI to values for packet. */
1260 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1262 peer
->afc_adv
[afi
][safi
] = 1;
1263 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1264 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
1265 stream_putc (s
, CAPABILITY_CODE_MP
);
1266 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
1267 stream_putw (s
, pkt_afi
);
1269 stream_putc (s
, pkt_safi
);
1273 /* Extended nexthop capability - currently supporting RFC-5549 for
1274 * 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 /* Route refresh. */
1297 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1298 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1299 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1300 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1301 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1302 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1303 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1304 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1305 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1308 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1309 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1310 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1311 stream_putc (s
, CAPABILITY_CODE_AS4
);
1312 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1313 if ( peer
->change_local_as
)
1314 local_as
= peer
->change_local_as
;
1316 local_as
= peer
->local_as
;
1317 stream_putl (s
, local_as
);
1320 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1321 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1322 if (peer
->afc
[afi
][safi
])
1326 /* Only advertise addpath TX if a feature that will use it is
1328 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
1329 CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
1333 SET_FLAG (peer
->cap
, PEER_CAP_ADDPATH_ADV
);
1334 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1335 stream_putc (s
, (CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
) + 2);
1336 stream_putc (s
, CAPABILITY_CODE_ADDPATH
);
1337 stream_putc (s
, CAPABILITY_CODE_ADDPATH_LEN
* afi_safi_count
);
1339 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1340 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1341 if (peer
->afc
[afi
][safi
])
1343 /* Convert AFI, SAFI to values for packet. */
1344 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1346 stream_putw (s
, pkt_afi
);
1347 stream_putc (s
, pkt_safi
);
1351 stream_putc (s
, BGP_ADDPATH_RX
|BGP_ADDPATH_TX
);
1352 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1353 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1357 stream_putc (s
, BGP_ADDPATH_RX
);
1358 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
);
1359 UNSET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
);
1363 /* ORF capability. */
1364 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1365 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1366 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1367 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1369 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1370 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1373 /* Dynamic capability. */
1374 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1376 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1377 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1378 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1379 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_OLD
);
1380 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1381 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1382 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1383 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1384 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1387 /* Hostname capability */
1389 if (names
.nodename
[0] != '\0')
1391 SET_FLAG(peer
->cap
, PEER_CAP_HOSTNAME_ADV
);
1392 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1393 rcapp
= stream_get_endp(s
); /* Ptr to length placeholder */
1394 stream_putc(s
, 0); /* dummy len for now */
1395 stream_putc (s
, CAPABILITY_CODE_FQDN
);
1396 capp
= stream_get_endp(s
);
1397 stream_putc(s
, 0); /* dummy len for now */
1398 len
= strlen(names
.nodename
);
1399 if (len
> BGP_MAX_HOSTNAME
)
1400 len
= BGP_MAX_HOSTNAME
;
1402 stream_putc(s
, len
);
1403 stream_put(s
, names
.nodename
, len
);
1404 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1405 if ((names
.domainname
[0] != '\0') &&
1406 (strcmp(names
.domainname
, "(none)") != 0))
1408 len
= strlen(names
.domainname
);
1409 if (len
> BGP_MAX_HOSTNAME
)
1410 len
= BGP_MAX_HOSTNAME
;
1412 stream_putc(s
, len
);
1413 stream_put(s
, names
.domainname
, len
);
1418 stream_putc(s
, 0); /* 0 length */
1421 /* Set the lengths straight */
1422 len
= stream_get_endp(s
) - rcapp
- 1;
1423 stream_putc_at(s
, rcapp
, len
);
1424 len
= stream_get_endp(s
) - capp
- 1;
1425 stream_putc_at(s
, capp
, len
);
1427 if (bgp_debug_neighbor_events(peer
))
1428 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
1429 zlog_debug("%s Sending hostname cap with hn = %s, dn = %s",
1430 peer
->host
, names
.nodename
, names
.domainname
);
1432 zlog_debug("%s Sending hostname cap with hn = %s", peer
->host
,
1437 /* Sending base graceful-restart capability irrespective of the config */
1438 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1439 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1440 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
1441 stream_putc (s
, 0); /* Capability Length */
1442 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1443 rcapp
= stream_get_endp (s
); /* Set Restart Capability Len Pointer */
1445 restart_time
= peer
->bgp
->restart_time
;
1446 if (peer
->bgp
->t_startup
)
1448 SET_FLAG (restart_time
, RESTART_R_BIT
);
1449 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_BIT_ADV
);
1451 stream_putw (s
, restart_time
);
1453 /* Send address-family specific graceful-restart capability only when GR config
1455 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1457 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1458 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1459 if (peer
->afc
[afi
][safi
])
1461 /* Convert AFI, SAFI to values for packet. */
1462 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
1463 stream_putw (s
, pkt_afi
);
1464 stream_putc (s
, pkt_safi
);
1465 if (bgp_flag_check(peer
->bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
1466 stream_putc (s
, RESTART_F_BIT
);
1472 /* Total Graceful restart capability Len. */
1473 len
= stream_get_endp (s
) - rcapp
- 1;
1474 stream_putc_at (s
, rcapp
, len
);
1476 /* Total Capability Len. */
1477 len
= stream_get_endp (s
) - capp
- 1;
1478 stream_putc_at (s
, capp
, len
);
1480 /* Total Opt Parm Len. */
1481 len
= stream_get_endp (s
) - cp
- 1;
1482 stream_putc_at (s
, cp
, len
);