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_UNICAST_MULTICAST
:
97 vty_out (vty
, "SAFI Unicast Multicast");
100 vty_out (vty
, "SAFI MPLS-VPN");
103 vty_out (vty
, "SAFI Unknown %d ", mpc
.safi
);
106 vty_out (vty
, "%s", VTY_NEWLINE
);
108 else if (hdr
->code
>= 128)
109 vty_out (vty
, " Capability error: vendor specific capability code %d",
112 vty_out (vty
, " Capability error: unknown capability code %d",
115 pnt
+= hdr
->length
+ 2;
120 bgp_capability_mp_data (struct stream
*s
, struct capability_mp_data
*mpc
)
122 mpc
->afi
= stream_getw (s
);
123 mpc
->reserved
= stream_getc (s
);
124 mpc
->safi
= stream_getc (s
);
128 bgp_afi_safi_valid_indices (afi_t afi
, safi_t
*safi
)
130 /* VPNvX are AFI specific */
131 if ((afi
== AFI_IP6
&& *safi
== BGP_SAFI_VPNV4
)
132 || (afi
== AFI_IP
&& *safi
== BGP_SAFI_VPNV6
))
134 zlog_warn ("Invalid afi/safi combination (%u/%u)", afi
, *safi
);
146 /* BGP VPNvX SAFI isn't contigious with others, remap */
149 *safi
= SAFI_MPLS_VPN
;
156 zlog_debug ("unknown afi/safi (%u/%u)", afi
, *safi
);
161 /* Set negotiated capability value. */
163 bgp_capability_mp (struct peer
*peer
, struct capability_header
*hdr
)
165 struct capability_mp_data mpc
;
166 struct stream
*s
= BGP_INPUT (peer
);
168 bgp_capability_mp_data (s
, &mpc
);
170 if (BGP_DEBUG (normal
, NORMAL
))
171 zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
172 peer
->host
, mpc
.afi
, mpc
.safi
);
174 if (!bgp_afi_safi_valid_indices (mpc
.afi
, &mpc
.safi
))
177 /* Now safi remapped, and afi/safi are valid array indices */
178 peer
->afc_recv
[mpc
.afi
][mpc
.safi
] = 1;
180 if (peer
->afc
[mpc
.afi
][mpc
.safi
])
181 peer
->afc_nego
[mpc
.afi
][mpc
.safi
] = 1;
189 bgp_capability_orf_not_support (struct peer
*peer
, afi_t afi
, safi_t safi
,
190 u_char type
, u_char mode
)
192 if (BGP_DEBUG (normal
, NORMAL
))
193 zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
194 peer
->host
, afi
, safi
, type
, mode
);
197 static struct message orf_type_str
[] =
199 { ORF_TYPE_PREFIX
, "Prefixlist" },
200 { ORF_TYPE_PREFIX_OLD
, "Prefixlist (old)" },
202 static int orf_type_str_max
= sizeof(orf_type_str
)/sizeof(orf_type_str
[0]);
204 static struct message orf_mode_str
[] =
206 { ORF_MODE_RECEIVE
, "Receive" },
207 { ORF_MODE_SEND
, "Send" },
208 { ORF_MODE_BOTH
, "Both" },
210 static int orf_mode_str_max
= sizeof(orf_mode_str
)/sizeof(orf_mode_str
[0]);
213 bgp_capability_orf_entry (struct peer
*peer
, struct capability_header
*hdr
)
215 struct stream
*s
= BGP_INPUT (peer
);
216 struct capability_orf_entry entry
;
221 u_int16_t sm_cap
= 0; /* capability send-mode receive */
222 u_int16_t rm_cap
= 0; /* capability receive-mode receive */
225 /* ORF Entry header */
226 bgp_capability_mp_data (s
, &entry
.mpc
);
227 entry
.num
= stream_getc (s
);
229 safi
= entry
.mpc
.safi
;
231 if (BGP_DEBUG (normal
, NORMAL
))
232 zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
233 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
235 /* Check AFI and SAFI. */
236 if (!bgp_afi_safi_valid_indices (entry
.mpc
.afi
, &safi
))
238 zlog_info ("%s Addr-family %d/%d not supported."
239 " Ignoring the ORF capability",
240 peer
->host
, entry
.mpc
.afi
, entry
.mpc
.safi
);
244 /* validate number field */
245 if (sizeof (struct capability_orf_entry
) + (entry
.num
* 2) > hdr
->length
)
247 zlog_info ("%s ORF Capability entry length error,"
248 " Cap length %u, num %u",
249 peer
->host
, hdr
->length
, entry
.num
);
250 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
254 for (i
= 0 ; i
< entry
.num
; i
++)
256 type
= stream_getc(s
);
257 mode
= stream_getc(s
);
259 /* ORF Mode error check */
264 case ORF_MODE_RECEIVE
:
267 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
270 /* ORF Type and afi/safi error checks */
271 /* capcode versus type */
274 case CAPABILITY_CODE_ORF
:
277 case ORF_TYPE_PREFIX
:
280 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
284 case CAPABILITY_CODE_ORF_OLD
:
287 case ORF_TYPE_PREFIX_OLD
:
290 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
295 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
300 if (!((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
301 || (afi
== AFI_IP
&& safi
== SAFI_MULTICAST
)
302 || (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
)))
304 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
308 if (BGP_DEBUG (normal
, NORMAL
))
309 zlog_debug ("%s OPEN has %s ORF capability"
310 " as %s for afi/safi: %d/%d",
311 peer
->host
, LOOKUP (orf_type_str
, type
),
312 LOOKUP (orf_mode_str
, mode
),
313 entry
.mpc
.afi
, safi
);
315 if (hdr
->code
== CAPABILITY_CODE_ORF
)
317 sm_cap
= PEER_CAP_ORF_PREFIX_SM_RCV
;
318 rm_cap
= PEER_CAP_ORF_PREFIX_RM_RCV
;
320 else if (hdr
->code
== CAPABILITY_CODE_ORF_OLD
)
322 sm_cap
= PEER_CAP_ORF_PREFIX_SM_OLD_RCV
;
323 rm_cap
= PEER_CAP_ORF_PREFIX_RM_OLD_RCV
;
327 bgp_capability_orf_not_support (peer
, afi
, safi
, type
, mode
);
334 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
335 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
338 SET_FLAG (peer
->af_cap
[afi
][safi
], sm_cap
);
340 case ORF_MODE_RECEIVE
:
341 SET_FLAG (peer
->af_cap
[afi
][safi
], rm_cap
);
349 bgp_capability_orf (struct peer
*peer
, struct capability_header
*hdr
)
351 struct stream
*s
= BGP_INPUT (peer
);
352 size_t end
= stream_get_getp (s
) + hdr
->length
;
354 assert (stream_get_getp(s
) + sizeof(struct capability_orf_entry
) <= end
);
356 /* We must have at least one ORF entry, as the caller has already done
357 * minimum length validation for the capability code - for ORF there must
358 * at least one ORF entry (header and unknown number of pairs of bytes).
362 if (bgp_capability_orf_entry (peer
, hdr
) == -1)
365 while (stream_get_getp(s
) + sizeof(struct capability_orf_entry
) < end
);
371 bgp_capability_restart (struct peer
*peer
, struct capability_header
*caphdr
)
373 struct stream
*s
= BGP_INPUT (peer
);
374 u_int16_t restart_flag_time
;
376 size_t end
= stream_get_getp (s
) + caphdr
->length
;
378 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
);
379 restart_flag_time
= stream_getw(s
);
380 if (CHECK_FLAG (restart_flag_time
, RESTART_R_BIT
))
382 UNSET_FLAG (restart_flag_time
, 0xF000);
383 peer
->v_gr_restart
= restart_flag_time
;
385 if (BGP_DEBUG (normal
, NORMAL
))
387 zlog_debug ("%s OPEN has Graceful Restart capability", peer
->host
);
388 zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
389 peer
->host
, restart_bit
? " " : " not ",
393 while (stream_get_getp (s
) + 4 < end
)
395 afi_t afi
= stream_getw (s
);
396 safi_t safi
= stream_getc (s
);
397 u_char flag
= stream_getc (s
);
399 if (!bgp_afi_safi_valid_indices (afi
, &safi
))
401 if (BGP_DEBUG (normal
, NORMAL
))
402 zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
403 " Ignore the Graceful Restart capability",
404 peer
->host
, afi
, safi
);
406 else if (!peer
->afc
[afi
][safi
])
408 if (BGP_DEBUG (normal
, NORMAL
))
409 zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
410 " Ignore the Graceful Restart capability",
411 peer
->host
, afi
, safi
);
415 if (BGP_DEBUG (normal
, NORMAL
))
416 zlog_debug ("%s Address family %s is%spreserved", peer
->host
,
417 afi_safi_print (afi
, safi
),
418 CHECK_FLAG (peer
->af_cap
[afi
][safi
],
419 PEER_CAP_RESTART_AF_PRESERVE_RCV
)
422 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_RCV
);
423 if (CHECK_FLAG (flag
, RESTART_F_BIT
))
424 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_RESTART_AF_PRESERVE_RCV
);
432 bgp_capability_as4 (struct peer
*peer
, struct capability_header
*hdr
)
434 as_t as4
= stream_getl (BGP_INPUT(peer
));
436 if (BGP_DEBUG (as4
, AS4
))
437 zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
439 SET_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
);
444 static struct message capcode_str
[] =
447 { CAPABILITY_CODE_MP
, "MultiProtocol Extensions" },
448 { CAPABILITY_CODE_REFRESH
, "Route Refresh" },
449 { CAPABILITY_CODE_ORF
, "Cooperative Route Filtering" },
450 { CAPABILITY_CODE_RESTART
, "Graceful Restart" },
451 { CAPABILITY_CODE_AS4
, "4-octet AS number" },
452 { CAPABILITY_CODE_DYNAMIC
, "Dynamic" },
453 { CAPABILITY_CODE_REFRESH_OLD
, "Route Refresh (Old)" },
454 { CAPABILITY_CODE_ORF_OLD
, "ORF (Old)" },
456 int capcode_str_max
= sizeof(capcode_str
)/sizeof(capcode_str
[0]);
458 /* Minimum sizes for length field of each cap (so not inc. the header) */
459 static size_t cap_minsizes
[] =
461 [CAPABILITY_CODE_MP
] = sizeof (struct capability_mp_data
),
462 [CAPABILITY_CODE_REFRESH
] = CAPABILITY_CODE_REFRESH_LEN
,
463 [CAPABILITY_CODE_ORF
] = sizeof (struct capability_orf_entry
),
464 [CAPABILITY_CODE_RESTART
] = sizeof (struct capability_gr
) - 2,
465 [CAPABILITY_CODE_AS4
] = CAPABILITY_CODE_AS4_LEN
,
466 [CAPABILITY_CODE_DYNAMIC
] = CAPABILITY_CODE_DYNAMIC_LEN
,
467 [CAPABILITY_CODE_REFRESH_OLD
] = CAPABILITY_CODE_REFRESH_LEN
,
468 [CAPABILITY_CODE_ORF_OLD
] = sizeof (struct capability_orf_entry
),
471 /* Parse given capability.
472 * XXX: This is reading into a stream, but not using stream API
475 bgp_capability_parse (struct peer
*peer
, size_t length
, u_char
**error
)
478 struct stream
*s
= BGP_INPUT (peer
);
479 size_t end
= stream_get_getp (s
) + length
;
481 assert (STREAM_READABLE (s
) >= length
);
483 while (stream_get_getp (s
) < end
)
486 u_char
*sp
= stream_pnt (s
);
487 struct capability_header caphdr
;
489 /* We need at least capability code and capability length. */
490 if (stream_get_getp(s
) + 2 > end
)
492 zlog_info ("%s Capability length error (< header)", peer
->host
);
493 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
497 caphdr
.code
= stream_getc (s
);
498 caphdr
.length
= stream_getc (s
);
499 start
= stream_get_getp (s
);
501 /* Capability length check sanity check. */
502 if (start
+ caphdr
.length
> end
)
504 zlog_info ("%s Capability length error (< length)", peer
->host
);
505 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
509 if (BGP_DEBUG (normal
, NORMAL
))
510 zlog_debug ("%s OPEN has %s capability (%u), length %u",
512 LOOKUP (capcode_str
, caphdr
.code
),
513 caphdr
.code
, caphdr
.length
);
515 /* Length sanity check, type-specific, for known capabilities */
518 case CAPABILITY_CODE_MP
:
519 case CAPABILITY_CODE_REFRESH
:
520 case CAPABILITY_CODE_REFRESH_OLD
:
521 case CAPABILITY_CODE_ORF
:
522 case CAPABILITY_CODE_ORF_OLD
:
523 case CAPABILITY_CODE_RESTART
:
524 case CAPABILITY_CODE_AS4
:
525 case CAPABILITY_CODE_DYNAMIC
:
527 if (caphdr
.length
< cap_minsizes
[caphdr
.code
])
529 zlog_info ("%s %s Capability length error: got %u,"
530 " expected at least %u",
532 LOOKUP (capcode_str
, caphdr
.code
),
533 caphdr
.length
, cap_minsizes
[caphdr
.code
]);
534 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
537 /* we deliberately ignore unknown codes, see below */
544 case CAPABILITY_CODE_MP
:
546 /* Ignore capability when override-capability is set. */
547 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
549 /* Set negotiated value. */
550 ret
= bgp_capability_mp (peer
, &caphdr
);
552 /* Unsupported Capability. */
555 /* Store return data. */
556 memcpy (*error
, sp
, caphdr
.length
+ 2);
557 *error
+= caphdr
.length
+ 2;
562 case CAPABILITY_CODE_REFRESH
:
563 case CAPABILITY_CODE_REFRESH_OLD
:
565 /* BGP refresh capability */
566 if (caphdr
.code
== CAPABILITY_CODE_REFRESH_OLD
)
567 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
);
569 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
);
572 case CAPABILITY_CODE_ORF
:
573 case CAPABILITY_CODE_ORF_OLD
:
574 if (bgp_capability_orf (peer
, &caphdr
))
577 case CAPABILITY_CODE_RESTART
:
578 if (bgp_capability_restart (peer
, &caphdr
))
581 case CAPABILITY_CODE_DYNAMIC
:
582 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
);
584 case CAPABILITY_CODE_AS4
:
585 /* Already handled as a special-case parsing of the capabilities
586 * at the beginning of OPEN processing. So we care not a jot
587 * for the value really, only error case.
589 if (!bgp_capability_as4 (peer
, &caphdr
))
593 if (caphdr
.code
> 128)
595 /* We don't send Notification for unknown vendor specific
596 capabilities. It seems reasonable for now... */
597 zlog_warn ("%s Vendor specific capability %d",
598 peer
->host
, caphdr
.code
);
602 zlog_warn ("%s unrecognized capability code: %d - ignored",
603 peer
->host
, caphdr
.code
);
604 memcpy (*error
, sp
, caphdr
.length
+ 2);
605 *error
+= caphdr
.length
+ 2;
608 if (stream_get_getp(s
) != (start
+ caphdr
.length
))
610 if (stream_get_getp(s
) > (start
+ caphdr
.length
))
611 zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
612 peer
->host
, LOOKUP (capcode_str
, caphdr
.code
),
614 stream_set_getp (s
, start
+ caphdr
.length
);
621 bgp_auth_parse (struct peer
*peer
, size_t length
)
623 bgp_notify_send (peer
,
625 BGP_NOTIFY_OPEN_AUTH_FAILURE
);
630 strict_capability_same (struct peer
*peer
)
634 for (i
= AFI_IP
; i
< AFI_MAX
; i
++)
635 for (j
= SAFI_UNICAST
; j
< SAFI_MAX
; j
++)
636 if (peer
->afc
[i
][j
] != peer
->afc_nego
[i
][j
])
641 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
642 * Returns 0 if no as4 found, as4cap value otherwise.
645 peek_for_as4_capability (struct peer
*peer
, u_char length
)
647 struct stream
*s
= BGP_INPUT (peer
);
648 size_t orig_getp
= stream_get_getp (s
);
649 size_t end
= orig_getp
+ length
;
652 /* The full capability parser will better flag the error.. */
653 if (STREAM_READABLE(s
) < length
)
656 if (BGP_DEBUG (as4
, AS4
))
657 zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
660 /* the error cases we DONT handle, we ONLY try to read as4 out of
661 * correctly formatted options.
663 while (stream_get_getp(s
) < end
)
668 /* Check the length. */
669 if (stream_get_getp (s
) + 2 > end
)
672 /* Fetch option type and length. */
673 opt_type
= stream_getc (s
);
674 opt_length
= stream_getc (s
);
676 /* Option length check. */
677 if (stream_get_getp (s
) + opt_length
> end
)
680 if (opt_type
== BGP_OPEN_OPT_CAP
)
682 unsigned long capd_start
= stream_get_getp (s
);
683 unsigned long capd_end
= capd_start
+ opt_length
;
685 assert (capd_end
<= end
);
687 while (stream_get_getp (s
) < capd_end
)
689 struct capability_header hdr
;
691 if (stream_get_getp (s
) + 2 > capd_end
)
694 hdr
.code
= stream_getc (s
);
695 hdr
.length
= stream_getc (s
);
697 if ((stream_get_getp(s
) + hdr
.length
) > capd_end
)
700 if (hdr
.code
== CAPABILITY_CODE_AS4
)
702 if (hdr
.length
!= CAPABILITY_CODE_AS4_LEN
)
705 if (BGP_DEBUG (as4
, AS4
))
706 zlog_info ("[AS4] found AS4 capability, about to parse");
707 as4
= bgp_capability_as4 (peer
, &hdr
);
711 stream_forward_getp (s
, hdr
.length
);
717 stream_set_getp (s
, orig_getp
);
721 /* Parse open option */
723 bgp_open_option_parse (struct peer
*peer
, u_char length
, int *capability
)
727 u_char error_data
[BGP_MAX_PACKET_SIZE
];
728 struct stream
*s
= BGP_INPUT(peer
);
729 size_t end
= stream_get_getp (s
) + length
;
734 if (BGP_DEBUG (normal
, NORMAL
))
735 zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
738 while (stream_get_getp(s
) < end
)
743 /* Must have at least an OPEN option header */
744 if (STREAM_READABLE(s
) < 2)
746 zlog_info ("%s Option length error", peer
->host
);
747 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
751 /* Fetch option type and length. */
752 opt_type
= stream_getc (s
);
753 opt_length
= stream_getc (s
);
755 /* Option length check. */
756 if (STREAM_READABLE (s
) < opt_length
)
758 zlog_info ("%s Option length error", peer
->host
);
759 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
763 if (BGP_DEBUG (normal
, NORMAL
))
764 zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
765 peer
->host
, opt_type
,
766 opt_type
== BGP_OPEN_OPT_AUTH
? "Authentication" :
767 opt_type
== BGP_OPEN_OPT_CAP
? "Capability" : "Unknown",
772 case BGP_OPEN_OPT_AUTH
:
773 ret
= bgp_auth_parse (peer
, opt_length
);
775 case BGP_OPEN_OPT_CAP
:
776 ret
= bgp_capability_parse (peer
, opt_length
, &error
);
780 bgp_notify_send (peer
,
782 BGP_NOTIFY_OPEN_UNSUP_PARAM
);
787 /* Parse error. To accumulate all unsupported capability codes,
788 bgp_capability_parse does not return -1 when encounter
789 unsupported capability code. To detect that, please check
790 error and erro_data pointer, like below. */
795 /* All OPEN option is parsed. Check capability when strict compare
797 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
799 /* If Unsupported Capability exists. */
800 if (error
!= error_data
)
802 bgp_notify_send_with_data (peer
,
804 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
805 error_data
, error
- error_data
);
809 /* Check local capability does not negotiated with remote
811 if (! strict_capability_same (peer
))
813 bgp_notify_send (peer
,
815 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
820 /* Check there is no common capability send Unsupported Capability
822 if (*capability
&& ! CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
824 if (! peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
825 && ! peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
826 && ! peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
827 && ! peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
828 && ! peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
])
830 plog_err (peer
->log
, "%s [Error] No common capability", peer
->host
);
832 if (error
!= error_data
)
834 bgp_notify_send_with_data (peer
,
836 BGP_NOTIFY_OPEN_UNSUP_CAPBL
,
837 error_data
, error
- error_data
);
839 bgp_notify_send (peer
,
841 BGP_NOTIFY_OPEN_UNSUP_CAPBL
);
849 bgp_open_capability_orf (struct stream
*s
, struct peer
*peer
,
850 afi_t afi
, safi_t safi
, u_char code
)
856 unsigned long numberp
;
857 int number_of_orfs
= 0;
859 if (safi
== SAFI_MPLS_VPN
)
860 safi
= BGP_SAFI_VPNV4
;
862 stream_putc (s
, BGP_OPEN_OPT_CAP
);
863 capp
= stream_get_endp (s
); /* Set Capability Len Pointer */
864 stream_putc (s
, 0); /* Capability Length */
865 stream_putc (s
, code
); /* Capability Code */
866 orfp
= stream_get_endp (s
); /* Set ORF Len Pointer */
867 stream_putc (s
, 0); /* ORF Length */
868 stream_putw (s
, afi
);
870 stream_putc (s
, safi
);
871 numberp
= stream_get_endp (s
); /* Set Number Pointer */
872 stream_putc (s
, 0); /* Number of ORFs */
874 /* Address Prefix ORF */
875 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
876 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
878 stream_putc (s
, (code
== CAPABILITY_CODE_ORF
?
879 ORF_TYPE_PREFIX
: ORF_TYPE_PREFIX_OLD
));
881 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
882 && CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
884 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
885 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
886 stream_putc (s
, ORF_MODE_BOTH
);
888 else if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
))
890 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
);
891 stream_putc (s
, ORF_MODE_SEND
);
895 SET_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
);
896 stream_putc (s
, ORF_MODE_RECEIVE
);
901 /* Total Number of ORFs. */
902 stream_putc_at (s
, numberp
, number_of_orfs
);
905 orf_len
= stream_get_endp (s
) - orfp
- 1;
906 stream_putc_at (s
, orfp
, orf_len
);
908 /* Total Capability Len. */
909 cap_len
= stream_get_endp (s
) - capp
- 1;
910 stream_putc_at (s
, capp
, cap_len
);
913 /* Fill in capability open option to the packet. */
915 bgp_open_capability (struct stream
*s
, struct peer
*peer
)
923 /* Remember current pointer for Opt Parm Len. */
924 cp
= stream_get_endp (s
);
929 /* Do not send capability. */
930 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
)
931 || CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
935 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
])
937 peer
->afc_adv
[AFI_IP
][SAFI_UNICAST
] = 1;
938 stream_putc (s
, BGP_OPEN_OPT_CAP
);
939 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
940 stream_putc (s
, CAPABILITY_CODE_MP
);
941 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
942 stream_putw (s
, AFI_IP
);
944 stream_putc (s
, SAFI_UNICAST
);
946 /* IPv4 multicast. */
947 if (peer
->afc
[AFI_IP
][SAFI_MULTICAST
])
949 peer
->afc_adv
[AFI_IP
][SAFI_MULTICAST
] = 1;
950 stream_putc (s
, BGP_OPEN_OPT_CAP
);
951 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
952 stream_putc (s
, CAPABILITY_CODE_MP
);
953 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
954 stream_putw (s
, AFI_IP
);
956 stream_putc (s
, SAFI_MULTICAST
);
959 if (peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
])
961 peer
->afc_adv
[AFI_IP
][SAFI_MPLS_VPN
] = 1;
962 stream_putc (s
, BGP_OPEN_OPT_CAP
);
963 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
964 stream_putc (s
, CAPABILITY_CODE_MP
);
965 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
966 stream_putw (s
, AFI_IP
);
968 stream_putc (s
, BGP_SAFI_VPNV4
);
972 if (peer
->afc
[AFI_IP6
][SAFI_UNICAST
])
974 peer
->afc_adv
[AFI_IP6
][SAFI_UNICAST
] = 1;
975 stream_putc (s
, BGP_OPEN_OPT_CAP
);
976 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
977 stream_putc (s
, CAPABILITY_CODE_MP
);
978 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
979 stream_putw (s
, AFI_IP6
);
981 stream_putc (s
, SAFI_UNICAST
);
983 /* IPv6 multicast. */
984 if (peer
->afc
[AFI_IP6
][SAFI_MULTICAST
])
986 peer
->afc_adv
[AFI_IP6
][SAFI_MULTICAST
] = 1;
987 stream_putc (s
, BGP_OPEN_OPT_CAP
);
988 stream_putc (s
, CAPABILITY_CODE_MP_LEN
+ 2);
989 stream_putc (s
, CAPABILITY_CODE_MP
);
990 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
991 stream_putw (s
, AFI_IP6
);
993 stream_putc (s
, SAFI_MULTICAST
);
995 #endif /* HAVE_IPV6 */
998 SET_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
);
999 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1000 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1001 stream_putc (s
, CAPABILITY_CODE_REFRESH_OLD
);
1002 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1003 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1004 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
+ 2);
1005 stream_putc (s
, CAPABILITY_CODE_REFRESH
);
1006 stream_putc (s
, CAPABILITY_CODE_REFRESH_LEN
);
1009 SET_FLAG (peer
->cap
, PEER_CAP_AS4_ADV
);
1010 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1011 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
+ 2);
1012 stream_putc (s
, CAPABILITY_CODE_AS4
);
1013 stream_putc (s
, CAPABILITY_CODE_AS4_LEN
);
1014 if ( peer
->change_local_as
)
1015 local_as
= peer
->change_local_as
;
1017 local_as
= peer
->local_as
;
1018 stream_putl (s
, local_as
);
1020 /* ORF capability. */
1021 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1022 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1023 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_SM
)
1024 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ORF_PREFIX_RM
))
1026 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF_OLD
);
1027 bgp_open_capability_orf (s
, peer
, afi
, safi
, CAPABILITY_CODE_ORF
);
1030 /* Dynamic capability. */
1031 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
1033 SET_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
);
1034 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1035 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
+ 2);
1036 stream_putc (s
, CAPABILITY_CODE_DYNAMIC
);
1037 stream_putc (s
, CAPABILITY_CODE_DYNAMIC_LEN
);
1040 /* Graceful restart capability */
1041 if (bgp_flag_check (peer
->bgp
, BGP_FLAG_GRACEFUL_RESTART
))
1043 SET_FLAG (peer
->cap
, PEER_CAP_RESTART_ADV
);
1044 stream_putc (s
, BGP_OPEN_OPT_CAP
);
1045 stream_putc (s
, CAPABILITY_CODE_RESTART_LEN
+ 2);
1046 stream_putc (s
, CAPABILITY_CODE_RESTART
);
1047 stream_putc (s
, CAPABILITY_CODE_RESTART_LEN
);
1048 stream_putw (s
, peer
->bgp
->restart_time
);
1051 /* Total Opt Parm Len. */
1052 len
= stream_get_endp (s
) - cp
- 1;
1053 stream_putc_at (s
, cp
, len
);