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 int 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
);
657 * Creates a BGP Notify and appends it to the peer's output queue.
659 * This function attempts to write the packet from the thread it is called
660 * from, to ensure the packet gets out ASAP.
662 * This function may be called from multiple threads. Since the function
663 * modifies I/O buffer(s) in the peer, these are locked for the duration of the
664 * call to prevent tampering from other threads.
666 * Delivery of the NOTIFICATION is attempted once and is best-effort. After
667 * return, the peer structure *must* be reset; no assumptions about session
671 * @param code BGP error code
672 * @param sub_code BGP error subcode
673 * @param data Data portion
674 * @param datalen length of data portion
676 void bgp_notify_send_with_data(struct peer
*peer
, uint8_t code
,
677 uint8_t sub_code
, uint8_t *data
, size_t datalen
)
681 /* Lock I/O mutex to prevent other threads from pushing packets */
682 frr_mutex_lock_autounlock(&peer
->io_mtx
);
683 /* ============================================== */
685 /* Allocate new stream. */
686 s
= stream_new(BGP_MAX_PACKET_SIZE
);
688 /* Make notify packet. */
689 bgp_packet_set_marker(s
, BGP_MSG_NOTIFY
);
691 /* Set notify packet values. */
692 stream_putc(s
, code
); /* BGP notify code */
693 stream_putc(s
, sub_code
); /* BGP notify sub_code */
695 /* If notify data is present. */
697 stream_write(s
, data
, datalen
);
699 /* Set BGP packet length. */
700 bgp_packet_set_size(s
);
702 /* wipe output buffer */
703 stream_fifo_clean(peer
->obuf
);
706 * If possible, store last packet for debugging purposes. This check is
707 * in place because we are sometimes called with a doppelganger peer,
708 * who tends to have a plethora of fields nulled out.
711 size_t packetsize
= stream_get_endp(peer
->curr
);
712 assert(packetsize
<= sizeof(peer
->last_reset_cause
));
713 memcpy(peer
->last_reset_cause
, peer
->curr
->data
, packetsize
);
714 peer
->last_reset_cause_size
= packetsize
;
719 struct bgp_notify bgp_notify
;
724 bgp_notify
.code
= code
;
725 bgp_notify
.subcode
= sub_code
;
726 bgp_notify
.data
= NULL
;
727 bgp_notify
.length
= datalen
;
728 bgp_notify
.raw_data
= data
;
730 peer
->notify
.code
= bgp_notify
.code
;
731 peer
->notify
.subcode
= bgp_notify
.subcode
;
733 if (bgp_notify
.length
&& data
) {
735 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
736 for (i
= 0; i
< bgp_notify
.length
; i
++)
738 snprintf(c
, sizeof(c
), " %02x",
741 strlcat(bgp_notify
.data
, c
,
746 snprintf(c
, sizeof(c
), "%02x", data
[i
]);
748 strlcpy(bgp_notify
.data
, c
,
752 bgp_notify_print(peer
, &bgp_notify
, "sending");
754 if (bgp_notify
.data
) {
755 XFREE(MTYPE_TMP
, bgp_notify
.data
);
756 bgp_notify
.length
= 0;
760 /* peer reset cause */
761 if (code
== BGP_NOTIFY_CEASE
) {
762 if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_RESET
)
763 peer
->last_reset
= PEER_DOWN_USER_RESET
;
764 else if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
)
765 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
767 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
769 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
771 /* Add packet to peer's output queue */
772 stream_fifo_push(peer
->obuf
, s
);
774 bgp_peer_gr_flags_update(peer
);
775 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
778 bgp_write_notify(peer
);
782 * Creates a BGP Notify and appends it to the peer's output queue.
784 * This function attempts to write the packet from the thread it is called
785 * from, to ensure the packet gets out ASAP.
788 * @param code BGP error code
789 * @param sub_code BGP error subcode
791 void bgp_notify_send(struct peer
*peer
, uint8_t code
, uint8_t sub_code
)
793 bgp_notify_send_with_data(peer
, code
, sub_code
, NULL
, 0);
797 * Creates BGP Route Refresh packet and appends it to the peer's output queue.
800 * @param afi Address Family Identifier
801 * @param safi Subsequent Address Family Identifier
802 * @param orf_type Outbound Route Filtering type
803 * @param when_to_refresh Whether to refresh immediately or defer
804 * @param remove Whether to remove ORF for specified AFI/SAFI
806 void bgp_route_refresh_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
807 uint8_t orf_type
, uint8_t when_to_refresh
,
811 struct bgp_filter
*filter
;
814 iana_safi_t pkt_safi
;
816 if (DISABLE_BGP_ANNOUNCE
)
819 filter
= &peer
->filter
[afi
][safi
];
821 /* Convert AFI, SAFI to values for packet. */
822 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
824 s
= stream_new(BGP_MAX_PACKET_SIZE
);
826 /* Make BGP update packet. */
827 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
828 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_NEW
);
830 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_OLD
);
832 /* Encode Route Refresh message. */
833 stream_putw(s
, pkt_afi
);
835 stream_putc(s
, pkt_safi
);
837 if (orf_type
== ORF_TYPE_PREFIX
|| orf_type
== ORF_TYPE_PREFIX_OLD
)
838 if (remove
|| filter
->plist
[FILTER_IN
].plist
) {
843 stream_putc(s
, when_to_refresh
);
844 stream_putc(s
, orf_type
);
845 orfp
= stream_get_endp(s
);
849 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
850 PEER_STATUS_ORF_PREFIX_SEND
);
851 stream_putc(s
, ORF_COMMON_PART_REMOVE_ALL
);
852 if (bgp_debug_neighbor_events(peer
))
854 "%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %s/%s",
855 peer
->host
, orf_type
,
856 (when_to_refresh
== REFRESH_DEFER
859 iana_afi2str(pkt_afi
),
860 iana_safi2str(pkt_safi
));
862 SET_FLAG(peer
->af_sflags
[afi
][safi
],
863 PEER_STATUS_ORF_PREFIX_SEND
);
864 prefix_bgp_orf_entry(
865 s
, filter
->plist
[FILTER_IN
].plist
,
867 ORF_COMMON_PART_PERMIT
,
868 ORF_COMMON_PART_DENY
);
869 if (bgp_debug_neighbor_events(peer
))
871 "%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %s/%s",
872 peer
->host
, orf_type
,
873 (when_to_refresh
== REFRESH_DEFER
876 iana_afi2str(pkt_afi
),
877 iana_safi2str(pkt_safi
));
880 /* Total ORF Entry Len. */
881 orf_len
= stream_get_endp(s
) - orfp
- 2;
882 stream_putw_at(s
, orfp
, orf_len
);
885 /* Set packet size. */
886 (void)bgp_packet_set_size(s
);
888 if (bgp_debug_neighbor_events(peer
)) {
890 zlog_debug("%s sending REFRESH_REQ for afi/safi: %s/%s",
891 peer
->host
, iana_afi2str(pkt_afi
),
892 iana_safi2str(pkt_safi
));
895 /* Add packet to the peer. */
896 bgp_packet_add(peer
, s
);
902 * Create a BGP Capability packet and append it to the peer's output queue.
905 * @param afi Address Family Identifier
906 * @param safi Subsequent Address Family Identifier
907 * @param capability_code BGP Capability Code
908 * @param action Set or Remove capability
910 void bgp_capability_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
911 int capability_code
, int action
)
915 iana_safi_t pkt_safi
;
917 /* Convert AFI, SAFI to values for packet. */
918 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
920 s
= stream_new(BGP_MAX_PACKET_SIZE
);
922 /* Make BGP update packet. */
923 bgp_packet_set_marker(s
, BGP_MSG_CAPABILITY
);
925 /* Encode MP_EXT capability. */
926 if (capability_code
== CAPABILITY_CODE_MP
) {
927 stream_putc(s
, action
);
928 stream_putc(s
, CAPABILITY_CODE_MP
);
929 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
930 stream_putw(s
, pkt_afi
);
932 stream_putc(s
, pkt_safi
);
934 if (bgp_debug_neighbor_events(peer
))
936 "%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %s/%s",
938 action
== CAPABILITY_ACTION_SET
? "Advertising"
940 iana_afi2str(pkt_afi
), iana_safi2str(pkt_safi
));
943 /* Set packet size. */
944 (void)bgp_packet_set_size(s
);
946 /* Add packet to the peer. */
947 bgp_packet_add(peer
, s
);
952 /* RFC1771 6.8 Connection collision detection. */
953 static int bgp_collision_detect(struct peer
*new, struct in_addr remote_id
)
957 /* Upon receipt of an OPEN message, the local system must examine
958 all of its connections that are in the OpenConfirm state. A BGP
959 speaker may also examine connections in an OpenSent state if it
960 knows the BGP Identifier of the peer by means outside of the
961 protocol. If among these connections there is a connection to a
962 remote BGP speaker whose BGP Identifier equals the one in the
963 OPEN message, then the local system performs the following
964 collision resolution procedure: */
966 if ((peer
= new->doppelganger
) != NULL
) {
967 /* Do not accept the new connection in Established or Clearing
969 * Note that a peer GR is handled by closing the existing
971 * upon receipt of new one.
973 if (peer
->status
== Established
|| peer
->status
== Clearing
) {
974 bgp_notify_send(new, BGP_NOTIFY_CEASE
,
975 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
977 } else if ((peer
->status
== OpenConfirm
)
978 || (peer
->status
== OpenSent
)) {
979 /* 1. The BGP Identifier of the local system is compared
981 the BGP Identifier of the remote system (as specified
983 the OPEN message). */
985 if (ntohl(peer
->local_id
.s_addr
)
986 < ntohl(remote_id
.s_addr
))
987 if (!CHECK_FLAG(peer
->sflags
,
988 PEER_STATUS_ACCEPT_PEER
)) {
989 /* 2. If the value of the local BGP
991 than the remote one, the local system
993 connection that already exists (the
995 already in the OpenConfirm state),
997 connection initiated by the remote
1000 peer
, BGP_NOTIFY_CEASE
,
1001 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1005 new, BGP_NOTIFY_CEASE
,
1006 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1010 if (ntohl(peer
->local_id
.s_addr
) ==
1011 ntohl(remote_id
.s_addr
))
1012 flog_err(EC_BGP_ROUTER_ID_SAME
, "Peer's router-id %s is the same as ours",
1013 inet_ntoa(remote_id
));
1015 /* 3. Otherwise, the local system closes newly
1017 BGP connection (the one associated with the
1019 received OPEN message), and continues to use
1021 existing one (the one that is already in the
1022 OpenConfirm state). */
1023 if (CHECK_FLAG(peer
->sflags
,
1024 PEER_STATUS_ACCEPT_PEER
)) {
1026 peer
, BGP_NOTIFY_CEASE
,
1027 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1031 new, BGP_NOTIFY_CEASE
,
1032 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
1041 /* Packet processing routines ---------------------------------------------- */
1043 * This is a family of functions designed to be called from
1044 * bgp_process_packet(). These functions all share similar behavior and should
1045 * adhere to the following invariants and restrictions:
1049 * The return code of any one of those functions should be one of the FSM event
1050 * codes specified in bgpd.h. If a NOTIFY was sent, this event code MUST be
1051 * BGP_Stop. Otherwise, the code SHOULD correspond to the function's expected
1052 * packet type. For example, bgp_open_receive() should return BGP_Stop upon
1053 * error and Receive_OPEN_message otherwise.
1055 * If no action is necessary, the correct return code is BGP_PACKET_NOOP as
1060 * - May send NOTIFY messages
1061 * - May not modify peer->status
1062 * - May not call bgp_event_update()
1065 #define BGP_PACKET_NOOP 0
1068 * Process BGP OPEN message for peer.
1070 * If any errors are encountered in the OPEN message, immediately sends NOTIFY
1071 * and returns BGP_Stop.
1074 * @param size size of the packet
1075 * @return as in summary
1077 static int bgp_open_receive(struct peer
*peer
, bgp_size_t size
)
1083 uint16_t send_holdtime
;
1085 as_t as4
= 0, as4_be
;
1086 struct in_addr remote_id
;
1088 uint8_t notify_data_remote_as
[2];
1089 uint8_t notify_data_remote_as4
[4];
1090 uint8_t notify_data_remote_id
[4];
1091 uint16_t *holdtime_ptr
;
1093 /* Parse open packet. */
1094 version
= stream_getc(peer
->curr
);
1095 memcpy(notify_data_remote_as
, stream_pnt(peer
->curr
), 2);
1096 remote_as
= stream_getw(peer
->curr
);
1097 holdtime_ptr
= (uint16_t *)stream_pnt(peer
->curr
);
1098 holdtime
= stream_getw(peer
->curr
);
1099 memcpy(notify_data_remote_id
, stream_pnt(peer
->curr
), 4);
1100 remote_id
.s_addr
= stream_get_ipv4(peer
->curr
);
1102 /* Receive OPEN message log */
1103 if (bgp_debug_neighbor_events(peer
))
1105 "%s rcv OPEN, version %d, remote-as (in open) %u,"
1106 " holdtime %d, id %s",
1107 peer
->host
, version
, remote_as
, holdtime
,
1108 inet_ntoa(remote_id
));
1110 /* BEGIN to read the capability here, but dont do it yet */
1112 optlen
= stream_getc(peer
->curr
);
1115 /* If not enough bytes, it is an error. */
1116 if (STREAM_READABLE(peer
->curr
) < optlen
) {
1117 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1118 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1122 /* We need the as4 capability value *right now* because
1123 * if it is there, we have not got the remote_as yet, and
1125 * that we do not know which peer is connecting to us now.
1127 as4
= peek_for_as4_capability(peer
, optlen
);
1130 as4_be
= htonl(as4
);
1131 memcpy(notify_data_remote_as4
, &as4_be
, 4);
1133 /* Just in case we have a silly peer who sends AS4 capability set to 0
1135 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
) && !as4
) {
1136 flog_err(EC_BGP_PKT_OPEN
,
1137 "%s bad OPEN, got AS4 capability, but AS4 set to 0",
1139 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1140 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1141 notify_data_remote_as4
, 4);
1145 if (remote_as
== BGP_AS_TRANS
) {
1146 /* Take the AS4 from the capability. We must have received the
1147 * capability now! Otherwise we have a asn16 peer who uses
1148 * BGP_AS_TRANS, for some unknown reason.
1150 if (as4
== BGP_AS_TRANS
) {
1153 "%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
1155 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1156 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1157 notify_data_remote_as4
, 4);
1161 if (!as4
&& BGP_DEBUG(as4
, AS4
))
1163 "%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
1164 " Odd, but proceeding.",
1166 else if (as4
< BGP_AS_MAX
&& BGP_DEBUG(as4
, AS4
))
1168 "%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
1169 "in 2-bytes, very odd peer.",
1174 /* We may have a partner with AS4 who has an asno < BGP_AS_MAX
1176 /* If we have got the capability, peer->as4cap must match
1178 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1179 && as4
!= remote_as
) {
1180 /* raise error, log this, close session */
1183 "%s bad OPEN, got AS4 capability, but remote_as %u"
1184 " mismatch with 16bit 'myasn' %u in open",
1185 peer
->host
, as4
, remote_as
);
1186 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1187 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1188 notify_data_remote_as4
, 4);
1193 /* remote router-id check. */
1194 if (remote_id
.s_addr
== INADDR_ANY
1195 || IPV4_CLASS_DE(ntohl(remote_id
.s_addr
))
1196 || ntohl(peer
->local_id
.s_addr
) == ntohl(remote_id
.s_addr
)) {
1197 if (bgp_debug_neighbor_events(peer
))
1198 zlog_debug("%s bad OPEN, wrong router identifier %s",
1199 peer
->host
, inet_ntoa(remote_id
));
1200 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1201 BGP_NOTIFY_OPEN_BAD_BGP_IDENT
,
1202 notify_data_remote_id
, 4);
1206 /* Set remote router-id */
1207 peer
->remote_id
= remote_id
;
1209 /* Peer BGP version check. */
1210 if (version
!= BGP_VERSION_4
) {
1211 uint16_t maxver
= htons(BGP_VERSION_4
);
1212 /* XXX this reply may not be correct if version < 4 XXX */
1213 if (bgp_debug_neighbor_events(peer
))
1215 "%s bad protocol version, remote requested %d, local request %d",
1216 peer
->host
, version
, BGP_VERSION_4
);
1217 /* Data must be in network byte order here */
1218 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1219 BGP_NOTIFY_OPEN_UNSUP_VERSION
,
1220 (uint8_t *)&maxver
, 2);
1224 /* Check neighbor as number. */
1225 if (peer
->as_type
== AS_UNSPECIFIED
) {
1226 if (bgp_debug_neighbor_events(peer
))
1228 "%s bad OPEN, remote AS is unspecified currently",
1230 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1231 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1232 notify_data_remote_as
, 2);
1234 } else if (peer
->as_type
== AS_INTERNAL
) {
1235 if (remote_as
!= peer
->bgp
->as
) {
1236 if (bgp_debug_neighbor_events(peer
))
1238 "%s bad OPEN, remote AS is %u, internal specified",
1239 peer
->host
, remote_as
);
1240 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1241 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1242 notify_data_remote_as
, 2);
1245 peer
->as
= peer
->local_as
;
1246 } else if (peer
->as_type
== AS_EXTERNAL
) {
1247 if (remote_as
== peer
->bgp
->as
) {
1248 if (bgp_debug_neighbor_events(peer
))
1250 "%s bad OPEN, remote AS is %u, external specified",
1251 peer
->host
, remote_as
);
1252 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1253 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1254 notify_data_remote_as
, 2);
1257 peer
->as
= remote_as
;
1258 } else if ((peer
->as_type
== AS_SPECIFIED
) && (remote_as
!= peer
->as
)) {
1259 if (bgp_debug_neighbor_events(peer
))
1260 zlog_debug("%s bad OPEN, remote AS is %u, expected %u",
1261 peer
->host
, remote_as
, peer
->as
);
1262 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1263 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1264 notify_data_remote_as
, 2);
1268 /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1269 calculate the value of the Hold Timer by using the smaller of its
1270 configured Hold Time and the Hold Time received in the OPEN message.
1271 The Hold Time MUST be either zero or at least three seconds. An
1272 implementation may reject connections on the basis of the Hold Time.
1275 if (holdtime
< 3 && holdtime
!= 0) {
1276 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1277 BGP_NOTIFY_OPEN_UNACEP_HOLDTIME
,
1278 (uint8_t *)holdtime_ptr
, 2);
1282 /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1283 would be one third of the Hold Time interval. KEEPALIVE messages
1284 MUST NOT be sent more frequently than one per second. An
1285 implementation MAY adjust the rate at which it sends KEEPALIVE
1286 messages as a function of the Hold Time interval. */
1288 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
))
1289 send_holdtime
= peer
->holdtime
;
1291 send_holdtime
= peer
->bgp
->default_holdtime
;
1293 if (holdtime
< send_holdtime
)
1294 peer
->v_holdtime
= holdtime
;
1296 peer
->v_holdtime
= send_holdtime
;
1298 if ((CHECK_FLAG(peer
->flags
, PEER_FLAG_TIMER
))
1299 && (peer
->keepalive
< peer
->v_holdtime
/ 3))
1300 peer
->v_keepalive
= peer
->keepalive
;
1302 peer
->v_keepalive
= peer
->v_holdtime
/ 3;
1304 /* Open option part parse. */
1306 if ((ret
= bgp_open_option_parse(peer
, optlen
, &mp_capability
))
1310 if (bgp_debug_neighbor_events(peer
))
1311 zlog_debug("%s rcvd OPEN w/ OPTION parameter len: 0",
1316 * Assume that the peer supports the locally configured set of
1317 * AFI/SAFIs if the peer did not send us any Mulitiprotocol
1318 * capabilities, or if 'override-capability' is configured.
1321 || CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1322 peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] =
1323 peer
->afc
[AFI_IP
][SAFI_UNICAST
];
1324 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] =
1325 peer
->afc
[AFI_IP
][SAFI_MULTICAST
];
1326 peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
] =
1327 peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
];
1328 peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
] =
1329 peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
];
1330 peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] =
1331 peer
->afc
[AFI_IP6
][SAFI_UNICAST
];
1332 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] =
1333 peer
->afc
[AFI_IP6
][SAFI_MULTICAST
];
1334 peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
] =
1335 peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
];
1336 peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
] =
1337 peer
->afc
[AFI_L2VPN
][SAFI_EVPN
];
1338 peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
] =
1339 peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
];
1342 /* When collision is detected and this peer is closed. Retrun
1344 ret
= bgp_collision_detect(peer
, remote_id
);
1349 if ((ret
= bgp_getsockname(peer
)) < 0) {
1350 flog_err_sys(EC_LIB_SOCKET
,
1351 "%s: bgp_getsockname() failed for peer: %s",
1352 __FUNCTION__
, peer
->host
);
1356 /* Verify valid local address present based on negotiated
1357 * address-families. */
1358 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1359 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1360 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1361 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1362 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]) {
1363 if (peer
->nexthop
.v4
.s_addr
== INADDR_ANY
) {
1364 #if defined(HAVE_CUMULUS)
1367 "%s: No local IPv4 addr resetting connection, fd %d",
1368 peer
->host
, peer
->fd
);
1369 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1370 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1375 if (peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1376 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1377 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1378 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1379 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]) {
1380 if (IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_global
)) {
1381 #if defined(HAVE_CUMULUS)
1384 "%s: No local IPv6 addr resetting connection, fd %d",
1385 peer
->host
, peer
->fd
);
1386 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1387 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1392 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
1394 return Receive_OPEN_message
;
1398 * Process BGP KEEPALIVE message for peer.
1401 * @param size size of the packet
1402 * @return as in summary
1404 static int bgp_keepalive_receive(struct peer
*peer
, bgp_size_t size
)
1406 if (bgp_debug_keepalive(peer
))
1407 zlog_debug("%s KEEPALIVE rcvd", peer
->host
);
1409 bgp_update_implicit_eors(peer
);
1411 return Receive_KEEPALIVE_message
;
1416 * Process BGP UPDATE message for peer.
1418 * Parses UPDATE and creates attribute object.
1421 * @param size size of the packet
1422 * @return as in summary
1424 static int bgp_update_receive(struct peer
*peer
, bgp_size_t size
)
1430 bgp_size_t attribute_len
;
1431 bgp_size_t update_len
;
1432 bgp_size_t withdraw_len
;
1433 bool restart
= false;
1442 struct bgp_nlri nlris
[NLRI_TYPE_MAX
];
1444 /* Status must be Established. */
1445 if (peer
->status
!= Established
) {
1446 flog_err(EC_BGP_INVALID_STATUS
,
1447 "%s [FSM] Update packet received under status %s",
1449 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1450 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1451 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1455 /* Set initial values. */
1456 memset(&attr
, 0, sizeof(struct attr
));
1457 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1458 attr
.label
= MPLS_INVALID_LABEL
;
1459 memset(&nlris
, 0, sizeof(nlris
));
1460 memset(peer
->rcvd_attr_str
, 0, BUFSIZ
);
1461 peer
->rcvd_attr_printed
= 0;
1464 end
= stream_pnt(s
) + size
;
1466 /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1467 Length is too large (i.e., if Unfeasible Routes Length + Total
1468 Attribute Length + 23 exceeds the message Length), then the Error
1469 Subcode is set to Malformed Attribute List. */
1470 if (stream_pnt(s
) + 2 > end
) {
1471 flog_err(EC_BGP_UPDATE_RCV
,
1472 "%s [Error] Update packet error"
1473 " (packet length is short for unfeasible length)",
1475 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1476 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1480 /* Unfeasible Route Length. */
1481 withdraw_len
= stream_getw(s
);
1483 /* Unfeasible Route Length check. */
1484 if (stream_pnt(s
) + withdraw_len
> end
) {
1485 flog_err(EC_BGP_UPDATE_RCV
,
1486 "%s [Error] Update packet error"
1487 " (packet unfeasible length overflow %d)",
1488 peer
->host
, withdraw_len
);
1489 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1490 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1494 /* Unfeasible Route packet format check. */
1495 if (withdraw_len
> 0) {
1496 nlris
[NLRI_WITHDRAW
].afi
= AFI_IP
;
1497 nlris
[NLRI_WITHDRAW
].safi
= SAFI_UNICAST
;
1498 nlris
[NLRI_WITHDRAW
].nlri
= stream_pnt(s
);
1499 nlris
[NLRI_WITHDRAW
].length
= withdraw_len
;
1500 stream_forward_getp(s
, withdraw_len
);
1503 /* Attribute total length check. */
1504 if (stream_pnt(s
) + 2 > end
) {
1506 EC_BGP_UPDATE_PACKET_SHORT
,
1507 "%s [Error] Packet Error (update packet is short for attribute length)",
1509 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1510 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1514 /* Fetch attribute total length. */
1515 attribute_len
= stream_getw(s
);
1517 /* Attribute length check. */
1518 if (stream_pnt(s
) + attribute_len
> end
) {
1520 EC_BGP_UPDATE_PACKET_LONG
,
1521 "%s [Error] Packet Error (update packet attribute length overflow %d)",
1522 peer
->host
, attribute_len
);
1523 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1524 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1528 /* Certain attribute parsing errors should not be considered bad enough
1529 * to reset the session for, most particularly any partial/optional
1530 * attributes that have 'tunneled' over speakers that don't understand
1531 * them. Instead we withdraw only the prefix concerned.
1533 * Complicates the flow a little though..
1535 bgp_attr_parse_ret_t attr_parse_ret
= BGP_ATTR_PARSE_PROCEED
;
1536 /* This define morphs the update case into a withdraw when lower levels
1537 * have signalled an error condition where this is best.
1539 #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1541 /* Parse attribute when it exists. */
1542 if (attribute_len
) {
1543 attr_parse_ret
= bgp_attr_parse(peer
, &attr
, attribute_len
,
1544 &nlris
[NLRI_MP_UPDATE
],
1545 &nlris
[NLRI_MP_WITHDRAW
]);
1546 if (attr_parse_ret
== BGP_ATTR_PARSE_ERROR
) {
1547 bgp_attr_unintern_sub(&attr
);
1552 /* Logging the attribute. */
1553 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
1554 || BGP_DEBUG(update
, UPDATE_IN
)
1555 || BGP_DEBUG(update
, UPDATE_PREFIX
)) {
1556 ret
= bgp_dump_attr(&attr
, peer
->rcvd_attr_str
, BUFSIZ
);
1558 peer
->stat_upd_7606
++;
1560 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
)
1563 "%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1566 if (ret
&& bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1567 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
1568 peer
->rcvd_attr_str
);
1569 peer
->rcvd_attr_printed
= 1;
1573 /* Network Layer Reachability Information. */
1574 update_len
= end
- stream_pnt(s
);
1577 /* Set NLRI portion to structure. */
1578 nlris
[NLRI_UPDATE
].afi
= AFI_IP
;
1579 nlris
[NLRI_UPDATE
].safi
= SAFI_UNICAST
;
1580 nlris
[NLRI_UPDATE
].nlri
= stream_pnt(s
);
1581 nlris
[NLRI_UPDATE
].length
= update_len
;
1582 stream_forward_getp(s
, update_len
);
1584 if (CHECK_FLAG(attr
.flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
))) {
1586 * We skipped nexthop attribute validation earlier so
1587 * validate the nexthop now.
1589 if (bgp_attr_nexthop_valid(peer
, &attr
) < 0) {
1590 bgp_attr_unintern_sub(&attr
);
1596 if (BGP_DEBUG(update
, UPDATE_IN
))
1597 zlog_debug("%s rcvd UPDATE wlen %d attrlen %d alen %d",
1598 peer
->host
, withdraw_len
, attribute_len
, update_len
);
1600 /* Parse any given NLRIs */
1601 for (int i
= NLRI_UPDATE
; i
< NLRI_TYPE_MAX
; i
++) {
1605 /* NLRI is processed iff the peer if configured for the specific
1607 if (!peer
->afc
[nlris
[i
].afi
][nlris
[i
].safi
]) {
1609 "%s [Info] UPDATE for non-enabled AFI/SAFI %u/%u",
1610 peer
->host
, nlris
[i
].afi
, nlris
[i
].safi
);
1614 /* EoR handled later */
1615 if (nlris
[i
].length
== 0)
1620 case NLRI_MP_UPDATE
:
1621 nlri_ret
= bgp_nlri_parse(peer
, NLRI_ATTR_ARG
,
1625 case NLRI_MP_WITHDRAW
:
1626 nlri_ret
= bgp_nlri_parse(peer
, &attr
, &nlris
[i
], 1);
1629 nlri_ret
= BGP_NLRI_PARSE_ERROR
;
1632 if (nlri_ret
< BGP_NLRI_PARSE_OK
1633 && nlri_ret
!= BGP_NLRI_PARSE_ERROR_PREFIX_OVERFLOW
) {
1634 flog_err(EC_BGP_UPDATE_RCV
,
1635 "%s [Error] Error parsing NLRI", peer
->host
);
1636 if (peer
->status
== Established
)
1638 peer
, BGP_NOTIFY_UPDATE_ERR
,
1640 ? BGP_NOTIFY_UPDATE_INVAL_NETWORK
1641 : BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
);
1642 bgp_attr_unintern_sub(&attr
);
1649 * Non-MP IPv4/Unicast EoR is a completely empty UPDATE
1650 * and MP EoR should have only an empty MP_UNREACH
1652 if ((!update_len
&& !withdraw_len
&& nlris
[NLRI_MP_UPDATE
].length
== 0)
1653 || (attr_parse_ret
== BGP_ATTR_PARSE_EOR
)) {
1656 struct graceful_restart_info
*gr_info
;
1658 /* Restarting router */
1659 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)
1660 && BGP_PEER_RESTARTING_MODE(peer
))
1663 /* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already
1665 * update and withdraw NLRI lengths are 0.
1667 if (!attribute_len
) {
1669 safi
= SAFI_UNICAST
;
1670 } else if (attr
.flag
& ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
)
1671 && nlris
[NLRI_MP_WITHDRAW
].length
== 0) {
1672 afi
= nlris
[NLRI_MP_WITHDRAW
].afi
;
1673 safi
= nlris
[NLRI_MP_WITHDRAW
].safi
;
1674 } else if (attr_parse_ret
== BGP_ATTR_PARSE_EOR
) {
1675 afi
= nlris
[NLRI_MP_UPDATE
].afi
;
1676 safi
= nlris
[NLRI_MP_UPDATE
].safi
;
1679 if (afi
&& peer
->afc
[afi
][safi
]) {
1680 struct vrf
*vrf
= vrf_lookup_by_id(peer
->bgp
->vrf_id
);
1682 /* End-of-RIB received */
1683 if (!CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1684 PEER_STATUS_EOR_RECEIVED
)) {
1685 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1686 PEER_STATUS_EOR_RECEIVED
);
1687 bgp_update_explicit_eors(peer
);
1688 /* Update graceful restart information */
1689 gr_info
= &(peer
->bgp
->gr_info
[afi
][safi
]);
1691 gr_info
->eor_received
++;
1692 /* If EOR received from all peers and selection
1693 * deferral timer is running, cancel the timer
1694 * and invoke the best path calculation
1696 if (gr_info
->eor_required
1697 == gr_info
->eor_received
) {
1698 if (bgp_debug_neighbor_events(peer
))
1702 gr_info
->eor_required
,
1704 gr_info
->eor_received
);
1706 gr_info
->t_select_deferral
);
1707 gr_info
->eor_required
= 0;
1708 gr_info
->eor_received
= 0;
1709 /* Best path selection */
1710 if (bgp_best_path_select_defer(
1711 peer
->bgp
, afi
, safi
)
1717 /* NSF delete stale route */
1718 if (peer
->nsf
[afi
][safi
])
1719 bgp_clear_stale_route(peer
, afi
, safi
);
1722 "%s: rcvd End-of-RIB for %s from %s in vrf %s",
1723 __func__
, get_afi_safi_str(afi
, safi
, false),
1724 peer
->host
, vrf
? vrf
->name
: VRF_DEFAULT_NAME
);
1728 /* Everything is done. We unintern temporary structures which
1729 interned in bgp_attr_parse(). */
1730 bgp_attr_unintern_sub(&attr
);
1732 peer
->update_time
= bgp_clock();
1734 /* Rearm holdtime timer */
1735 BGP_TIMER_OFF(peer
->t_holdtime
);
1736 bgp_timer_set(peer
);
1738 return Receive_UPDATE_message
;
1742 * Process BGP NOTIFY message for peer.
1745 * @param size size of the packet
1746 * @return as in summary
1748 static int bgp_notify_receive(struct peer
*peer
, bgp_size_t size
)
1750 struct bgp_notify bgp_notify
;
1752 if (peer
->notify
.data
) {
1753 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1754 peer
->notify
.length
= 0;
1757 bgp_notify
.code
= stream_getc(peer
->curr
);
1758 bgp_notify
.subcode
= stream_getc(peer
->curr
);
1759 bgp_notify
.length
= size
- 2;
1760 bgp_notify
.data
= NULL
;
1762 /* Preserv notify code and sub code. */
1763 peer
->notify
.code
= bgp_notify
.code
;
1764 peer
->notify
.subcode
= bgp_notify
.subcode
;
1765 /* For further diagnostic record returned Data. */
1766 if (bgp_notify
.length
) {
1767 peer
->notify
.length
= size
- 2;
1768 peer
->notify
.data
= XMALLOC(MTYPE_TMP
, size
- 2);
1769 memcpy(peer
->notify
.data
, stream_pnt(peer
->curr
), size
- 2);
1778 if (bgp_notify
.length
) {
1780 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
1781 for (i
= 0; i
< bgp_notify
.length
; i
++)
1783 snprintf(c
, sizeof(c
), " %02x",
1784 stream_getc(peer
->curr
));
1786 strlcat(bgp_notify
.data
, c
,
1787 bgp_notify
.length
* 3);
1791 snprintf(c
, sizeof(c
), "%02x",
1792 stream_getc(peer
->curr
));
1794 strlcpy(bgp_notify
.data
, c
,
1795 bgp_notify
.length
* 3);
1797 bgp_notify
.raw_data
= (uint8_t *)peer
->notify
.data
;
1800 bgp_notify_print(peer
, &bgp_notify
, "received");
1801 if (bgp_notify
.data
) {
1802 XFREE(MTYPE_TMP
, bgp_notify
.data
);
1803 bgp_notify
.length
= 0;
1807 /* peer count update */
1808 atomic_fetch_add_explicit(&peer
->notify_in
, 1, memory_order_relaxed
);
1810 peer
->last_reset
= PEER_DOWN_NOTIFY_RECEIVED
;
1812 /* We have to check for Notify with Unsupported Optional Parameter.
1813 in that case we fallback to open without the capability option.
1814 But this done in bgp_stop. We just mark it here to avoid changing
1816 if (bgp_notify
.code
== BGP_NOTIFY_OPEN_ERR
1817 && bgp_notify
.subcode
== BGP_NOTIFY_OPEN_UNSUP_PARAM
)
1818 UNSET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1820 bgp_peer_gr_flags_update(peer
);
1821 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(peer
->bgp
,
1824 return Receive_NOTIFICATION_message
;
1828 * Process BGP ROUTEREFRESH message for peer.
1831 * @param size size of the packet
1832 * @return as in summary
1834 static int bgp_route_refresh_receive(struct peer
*peer
, bgp_size_t size
)
1838 iana_safi_t pkt_safi
;
1841 struct peer_af
*paf
;
1842 struct update_group
*updgrp
;
1843 struct peer
*updgrp_peer
;
1845 /* If peer does not have the capability, send notification. */
1846 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
)) {
1847 flog_err(EC_BGP_NO_CAP
,
1848 "%s [Error] BGP route refresh is not enabled",
1850 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
1851 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
1855 /* Status must be Established. */
1856 if (peer
->status
!= Established
) {
1858 EC_BGP_INVALID_STATUS
,
1859 "%s [Error] Route refresh packet received under status %s",
1861 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1862 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
1863 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1870 pkt_afi
= stream_getw(s
);
1871 (void)stream_getc(s
);
1872 pkt_safi
= stream_getc(s
);
1874 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1875 zlog_debug("%s rcvd REFRESH_REQ for afi/safi: %s/%s",
1876 peer
->host
, iana_afi2str(pkt_afi
),
1877 iana_safi2str(pkt_safi
));
1879 /* Convert AFI, SAFI to internal values and check. */
1880 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
1882 "%s REFRESH_REQ for unrecognized afi/safi: %s/%s - ignored",
1883 peer
->host
, iana_afi2str(pkt_afi
),
1884 iana_safi2str(pkt_safi
));
1885 return BGP_PACKET_NOOP
;
1888 if (size
!= BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
) {
1890 uint8_t when_to_refresh
;
1894 if (size
- (BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
)
1896 zlog_info("%s ORF route refresh length error",
1898 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1899 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1903 when_to_refresh
= stream_getc(s
);
1904 end
= stream_pnt(s
) + (size
- 5);
1906 while ((stream_pnt(s
) + 2) < end
) {
1907 orf_type
= stream_getc(s
);
1908 orf_len
= stream_getw(s
);
1910 /* orf_len in bounds? */
1911 if ((stream_pnt(s
) + orf_len
) > end
)
1912 break; /* XXX: Notify instead?? */
1913 if (orf_type
== ORF_TYPE_PREFIX
1914 || orf_type
== ORF_TYPE_PREFIX_OLD
) {
1915 uint8_t *p_pnt
= stream_pnt(s
);
1916 uint8_t *p_end
= stream_pnt(s
) + orf_len
;
1917 struct orf_prefix orfp
;
1922 int ret
= CMD_SUCCESS
;
1924 if (bgp_debug_neighbor_events(peer
)) {
1926 "%s rcvd Prefixlist ORF(%d) length %d",
1927 peer
->host
, orf_type
, orf_len
);
1930 /* we're going to read at least 1 byte of common
1932 * and 7 bytes of ORF Address-filter entry from
1938 /* ORF prefix-list name */
1939 sprintf(name
, "%s.%d.%d", peer
->host
, afi
,
1942 while (p_pnt
< p_end
) {
1943 /* If the ORF entry is malformed, want
1944 * to read as much of it
1945 * as possible without going beyond the
1946 * bounds of the entry,
1947 * to maximise debug information.
1951 sizeof(struct orf_prefix
));
1953 /* after ++: p_pnt <= p_end */
1955 & ORF_COMMON_PART_REMOVE_ALL
) {
1956 if (bgp_debug_neighbor_events(
1959 "%s rcvd Remove-All pfxlist ORF request",
1961 prefix_bgp_orf_remove_all(afi
,
1965 ok
= ((uint32_t)(p_end
- p_pnt
)
1966 >= sizeof(uint32_t));
1970 p_pnt
+= sizeof(uint32_t);
1971 orfp
.seq
= ntohl(seq
);
1975 if ((ok
= (p_pnt
< p_end
)))
1979 prefix_bgp_orf_set()
1981 if ((ok
= (p_pnt
< p_end
)))
1985 prefix_bgp_orf_set()
1987 if ((ok
= (p_pnt
< p_end
)))
1988 orfp
.p
.prefixlen
= *p_pnt
++;
1989 orfp
.p
.family
= afi2family(
1990 afi
); /* afi checked already */
1993 orfp
.p
.prefixlen
); /* 0 if not
1997 &orfp
.p
)) /* valid for
2001 psize
= prefix_blen(&orfp
.p
);
2004 > (p_end
- p_pnt
)) /* valid for
2008 psize
= p_end
- p_pnt
;
2012 memcpy(&orfp
.p
.u
.prefix
, p_pnt
,
2016 if (bgp_debug_neighbor_events(peer
)) {
2017 char buf
[INET6_BUFSIZ
];
2020 "%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
2022 (common
& ORF_COMMON_PART_REMOVE
2025 (common
& ORF_COMMON_PART_DENY
2036 ok
? "" : " MALFORMED");
2040 ret
= prefix_bgp_orf_set(
2042 (common
& ORF_COMMON_PART_DENY
2045 (common
& ORF_COMMON_PART_REMOVE
2049 if (!ok
|| (ok
&& ret
!= CMD_SUCCESS
)) {
2051 "%s Received misformatted prefixlist ORF."
2052 " Remove All pfxlist",
2054 prefix_bgp_orf_remove_all(afi
,
2060 peer
->orf_plist
[afi
][safi
] =
2061 prefix_bgp_orf_lookup(afi
, name
);
2063 stream_forward_getp(s
, orf_len
);
2065 if (bgp_debug_neighbor_events(peer
))
2066 zlog_debug("%s rcvd Refresh %s ORF request", peer
->host
,
2067 when_to_refresh
== REFRESH_DEFER
2070 if (when_to_refresh
== REFRESH_DEFER
)
2071 return BGP_PACKET_NOOP
;
2074 /* First update is deferred until ORF or ROUTE-REFRESH is received */
2075 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
2076 PEER_STATUS_ORF_WAIT_REFRESH
))
2077 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
2078 PEER_STATUS_ORF_WAIT_REFRESH
);
2080 paf
= peer_af_find(peer
, afi
, safi
);
2081 if (paf
&& paf
->subgroup
) {
2082 if (peer
->orf_plist
[afi
][safi
]) {
2083 updgrp
= PAF_UPDGRP(paf
);
2084 updgrp_peer
= UPDGRP_PEER(updgrp
);
2085 updgrp_peer
->orf_plist
[afi
][safi
] =
2086 peer
->orf_plist
[afi
][safi
];
2089 /* If the peer is configured for default-originate clear the
2090 * SUBGRP_STATUS_DEFAULT_ORIGINATE flag so that we will
2094 if (CHECK_FLAG(paf
->subgroup
->sflags
,
2095 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
2096 UNSET_FLAG(paf
->subgroup
->sflags
,
2097 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
2100 /* Perform route refreshment to the peer */
2101 bgp_announce_route(peer
, afi
, safi
);
2103 /* No FSM action necessary */
2104 return BGP_PACKET_NOOP
;
2108 * Parse BGP CAPABILITY message for peer.
2111 * @param size size of the packet
2112 * @return as in summary
2114 static int bgp_capability_msg_parse(struct peer
*peer
, uint8_t *pnt
,
2118 struct capability_mp_data mpc
;
2119 struct capability_header
*hdr
;
2123 iana_safi_t pkt_safi
;
2129 /* We need at least action, capability code and capability
2131 if (pnt
+ 3 > end
) {
2132 zlog_info("%s Capability length error", peer
->host
);
2133 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2134 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2138 hdr
= (struct capability_header
*)(pnt
+ 1);
2140 /* Action value check. */
2141 if (action
!= CAPABILITY_ACTION_SET
2142 && action
!= CAPABILITY_ACTION_UNSET
) {
2143 zlog_info("%s Capability Action Value error %d",
2144 peer
->host
, action
);
2145 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2146 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2150 if (bgp_debug_neighbor_events(peer
))
2152 "%s CAPABILITY has action: %d, code: %u, length %u",
2153 peer
->host
, action
, hdr
->code
, hdr
->length
);
2155 /* Capability length check. */
2156 if ((pnt
+ hdr
->length
+ 3) > end
) {
2157 zlog_info("%s Capability length error", peer
->host
);
2158 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2159 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2163 /* Fetch structure to the byte stream. */
2164 memcpy(&mpc
, pnt
+ 3, sizeof(struct capability_mp_data
));
2165 pnt
+= hdr
->length
+ 3;
2167 /* We know MP Capability Code. */
2168 if (hdr
->code
== CAPABILITY_CODE_MP
) {
2169 pkt_afi
= ntohs(mpc
.afi
);
2170 pkt_safi
= mpc
.safi
;
2172 /* Ignore capability when override-capability is set. */
2173 if (CHECK_FLAG(peer
->flags
,
2174 PEER_FLAG_OVERRIDE_CAPABILITY
))
2177 /* Convert AFI, SAFI to internal values. */
2178 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
,
2180 if (bgp_debug_neighbor_events(peer
))
2182 "%s Dynamic Capability MP_EXT afi/safi invalid "
2185 iana_afi2str(pkt_afi
),
2186 iana_safi2str(pkt_safi
));
2190 /* Address family check. */
2191 if (bgp_debug_neighbor_events(peer
))
2193 "%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2195 action
== CAPABILITY_ACTION_SET
2200 if (action
== CAPABILITY_ACTION_SET
) {
2201 peer
->afc_recv
[afi
][safi
] = 1;
2202 if (peer
->afc
[afi
][safi
]) {
2203 peer
->afc_nego
[afi
][safi
] = 1;
2204 bgp_announce_route(peer
, afi
, safi
);
2207 peer
->afc_recv
[afi
][safi
] = 0;
2208 peer
->afc_nego
[afi
][safi
] = 0;
2210 if (peer_active_nego(peer
))
2211 bgp_clear_route(peer
, afi
, safi
);
2217 EC_BGP_UNRECOGNIZED_CAPABILITY
,
2218 "%s unrecognized capability code: %d - ignored",
2219 peer
->host
, hdr
->code
);
2223 /* No FSM action necessary */
2224 return BGP_PACKET_NOOP
;
2228 * Parse BGP CAPABILITY message for peer.
2230 * Exported for unit testing.
2233 * @param size size of the packet
2234 * @return as in summary
2236 int bgp_capability_receive(struct peer
*peer
, bgp_size_t size
)
2240 /* Fetch pointer. */
2241 pnt
= stream_pnt(peer
->curr
);
2243 if (bgp_debug_neighbor_events(peer
))
2244 zlog_debug("%s rcv CAPABILITY", peer
->host
);
2246 /* If peer does not have the capability, send notification. */
2247 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
)) {
2248 flog_err(EC_BGP_NO_CAP
,
2249 "%s [Error] BGP dynamic capability is not enabled",
2251 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
2252 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
2256 /* Status must be Established. */
2257 if (peer
->status
!= Established
) {
2260 "%s [Error] Dynamic capability packet received under status %s",
2262 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
2263 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
,
2264 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
2269 return bgp_capability_msg_parse(peer
, pnt
, size
);
2273 * Processes a peer's input buffer.
2275 * This function sidesteps the event loop and directly calls bgp_event_update()
2276 * after processing each BGP message. This is necessary to ensure proper
2277 * ordering of FSM events and unifies the behavior that was present previously,
2278 * whereby some of the packet handling functions would update the FSM and some
2279 * would not, making event flow difficult to understand. Please think twice
2280 * before hacking this.
2282 * Thread type: THREAD_EVENT
2286 int bgp_process_packet(struct thread
*thread
)
2288 /* Yes first of all get peer pointer. */
2289 struct peer
*peer
; // peer
2290 uint32_t rpkt_quanta_old
; // how many packets to read
2291 int fsm_update_result
; // return code of bgp_event_update()
2292 int mprc
; // message processing return code
2294 peer
= THREAD_ARG(thread
);
2295 rpkt_quanta_old
= atomic_load_explicit(&peer
->bgp
->rpkt_quanta
,
2296 memory_order_relaxed
);
2297 fsm_update_result
= 0;
2299 /* Guard against scheduled events that occur after peer deletion. */
2300 if (peer
->status
== Deleted
|| peer
->status
== Clearing
)
2303 unsigned int processed
= 0;
2305 while (processed
< rpkt_quanta_old
) {
2308 char notify_data_length
[2];
2310 frr_with_mutex(&peer
->io_mtx
) {
2311 peer
->curr
= stream_fifo_pop(peer
->ibuf
);
2314 if (peer
->curr
== NULL
) // no packets to process, hmm...
2317 /* skip the marker and copy the packet length */
2318 stream_forward_getp(peer
->curr
, BGP_MARKER_SIZE
);
2319 memcpy(notify_data_length
, stream_pnt(peer
->curr
), 2);
2321 /* read in the packet length and type */
2322 size
= stream_getw(peer
->curr
);
2323 type
= stream_getc(peer
->curr
);
2325 hook_call(bgp_packet_dump
, peer
, type
, size
, peer
->curr
);
2327 /* adjust size to exclude the marker + length + type */
2328 size
-= BGP_HEADER_SIZE
;
2330 /* Read rest of the packet and call each sort of packet routine
2334 atomic_fetch_add_explicit(&peer
->open_in
, 1,
2335 memory_order_relaxed
);
2336 mprc
= bgp_open_receive(peer
, size
);
2337 if (mprc
== BGP_Stop
)
2340 "%s: BGP OPEN receipt failed for peer: %s",
2341 __FUNCTION__
, peer
->host
);
2343 case BGP_MSG_UPDATE
:
2344 atomic_fetch_add_explicit(&peer
->update_in
, 1,
2345 memory_order_relaxed
);
2346 peer
->readtime
= monotime(NULL
);
2347 mprc
= bgp_update_receive(peer
, size
);
2348 if (mprc
== BGP_Stop
)
2351 "%s: BGP UPDATE receipt failed for peer: %s",
2352 __FUNCTION__
, peer
->host
);
2354 case BGP_MSG_NOTIFY
:
2355 atomic_fetch_add_explicit(&peer
->notify_in
, 1,
2356 memory_order_relaxed
);
2357 mprc
= bgp_notify_receive(peer
, size
);
2358 if (mprc
== BGP_Stop
)
2361 "%s: BGP NOTIFY receipt failed for peer: %s",
2362 __FUNCTION__
, peer
->host
);
2364 case BGP_MSG_KEEPALIVE
:
2365 peer
->readtime
= monotime(NULL
);
2366 atomic_fetch_add_explicit(&peer
->keepalive_in
, 1,
2367 memory_order_relaxed
);
2368 mprc
= bgp_keepalive_receive(peer
, size
);
2369 if (mprc
== BGP_Stop
)
2372 "%s: BGP KEEPALIVE receipt failed for peer: %s",
2373 __FUNCTION__
, peer
->host
);
2375 case BGP_MSG_ROUTE_REFRESH_NEW
:
2376 case BGP_MSG_ROUTE_REFRESH_OLD
:
2377 atomic_fetch_add_explicit(&peer
->refresh_in
, 1,
2378 memory_order_relaxed
);
2379 mprc
= bgp_route_refresh_receive(peer
, size
);
2380 if (mprc
== BGP_Stop
)
2383 "%s: BGP ROUTEREFRESH receipt failed for peer: %s",
2384 __FUNCTION__
, peer
->host
);
2386 case BGP_MSG_CAPABILITY
:
2387 atomic_fetch_add_explicit(&peer
->dynamic_cap_in
, 1,
2388 memory_order_relaxed
);
2389 mprc
= bgp_capability_receive(peer
, size
);
2390 if (mprc
== BGP_Stop
)
2393 "%s: BGP CAPABILITY receipt failed for peer: %s",
2394 __FUNCTION__
, peer
->host
);
2397 /* Suppress uninitialized variable warning */
2401 * The message type should have been sanitized before
2402 * we ever got here. Receipt of a message with an
2403 * invalid header at this point is indicative of a
2406 assert (!"Message of invalid type received during input processing");
2409 /* delete processed packet */
2410 stream_free(peer
->curr
);
2415 if (mprc
!= BGP_PACKET_NOOP
)
2416 fsm_update_result
= bgp_event_update(peer
, mprc
);
2421 * If peer was deleted, do not process any more packets. This
2422 * is usually due to executing BGP_Stop or a stub deletion.
2424 if (fsm_update_result
== FSM_PEER_TRANSFERRED
2425 || fsm_update_result
== FSM_PEER_STOPPED
)
2429 if (fsm_update_result
!= FSM_PEER_TRANSFERRED
2430 && fsm_update_result
!= FSM_PEER_STOPPED
) {
2431 frr_with_mutex(&peer
->io_mtx
) {
2432 // more work to do, come back later
2433 if (peer
->ibuf
->count
> 0)
2434 thread_add_timer_msec(
2435 bm
->master
, bgp_process_packet
, peer
, 0,
2436 &peer
->t_process_packet
);
2443 /* Send EOR when routes are processed by selection deferral timer */
2444 void bgp_send_delayed_eor(struct bgp
*bgp
)
2447 struct listnode
*node
, *nnode
;
2449 /* EOR message sent in bgp_write_proceed_actions */
2450 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
2451 bgp_write_proceed_actions(peer
);