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 () */
40 #include "bgpd/bgpd.h"
41 #include "bgpd/bgp_table.h"
42 #include "bgpd/bgp_dump.h"
43 #include "bgpd/bgp_attr.h"
44 #include "bgpd/bgp_debug.h"
45 #include "bgpd/bgp_fsm.h"
46 #include "bgpd/bgp_route.h"
47 #include "bgpd/bgp_packet.h"
48 #include "bgpd/bgp_open.h"
49 #include "bgpd/bgp_aspath.h"
50 #include "bgpd/bgp_community.h"
51 #include "bgpd/bgp_ecommunity.h"
52 #include "bgpd/bgp_lcommunity.h"
53 #include "bgpd/bgp_network.h"
54 #include "bgpd/bgp_mplsvpn.h"
55 #include "bgpd/bgp_evpn.h"
56 #include "bgpd/bgp_advertise.h"
57 #include "bgpd/bgp_vty.h"
58 #include "bgpd/bgp_updgrp.h"
59 #include "bgpd/bgp_label.h"
60 #include "bgpd/bgp_io.h"
61 #include "bgpd/bgp_keepalives.h"
64 * Sets marker and type fields for a BGP message.
66 * @param s the stream containing the packet
67 * @param type the packet type
68 * @return the size of the stream
70 int bgp_packet_set_marker(struct stream
*s
, u_char type
)
75 for (i
= 0; i
< BGP_MARKER_SIZE
; i
++)
78 /* Dummy total length. This field is should be filled in later on. */
81 /* BGP packet type. */
84 /* Return current stream size. */
85 return stream_get_endp(s
);
89 * Sets size field for a BGP message.
91 * Size field is set to the size of the stream passed.
93 * @param s the stream containing the packet
94 * @return the size of the stream
96 int bgp_packet_set_size(struct stream
*s
)
100 /* Preserve current pointer. */
101 cp
= stream_get_endp(s
);
102 stream_putw_at(s
, BGP_MARKER_SIZE
, cp
);
108 * Push a packet onto the beginning of the peer's output queue.
109 * This function acquires the peer's write mutex before proceeding.
111 static void bgp_packet_add(struct peer
*peer
, struct stream
*s
)
113 pthread_mutex_lock(&peer
->io_mtx
);
114 stream_fifo_push(peer
->obuf
, s
);
115 pthread_mutex_unlock(&peer
->io_mtx
);
118 static struct stream
*bgp_update_packet_eor(struct peer
*peer
, afi_t afi
,
123 iana_safi_t pkt_safi
;
125 if (DISABLE_BGP_ANNOUNCE
)
128 if (bgp_debug_neighbor_events(peer
))
129 zlog_debug("send End-of-RIB for %s to %s",
130 afi_safi_print(afi
, safi
), peer
->host
);
132 s
= stream_new(BGP_MAX_PACKET_SIZE
);
134 /* Make BGP update packet. */
135 bgp_packet_set_marker(s
, BGP_MSG_UPDATE
);
137 /* Unfeasible Routes Length */
140 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
) {
141 /* Total Path Attribute Length */
144 /* Convert AFI, SAFI to values for packet. */
145 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
147 /* Total Path Attribute Length */
149 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
150 stream_putc(s
, BGP_ATTR_MP_UNREACH_NLRI
);
152 stream_putw(s
, pkt_afi
);
153 stream_putc(s
, pkt_safi
);
156 bgp_packet_set_size(s
);
160 /* Called when there is a change in the EOR(implicit or explicit) status of a
161 * peer. Ends the update-delay if all expected peers are done with EORs. */
162 void bgp_check_update_delay(struct bgp
*bgp
)
164 struct listnode
*node
, *nnode
;
165 struct peer
*peer
= NULL
;
167 if (bgp_debug_neighbor_events(peer
))
168 zlog_debug("Checking update delay, T: %d R: %d I:%d E: %d",
169 bgp
->established
, bgp
->restarted_peers
,
170 bgp
->implicit_eors
, bgp
->explicit_eors
);
173 <= bgp
->restarted_peers
+ bgp
->implicit_eors
+ bgp
->explicit_eors
) {
175 * This is an extra sanity check to make sure we wait for all
176 * the eligible configured peers. This check is performed if
177 * establish wait timer is on, or establish wait option is not
178 * given with the update-delay command
180 if (bgp
->t_establish_wait
181 || (bgp
->v_establish_wait
== bgp
->v_update_delay
))
182 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
183 if (CHECK_FLAG(peer
->flags
,
184 PEER_FLAG_CONFIG_NODE
)
185 && !CHECK_FLAG(peer
->flags
,
187 && !peer
->update_delay_over
) {
188 if (bgp_debug_neighbor_events(peer
))
190 " Peer %s pending, continuing read-only mode",
197 "Update delay ended, restarted: %d, EORs implicit: %d, explicit: %d",
198 bgp
->restarted_peers
, bgp
->implicit_eors
,
200 bgp_update_delay_end(bgp
);
205 * Called if peer is known to have restarted. The restart-state bit in
206 * Graceful-Restart capability is used for that
208 void bgp_update_restarted_peers(struct peer
*peer
)
210 if (!bgp_update_delay_active(peer
->bgp
))
211 return; /* BGP update delay has ended */
212 if (peer
->update_delay_over
)
213 return; /* This peer has already been considered */
215 if (bgp_debug_neighbor_events(peer
))
216 zlog_debug("Peer %s: Checking restarted", peer
->host
);
218 if (peer
->status
== Established
) {
219 peer
->update_delay_over
= 1;
220 peer
->bgp
->restarted_peers
++;
221 bgp_check_update_delay(peer
->bgp
);
226 * Called as peer receives a keep-alive. Determines if this occurence can be
227 * taken as an implicit EOR for this peer.
228 * NOTE: The very first keep-alive after the Established state of a peer is
229 * considered implicit EOR for the update-delay purposes
231 void bgp_update_implicit_eors(struct peer
*peer
)
233 if (!bgp_update_delay_active(peer
->bgp
))
234 return; /* BGP update delay has ended */
235 if (peer
->update_delay_over
)
236 return; /* This peer has already been considered */
238 if (bgp_debug_neighbor_events(peer
))
239 zlog_debug("Peer %s: Checking implicit EORs", peer
->host
);
241 if (peer
->status
== Established
) {
242 peer
->update_delay_over
= 1;
243 peer
->bgp
->implicit_eors
++;
244 bgp_check_update_delay(peer
->bgp
);
249 * Should be called only when there is a change in the EOR_RECEIVED status
250 * for any afi/safi on a peer.
252 static void bgp_update_explicit_eors(struct peer
*peer
)
257 if (!bgp_update_delay_active(peer
->bgp
))
258 return; /* BGP update delay has ended */
259 if (peer
->update_delay_over
)
260 return; /* This peer has already been considered */
262 if (bgp_debug_neighbor_events(peer
))
263 zlog_debug("Peer %s: Checking explicit EORs", peer
->host
);
265 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
266 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
267 if (peer
->afc_nego
[afi
][safi
]
268 && !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
269 PEER_STATUS_EOR_RECEIVED
)) {
270 if (bgp_debug_neighbor_events(peer
))
272 " afi %d safi %d didnt receive EOR",
278 peer
->update_delay_over
= 1;
279 peer
->bgp
->explicit_eors
++;
280 bgp_check_update_delay(peer
->bgp
);
284 * Frontend for NLRI parsing, to fan-out to AFI/SAFI specific parsers.
286 * mp_withdraw, if set, is used to nullify attr structure on most of the
287 * calling safi function and for evpn, passed as parameter
289 int bgp_nlri_parse(struct peer
*peer
, struct attr
*attr
,
290 struct bgp_nlri
*packet
, int mp_withdraw
)
292 switch (packet
->safi
) {
295 return bgp_nlri_parse_ip(peer
, mp_withdraw
? NULL
: attr
,
297 case SAFI_LABELED_UNICAST
:
298 return bgp_nlri_parse_label(peer
, mp_withdraw
? NULL
: attr
,
301 return bgp_nlri_parse_vpn(peer
, mp_withdraw
? NULL
: attr
,
304 return bgp_nlri_parse_evpn(peer
, attr
, packet
, mp_withdraw
);
310 * Checks a variety of conditions to determine whether the peer needs to be
311 * rescheduled for packet generation again, and does so if necessary.
313 * @param peer to check for rescheduling
315 static void bgp_write_proceed_actions(struct peer
*peer
)
320 struct bpacket
*next_pkt
;
321 struct update_subgroup
*subgrp
;
323 FOREACH_AFI_SAFI (afi
, safi
) {
324 paf
= peer_af_find(peer
, afi
, safi
);
327 subgrp
= paf
->subgroup
;
331 next_pkt
= paf
->next_pkt_to_send
;
332 if (next_pkt
&& next_pkt
->buffer
) {
333 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
334 bgp_generate_updgrp_packets
, 0);
338 /* No packets readily available for AFI/SAFI, are there
340 * that need to be generated? */
341 if (bpacket_queue_is_full(SUBGRP_INST(subgrp
),
343 || subgroup_packets_to_build(subgrp
)) {
344 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
345 bgp_generate_updgrp_packets
, 0);
349 /* No packets to send, see if EOR is pending */
350 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
351 if (!subgrp
->t_coalesce
&& peer
->afc_nego
[afi
][safi
]
353 && !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
354 PEER_STATUS_EOR_SEND
)
355 && safi
!= SAFI_MPLS_VPN
) {
356 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
357 bgp_generate_updgrp_packets
, 0);
365 * Generate advertisement information (withdraws, updates, EOR) from each
366 * update group a peer belongs to, encode this information into packets, and
367 * enqueue the packets onto the peer's output buffer.
369 int bgp_generate_updgrp_packets(struct thread
*thread
)
371 struct peer
*peer
= THREAD_ARG(thread
);
375 struct bpacket
*next_pkt
;
377 uint32_t generated
= 0;
381 wpq
= atomic_load_explicit(&peer
->bgp
->wpkt_quanta
,
382 memory_order_relaxed
);
385 * The code beyond this part deals with update packets, proceed only
386 * if peer is Established and updates are not on hold (as part of
387 * update-delay post processing).
389 if (peer
->status
!= Established
)
392 if (peer
->bgp
&& peer
->bgp
->main_peers_update_hold
)
397 FOREACH_AFI_SAFI (afi
, safi
) {
398 paf
= peer_af_find(peer
, afi
, safi
);
399 if (!paf
|| !PAF_SUBGRP(paf
))
401 next_pkt
= paf
->next_pkt_to_send
;
404 * Try to generate a packet for the peer if we are at
405 * the end of the list. Always try to push out
408 if (!next_pkt
|| !next_pkt
->buffer
) {
409 next_pkt
= subgroup_withdraw_packet(
411 if (!next_pkt
|| !next_pkt
->buffer
)
412 subgroup_update_packet(PAF_SUBGRP(paf
));
413 next_pkt
= paf
->next_pkt_to_send
;
417 * If we still don't have a packet to send to the peer,
418 * then try to find out out if we have to send eor or
419 * if not, skip to the next AFI, SAFI. Don't send the
420 * EOR prematurely; if the subgroup's coalesce timer is
421 * running, the adjacency-out structure is not created
424 if (!next_pkt
|| !next_pkt
->buffer
) {
425 if (CHECK_FLAG(peer
->cap
,
426 PEER_CAP_RESTART_RCV
)) {
427 if (!(PAF_SUBGRP(paf
))->t_coalesce
428 && peer
->afc_nego
[afi
][safi
]
433 PEER_STATUS_EOR_SEND
)) {
434 SET_FLAG(peer
->af_sflags
[afi
]
436 PEER_STATUS_EOR_SEND
);
438 if ((s
= bgp_update_packet_eor(
441 bgp_packet_add(peer
, s
);
449 /* Found a packet template to send, overwrite
450 * packet with appropriate attributes from peer
451 * and advance peer */
452 s
= bpacket_reformat_for_peer(next_pkt
, paf
);
453 bgp_packet_add(peer
, s
);
454 bpacket_queue_advance_peer(paf
);
456 } while (s
&& (++generated
< wpq
));
461 bgp_write_proceed_actions(peer
);
467 * Creates a BGP Keepalive packet and appends it to the peer's output queue.
469 void bgp_keepalive_send(struct peer
*peer
)
473 s
= stream_new(BGP_MAX_PACKET_SIZE
);
475 /* Make keepalive packet. */
476 bgp_packet_set_marker(s
, BGP_MSG_KEEPALIVE
);
478 /* Set packet size. */
479 (void)bgp_packet_set_size(s
);
481 /* Dump packet if debug option is set. */
482 /* bgp_packet_dump (s); */
484 if (bgp_debug_keepalive(peer
))
485 zlog_debug("%s sending KEEPALIVE", peer
->host
);
487 /* Add packet to the peer. */
488 bgp_packet_add(peer
, s
);
494 * Creates a BGP Open packet and appends it to the peer's output queue.
495 * Sets capabilities as necessary.
497 void bgp_open_send(struct peer
*peer
)
500 u_int16_t send_holdtime
;
503 if (PEER_OR_GROUP_TIMER_SET(peer
))
504 send_holdtime
= peer
->holdtime
;
506 send_holdtime
= peer
->bgp
->default_holdtime
;
508 /* local-as Change */
509 if (peer
->change_local_as
)
510 local_as
= peer
->change_local_as
;
512 local_as
= peer
->local_as
;
514 s
= stream_new(BGP_MAX_PACKET_SIZE
);
516 /* Make open packet. */
517 bgp_packet_set_marker(s
, BGP_MSG_OPEN
);
519 /* Set open packet values. */
520 stream_putc(s
, BGP_VERSION_4
); /* BGP version */
522 (local_as
<= BGP_AS_MAX
) ? (u_int16_t
)local_as
524 stream_putw(s
, send_holdtime
); /* Hold Time */
525 stream_put_in_addr(s
, &peer
->local_id
); /* BGP Identifier */
527 /* Set capability code. */
528 bgp_open_capability(s
, peer
);
530 /* Set BGP packet length. */
531 (void)bgp_packet_set_size(s
);
533 if (bgp_debug_neighbor_events(peer
))
535 "%s sending OPEN, version %d, my as %u, holdtime %d, id %s",
536 peer
->host
, BGP_VERSION_4
, local_as
, send_holdtime
,
537 inet_ntoa(peer
->local_id
));
539 /* Dump packet if debug option is set. */
540 /* bgp_packet_dump (s); */
542 /* Add packet to the peer. */
543 bgp_packet_add(peer
, s
);
549 * Writes NOTIFICATION message directly to a peer socket without waiting for
552 * There must be exactly one stream on the peer->obuf FIFO, and the data within
553 * this stream must match the format of a BGP NOTIFICATION message.
554 * Transmission is best-effort.
556 * @requires peer->io_mtx
560 static int bgp_write_notify(struct peer
*peer
)
566 /* There should be at least one packet. */
567 s
= stream_fifo_pop(peer
->obuf
);
572 assert(stream_get_endp(s
) >= BGP_HEADER_SIZE
);
574 /* Stop collecting data within the socket */
575 sockopt_cork(peer
->fd
, 0);
578 * socket is in nonblocking mode, if we can't deliver the NOTIFY, well,
579 * we only care about getting a clean shutdown at this point.
581 ret
= write(peer
->fd
, STREAM_DATA(s
), stream_get_endp(s
));
584 * only connection reset/close gets counted as TCP_fatal_error, failure
585 * to write the entire NOTIFY doesn't get different FSM treatment
589 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
593 /* Disable Nagle, make NOTIFY packet go out right away */
595 (void)setsockopt(peer
->fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
,
598 /* Retrieve BGP packet type. */
599 stream_set_getp(s
, BGP_MARKER_SIZE
+ 2);
600 type
= stream_getc(s
);
602 assert(type
== BGP_MSG_NOTIFY
);
604 /* Type should be notify. */
605 atomic_fetch_add_explicit(&peer
->notify_out
, 1, memory_order_relaxed
);
608 /* Double start timer. */
611 /* Overflow check. */
612 if (peer
->v_start
>= (60 * 2))
613 peer
->v_start
= (60 * 2);
616 * Handle Graceful Restart case where the state changes to
617 * Connect instead of Idle
619 BGP_EVENT_ADD(peer
, BGP_Stop
);
627 * Creates a BGP Notify and appends it to the peer's output queue.
629 * This function attempts to write the packet from the thread it is called
630 * from, to ensure the packet gets out ASAP.
632 * This function may be called from multiple threads. Since the function
633 * modifies I/O buffer(s) in the peer, these are locked for the duration of the
634 * call to prevent tampering from other threads.
636 * Delivery of the NOTIFICATION is attempted once and is best-effort. After
637 * return, the peer structure *must* be reset; no assumptions about session
641 * @param code BGP error code
642 * @param sub_code BGP error subcode
643 * @param data Data portion
644 * @param datalen length of data portion
646 void bgp_notify_send_with_data(struct peer
*peer
, u_char code
, u_char sub_code
,
647 u_char
*data
, size_t datalen
)
652 /* Lock I/O mutex to prevent other threads from pushing packets */
653 pthread_mutex_lock(&peer
->io_mtx
);
654 /* ============================================== */
656 /* Allocate new stream. */
657 s
= stream_new(BGP_MAX_PACKET_SIZE
);
659 /* Make notify packet. */
660 bgp_packet_set_marker(s
, BGP_MSG_NOTIFY
);
662 /* Set notify packet values. */
663 stream_putc(s
, code
); /* BGP notify code */
664 stream_putc(s
, sub_code
); /* BGP notify sub_code */
666 /* If notify data is present. */
668 stream_write(s
, data
, datalen
);
670 /* Set BGP packet length. */
671 length
= bgp_packet_set_size(s
);
673 /* wipe output buffer */
674 stream_fifo_clean(peer
->obuf
);
677 * If possible, store last packet for debugging purposes. This check is
678 * in place because we are sometimes called with a doppelganger peer,
679 * who tends to have a plethora of fields nulled out.
681 if (peer
->curr
&& peer
->last_reset_cause_size
) {
682 size_t packetsize
= stream_get_endp(peer
->curr
);
683 assert(packetsize
<= peer
->last_reset_cause_size
);
684 memcpy(peer
->last_reset_cause
, peer
->curr
->data
, packetsize
);
685 peer
->last_reset_cause_size
= packetsize
;
690 struct bgp_notify bgp_notify
;
695 bgp_notify
.code
= code
;
696 bgp_notify
.subcode
= sub_code
;
697 bgp_notify
.data
= NULL
;
698 bgp_notify
.length
= length
- BGP_MSG_NOTIFY_MIN_SIZE
;
699 bgp_notify
.raw_data
= data
;
701 peer
->notify
.code
= bgp_notify
.code
;
702 peer
->notify
.subcode
= bgp_notify
.subcode
;
704 if (bgp_notify
.length
) {
706 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
707 for (i
= 0; i
< bgp_notify
.length
; i
++)
709 sprintf(c
, " %02x", data
[i
]);
710 strcat(bgp_notify
.data
, c
);
713 sprintf(c
, "%02x", data
[i
]);
714 strcpy(bgp_notify
.data
, c
);
717 bgp_notify_print(peer
, &bgp_notify
, "sending");
719 if (bgp_notify
.data
) {
720 XFREE(MTYPE_TMP
, bgp_notify
.data
);
721 bgp_notify
.data
= NULL
;
722 bgp_notify
.length
= 0;
726 /* peer reset cause */
727 if (code
== BGP_NOTIFY_CEASE
) {
728 if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_RESET
)
729 peer
->last_reset
= PEER_DOWN_USER_RESET
;
730 else if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
)
731 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
733 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
735 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
737 /* Add packet to peer's output queue */
738 stream_fifo_push(peer
->obuf
, s
);
740 bgp_write_notify(peer
);
742 /* ============================================== */
743 pthread_mutex_unlock(&peer
->io_mtx
);
747 * Creates a BGP Notify and appends it to the peer's output queue.
749 * This function attempts to write the packet from the thread it is called
750 * from, to ensure the packet gets out ASAP.
753 * @param code BGP error code
754 * @param sub_code BGP error subcode
756 void bgp_notify_send(struct peer
*peer
, u_char code
, u_char sub_code
)
758 bgp_notify_send_with_data(peer
, code
, sub_code
, NULL
, 0);
762 * Creates BGP Route Refresh packet and appends it to the peer's output queue.
765 * @param afi Address Family Identifier
766 * @param safi Subsequent Address Family Identifier
767 * @param orf_type Outbound Route Filtering type
768 * @param when_to_refresh Whether to refresh immediately or defer
769 * @param remove Whether to remove ORF for specified AFI/SAFI
771 void bgp_route_refresh_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
772 u_char orf_type
, u_char when_to_refresh
, int remove
)
775 struct bgp_filter
*filter
;
778 iana_safi_t pkt_safi
;
780 if (DISABLE_BGP_ANNOUNCE
)
783 filter
= &peer
->filter
[afi
][safi
];
785 /* Convert AFI, SAFI to values for packet. */
786 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
788 s
= stream_new(BGP_MAX_PACKET_SIZE
);
790 /* Make BGP update packet. */
791 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
792 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_NEW
);
794 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_OLD
);
796 /* Encode Route Refresh message. */
797 stream_putw(s
, pkt_afi
);
799 stream_putc(s
, pkt_safi
);
801 if (orf_type
== ORF_TYPE_PREFIX
|| orf_type
== ORF_TYPE_PREFIX_OLD
)
802 if (remove
|| filter
->plist
[FILTER_IN
].plist
) {
807 stream_putc(s
, when_to_refresh
);
808 stream_putc(s
, orf_type
);
809 orfp
= stream_get_endp(s
);
813 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
814 PEER_STATUS_ORF_PREFIX_SEND
);
815 stream_putc(s
, ORF_COMMON_PART_REMOVE_ALL
);
816 if (bgp_debug_neighbor_events(peer
))
818 "%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %d/%d",
819 peer
->host
, orf_type
,
820 (when_to_refresh
== REFRESH_DEFER
825 SET_FLAG(peer
->af_sflags
[afi
][safi
],
826 PEER_STATUS_ORF_PREFIX_SEND
);
827 prefix_bgp_orf_entry(
828 s
, filter
->plist
[FILTER_IN
].plist
,
830 ORF_COMMON_PART_PERMIT
,
831 ORF_COMMON_PART_DENY
);
832 if (bgp_debug_neighbor_events(peer
))
834 "%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %d/%d",
835 peer
->host
, orf_type
,
836 (when_to_refresh
== REFRESH_DEFER
842 /* Total ORF Entry Len. */
843 orf_len
= stream_get_endp(s
) - orfp
- 2;
844 stream_putw_at(s
, orfp
, orf_len
);
847 /* Set packet size. */
848 (void)bgp_packet_set_size(s
);
850 if (bgp_debug_neighbor_events(peer
)) {
852 zlog_debug("%s sending REFRESH_REQ for afi/safi: %d/%d",
853 peer
->host
, pkt_afi
, pkt_safi
);
856 /* Add packet to the peer. */
857 bgp_packet_add(peer
, s
);
863 * Create a BGP Capability packet and append it to the peer's output queue.
866 * @param afi Address Family Identifier
867 * @param safi Subsequent Address Family Identifier
868 * @param capability_code BGP Capability Code
869 * @param action Set or Remove capability
871 void bgp_capability_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
872 int capability_code
, int action
)
876 iana_safi_t pkt_safi
;
878 /* Convert AFI, SAFI to values for packet. */
879 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
881 s
= stream_new(BGP_MAX_PACKET_SIZE
);
883 /* Make BGP update packet. */
884 bgp_packet_set_marker(s
, BGP_MSG_CAPABILITY
);
886 /* Encode MP_EXT capability. */
887 if (capability_code
== CAPABILITY_CODE_MP
) {
888 stream_putc(s
, action
);
889 stream_putc(s
, CAPABILITY_CODE_MP
);
890 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
891 stream_putw(s
, pkt_afi
);
893 stream_putc(s
, pkt_safi
);
895 if (bgp_debug_neighbor_events(peer
))
897 "%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %d/%d",
899 action
== CAPABILITY_ACTION_SET
? "Advertising"
904 /* Set packet size. */
905 (void)bgp_packet_set_size(s
);
907 /* Add packet to the peer. */
908 bgp_packet_add(peer
, s
);
913 /* RFC1771 6.8 Connection collision detection. */
914 static int bgp_collision_detect(struct peer
*new, struct in_addr remote_id
)
918 /* Upon receipt of an OPEN message, the local system must examine
919 all of its connections that are in the OpenConfirm state. A BGP
920 speaker may also examine connections in an OpenSent state if it
921 knows the BGP Identifier of the peer by means outside of the
922 protocol. If among these connections there is a connection to a
923 remote BGP speaker whose BGP Identifier equals the one in the
924 OPEN message, then the local system performs the following
925 collision resolution procedure: */
927 if ((peer
= new->doppelganger
) != NULL
) {
928 /* Do not accept the new connection in Established or Clearing
930 * Note that a peer GR is handled by closing the existing
932 * upon receipt of new one.
934 if (peer
->status
== Established
|| peer
->status
== Clearing
) {
935 bgp_notify_send(new, BGP_NOTIFY_CEASE
,
936 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
938 } else if ((peer
->status
== OpenConfirm
)
939 || (peer
->status
== OpenSent
)) {
940 /* 1. The BGP Identifier of the local system is compared
942 the BGP Identifier of the remote system (as specified
944 the OPEN message). */
946 if (ntohl(peer
->local_id
.s_addr
)
947 < ntohl(remote_id
.s_addr
))
948 if (!CHECK_FLAG(peer
->sflags
,
949 PEER_STATUS_ACCEPT_PEER
)) {
950 /* 2. If the value of the local BGP
952 than the remote one, the local system
954 connection that already exists (the
956 already in the OpenConfirm state),
958 connection initiated by the remote
961 peer
, BGP_NOTIFY_CEASE
,
962 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
966 new, BGP_NOTIFY_CEASE
,
967 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
971 /* 3. Otherwise, the local system closes newly
973 BGP connection (the one associated with the
975 received OPEN message), and continues to use
977 existing one (the one that is already in the
978 OpenConfirm state). */
979 if (CHECK_FLAG(peer
->sflags
,
980 PEER_STATUS_ACCEPT_PEER
)) {
982 peer
, BGP_NOTIFY_CEASE
,
983 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
987 new, BGP_NOTIFY_CEASE
,
988 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
997 /* Packet processing routines ---------------------------------------------- */
999 * This is a family of functions designed to be called from
1000 * bgp_process_packet(). These functions all share similar behavior and should
1001 * adhere to the following invariants and restrictions:
1005 * The return code of any one of those functions should be one of the FSM event
1006 * codes specified in bgpd.h. If a NOTIFY was sent, this event code MUST be
1007 * BGP_Stop. Otherwise, the code SHOULD correspond to the function's expected
1008 * packet type. For example, bgp_open_receive() should return BGP_Stop upon
1009 * error and Receive_OPEN_message otherwise.
1011 * If no action is necessary, the correct return code is BGP_PACKET_NOOP as
1016 * - May send NOTIFY messages
1017 * - May not modify peer->status
1018 * - May not call bgp_event_update()
1021 #define BGP_PACKET_NOOP 0
1024 * Process BGP OPEN message for peer.
1026 * If any errors are encountered in the OPEN message, immediately sends NOTIFY
1027 * and returns BGP_Stop.
1030 * @param size size of the packet
1031 * @return as in summary
1033 static int bgp_open_receive(struct peer
*peer
, bgp_size_t size
)
1039 u_int16_t send_holdtime
;
1042 struct in_addr remote_id
;
1044 u_int8_t notify_data_remote_as
[2];
1045 u_int8_t notify_data_remote_as4
[4];
1046 u_int8_t notify_data_remote_id
[4];
1047 u_int16_t
*holdtime_ptr
;
1049 /* Parse open packet. */
1050 version
= stream_getc(peer
->curr
);
1051 memcpy(notify_data_remote_as
, stream_pnt(peer
->curr
), 2);
1052 remote_as
= stream_getw(peer
->curr
);
1053 holdtime_ptr
= (u_int16_t
*)stream_pnt(peer
->curr
);
1054 holdtime
= stream_getw(peer
->curr
);
1055 memcpy(notify_data_remote_id
, stream_pnt(peer
->curr
), 4);
1056 remote_id
.s_addr
= stream_get_ipv4(peer
->curr
);
1058 /* Receive OPEN message log */
1059 if (bgp_debug_neighbor_events(peer
))
1061 "%s rcv OPEN, version %d, remote-as (in open) %u,"
1062 " holdtime %d, id %s",
1063 peer
->host
, version
, remote_as
, holdtime
,
1064 inet_ntoa(remote_id
));
1066 /* BEGIN to read the capability here, but dont do it yet */
1068 optlen
= stream_getc(peer
->curr
);
1071 /* If not enough bytes, it is an error. */
1072 if (STREAM_READABLE(peer
->curr
) < optlen
) {
1073 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1074 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1078 /* We need the as4 capability value *right now* because
1079 * if it is there, we have not got the remote_as yet, and
1081 * that we do not know which peer is connecting to us now.
1083 as4
= peek_for_as4_capability(peer
, optlen
);
1084 memcpy(notify_data_remote_as4
, &as4
, 4);
1087 /* Just in case we have a silly peer who sends AS4 capability set to 0
1089 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
) && !as4
) {
1090 zlog_err("%s bad OPEN, got AS4 capability, but AS4 set to 0",
1092 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1093 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1094 notify_data_remote_as4
, 4);
1098 if (remote_as
== BGP_AS_TRANS
) {
1099 /* Take the AS4 from the capability. We must have received the
1100 * capability now! Otherwise we have a asn16 peer who uses
1101 * BGP_AS_TRANS, for some unknown reason.
1103 if (as4
== BGP_AS_TRANS
) {
1105 "%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
1107 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1108 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1109 notify_data_remote_as4
, 4);
1113 if (!as4
&& BGP_DEBUG(as4
, AS4
))
1115 "%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
1116 " Odd, but proceeding.",
1118 else if (as4
< BGP_AS_MAX
&& BGP_DEBUG(as4
, AS4
))
1120 "%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
1121 "in 2-bytes, very odd peer.",
1126 /* We may have a partner with AS4 who has an asno < BGP_AS_MAX
1128 /* If we have got the capability, peer->as4cap must match
1130 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1131 && as4
!= remote_as
) {
1132 /* raise error, log this, close session */
1134 "%s bad OPEN, got AS4 capability, but remote_as %u"
1135 " mismatch with 16bit 'myasn' %u in open",
1136 peer
->host
, as4
, remote_as
);
1137 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1138 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1139 notify_data_remote_as4
, 4);
1144 /* remote router-id check. */
1145 if (remote_id
.s_addr
== 0 || IPV4_CLASS_DE(ntohl(remote_id
.s_addr
))
1146 || ntohl(peer
->local_id
.s_addr
) == ntohl(remote_id
.s_addr
)) {
1147 if (bgp_debug_neighbor_events(peer
))
1148 zlog_debug("%s bad OPEN, wrong router identifier %s",
1149 peer
->host
, inet_ntoa(remote_id
));
1150 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1151 BGP_NOTIFY_OPEN_BAD_BGP_IDENT
,
1152 notify_data_remote_id
, 4);
1156 /* Set remote router-id */
1157 peer
->remote_id
= remote_id
;
1159 /* Peer BGP version check. */
1160 if (version
!= BGP_VERSION_4
) {
1161 u_int16_t maxver
= htons(BGP_VERSION_4
);
1162 /* XXX this reply may not be correct if version < 4 XXX */
1163 if (bgp_debug_neighbor_events(peer
))
1165 "%s bad protocol version, remote requested %d, local request %d",
1166 peer
->host
, version
, BGP_VERSION_4
);
1167 /* Data must be in network byte order here */
1168 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1169 BGP_NOTIFY_OPEN_UNSUP_VERSION
,
1170 (u_int8_t
*)&maxver
, 2);
1174 /* Check neighbor as number. */
1175 if (peer
->as_type
== AS_UNSPECIFIED
) {
1176 if (bgp_debug_neighbor_events(peer
))
1178 "%s bad OPEN, remote AS is unspecified currently",
1180 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1181 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1182 notify_data_remote_as
, 2);
1184 } else if (peer
->as_type
== AS_INTERNAL
) {
1185 if (remote_as
!= peer
->bgp
->as
) {
1186 if (bgp_debug_neighbor_events(peer
))
1188 "%s bad OPEN, remote AS is %u, internal specified",
1189 peer
->host
, remote_as
);
1190 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1191 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1192 notify_data_remote_as
, 2);
1195 peer
->as
= peer
->local_as
;
1196 } else if (peer
->as_type
== AS_EXTERNAL
) {
1197 if (remote_as
== peer
->bgp
->as
) {
1198 if (bgp_debug_neighbor_events(peer
))
1200 "%s bad OPEN, remote AS is %u, external specified",
1201 peer
->host
, remote_as
);
1202 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1203 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1204 notify_data_remote_as
, 2);
1207 peer
->as
= remote_as
;
1208 } else if ((peer
->as_type
== AS_SPECIFIED
) && (remote_as
!= peer
->as
)) {
1209 if (bgp_debug_neighbor_events(peer
))
1210 zlog_debug("%s bad OPEN, remote AS is %u, expected %u",
1211 peer
->host
, remote_as
, peer
->as
);
1212 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1213 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1214 notify_data_remote_as
, 2);
1218 /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1219 calculate the value of the Hold Timer by using the smaller of its
1220 configured Hold Time and the Hold Time received in the OPEN message.
1221 The Hold Time MUST be either zero or at least three seconds. An
1222 implementation may reject connections on the basis of the Hold Time.
1225 if (holdtime
< 3 && holdtime
!= 0) {
1226 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1227 BGP_NOTIFY_OPEN_UNACEP_HOLDTIME
,
1228 (u_char
*)holdtime_ptr
, 2);
1232 /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1233 would be one third of the Hold Time interval. KEEPALIVE messages
1234 MUST NOT be sent more frequently than one per second. An
1235 implementation MAY adjust the rate at which it sends KEEPALIVE
1236 messages as a function of the Hold Time interval. */
1238 if (PEER_OR_GROUP_TIMER_SET(peer
))
1239 send_holdtime
= peer
->holdtime
;
1241 send_holdtime
= peer
->bgp
->default_holdtime
;
1243 if (holdtime
< send_holdtime
)
1244 peer
->v_holdtime
= holdtime
;
1246 peer
->v_holdtime
= send_holdtime
;
1248 if ((PEER_OR_GROUP_TIMER_SET(peer
))
1249 && (peer
->keepalive
< peer
->v_holdtime
/ 3))
1250 peer
->v_keepalive
= peer
->keepalive
;
1252 peer
->v_keepalive
= peer
->v_holdtime
/ 3;
1254 /* Open option part parse. */
1256 if ((ret
= bgp_open_option_parse(peer
, optlen
, &mp_capability
))
1260 if (bgp_debug_neighbor_events(peer
))
1261 zlog_debug("%s rcvd OPEN w/ OPTION parameter len: 0",
1266 * Assume that the peer supports the locally configured set of
1267 * AFI/SAFIs if the peer did not send us any Mulitiprotocol
1268 * capabilities, or if 'override-capability' is configured.
1271 || CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1272 peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] =
1273 peer
->afc
[AFI_IP
][SAFI_UNICAST
];
1274 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] =
1275 peer
->afc
[AFI_IP
][SAFI_MULTICAST
];
1276 peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
] =
1277 peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
];
1278 peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] =
1279 peer
->afc
[AFI_IP6
][SAFI_UNICAST
];
1280 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] =
1281 peer
->afc
[AFI_IP6
][SAFI_MULTICAST
];
1282 peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
] =
1283 peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
];
1284 peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
] =
1285 peer
->afc
[AFI_L2VPN
][SAFI_EVPN
];
1288 /* When collision is detected and this peer is closed. Retrun
1290 ret
= bgp_collision_detect(peer
, remote_id
);
1295 if ((ret
= bgp_getsockname(peer
)) < 0) {
1296 zlog_err("%s: bgp_getsockname() failed for peer: %s",
1297 __FUNCTION__
, peer
->host
);
1301 /* Verify valid local address present based on negotiated
1302 * address-families. */
1303 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1304 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1305 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1306 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1307 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]) {
1308 if (!peer
->nexthop
.v4
.s_addr
) {
1309 #if defined(HAVE_CUMULUS)
1311 "%s: No local IPv4 addr resetting connection, fd %d",
1312 peer
->host
, peer
->fd
);
1313 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1314 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1319 if (peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1320 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1321 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1322 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1323 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]) {
1324 if (IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_global
)) {
1325 #if defined(HAVE_CUMULUS)
1327 "%s: No local IPv6 addr resetting connection, fd %d",
1328 peer
->host
, peer
->fd
);
1329 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1330 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1335 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
1337 return Receive_OPEN_message
;
1341 * Process BGP KEEPALIVE message for peer.
1344 * @param size size of the packet
1345 * @return as in summary
1347 static int bgp_keepalive_receive(struct peer
*peer
, bgp_size_t size
)
1349 if (bgp_debug_keepalive(peer
))
1350 zlog_debug("%s KEEPALIVE rcvd", peer
->host
);
1352 bgp_update_implicit_eors(peer
);
1354 return Receive_KEEPALIVE_message
;
1359 * Process BGP UPDATE message for peer.
1361 * Parses UPDATE and creates attribute object.
1364 * @param size size of the packet
1365 * @return as in summary
1367 static int bgp_update_receive(struct peer
*peer
, bgp_size_t size
)
1373 bgp_size_t attribute_len
;
1374 bgp_size_t update_len
;
1375 bgp_size_t withdraw_len
;
1384 struct bgp_nlri nlris
[NLRI_TYPE_MAX
];
1386 /* Status must be Established. */
1387 if (peer
->status
!= Established
) {
1388 zlog_err("%s [FSM] Update packet received under status %s",
1390 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1391 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1395 /* Set initial values. */
1396 memset(&attr
, 0, sizeof(struct attr
));
1397 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1398 attr
.label
= MPLS_INVALID_LABEL
;
1399 memset(&nlris
, 0, sizeof(nlris
));
1400 memset(peer
->rcvd_attr_str
, 0, BUFSIZ
);
1401 peer
->rcvd_attr_printed
= 0;
1404 end
= stream_pnt(s
) + size
;
1406 /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1407 Length is too large (i.e., if Unfeasible Routes Length + Total
1408 Attribute Length + 23 exceeds the message Length), then the Error
1409 Subcode is set to Malformed Attribute List. */
1410 if (stream_pnt(s
) + 2 > end
) {
1412 "%s [Error] Update packet error"
1413 " (packet length is short for unfeasible length)",
1415 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1416 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1420 /* Unfeasible Route Length. */
1421 withdraw_len
= stream_getw(s
);
1423 /* Unfeasible Route Length check. */
1424 if (stream_pnt(s
) + withdraw_len
> end
) {
1426 "%s [Error] Update packet error"
1427 " (packet unfeasible length overflow %d)",
1428 peer
->host
, withdraw_len
);
1429 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1430 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1434 /* Unfeasible Route packet format check. */
1435 if (withdraw_len
> 0) {
1436 nlris
[NLRI_WITHDRAW
].afi
= AFI_IP
;
1437 nlris
[NLRI_WITHDRAW
].safi
= SAFI_UNICAST
;
1438 nlris
[NLRI_WITHDRAW
].nlri
= stream_pnt(s
);
1439 nlris
[NLRI_WITHDRAW
].length
= withdraw_len
;
1440 stream_forward_getp(s
, withdraw_len
);
1443 /* Attribute total length check. */
1444 if (stream_pnt(s
) + 2 > end
) {
1446 "%s [Error] Packet Error"
1447 " (update packet is short for attribute length)",
1449 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1450 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1454 /* Fetch attribute total length. */
1455 attribute_len
= stream_getw(s
);
1457 /* Attribute length check. */
1458 if (stream_pnt(s
) + attribute_len
> end
) {
1460 "%s [Error] Packet Error"
1461 " (update packet attribute length overflow %d)",
1462 peer
->host
, attribute_len
);
1463 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1464 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1468 /* Certain attribute parsing errors should not be considered bad enough
1469 * to reset the session for, most particularly any partial/optional
1470 * attributes that have 'tunneled' over speakers that don't understand
1471 * them. Instead we withdraw only the prefix concerned.
1473 * Complicates the flow a little though..
1475 bgp_attr_parse_ret_t attr_parse_ret
= BGP_ATTR_PARSE_PROCEED
;
1476 /* This define morphs the update case into a withdraw when lower levels
1477 * have signalled an error condition where this is best.
1479 #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1481 /* Parse attribute when it exists. */
1482 if (attribute_len
) {
1483 attr_parse_ret
= bgp_attr_parse(peer
, &attr
, attribute_len
,
1484 &nlris
[NLRI_MP_UPDATE
],
1485 &nlris
[NLRI_MP_WITHDRAW
]);
1486 if (attr_parse_ret
== BGP_ATTR_PARSE_ERROR
) {
1487 bgp_attr_unintern_sub(&attr
);
1492 /* Logging the attribute. */
1493 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
1494 || BGP_DEBUG(update
, UPDATE_IN
)
1495 || BGP_DEBUG(update
, UPDATE_PREFIX
)) {
1496 ret
= bgp_dump_attr(&attr
, peer
->rcvd_attr_str
, BUFSIZ
);
1498 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
)
1500 "%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1503 if (ret
&& bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1504 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
1505 peer
->rcvd_attr_str
);
1506 peer
->rcvd_attr_printed
= 1;
1510 /* Network Layer Reachability Information. */
1511 update_len
= end
- stream_pnt(s
);
1514 /* Set NLRI portion to structure. */
1515 nlris
[NLRI_UPDATE
].afi
= AFI_IP
;
1516 nlris
[NLRI_UPDATE
].safi
= SAFI_UNICAST
;
1517 nlris
[NLRI_UPDATE
].nlri
= stream_pnt(s
);
1518 nlris
[NLRI_UPDATE
].length
= update_len
;
1519 stream_forward_getp(s
, update_len
);
1522 if (BGP_DEBUG(update
, UPDATE_IN
))
1523 zlog_debug("%s rcvd UPDATE wlen %d attrlen %d alen %d",
1524 peer
->host
, withdraw_len
, attribute_len
, update_len
);
1526 /* Parse any given NLRIs */
1527 for (int i
= NLRI_UPDATE
; i
< NLRI_TYPE_MAX
; i
++) {
1531 /* NLRI is processed iff the peer if configured for the specific
1533 if (!peer
->afc
[nlris
[i
].afi
][nlris
[i
].safi
]) {
1535 "%s [Info] UPDATE for non-enabled AFI/SAFI %u/%u",
1536 peer
->host
, nlris
[i
].afi
, nlris
[i
].safi
);
1540 /* EoR handled later */
1541 if (nlris
[i
].length
== 0)
1546 case NLRI_MP_UPDATE
:
1547 nlri_ret
= bgp_nlri_parse(peer
, NLRI_ATTR_ARG
,
1551 case NLRI_MP_WITHDRAW
:
1552 nlri_ret
= bgp_nlri_parse(peer
, &attr
, &nlris
[i
], 1);
1559 zlog_err("%s [Error] Error parsing NLRI", peer
->host
);
1560 if (peer
->status
== Established
)
1562 peer
, BGP_NOTIFY_UPDATE_ERR
,
1564 ? BGP_NOTIFY_UPDATE_INVAL_NETWORK
1565 : BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
);
1566 bgp_attr_unintern_sub(&attr
);
1573 * Non-MP IPv4/Unicast EoR is a completely empty UPDATE
1574 * and MP EoR should have only an empty MP_UNREACH
1576 if ((!update_len
&& !withdraw_len
&&
1577 nlris
[NLRI_MP_UPDATE
].length
== 0) ||
1578 (attr_parse_ret
== BGP_ATTR_PARSE_EOR
)) {
1582 /* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already
1584 * update and withdraw NLRI lengths are 0.
1586 if (!attribute_len
) {
1588 safi
= SAFI_UNICAST
;
1589 } else if (attr
.flag
& ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
)
1590 && nlris
[NLRI_MP_WITHDRAW
].length
== 0) {
1591 afi
= nlris
[NLRI_MP_WITHDRAW
].afi
;
1592 safi
= nlris
[NLRI_MP_WITHDRAW
].safi
;
1593 } else if (attr_parse_ret
== BGP_ATTR_PARSE_EOR
) {
1594 afi
= nlris
[NLRI_MP_UPDATE
].afi
;
1595 safi
= nlris
[NLRI_MP_UPDATE
].safi
;
1598 if (afi
&& peer
->afc
[afi
][safi
]) {
1599 /* End-of-RIB received */
1600 if (!CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1601 PEER_STATUS_EOR_RECEIVED
)) {
1602 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1603 PEER_STATUS_EOR_RECEIVED
);
1604 bgp_update_explicit_eors(peer
);
1607 /* NSF delete stale route */
1608 if (peer
->nsf
[afi
][safi
])
1609 bgp_clear_stale_route(peer
, afi
, safi
);
1611 if (bgp_debug_neighbor_events(peer
)) {
1612 zlog_debug("rcvd End-of-RIB for %s from %s",
1613 afi_safi_print(afi
, safi
),
1619 /* Everything is done. We unintern temporary structures which
1620 interned in bgp_attr_parse(). */
1621 bgp_attr_unintern_sub(&attr
);
1623 peer
->update_time
= bgp_clock();
1625 /* Rearm holdtime timer */
1626 BGP_TIMER_OFF(peer
->t_holdtime
);
1627 bgp_timer_set(peer
);
1629 return Receive_UPDATE_message
;
1633 * Process BGP NOTIFY message for peer.
1636 * @param size size of the packet
1637 * @return as in summary
1639 static int bgp_notify_receive(struct peer
*peer
, bgp_size_t size
)
1641 struct bgp_notify bgp_notify
;
1643 if (peer
->notify
.data
) {
1644 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1645 peer
->notify
.data
= NULL
;
1646 peer
->notify
.length
= 0;
1649 bgp_notify
.code
= stream_getc(peer
->curr
);
1650 bgp_notify
.subcode
= stream_getc(peer
->curr
);
1651 bgp_notify
.length
= size
- 2;
1652 bgp_notify
.data
= NULL
;
1654 /* Preserv notify code and sub code. */
1655 peer
->notify
.code
= bgp_notify
.code
;
1656 peer
->notify
.subcode
= bgp_notify
.subcode
;
1657 /* For further diagnostic record returned Data. */
1658 if (bgp_notify
.length
) {
1659 peer
->notify
.length
= size
- 2;
1660 peer
->notify
.data
= XMALLOC(MTYPE_TMP
, size
- 2);
1661 memcpy(peer
->notify
.data
, stream_pnt(peer
->curr
), size
- 2);
1670 if (bgp_notify
.length
) {
1672 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
1673 for (i
= 0; i
< bgp_notify
.length
; i
++)
1676 stream_getc(peer
->curr
));
1677 strcat(bgp_notify
.data
, c
);
1681 stream_getc(peer
->curr
));
1682 strcpy(bgp_notify
.data
, c
);
1684 bgp_notify
.raw_data
= (u_char
*)peer
->notify
.data
;
1687 bgp_notify_print(peer
, &bgp_notify
, "received");
1688 if (bgp_notify
.data
) {
1689 XFREE(MTYPE_TMP
, bgp_notify
.data
);
1690 bgp_notify
.data
= NULL
;
1691 bgp_notify
.length
= 0;
1695 /* peer count update */
1696 atomic_fetch_add_explicit(&peer
->notify_in
, 1, memory_order_relaxed
);
1698 peer
->last_reset
= PEER_DOWN_NOTIFY_RECEIVED
;
1700 /* We have to check for Notify with Unsupported Optional Parameter.
1701 in that case we fallback to open without the capability option.
1702 But this done in bgp_stop. We just mark it here to avoid changing
1704 if (bgp_notify
.code
== BGP_NOTIFY_OPEN_ERR
1705 && bgp_notify
.subcode
== BGP_NOTIFY_OPEN_UNSUP_PARAM
)
1706 UNSET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1708 return Receive_NOTIFICATION_message
;
1712 * Process BGP ROUTEREFRESH message for peer.
1715 * @param size size of the packet
1716 * @return as in summary
1718 static int bgp_route_refresh_receive(struct peer
*peer
, bgp_size_t size
)
1722 iana_safi_t pkt_safi
;
1725 struct peer_af
*paf
;
1726 struct update_group
*updgrp
;
1727 struct peer
*updgrp_peer
;
1729 /* If peer does not have the capability, send notification. */
1730 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
)) {
1731 zlog_err("%s [Error] BGP route refresh is not enabled",
1733 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
1734 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
1738 /* Status must be Established. */
1739 if (peer
->status
!= Established
) {
1741 "%s [Error] Route refresh packet received under status %s",
1743 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1744 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1751 pkt_afi
= stream_getw(s
);
1752 (void)stream_getc(s
);
1753 pkt_safi
= stream_getc(s
);
1755 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1756 zlog_debug("%s rcvd REFRESH_REQ for afi/safi: %d/%d",
1757 peer
->host
, pkt_afi
, pkt_safi
);
1759 /* Convert AFI, SAFI to internal values and check. */
1760 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
1762 "%s REFRESH_REQ for unrecognized afi/safi: %d/%d - ignored",
1763 peer
->host
, pkt_afi
, pkt_safi
);
1764 return BGP_PACKET_NOOP
;
1767 if (size
!= BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
) {
1769 u_char when_to_refresh
;
1773 if (size
- (BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
)
1775 zlog_info("%s ORF route refresh length error",
1777 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
1781 when_to_refresh
= stream_getc(s
);
1782 end
= stream_pnt(s
) + (size
- 5);
1784 while ((stream_pnt(s
) + 2) < end
) {
1785 orf_type
= stream_getc(s
);
1786 orf_len
= stream_getw(s
);
1788 /* orf_len in bounds? */
1789 if ((stream_pnt(s
) + orf_len
) > end
)
1790 break; /* XXX: Notify instead?? */
1791 if (orf_type
== ORF_TYPE_PREFIX
1792 || orf_type
== ORF_TYPE_PREFIX_OLD
) {
1793 uint8_t *p_pnt
= stream_pnt(s
);
1794 uint8_t *p_end
= stream_pnt(s
) + orf_len
;
1795 struct orf_prefix orfp
;
1800 int ret
= CMD_SUCCESS
;
1802 if (bgp_debug_neighbor_events(peer
)) {
1804 "%s rcvd Prefixlist ORF(%d) length %d",
1805 peer
->host
, orf_type
, orf_len
);
1808 /* we're going to read at least 1 byte of common
1810 * and 7 bytes of ORF Address-filter entry from
1816 /* ORF prefix-list name */
1817 sprintf(name
, "%s.%d.%d", peer
->host
, afi
,
1820 while (p_pnt
< p_end
) {
1821 /* If the ORF entry is malformed, want
1822 * to read as much of it
1823 * as possible without going beyond the
1824 * bounds of the entry,
1825 * to maximise debug information.
1829 sizeof(struct orf_prefix
));
1831 /* after ++: p_pnt <= p_end */
1833 & ORF_COMMON_PART_REMOVE_ALL
) {
1834 if (bgp_debug_neighbor_events(
1837 "%s rcvd Remove-All pfxlist ORF request",
1839 prefix_bgp_orf_remove_all(afi
,
1843 ok
= ((u_int32_t
)(p_end
- p_pnt
)
1844 >= sizeof(u_int32_t
));
1848 p_pnt
+= sizeof(u_int32_t
);
1849 orfp
.seq
= ntohl(seq
);
1853 if ((ok
= (p_pnt
< p_end
)))
1857 prefix_bgp_orf_set()
1859 if ((ok
= (p_pnt
< p_end
)))
1863 prefix_bgp_orf_set()
1865 if ((ok
= (p_pnt
< p_end
)))
1866 orfp
.p
.prefixlen
= *p_pnt
++;
1867 orfp
.p
.family
= afi2family(
1868 afi
); /* afi checked already */
1871 orfp
.p
.prefixlen
); /* 0 if not
1875 &orfp
.p
)) /* valid for
1879 psize
= prefix_blen(&orfp
.p
);
1882 > (p_end
- p_pnt
)) /* valid for
1886 psize
= p_end
- p_pnt
;
1890 memcpy(&orfp
.p
.u
.prefix
, p_pnt
,
1894 if (bgp_debug_neighbor_events(peer
)) {
1895 char buf
[INET6_BUFSIZ
];
1898 "%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
1900 (common
& ORF_COMMON_PART_REMOVE
1903 (common
& ORF_COMMON_PART_DENY
1914 ok
? "" : " MALFORMED");
1918 ret
= prefix_bgp_orf_set(
1920 (common
& ORF_COMMON_PART_DENY
1923 (common
& ORF_COMMON_PART_REMOVE
1927 if (!ok
|| (ok
&& ret
!= CMD_SUCCESS
)) {
1929 "%s Received misformatted prefixlist ORF."
1930 " Remove All pfxlist",
1932 prefix_bgp_orf_remove_all(afi
,
1938 peer
->orf_plist
[afi
][safi
] =
1939 prefix_bgp_orf_lookup(afi
, name
);
1941 stream_forward_getp(s
, orf_len
);
1943 if (bgp_debug_neighbor_events(peer
))
1944 zlog_debug("%s rcvd Refresh %s ORF request", peer
->host
,
1945 when_to_refresh
== REFRESH_DEFER
1948 if (when_to_refresh
== REFRESH_DEFER
)
1949 return BGP_PACKET_NOOP
;
1952 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1953 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1954 PEER_STATUS_ORF_WAIT_REFRESH
))
1955 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
1956 PEER_STATUS_ORF_WAIT_REFRESH
);
1958 paf
= peer_af_find(peer
, afi
, safi
);
1959 if (paf
&& paf
->subgroup
) {
1960 if (peer
->orf_plist
[afi
][safi
]) {
1961 updgrp
= PAF_UPDGRP(paf
);
1962 updgrp_peer
= UPDGRP_PEER(updgrp
);
1963 updgrp_peer
->orf_plist
[afi
][safi
] =
1964 peer
->orf_plist
[afi
][safi
];
1967 /* If the peer is configured for default-originate clear the
1968 * SUBGRP_STATUS_DEFAULT_ORIGINATE flag so that we will
1972 if (CHECK_FLAG(paf
->subgroup
->sflags
,
1973 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1974 UNSET_FLAG(paf
->subgroup
->sflags
,
1975 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
1978 /* Perform route refreshment to the peer */
1979 bgp_announce_route(peer
, afi
, safi
);
1981 /* No FSM action necessary */
1982 return BGP_PACKET_NOOP
;
1986 * Parse BGP CAPABILITY message for peer.
1989 * @param size size of the packet
1990 * @return as in summary
1992 static int bgp_capability_msg_parse(struct peer
*peer
, u_char
*pnt
,
1996 struct capability_mp_data mpc
;
1997 struct capability_header
*hdr
;
2001 iana_safi_t pkt_safi
;
2007 /* We need at least action, capability code and capability
2009 if (pnt
+ 3 > end
) {
2010 zlog_info("%s Capability length error", peer
->host
);
2011 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
2015 hdr
= (struct capability_header
*)(pnt
+ 1);
2017 /* Action value check. */
2018 if (action
!= CAPABILITY_ACTION_SET
2019 && action
!= CAPABILITY_ACTION_UNSET
) {
2020 zlog_info("%s Capability Action Value error %d",
2021 peer
->host
, action
);
2022 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
2026 if (bgp_debug_neighbor_events(peer
))
2028 "%s CAPABILITY has action: %d, code: %u, length %u",
2029 peer
->host
, action
, hdr
->code
, hdr
->length
);
2031 /* Capability length check. */
2032 if ((pnt
+ hdr
->length
+ 3) > end
) {
2033 zlog_info("%s Capability length error", peer
->host
);
2034 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
2038 /* Fetch structure to the byte stream. */
2039 memcpy(&mpc
, pnt
+ 3, sizeof(struct capability_mp_data
));
2040 pnt
+= hdr
->length
+ 3;
2042 /* We know MP Capability Code. */
2043 if (hdr
->code
== CAPABILITY_CODE_MP
) {
2044 pkt_afi
= ntohs(mpc
.afi
);
2045 pkt_safi
= mpc
.safi
;
2047 /* Ignore capability when override-capability is set. */
2048 if (CHECK_FLAG(peer
->flags
,
2049 PEER_FLAG_OVERRIDE_CAPABILITY
))
2052 /* Convert AFI, SAFI to internal values. */
2053 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
,
2055 if (bgp_debug_neighbor_events(peer
))
2057 "%s Dynamic Capability MP_EXT afi/safi invalid "
2059 peer
->host
, pkt_afi
, pkt_safi
);
2063 /* Address family check. */
2064 if (bgp_debug_neighbor_events(peer
))
2066 "%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2068 action
== CAPABILITY_ACTION_SET
2073 if (action
== CAPABILITY_ACTION_SET
) {
2074 peer
->afc_recv
[afi
][safi
] = 1;
2075 if (peer
->afc
[afi
][safi
]) {
2076 peer
->afc_nego
[afi
][safi
] = 1;
2077 bgp_announce_route(peer
, afi
, safi
);
2080 peer
->afc_recv
[afi
][safi
] = 0;
2081 peer
->afc_nego
[afi
][safi
] = 0;
2083 if (peer_active_nego(peer
))
2084 bgp_clear_route(peer
, afi
, safi
);
2090 "%s unrecognized capability code: %d - ignored",
2091 peer
->host
, hdr
->code
);
2095 /* No FSM action necessary */
2096 return BGP_PACKET_NOOP
;
2100 * Parse BGP CAPABILITY message for peer.
2102 * Exported for unit testing.
2105 * @param size size of the packet
2106 * @return as in summary
2108 int bgp_capability_receive(struct peer
*peer
, bgp_size_t size
)
2112 /* Fetch pointer. */
2113 pnt
= stream_pnt(peer
->curr
);
2115 if (bgp_debug_neighbor_events(peer
))
2116 zlog_debug("%s rcv CAPABILITY", peer
->host
);
2118 /* If peer does not have the capability, send notification. */
2119 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
)) {
2120 zlog_err("%s [Error] BGP dynamic capability is not enabled",
2122 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
2123 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
2127 /* Status must be Established. */
2128 if (peer
->status
!= Established
) {
2130 "%s [Error] Dynamic capability packet received under status %s",
2132 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
2133 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
2138 return bgp_capability_msg_parse(peer
, pnt
, size
);
2142 * Processes a peer's input buffer.
2144 * This function sidesteps the event loop and directly calls bgp_event_update()
2145 * after processing each BGP message. This is necessary to ensure proper
2146 * ordering of FSM events and unifies the behavior that was present previously,
2147 * whereby some of the packet handling functions would update the FSM and some
2148 * would not, making event flow difficult to understand. Please think twice
2149 * before hacking this.
2151 * Thread type: THREAD_EVENT
2155 int bgp_process_packet(struct thread
*thread
)
2157 /* Yes first of all get peer pointer. */
2158 struct peer
*peer
; // peer
2159 uint32_t rpkt_quanta_old
; // how many packets to read
2160 int fsm_update_result
; // return code of bgp_event_update()
2161 int mprc
; // message processing return code
2163 peer
= THREAD_ARG(thread
);
2164 rpkt_quanta_old
= atomic_load_explicit(&peer
->bgp
->rpkt_quanta
,
2165 memory_order_relaxed
);
2166 fsm_update_result
= 0;
2168 /* Guard against scheduled events that occur after peer deletion. */
2169 if (peer
->status
== Deleted
|| peer
->status
== Clearing
)
2172 unsigned int processed
= 0;
2174 while (processed
< rpkt_quanta_old
) {
2177 char notify_data_length
[2];
2179 pthread_mutex_lock(&peer
->io_mtx
);
2181 peer
->curr
= stream_fifo_pop(peer
->ibuf
);
2183 pthread_mutex_unlock(&peer
->io_mtx
);
2185 if (peer
->curr
== NULL
) // no packets to process, hmm...
2188 /* skip the marker and copy the packet length */
2189 stream_forward_getp(peer
->curr
, BGP_MARKER_SIZE
);
2190 memcpy(notify_data_length
, stream_pnt(peer
->curr
), 2);
2192 /* read in the packet length and type */
2193 size
= stream_getw(peer
->curr
);
2194 type
= stream_getc(peer
->curr
);
2196 /* BGP packet dump function. */
2197 bgp_dump_packet(peer
, type
, peer
->curr
);
2199 /* adjust size to exclude the marker + length + type */
2200 size
-= BGP_HEADER_SIZE
;
2202 /* Read rest of the packet and call each sort of packet routine
2206 atomic_fetch_add_explicit(&peer
->open_in
, 1,
2207 memory_order_relaxed
);
2208 mprc
= bgp_open_receive(peer
, size
);
2209 if (mprc
== BGP_Stop
)
2211 "%s: BGP OPEN receipt failed for peer: %s",
2212 __FUNCTION__
, peer
->host
);
2214 case BGP_MSG_UPDATE
:
2215 atomic_fetch_add_explicit(&peer
->update_in
, 1,
2216 memory_order_relaxed
);
2217 peer
->readtime
= monotime(NULL
);
2218 mprc
= bgp_update_receive(peer
, size
);
2219 if (mprc
== BGP_Stop
)
2221 "%s: BGP UPDATE receipt failed for peer: %s",
2222 __FUNCTION__
, peer
->host
);
2224 case BGP_MSG_NOTIFY
:
2225 atomic_fetch_add_explicit(&peer
->notify_in
, 1,
2226 memory_order_relaxed
);
2227 mprc
= bgp_notify_receive(peer
, size
);
2228 if (mprc
== BGP_Stop
)
2230 "%s: BGP NOTIFY receipt failed for peer: %s",
2231 __FUNCTION__
, peer
->host
);
2233 case BGP_MSG_KEEPALIVE
:
2234 peer
->readtime
= monotime(NULL
);
2235 atomic_fetch_add_explicit(&peer
->keepalive_in
, 1,
2236 memory_order_relaxed
);
2237 mprc
= bgp_keepalive_receive(peer
, size
);
2238 if (mprc
== BGP_Stop
)
2240 "%s: BGP KEEPALIVE receipt failed for peer: %s",
2241 __FUNCTION__
, peer
->host
);
2243 case BGP_MSG_ROUTE_REFRESH_NEW
:
2244 case BGP_MSG_ROUTE_REFRESH_OLD
:
2245 atomic_fetch_add_explicit(&peer
->refresh_in
, 1,
2246 memory_order_relaxed
);
2247 mprc
= bgp_route_refresh_receive(peer
, size
);
2248 if (mprc
== BGP_Stop
)
2250 "%s: BGP ROUTEREFRESH receipt failed for peer: %s",
2251 __FUNCTION__
, peer
->host
);
2253 case BGP_MSG_CAPABILITY
:
2254 atomic_fetch_add_explicit(&peer
->dynamic_cap_in
, 1,
2255 memory_order_relaxed
);
2256 mprc
= bgp_capability_receive(peer
, size
);
2257 if (mprc
== BGP_Stop
)
2259 "%s: BGP CAPABILITY receipt failed for peer: %s",
2260 __FUNCTION__
, peer
->host
);
2264 * The message type should have been sanitized before
2265 * we ever got here. Receipt of a message with an
2266 * invalid header at this point is indicative of a
2269 assert (!"Message of invalid type received during input processing");
2272 /* delete processed packet */
2273 stream_free(peer
->curr
);
2278 if (mprc
!= BGP_PACKET_NOOP
)
2279 fsm_update_result
= bgp_event_update(peer
, mprc
);
2284 * If peer was deleted, do not process any more packets. This
2285 * is usually due to executing BGP_Stop or a stub deletion.
2287 if (fsm_update_result
== FSM_PEER_TRANSFERRED
2288 || fsm_update_result
== FSM_PEER_STOPPED
)
2292 if (fsm_update_result
!= FSM_PEER_TRANSFERRED
2293 && fsm_update_result
!= FSM_PEER_STOPPED
) {
2294 pthread_mutex_lock(&peer
->io_mtx
);
2296 // more work to do, come back later
2297 if (peer
->ibuf
->count
> 0)
2298 thread_add_timer_msec(
2299 bm
->master
, bgp_process_packet
, peer
, 0,
2300 &peer
->t_process_packet
);
2302 pthread_mutex_unlock(&peer
->io_mtx
);