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
31 #include "bgpd/bgpd.h"
32 #include "bgpd/bgp_attr.h"
33 #include "bgpd/bgp_debug.h"
34 #include "bgpd/bgp_fsm.h"
35 #include "bgpd/bgp_packet.h"
36 #include "bgpd/bgp_open.h"
37 #include "bgpd/bgp_aspath.h"
38 #include "bgpd/bgp_vty.h"
40 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
41 negotiate remote peer supports extentions or not. But if
42 remote-peer doesn't supports negotiation process itself. We would
43 like to do manual configuration.
45 So there is many configurable point. First of all we want set each
46 peer whether we send capability negotiation to the peer or not.
47 Next, if we send capability to the peer we want to set my capabilty
48 inforation at each peer. */
51 bgp_capability_vty_out (struct vty
*vty
, struct peer
*peer
)
55 struct capability_mp_data mpc
;
56 struct capability_header
*hdr
;
58 pnt
= peer
->notify
.data
;
59 end
= pnt
+ peer
->notify
.length
;
63 if (pnt
+ sizeof (struct capability_mp_data
) + 2 > end
)
66 hdr
= (struct capability_header
*)pnt
;
67 if (pnt
+ hdr
->length
+ 2 > end
)
70 memcpy (&mpc
, pnt
+ 2, sizeof(struct capability_mp_data
));
72 if (hdr
->code
== CAPABILITY_CODE_MP
)
74 vty_out (vty
, " Capability error for: Multi protocol ");
76 switch (ntohs (mpc
.afi
))
79 vty_out (vty
, "AFI IPv4, ");
82 vty_out (vty
, "AFI IPv6, ");
85 vty_out (vty
, "AFI Unknown %d, ", ntohs (mpc
.afi
));
91 vty_out (vty
, "SAFI Unicast");
94 vty_out (vty
, "SAFI Multicast");
96 case SAFI_MPLS_LABELED_VPN
:
97 vty_out (vty
, "SAFI MPLS-labeled VPN");
100 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
103 vty_out (vty
, "%s", VTY_NEWLINE
);
105 else if (hdr
->code
>= 128)
106 vty_out (vty
, " Capability error: vendor specific capability code %d",
109 vty_out (vty
, " Capability error: unknown capability code %d",
112 pnt
+= hdr
->length
+ 2;
117 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
119 mpc
->afi
= stream_getw (s
);
120 mpc
->reserved
= stream_getc (s
);
121 mpc
->safi
= stream_getc (s
);
125 bgp_afi_safi_valid_indices (afi_t afi
, safi_t
*safi
)
135 /* BGP MPLS-labeled VPN SAFI isn't contigious with others, remap */
136 case SAFI_MPLS_LABELED_VPN
:
137 *safi
= SAFI_MPLS_VPN
;
144 zlog_debug ("unknown afi/safi (%u/%u)", afi
, *safi
);
149 /* Set negotiated capability value. */
151 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
153 struct capability_mp_data mpc
;
154 struct stream
*s
= BGP_INPUT (peer
);
156 bgp_capability_mp_data (s
, &mpc
);
158 if (BGP_DEBUG (normal
, NORMAL
))
159 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
160 peer
->host
, mpc
.afi
, mpc
.safi
);
162 if (!bgp_afi_safi_valid_indices (mpc
.afi
, &mpc
.safi
))
165 /* Now safi remapped, and afi/safi are valid array indices */
166 peer
->afc_recv
[mpc
.afi
][mpc
.safi
] = 1;
168 if (peer
->afc
[mpc
.afi
][mpc
.safi
])
169 peer
->afc_nego
[mpc
.afi
][mpc
.safi
] = 1;
177 bgp_capability_orf_not_support (struct peer
*peer
, afi_t afi
, safi_t safi
,
178 u_char type
, u_char mode
)
180 if (BGP_DEBUG (normal
, NORMAL
))
181 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
182 peer
->host
, afi
, safi
, type
, mode
);
185 static const struct message orf_type_str
[] =
187 { ORF_TYPE_PREFIX
, "Prefixlist" },
188 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
190 static const int orf_type_str_max
191 = sizeof(orf_type_str
)/sizeof(orf_type_str
[0]);
193 static const struct message orf_mode_str
[] =
195 { ORF_MODE_RECEIVE
, "Receive" },
196 { ORF_MODE_SEND
, "Send" },
197 { ORF_MODE_BOTH
, "Both" },
199 static const int orf_mode_str_max
200 = sizeof(orf_mode_str
)/sizeof(orf_mode_str
[0]);
203 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
205 struct stream
*s
= BGP_INPUT (peer
);
206 struct capability_orf_entry entry
;
211 u_int16_t sm_cap
= 0; /* capability send-mode receive */
212 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
215 /* ORF Entry header */
216 bgp_capability_mp_data (s
, &entry
.mpc
);
217 entry
.num
= stream_getc (s
);
219 safi
= entry
.mpc
.safi
;
221 if (BGP_DEBUG (normal
, NORMAL
))
222 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
223 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
225 /* Check AFI and SAFI. */
226 if (!bgp_afi_safi_valid_indices (entry
.mpc
.afi
, &safi
))
228 zlog_info ("%s Addr-family %d/%d not supported."
229 " Ignoring the ORF capability",
230 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
234 /* validate number field */
235 if (sizeof (struct capability_orf_entry
) + (entry
.num
* 2) > hdr
->length
)
237 zlog_info ("%s ORF Capability entry length error,"
238 " Cap length %u, num %u",
239 peer
->host
, hdr
->length
, entry
.num
);
240 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
244 for (i
= 0 ; i
< entry
.num
; i
++)
246 type
= stream_getc(s
);
247 mode
= stream_getc(s
);
249 /* ORF Mode error check */
254 case ORF_MODE_RECEIVE
:
257 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
260 /* ORF Type and afi/safi error checks */
261 /* capcode versus type */
264 case CAPABILITY_CODE_ORF
:
267 case ORF_TYPE_PREFIX
:
270 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
274 case CAPABILITY_CODE_ORF_OLD
:
277 case ORF_TYPE_PREFIX_OLD
:
280 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
285 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
290 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
291 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
292 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
294 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
298 if (BGP_DEBUG (normal
, NORMAL
))
299 zlog_debug ("%s OPEN has %s ORF capability"
300 " as %s for afi/safi: %d/%d",
301 peer
->host
, LOOKUP (orf_type_str
, type
),
302 LOOKUP (orf_mode_str
, mode
),
303 entry
.mpc
.afi
, safi
);
305 if (hdr
->code
== CAPABILITY_CODE_ORF
)
307 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
308 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
310 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
312 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
313 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
317 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
324 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
325 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
328 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
330 case ORF_MODE_RECEIVE
:
331 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
339 bgp_capability_orf (struct peer
*peer
, struct capability_header
*hdr
)
341 struct stream
*s
= BGP_INPUT (peer
);
342 size_t end
= stream_get_getp (s
) + hdr
->length
;
344 assert (stream_get_getp(s
) + sizeof(struct capability_orf_entry
) <= end
);
346 /* We must have at least one ORF entry, as the caller has already done
347 * minimum length validation for the capability code - for ORF there must
348 * at least one ORF entry (header and unknown number of pairs of bytes).
352 if (bgp_capability_orf_entry (peer
, hdr
) == -1)
355 while (stream_get_getp(s
) + sizeof(struct capability_orf_entry
) < end
);
361 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
363 struct stream
*s
= BGP_INPUT (peer
);
364 u_int16_t restart_flag_time
;
366 size_t end
= stream_get_getp (s
) + caphdr
->length
;
368 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
369 restart_flag_time
= stream_getw(s
);
370 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
372 UNSET_FLAG (restart_flag_time
, 0xF000);
373 peer
->v_gr_restart
= restart_flag_time
;
375 if (BGP_DEBUG (normal
, NORMAL
))
377 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
378 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
379 peer
->host
, restart_bit
? " " : " not ",
383 while (stream_get_getp (s
) + 4 <= end
)
385 afi_t afi
= stream_getw (s
);
386 safi_t safi
= stream_getc (s
);
387 u_char flag
= stream_getc (s
);
389 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
391 if (BGP_DEBUG (normal
, NORMAL
))
392 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
393 " Ignore the Graceful Restart capability",
394 peer
->host
, afi
, safi
);
396 else if (!peer
->afc
[afi
][safi
])
398 if (BGP_DEBUG (normal
, NORMAL
))
399 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
400 " Ignore the Graceful Restart capability",
401 peer
->host
, afi
, safi
);
405 if (BGP_DEBUG (normal
, NORMAL
))
406 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
407 afi_safi_print (afi
, safi
),
408 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
409 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
412 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
413 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
414 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
422 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
424 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
426 if (hdr
->length
!= CAPABILITY_CODE_AS4_LEN
)
428 zlog_err ("%s AS4 capability has incorrect data length %d",
429 peer
->host
, hdr
->length
);
433 as_t as4
= stream_getl (BGP_INPUT(peer
));
435 if (BGP_DEBUG (as4
, AS4
))
436 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
441 static const struct message capcode_str
[] =
443 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
444 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
445 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
446 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
447 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
448 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
449 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
450 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
452 static const int capcode_str_max
= sizeof(capcode_str
)/sizeof(capcode_str
[0]);
454 /* Minimum sizes for length field of each cap (so not inc. the header) */
455 static const size_t cap_minsizes
[] =
457 [CAPABILITY_CODE_MP
] = sizeof (struct capability_mp_data
),
458 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
459 [CAPABILITY_CODE_ORF
] = sizeof (struct capability_orf_entry
),
460 [CAPABILITY_CODE_RESTART
] = sizeof (struct capability_gr
),
461 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
462 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
463 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
464 [CAPABILITY_CODE_ORF_OLD
] = sizeof (struct capability_orf_entry
),
468 * Parse given capability.
469 * XXX: This is reading into a stream, but not using stream API
471 * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
472 * capabilities were encountered.
475 bgp_capability_parse (struct peer
*peer
, size_t length
, int *mp_capability
,
479 struct stream
*s
= BGP_INPUT (peer
);
480 size_t end
= stream_get_getp (s
) + length
;
482 assert (STREAM_READABLE (s
) >= length
);
484 while (stream_get_getp (s
) < end
)
487 u_char
*sp
= stream_pnt (s
);
488 struct capability_header caphdr
;
490 /* We need at least capability code and capability length. */
491 if (stream_get_getp(s
) + 2 > end
)
493 zlog_info ("%s Capability length error (< header)", peer
->host
);
494 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
498 caphdr
.code
= stream_getc (s
);
499 caphdr
.length
= stream_getc (s
);
500 start
= stream_get_getp (s
);
502 /* Capability length check sanity check. */
503 if (start
+ caphdr
.length
> end
)
505 zlog_info ("%s Capability length error (< length)", peer
->host
);
506 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
510 if (BGP_DEBUG (normal
, NORMAL
))
511 zlog_debug ("%s OPEN has %s capability (%u), length %u",
513 LOOKUP (capcode_str
, caphdr
.code
),
514 caphdr
.code
, caphdr
.length
);
516 /* Length sanity check, type-specific, for known capabilities */
519 case CAPABILITY_CODE_MP
:
520 case CAPABILITY_CODE_REFRESH
:
521 case CAPABILITY_CODE_REFRESH_OLD
:
522 case CAPABILITY_CODE_ORF
:
523 case CAPABILITY_CODE_ORF_OLD
:
524 case CAPABILITY_CODE_RESTART
:
525 case CAPABILITY_CODE_AS4
:
526 case CAPABILITY_CODE_DYNAMIC
:
528 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
530 zlog_info ("%s %s Capability length error: got %u,"
531 " expected at least %u",
533 LOOKUP (capcode_str
, caphdr
.code
),
535 (unsigned) cap_minsizes
[caphdr
.code
]);
536 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
539 /* we deliberately ignore unknown codes, see below */
546 case CAPABILITY_CODE_MP
:
550 /* Ignore capability when override-capability is set. */
551 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
553 /* Set negotiated value. */
554 ret
= bgp_capability_mp (peer
, &caphdr
);
556 /* Unsupported Capability. */
559 /* Store return data. */
560 memcpy (*error
, sp
, caphdr
.length
+ 2);
561 *error
+= caphdr
.length
+ 2;
566 case CAPABILITY_CODE_REFRESH
:
567 case CAPABILITY_CODE_REFRESH_OLD
:
569 /* BGP refresh capability */
570 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
571 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
573 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
576 case CAPABILITY_CODE_ORF
:
577 case CAPABILITY_CODE_ORF_OLD
:
578 if (bgp_capability_orf (peer
, &caphdr
))
581 case CAPABILITY_CODE_RESTART
:
582 if (bgp_capability_restart (peer
, &caphdr
))
585 case CAPABILITY_CODE_DYNAMIC
:
586 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
588 case CAPABILITY_CODE_AS4
:
589 /* Already handled as a special-case parsing of the capabilities
590 * at the beginning of OPEN processing. So we care not a jot
591 * for the value really, only error case.
593 if (!bgp_capability_as4 (peer
, &caphdr
))
597 if (caphdr
.code
> 128)
599 /* We don't send Notification for unknown vendor specific
600 capabilities. It seems reasonable for now... */
601 zlog_warn ("%s Vendor specific capability %d",
602 peer
->host
, caphdr
.code
);
606 zlog_warn ("%s unrecognized capability code: %d - ignored",
607 peer
->host
, caphdr
.code
);
608 memcpy (*error
, sp
, caphdr
.length
+ 2);
609 *error
+= caphdr
.length
+ 2;
612 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
614 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
615 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
616 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
618 stream_set_getp (s
, start
+ caphdr
.length
);
625 bgp_auth_parse (struct peer
*peer
, size_t length
)
627 bgp_notify_send (peer
,
629 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
634 strict_capability_same (struct peer
*peer
)
638 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
639 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
640 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
645 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
646 * Returns 0 if no as4 found, as4cap value otherwise.
649 peek_for_as4_capability (struct peer
*peer
, u_char length
)
651 struct stream
*s
= BGP_INPUT (peer
);
652 size_t orig_getp
= stream_get_getp (s
);
653 size_t end
= orig_getp
+ length
;
656 /* The full capability parser will better flag the error.. */
657 if (STREAM_READABLE(s
) < length
)
660 if (BGP_DEBUG (as4
, AS4
))
661 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
664 /* the error cases we DONT handle, we ONLY try to read as4 out of
665 * correctly formatted options.
667 while (stream_get_getp(s
) < end
)
672 /* Check the length. */
673 if (stream_get_getp (s
) + 2 > end
)
676 /* Fetch option type and length. */
677 opt_type
= stream_getc (s
);
678 opt_length
= stream_getc (s
);
680 /* Option length check. */
681 if (stream_get_getp (s
) + opt_length
> end
)
684 if (opt_type
== BGP_OPEN_OPT_CAP
)
686 unsigned long capd_start
= stream_get_getp (s
);
687 unsigned long capd_end
= capd_start
+ opt_length
;
689 assert (capd_end
<= end
);
691 while (stream_get_getp (s
) < capd_end
)
693 struct capability_header hdr
;
695 if (stream_get_getp (s
) + 2 > capd_end
)
698 hdr
.code
= stream_getc (s
);
699 hdr
.length
= stream_getc (s
);
701 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
704 if (hdr
.code
== CAPABILITY_CODE_AS4
)
706 if (BGP_DEBUG (as4
, AS4
))
707 zlog_info ("[AS4] found AS4 capability, about to parse");
708 as4
= bgp_capability_as4 (peer
, &hdr
);
712 stream_forward_getp (s
, hdr
.length
);
718 stream_set_getp (s
, orig_getp
);
725 * @param[out] mp_capability @see bgp_capability_parse() for semantics.
728 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *mp_capability
)
732 u_char error_data
[BGP_MAX_PACKET_SIZE
];
733 struct stream
*s
= BGP_INPUT(peer
);
734 size_t end
= stream_get_getp (s
) + length
;
739 if (BGP_DEBUG (normal
, NORMAL
))
740 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
743 while (stream_get_getp(s
) < end
)
748 /* Must have at least an OPEN option header */
749 if (STREAM_READABLE(s
) < 2)
751 zlog_info ("%s Option length error", peer
->host
);
752 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
756 /* Fetch option type and length. */
757 opt_type
= stream_getc (s
);
758 opt_length
= stream_getc (s
);
760 /* Option length check. */
761 if (STREAM_READABLE (s
) < opt_length
)
763 zlog_info ("%s Option length error", peer
->host
);
764 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
768 if (BGP_DEBUG (normal
, NORMAL
))
769 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
770 peer
->host
, opt_type
,
771 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
772 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
777 case BGP_OPEN_OPT_AUTH
:
778 ret
= bgp_auth_parse (peer
, opt_length
);
780 case BGP_OPEN_OPT_CAP
:
781 ret
= bgp_capability_parse (peer
, opt_length
, mp_capability
, &error
);
784 bgp_notify_send (peer
,
786 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
791 /* Parse error. To accumulate all unsupported capability codes,
792 bgp_capability_parse does not return -1 when encounter
793 unsupported capability code. To detect that, please check
794 error and erro_data pointer, like below. */
799 /* All OPEN option is parsed. Check capability when strict compare
801 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
803 /* If Unsupported Capability exists. */
804 if (error
!= error_data
)
806 bgp_notify_send_with_data (peer
,
808 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
809 error_data
, error
- error_data
);
813 /* Check local capability does not negotiated with remote
815 if (! strict_capability_same (peer
))
817 bgp_notify_send (peer
,
819 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
824 /* Check there are no common AFI/SAFIs and send Unsupported Capability
826 if (*mp_capability
&&
827 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
829 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
830 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
831 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
832 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
833 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
])
835 plog_err (peer
->log
, "%s [Error] Configured AFI/SAFIs do not "
836 "overlap with received MP capabilities",
839 if (error
!= error_data
)
841 bgp_notify_send_with_data (peer
,
843 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
844 error_data
, error
- error_data
);
846 bgp_notify_send (peer
,
848 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
856 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
857 afi_t afi
, safi_t safi
, u_char code
)
863 unsigned long numberp
;
864 int number_of_orfs
= 0;
866 if (safi
== SAFI_MPLS_VPN
)
867 safi
= SAFI_MPLS_LABELED_VPN
;
869 stream_putc (s
, BGP_OPEN_OPT_CAP
);
870 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
871 stream_putc (s
, 0); /* Capability Length */
872 stream_putc (s
, code
); /* Capability Code */
873 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
874 stream_putc (s
, 0); /* ORF Length */
875 stream_putw (s
, afi
);
877 stream_putc (s
, safi
);
878 numberp
= stream_get_endp (s
); /* Set Number Pointer */
879 stream_putc (s
, 0); /* Number of ORFs */
881 /* Address Prefix ORF */
882 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
883 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
885 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
886 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
888 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
889 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
891 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
892 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
893 stream_putc (s
, ORF_MODE_BOTH
);
895 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
897 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
898 stream_putc (s
, ORF_MODE_SEND
);
902 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
903 stream_putc (s
, ORF_MODE_RECEIVE
);
908 /* Total Number of ORFs. */
909 stream_putc_at (s
, numberp
, number_of_orfs
);
912 orf_len
= stream_get_endp (s
) - orfp
- 1;
913 stream_putc_at (s
, orfp
, orf_len
);
915 /* Total Capability Len. */
916 cap_len
= stream_get_endp (s
) - capp
- 1;
917 stream_putc_at (s
, capp
, cap_len
);
920 /* Fill in capability open option to the packet. */
922 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
930 /* Remember current pointer for Opt Parm Len. */
931 cp
= stream_get_endp (s
);
936 /* Do not send capability. */
937 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
938 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
942 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
])
944 peer
->afc_adv
[AFI_IP
][SAFI_UNICAST
] = 1;
945 stream_putc (s
, BGP_OPEN_OPT_CAP
);
946 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
947 stream_putc (s
, CAPABILITY_CODE_MP
);
948 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
949 stream_putw (s
, AFI_IP
);
951 stream_putc (s
, SAFI_UNICAST
);
953 /* IPv4 multicast. */
954 if (peer
->afc
[AFI_IP
][SAFI_MULTICAST
])
956 peer
->afc_adv
[AFI_IP
][SAFI_MULTICAST
] = 1;
957 stream_putc (s
, BGP_OPEN_OPT_CAP
);
958 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
959 stream_putc (s
, CAPABILITY_CODE_MP
);
960 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
961 stream_putw (s
, AFI_IP
);
963 stream_putc (s
, SAFI_MULTICAST
);
966 if (peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
])
968 peer
->afc_adv
[AFI_IP
][SAFI_MPLS_VPN
] = 1;
969 stream_putc (s
, BGP_OPEN_OPT_CAP
);
970 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
971 stream_putc (s
, CAPABILITY_CODE_MP
);
972 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
973 stream_putw (s
, AFI_IP
);
975 stream_putc (s
, SAFI_MPLS_LABELED_VPN
);
979 if (peer
->afc
[AFI_IP6
][SAFI_UNICAST
])
981 peer
->afc_adv
[AFI_IP6
][SAFI_UNICAST
] = 1;
982 stream_putc (s
, BGP_OPEN_OPT_CAP
);
983 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
984 stream_putc (s
, CAPABILITY_CODE_MP
);
985 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
986 stream_putw (s
, AFI_IP6
);
988 stream_putc (s
, SAFI_UNICAST
);
990 /* IPv6 multicast. */
991 if (peer
->afc
[AFI_IP6
][SAFI_MULTICAST
])
993 peer
->afc_adv
[AFI_IP6
][SAFI_MULTICAST
] = 1;
994 stream_putc (s
, BGP_OPEN_OPT_CAP
);
995 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
996 stream_putc (s
, CAPABILITY_CODE_MP
);
997 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
998 stream_putw (s
, AFI_IP6
);
1000 stream_putc (s
, SAFI_MULTICAST
);
1002 #endif /* HAVE_IPV6 */
1004 /* Route refresh. */
1005 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
1006 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1007 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1008 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1009 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1010 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1011 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1012 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1013 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1016 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1017 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1018 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1019 stream_putc (s
, CAPABILITY_CODE_AS4
);
1020 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1021 if ( peer
->change_local_as
)
1022 local_as
= peer
->change_local_as
;
1024 local_as
= peer
->local_as
;
1025 stream_putl (s
, local_as
);
1027 /* ORF capability. */
1028 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1029 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1030 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1031 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1033 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1034 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1037 /* Dynamic capability. */
1038 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1040 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1041 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1042 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1043 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1044 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1047 /* Graceful restart capability */
1048 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1050 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1051 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1052 stream_putc (s
, CAPABILITY_CODE_RESTART_LEN
+ 2);
1053 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1054 stream_putc (s
, CAPABILITY_CODE_RESTART_LEN
);
1055 stream_putw (s
, peer
->bgp
->restart_time
);
1058 /* Total Opt Parm Len. */
1059 len
= stream_get_endp (s
) - cp
- 1;
1060 stream_putc_at (s
, cp
, len
);