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
);
309 /* The next action for the peer from a write perspective */
310 static void bgp_write_proceed_actions(struct peer
*peer
)
315 struct bpacket
*next_pkt
;
316 struct update_subgroup
*subgrp
;
318 FOREACH_AFI_SAFI (afi
, safi
) {
319 paf
= peer_af_find(peer
, afi
, safi
);
322 subgrp
= paf
->subgroup
;
326 next_pkt
= paf
->next_pkt_to_send
;
327 if (next_pkt
&& next_pkt
->buffer
) {
328 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
329 bgp_generate_updgrp_packets
, 0);
333 /* No packets readily available for AFI/SAFI, are there
335 * that need to be generated? */
336 if (bpacket_queue_is_full(SUBGRP_INST(subgrp
),
338 || subgroup_packets_to_build(subgrp
)) {
339 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
340 bgp_generate_updgrp_packets
, 0);
344 /* No packets to send, see if EOR is pending */
345 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
)) {
346 if (!subgrp
->t_coalesce
&& peer
->afc_nego
[afi
][safi
]
348 && !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
349 PEER_STATUS_EOR_SEND
)
350 && safi
!= SAFI_MPLS_VPN
) {
351 BGP_TIMER_ON(peer
->t_generate_updgrp_packets
,
352 bgp_generate_updgrp_packets
, 0);
360 * Enqueue onto the peer's output buffer any packets which are pending for the
361 * update group it is a member of.
363 * XXX: Severely needs performance work.
365 int bgp_generate_updgrp_packets(struct thread
*thread
)
367 struct peer
*peer
= THREAD_ARG(thread
);
371 struct bpacket
*next_pkt
;
373 uint32_t generated
= 0;
377 wpq
= atomic_load_explicit(&peer
->bgp
->wpkt_quanta
,
378 memory_order_relaxed
);
381 * The code beyond this part deals with update packets, proceed only
382 * if peer is Established and updates are not on hold (as part of
383 * update-delay post processing).
385 if (peer
->status
!= Established
)
388 if (peer
->bgp
&& peer
->bgp
->main_peers_update_hold
)
393 FOREACH_AFI_SAFI (afi
, safi
) {
394 paf
= peer_af_find(peer
, afi
, safi
);
395 if (!paf
|| !PAF_SUBGRP(paf
))
397 next_pkt
= paf
->next_pkt_to_send
;
400 * Try to generate a packet for the peer if we are at
401 * the end of the list. Always try to push out
404 if (!next_pkt
|| !next_pkt
->buffer
) {
405 next_pkt
= subgroup_withdraw_packet(
407 if (!next_pkt
|| !next_pkt
->buffer
)
408 subgroup_update_packet(PAF_SUBGRP(paf
));
409 next_pkt
= paf
->next_pkt_to_send
;
413 * If we still don't have a packet to send to the peer,
414 * then try to find out out if we have to send eor or
415 * if not, skip to the next AFI, SAFI. Don't send the
416 * EOR prematurely; if the subgroup's coalesce timer is
417 * running, the adjacency-out structure is not created
420 if (!next_pkt
|| !next_pkt
->buffer
) {
421 if (CHECK_FLAG(peer
->cap
,
422 PEER_CAP_RESTART_RCV
)) {
423 if (!(PAF_SUBGRP(paf
))->t_coalesce
424 && peer
->afc_nego
[afi
][safi
]
429 PEER_STATUS_EOR_SEND
)) {
430 SET_FLAG(peer
->af_sflags
[afi
]
432 PEER_STATUS_EOR_SEND
);
434 if ((s
= bgp_update_packet_eor(
437 bgp_packet_add(peer
, s
);
446 /* Found a packet template to send, overwrite
447 * packet with appropriate attributes from peer
448 * and advance peer */
449 s
= bpacket_reformat_for_peer(next_pkt
, paf
);
450 bgp_packet_add(peer
, s
);
452 bpacket_queue_advance_peer(paf
);
454 } while (s
&& (++generated
< wpq
));
456 bgp_write_proceed_actions(peer
);
462 * Creates a BGP Keepalive packet and appends it to the peer's output queue.
464 void bgp_keepalive_send(struct peer
*peer
)
468 s
= stream_new(BGP_MAX_PACKET_SIZE
);
470 /* Make keepalive packet. */
471 bgp_packet_set_marker(s
, BGP_MSG_KEEPALIVE
);
473 /* Set packet size. */
474 (void)bgp_packet_set_size(s
);
476 /* Dump packet if debug option is set. */
477 /* bgp_packet_dump (s); */
479 if (bgp_debug_keepalive(peer
))
480 zlog_debug("%s sending KEEPALIVE", peer
->host
);
482 /* Add packet to the peer. */
483 bgp_packet_add(peer
, s
);
489 * Creates a BGP Open packet and appends it to the peer's output queue.
490 * Sets capabilities as necessary.
492 void bgp_open_send(struct peer
*peer
)
495 u_int16_t send_holdtime
;
498 if (PEER_OR_GROUP_TIMER_SET(peer
))
499 send_holdtime
= peer
->holdtime
;
501 send_holdtime
= peer
->bgp
->default_holdtime
;
503 /* local-as Change */
504 if (peer
->change_local_as
)
505 local_as
= peer
->change_local_as
;
507 local_as
= peer
->local_as
;
509 s
= stream_new(BGP_MAX_PACKET_SIZE
);
511 /* Make open packet. */
512 bgp_packet_set_marker(s
, BGP_MSG_OPEN
);
514 /* Set open packet values. */
515 stream_putc(s
, BGP_VERSION_4
); /* BGP version */
517 (local_as
<= BGP_AS_MAX
) ? (u_int16_t
)local_as
519 stream_putw(s
, send_holdtime
); /* Hold Time */
520 stream_put_in_addr(s
, &peer
->local_id
); /* BGP Identifier */
522 /* Set capability code. */
523 bgp_open_capability(s
, peer
);
525 /* Set BGP packet length. */
526 (void)bgp_packet_set_size(s
);
528 if (bgp_debug_neighbor_events(peer
))
530 "%s sending OPEN, version %d, my as %u, holdtime %d, id %s",
531 peer
->host
, BGP_VERSION_4
, local_as
, send_holdtime
,
532 inet_ntoa(peer
->local_id
));
534 /* Dump packet if debug option is set. */
535 /* bgp_packet_dump (s); */
537 /* Add packet to the peer. */
538 bgp_packet_add(peer
, s
);
543 /* This is only for sending NOTIFICATION message to neighbor. */
544 static int bgp_write_notify(struct peer
*peer
)
550 pthread_mutex_lock(&peer
->io_mtx
);
552 /* There should be at least one packet. */
553 s
= stream_fifo_pop(peer
->obuf
);
556 assert(stream_get_endp(s
) >= BGP_HEADER_SIZE
);
558 pthread_mutex_unlock(&peer
->io_mtx
);
560 /* Stop collecting data within the socket */
561 sockopt_cork(peer
->fd
, 0);
564 * socket is in nonblocking mode, if we can't deliver the NOTIFY, well,
565 * we only care about getting a clean shutdown at this point.
567 ret
= write(peer
->fd
, STREAM_DATA(s
), stream_get_endp(s
));
570 * only connection reset/close gets counted as TCP_fatal_error, failure
571 * to write the entire NOTIFY doesn't get different FSM treatment
575 BGP_EVENT_ADD(peer
, TCP_fatal_error
);
579 /* Disable Nagle, make NOTIFY packet go out right away */
581 (void)setsockopt(peer
->fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
,
584 /* Retrieve BGP packet type. */
585 stream_set_getp(s
, BGP_MARKER_SIZE
+ 2);
586 type
= stream_getc(s
);
588 assert(type
== BGP_MSG_NOTIFY
);
590 /* Type should be notify. */
593 /* Double start timer. */
596 /* Overflow check. */
597 if (peer
->v_start
>= (60 * 2))
598 peer
->v_start
= (60 * 2);
601 * Handle Graceful Restart case where the state changes to
602 * Connect instead of Idle
604 BGP_EVENT_ADD(peer
, BGP_Stop
);
612 * Creates a BGP Notify and appends it to the peer's output queue.
614 * This function attempts to write the packet from the thread it is called
615 * from, to ensure the packet gets out ASAP.
618 * @param code BGP error code
619 * @param sub_code BGP error subcode
620 * @param data Data portion
621 * @param datalen length of data portion
623 void bgp_notify_send_with_data(struct peer
*peer
, u_char code
, u_char sub_code
,
624 u_char
*data
, size_t datalen
)
629 /* Allocate new stream. */
630 s
= stream_new(BGP_MAX_PACKET_SIZE
);
632 /* Make notify packet. */
633 bgp_packet_set_marker(s
, BGP_MSG_NOTIFY
);
635 /* Set notify packet values. */
636 stream_putc(s
, code
); /* BGP notify code */
637 stream_putc(s
, sub_code
); /* BGP notify sub_code */
639 /* If notify data is present. */
641 stream_write(s
, data
, datalen
);
643 /* Set BGP packet length. */
644 length
= bgp_packet_set_size(s
);
647 * Turn off keepalive generation for peer. This is necessary because
648 * otherwise between the time we wipe the output buffer and the time we
649 * push the NOTIFY onto it, the KA generation thread could have pushed
650 * a KEEPALIVE in the middle.
652 bgp_keepalives_off(peer
);
654 /* wipe output buffer */
655 pthread_mutex_lock(&peer
->io_mtx
);
657 stream_fifo_clean(peer
->obuf
);
659 pthread_mutex_unlock(&peer
->io_mtx
);
662 * If possible, store last packet for debugging purposes. This check is
663 * in place because we are sometimes called with a doppelganger peer,
664 * who tends to have a plethora of fields nulled out.
666 if (peer
->curr
&& peer
->last_reset_cause_size
) {
667 size_t packetsize
= stream_get_endp(peer
->curr
);
668 assert(packetsize
<= peer
->last_reset_cause_size
);
669 memcpy(peer
->last_reset_cause
, peer
->curr
->data
, packetsize
);
670 peer
->last_reset_cause_size
= packetsize
;
675 struct bgp_notify bgp_notify
;
680 bgp_notify
.code
= code
;
681 bgp_notify
.subcode
= sub_code
;
682 bgp_notify
.data
= NULL
;
683 bgp_notify
.length
= length
- BGP_MSG_NOTIFY_MIN_SIZE
;
684 bgp_notify
.raw_data
= data
;
686 peer
->notify
.code
= bgp_notify
.code
;
687 peer
->notify
.subcode
= bgp_notify
.subcode
;
689 if (bgp_notify
.length
) {
691 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
692 for (i
= 0; i
< bgp_notify
.length
; i
++)
694 sprintf(c
, " %02x", data
[i
]);
695 strcat(bgp_notify
.data
, c
);
698 sprintf(c
, "%02x", data
[i
]);
699 strcpy(bgp_notify
.data
, c
);
702 bgp_notify_print(peer
, &bgp_notify
, "sending");
704 if (bgp_notify
.data
) {
705 XFREE(MTYPE_TMP
, bgp_notify
.data
);
706 bgp_notify
.data
= NULL
;
707 bgp_notify
.length
= 0;
711 /* peer reset cause */
712 if (code
== BGP_NOTIFY_CEASE
) {
713 if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_RESET
)
714 peer
->last_reset
= PEER_DOWN_USER_RESET
;
715 else if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
)
716 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
718 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
720 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
722 /* Add packet to peer's output queue */
723 bgp_packet_add(peer
, s
);
725 bgp_write_notify(peer
);
729 * Creates a BGP Notify and appends it to the peer's output queue.
731 * This function attempts to write the packet from the thread it is called
732 * from, to ensure the packet gets out ASAP.
735 * @param code BGP error code
736 * @param sub_code BGP error subcode
738 void bgp_notify_send(struct peer
*peer
, u_char code
, u_char sub_code
)
740 bgp_notify_send_with_data(peer
, code
, sub_code
, NULL
, 0);
744 * Creates BGP Route Refresh packet and appends it to the peer's output queue.
747 * @param afi Address Family Identifier
748 * @param safi Subsequent Address Family Identifier
749 * @param orf_type Outbound Route Filtering type
750 * @param when_to_refresh Whether to refresh immediately or defer
751 * @param remove Whether to remove ORF for specified AFI/SAFI
753 void bgp_route_refresh_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
754 u_char orf_type
, u_char when_to_refresh
, int remove
)
757 struct bgp_filter
*filter
;
760 iana_safi_t pkt_safi
;
762 if (DISABLE_BGP_ANNOUNCE
)
765 filter
= &peer
->filter
[afi
][safi
];
767 /* Convert AFI, SAFI to values for packet. */
768 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
770 s
= stream_new(BGP_MAX_PACKET_SIZE
);
772 /* Make BGP update packet. */
773 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
774 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_NEW
);
776 bgp_packet_set_marker(s
, BGP_MSG_ROUTE_REFRESH_OLD
);
778 /* Encode Route Refresh message. */
779 stream_putw(s
, pkt_afi
);
781 stream_putc(s
, pkt_safi
);
783 if (orf_type
== ORF_TYPE_PREFIX
|| orf_type
== ORF_TYPE_PREFIX_OLD
)
784 if (remove
|| filter
->plist
[FILTER_IN
].plist
) {
789 stream_putc(s
, when_to_refresh
);
790 stream_putc(s
, orf_type
);
791 orfp
= stream_get_endp(s
);
795 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
796 PEER_STATUS_ORF_PREFIX_SEND
);
797 stream_putc(s
, ORF_COMMON_PART_REMOVE_ALL
);
798 if (bgp_debug_neighbor_events(peer
))
800 "%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %d/%d",
801 peer
->host
, orf_type
,
802 (when_to_refresh
== REFRESH_DEFER
807 SET_FLAG(peer
->af_sflags
[afi
][safi
],
808 PEER_STATUS_ORF_PREFIX_SEND
);
809 prefix_bgp_orf_entry(
810 s
, filter
->plist
[FILTER_IN
].plist
,
812 ORF_COMMON_PART_PERMIT
,
813 ORF_COMMON_PART_DENY
);
814 if (bgp_debug_neighbor_events(peer
))
816 "%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %d/%d",
817 peer
->host
, orf_type
,
818 (when_to_refresh
== REFRESH_DEFER
824 /* Total ORF Entry Len. */
825 orf_len
= stream_get_endp(s
) - orfp
- 2;
826 stream_putw_at(s
, orfp
, orf_len
);
829 /* Set packet size. */
830 (void)bgp_packet_set_size(s
);
832 if (bgp_debug_neighbor_events(peer
)) {
834 zlog_debug("%s sending REFRESH_REQ for afi/safi: %d/%d",
835 peer
->host
, pkt_afi
, pkt_safi
);
838 /* Add packet to the peer. */
839 bgp_packet_add(peer
, s
);
845 * Create a BGP Capability packet and append it to the peer's output queue.
848 * @param afi Address Family Identifier
849 * @param safi Subsequent Address Family Identifier
850 * @param capability_code BGP Capability Code
851 * @param action Set or Remove capability
853 void bgp_capability_send(struct peer
*peer
, afi_t afi
, safi_t safi
,
854 int capability_code
, int action
)
858 iana_safi_t pkt_safi
;
860 /* Convert AFI, SAFI to values for packet. */
861 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
863 s
= stream_new(BGP_MAX_PACKET_SIZE
);
865 /* Make BGP update packet. */
866 bgp_packet_set_marker(s
, BGP_MSG_CAPABILITY
);
868 /* Encode MP_EXT capability. */
869 if (capability_code
== CAPABILITY_CODE_MP
) {
870 stream_putc(s
, action
);
871 stream_putc(s
, CAPABILITY_CODE_MP
);
872 stream_putc(s
, CAPABILITY_CODE_MP_LEN
);
873 stream_putw(s
, pkt_afi
);
875 stream_putc(s
, pkt_safi
);
877 if (bgp_debug_neighbor_events(peer
))
879 "%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %d/%d",
881 action
== CAPABILITY_ACTION_SET
? "Advertising"
886 /* Set packet size. */
887 (void)bgp_packet_set_size(s
);
889 /* Add packet to the peer. */
890 bgp_packet_add(peer
, s
);
895 /* RFC1771 6.8 Connection collision detection. */
896 static int bgp_collision_detect(struct peer
*new, struct in_addr remote_id
)
900 /* Upon receipt of an OPEN message, the local system must examine
901 all of its connections that are in the OpenConfirm state. A BGP
902 speaker may also examine connections in an OpenSent state if it
903 knows the BGP Identifier of the peer by means outside of the
904 protocol. If among these connections there is a connection to a
905 remote BGP speaker whose BGP Identifier equals the one in the
906 OPEN message, then the local system performs the following
907 collision resolution procedure: */
909 if ((peer
= new->doppelganger
) != NULL
) {
910 /* Do not accept the new connection in Established or Clearing
912 * Note that a peer GR is handled by closing the existing
914 * upon receipt of new one.
916 if (peer
->status
== Established
|| peer
->status
== Clearing
) {
917 bgp_notify_send(new, BGP_NOTIFY_CEASE
,
918 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
920 } else if ((peer
->status
== OpenConfirm
)
921 || (peer
->status
== OpenSent
)) {
922 /* 1. The BGP Identifier of the local system is compared
924 the BGP Identifier of the remote system (as specified
926 the OPEN message). */
928 if (ntohl(peer
->local_id
.s_addr
)
929 < ntohl(remote_id
.s_addr
))
930 if (!CHECK_FLAG(peer
->sflags
,
931 PEER_STATUS_ACCEPT_PEER
)) {
932 /* 2. If the value of the local BGP
934 than the remote one, the local system
936 connection that already exists (the
938 already in the OpenConfirm state),
940 connection initiated by the remote
943 peer
, BGP_NOTIFY_CEASE
,
944 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
948 new, BGP_NOTIFY_CEASE
,
949 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
953 /* 3. Otherwise, the local system closes newly
955 BGP connection (the one associated with the
957 received OPEN message), and continues to use
959 existing one (the one that is already in the
960 OpenConfirm state). */
961 if (CHECK_FLAG(peer
->sflags
,
962 PEER_STATUS_ACCEPT_PEER
)) {
964 peer
, BGP_NOTIFY_CEASE
,
965 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
969 new, BGP_NOTIFY_CEASE
,
970 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
979 /* Packet processing routines ---------------------------------------------- */
981 * This is a family of functions designed to be called from
982 * bgp_process_packet(). These functions all share similar behavior and should
983 * adhere to the following invariants and restrictions:
987 * The return code of any one of those functions should be one of the FSM event
988 * codes specified in bgpd.h. If a NOTIFY was sent, this event code MUST be
989 * BGP_Stop. Otherwise, the code SHOULD correspond to the function's expected
990 * packet type. For example, bgp_open_receive() should return BGP_Stop upon
991 * error and Receive_OPEN_message otherwise.
993 * If no action is necessary, the correct return code is BGP_PACKET_NOOP as
998 * - May send NOTIFY messages
999 * - May not modify peer->status
1000 * - May not call bgp_event_update()
1003 #define BGP_PACKET_NOOP 0
1006 * Process BGP OPEN message for peer.
1008 * If any errors are encountered in the OPEN message, immediately sends NOTIFY
1009 * and returns BGP_Stop.
1012 * @param size size of the packet
1013 * @return as in summary
1015 static int bgp_open_receive(struct peer
*peer
, bgp_size_t size
)
1021 u_int16_t send_holdtime
;
1024 struct in_addr remote_id
;
1026 u_int8_t notify_data_remote_as
[2];
1027 u_int8_t notify_data_remote_as4
[4];
1028 u_int8_t notify_data_remote_id
[4];
1029 u_int16_t
*holdtime_ptr
;
1031 /* Parse open packet. */
1032 version
= stream_getc(peer
->curr
);
1033 memcpy(notify_data_remote_as
, stream_pnt(peer
->curr
), 2);
1034 remote_as
= stream_getw(peer
->curr
);
1035 holdtime_ptr
= (u_int16_t
*)stream_pnt(peer
->curr
);
1036 holdtime
= stream_getw(peer
->curr
);
1037 memcpy(notify_data_remote_id
, stream_pnt(peer
->curr
), 4);
1038 remote_id
.s_addr
= stream_get_ipv4(peer
->curr
);
1040 /* Receive OPEN message log */
1041 if (bgp_debug_neighbor_events(peer
))
1043 "%s rcv OPEN, version %d, remote-as (in open) %u,"
1044 " holdtime %d, id %s",
1045 peer
->host
, version
, remote_as
, holdtime
,
1046 inet_ntoa(remote_id
));
1048 /* BEGIN to read the capability here, but dont do it yet */
1050 optlen
= stream_getc(peer
->curr
);
1053 /* If not enough bytes, it is an error. */
1054 if (STREAM_READABLE(peer
->curr
) < optlen
) {
1055 bgp_notify_send(peer
, BGP_NOTIFY_OPEN_ERR
,
1056 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
1060 /* We need the as4 capability value *right now* because
1061 * if it is there, we have not got the remote_as yet, and
1063 * that we do not know which peer is connecting to us now.
1065 as4
= peek_for_as4_capability(peer
, optlen
);
1066 memcpy(notify_data_remote_as4
, &as4
, 4);
1069 /* Just in case we have a silly peer who sends AS4 capability set to 0
1071 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
) && !as4
) {
1072 zlog_err("%s bad OPEN, got AS4 capability, but AS4 set to 0",
1074 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1075 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1076 notify_data_remote_as4
, 4);
1080 if (remote_as
== BGP_AS_TRANS
) {
1081 /* Take the AS4 from the capability. We must have received the
1082 * capability now! Otherwise we have a asn16 peer who uses
1083 * BGP_AS_TRANS, for some unknown reason.
1085 if (as4
== BGP_AS_TRANS
) {
1087 "%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
1089 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1090 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1091 notify_data_remote_as4
, 4);
1095 if (!as4
&& BGP_DEBUG(as4
, AS4
))
1097 "%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
1098 " Odd, but proceeding.",
1100 else if (as4
< BGP_AS_MAX
&& BGP_DEBUG(as4
, AS4
))
1102 "%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
1103 "in 2-bytes, very odd peer.",
1108 /* We may have a partner with AS4 who has an asno < BGP_AS_MAX
1110 /* If we have got the capability, peer->as4cap must match
1112 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1113 && as4
!= remote_as
) {
1114 /* raise error, log this, close session */
1116 "%s bad OPEN, got AS4 capability, but remote_as %u"
1117 " mismatch with 16bit 'myasn' %u in open",
1118 peer
->host
, as4
, remote_as
);
1119 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1120 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1121 notify_data_remote_as4
, 4);
1126 /* remote router-id check. */
1127 if (remote_id
.s_addr
== 0 || IPV4_CLASS_DE(ntohl(remote_id
.s_addr
))
1128 || ntohl(peer
->local_id
.s_addr
) == ntohl(remote_id
.s_addr
)) {
1129 if (bgp_debug_neighbor_events(peer
))
1130 zlog_debug("%s bad OPEN, wrong router identifier %s",
1131 peer
->host
, inet_ntoa(remote_id
));
1132 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1133 BGP_NOTIFY_OPEN_BAD_BGP_IDENT
,
1134 notify_data_remote_id
, 4);
1138 /* Set remote router-id */
1139 peer
->remote_id
= remote_id
;
1141 /* Peer BGP version check. */
1142 if (version
!= BGP_VERSION_4
) {
1143 u_int16_t maxver
= htons(BGP_VERSION_4
);
1144 /* XXX this reply may not be correct if version < 4 XXX */
1145 if (bgp_debug_neighbor_events(peer
))
1147 "%s bad protocol version, remote requested %d, local request %d",
1148 peer
->host
, version
, BGP_VERSION_4
);
1149 /* Data must be in network byte order here */
1150 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1151 BGP_NOTIFY_OPEN_UNSUP_VERSION
,
1152 (u_int8_t
*)&maxver
, 2);
1156 /* Check neighbor as number. */
1157 if (peer
->as_type
== AS_UNSPECIFIED
) {
1158 if (bgp_debug_neighbor_events(peer
))
1160 "%s bad OPEN, remote AS is unspecified currently",
1162 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1163 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1164 notify_data_remote_as
, 2);
1166 } else if (peer
->as_type
== AS_INTERNAL
) {
1167 if (remote_as
!= peer
->bgp
->as
) {
1168 if (bgp_debug_neighbor_events(peer
))
1170 "%s bad OPEN, remote AS is %u, internal specified",
1171 peer
->host
, remote_as
);
1172 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1173 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1174 notify_data_remote_as
, 2);
1177 peer
->as
= peer
->local_as
;
1178 } else if (peer
->as_type
== AS_EXTERNAL
) {
1179 if (remote_as
== peer
->bgp
->as
) {
1180 if (bgp_debug_neighbor_events(peer
))
1182 "%s bad OPEN, remote AS is %u, external specified",
1183 peer
->host
, remote_as
);
1184 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1185 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1186 notify_data_remote_as
, 2);
1189 peer
->as
= remote_as
;
1190 } else if ((peer
->as_type
== AS_SPECIFIED
) && (remote_as
!= peer
->as
)) {
1191 if (bgp_debug_neighbor_events(peer
))
1192 zlog_debug("%s bad OPEN, remote AS is %u, expected %u",
1193 peer
->host
, remote_as
, peer
->as
);
1194 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1195 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1196 notify_data_remote_as
, 2);
1200 /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1201 calculate the value of the Hold Timer by using the smaller of its
1202 configured Hold Time and the Hold Time received in the OPEN message.
1203 The Hold Time MUST be either zero or at least three seconds. An
1204 implementation may reject connections on the basis of the Hold Time.
1207 if (holdtime
< 3 && holdtime
!= 0) {
1208 bgp_notify_send_with_data(peer
, BGP_NOTIFY_OPEN_ERR
,
1209 BGP_NOTIFY_OPEN_UNACEP_HOLDTIME
,
1210 (u_char
*)holdtime_ptr
, 2);
1214 /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1215 would be one third of the Hold Time interval. KEEPALIVE messages
1216 MUST NOT be sent more frequently than one per second. An
1217 implementation MAY adjust the rate at which it sends KEEPALIVE
1218 messages as a function of the Hold Time interval. */
1220 if (PEER_OR_GROUP_TIMER_SET(peer
))
1221 send_holdtime
= peer
->holdtime
;
1223 send_holdtime
= peer
->bgp
->default_holdtime
;
1225 if (holdtime
< send_holdtime
)
1226 peer
->v_holdtime
= holdtime
;
1228 peer
->v_holdtime
= send_holdtime
;
1230 if ((PEER_OR_GROUP_TIMER_SET(peer
))
1231 && (peer
->keepalive
< peer
->v_holdtime
/ 3))
1232 peer
->v_keepalive
= peer
->keepalive
;
1234 peer
->v_keepalive
= peer
->v_holdtime
/ 3;
1236 /* Open option part parse. */
1238 if ((ret
= bgp_open_option_parse(peer
, optlen
, &mp_capability
))
1242 if (bgp_debug_neighbor_events(peer
))
1243 zlog_debug("%s rcvd OPEN w/ OPTION parameter len: 0",
1248 * Assume that the peer supports the locally configured set of
1249 * AFI/SAFIs if the peer did not send us any Mulitiprotocol
1250 * capabilities, or if 'override-capability' is configured.
1253 || CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
1254 peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] =
1255 peer
->afc
[AFI_IP
][SAFI_UNICAST
];
1256 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] =
1257 peer
->afc
[AFI_IP
][SAFI_MULTICAST
];
1258 peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
] =
1259 peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
];
1260 peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] =
1261 peer
->afc
[AFI_IP6
][SAFI_UNICAST
];
1262 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] =
1263 peer
->afc
[AFI_IP6
][SAFI_MULTICAST
];
1264 peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
] =
1265 peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
];
1266 peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
] =
1267 peer
->afc
[AFI_L2VPN
][SAFI_EVPN
];
1270 /* When collision is detected and this peer is closed. Retrun
1272 ret
= bgp_collision_detect(peer
, remote_id
);
1277 if ((ret
= bgp_getsockname(peer
)) < 0) {
1278 zlog_err("%s: bgp_getsockname() failed for peer: %s",
1279 __FUNCTION__
, peer
->host
);
1283 /* Verify valid local address present based on negotiated
1284 * address-families. */
1285 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
1286 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
1287 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
1288 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
1289 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]) {
1290 if (!peer
->nexthop
.v4
.s_addr
) {
1291 #if defined(HAVE_CUMULUS)
1293 "%s: No local IPv4 addr resetting connection, fd %d",
1294 peer
->host
, peer
->fd
);
1295 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1296 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1301 if (peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
1302 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
1303 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
1304 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
1305 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]) {
1306 if (IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_global
)) {
1307 #if defined(HAVE_CUMULUS)
1309 "%s: No local IPv6 addr resetting connection, fd %d",
1310 peer
->host
, peer
->fd
);
1311 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1312 BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1317 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
1319 return Receive_OPEN_message
;
1323 * Process BGP KEEPALIVE message for peer.
1326 * @param size size of the packet
1327 * @return as in summary
1329 static int bgp_keepalive_receive(struct peer
*peer
, bgp_size_t size
)
1331 if (bgp_debug_keepalive(peer
))
1332 zlog_debug("%s KEEPALIVE rcvd", peer
->host
);
1334 bgp_update_implicit_eors(peer
);
1336 return Receive_KEEPALIVE_message
;
1341 * Process BGP UPDATE message for peer.
1343 * Parses UPDATE and creates attribute object.
1346 * @param size size of the packet
1347 * @return as in summary
1349 static int bgp_update_receive(struct peer
*peer
, bgp_size_t size
)
1355 bgp_size_t attribute_len
;
1356 bgp_size_t update_len
;
1357 bgp_size_t withdraw_len
;
1366 struct bgp_nlri nlris
[NLRI_TYPE_MAX
];
1368 /* Status must be Established. */
1369 if (peer
->status
!= Established
) {
1370 zlog_err("%s [FSM] Update packet received under status %s",
1372 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1373 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1377 /* Set initial values. */
1378 memset(&attr
, 0, sizeof(struct attr
));
1379 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1380 attr
.label
= MPLS_INVALID_LABEL
;
1381 memset(&nlris
, 0, sizeof(nlris
));
1382 memset(peer
->rcvd_attr_str
, 0, BUFSIZ
);
1383 peer
->rcvd_attr_printed
= 0;
1386 end
= stream_pnt(s
) + size
;
1388 /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1389 Length is too large (i.e., if Unfeasible Routes Length + Total
1390 Attribute Length + 23 exceeds the message Length), then the Error
1391 Subcode is set to Malformed Attribute List. */
1392 if (stream_pnt(s
) + 2 > end
) {
1394 "%s [Error] Update packet error"
1395 " (packet length is short for unfeasible length)",
1397 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1398 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1402 /* Unfeasible Route Length. */
1403 withdraw_len
= stream_getw(s
);
1405 /* Unfeasible Route Length check. */
1406 if (stream_pnt(s
) + withdraw_len
> end
) {
1408 "%s [Error] Update packet error"
1409 " (packet unfeasible length overflow %d)",
1410 peer
->host
, withdraw_len
);
1411 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1412 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1416 /* Unfeasible Route packet format check. */
1417 if (withdraw_len
> 0) {
1418 nlris
[NLRI_WITHDRAW
].afi
= AFI_IP
;
1419 nlris
[NLRI_WITHDRAW
].safi
= SAFI_UNICAST
;
1420 nlris
[NLRI_WITHDRAW
].nlri
= stream_pnt(s
);
1421 nlris
[NLRI_WITHDRAW
].length
= withdraw_len
;
1422 stream_forward_getp(s
, withdraw_len
);
1425 /* Attribute total length check. */
1426 if (stream_pnt(s
) + 2 > end
) {
1428 "%s [Error] Packet Error"
1429 " (update packet is short for attribute length)",
1431 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1432 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1436 /* Fetch attribute total length. */
1437 attribute_len
= stream_getw(s
);
1439 /* Attribute length check. */
1440 if (stream_pnt(s
) + attribute_len
> end
) {
1442 "%s [Error] Packet Error"
1443 " (update packet attribute length overflow %d)",
1444 peer
->host
, attribute_len
);
1445 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
1446 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1450 /* Certain attribute parsing errors should not be considered bad enough
1451 * to reset the session for, most particularly any partial/optional
1452 * attributes that have 'tunneled' over speakers that don't understand
1453 * them. Instead we withdraw only the prefix concerned.
1455 * Complicates the flow a little though..
1457 bgp_attr_parse_ret_t attr_parse_ret
= BGP_ATTR_PARSE_PROCEED
;
1458 /* This define morphs the update case into a withdraw when lower levels
1459 * have signalled an error condition where this is best.
1461 #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1463 /* Parse attribute when it exists. */
1464 if (attribute_len
) {
1465 attr_parse_ret
= bgp_attr_parse(peer
, &attr
, attribute_len
,
1466 &nlris
[NLRI_MP_UPDATE
],
1467 &nlris
[NLRI_MP_WITHDRAW
]);
1468 if (attr_parse_ret
== BGP_ATTR_PARSE_ERROR
) {
1469 bgp_attr_unintern_sub(&attr
);
1474 /* Logging the attribute. */
1475 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
1476 || BGP_DEBUG(update
, UPDATE_IN
)
1477 || BGP_DEBUG(update
, UPDATE_PREFIX
)) {
1478 ret
= bgp_dump_attr(&attr
, peer
->rcvd_attr_str
, BUFSIZ
);
1480 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
)
1482 "%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1485 if (ret
&& bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1486 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
1487 peer
->rcvd_attr_str
);
1488 peer
->rcvd_attr_printed
= 1;
1492 /* Network Layer Reachability Information. */
1493 update_len
= end
- stream_pnt(s
);
1496 /* Set NLRI portion to structure. */
1497 nlris
[NLRI_UPDATE
].afi
= AFI_IP
;
1498 nlris
[NLRI_UPDATE
].safi
= SAFI_UNICAST
;
1499 nlris
[NLRI_UPDATE
].nlri
= stream_pnt(s
);
1500 nlris
[NLRI_UPDATE
].length
= update_len
;
1501 stream_forward_getp(s
, update_len
);
1504 if (BGP_DEBUG(update
, UPDATE_IN
))
1505 zlog_debug("%s rcvd UPDATE wlen %d attrlen %d alen %d",
1506 peer
->host
, withdraw_len
, attribute_len
, update_len
);
1508 /* Parse any given NLRIs */
1509 for (int i
= NLRI_UPDATE
; i
< NLRI_TYPE_MAX
; i
++) {
1513 /* NLRI is processed iff the peer if configured for the specific
1515 if (!peer
->afc
[nlris
[i
].afi
][nlris
[i
].safi
]) {
1517 "%s [Info] UPDATE for non-enabled AFI/SAFI %u/%u",
1518 peer
->host
, nlris
[i
].afi
, nlris
[i
].safi
);
1522 /* EoR handled later */
1523 if (nlris
[i
].length
== 0)
1528 case NLRI_MP_UPDATE
:
1529 nlri_ret
= bgp_nlri_parse(peer
, NLRI_ATTR_ARG
,
1533 case NLRI_MP_WITHDRAW
:
1534 nlri_ret
= bgp_nlri_parse(peer
, &attr
, &nlris
[i
], 1);
1541 zlog_err("%s [Error] Error parsing NLRI", peer
->host
);
1542 if (peer
->status
== Established
)
1544 peer
, BGP_NOTIFY_UPDATE_ERR
,
1546 ? BGP_NOTIFY_UPDATE_INVAL_NETWORK
1547 : BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
);
1548 bgp_attr_unintern_sub(&attr
);
1555 * Non-MP IPv4/Unicast EoR is a completely empty UPDATE
1556 * and MP EoR should have only an empty MP_UNREACH
1558 if ((!update_len
&& !withdraw_len
&&
1559 nlris
[NLRI_MP_UPDATE
].length
== 0) ||
1560 (attr_parse_ret
== BGP_ATTR_PARSE_EOR
)) {
1564 /* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already
1566 * update and withdraw NLRI lengths are 0.
1568 if (!attribute_len
) {
1570 safi
= SAFI_UNICAST
;
1571 } else if (attr
.flag
& ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
)
1572 && nlris
[NLRI_MP_WITHDRAW
].length
== 0) {
1573 afi
= nlris
[NLRI_MP_WITHDRAW
].afi
;
1574 safi
= nlris
[NLRI_MP_WITHDRAW
].safi
;
1575 } else if (attr_parse_ret
== BGP_ATTR_PARSE_EOR
) {
1576 afi
= nlris
[NLRI_MP_UPDATE
].afi
;
1577 safi
= nlris
[NLRI_MP_UPDATE
].safi
;
1580 if (afi
&& peer
->afc
[afi
][safi
]) {
1581 /* End-of-RIB received */
1582 if (!CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1583 PEER_STATUS_EOR_RECEIVED
)) {
1584 SET_FLAG(peer
->af_sflags
[afi
][safi
],
1585 PEER_STATUS_EOR_RECEIVED
);
1586 bgp_update_explicit_eors(peer
);
1589 /* NSF delete stale route */
1590 if (peer
->nsf
[afi
][safi
])
1591 bgp_clear_stale_route(peer
, afi
, safi
);
1593 if (bgp_debug_neighbor_events(peer
)) {
1594 zlog_debug("rcvd End-of-RIB for %s from %s",
1595 afi_safi_print(afi
, safi
),
1601 /* Everything is done. We unintern temporary structures which
1602 interned in bgp_attr_parse(). */
1603 bgp_attr_unintern_sub(&attr
);
1605 peer
->update_time
= bgp_clock();
1607 /* Rearm holdtime timer */
1608 BGP_TIMER_OFF(peer
->t_holdtime
);
1609 bgp_timer_set(peer
);
1611 return Receive_UPDATE_message
;
1615 * Process BGP NOTIFY message for peer.
1618 * @param size size of the packet
1619 * @return as in summary
1621 static int bgp_notify_receive(struct peer
*peer
, bgp_size_t size
)
1623 struct bgp_notify bgp_notify
;
1625 if (peer
->notify
.data
) {
1626 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1627 peer
->notify
.data
= NULL
;
1628 peer
->notify
.length
= 0;
1631 bgp_notify
.code
= stream_getc(peer
->curr
);
1632 bgp_notify
.subcode
= stream_getc(peer
->curr
);
1633 bgp_notify
.length
= size
- 2;
1634 bgp_notify
.data
= NULL
;
1636 /* Preserv notify code and sub code. */
1637 peer
->notify
.code
= bgp_notify
.code
;
1638 peer
->notify
.subcode
= bgp_notify
.subcode
;
1639 /* For further diagnostic record returned Data. */
1640 if (bgp_notify
.length
) {
1641 peer
->notify
.length
= size
- 2;
1642 peer
->notify
.data
= XMALLOC(MTYPE_TMP
, size
- 2);
1643 memcpy(peer
->notify
.data
, stream_pnt(peer
->curr
), size
- 2);
1652 if (bgp_notify
.length
) {
1654 XMALLOC(MTYPE_TMP
, bgp_notify
.length
* 3);
1655 for (i
= 0; i
< bgp_notify
.length
; i
++)
1658 stream_getc(peer
->curr
));
1659 strcat(bgp_notify
.data
, c
);
1663 stream_getc(peer
->curr
));
1664 strcpy(bgp_notify
.data
, c
);
1666 bgp_notify
.raw_data
= (u_char
*)peer
->notify
.data
;
1669 bgp_notify_print(peer
, &bgp_notify
, "received");
1670 if (bgp_notify
.data
) {
1671 XFREE(MTYPE_TMP
, bgp_notify
.data
);
1672 bgp_notify
.data
= NULL
;
1673 bgp_notify
.length
= 0;
1677 /* peer count update */
1680 peer
->last_reset
= PEER_DOWN_NOTIFY_RECEIVED
;
1682 /* We have to check for Notify with Unsupported Optional Parameter.
1683 in that case we fallback to open without the capability option.
1684 But this done in bgp_stop. We just mark it here to avoid changing
1686 if (bgp_notify
.code
== BGP_NOTIFY_OPEN_ERR
1687 && bgp_notify
.subcode
== BGP_NOTIFY_OPEN_UNSUP_PARAM
)
1688 UNSET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1690 return Receive_NOTIFICATION_message
;
1694 * Process BGP ROUTEREFRESH message for peer.
1697 * @param size size of the packet
1698 * @return as in summary
1700 static int bgp_route_refresh_receive(struct peer
*peer
, bgp_size_t size
)
1704 iana_safi_t pkt_safi
;
1707 struct peer_af
*paf
;
1708 struct update_group
*updgrp
;
1709 struct peer
*updgrp_peer
;
1711 /* If peer does not have the capability, send notification. */
1712 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_ADV
)) {
1713 zlog_err("%s [Error] BGP route refresh is not enabled",
1715 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
1716 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
1720 /* Status must be Established. */
1721 if (peer
->status
!= Established
) {
1723 "%s [Error] Route refresh packet received under status %s",
1725 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
1726 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
1733 pkt_afi
= stream_getw(s
);
1734 (void)stream_getc(s
);
1735 pkt_safi
= stream_getc(s
);
1737 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1738 zlog_debug("%s rcvd REFRESH_REQ for afi/safi: %d/%d",
1739 peer
->host
, pkt_afi
, pkt_safi
);
1741 /* Convert AFI, SAFI to internal values and check. */
1742 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
1744 "%s REFRESH_REQ for unrecognized afi/safi: %d/%d - ignored",
1745 peer
->host
, pkt_afi
, pkt_safi
);
1746 return BGP_PACKET_NOOP
;
1749 if (size
!= BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
) {
1751 u_char when_to_refresh
;
1755 if (size
- (BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
)
1757 zlog_info("%s ORF route refresh length error",
1759 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
1763 when_to_refresh
= stream_getc(s
);
1764 end
= stream_pnt(s
) + (size
- 5);
1766 while ((stream_pnt(s
) + 2) < end
) {
1767 orf_type
= stream_getc(s
);
1768 orf_len
= stream_getw(s
);
1770 /* orf_len in bounds? */
1771 if ((stream_pnt(s
) + orf_len
) > end
)
1772 break; /* XXX: Notify instead?? */
1773 if (orf_type
== ORF_TYPE_PREFIX
1774 || orf_type
== ORF_TYPE_PREFIX_OLD
) {
1775 uint8_t *p_pnt
= stream_pnt(s
);
1776 uint8_t *p_end
= stream_pnt(s
) + orf_len
;
1777 struct orf_prefix orfp
;
1782 int ret
= CMD_SUCCESS
;
1784 if (bgp_debug_neighbor_events(peer
)) {
1786 "%s rcvd Prefixlist ORF(%d) length %d",
1787 peer
->host
, orf_type
, orf_len
);
1790 /* we're going to read at least 1 byte of common
1792 * and 7 bytes of ORF Address-filter entry from
1798 /* ORF prefix-list name */
1799 sprintf(name
, "%s.%d.%d", peer
->host
, afi
,
1802 while (p_pnt
< p_end
) {
1803 /* If the ORF entry is malformed, want
1804 * to read as much of it
1805 * as possible without going beyond the
1806 * bounds of the entry,
1807 * to maximise debug information.
1811 sizeof(struct orf_prefix
));
1813 /* after ++: p_pnt <= p_end */
1815 & ORF_COMMON_PART_REMOVE_ALL
) {
1816 if (bgp_debug_neighbor_events(
1819 "%s rcvd Remove-All pfxlist ORF request",
1821 prefix_bgp_orf_remove_all(afi
,
1825 ok
= ((u_int32_t
)(p_end
- p_pnt
)
1826 >= sizeof(u_int32_t
));
1830 p_pnt
+= sizeof(u_int32_t
);
1831 orfp
.seq
= ntohl(seq
);
1835 if ((ok
= (p_pnt
< p_end
)))
1839 prefix_bgp_orf_set()
1841 if ((ok
= (p_pnt
< p_end
)))
1845 prefix_bgp_orf_set()
1847 if ((ok
= (p_pnt
< p_end
)))
1848 orfp
.p
.prefixlen
= *p_pnt
++;
1849 orfp
.p
.family
= afi2family(
1850 afi
); /* afi checked already */
1853 orfp
.p
.prefixlen
); /* 0 if not
1857 &orfp
.p
)) /* valid for
1861 psize
= prefix_blen(&orfp
.p
);
1864 > (p_end
- p_pnt
)) /* valid for
1868 psize
= p_end
- p_pnt
;
1872 memcpy(&orfp
.p
.u
.prefix
, p_pnt
,
1876 if (bgp_debug_neighbor_events(peer
)) {
1877 char buf
[INET6_BUFSIZ
];
1880 "%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
1882 (common
& ORF_COMMON_PART_REMOVE
1885 (common
& ORF_COMMON_PART_DENY
1896 ok
? "" : " MALFORMED");
1900 ret
= prefix_bgp_orf_set(
1902 (common
& ORF_COMMON_PART_DENY
1905 (common
& ORF_COMMON_PART_REMOVE
1909 if (!ok
|| (ok
&& ret
!= CMD_SUCCESS
)) {
1911 "%s Received misformatted prefixlist ORF."
1912 " Remove All pfxlist",
1914 prefix_bgp_orf_remove_all(afi
,
1920 peer
->orf_plist
[afi
][safi
] =
1921 prefix_bgp_orf_lookup(afi
, name
);
1923 stream_forward_getp(s
, orf_len
);
1925 if (bgp_debug_neighbor_events(peer
))
1926 zlog_debug("%s rcvd Refresh %s ORF request", peer
->host
,
1927 when_to_refresh
== REFRESH_DEFER
1930 if (when_to_refresh
== REFRESH_DEFER
)
1931 return BGP_PACKET_NOOP
;
1934 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1935 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
1936 PEER_STATUS_ORF_WAIT_REFRESH
))
1937 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
1938 PEER_STATUS_ORF_WAIT_REFRESH
);
1940 paf
= peer_af_find(peer
, afi
, safi
);
1941 if (paf
&& paf
->subgroup
) {
1942 if (peer
->orf_plist
[afi
][safi
]) {
1943 updgrp
= PAF_UPDGRP(paf
);
1944 updgrp_peer
= UPDGRP_PEER(updgrp
);
1945 updgrp_peer
->orf_plist
[afi
][safi
] =
1946 peer
->orf_plist
[afi
][safi
];
1949 /* If the peer is configured for default-originate clear the
1950 * SUBGRP_STATUS_DEFAULT_ORIGINATE flag so that we will
1954 if (CHECK_FLAG(paf
->subgroup
->sflags
,
1955 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1956 UNSET_FLAG(paf
->subgroup
->sflags
,
1957 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
1960 /* Perform route refreshment to the peer */
1961 bgp_announce_route(peer
, afi
, safi
);
1963 /* No FSM action necessary */
1964 return BGP_PACKET_NOOP
;
1968 * Parse BGP CAPABILITY message for peer.
1971 * @param size size of the packet
1972 * @return as in summary
1974 static int bgp_capability_msg_parse(struct peer
*peer
, u_char
*pnt
,
1978 struct capability_mp_data mpc
;
1979 struct capability_header
*hdr
;
1983 iana_safi_t pkt_safi
;
1989 /* We need at least action, capability code and capability
1991 if (pnt
+ 3 > end
) {
1992 zlog_info("%s Capability length error", peer
->host
);
1993 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
1997 hdr
= (struct capability_header
*)(pnt
+ 1);
1999 /* Action value check. */
2000 if (action
!= CAPABILITY_ACTION_SET
2001 && action
!= CAPABILITY_ACTION_UNSET
) {
2002 zlog_info("%s Capability Action Value error %d",
2003 peer
->host
, action
);
2004 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
2008 if (bgp_debug_neighbor_events(peer
))
2010 "%s CAPABILITY has action: %d, code: %u, length %u",
2011 peer
->host
, action
, hdr
->code
, hdr
->length
);
2013 /* Capability length check. */
2014 if ((pnt
+ hdr
->length
+ 3) > end
) {
2015 zlog_info("%s Capability length error", peer
->host
);
2016 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
, 0);
2020 /* Fetch structure to the byte stream. */
2021 memcpy(&mpc
, pnt
+ 3, sizeof(struct capability_mp_data
));
2022 pnt
+= hdr
->length
+ 3;
2024 /* We know MP Capability Code. */
2025 if (hdr
->code
== CAPABILITY_CODE_MP
) {
2026 pkt_afi
= ntohs(mpc
.afi
);
2027 pkt_safi
= mpc
.safi
;
2029 /* Ignore capability when override-capability is set. */
2030 if (CHECK_FLAG(peer
->flags
,
2031 PEER_FLAG_OVERRIDE_CAPABILITY
))
2034 /* Convert AFI, SAFI to internal values. */
2035 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
,
2037 if (bgp_debug_neighbor_events(peer
))
2039 "%s Dynamic Capability MP_EXT afi/safi invalid "
2041 peer
->host
, pkt_afi
, pkt_safi
);
2045 /* Address family check. */
2046 if (bgp_debug_neighbor_events(peer
))
2048 "%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2050 action
== CAPABILITY_ACTION_SET
2055 if (action
== CAPABILITY_ACTION_SET
) {
2056 peer
->afc_recv
[afi
][safi
] = 1;
2057 if (peer
->afc
[afi
][safi
]) {
2058 peer
->afc_nego
[afi
][safi
] = 1;
2059 bgp_announce_route(peer
, afi
, safi
);
2062 peer
->afc_recv
[afi
][safi
] = 0;
2063 peer
->afc_nego
[afi
][safi
] = 0;
2065 if (peer_active_nego(peer
))
2066 bgp_clear_route(peer
, afi
, safi
);
2072 "%s unrecognized capability code: %d - ignored",
2073 peer
->host
, hdr
->code
);
2077 /* No FSM action necessary */
2078 return BGP_PACKET_NOOP
;
2082 * Parse BGP CAPABILITY message for peer.
2084 * Exported for unit testing.
2087 * @param size size of the packet
2088 * @return as in summary
2090 int bgp_capability_receive(struct peer
*peer
, bgp_size_t size
)
2094 /* Fetch pointer. */
2095 pnt
= stream_pnt(peer
->curr
);
2097 if (bgp_debug_neighbor_events(peer
))
2098 zlog_debug("%s rcv CAPABILITY", peer
->host
);
2100 /* If peer does not have the capability, send notification. */
2101 if (!CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_ADV
)) {
2102 zlog_err("%s [Error] BGP dynamic capability is not enabled",
2104 bgp_notify_send(peer
, BGP_NOTIFY_HEADER_ERR
,
2105 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
2109 /* Status must be Established. */
2110 if (peer
->status
!= Established
) {
2112 "%s [Error] Dynamic capability packet received under status %s",
2114 lookup_msg(bgp_status_msg
, peer
->status
, NULL
));
2115 bgp_notify_send(peer
, BGP_NOTIFY_FSM_ERR
, 0);
2120 return bgp_capability_msg_parse(peer
, pnt
, size
);
2124 * Processes a peer's input buffer.
2126 * This function sidesteps the event loop and directly calls bgp_event_update()
2127 * after processing each BGP message. This is necessary to ensure proper
2128 * ordering of FSM events and unifies the behavior that was present previously,
2129 * whereby some of the packet handling functions would update the FSM and some
2130 * would not, making event flow difficult to understand. Please think twice
2131 * before hacking this.
2133 * Thread type: THREAD_EVENT
2137 int bgp_process_packet(struct thread
*thread
)
2139 /* Yes first of all get peer pointer. */
2140 struct peer
*peer
; // peer
2141 uint32_t rpkt_quanta_old
; // how many packets to read
2142 int fsm_update_result
; // return code of bgp_event_update()
2143 int mprc
; // message processing return code
2145 peer
= THREAD_ARG(thread
);
2146 rpkt_quanta_old
= atomic_load_explicit(&peer
->bgp
->rpkt_quanta
,
2147 memory_order_relaxed
);
2148 fsm_update_result
= 0;
2150 /* Guard against scheduled events that occur after peer deletion. */
2151 if (peer
->status
== Deleted
|| peer
->status
== Clearing
)
2154 unsigned int processed
= 0;
2156 while (processed
< rpkt_quanta_old
) {
2159 char notify_data_length
[2];
2161 pthread_mutex_lock(&peer
->io_mtx
);
2163 peer
->curr
= stream_fifo_pop(peer
->ibuf
);
2165 pthread_mutex_unlock(&peer
->io_mtx
);
2167 if (peer
->curr
== NULL
) // no packets to process, hmm...
2170 /* skip the marker and copy the packet length */
2171 stream_forward_getp(peer
->curr
, BGP_MARKER_SIZE
);
2172 memcpy(notify_data_length
, stream_pnt(peer
->curr
), 2);
2174 /* read in the packet length and type */
2175 size
= stream_getw(peer
->curr
);
2176 type
= stream_getc(peer
->curr
);
2178 /* BGP packet dump function. */
2179 bgp_dump_packet(peer
, type
, peer
->curr
);
2181 /* adjust size to exclude the marker + length + type */
2182 size
-= BGP_HEADER_SIZE
;
2184 /* Read rest of the packet and call each sort of packet routine
2189 mprc
= bgp_open_receive(peer
, size
);
2190 if (mprc
== BGP_Stop
)
2192 "%s: BGP OPEN receipt failed for peer: %s",
2193 __FUNCTION__
, peer
->host
);
2195 case BGP_MSG_UPDATE
:
2197 peer
->readtime
= monotime(NULL
);
2198 mprc
= bgp_update_receive(peer
, size
);
2199 if (mprc
== BGP_Stop
)
2201 "%s: BGP UPDATE receipt failed for peer: %s",
2202 __FUNCTION__
, peer
->host
);
2204 case BGP_MSG_NOTIFY
:
2206 mprc
= bgp_notify_receive(peer
, size
);
2207 if (mprc
== BGP_Stop
)
2209 "%s: BGP NOTIFY receipt failed for peer: %s",
2210 __FUNCTION__
, peer
->host
);
2212 case BGP_MSG_KEEPALIVE
:
2213 peer
->readtime
= monotime(NULL
);
2214 peer
->keepalive_in
++;
2215 mprc
= bgp_keepalive_receive(peer
, size
);
2216 if (mprc
== BGP_Stop
)
2218 "%s: BGP KEEPALIVE receipt failed for peer: %s",
2219 __FUNCTION__
, peer
->host
);
2221 case BGP_MSG_ROUTE_REFRESH_NEW
:
2222 case BGP_MSG_ROUTE_REFRESH_OLD
:
2224 mprc
= bgp_route_refresh_receive(peer
, size
);
2225 if (mprc
== BGP_Stop
)
2227 "%s: BGP ROUTEREFRESH receipt failed for peer: %s",
2228 __FUNCTION__
, peer
->host
);
2230 case BGP_MSG_CAPABILITY
:
2231 peer
->dynamic_cap_in
++;
2232 mprc
= bgp_capability_receive(peer
, size
);
2233 if (mprc
== BGP_Stop
)
2235 "%s: BGP CAPABILITY receipt failed for peer: %s",
2236 __FUNCTION__
, peer
->host
);
2240 * The message type should have been sanitized before
2241 * we ever got here. Receipt of a message with an
2242 * invalid header at this point is indicative of a
2245 assert (!"Message of invalid type received during input processing");
2248 /* delete processed packet */
2249 stream_free(peer
->curr
);
2254 if (mprc
!= BGP_PACKET_NOOP
)
2255 fsm_update_result
= bgp_event_update(peer
, mprc
);
2260 * If peer was deleted, do not process any more packets. This
2261 * is usually due to executing BGP_Stop or a stub deletion.
2263 if (fsm_update_result
== FSM_PEER_TRANSFERRED
2264 || fsm_update_result
== FSM_PEER_STOPPED
)
2268 if (fsm_update_result
!= FSM_PEER_TRANSFERRED
2269 && fsm_update_result
!= FSM_PEER_STOPPED
) {
2270 pthread_mutex_lock(&peer
->io_mtx
);
2272 // more work to do, come back later
2273 if (peer
->ibuf
->count
> 0)
2274 thread_add_timer_msec(
2275 bm
->master
, bgp_process_packet
, peer
, 0,
2276 &peer
->t_process_packet
);
2278 pthread_mutex_unlock(&peer
->io_mtx
);