1 /* BGP packet management routine.
2 * Contains utility functions for constructing and consuming BGP messages.
3 * Copyright (C) 2017 Cumulus Networks
4 * Copyright (C) 1999 Kunihiro Ishiguro
6 * This file is part of GNU Zebra.
8 * GNU Zebra is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
13 * GNU Zebra is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; see the file COPYING; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #include "sockunion.h" /* for inet_ntop () */
39 #include "lib_errors.h"
41 #include "bgpd/bgpd.h"
42 #include "bgpd/bgp_table.h"
43 #include "bgpd/bgp_dump.h"
44 #include "bgpd/bgp_bmp.h"
45 #include "bgpd/bgp_attr.h"
46 #include "bgpd/bgp_debug.h"
47 #include "bgpd/bgp_errors.h"
48 #include "bgpd/bgp_fsm.h"
49 #include "bgpd/bgp_route.h"
50 #include "bgpd/bgp_packet.h"
51 #include "bgpd/bgp_open.h"
52 #include "bgpd/bgp_aspath.h"
53 #include "bgpd/bgp_community.h"
54 #include "bgpd/bgp_ecommunity.h"
55 #include "bgpd/bgp_lcommunity.h"
56 #include "bgpd/bgp_network.h"
57 #include "bgpd/bgp_mplsvpn.h"
58 #include "bgpd/bgp_evpn.h"
59 #include "bgpd/bgp_advertise.h"
60 #include "bgpd/bgp_vty.h"
61 #include "bgpd/bgp_updgrp.h"
62 #include "bgpd/bgp_label.h"
63 #include "bgpd/bgp_io.h"
64 #include "bgpd/bgp_keepalives.h"
65 #include "bgpd/bgp_flowspec.h"
67 DEFINE_HOOK(bgp_packet_dump
,
68 (struct peer
*peer
, uint8_t type
, bgp_size_t size
,
70 (peer
, type
, size
, s
))
72 DEFINE_HOOK(bgp_packet_send
,
73 (struct peer
*peer
, uint8_t type
, bgp_size_t size
,
75 (peer
, type
, size
, s
))
78 * Sets marker and type fields for a BGP message.
80 * @param s the stream containing the packet
81 * @param type the packet type
82 * @return the size of the stream
84 int bgp_packet_set_marker(struct stream
*s
, uint8_t type
)
89 for (i
= 0; i
< BGP_MARKER_SIZE
; i
++)
92 /* Dummy total length. This field is should be filled in later on. */
95 /* BGP packet type. */
98 /* Return current stream size. */
99 return stream_get_endp(s
);
103 * Sets size field for a BGP message.
105 * Size field is set to the size of the stream passed.
107 * @param s the stream containing the packet
108 * @return the size of the stream
110 int bgp_packet_set_size(struct stream
*s
)
114 /* Preserve current pointer. */
115 cp
= stream_get_endp(s
);
116 stream_putw_at(s
, BGP_MARKER_SIZE
, cp
);
122 * Push a packet onto the beginning of the peer's output queue.
123 * This function acquires the peer's write mutex before proceeding.
125 static void bgp_packet_add(struct peer
*peer
, struct stream
*s
)
127 frr_with_mutex(&peer
->io_mtx
) {
128 stream_fifo_push(peer
->obuf
, s
);
132 static struct stream
*bgp_update_packet_eor(struct peer
*peer
, afi_t afi
,
137 iana_safi_t pkt_safi
;
139 if (DISABLE_BGP_ANNOUNCE
)
142 if (bgp_debug_neighbor_events(peer
))
143 zlog_debug("send End-of-RIB for %s to %s",
144 get_afi_safi_str(afi
, safi
, false), peer
->host
);
146 s
= stream_new(BGP_MAX_PACKET_SIZE
);
148 /* Make BGP update packet. */
149 bgp_packet_set_marker(s
, BGP_MSG_UPDATE
);
151 /* Unfeasible Routes Length */
154 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
) {
155 /* Total Path Attribute Length */
158 /* Convert AFI, SAFI to values for packet. */
159 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
161 /* Total Path Attribute Length */
163 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
164 stream_putc(s
, BGP_ATTR_MP_UNREACH_NLRI
);
166 stream_putw(s
, pkt_afi
);
167 stream_putc(s
, pkt_safi
);
170 bgp_packet_set_size(s
);
174 /* Called when there is a change in the EOR(implicit or explicit) status of a
175 * peer. Ends the update-delay if all expected peers are done with EORs. */
176 void bgp_check_update_delay(struct bgp
*bgp
)
178 struct listnode
*node
, *nnode
;
179 struct peer
*peer
= NULL
;
181 if (bgp_debug_neighbor_events(peer
))
182 zlog_debug("Checking update delay, T: %d R: %d I:%d E: %d",
183 bgp
->established
, bgp
->restarted_peers
,
184 bgp
->implicit_eors
, bgp
->explicit_eors
);
187 <= bgp
->restarted_peers
+ bgp
->implicit_eors
+ bgp
->explicit_eors
) {
189 * This is an extra sanity check to make sure we wait for all
190 * the eligible configured peers. This check is performed if
191 * establish wait timer is on, or establish wait option is not
192 * given with the update-delay command
194 if (bgp
->t_establish_wait
195 || (bgp
->v_establish_wait
== bgp
->v_update_delay
))
196 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
197 if (CHECK_FLAG(peer
->flags
,
198 PEER_FLAG_CONFIG_NODE
)
199 && !CHECK_FLAG(peer
->flags
,
201 && !peer
->update_delay_over
) {
202 if (bgp_debug_neighbor_events(peer
))
204 " Peer %s pending, continuing read-only mode",
211 "Update delay ended, restarted: %d, EORs implicit: %d, explicit: %d",
212 bgp
->restarted_peers
, bgp
->implicit_eors
,
214 bgp_update_delay_end(bgp
);
219 * Called if peer is known to have restarted. The restart-state bit in
220 * Graceful-Restart capability is used for that
222 void bgp_update_restarted_peers(struct peer
*peer
)
224 if (!bgp_update_delay_active(peer
->bgp
))
225 return; /* BGP update delay has ended */
226 if (peer
->update_delay_over
)
227 return; /* This peer has already been considered */
229 if (bgp_debug_neighbor_events(peer
))
230 zlog_debug("Peer %s: Checking restarted", peer
->host
);
232 if (peer
->status
== Established
) {
233 peer
->update_delay_over
= 1;
234 peer
->bgp
->restarted_peers
++;
235 bgp_check_update_delay(peer
->bgp
);
240 * Called as peer receives a keep-alive. Determines if this occurence can be
241 * taken as an implicit EOR for this peer.
242 * NOTE: The very first keep-alive after the Established state of a peer is
243 * considered implicit EOR for the update-delay purposes
245 void bgp_update_implicit_eors(struct peer
*peer
)
247 if (!bgp_update_delay_active(peer
->bgp
))
248 return; /* BGP update delay has ended */
249 if (peer
->update_delay_over
)
250 return; /* This peer has already been considered */
252 if (bgp_debug_neighbor_events(peer
))
253 zlog_debug("Peer %s: Checking implicit EORs", peer
->host
);
255 if (peer
->status
== Established
) {
256 peer
->update_delay_over
= 1;
257 peer
->bgp
->implicit_eors
++;
258 bgp_check_update_delay(peer
->bgp
);
263 * Should be called only when there is a change in the EOR_RECEIVED status
264 * for any afi/safi on a peer.
266 static void bgp_update_explicit_eors(struct peer
*peer
)
271 if (!bgp_update_delay_active(peer
->bgp
))
272 return; /* BGP update delay has ended */
273 if (peer
->update_delay_over
)
274 return; /* This peer has already been considered */
276 if (bgp_debug_neighbor_events(peer
))
277 zlog_debug("Peer %s: Checking explicit EORs", peer
->host
);
279 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
280 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
281 if (peer
->afc_nego
[afi
][safi
]
282 && !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
283 PEER_STATUS_EOR_RECEIVED
)) {
284 if (bgp_debug_neighbor_events(peer
))
286 " afi %d safi %d didn't receive EOR",
292 peer
->update_delay_over
= 1;
293 peer
->bgp
->explicit_eors
++;
294 bgp_check_update_delay(peer
->bgp
);
298 * Frontend for NLRI parsing, to fan-out to AFI/SAFI specific parsers.
300 * mp_withdraw, if set, is used to nullify attr structure on most of the
301 * calling safi function and for evpn, passed as parameter
303 int bgp_nlri_parse(struct peer
*peer
, struct attr
*attr
,
304 struct bgp_nlri
*packet
, int mp_withdraw
)
306 switch (packet
->safi
) {
309 return bgp_nlri_parse_ip(peer
, mp_withdraw
? NULL
: attr
,
311 case SAFI_LABELED_UNICAST
:
312 return bgp_nlri_parse_label(peer
, mp_withdraw
? NULL
: attr
,
315 return bgp_nlri_parse_vpn(peer
, mp_withdraw
? NULL
: attr
,
318 return bgp_nlri_parse_evpn(peer
, attr
, packet
, mp_withdraw
);
320 return bgp_nlri_parse_flowspec(peer
, attr
, packet
, mp_withdraw
);
322 return BGP_NLRI_PARSE_ERROR
;
326 * Checks a variety of conditions to determine whether the peer needs to be
327 * rescheduled for packet generation again, and does so if necessary.
329 * @param peer to check for rescheduling
331 static void bgp_write_proceed_actions(struct peer
*peer
)
336 struct bpacket
*next_pkt
;
337 struct update_subgroup
*subgrp
;
339 FOREACH_AFI_SAFI (afi
, safi
) {
340 paf
= peer_af_find(peer
, afi
, safi
);
343 subgrp
= paf
->subgroup
;
347 next_pkt
= paf
->next_pkt_to_send
;
348 if (next_pkt
&& next_pkt
->buffer
) {
349 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
350 bgp_generate_updgrp_packets
, 0);
354 /* No packets readily available for AFI/SAFI, are there
356 * that need to be generated? */
357 if (bpacket_queue_is_full(SUBGRP_INST(subgrp
),
359 || subgroup_packets_to_build(subgrp
)) {
360 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
361 bgp_generate_updgrp_packets
, 0);
365 /* No packets to send, see if EOR is pending */
366 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
367 if (!subgrp
->t_coalesce
&& peer
->afc_nego
[afi
][safi
]
369 && !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
370 PEER_STATUS_EOR_SEND
)
371 && safi
!= SAFI_MPLS_VPN
) {
372 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
373 bgp_generate_updgrp_packets
, 0);
381 * Generate advertisement information (withdraws, updates, EOR) from each
382 * update group a peer belongs to, encode this information into packets, and
383 * enqueue the packets onto the peer's output buffer.
385 int bgp_generate_updgrp_packets(struct thread
*thread
)
387 struct peer
*peer
= THREAD_ARG(thread
);
391 struct bpacket
*next_pkt
;
393 uint32_t generated
= 0;
397 wpq
= atomic_load_explicit(&peer
->bgp
->wpkt_quanta
,
398 memory_order_relaxed
);
401 * The code beyond this part deals with update packets, proceed only
402 * if peer is Established and updates are not on hold (as part of
403 * update-delay post processing).
405 if (peer
->status
!= Established
)
408 if (peer
->bgp
->main_peers_update_hold
)
413 FOREACH_AFI_SAFI (afi
, safi
) {
414 paf
= peer_af_find(peer
, afi
, safi
);
415 if (!paf
|| !PAF_SUBGRP(paf
))
417 next_pkt
= paf
->next_pkt_to_send
;
420 * Try to generate a packet for the peer if we are at
421 * the end of the list. Always try to push out
424 if (!next_pkt
|| !next_pkt
->buffer
) {
425 next_pkt
= subgroup_withdraw_packet(
427 if (!next_pkt
|| !next_pkt
->buffer
)
428 subgroup_update_packet(PAF_SUBGRP(paf
));
429 next_pkt
= paf
->next_pkt_to_send
;
433 * If we still don't have a packet to send to the peer,
434 * then try to find out out if we have to send eor or
435 * if not, skip to the next AFI, SAFI. Don't send the
436 * EOR prematurely; if the subgroup's coalesce timer is
437 * running, the adjacency-out structure is not created
440 if (!next_pkt
|| !next_pkt
->buffer
) {
441 if (CHECK_FLAG(peer
->cap
,
442 PEER_CAP_RESTART_RCV
)) {
443 if (!(PAF_SUBGRP(paf
))->t_coalesce
444 && peer
->afc_nego
[afi
][safi
]
447 peer
->af_sflags
[afi
][safi
],
448 PEER_STATUS_EOR_SEND
)) {
449 /* If EOR is disabled,
450 * the message is not sent
452 if (BGP_SEND_EOR(peer
->bgp
, afi
,
458 PEER_STATUS_EOR_SEND
);
476 /* Update packet send time */
477 peer
->pkt_stime
[afi
][safi
] = monotime(NULL
);
479 /* Found a packet template to send, overwrite
480 * packet with appropriate attributes from peer
481 * and advance peer */
482 s
= bpacket_reformat_for_peer(next_pkt
, paf
);
483 bgp_packet_add(peer
, s
);
484 bpacket_queue_advance_peer(paf
);
486 } while (s
&& (++generated
< wpq
));
491 bgp_write_proceed_actions(peer
);
497 * Creates a BGP Keepalive packet and appends it to the peer's output queue.
499 void bgp_keepalive_send(struct peer
*peer
)
503 s
= stream_new(BGP_MAX_PACKET_SIZE
);
505 /* Make keepalive packet. */
506 bgp_packet_set_marker(s
, BGP_MSG_KEEPALIVE
);
508 /* Set packet size. */
509 (void)bgp_packet_set_size(s
);
511 /* Dump packet if debug option is set. */
512 /* bgp_packet_dump (s); */
514 if (bgp_debug_keepalive(peer
))
515 zlog_debug("%s sending KEEPALIVE", peer
->host
);
517 /* Add packet to the peer. */
518 bgp_packet_add(peer
, s
);
524 * Creates a BGP Open packet and appends it to the peer's output queue.
525 * Sets capabilities as necessary.
527 void bgp_open_send(struct peer
*peer
)
530 uint16_t send_holdtime
;
533 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
))
534 send_holdtime
= peer
->holdtime
;
536 send_holdtime
= peer
->bgp
->default_holdtime
;
538 /* local-as Change */
539 if (peer
->change_local_as
)
540 local_as
= peer
->change_local_as
;
542 local_as
= peer
->local_as
;
544 s
= stream_new(BGP_MAX_PACKET_SIZE
);
546 /* Make open packet. */
547 bgp_packet_set_marker(s
, BGP_MSG_OPEN
);
549 /* Set open packet values. */
550 stream_putc(s
, BGP_VERSION_4
); /* BGP version */
551 stream_putw(s
, (local_as
<= BGP_AS_MAX
) ? (uint16_t)local_as
553 stream_putw(s
, send_holdtime
); /* Hold Time */
554 stream_put_in_addr(s
, &peer
->local_id
); /* BGP Identifier */
556 /* Set capability code. */
557 bgp_open_capability(s
, peer
);
559 /* Set BGP packet length. */
560 (void)bgp_packet_set_size(s
);
562 if (bgp_debug_neighbor_events(peer
))
564 "%s sending OPEN, version %d, my as %u, holdtime %d, id %s",
565 peer
->host
, BGP_VERSION_4
, local_as
, send_holdtime
,
566 inet_ntoa(peer
->local_id
));
568 /* Dump packet if debug option is set. */
569 /* bgp_packet_dump (s); */
570 hook_call(bgp_packet_send
, peer
, BGP_MSG_OPEN
, stream_get_endp(s
), s
);
572 /* Add packet to the peer. */
573 bgp_packet_add(peer
, s
);
579 * Writes NOTIFICATION message directly to a peer socket without waiting for
582 * There must be exactly one stream on the peer->obuf FIFO, and the data within
583 * this stream must match the format of a BGP NOTIFICATION message.
584 * Transmission is best-effort.
586 * @requires peer->io_mtx
590 static void bgp_write_notify(struct peer
*peer
)
596 /* There should be at least one packet. */
597 s
= stream_fifo_pop(peer
->obuf
);
602 assert(stream_get_endp(s
) >= BGP_HEADER_SIZE
);
604 /* Stop collecting data within the socket */
605 sockopt_cork(peer
->fd
, 0);
608 * socket is in nonblocking mode, if we can't deliver the NOTIFY, well,
609 * we only care about getting a clean shutdown at this point.
611 ret
= write(peer
->fd
, STREAM_DATA(s
), stream_get_endp(s
));
614 * only connection reset/close gets counted as TCP_fatal_error, failure
615 * to write the entire NOTIFY doesn't get different FSM treatment
619 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
623 /* Disable Nagle, make NOTIFY packet go out right away */
625 (void)setsockopt(peer
->fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
,
628 /* Retrieve BGP packet type. */
629 stream_set_getp(s
, BGP_MARKER_SIZE
+ 2);
630 type
= stream_getc(s
);
632 assert(type
== BGP_MSG_NOTIFY
);
634 /* Type should be notify. */
635 atomic_fetch_add_explicit(&peer
->notify_out
, 1, memory_order_relaxed
);
638 /* Double start timer. */
641 /* Overflow check. */
642 if (peer
->v_start
>= (60 * 2))
643 peer
->v_start
= (60 * 2);
646 * Handle Graceful Restart case where the state changes to
647 * Connect instead of Idle
649 BGP_EVENT_ADD(peer
, BGP_Stop
);
655 * Creates a BGP Notify and appends it to the peer's output queue.
657 * This function attempts to write the packet from the thread it is called
658 * from, to ensure the packet gets out ASAP.
660 * This function may be called from multiple threads. Since the function
661 * modifies I/O buffer(s) in the peer, these are locked for the duration of the
662 * call to prevent tampering from other threads.
664 * Delivery of the NOTIFICATION is attempted once and is best-effort. After
665 * return, the peer structure *must* be reset; no assumptions about session
669 * @param code BGP error code
670 * @param sub_code BGP error subcode
671 * @param data Data portion
672 * @param datalen length of data portion
674 void bgp_notify_send_with_data(struct peer
*peer
, uint8_t code
,
675 uint8_t sub_code
, uint8_t *data
, size_t datalen
)
679 /* Lock I/O mutex to prevent other threads from pushing packets */
680 frr_mutex_lock_autounlock(&peer
->io_mtx
);
681 /* ============================================== */
683 /* Allocate new stream. */
684 s
= stream_new(BGP_MAX_PACKET_SIZE
);
686 /* Make notify packet. */
687 bgp_packet_set_marker(s
, BGP_MSG_NOTIFY
);
689 /* Set notify packet values. */
690 stream_putc(s
, code
); /* BGP notify code */
691 stream_putc(s
, sub_code
); /* BGP notify sub_code */
693 /* If notify data is present. */
695 stream_write(s
, data
, datalen
);
697 /* Set BGP packet length. */
698 bgp_packet_set_size(s
);
700 /* wipe output buffer */
701 stream_fifo_clean(peer
->obuf
);
704 * If possible, store last packet for debugging purposes. This check is
705 * in place because we are sometimes called with a doppelganger peer,
706 * who tends to have a plethora of fields nulled out.
709 size_t packetsize
= stream_get_endp(peer
->curr
);
710 assert(packetsize
<= sizeof(peer
->last_reset_cause
));
711 memcpy(peer
->last_reset_cause
, peer
->curr
->data
, packetsize
);
712 peer
->last_reset_cause_size
= packetsize
;
717 struct bgp_notify bgp_notify
;
722 bgp_notify
.code
= code
;
723 bgp_notify
.subcode
= sub_code
;
724 bgp_notify
.data
= NULL
;
725 bgp_notify
.length
= datalen
;
726 bgp_notify
.raw_data
= data
;
728 peer
->notify
.code
= bgp_notify
.code
;
729 peer
->notify
.subcode
= bgp_notify
.subcode
;
731 if (bgp_notify
.length
&& data
) {
733 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
734 for (i
= 0; i
< bgp_notify
.length
; i
++)
736 snprintf(c
, sizeof(c
), " %02x",
739 strlcat(bgp_notify
.data
, c
,
744 snprintf(c
, sizeof(c
), "%02x", data
[i
]);
746 strlcpy(bgp_notify
.data
, c
,
750 bgp_notify_print(peer
, &bgp_notify
, "sending");
752 if (bgp_notify
.data
) {
753 XFREE(MTYPE_TMP
, bgp_notify
.data
);
754 bgp_notify
.length
= 0;
758 /* peer reset cause */
759 if (code
== BGP_NOTIFY_CEASE
) {
760 if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_RESET
)
761 peer
->last_reset
= PEER_DOWN_USER_RESET
;
762 else if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
)
763 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
765 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
767 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
769 /* Add packet to peer's output queue */
770 stream_fifo_push(peer
->obuf
, s
);
772 bgp_peer_gr_flags_update(peer
);
773 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
776 bgp_write_notify(peer
);
780 * Creates a BGP Notify and appends it to the peer's output queue.
782 * This function attempts to write the packet from the thread it is called
783 * from, to ensure the packet gets out ASAP.
786 * @param code BGP error code
787 * @param sub_code BGP error subcode
789 void bgp_notify_send(struct peer
*peer
, uint8_t code
, uint8_t sub_code
)
791 bgp_notify_send_with_data(peer
, code
, sub_code
, NULL
, 0);
795 * Creates BGP Route Refresh packet and appends it to the peer's output queue.
798 * @param afi Address Family Identifier
799 * @param safi Subsequent Address Family Identifier
800 * @param orf_type Outbound Route Filtering type
801 * @param when_to_refresh Whether to refresh immediately or defer
802 * @param remove Whether to remove ORF for specified AFI/SAFI
804 void bgp_route_refresh_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
805 uint8_t orf_type
, uint8_t when_to_refresh
,
809 struct bgp_filter
*filter
;
812 iana_safi_t pkt_safi
;
814 if (DISABLE_BGP_ANNOUNCE
)
817 filter
= &peer
->filter
[afi
][safi
];
819 /* Convert AFI, SAFI to values for packet. */
820 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
822 s
= stream_new(BGP_MAX_PACKET_SIZE
);
824 /* Make BGP update packet. */
825 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
826 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_NEW
);
828 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_OLD
);
830 /* Encode Route Refresh message. */
831 stream_putw(s
, pkt_afi
);
833 stream_putc(s
, pkt_safi
);
835 if (orf_type
== ORF_TYPE_PREFIX
|| orf_type
== ORF_TYPE_PREFIX_OLD
)
836 if (remove
|| filter
->plist
[FILTER_IN
].plist
) {
841 stream_putc(s
, when_to_refresh
);
842 stream_putc(s
, orf_type
);
843 orfp
= stream_get_endp(s
);
847 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
848 PEER_STATUS_ORF_PREFIX_SEND
);
849 stream_putc(s
, ORF_COMMON_PART_REMOVE_ALL
);
850 if (bgp_debug_neighbor_events(peer
))
852 "%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %s/%s",
853 peer
->host
, orf_type
,
854 (when_to_refresh
== REFRESH_DEFER
857 iana_afi2str(pkt_afi
),
858 iana_safi2str(pkt_safi
));
860 SET_FLAG(peer
->af_sflags
[afi
][safi
],
861 PEER_STATUS_ORF_PREFIX_SEND
);
862 prefix_bgp_orf_entry(
863 s
, filter
->plist
[FILTER_IN
].plist
,
865 ORF_COMMON_PART_PERMIT
,
866 ORF_COMMON_PART_DENY
);
867 if (bgp_debug_neighbor_events(peer
))
869 "%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %s/%s",
870 peer
->host
, orf_type
,
871 (when_to_refresh
== REFRESH_DEFER
874 iana_afi2str(pkt_afi
),
875 iana_safi2str(pkt_safi
));
878 /* Total ORF Entry Len. */
879 orf_len
= stream_get_endp(s
) - orfp
- 2;
880 stream_putw_at(s
, orfp
, orf_len
);
883 /* Set packet size. */
884 (void)bgp_packet_set_size(s
);
886 if (bgp_debug_neighbor_events(peer
)) {
888 zlog_debug("%s sending REFRESH_REQ for afi/safi: %s/%s",
889 peer
->host
, iana_afi2str(pkt_afi
),
890 iana_safi2str(pkt_safi
));
893 /* Add packet to the peer. */
894 bgp_packet_add(peer
, s
);
900 * Create a BGP Capability packet and append it to the peer's output queue.
903 * @param afi Address Family Identifier
904 * @param safi Subsequent Address Family Identifier
905 * @param capability_code BGP Capability Code
906 * @param action Set or Remove capability
908 void bgp_capability_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
909 int capability_code
, int action
)
913 iana_safi_t pkt_safi
;
915 /* Convert AFI, SAFI to values for packet. */
916 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
918 s
= stream_new(BGP_MAX_PACKET_SIZE
);
920 /* Make BGP update packet. */
921 bgp_packet_set_marker(s
, BGP_MSG_CAPABILITY
);
923 /* Encode MP_EXT capability. */
924 if (capability_code
== CAPABILITY_CODE_MP
) {
925 stream_putc(s
, action
);
926 stream_putc(s
, CAPABILITY_CODE_MP
);
927 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
928 stream_putw(s
, pkt_afi
);
930 stream_putc(s
, pkt_safi
);
932 if (bgp_debug_neighbor_events(peer
))
934 "%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %s/%s",
936 action
== CAPABILITY_ACTION_SET
? "Advertising"
938 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
941 /* Set packet size. */
942 (void)bgp_packet_set_size(s
);
944 /* Add packet to the peer. */
945 bgp_packet_add(peer
, s
);
950 /* RFC1771 6.8 Connection collision detection. */
951 static int bgp_collision_detect(struct peer
*new, struct in_addr remote_id
)
955 /* Upon receipt of an OPEN message, the local system must examine
956 all of its connections that are in the OpenConfirm state. A BGP
957 speaker may also examine connections in an OpenSent state if it
958 knows the BGP Identifier of the peer by means outside of the
959 protocol. If among these connections there is a connection to a
960 remote BGP speaker whose BGP Identifier equals the one in the
961 OPEN message, then the local system performs the following
962 collision resolution procedure: */
964 if ((peer
= new->doppelganger
) != NULL
) {
965 /* Do not accept the new connection in Established or Clearing
967 * Note that a peer GR is handled by closing the existing
969 * upon receipt of new one.
971 if (peer
->status
== Established
|| peer
->status
== Clearing
) {
972 bgp_notify_send(new, BGP_NOTIFY_CEASE
,
973 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
975 } else if ((peer
->status
== OpenConfirm
)
976 || (peer
->status
== OpenSent
)) {
977 /* 1. The BGP Identifier of the local system is
978 * compared to the BGP Identifier of the remote
979 * system (as specified in the OPEN message).
981 * If the BGP Identifiers of the peers
982 * involved in the connection collision
983 * are identical, then the connection
984 * initiated by the BGP speaker with the
985 * larger AS number is preserved.
987 if (ntohl(peer
->local_id
.s_addr
)
988 < ntohl(remote_id
.s_addr
)
989 || (ntohl(peer
->local_id
.s_addr
)
990 == ntohl(remote_id
.s_addr
)
991 && peer
->local_as
< peer
->as
))
992 if (!CHECK_FLAG(peer
->sflags
,
993 PEER_STATUS_ACCEPT_PEER
)) {
994 /* 2. If the value of the local BGP
996 than the remote one, the local system
998 connection that already exists (the
1000 already in the OpenConfirm state),
1002 connection initiated by the remote
1005 peer
, BGP_NOTIFY_CEASE
,
1006 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1010 new, BGP_NOTIFY_CEASE
,
1011 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1015 if (ntohl(peer
->local_id
.s_addr
)
1016 == ntohl(remote_id
.s_addr
)
1017 && peer
->local_as
== peer
->as
)
1019 EC_BGP_ROUTER_ID_SAME
,
1020 "Peer's router-id %s is the same as ours",
1021 inet_ntoa(remote_id
));
1023 /* 3. Otherwise, the local system closes newly
1025 BGP connection (the one associated with the
1027 received OPEN message), and continues to use
1029 existing one (the one that is already in the
1030 OpenConfirm state). */
1031 if (CHECK_FLAG(peer
->sflags
,
1032 PEER_STATUS_ACCEPT_PEER
)) {
1034 peer
, BGP_NOTIFY_CEASE
,
1035 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1039 new, BGP_NOTIFY_CEASE
,
1040 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1049 /* Packet processing routines ---------------------------------------------- */
1051 * This is a family of functions designed to be called from
1052 * bgp_process_packet(). These functions all share similar behavior and should
1053 * adhere to the following invariants and restrictions:
1057 * The return code of any one of those functions should be one of the FSM event
1058 * codes specified in bgpd.h. If a NOTIFY was sent, this event code MUST be
1059 * BGP_Stop. Otherwise, the code SHOULD correspond to the function's expected
1060 * packet type. For example, bgp_open_receive() should return BGP_Stop upon
1061 * error and Receive_OPEN_message otherwise.
1063 * If no action is necessary, the correct return code is BGP_PACKET_NOOP as
1068 * - May send NOTIFY messages
1069 * - May not modify peer->status
1070 * - May not call bgp_event_update()
1073 #define BGP_PACKET_NOOP 0
1076 * Process BGP OPEN message for peer.
1078 * If any errors are encountered in the OPEN message, immediately sends NOTIFY
1079 * and returns BGP_Stop.
1082 * @param size size of the packet
1083 * @return as in summary
1085 static int bgp_open_receive(struct peer
*peer
, bgp_size_t size
)
1091 uint16_t send_holdtime
;
1093 as_t as4
= 0, as4_be
;
1094 struct in_addr remote_id
;
1096 uint8_t notify_data_remote_as
[2];
1097 uint8_t notify_data_remote_as4
[4];
1098 uint8_t notify_data_remote_id
[4];
1099 uint16_t *holdtime_ptr
;
1101 /* Parse open packet. */
1102 version
= stream_getc(peer
->curr
);
1103 memcpy(notify_data_remote_as
, stream_pnt(peer
->curr
), 2);
1104 remote_as
= stream_getw(peer
->curr
);
1105 holdtime_ptr
= (uint16_t *)stream_pnt(peer
->curr
);
1106 holdtime
= stream_getw(peer
->curr
);
1107 memcpy(notify_data_remote_id
, stream_pnt(peer
->curr
), 4);
1108 remote_id
.s_addr
= stream_get_ipv4(peer
->curr
);
1110 /* Receive OPEN message log */
1111 if (bgp_debug_neighbor_events(peer
))
1113 "%s rcv OPEN, version %d, remote-as (in open) %u,"
1114 " holdtime %d, id %s",
1115 peer
->host
, version
, remote_as
, holdtime
,
1116 inet_ntoa(remote_id
));
1118 /* BEGIN to read the capability here, but dont do it yet */
1120 optlen
= stream_getc(peer
->curr
);
1123 /* If not enough bytes, it is an error. */
1124 if (STREAM_READABLE(peer
->curr
) < optlen
) {
1125 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1126 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1130 /* We need the as4 capability value *right now* because
1131 * if it is there, we have not got the remote_as yet, and
1133 * that we do not know which peer is connecting to us now.
1135 as4
= peek_for_as4_capability(peer
, optlen
);
1138 as4_be
= htonl(as4
);
1139 memcpy(notify_data_remote_as4
, &as4_be
, 4);
1141 /* Just in case we have a silly peer who sends AS4 capability set to 0
1143 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
) && !as4
) {
1144 flog_err(EC_BGP_PKT_OPEN
,
1145 "%s bad OPEN, got AS4 capability, but AS4 set to 0",
1147 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1148 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1149 notify_data_remote_as4
, 4);
1153 /* Codification of AS 0 Processing */
1154 if (remote_as
== BGP_AS_ZERO
) {
1155 flog_err(EC_BGP_PKT_OPEN
, "%s bad OPEN, got AS set to 0",
1157 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1158 BGP_NOTIFY_OPEN_BAD_PEER_AS
);
1162 if (remote_as
== BGP_AS_TRANS
) {
1163 /* Take the AS4 from the capability. We must have received the
1164 * capability now! Otherwise we have a asn16 peer who uses
1165 * BGP_AS_TRANS, for some unknown reason.
1167 if (as4
== BGP_AS_TRANS
) {
1170 "%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
1172 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1173 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1174 notify_data_remote_as4
, 4);
1178 if (!as4
&& BGP_DEBUG(as4
, AS4
))
1180 "%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
1181 " Odd, but proceeding.",
1183 else if (as4
< BGP_AS_MAX
&& BGP_DEBUG(as4
, AS4
))
1185 "%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
1186 "in 2-bytes, very odd peer.",
1191 /* We may have a partner with AS4 who has an asno < BGP_AS_MAX
1193 /* If we have got the capability, peer->as4cap must match
1195 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1196 && as4
!= remote_as
) {
1197 /* raise error, log this, close session */
1200 "%s bad OPEN, got AS4 capability, but remote_as %u"
1201 " mismatch with 16bit 'myasn' %u in open",
1202 peer
->host
, as4
, remote_as
);
1203 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1204 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1205 notify_data_remote_as4
, 4);
1211 * If the BGP Identifier field of the OPEN message
1212 * is zero, or if it is the same as the BGP Identifier
1213 * of the local BGP speaker and the message is from an
1214 * internal peer, then the Error Subcode is set to
1215 * "Bad BGP Identifier".
1217 if (remote_id
.s_addr
== INADDR_ANY
1218 || IPV4_CLASS_DE(ntohl(remote_id
.s_addr
))
1219 || (peer
->sort
== BGP_PEER_IBGP
1220 && ntohl(peer
->local_id
.s_addr
) == ntohl(remote_id
.s_addr
))) {
1221 if (bgp_debug_neighbor_events(peer
))
1222 zlog_debug("%s bad OPEN, wrong router identifier %s",
1223 peer
->host
, inet_ntoa(remote_id
));
1224 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1225 BGP_NOTIFY_OPEN_BAD_BGP_IDENT
,
1226 notify_data_remote_id
, 4);
1230 /* Set remote router-id */
1231 peer
->remote_id
= remote_id
;
1233 /* Peer BGP version check. */
1234 if (version
!= BGP_VERSION_4
) {
1235 uint16_t maxver
= htons(BGP_VERSION_4
);
1236 /* XXX this reply may not be correct if version < 4 XXX */
1237 if (bgp_debug_neighbor_events(peer
))
1239 "%s bad protocol version, remote requested %d, local request %d",
1240 peer
->host
, version
, BGP_VERSION_4
);
1241 /* Data must be in network byte order here */
1242 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1243 BGP_NOTIFY_OPEN_UNSUP_VERSION
,
1244 (uint8_t *)&maxver
, 2);
1248 /* Check neighbor as number. */
1249 if (peer
->as_type
== AS_UNSPECIFIED
) {
1250 if (bgp_debug_neighbor_events(peer
))
1252 "%s bad OPEN, remote AS is unspecified currently",
1254 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1255 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1256 notify_data_remote_as
, 2);
1258 } else if (peer
->as_type
== AS_INTERNAL
) {
1259 if (remote_as
!= peer
->bgp
->as
) {
1260 if (bgp_debug_neighbor_events(peer
))
1262 "%s bad OPEN, remote AS is %u, internal specified",
1263 peer
->host
, remote_as
);
1264 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1265 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1266 notify_data_remote_as
, 2);
1269 peer
->as
= peer
->local_as
;
1270 } else if (peer
->as_type
== AS_EXTERNAL
) {
1271 if (remote_as
== peer
->bgp
->as
) {
1272 if (bgp_debug_neighbor_events(peer
))
1274 "%s bad OPEN, remote AS is %u, external specified",
1275 peer
->host
, remote_as
);
1276 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1277 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1278 notify_data_remote_as
, 2);
1281 peer
->as
= remote_as
;
1282 } else if ((peer
->as_type
== AS_SPECIFIED
) && (remote_as
!= peer
->as
)) {
1283 if (bgp_debug_neighbor_events(peer
))
1284 zlog_debug("%s bad OPEN, remote AS is %u, expected %u",
1285 peer
->host
, remote_as
, peer
->as
);
1286 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1287 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1288 notify_data_remote_as
, 2);
1292 /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1293 calculate the value of the Hold Timer by using the smaller of its
1294 configured Hold Time and the Hold Time received in the OPEN message.
1295 The Hold Time MUST be either zero or at least three seconds. An
1296 implementation may reject connections on the basis of the Hold Time.
1299 if (holdtime
< 3 && holdtime
!= 0) {
1300 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1301 BGP_NOTIFY_OPEN_UNACEP_HOLDTIME
,
1302 (uint8_t *)holdtime_ptr
, 2);
1306 /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1307 would be one third of the Hold Time interval. KEEPALIVE messages
1308 MUST NOT be sent more frequently than one per second. An
1309 implementation MAY adjust the rate at which it sends KEEPALIVE
1310 messages as a function of the Hold Time interval. */
1312 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
))
1313 send_holdtime
= peer
->holdtime
;
1315 send_holdtime
= peer
->bgp
->default_holdtime
;
1317 if (holdtime
< send_holdtime
)
1318 peer
->v_holdtime
= holdtime
;
1320 peer
->v_holdtime
= send_holdtime
;
1322 if ((CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
))
1323 && (peer
->keepalive
< peer
->v_holdtime
/ 3))
1324 peer
->v_keepalive
= peer
->keepalive
;
1326 peer
->v_keepalive
= peer
->v_holdtime
/ 3;
1328 /* Open option part parse. */
1330 if (bgp_open_option_parse(peer
, optlen
, &mp_capability
) < 0)
1333 if (bgp_debug_neighbor_events(peer
))
1334 zlog_debug("%s rcvd OPEN w/ OPTION parameter len: 0",
1339 * Assume that the peer supports the locally configured set of
1340 * AFI/SAFIs if the peer did not send us any Mulitiprotocol
1341 * capabilities, or if 'override-capability' is configured.
1344 || CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1345 peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] =
1346 peer
->afc
[AFI_IP
][SAFI_UNICAST
];
1347 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] =
1348 peer
->afc
[AFI_IP
][SAFI_MULTICAST
];
1349 peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
] =
1350 peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
];
1351 peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
] =
1352 peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
];
1353 peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] =
1354 peer
->afc
[AFI_IP6
][SAFI_UNICAST
];
1355 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] =
1356 peer
->afc
[AFI_IP6
][SAFI_MULTICAST
];
1357 peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
] =
1358 peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
];
1359 peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
] =
1360 peer
->afc
[AFI_L2VPN
][SAFI_EVPN
];
1361 peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
] =
1362 peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
];
1365 /* When collision is detected and this peer is closed.
1366 * Return immediately.
1368 ret
= bgp_collision_detect(peer
, remote_id
);
1373 if (bgp_getsockname(peer
) < 0) {
1374 flog_err_sys(EC_LIB_SOCKET
,
1375 "%s: bgp_getsockname() failed for peer: %s",
1376 __func__
, peer
->host
);
1380 /* Verify valid local address present based on negotiated
1381 * address-families. */
1382 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1383 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1384 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1385 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1386 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]) {
1387 if (peer
->nexthop
.v4
.s_addr
== INADDR_ANY
) {
1388 #if defined(HAVE_CUMULUS)
1391 "%s: No local IPv4 addr resetting connection, fd %d",
1392 peer
->host
, peer
->fd
);
1393 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1394 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1399 if (peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1400 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1401 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1402 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1403 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]) {
1404 if (IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_global
)) {
1405 #if defined(HAVE_CUMULUS)
1408 "%s: No local IPv6 addr resetting connection, fd %d",
1409 peer
->host
, peer
->fd
);
1410 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1411 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1416 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
1418 return Receive_OPEN_message
;
1422 * Process BGP KEEPALIVE message for peer.
1425 * @param size size of the packet
1426 * @return as in summary
1428 static int bgp_keepalive_receive(struct peer
*peer
, bgp_size_t size
)
1430 if (bgp_debug_keepalive(peer
))
1431 zlog_debug("%s KEEPALIVE rcvd", peer
->host
);
1433 bgp_update_implicit_eors(peer
);
1435 return Receive_KEEPALIVE_message
;
1440 * Process BGP UPDATE message for peer.
1442 * Parses UPDATE and creates attribute object.
1445 * @param size size of the packet
1446 * @return as in summary
1448 static int bgp_update_receive(struct peer
*peer
, bgp_size_t size
)
1454 bgp_size_t attribute_len
;
1455 bgp_size_t update_len
;
1456 bgp_size_t withdraw_len
;
1457 bool restart
= false;
1466 struct bgp_nlri nlris
[NLRI_TYPE_MAX
];
1468 /* Status must be Established. */
1469 if (peer
->status
!= Established
) {
1470 flog_err(EC_BGP_INVALID_STATUS
,
1471 "%s [FSM] Update packet received under status %s",
1473 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1474 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1475 bgp_fsm_error_subcode(peer
->status
));
1479 /* Set initial values. */
1480 memset(&attr
, 0, sizeof(struct attr
));
1481 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1482 attr
.label
= MPLS_INVALID_LABEL
;
1483 memset(&nlris
, 0, sizeof(nlris
));
1484 memset(peer
->rcvd_attr_str
, 0, BUFSIZ
);
1485 peer
->rcvd_attr_printed
= 0;
1488 end
= stream_pnt(s
) + size
;
1490 /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1491 Length is too large (i.e., if Unfeasible Routes Length + Total
1492 Attribute Length + 23 exceeds the message Length), then the Error
1493 Subcode is set to Malformed Attribute List. */
1494 if (stream_pnt(s
) + 2 > end
) {
1495 flog_err(EC_BGP_UPDATE_RCV
,
1496 "%s [Error] Update packet error"
1497 " (packet length is short for unfeasible length)",
1499 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1500 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1504 /* Unfeasible Route Length. */
1505 withdraw_len
= stream_getw(s
);
1507 /* Unfeasible Route Length check. */
1508 if (stream_pnt(s
) + withdraw_len
> end
) {
1509 flog_err(EC_BGP_UPDATE_RCV
,
1510 "%s [Error] Update packet error"
1511 " (packet unfeasible length overflow %d)",
1512 peer
->host
, withdraw_len
);
1513 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1514 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1518 /* Unfeasible Route packet format check. */
1519 if (withdraw_len
> 0) {
1520 nlris
[NLRI_WITHDRAW
].afi
= AFI_IP
;
1521 nlris
[NLRI_WITHDRAW
].safi
= SAFI_UNICAST
;
1522 nlris
[NLRI_WITHDRAW
].nlri
= stream_pnt(s
);
1523 nlris
[NLRI_WITHDRAW
].length
= withdraw_len
;
1524 stream_forward_getp(s
, withdraw_len
);
1527 /* Attribute total length check. */
1528 if (stream_pnt(s
) + 2 > end
) {
1530 EC_BGP_UPDATE_PACKET_SHORT
,
1531 "%s [Error] Packet Error (update packet is short for attribute length)",
1533 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1534 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1538 /* Fetch attribute total length. */
1539 attribute_len
= stream_getw(s
);
1541 /* Attribute length check. */
1542 if (stream_pnt(s
) + attribute_len
> end
) {
1544 EC_BGP_UPDATE_PACKET_LONG
,
1545 "%s [Error] Packet Error (update packet attribute length overflow %d)",
1546 peer
->host
, attribute_len
);
1547 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1548 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1552 /* Certain attribute parsing errors should not be considered bad enough
1553 * to reset the session for, most particularly any partial/optional
1554 * attributes that have 'tunneled' over speakers that don't understand
1555 * them. Instead we withdraw only the prefix concerned.
1557 * Complicates the flow a little though..
1559 bgp_attr_parse_ret_t attr_parse_ret
= BGP_ATTR_PARSE_PROCEED
;
1560 /* This define morphs the update case into a withdraw when lower levels
1561 * have signalled an error condition where this is best.
1563 #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1565 /* Parse attribute when it exists. */
1566 if (attribute_len
) {
1567 attr_parse_ret
= bgp_attr_parse(peer
, &attr
, attribute_len
,
1568 &nlris
[NLRI_MP_UPDATE
],
1569 &nlris
[NLRI_MP_WITHDRAW
]);
1570 if (attr_parse_ret
== BGP_ATTR_PARSE_ERROR
) {
1571 bgp_attr_unintern_sub(&attr
);
1576 /* Logging the attribute. */
1577 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
1578 || BGP_DEBUG(update
, UPDATE_IN
)
1579 || BGP_DEBUG(update
, UPDATE_PREFIX
)) {
1580 ret
= bgp_dump_attr(&attr
, peer
->rcvd_attr_str
, BUFSIZ
);
1582 peer
->stat_upd_7606
++;
1584 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
)
1587 "%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1590 if (ret
&& bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1591 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
1592 peer
->rcvd_attr_str
);
1593 peer
->rcvd_attr_printed
= 1;
1597 /* Network Layer Reachability Information. */
1598 update_len
= end
- stream_pnt(s
);
1601 /* Set NLRI portion to structure. */
1602 nlris
[NLRI_UPDATE
].afi
= AFI_IP
;
1603 nlris
[NLRI_UPDATE
].safi
= SAFI_UNICAST
;
1604 nlris
[NLRI_UPDATE
].nlri
= stream_pnt(s
);
1605 nlris
[NLRI_UPDATE
].length
= update_len
;
1606 stream_forward_getp(s
, update_len
);
1608 if (CHECK_FLAG(attr
.flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
))) {
1610 * We skipped nexthop attribute validation earlier so
1611 * validate the nexthop now.
1613 if (bgp_attr_nexthop_valid(peer
, &attr
) < 0) {
1614 bgp_attr_unintern_sub(&attr
);
1620 if (BGP_DEBUG(update
, UPDATE_IN
))
1621 zlog_debug("%s rcvd UPDATE wlen %d attrlen %d alen %d",
1622 peer
->host
, withdraw_len
, attribute_len
, update_len
);
1624 /* Parse any given NLRIs */
1625 for (int i
= NLRI_UPDATE
; i
< NLRI_TYPE_MAX
; i
++) {
1629 /* NLRI is processed iff the peer if configured for the specific
1631 if (!peer
->afc
[nlris
[i
].afi
][nlris
[i
].safi
]) {
1633 "%s [Info] UPDATE for non-enabled AFI/SAFI %u/%u",
1634 peer
->host
, nlris
[i
].afi
, nlris
[i
].safi
);
1638 /* EoR handled later */
1639 if (nlris
[i
].length
== 0)
1644 case NLRI_MP_UPDATE
:
1645 nlri_ret
= bgp_nlri_parse(peer
, NLRI_ATTR_ARG
,
1649 case NLRI_MP_WITHDRAW
:
1650 nlri_ret
= bgp_nlri_parse(peer
, &attr
, &nlris
[i
], 1);
1653 nlri_ret
= BGP_NLRI_PARSE_ERROR
;
1656 if (nlri_ret
< BGP_NLRI_PARSE_OK
1657 && nlri_ret
!= BGP_NLRI_PARSE_ERROR_PREFIX_OVERFLOW
) {
1658 flog_err(EC_BGP_UPDATE_RCV
,
1659 "%s [Error] Error parsing NLRI", peer
->host
);
1660 if (peer
->status
== Established
)
1662 peer
, BGP_NOTIFY_UPDATE_ERR
,
1664 ? BGP_NOTIFY_UPDATE_INVAL_NETWORK
1665 : BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
);
1666 bgp_attr_unintern_sub(&attr
);
1673 * Non-MP IPv4/Unicast EoR is a completely empty UPDATE
1674 * and MP EoR should have only an empty MP_UNREACH
1676 if ((!update_len
&& !withdraw_len
&& nlris
[NLRI_MP_UPDATE
].length
== 0)
1677 || (attr_parse_ret
== BGP_ATTR_PARSE_EOR
)) {
1680 struct graceful_restart_info
*gr_info
;
1682 /* Restarting router */
1683 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)
1684 && BGP_PEER_RESTARTING_MODE(peer
))
1687 /* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already
1689 * update and withdraw NLRI lengths are 0.
1691 if (!attribute_len
) {
1693 safi
= SAFI_UNICAST
;
1694 } else if (attr
.flag
& ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
)
1695 && nlris
[NLRI_MP_WITHDRAW
].length
== 0) {
1696 afi
= nlris
[NLRI_MP_WITHDRAW
].afi
;
1697 safi
= nlris
[NLRI_MP_WITHDRAW
].safi
;
1698 } else if (attr_parse_ret
== BGP_ATTR_PARSE_EOR
) {
1699 afi
= nlris
[NLRI_MP_UPDATE
].afi
;
1700 safi
= nlris
[NLRI_MP_UPDATE
].safi
;
1703 if (afi
&& peer
->afc
[afi
][safi
]) {
1704 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1706 /* End-of-RIB received */
1707 if (!CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1708 PEER_STATUS_EOR_RECEIVED
)) {
1709 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1710 PEER_STATUS_EOR_RECEIVED
);
1711 bgp_update_explicit_eors(peer
);
1712 /* Update graceful restart information */
1713 gr_info
= &(peer
->bgp
->gr_info
[afi
][safi
]);
1715 gr_info
->eor_received
++;
1716 /* If EOR received from all peers and selection
1717 * deferral timer is running, cancel the timer
1718 * and invoke the best path calculation
1720 if (gr_info
->eor_required
1721 == gr_info
->eor_received
) {
1722 if (bgp_debug_neighbor_events(peer
))
1726 gr_info
->eor_required
,
1728 gr_info
->eor_received
);
1730 gr_info
->t_select_deferral
);
1731 gr_info
->eor_required
= 0;
1732 gr_info
->eor_received
= 0;
1733 /* Best path selection */
1734 if (bgp_best_path_select_defer(
1735 peer
->bgp
, afi
, safi
)
1741 /* NSF delete stale route */
1742 if (peer
->nsf
[afi
][safi
])
1743 bgp_clear_stale_route(peer
, afi
, safi
);
1746 "%s: rcvd End-of-RIB for %s from %s in vrf %s",
1747 __func__
, get_afi_safi_str(afi
, safi
, false),
1748 peer
->host
, vrf
? vrf
->name
: VRF_DEFAULT_NAME
);
1752 /* Everything is done. We unintern temporary structures which
1753 interned in bgp_attr_parse(). */
1754 bgp_attr_unintern_sub(&attr
);
1756 peer
->update_time
= bgp_clock();
1758 /* Rearm holdtime timer */
1759 BGP_TIMER_OFF(peer
->t_holdtime
);
1760 bgp_timer_set(peer
);
1762 return Receive_UPDATE_message
;
1766 * Process BGP NOTIFY message for peer.
1769 * @param size size of the packet
1770 * @return as in summary
1772 static int bgp_notify_receive(struct peer
*peer
, bgp_size_t size
)
1774 struct bgp_notify bgp_notify
;
1776 if (peer
->notify
.data
) {
1777 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1778 peer
->notify
.length
= 0;
1781 bgp_notify
.code
= stream_getc(peer
->curr
);
1782 bgp_notify
.subcode
= stream_getc(peer
->curr
);
1783 bgp_notify
.length
= size
- 2;
1784 bgp_notify
.data
= NULL
;
1786 /* Preserv notify code and sub code. */
1787 peer
->notify
.code
= bgp_notify
.code
;
1788 peer
->notify
.subcode
= bgp_notify
.subcode
;
1789 /* For further diagnostic record returned Data. */
1790 if (bgp_notify
.length
) {
1791 peer
->notify
.length
= size
- 2;
1792 peer
->notify
.data
= XMALLOC(MTYPE_TMP
, size
- 2);
1793 memcpy(peer
->notify
.data
, stream_pnt(peer
->curr
), size
- 2);
1802 if (bgp_notify
.length
) {
1804 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
1805 for (i
= 0; i
< bgp_notify
.length
; i
++)
1807 snprintf(c
, sizeof(c
), " %02x",
1808 stream_getc(peer
->curr
));
1810 strlcat(bgp_notify
.data
, c
,
1811 bgp_notify
.length
* 3);
1815 snprintf(c
, sizeof(c
), "%02x",
1816 stream_getc(peer
->curr
));
1818 strlcpy(bgp_notify
.data
, c
,
1819 bgp_notify
.length
* 3);
1821 bgp_notify
.raw_data
= (uint8_t *)peer
->notify
.data
;
1824 bgp_notify_print(peer
, &bgp_notify
, "received");
1825 if (bgp_notify
.data
) {
1826 XFREE(MTYPE_TMP
, bgp_notify
.data
);
1827 bgp_notify
.length
= 0;
1831 /* peer count update */
1832 atomic_fetch_add_explicit(&peer
->notify_in
, 1, memory_order_relaxed
);
1834 peer
->last_reset
= PEER_DOWN_NOTIFY_RECEIVED
;
1836 /* We have to check for Notify with Unsupported Optional Parameter.
1837 in that case we fallback to open without the capability option.
1838 But this done in bgp_stop. We just mark it here to avoid changing
1840 if (bgp_notify
.code
== BGP_NOTIFY_OPEN_ERR
1841 && bgp_notify
.subcode
== BGP_NOTIFY_OPEN_UNSUP_PARAM
)
1842 UNSET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1844 bgp_peer_gr_flags_update(peer
);
1845 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
1848 return Receive_NOTIFICATION_message
;
1852 * Process BGP ROUTEREFRESH message for peer.
1855 * @param size size of the packet
1856 * @return as in summary
1858 static int bgp_route_refresh_receive(struct peer
*peer
, bgp_size_t size
)
1862 iana_safi_t pkt_safi
;
1865 struct peer_af
*paf
;
1866 struct update_group
*updgrp
;
1867 struct peer
*updgrp_peer
;
1869 /* If peer does not have the capability, send notification. */
1870 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
)) {
1871 flog_err(EC_BGP_NO_CAP
,
1872 "%s [Error] BGP route refresh is not enabled",
1874 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
1875 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
1879 /* Status must be Established. */
1880 if (peer
->status
!= Established
) {
1882 EC_BGP_INVALID_STATUS
,
1883 "%s [Error] Route refresh packet received under status %s",
1885 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1886 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1887 bgp_fsm_error_subcode(peer
->status
));
1894 pkt_afi
= stream_getw(s
);
1895 (void)stream_getc(s
);
1896 pkt_safi
= stream_getc(s
);
1898 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1899 zlog_debug("%s rcvd REFRESH_REQ for afi/safi: %s/%s",
1900 peer
->host
, iana_afi2str(pkt_afi
),
1901 iana_safi2str(pkt_safi
));
1903 /* Convert AFI, SAFI to internal values and check. */
1904 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
1906 "%s REFRESH_REQ for unrecognized afi/safi: %s/%s - ignored",
1907 peer
->host
, iana_afi2str(pkt_afi
),
1908 iana_safi2str(pkt_safi
));
1909 return BGP_PACKET_NOOP
;
1912 if (size
!= BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
) {
1914 uint8_t when_to_refresh
;
1918 if (size
- (BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
)
1920 zlog_info("%s ORF route refresh length error",
1922 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1923 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1927 when_to_refresh
= stream_getc(s
);
1928 end
= stream_pnt(s
) + (size
- 5);
1930 while ((stream_pnt(s
) + 2) < end
) {
1931 orf_type
= stream_getc(s
);
1932 orf_len
= stream_getw(s
);
1934 /* orf_len in bounds? */
1935 if ((stream_pnt(s
) + orf_len
) > end
)
1936 break; /* XXX: Notify instead?? */
1937 if (orf_type
== ORF_TYPE_PREFIX
1938 || orf_type
== ORF_TYPE_PREFIX_OLD
) {
1939 uint8_t *p_pnt
= stream_pnt(s
);
1940 uint8_t *p_end
= stream_pnt(s
) + orf_len
;
1941 struct orf_prefix orfp
;
1946 int ret
= CMD_SUCCESS
;
1948 if (bgp_debug_neighbor_events(peer
)) {
1950 "%s rcvd Prefixlist ORF(%d) length %d",
1951 peer
->host
, orf_type
, orf_len
);
1954 /* we're going to read at least 1 byte of common
1956 * and 7 bytes of ORF Address-filter entry from
1962 /* ORF prefix-list name */
1963 sprintf(name
, "%s.%d.%d", peer
->host
, afi
,
1966 while (p_pnt
< p_end
) {
1967 /* If the ORF entry is malformed, want
1968 * to read as much of it
1969 * as possible without going beyond the
1970 * bounds of the entry,
1971 * to maximise debug information.
1975 sizeof(struct orf_prefix
));
1977 /* after ++: p_pnt <= p_end */
1979 & ORF_COMMON_PART_REMOVE_ALL
) {
1980 if (bgp_debug_neighbor_events(
1983 "%s rcvd Remove-All pfxlist ORF request",
1985 prefix_bgp_orf_remove_all(afi
,
1989 ok
= ((uint32_t)(p_end
- p_pnt
)
1990 >= sizeof(uint32_t));
1994 p_pnt
+= sizeof(uint32_t);
1995 orfp
.seq
= ntohl(seq
);
1999 /* val checked in prefix_bgp_orf_set */
2003 /* val checked in prefix_bgp_orf_set */
2007 if ((ok
= (p_pnt
< p_end
)))
2008 orfp
.p
.prefixlen
= *p_pnt
++;
2010 /* afi checked already */
2011 orfp
.p
.family
= afi2family(afi
);
2014 psize
= PSIZE(orfp
.p
.prefixlen
);
2015 /* valid for family ? */
2016 if (psize
> prefix_blen(&orfp
.p
)) {
2018 psize
= prefix_blen(&orfp
.p
);
2020 /* valid for packet ? */
2021 if (psize
> (p_end
- p_pnt
)) {
2023 psize
= p_end
- p_pnt
;
2027 memcpy(&orfp
.p
.u
.prefix
, p_pnt
,
2031 if (bgp_debug_neighbor_events(peer
)) {
2032 char buf
[INET6_BUFSIZ
];
2035 "%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
2037 (common
& ORF_COMMON_PART_REMOVE
2040 (common
& ORF_COMMON_PART_DENY
2051 ok
? "" : " MALFORMED");
2055 ret
= prefix_bgp_orf_set(
2057 (common
& ORF_COMMON_PART_DENY
2060 (common
& ORF_COMMON_PART_REMOVE
2064 if (!ok
|| (ok
&& ret
!= CMD_SUCCESS
)) {
2066 "%s Received misformatted prefixlist ORF."
2067 " Remove All pfxlist",
2069 prefix_bgp_orf_remove_all(afi
,
2075 peer
->orf_plist
[afi
][safi
] =
2076 prefix_bgp_orf_lookup(afi
, name
);
2078 stream_forward_getp(s
, orf_len
);
2080 if (bgp_debug_neighbor_events(peer
))
2081 zlog_debug("%s rcvd Refresh %s ORF request", peer
->host
,
2082 when_to_refresh
== REFRESH_DEFER
2085 if (when_to_refresh
== REFRESH_DEFER
)
2086 return BGP_PACKET_NOOP
;
2089 /* First update is deferred until ORF or ROUTE-REFRESH is received */
2090 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
2091 PEER_STATUS_ORF_WAIT_REFRESH
))
2092 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
2093 PEER_STATUS_ORF_WAIT_REFRESH
);
2095 paf
= peer_af_find(peer
, afi
, safi
);
2096 if (paf
&& paf
->subgroup
) {
2097 if (peer
->orf_plist
[afi
][safi
]) {
2098 updgrp
= PAF_UPDGRP(paf
);
2099 updgrp_peer
= UPDGRP_PEER(updgrp
);
2100 updgrp_peer
->orf_plist
[afi
][safi
] =
2101 peer
->orf_plist
[afi
][safi
];
2104 /* If the peer is configured for default-originate clear the
2105 * SUBGRP_STATUS_DEFAULT_ORIGINATE flag so that we will
2109 if (CHECK_FLAG(paf
->subgroup
->sflags
,
2110 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
2111 UNSET_FLAG(paf
->subgroup
->sflags
,
2112 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
2115 /* Perform route refreshment to the peer */
2116 bgp_announce_route(peer
, afi
, safi
);
2118 /* No FSM action necessary */
2119 return BGP_PACKET_NOOP
;
2123 * Parse BGP CAPABILITY message for peer.
2126 * @param size size of the packet
2127 * @return as in summary
2129 static int bgp_capability_msg_parse(struct peer
*peer
, uint8_t *pnt
,
2133 struct capability_mp_data mpc
;
2134 struct capability_header
*hdr
;
2138 iana_safi_t pkt_safi
;
2144 /* We need at least action, capability code and capability
2146 if (pnt
+ 3 > end
) {
2147 zlog_info("%s Capability length error", peer
->host
);
2148 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2149 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2153 hdr
= (struct capability_header
*)(pnt
+ 1);
2155 /* Action value check. */
2156 if (action
!= CAPABILITY_ACTION_SET
2157 && action
!= CAPABILITY_ACTION_UNSET
) {
2158 zlog_info("%s Capability Action Value error %d",
2159 peer
->host
, action
);
2160 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2161 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2165 if (bgp_debug_neighbor_events(peer
))
2167 "%s CAPABILITY has action: %d, code: %u, length %u",
2168 peer
->host
, action
, hdr
->code
, hdr
->length
);
2170 /* Capability length check. */
2171 if ((pnt
+ hdr
->length
+ 3) > end
) {
2172 zlog_info("%s Capability length error", peer
->host
);
2173 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2174 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2178 /* Fetch structure to the byte stream. */
2179 memcpy(&mpc
, pnt
+ 3, sizeof(struct capability_mp_data
));
2180 pnt
+= hdr
->length
+ 3;
2182 /* We know MP Capability Code. */
2183 if (hdr
->code
== CAPABILITY_CODE_MP
) {
2184 pkt_afi
= ntohs(mpc
.afi
);
2185 pkt_safi
= mpc
.safi
;
2187 /* Ignore capability when override-capability is set. */
2188 if (CHECK_FLAG(peer
->flags
,
2189 PEER_FLAG_OVERRIDE_CAPABILITY
))
2192 /* Convert AFI, SAFI to internal values. */
2193 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
,
2195 if (bgp_debug_neighbor_events(peer
))
2197 "%s Dynamic Capability MP_EXT afi/safi invalid "
2200 iana_afi2str(pkt_afi
),
2201 iana_safi2str(pkt_safi
));
2205 /* Address family check. */
2206 if (bgp_debug_neighbor_events(peer
))
2208 "%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2210 action
== CAPABILITY_ACTION_SET
2215 if (action
== CAPABILITY_ACTION_SET
) {
2216 peer
->afc_recv
[afi
][safi
] = 1;
2217 if (peer
->afc
[afi
][safi
]) {
2218 peer
->afc_nego
[afi
][safi
] = 1;
2219 bgp_announce_route(peer
, afi
, safi
);
2222 peer
->afc_recv
[afi
][safi
] = 0;
2223 peer
->afc_nego
[afi
][safi
] = 0;
2225 if (peer_active_nego(peer
))
2226 bgp_clear_route(peer
, afi
, safi
);
2232 EC_BGP_UNRECOGNIZED_CAPABILITY
,
2233 "%s unrecognized capability code: %d - ignored",
2234 peer
->host
, hdr
->code
);
2238 /* No FSM action necessary */
2239 return BGP_PACKET_NOOP
;
2243 * Parse BGP CAPABILITY message for peer.
2245 * Exported for unit testing.
2248 * @param size size of the packet
2249 * @return as in summary
2251 int bgp_capability_receive(struct peer
*peer
, bgp_size_t size
)
2255 /* Fetch pointer. */
2256 pnt
= stream_pnt(peer
->curr
);
2258 if (bgp_debug_neighbor_events(peer
))
2259 zlog_debug("%s rcv CAPABILITY", peer
->host
);
2261 /* If peer does not have the capability, send notification. */
2262 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
)) {
2263 flog_err(EC_BGP_NO_CAP
,
2264 "%s [Error] BGP dynamic capability is not enabled",
2266 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
2267 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
2271 /* Status must be Established. */
2272 if (peer
->status
!= Established
) {
2275 "%s [Error] Dynamic capability packet received under status %s",
2277 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
2278 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
2279 bgp_fsm_error_subcode(peer
->status
));
2284 return bgp_capability_msg_parse(peer
, pnt
, size
);
2288 * Processes a peer's input buffer.
2290 * This function sidesteps the event loop and directly calls bgp_event_update()
2291 * after processing each BGP message. This is necessary to ensure proper
2292 * ordering of FSM events and unifies the behavior that was present previously,
2293 * whereby some of the packet handling functions would update the FSM and some
2294 * would not, making event flow difficult to understand. Please think twice
2295 * before hacking this.
2297 * Thread type: THREAD_EVENT
2301 int bgp_process_packet(struct thread
*thread
)
2303 /* Yes first of all get peer pointer. */
2304 struct peer
*peer
; // peer
2305 uint32_t rpkt_quanta_old
; // how many packets to read
2306 int fsm_update_result
; // return code of bgp_event_update()
2307 int mprc
; // message processing return code
2309 peer
= THREAD_ARG(thread
);
2310 rpkt_quanta_old
= atomic_load_explicit(&peer
->bgp
->rpkt_quanta
,
2311 memory_order_relaxed
);
2312 fsm_update_result
= 0;
2314 /* Guard against scheduled events that occur after peer deletion. */
2315 if (peer
->status
== Deleted
|| peer
->status
== Clearing
)
2318 unsigned int processed
= 0;
2320 while (processed
< rpkt_quanta_old
) {
2323 char notify_data_length
[2];
2325 frr_with_mutex(&peer
->io_mtx
) {
2326 peer
->curr
= stream_fifo_pop(peer
->ibuf
);
2329 if (peer
->curr
== NULL
) // no packets to process, hmm...
2332 /* skip the marker and copy the packet length */
2333 stream_forward_getp(peer
->curr
, BGP_MARKER_SIZE
);
2334 memcpy(notify_data_length
, stream_pnt(peer
->curr
), 2);
2336 /* read in the packet length and type */
2337 size
= stream_getw(peer
->curr
);
2338 type
= stream_getc(peer
->curr
);
2340 hook_call(bgp_packet_dump
, peer
, type
, size
, peer
->curr
);
2342 /* adjust size to exclude the marker + length + type */
2343 size
-= BGP_HEADER_SIZE
;
2345 /* Read rest of the packet and call each sort of packet routine
2349 atomic_fetch_add_explicit(&peer
->open_in
, 1,
2350 memory_order_relaxed
);
2351 mprc
= bgp_open_receive(peer
, size
);
2352 if (mprc
== BGP_Stop
)
2355 "%s: BGP OPEN receipt failed for peer: %s",
2356 __func__
, peer
->host
);
2358 case BGP_MSG_UPDATE
:
2359 atomic_fetch_add_explicit(&peer
->update_in
, 1,
2360 memory_order_relaxed
);
2361 peer
->readtime
= monotime(NULL
);
2362 mprc
= bgp_update_receive(peer
, size
);
2363 if (mprc
== BGP_Stop
)
2366 "%s: BGP UPDATE receipt failed for peer: %s",
2367 __func__
, peer
->host
);
2369 case BGP_MSG_NOTIFY
:
2370 atomic_fetch_add_explicit(&peer
->notify_in
, 1,
2371 memory_order_relaxed
);
2372 mprc
= bgp_notify_receive(peer
, size
);
2373 if (mprc
== BGP_Stop
)
2376 "%s: BGP NOTIFY receipt failed for peer: %s",
2377 __func__
, peer
->host
);
2379 case BGP_MSG_KEEPALIVE
:
2380 peer
->readtime
= monotime(NULL
);
2381 atomic_fetch_add_explicit(&peer
->keepalive_in
, 1,
2382 memory_order_relaxed
);
2383 mprc
= bgp_keepalive_receive(peer
, size
);
2384 if (mprc
== BGP_Stop
)
2387 "%s: BGP KEEPALIVE receipt failed for peer: %s",
2388 __func__
, peer
->host
);
2390 case BGP_MSG_ROUTE_REFRESH_NEW
:
2391 case BGP_MSG_ROUTE_REFRESH_OLD
:
2392 atomic_fetch_add_explicit(&peer
->refresh_in
, 1,
2393 memory_order_relaxed
);
2394 mprc
= bgp_route_refresh_receive(peer
, size
);
2395 if (mprc
== BGP_Stop
)
2398 "%s: BGP ROUTEREFRESH receipt failed for peer: %s",
2399 __func__
, peer
->host
);
2401 case BGP_MSG_CAPABILITY
:
2402 atomic_fetch_add_explicit(&peer
->dynamic_cap_in
, 1,
2403 memory_order_relaxed
);
2404 mprc
= bgp_capability_receive(peer
, size
);
2405 if (mprc
== BGP_Stop
)
2408 "%s: BGP CAPABILITY receipt failed for peer: %s",
2409 __func__
, peer
->host
);
2412 /* Suppress uninitialized variable warning */
2416 * The message type should have been sanitized before
2417 * we ever got here. Receipt of a message with an
2418 * invalid header at this point is indicative of a
2421 assert (!"Message of invalid type received during input processing");
2424 /* delete processed packet */
2425 stream_free(peer
->curr
);
2430 if (mprc
!= BGP_PACKET_NOOP
)
2431 fsm_update_result
= bgp_event_update(peer
, mprc
);
2436 * If peer was deleted, do not process any more packets. This
2437 * is usually due to executing BGP_Stop or a stub deletion.
2439 if (fsm_update_result
== FSM_PEER_TRANSFERRED
2440 || fsm_update_result
== FSM_PEER_STOPPED
)
2444 if (fsm_update_result
!= FSM_PEER_TRANSFERRED
2445 && fsm_update_result
!= FSM_PEER_STOPPED
) {
2446 frr_with_mutex(&peer
->io_mtx
) {
2447 // more work to do, come back later
2448 if (peer
->ibuf
->count
> 0)
2449 thread_add_timer_msec(
2450 bm
->master
, bgp_process_packet
, peer
, 0,
2451 &peer
->t_process_packet
);
2458 /* Send EOR when routes are processed by selection deferral timer */
2459 void bgp_send_delayed_eor(struct bgp
*bgp
)
2462 struct listnode
*node
, *nnode
;
2464 /* EOR message sent in bgp_write_proceed_actions */
2465 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
2466 bgp_write_proceed_actions(peer
);