1 /* BGP packet management routine.
2 Copyright (C) 1999 Kunihiro Ishiguro
4 This file is part of GNU Zebra.
6 GNU Zebra is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 GNU Zebra is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Zebra; see the file COPYING. If not, write to the Free
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
30 #include "sockunion.h" /* for inet_ntop () */
37 #include "bgpd/bgpd.h"
38 #include "bgpd/bgp_table.h"
39 #include "bgpd/bgp_dump.h"
40 #include "bgpd/bgp_attr.h"
41 #include "bgpd/bgp_debug.h"
42 #include "bgpd/bgp_fsm.h"
43 #include "bgpd/bgp_route.h"
44 #include "bgpd/bgp_packet.h"
45 #include "bgpd/bgp_open.h"
46 #include "bgpd/bgp_aspath.h"
47 #include "bgpd/bgp_community.h"
48 #include "bgpd/bgp_ecommunity.h"
49 #include "bgpd/bgp_lcommunity.h"
50 #include "bgpd/bgp_network.h"
51 #include "bgpd/bgp_mplsvpn.h"
52 #include "bgpd/bgp_evpn.h"
53 #include "bgpd/bgp_encap.h"
54 #include "bgpd/bgp_evpn.h"
55 #include "bgpd/bgp_advertise.h"
56 #include "bgpd/bgp_vty.h"
57 #include "bgpd/bgp_updgrp.h"
58 #include "bgpd/bgp_label.h"
60 /* Set up BGP packet marker and packet type. */
62 bgp_packet_set_marker (struct stream
*s
, u_char type
)
67 for (i
= 0; i
< BGP_MARKER_SIZE
; i
++)
68 stream_putc (s
, 0xff);
70 /* Dummy total length. This field is should be filled in later on. */
73 /* BGP packet type. */
74 stream_putc (s
, type
);
76 /* Return current stream size. */
77 return stream_get_endp (s
);
80 /* Set BGP packet header size entry. If size is zero then use current
83 bgp_packet_set_size (struct stream
*s
)
87 /* Preserve current pointer. */
88 cp
= stream_get_endp (s
);
89 stream_putw_at (s
, BGP_MARKER_SIZE
, cp
);
94 /* Add new packet to the peer. */
96 bgp_packet_add (struct peer
*peer
, struct stream
*s
)
98 /* Add packet to the end of list. */
99 stream_fifo_push (peer
->obuf
, s
);
102 /* Free first packet. */
104 bgp_packet_delete (struct peer
*peer
)
106 stream_free (stream_fifo_pop (peer
->obuf
));
109 /* Check file descriptor whether connect is established. */
111 bgp_connect_check (struct peer
*peer
, int change_state
)
117 /* Anyway I have to reset read and write thread. */
118 BGP_READ_OFF (peer
->t_read
);
119 BGP_WRITE_OFF (peer
->t_write
);
121 /* Check file descriptor. */
122 slen
= sizeof (status
);
123 ret
= getsockopt(peer
->fd
, SOL_SOCKET
, SO_ERROR
, (void *) &status
, &slen
);
125 /* If getsockopt is fail, this is fatal error. */
128 zlog_info ("can't get sockopt for nonblocking connect");
129 BGP_EVENT_ADD (peer
, TCP_fatal_error
);
133 /* When status is 0 then TCP connection is established. */
136 BGP_EVENT_ADD (peer
, TCP_connection_open
);
141 if (bgp_debug_neighbor_events(peer
))
142 zlog_debug ("%s [Event] Connect failed (%s)",
143 peer
->host
, safe_strerror (errno
));
145 BGP_EVENT_ADD (peer
, TCP_connection_open_failed
);
150 static struct stream
*
151 bgp_update_packet_eor (struct peer
*peer
, afi_t afi
, safi_t safi
)
157 if (DISABLE_BGP_ANNOUNCE
)
160 if (bgp_debug_neighbor_events(peer
))
161 zlog_debug ("send End-of-RIB for %s to %s", afi_safi_print (afi
, safi
), peer
->host
);
163 s
= stream_new (BGP_MAX_PACKET_SIZE
);
165 /* Make BGP update packet. */
166 bgp_packet_set_marker (s
, BGP_MSG_UPDATE
);
168 /* Unfeasible Routes Length */
171 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
173 /* Total Path Attribute Length */
178 /* Convert AFI, SAFI to values for packet. */
179 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
181 /* Total Path Attribute Length */
183 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
);
184 stream_putc (s
, BGP_ATTR_MP_UNREACH_NLRI
);
186 stream_putw (s
, pkt_afi
);
187 stream_putc (s
, pkt_safi
);
190 bgp_packet_set_size (s
);
191 bgp_packet_add (peer
, s
);
195 /* Get next packet to be written. */
196 static struct stream
*
197 bgp_write_packet (struct peer
*peer
)
199 struct stream
*s
= NULL
;
201 struct bpacket
*next_pkt
;
205 s
= stream_fifo_head (peer
->obuf
);
210 * The code beyond this part deals with update packets, proceed only
211 * if peer is Established and updates are not on hold (as part of
212 * update-delay post processing).
214 if (peer
->status
!= Established
)
217 if (peer
->bgp
&& peer
->bgp
->main_peers_update_hold
)
220 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
221 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
223 paf
= peer_af_find (peer
, afi
, safi
);
224 if (!paf
|| !PAF_SUBGRP(paf
))
226 next_pkt
= paf
->next_pkt_to_send
;
228 /* Try to generate a packet for the peer if we are at the end of
229 * the list. Always try to push out WITHDRAWs first. */
230 if (!next_pkt
|| !next_pkt
->buffer
)
232 next_pkt
= subgroup_withdraw_packet(PAF_SUBGRP(paf
));
233 if (!next_pkt
|| !next_pkt
->buffer
)
234 subgroup_update_packet (PAF_SUBGRP(paf
));
235 next_pkt
= paf
->next_pkt_to_send
;
238 /* If we still don't have a packet to send to the peer, then
239 * try to find out out if we have to send eor or if not, skip to
240 * the next AFI, SAFI.
241 * Don't send the EOR prematurely... if the subgroup's coalesce
242 * timer is running, the adjacency-out structure is not created
245 if (!next_pkt
|| !next_pkt
->buffer
)
247 if (CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
))
249 if (!(PAF_SUBGRP(paf
))->t_coalesce
&&
250 peer
->afc_nego
[afi
][safi
] && peer
->synctime
251 && ! CHECK_FLAG (peer
->af_sflags
[afi
][safi
],
252 PEER_STATUS_EOR_SEND
)
253 && safi
!= SAFI_EVPN
)
255 SET_FLAG (peer
->af_sflags
[afi
][safi
],
256 PEER_STATUS_EOR_SEND
);
257 return bgp_update_packet_eor (peer
, afi
, safi
);
265 * Found a packet template to send, overwrite packet with appropriate
266 * attributes from peer and advance peer
268 s
= bpacket_reformat_for_peer (next_pkt
, paf
);
269 bpacket_queue_advance_peer (paf
);
276 /* The next action for the peer from a write perspective */
278 bgp_write_proceed_actions (struct peer
*peer
)
283 struct bpacket
*next_pkt
;
285 struct update_subgroup
*subgrp
;
287 if (stream_fifo_head (peer
->obuf
))
289 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
293 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
294 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
296 paf
= peer_af_find (peer
, afi
, safi
);
299 subgrp
= paf
->subgroup
;
303 next_pkt
= paf
->next_pkt_to_send
;
304 if (next_pkt
&& next_pkt
->buffer
)
306 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
310 /* No packets readily available for AFI/SAFI, are there subgroup packets
311 * that need to be generated? */
312 if (bpacket_queue_is_full(SUBGRP_INST(subgrp
),
313 SUBGRP_PKTQ(subgrp
)))
315 else if (subgroup_packets_to_build (subgrp
))
317 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
321 /* No packets to send, see if EOR is pending */
322 if (CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
))
324 if (!subgrp
->t_coalesce
&&
325 peer
->afc_nego
[afi
][safi
] &&
327 !CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
328 PEER_STATUS_EOR_SEND
) &&
329 safi
!= SAFI_MPLS_VPN
)
331 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
339 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
344 /* Write packet to the peer. */
346 bgp_write (struct thread
*thread
)
352 int update_last_write
= 0;
353 unsigned int count
= 0;
356 /* Yes first of all get peer pointer. */
357 peer
= THREAD_ARG (thread
);
358 peer
->t_write
= NULL
;
360 /* For non-blocking IO check. */
361 if (peer
->status
== Connect
)
363 bgp_connect_check (peer
, 1);
367 s
= bgp_write_packet (peer
);
370 bgp_write_proceed_actions (peer
);
374 sockopt_cork (peer
->fd
, 1);
376 oc
= peer
->update_out
;
378 /* Nonblocking write until TCP output buffer is full. */
383 /* Number of bytes to be sent. */
384 writenum
= stream_get_endp (s
) - stream_get_getp (s
);
386 /* Call write() system call. */
387 num
= write (peer
->fd
, STREAM_PNT (s
), writenum
);
390 /* write failed either retry needed or error */
391 if (ERRNO_IO_RETRY(errno
))
394 BGP_EVENT_ADD (peer
, TCP_fatal_error
);
401 stream_forward_getp (s
, num
);
405 /* Retrieve BGP packet type. */
406 stream_set_getp (s
, BGP_MARKER_SIZE
+ 2);
407 type
= stream_getc (s
);
419 /* Double start timer. */
422 /* Overflow check. */
423 if (peer
->v_start
>= (60 * 2))
424 peer
->v_start
= (60 * 2);
426 /* Flush any existing events */
427 BGP_EVENT_ADD (peer
, BGP_Stop
);
430 case BGP_MSG_KEEPALIVE
:
431 peer
->keepalive_out
++;
433 case BGP_MSG_ROUTE_REFRESH_NEW
:
434 case BGP_MSG_ROUTE_REFRESH_OLD
:
437 case BGP_MSG_CAPABILITY
:
438 peer
->dynamic_cap_out
++;
442 /* OK we send packet so delete it. */
443 bgp_packet_delete (peer
);
444 update_last_write
= 1;
446 while (++count
< peer
->bgp
->wpkt_quanta
&&
447 (s
= bgp_write_packet (peer
)) != NULL
);
449 bgp_write_proceed_actions (peer
);
452 /* Update last_update if UPDATEs were written. */
453 if (peer
->update_out
> oc
)
454 peer
->last_update
= bgp_clock ();
456 /* If we TXed any flavor of packet update last_write */
457 if (update_last_write
)
458 peer
->last_write
= bgp_clock ();
460 sockopt_cork (peer
->fd
, 0);
464 /* This is only for sending NOTIFICATION message to neighbor. */
466 bgp_write_notify (struct peer
*peer
)
472 /* There should be at least one packet. */
473 s
= stream_fifo_head (peer
->obuf
);
476 assert (stream_get_endp (s
) >= BGP_HEADER_SIZE
);
478 /* Stop collecting data within the socket */
479 sockopt_cork (peer
->fd
, 0);
481 /* socket is in nonblocking mode, if we can't deliver the NOTIFY, well,
482 * we only care about getting a clean shutdown at this point. */
483 ret
= write (peer
->fd
, STREAM_DATA (s
), stream_get_endp (s
));
485 /* only connection reset/close gets counted as TCP_fatal_error, failure
486 * to write the entire NOTIFY doesn't get different FSM treatment */
489 BGP_EVENT_ADD (peer
, TCP_fatal_error
);
493 /* Disable Nagle, make NOTIFY packet go out right away */
495 (void) setsockopt (peer
->fd
, IPPROTO_TCP
, TCP_NODELAY
,
496 (char *) &val
, sizeof (val
));
498 /* Retrieve BGP packet type. */
499 stream_set_getp (s
, BGP_MARKER_SIZE
+ 2);
500 type
= stream_getc (s
);
502 assert (type
== BGP_MSG_NOTIFY
);
504 /* Type should be notify. */
507 /* Double start timer. */
510 /* Overflow check. */
511 if (peer
->v_start
>= (60 * 2))
512 peer
->v_start
= (60 * 2);
514 /* Handle Graceful Restart case where the state changes to
515 Connect instead of Idle */
516 BGP_EVENT_ADD (peer
, BGP_Stop
);
521 /* Make keepalive packet and send it to the peer. */
523 bgp_keepalive_send (struct peer
*peer
)
527 s
= stream_new (BGP_MAX_PACKET_SIZE
);
529 /* Make keepalive packet. */
530 bgp_packet_set_marker (s
, BGP_MSG_KEEPALIVE
);
532 /* Set packet size. */
533 (void)bgp_packet_set_size (s
);
535 /* Dump packet if debug option is set. */
536 /* bgp_packet_dump (s); */
538 if (bgp_debug_keepalive(peer
))
539 zlog_debug ("%s sending KEEPALIVE", peer
->host
);
541 /* Add packet to the peer. */
542 bgp_packet_add (peer
, s
);
544 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
547 /* Make open packet and send it to the peer. */
549 bgp_open_send (struct peer
*peer
)
552 u_int16_t send_holdtime
;
555 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
))
556 send_holdtime
= peer
->holdtime
;
558 send_holdtime
= peer
->bgp
->default_holdtime
;
560 /* local-as Change */
561 if (peer
->change_local_as
)
562 local_as
= peer
->change_local_as
;
564 local_as
= peer
->local_as
;
566 s
= stream_new (BGP_MAX_PACKET_SIZE
);
568 /* Make open packet. */
569 bgp_packet_set_marker (s
, BGP_MSG_OPEN
);
571 /* Set open packet values. */
572 stream_putc (s
, BGP_VERSION_4
); /* BGP version */
573 stream_putw (s
, (local_as
<= BGP_AS_MAX
) ? (u_int16_t
) local_as
575 stream_putw (s
, send_holdtime
); /* Hold Time */
576 stream_put_in_addr (s
, &peer
->local_id
); /* BGP Identifier */
578 /* Set capability code. */
579 bgp_open_capability (s
, peer
);
581 /* Set BGP packet length. */
582 (void)bgp_packet_set_size (s
);
584 if (bgp_debug_neighbor_events(peer
))
585 zlog_debug ("%s sending OPEN, version %d, my as %u, holdtime %d, id %s",
586 peer
->host
, BGP_VERSION_4
, local_as
,
587 send_holdtime
, inet_ntoa (peer
->local_id
));
589 /* Dump packet if debug option is set. */
590 /* bgp_packet_dump (s); */
592 /* Add packet to the peer. */
593 bgp_packet_add (peer
, s
);
595 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
598 /* Send BGP notify packet with data potion. */
600 bgp_notify_send_with_data (struct peer
*peer
, u_char code
, u_char sub_code
,
601 u_char
*data
, size_t datalen
)
606 /* Allocate new stream. */
607 s
= stream_new (BGP_MAX_PACKET_SIZE
);
609 /* Make nitify packet. */
610 bgp_packet_set_marker (s
, BGP_MSG_NOTIFY
);
612 /* Set notify packet values. */
613 stream_putc (s
, code
); /* BGP notify code */
614 stream_putc (s
, sub_code
); /* BGP notify sub_code */
616 /* If notify data is present. */
618 stream_write (s
, data
, datalen
);
620 /* Set BGP packet length. */
621 length
= bgp_packet_set_size (s
);
623 /* Add packet to the peer. */
624 stream_fifo_clean (peer
->obuf
);
625 bgp_packet_add (peer
, s
);
629 struct bgp_notify bgp_notify
;
634 bgp_notify
.code
= code
;
635 bgp_notify
.subcode
= sub_code
;
636 bgp_notify
.data
= NULL
;
637 bgp_notify
.length
= length
- BGP_MSG_NOTIFY_MIN_SIZE
;
638 bgp_notify
.raw_data
= data
;
640 peer
->notify
.code
= bgp_notify
.code
;
641 peer
->notify
.subcode
= bgp_notify
.subcode
;
643 if (bgp_notify
.length
)
645 bgp_notify
.data
= XMALLOC (MTYPE_TMP
, bgp_notify
.length
* 3);
646 for (i
= 0; i
< bgp_notify
.length
; i
++)
649 sprintf (c
, " %02x", data
[i
]);
650 strcat (bgp_notify
.data
, c
);
655 sprintf (c
, "%02x", data
[i
]);
656 strcpy (bgp_notify
.data
, c
);
659 bgp_notify_print (peer
, &bgp_notify
, "sending");
663 XFREE (MTYPE_TMP
, bgp_notify
.data
);
664 bgp_notify
.data
= NULL
;
665 bgp_notify
.length
= 0;
669 /* peer reset cause */
670 if (code
== BGP_NOTIFY_CEASE
)
672 if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_RESET
)
673 peer
->last_reset
= PEER_DOWN_USER_RESET
;
674 else if (sub_code
== BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
)
675 peer
->last_reset
= PEER_DOWN_USER_SHUTDOWN
;
677 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
680 peer
->last_reset
= PEER_DOWN_NOTIFY_SEND
;
682 /* Call immediately. */
683 BGP_WRITE_OFF (peer
->t_write
);
685 bgp_write_notify (peer
);
688 /* Send BGP notify packet. */
690 bgp_notify_send (struct peer
*peer
, u_char code
, u_char sub_code
)
692 bgp_notify_send_with_data (peer
, code
, sub_code
, NULL
, 0);
695 /* Send route refresh message to the peer. */
697 bgp_route_refresh_send (struct peer
*peer
, afi_t afi
, safi_t safi
,
698 u_char orf_type
, u_char when_to_refresh
, int remove
)
701 struct bgp_filter
*filter
;
706 if (DISABLE_BGP_ANNOUNCE
)
709 filter
= &peer
->filter
[afi
][safi
];
711 /* Convert AFI, SAFI to values for packet. */
712 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
714 s
= stream_new (BGP_MAX_PACKET_SIZE
);
716 /* Make BGP update packet. */
717 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
718 bgp_packet_set_marker (s
, BGP_MSG_ROUTE_REFRESH_NEW
);
720 bgp_packet_set_marker (s
, BGP_MSG_ROUTE_REFRESH_OLD
);
722 /* Encode Route Refresh message. */
723 stream_putw (s
, pkt_afi
);
725 stream_putc (s
, pkt_safi
);
727 if (orf_type
== ORF_TYPE_PREFIX
728 || orf_type
== ORF_TYPE_PREFIX_OLD
)
729 if (remove
|| filter
->plist
[FILTER_IN
].plist
)
735 stream_putc (s
, when_to_refresh
);
736 stream_putc (s
, orf_type
);
737 orfp
= stream_get_endp (s
);
742 UNSET_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
);
743 stream_putc (s
, ORF_COMMON_PART_REMOVE_ALL
);
744 if (bgp_debug_neighbor_events(peer
))
745 zlog_debug ("%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %d/%d",
746 peer
->host
, orf_type
,
747 (when_to_refresh
== REFRESH_DEFER
? "defer" : "immediate"),
752 SET_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
);
753 prefix_bgp_orf_entry (s
, filter
->plist
[FILTER_IN
].plist
,
754 ORF_COMMON_PART_ADD
, ORF_COMMON_PART_PERMIT
,
755 ORF_COMMON_PART_DENY
);
756 if (bgp_debug_neighbor_events(peer
))
757 zlog_debug ("%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %d/%d",
758 peer
->host
, orf_type
,
759 (when_to_refresh
== REFRESH_DEFER
? "defer" : "immediate"),
763 /* Total ORF Entry Len. */
764 orf_len
= stream_get_endp (s
) - orfp
- 2;
765 stream_putw_at (s
, orfp
, orf_len
);
768 /* Set packet size. */
769 (void)bgp_packet_set_size (s
);
771 if (bgp_debug_neighbor_events(peer
))
774 zlog_debug ("%s sending REFRESH_REQ for afi/safi: %d/%d",
775 peer
->host
, pkt_afi
, pkt_safi
);
778 /* Add packet to the peer. */
779 bgp_packet_add (peer
, s
);
781 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
784 /* Send capability message to the peer. */
786 bgp_capability_send (struct peer
*peer
, afi_t afi
, safi_t safi
,
787 int capability_code
, int action
)
793 /* Convert AFI, SAFI to values for packet. */
794 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
796 s
= stream_new (BGP_MAX_PACKET_SIZE
);
798 /* Make BGP update packet. */
799 bgp_packet_set_marker (s
, BGP_MSG_CAPABILITY
);
801 /* Encode MP_EXT capability. */
802 if (capability_code
== CAPABILITY_CODE_MP
)
804 stream_putc (s
, action
);
805 stream_putc (s
, CAPABILITY_CODE_MP
);
806 stream_putc (s
, CAPABILITY_CODE_MP_LEN
);
807 stream_putw (s
, pkt_afi
);
809 stream_putc (s
, pkt_safi
);
811 if (bgp_debug_neighbor_events(peer
))
812 zlog_debug ("%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %d/%d",
813 peer
->host
, action
== CAPABILITY_ACTION_SET
?
814 "Advertising" : "Removing", pkt_afi
, pkt_safi
);
817 /* Set packet size. */
818 (void)bgp_packet_set_size (s
);
820 /* Add packet to the peer. */
821 bgp_packet_add (peer
, s
);
823 BGP_WRITE_ON (peer
->t_write
, bgp_write
, peer
->fd
);
826 /* RFC1771 6.8 Connection collision detection. */
828 bgp_collision_detect (struct peer
*new, struct in_addr remote_id
)
832 /* Upon receipt of an OPEN message, the local system must examine
833 all of its connections that are in the OpenConfirm state. A BGP
834 speaker may also examine connections in an OpenSent state if it
835 knows the BGP Identifier of the peer by means outside of the
836 protocol. If among these connections there is a connection to a
837 remote BGP speaker whose BGP Identifier equals the one in the
838 OPEN message, then the local system performs the following
839 collision resolution procedure: */
841 if ((peer
= new->doppelganger
) != NULL
)
843 /* Do not accept the new connection in Established or Clearing states.
844 * Note that a peer GR is handled by closing the existing connection
845 * upon receipt of new one.
847 if (peer
->status
== Established
|| peer
->status
== Clearing
)
849 bgp_notify_send (new, BGP_NOTIFY_CEASE
,
850 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
853 else if ((peer
->status
== OpenConfirm
) || (peer
->status
== OpenSent
))
855 /* 1. The BGP Identifier of the local system is compared to
856 the BGP Identifier of the remote system (as specified in
857 the OPEN message). */
859 if (ntohl (peer
->local_id
.s_addr
) < ntohl (remote_id
.s_addr
))
860 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
862 /* 2. If the value of the local BGP Identifier is less
863 than the remote one, the local system closes BGP
864 connection that already exists (the one that is
865 already in the OpenConfirm state), and accepts BGP
866 connection initiated by the remote system. */
867 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
868 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
873 bgp_notify_send (new, BGP_NOTIFY_CEASE
,
874 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
879 /* 3. Otherwise, the local system closes newly created
880 BGP connection (the one associated with the newly
881 received OPEN message), and continues to use the
882 existing one (the one that is already in the
883 OpenConfirm state). */
884 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
886 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
887 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
892 bgp_notify_send (new, BGP_NOTIFY_CEASE
,
893 BGP_NOTIFY_CEASE_COLLISION_RESOLUTION
);
903 bgp_open_receive (struct peer
*peer
, bgp_size_t size
)
909 u_int16_t send_holdtime
;
912 struct in_addr remote_id
;
914 u_int8_t notify_data_remote_as
[2];
915 u_int8_t notify_data_remote_as4
[4];
916 u_int8_t notify_data_remote_id
[4];
917 u_int16_t
*holdtime_ptr
;
919 /* Parse open packet. */
920 version
= stream_getc (peer
->ibuf
);
921 memcpy (notify_data_remote_as
, stream_pnt (peer
->ibuf
), 2);
922 remote_as
= stream_getw (peer
->ibuf
);
923 holdtime_ptr
= (u_int16_t
*)stream_pnt (peer
->ibuf
);
924 holdtime
= stream_getw (peer
->ibuf
);
925 memcpy (notify_data_remote_id
, stream_pnt (peer
->ibuf
), 4);
926 remote_id
.s_addr
= stream_get_ipv4 (peer
->ibuf
);
928 /* Receive OPEN message log */
929 if (bgp_debug_neighbor_events(peer
))
930 zlog_debug ("%s rcv OPEN, version %d, remote-as (in open) %u,"
931 " holdtime %d, id %s",
932 peer
->host
, version
, remote_as
, holdtime
,
933 inet_ntoa (remote_id
));
935 /* BEGIN to read the capability here, but dont do it yet */
937 optlen
= stream_getc (peer
->ibuf
);
941 /* If not enough bytes, it is an error. */
942 if (STREAM_READABLE(peer
->ibuf
) < optlen
)
944 bgp_notify_send (peer
, BGP_NOTIFY_OPEN_ERR
,
945 BGP_NOTIFY_OPEN_MALFORMED_ATTR
);
949 /* We need the as4 capability value *right now* because
950 * if it is there, we have not got the remote_as yet, and without
951 * that we do not know which peer is connecting to us now.
953 as4
= peek_for_as4_capability (peer
, optlen
);
954 memcpy (notify_data_remote_as4
, &as4
, 4);
957 /* Just in case we have a silly peer who sends AS4 capability set to 0 */
958 if (CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
) && !as4
)
960 zlog_err ("%s bad OPEN, got AS4 capability, but AS4 set to 0",
962 bgp_notify_send_with_data (peer
,
964 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
965 notify_data_remote_as4
, 4);
969 if (remote_as
== BGP_AS_TRANS
)
971 /* Take the AS4 from the capability. We must have received the
972 * capability now! Otherwise we have a asn16 peer who uses
973 * BGP_AS_TRANS, for some unknown reason.
975 if (as4
== BGP_AS_TRANS
)
977 zlog_err ("%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
979 bgp_notify_send_with_data (peer
,
981 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
982 notify_data_remote_as4
, 4);
986 if (!as4
&& BGP_DEBUG (as4
, AS4
))
987 zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
988 " Odd, but proceeding.", peer
->host
);
989 else if (as4
< BGP_AS_MAX
&& BGP_DEBUG (as4
, AS4
))
990 zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
991 "in 2-bytes, very odd peer.", peer
->host
, as4
);
997 /* We may have a partner with AS4 who has an asno < BGP_AS_MAX */
998 /* If we have got the capability, peer->as4cap must match remote_as */
999 if (CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
)
1000 && as4
!= remote_as
)
1002 /* raise error, log this, close session */
1003 zlog_err ("%s bad OPEN, got AS4 capability, but remote_as %u"
1004 " mismatch with 16bit 'myasn' %u in open",
1005 peer
->host
, as4
, remote_as
);
1006 bgp_notify_send_with_data (peer
,
1007 BGP_NOTIFY_OPEN_ERR
,
1008 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1009 notify_data_remote_as4
, 4);
1014 /* remote router-id check. */
1015 if (remote_id
.s_addr
== 0
1016 || IPV4_CLASS_DE (ntohl (remote_id
.s_addr
))
1017 || ntohl (peer
->local_id
.s_addr
) == ntohl (remote_id
.s_addr
))
1019 if (bgp_debug_neighbor_events(peer
))
1020 zlog_debug ("%s bad OPEN, wrong router identifier %s",
1021 peer
->host
, inet_ntoa (remote_id
));
1022 bgp_notify_send_with_data (peer
,
1023 BGP_NOTIFY_OPEN_ERR
,
1024 BGP_NOTIFY_OPEN_BAD_BGP_IDENT
,
1025 notify_data_remote_id
, 4);
1029 /* Set remote router-id */
1030 peer
->remote_id
= remote_id
;
1032 /* Peer BGP version check. */
1033 if (version
!= BGP_VERSION_4
)
1035 u_int16_t maxver
= htons(BGP_VERSION_4
);
1036 /* XXX this reply may not be correct if version < 4 XXX */
1037 if (bgp_debug_neighbor_events(peer
))
1038 zlog_debug ("%s bad protocol version, remote requested %d, local request %d",
1039 peer
->host
, version
, BGP_VERSION_4
);
1040 /* Data must be in network byte order here */
1041 bgp_notify_send_with_data (peer
,
1042 BGP_NOTIFY_OPEN_ERR
,
1043 BGP_NOTIFY_OPEN_UNSUP_VERSION
,
1044 (u_int8_t
*) &maxver
, 2);
1048 /* Check neighbor as number. */
1049 if (peer
->as_type
== AS_UNSPECIFIED
)
1051 if (bgp_debug_neighbor_events(peer
))
1052 zlog_debug("%s bad OPEN, remote AS is unspecified currently", peer
->host
);
1053 bgp_notify_send_with_data(peer
,
1054 BGP_NOTIFY_OPEN_ERR
,
1055 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1056 notify_data_remote_as
, 2);
1059 else if (peer
->as_type
== AS_INTERNAL
)
1061 if (remote_as
!= peer
->bgp
->as
)
1063 if (bgp_debug_neighbor_events(peer
))
1064 zlog_debug ("%s bad OPEN, remote AS is %u, internal specified",
1065 peer
->host
, remote_as
);
1066 bgp_notify_send_with_data (peer
,
1067 BGP_NOTIFY_OPEN_ERR
,
1068 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1069 notify_data_remote_as
, 2);
1072 peer
->as
= peer
->local_as
;
1074 else if (peer
->as_type
== AS_EXTERNAL
)
1076 if (remote_as
== peer
->bgp
->as
)
1078 if (bgp_debug_neighbor_events(peer
))
1079 zlog_debug ("%s bad OPEN, remote AS is %u, external specified",
1080 peer
->host
, remote_as
);
1081 bgp_notify_send_with_data (peer
,
1082 BGP_NOTIFY_OPEN_ERR
,
1083 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1084 notify_data_remote_as
, 2);
1087 peer
->as
= remote_as
;
1089 else if ((peer
->as_type
== AS_SPECIFIED
) && (remote_as
!= peer
->as
))
1091 if (bgp_debug_neighbor_events(peer
))
1092 zlog_debug ("%s bad OPEN, remote AS is %u, expected %u",
1093 peer
->host
, remote_as
, peer
->as
);
1094 bgp_notify_send_with_data (peer
,
1095 BGP_NOTIFY_OPEN_ERR
,
1096 BGP_NOTIFY_OPEN_BAD_PEER_AS
,
1097 notify_data_remote_as
, 2);
1101 /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1102 calculate the value of the Hold Timer by using the smaller of its
1103 configured Hold Time and the Hold Time received in the OPEN message.
1104 The Hold Time MUST be either zero or at least three seconds. An
1105 implementation may reject connections on the basis of the Hold Time. */
1107 if (holdtime
< 3 && holdtime
!= 0)
1109 bgp_notify_send_with_data (peer
,
1110 BGP_NOTIFY_OPEN_ERR
,
1111 BGP_NOTIFY_OPEN_UNACEP_HOLDTIME
,
1112 (u_char
*)holdtime_ptr
, 2);
1116 /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1117 would be one third of the Hold Time interval. KEEPALIVE messages
1118 MUST NOT be sent more frequently than one per second. An
1119 implementation MAY adjust the rate at which it sends KEEPALIVE
1120 messages as a function of the Hold Time interval. */
1122 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
))
1123 send_holdtime
= peer
->holdtime
;
1125 send_holdtime
= peer
->bgp
->default_holdtime
;
1127 if (holdtime
< send_holdtime
)
1128 peer
->v_holdtime
= holdtime
;
1130 peer
->v_holdtime
= send_holdtime
;
1132 peer
->v_keepalive
= peer
->v_holdtime
/ 3;
1134 /* Open option part parse. */
1137 if ((ret
= bgp_open_option_parse (peer
, optlen
, &mp_capability
)) < 0)
1142 if (bgp_debug_neighbor_events(peer
))
1143 zlog_debug ("%s rcvd OPEN w/ OPTION parameter len: 0",
1148 * Assume that the peer supports the locally configured set of
1149 * AFI/SAFIs if the peer did not send us any Mulitiprotocol
1150 * capabilities, or if 'override-capability' is configured.
1152 if (! mp_capability
||
1153 CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
1155 peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] = peer
->afc
[AFI_IP
][SAFI_UNICAST
];
1156 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] = peer
->afc
[AFI_IP
][SAFI_MULTICAST
];
1157 peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
] = peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
];
1158 peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] = peer
->afc
[AFI_IP6
][SAFI_UNICAST
];
1159 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] = peer
->afc
[AFI_IP6
][SAFI_MULTICAST
];
1160 peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
] = peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
];
1163 /* When collision is detected and this peer is closed. Retrun
1165 ret
= bgp_collision_detect (peer
, remote_id
);
1170 if ((ret
= bgp_getsockname (peer
)) < 0)
1172 zlog_err("%s: bgp_getsockname() failed for peer: %s", __FUNCTION__
,
1177 /* Verify valid local address present based on negotiated address-families. */
1178 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
] ||
1179 peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
] ||
1180 peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
] ||
1181 peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
])
1183 if (!peer
->nexthop
.v4
.s_addr
)
1185 #if defined (HAVE_CUMULUS)
1186 zlog_err ("%s: No local IPv4 addr resetting connection, fd %d",
1187 peer
->host
, peer
->fd
);
1188 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1193 if (peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
] ||
1194 peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
] ||
1195 peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
] ||
1196 peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
1198 if (IN6_IS_ADDR_UNSPECIFIED (&peer
->nexthop
.v6_global
))
1200 #if defined (HAVE_CUMULUS)
1201 zlog_err ("%s: No local IPv6 addr resetting connection, fd %d",
1202 peer
->host
, peer
->fd
);
1203 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_SUBCODE_UNSPECIFIC
);
1208 peer
->rtt
= sockopt_tcp_rtt (peer
->fd
);
1210 if ((ret
= bgp_event_update(peer
, Receive_OPEN_message
)) < 0)
1212 zlog_err("%s: BGP event update failed for peer: %s", __FUNCTION__
,
1214 /* DD: bgp send notify and reset state */
1218 peer
->packet_size
= 0;
1220 stream_reset (peer
->ibuf
);
1225 /* Called when there is a change in the EOR(implicit or explicit) status of a peer.
1226 Ends the update-delay if all expected peers are done with EORs. */
1228 bgp_check_update_delay(struct bgp
*bgp
)
1230 struct listnode
*node
, *nnode
;
1231 struct peer
*peer
= NULL
;
1233 if (bgp_debug_neighbor_events(peer
))
1234 zlog_debug ("Checking update delay, T: %d R: %d I:%d E: %d", bgp
->established
,
1235 bgp
->restarted_peers
, bgp
->implicit_eors
, bgp
->explicit_eors
);
1237 if (bgp
->established
<=
1238 bgp
->restarted_peers
+ bgp
->implicit_eors
+ bgp
->explicit_eors
)
1240 /* This is an extra sanity check to make sure we wait for all the
1241 eligible configured peers. This check is performed if establish wait
1242 timer is on, or establish wait option is not given with the
1243 update-delay command */
1244 if (bgp
->t_establish_wait
||
1245 (bgp
->v_establish_wait
== bgp
->v_update_delay
))
1246 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
1248 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1249 && !CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
)
1250 && !peer
->update_delay_over
)
1252 if (bgp_debug_neighbor_events(peer
))
1253 zlog_debug (" Peer %s pending, continuing read-only mode",
1259 zlog_info ("Update delay ended, restarted: %d, EORs implicit: %d, explicit: %d",
1260 bgp
->restarted_peers
, bgp
->implicit_eors
, bgp
->explicit_eors
);
1261 bgp_update_delay_end(bgp
);
1265 /* Called if peer is known to have restarted. The restart-state bit in
1266 Graceful-Restart capability is used for that */
1268 bgp_update_restarted_peers (struct peer
*peer
)
1270 if (!bgp_update_delay_active(peer
->bgp
)) return; /* BGP update delay has ended */
1271 if (peer
->update_delay_over
) return; /* This peer has already been considered */
1273 if (bgp_debug_neighbor_events(peer
))
1274 zlog_debug ("Peer %s: Checking restarted", peer
->host
);
1276 if (peer
->status
== Established
)
1278 peer
->update_delay_over
= 1;
1279 peer
->bgp
->restarted_peers
++;
1280 bgp_check_update_delay(peer
->bgp
);
1284 /* Called as peer receives a keep-alive. Determines if this occurence can be
1285 taken as an implicit EOR for this peer.
1286 NOTE: The very first keep-alive after the Established state of a peer is
1287 considered implicit EOR for the update-delay purposes */
1289 bgp_update_implicit_eors (struct peer
*peer
)
1291 if (!bgp_update_delay_active(peer
->bgp
)) return; /* BGP update delay has ended */
1292 if (peer
->update_delay_over
) return; /* This peer has already been considered */
1294 if (bgp_debug_neighbor_events(peer
))
1295 zlog_debug ("Peer %s: Checking implicit EORs", peer
->host
);
1297 if (peer
->status
== Established
)
1299 peer
->update_delay_over
= 1;
1300 peer
->bgp
->implicit_eors
++;
1301 bgp_check_update_delay(peer
->bgp
);
1305 /* Should be called only when there is a change in the EOR_RECEIVED status
1306 for any afi/safi on a peer */
1308 bgp_update_explicit_eors (struct peer
*peer
)
1313 if (!bgp_update_delay_active(peer
->bgp
)) return; /* BGP update delay has ended */
1314 if (peer
->update_delay_over
) return; /* This peer has already been considered */
1316 if (bgp_debug_neighbor_events(peer
))
1317 zlog_debug ("Peer %s: Checking explicit EORs", peer
->host
);
1319 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1320 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1322 if (peer
->afc_nego
[afi
][safi
] &&
1323 !CHECK_FLAG(peer
->af_sflags
[afi
][safi
], PEER_STATUS_EOR_RECEIVED
))
1325 if (bgp_debug_neighbor_events(peer
))
1326 zlog_debug (" afi %d safi %d didnt receive EOR", afi
, safi
);
1331 peer
->update_delay_over
= 1;
1332 peer
->bgp
->explicit_eors
++;
1333 bgp_check_update_delay(peer
->bgp
);
1336 /* Frontend for NLRI parsing, to fan-out to AFI/SAFI specific parsers
1337 * mp_withdraw, if set, is used to nullify attr structure on most of the calling safi function
1338 * and for evpn, passed as parameter
1341 bgp_nlri_parse (struct peer
*peer
, struct attr
*attr
, struct bgp_nlri
*packet
, int mp_withdraw
)
1343 switch (packet
->safi
)
1346 case SAFI_MULTICAST
:
1347 return bgp_nlri_parse_ip (peer
, mp_withdraw
?NULL
:attr
, packet
);
1348 case SAFI_LABELED_UNICAST
:
1349 return bgp_nlri_parse_label (peer
, mp_withdraw
?NULL
:attr
, packet
);
1351 return bgp_nlri_parse_vpn (peer
, mp_withdraw
?NULL
:attr
, packet
);
1353 return bgp_nlri_parse_encap (peer
, mp_withdraw
?NULL
:attr
, packet
);
1355 return bgp_nlri_parse_evpn (peer
, attr
, packet
, mp_withdraw
);
1360 /* Parse BGP Update packet and make attribute object. */
1362 bgp_update_receive (struct peer
*peer
, bgp_size_t size
)
1368 struct attr_extra extra
;
1369 bgp_size_t attribute_len
;
1370 bgp_size_t update_len
;
1371 bgp_size_t withdraw_len
;
1380 struct bgp_nlri nlris
[NLRI_TYPE_MAX
];
1382 /* Status must be Established. */
1383 if (peer
->status
!= Established
)
1385 zlog_err ("%s [FSM] Update packet received under status %s",
1386 peer
->host
, LOOKUP (bgp_status_msg
, peer
->status
));
1387 bgp_notify_send (peer
, BGP_NOTIFY_FSM_ERR
, 0);
1391 /* Set initial values. */
1392 memset (&attr
, 0, sizeof (struct attr
));
1393 memset (&extra
, 0, sizeof (struct attr_extra
));
1394 extra
.label_index
= BGP_INVALID_LABEL_INDEX
;
1395 memset (&nlris
, 0, sizeof (nlris
));
1396 attr
.extra
= &extra
;
1397 memset (peer
->rcvd_attr_str
, 0, BUFSIZ
);
1398 peer
->rcvd_attr_printed
= 0;
1401 end
= stream_pnt (s
) + size
;
1403 /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1404 Length is too large (i.e., if Unfeasible Routes Length + Total
1405 Attribute Length + 23 exceeds the message Length), then the Error
1406 Subcode is set to Malformed Attribute List. */
1407 if (stream_pnt (s
) + 2 > end
)
1409 zlog_err ("%s [Error] Update packet error"
1410 " (packet length is short for unfeasible length)",
1412 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1413 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1417 /* Unfeasible Route Length. */
1418 withdraw_len
= stream_getw (s
);
1420 /* Unfeasible Route Length check. */
1421 if (stream_pnt (s
) + withdraw_len
> end
)
1423 zlog_err ("%s [Error] Update packet error"
1424 " (packet unfeasible length overflow %d)",
1425 peer
->host
, withdraw_len
);
1426 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1427 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1431 /* Unfeasible Route packet format check. */
1432 if (withdraw_len
> 0)
1434 nlris
[NLRI_WITHDRAW
].afi
= AFI_IP
;
1435 nlris
[NLRI_WITHDRAW
].safi
= SAFI_UNICAST
;
1436 nlris
[NLRI_WITHDRAW
].nlri
= stream_pnt (s
);
1437 nlris
[NLRI_WITHDRAW
].length
= withdraw_len
;
1438 stream_forward_getp (s
, withdraw_len
);
1441 /* Attribute total length check. */
1442 if (stream_pnt (s
) + 2 > end
)
1444 zlog_warn ("%s [Error] Packet Error"
1445 " (update packet is short for attribute length)",
1447 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1448 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1452 /* Fetch attribute total length. */
1453 attribute_len
= stream_getw (s
);
1455 /* Attribute length check. */
1456 if (stream_pnt (s
) + attribute_len
> end
)
1458 zlog_warn ("%s [Error] Packet Error"
1459 " (update packet attribute length overflow %d)",
1460 peer
->host
, attribute_len
);
1461 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1462 BGP_NOTIFY_UPDATE_MAL_ATTR
);
1466 /* Certain attribute parsing errors should not be considered bad enough
1467 * to reset the session for, most particularly any partial/optional
1468 * attributes that have 'tunneled' over speakers that don't understand
1469 * them. Instead we withdraw only the prefix concerned.
1471 * Complicates the flow a little though..
1473 bgp_attr_parse_ret_t attr_parse_ret
= BGP_ATTR_PARSE_PROCEED
;
1474 /* This define morphs the update case into a withdraw when lower levels
1475 * have signalled an error condition where this is best.
1477 #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1479 /* Parse attribute when it exists. */
1482 attr_parse_ret
= bgp_attr_parse (peer
, &attr
, attribute_len
,
1483 &nlris
[NLRI_MP_UPDATE
], &nlris
[NLRI_MP_WITHDRAW
]);
1484 if (attr_parse_ret
== BGP_ATTR_PARSE_ERROR
)
1486 bgp_attr_unintern_sub (&attr
);
1491 /* Logging the attribute. */
1492 if (attr_parse_ret
== BGP_ATTR_PARSE_WITHDRAW
||
1493 BGP_DEBUG (update
, UPDATE_IN
) ||
1494 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
)
1499 zlog_err ("%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1502 if (ret
&& bgp_debug_update(peer
, NULL
, NULL
, 1))
1504 zlog_debug ("%s rcvd UPDATE w/ attr: %s", peer
->host
, peer
->rcvd_attr_str
);
1505 peer
->rcvd_attr_printed
= 1;
1509 /* Network Layer Reachability Information. */
1510 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
++)
1532 /* NLRI is processed iff the peer if configured for the specific afi/safi */
1533 if (!peer
->afc
[nlris
[i
].afi
][nlris
[i
].safi
])
1535 zlog_info ("%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)
1547 case NLRI_MP_UPDATE
:
1548 nlri_ret
= bgp_nlri_parse (peer
, NLRI_ATTR_ARG
, &nlris
[i
], 0);
1551 case NLRI_MP_WITHDRAW
:
1552 nlri_ret
= bgp_nlri_parse (peer
, &attr
, &nlris
[i
], 1);
1560 zlog_err("%s [Error] Error parsing NLRI", peer
->host
);
1561 if (peer
->status
== Established
)
1562 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1563 i
<= NLRI_WITHDRAW
? BGP_NOTIFY_UPDATE_INVAL_NETWORK
1564 : BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
);
1565 bgp_attr_unintern_sub (&attr
);
1572 * Non-MP IPv4/Unicast EoR is a completely empty UPDATE
1573 * and MP EoR should have only an empty MP_UNREACH
1575 if (!update_len
&& !withdraw_len
1576 && nlris
[NLRI_MP_UPDATE
].length
== 0)
1581 /* Non-MP IPv4/Unicast is a completely emtpy UPDATE - already checked
1582 * update and withdraw NLRI lengths are 0.
1587 safi
= SAFI_UNICAST
;
1589 else if (attr
.flag
& ATTR_FLAG_BIT (BGP_ATTR_MP_UNREACH_NLRI
)
1590 && nlris
[NLRI_MP_WITHDRAW
].length
== 0)
1592 afi
= nlris
[NLRI_MP_WITHDRAW
].afi
;
1593 safi
= nlris
[NLRI_MP_WITHDRAW
].safi
;
1596 if (afi
&& peer
->afc
[afi
][safi
])
1598 /* End-of-RIB received */
1599 if (!CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_EOR_RECEIVED
))
1601 SET_FLAG (peer
->af_sflags
[afi
][safi
],
1602 PEER_STATUS_EOR_RECEIVED
);
1603 bgp_update_explicit_eors(peer
);
1606 /* NSF delete stale route */
1607 if (peer
->nsf
[afi
][safi
])
1608 bgp_clear_stale_route (peer
, afi
, safi
);
1610 if (bgp_debug_neighbor_events(peer
))
1612 zlog_debug ("rcvd End-of-RIB for %s from %s",
1613 afi_safi_print (afi
, safi
), peer
->host
);
1618 /* Everything is done. We unintern temporary structures which
1619 interned in bgp_attr_parse(). */
1620 bgp_attr_unintern_sub (&attr
);
1622 /* If peering is stopped due to some reason, do not generate BGP
1624 if (peer
->status
!= Established
)
1627 /* Increment packet counter. */
1629 peer
->update_time
= bgp_clock ();
1631 /* Rearm holdtime timer */
1632 BGP_TIMER_OFF (peer
->t_holdtime
);
1633 bgp_timer_set (peer
);
1638 /* Notify message treatment function. */
1640 bgp_notify_receive (struct peer
*peer
, bgp_size_t size
)
1642 struct bgp_notify bgp_notify
;
1644 if (peer
->notify
.data
)
1646 XFREE (MTYPE_TMP
, peer
->notify
.data
);
1647 peer
->notify
.data
= NULL
;
1648 peer
->notify
.length
= 0;
1651 bgp_notify
.code
= stream_getc (peer
->ibuf
);
1652 bgp_notify
.subcode
= stream_getc (peer
->ibuf
);
1653 bgp_notify
.length
= size
- 2;
1654 bgp_notify
.data
= NULL
;
1656 /* Preserv notify code and sub code. */
1657 peer
->notify
.code
= bgp_notify
.code
;
1658 peer
->notify
.subcode
= bgp_notify
.subcode
;
1659 /* For further diagnostic record returned Data. */
1660 if (bgp_notify
.length
)
1662 peer
->notify
.length
= size
- 2;
1663 peer
->notify
.data
= XMALLOC (MTYPE_TMP
, size
- 2);
1664 memcpy (peer
->notify
.data
, stream_pnt (peer
->ibuf
), size
- 2);
1673 if (bgp_notify
.length
)
1675 bgp_notify
.data
= XMALLOC (MTYPE_TMP
, bgp_notify
.length
* 3);
1676 for (i
= 0; i
< bgp_notify
.length
; i
++)
1679 sprintf (c
, " %02x", stream_getc (peer
->ibuf
));
1680 strcat (bgp_notify
.data
, c
);
1685 sprintf (c
, "%02x", stream_getc (peer
->ibuf
));
1686 strcpy (bgp_notify
.data
, c
);
1688 bgp_notify
.raw_data
= (u_char
*)peer
->notify
.data
;
1691 bgp_notify_print(peer
, &bgp_notify
, "received");
1692 if (bgp_notify
.data
)
1694 XFREE (MTYPE_TMP
, bgp_notify
.data
);
1695 bgp_notify
.data
= NULL
;
1696 bgp_notify
.length
= 0;
1700 /* peer count update */
1703 peer
->last_reset
= PEER_DOWN_NOTIFY_RECEIVED
;
1705 /* We have to check for Notify with Unsupported Optional Parameter.
1706 in that case we fallback to open without the capability option.
1707 But this done in bgp_stop. We just mark it here to avoid changing
1709 if (bgp_notify
.code
== BGP_NOTIFY_OPEN_ERR
&&
1710 bgp_notify
.subcode
== BGP_NOTIFY_OPEN_UNSUP_PARAM
)
1711 UNSET_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1713 BGP_EVENT_ADD (peer
, Receive_NOTIFICATION_message
);
1716 /* Keepalive treatment function -- get keepalive send keepalive */
1718 bgp_keepalive_receive (struct peer
*peer
, bgp_size_t size
)
1720 if (bgp_debug_keepalive(peer
))
1721 zlog_debug ("%s KEEPALIVE rcvd", peer
->host
);
1723 BGP_EVENT_ADD (peer
, Receive_KEEPALIVE_message
);
1726 /* Route refresh message is received. */
1728 bgp_route_refresh_receive (struct peer
*peer
, bgp_size_t size
)
1732 safi_t pkt_safi
, safi
;
1734 struct peer_af
*paf
;
1735 struct update_group
*updgrp
;
1736 struct peer
*updgrp_peer
;
1738 /* If peer does not have the capability, send notification. */
1739 if (! CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_ADV
))
1741 zlog_err ("%s [Error] BGP route refresh is not enabled",
1743 bgp_notify_send (peer
,
1744 BGP_NOTIFY_HEADER_ERR
,
1745 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
1749 /* Status must be Established. */
1750 if (peer
->status
!= Established
)
1752 zlog_err ("%s [Error] Route refresh packet received under status %s",
1753 peer
->host
, LOOKUP (bgp_status_msg
, peer
->status
));
1754 bgp_notify_send (peer
, BGP_NOTIFY_FSM_ERR
, 0);
1761 pkt_afi
= stream_getw (s
);
1762 (void)stream_getc (s
);
1763 pkt_safi
= stream_getc (s
);
1765 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1766 zlog_debug ("%s rcvd REFRESH_REQ for afi/safi: %d/%d",
1767 peer
->host
, pkt_afi
, pkt_safi
);
1769 /* Convert AFI, SAFI to internal values and check. */
1770 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
1772 zlog_info ("%s REFRESH_REQ for unrecognized afi/safi: %d/%d - ignored",
1773 peer
->host
, pkt_afi
, pkt_safi
);
1777 if (size
!= BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
)
1780 u_char when_to_refresh
;
1784 if (size
- (BGP_MSG_ROUTE_REFRESH_MIN_SIZE
- BGP_HEADER_SIZE
) < 5)
1786 zlog_info ("%s ORF route refresh length error", peer
->host
);
1787 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
1791 when_to_refresh
= stream_getc (s
);
1792 end
= stream_pnt (s
) + (size
- 5);
1794 while ((stream_pnt (s
) + 2) < end
)
1796 orf_type
= stream_getc (s
);
1797 orf_len
= stream_getw (s
);
1799 /* orf_len in bounds? */
1800 if ((stream_pnt (s
) + orf_len
) > end
)
1801 break; /* XXX: Notify instead?? */
1802 if (orf_type
== ORF_TYPE_PREFIX
1803 || orf_type
== ORF_TYPE_PREFIX_OLD
)
1805 uint8_t *p_pnt
= stream_pnt (s
);
1806 uint8_t *p_end
= stream_pnt (s
) + orf_len
;
1807 struct orf_prefix orfp
;
1812 int ret
= CMD_SUCCESS
;
1814 if (bgp_debug_neighbor_events(peer
))
1816 zlog_debug ("%s rcvd Prefixlist ORF(%d) length %d",
1817 peer
->host
, orf_type
, orf_len
);
1820 /* we're going to read at least 1 byte of common ORF header,
1821 * and 7 bytes of ORF Address-filter entry from the stream
1826 /* ORF prefix-list name */
1827 sprintf (name
, "%s.%d.%d", peer
->host
, afi
, safi
);
1829 while (p_pnt
< p_end
)
1831 /* If the ORF entry is malformed, want to read as much of it
1832 * as possible without going beyond the bounds of the entry,
1833 * to maximise debug information.
1836 memset (&orfp
, 0, sizeof (struct orf_prefix
));
1838 /* after ++: p_pnt <= p_end */
1839 if (common
& ORF_COMMON_PART_REMOVE_ALL
)
1841 if (bgp_debug_neighbor_events(peer
))
1842 zlog_debug ("%s rcvd Remove-All pfxlist ORF request", peer
->host
);
1843 prefix_bgp_orf_remove_all (afi
, name
);
1846 ok
= ((u_int32_t
)(p_end
- p_pnt
) >= sizeof(u_int32_t
)) ;
1849 memcpy (&seq
, p_pnt
, sizeof (u_int32_t
));
1850 p_pnt
+= sizeof (u_int32_t
);
1851 orfp
.seq
= ntohl (seq
);
1856 if ((ok
= (p_pnt
< p_end
)))
1857 orfp
.ge
= *p_pnt
++ ; /* value checked in prefix_bgp_orf_set() */
1858 if ((ok
= (p_pnt
< p_end
)))
1859 orfp
.le
= *p_pnt
++ ; /* value checked in prefix_bgp_orf_set() */
1860 if ((ok
= (p_pnt
< p_end
)))
1861 orfp
.p
.prefixlen
= *p_pnt
++ ;
1862 orfp
.p
.family
= afi2family (afi
); /* afi checked already */
1864 psize
= PSIZE (orfp
.p
.prefixlen
); /* 0 if not ok */
1865 if (psize
> prefix_blen(&orfp
.p
)) /* valid for family ? */
1868 psize
= prefix_blen(&orfp
.p
) ;
1870 if (psize
> (p_end
- p_pnt
)) /* valid for packet ? */
1873 psize
= p_end
- p_pnt
;
1877 memcpy (&orfp
.p
.u
.prefix
, p_pnt
, psize
);
1880 if (bgp_debug_neighbor_events(peer
))
1882 char buf
[INET6_BUFSIZ
];
1884 zlog_debug ("%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
1886 (common
& ORF_COMMON_PART_REMOVE
? "Remove" : "Add"),
1887 (common
& ORF_COMMON_PART_DENY
? "deny" : "permit"),
1889 inet_ntop (orfp
.p
.family
, &orfp
.p
.u
.prefix
, buf
, INET6_BUFSIZ
),
1890 orfp
.p
.prefixlen
, orfp
.ge
, orfp
.le
,
1891 ok
? "" : " MALFORMED");
1895 ret
= prefix_bgp_orf_set (name
, afi
, &orfp
,
1896 (common
& ORF_COMMON_PART_DENY
? 0 : 1 ),
1897 (common
& ORF_COMMON_PART_REMOVE
? 0 : 1));
1899 if (!ok
|| (ok
&& ret
!= CMD_SUCCESS
))
1901 zlog_info ("%s Received misformatted prefixlist ORF."
1902 " Remove All pfxlist", peer
->host
);
1903 prefix_bgp_orf_remove_all (afi
, name
);
1908 peer
->orf_plist
[afi
][safi
] = prefix_bgp_orf_lookup (afi
, name
);
1910 stream_forward_getp (s
, orf_len
);
1912 if (bgp_debug_neighbor_events(peer
))
1913 zlog_debug ("%s rcvd Refresh %s ORF request", peer
->host
,
1914 when_to_refresh
== REFRESH_DEFER
? "Defer" : "Immediate");
1915 if (when_to_refresh
== REFRESH_DEFER
)
1919 /* First update is deferred until ORF or ROUTE-REFRESH is received */
1920 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_WAIT_REFRESH
))
1921 UNSET_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_WAIT_REFRESH
);
1923 paf
= peer_af_find (peer
, afi
, safi
);
1924 if (paf
&& paf
->subgroup
)
1926 if (peer
->orf_plist
[afi
][safi
])
1928 updgrp
= PAF_UPDGRP(paf
);
1929 updgrp_peer
= UPDGRP_PEER(updgrp
);
1930 updgrp_peer
->orf_plist
[afi
][safi
] = peer
->orf_plist
[afi
][safi
];
1933 /* If the peer is configured for default-originate clear the
1934 * SUBGRP_STATUS_DEFAULT_ORIGINATE flag so that we will re-advertise the
1937 if (CHECK_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1938 UNSET_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
1941 /* Perform route refreshment to the peer */
1942 bgp_announce_route (peer
, afi
, safi
);
1946 bgp_capability_msg_parse (struct peer
*peer
, u_char
*pnt
, bgp_size_t length
)
1949 struct capability_mp_data mpc
;
1950 struct capability_header
*hdr
;
1954 safi_t pkt_safi
, safi
;
1960 /* We need at least action, capability code and capability length. */
1963 zlog_info ("%s Capability length error", peer
->host
);
1964 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
1968 hdr
= (struct capability_header
*)(pnt
+ 1);
1970 /* Action value check. */
1971 if (action
!= CAPABILITY_ACTION_SET
1972 && action
!= CAPABILITY_ACTION_UNSET
)
1974 zlog_info ("%s Capability Action Value error %d",
1975 peer
->host
, action
);
1976 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
1980 if (bgp_debug_neighbor_events(peer
))
1981 zlog_debug ("%s CAPABILITY has action: %d, code: %u, length %u",
1982 peer
->host
, action
, hdr
->code
, hdr
->length
);
1984 /* Capability length check. */
1985 if ((pnt
+ hdr
->length
+ 3) > end
)
1987 zlog_info ("%s Capability length error", peer
->host
);
1988 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, 0);
1992 /* Fetch structure to the byte stream. */
1993 memcpy (&mpc
, pnt
+ 3, sizeof (struct capability_mp_data
));
1995 /* We know MP Capability Code. */
1996 if (hdr
->code
== CAPABILITY_CODE_MP
)
1998 pkt_afi
= ntohs (mpc
.afi
);
1999 pkt_safi
= mpc
.safi
;
2001 /* Ignore capability when override-capability is set. */
2002 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
2005 /* Convert AFI, SAFI to internal values. */
2006 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
2008 if (bgp_debug_neighbor_events(peer
))
2009 zlog_debug ("%s Dynamic Capability MP_EXT afi/safi invalid "
2010 "(%u/%u)", peer
->host
, pkt_afi
, pkt_safi
);
2014 /* Address family check. */
2015 if (bgp_debug_neighbor_events(peer
))
2016 zlog_debug ("%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2018 action
== CAPABILITY_ACTION_SET
2019 ? "Advertising" : "Removing",
2022 if (action
== CAPABILITY_ACTION_SET
)
2024 peer
->afc_recv
[afi
][safi
] = 1;
2025 if (peer
->afc
[afi
][safi
])
2027 peer
->afc_nego
[afi
][safi
] = 1;
2028 bgp_announce_route (peer
, afi
, safi
);
2033 peer
->afc_recv
[afi
][safi
] = 0;
2034 peer
->afc_nego
[afi
][safi
] = 0;
2036 if (peer_active_nego (peer
))
2037 bgp_clear_route (peer
, afi
, safi
);
2039 BGP_EVENT_ADD (peer
, BGP_Stop
);
2044 zlog_warn ("%s unrecognized capability code: %d - ignored",
2045 peer
->host
, hdr
->code
);
2047 pnt
+= hdr
->length
+ 3;
2052 /* Dynamic Capability is received.
2054 * This is exported for unit-test purposes
2057 bgp_capability_receive (struct peer
*peer
, bgp_size_t size
)
2061 /* Fetch pointer. */
2062 pnt
= stream_pnt (peer
->ibuf
);
2064 if (bgp_debug_neighbor_events(peer
))
2065 zlog_debug ("%s rcv CAPABILITY", peer
->host
);
2067 /* If peer does not have the capability, send notification. */
2068 if (! CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_ADV
))
2070 zlog_err ("%s [Error] BGP dynamic capability is not enabled",
2072 bgp_notify_send (peer
,
2073 BGP_NOTIFY_HEADER_ERR
,
2074 BGP_NOTIFY_HEADER_BAD_MESTYPE
);
2078 /* Status must be Established. */
2079 if (peer
->status
!= Established
)
2081 zlog_err ("%s [Error] Dynamic capability packet received under status %s",
2082 peer
->host
, LOOKUP (bgp_status_msg
, peer
->status
));
2083 bgp_notify_send (peer
, BGP_NOTIFY_FSM_ERR
, 0);
2088 return bgp_capability_msg_parse (peer
, pnt
, size
);
2091 /* BGP read utility function. */
2093 bgp_read_packet (struct peer
*peer
)
2098 readsize
= peer
->packet_size
- stream_get_endp (peer
->ibuf
);
2100 /* If size is zero then return. */
2104 /* Read packet from fd. */
2105 nbytes
= stream_read_try (peer
->ibuf
, peer
->fd
, readsize
);
2107 /* If read byte is smaller than zero then error occured. */
2110 /* Transient error should retry */
2114 zlog_err ("%s [Error] bgp_read_packet error: %s",
2115 peer
->host
, safe_strerror (errno
));
2117 if (peer
->status
== Established
)
2119 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
))
2121 peer
->last_reset
= PEER_DOWN_NSF_CLOSE_SESSION
;
2122 SET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2125 peer
->last_reset
= PEER_DOWN_CLOSE_SESSION
;
2128 BGP_EVENT_ADD (peer
, TCP_fatal_error
);
2132 /* When read byte is zero : clear bgp peer and return */
2135 if (bgp_debug_neighbor_events(peer
))
2136 zlog_debug ("%s [Event] BGP connection closed fd %d",
2137 peer
->host
, peer
->fd
);
2139 if (peer
->status
== Established
)
2141 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
))
2143 peer
->last_reset
= PEER_DOWN_NSF_CLOSE_SESSION
;
2144 SET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2147 peer
->last_reset
= PEER_DOWN_CLOSE_SESSION
;
2150 BGP_EVENT_ADD (peer
, TCP_connection_closed
);
2154 /* We read partial packet. */
2155 if (stream_get_endp (peer
->ibuf
) != peer
->packet_size
)
2163 bgp_marker_all_one (struct stream
*s
, int length
)
2167 for (i
= 0; i
< length
; i
++)
2168 if (s
->data
[i
] != 0xff)
2174 /* Starting point of packet process function. */
2176 bgp_read (struct thread
*thread
)
2182 char notify_data_length
[2];
2183 u_int32_t notify_out
;
2185 /* Yes first of all get peer pointer. */
2186 peer
= THREAD_ARG (thread
);
2187 peer
->t_read
= NULL
;
2189 /* Note notify_out so we can check later to see if we sent another one */
2190 notify_out
= peer
->notify_out
;
2192 /* For non-blocking IO check. */
2193 if (peer
->status
== Connect
)
2195 bgp_connect_check (peer
, 1);
2202 zlog_err ("bgp_read peer's fd is negative value %d", peer
->fd
);
2205 BGP_READ_ON (peer
->t_read
, bgp_read
, peer
->fd
);
2208 /* Read packet header to determine type of the packet */
2209 if (peer
->packet_size
== 0)
2210 peer
->packet_size
= BGP_HEADER_SIZE
;
2212 if (stream_get_endp (peer
->ibuf
) < BGP_HEADER_SIZE
)
2214 ret
= bgp_read_packet (peer
);
2216 /* Header read error or partial read packet. */
2220 /* Get size and type. */
2221 stream_forward_getp (peer
->ibuf
, BGP_MARKER_SIZE
);
2222 memcpy (notify_data_length
, stream_pnt (peer
->ibuf
), 2);
2223 size
= stream_getw (peer
->ibuf
);
2224 type
= stream_getc (peer
->ibuf
);
2227 if (((type
== BGP_MSG_OPEN
) || (type
== BGP_MSG_KEEPALIVE
))
2228 && ! bgp_marker_all_one (peer
->ibuf
, BGP_MARKER_SIZE
))
2230 bgp_notify_send (peer
,
2231 BGP_NOTIFY_HEADER_ERR
,
2232 BGP_NOTIFY_HEADER_NOT_SYNC
);
2236 /* BGP type check. */
2237 if (type
!= BGP_MSG_OPEN
&& type
!= BGP_MSG_UPDATE
2238 && type
!= BGP_MSG_NOTIFY
&& type
!= BGP_MSG_KEEPALIVE
2239 && type
!= BGP_MSG_ROUTE_REFRESH_NEW
2240 && type
!= BGP_MSG_ROUTE_REFRESH_OLD
2241 && type
!= BGP_MSG_CAPABILITY
)
2243 if (bgp_debug_neighbor_events(peer
))
2244 zlog_debug ("%s unknown message type 0x%02x",
2246 bgp_notify_send_with_data (peer
,
2247 BGP_NOTIFY_HEADER_ERR
,
2248 BGP_NOTIFY_HEADER_BAD_MESTYPE
,
2252 /* Mimimum packet length check. */
2253 if ((size
< BGP_HEADER_SIZE
)
2254 || (size
> BGP_MAX_PACKET_SIZE
)
2255 || (type
== BGP_MSG_OPEN
&& size
< BGP_MSG_OPEN_MIN_SIZE
)
2256 || (type
== BGP_MSG_UPDATE
&& size
< BGP_MSG_UPDATE_MIN_SIZE
)
2257 || (type
== BGP_MSG_NOTIFY
&& size
< BGP_MSG_NOTIFY_MIN_SIZE
)
2258 || (type
== BGP_MSG_KEEPALIVE
&& size
!= BGP_MSG_KEEPALIVE_MIN_SIZE
)
2259 || (type
== BGP_MSG_ROUTE_REFRESH_NEW
&& size
< BGP_MSG_ROUTE_REFRESH_MIN_SIZE
)
2260 || (type
== BGP_MSG_ROUTE_REFRESH_OLD
&& size
< BGP_MSG_ROUTE_REFRESH_MIN_SIZE
)
2261 || (type
== BGP_MSG_CAPABILITY
&& size
< BGP_MSG_CAPABILITY_MIN_SIZE
))
2263 if (bgp_debug_neighbor_events(peer
))
2264 zlog_debug ("%s bad message length - %d for %s",
2266 type
== 128 ? "ROUTE-REFRESH" :
2267 bgp_type_str
[(int) type
]);
2268 bgp_notify_send_with_data (peer
,
2269 BGP_NOTIFY_HEADER_ERR
,
2270 BGP_NOTIFY_HEADER_BAD_MESLEN
,
2271 (u_char
*) notify_data_length
, 2);
2275 /* Adjust size to message length. */
2276 peer
->packet_size
= size
;
2279 ret
= bgp_read_packet (peer
);
2283 /* Get size and type again. */
2284 (void)stream_getw_from (peer
->ibuf
, BGP_MARKER_SIZE
);
2285 type
= stream_getc_from (peer
->ibuf
, BGP_MARKER_SIZE
+ 2);
2287 /* BGP packet dump function. */
2288 bgp_dump_packet (peer
, type
, peer
->ibuf
);
2290 size
= (peer
->packet_size
- BGP_HEADER_SIZE
);
2292 /* Read rest of the packet and call each sort of packet routine */
2297 bgp_open_receive (peer
, size
); /* XXX return value ignored! */
2299 case BGP_MSG_UPDATE
:
2300 peer
->readtime
= monotime (NULL
);
2301 bgp_update_receive (peer
, size
);
2303 case BGP_MSG_NOTIFY
:
2304 bgp_notify_receive (peer
, size
);
2306 case BGP_MSG_KEEPALIVE
:
2307 peer
->readtime
= monotime (NULL
);
2308 bgp_keepalive_receive (peer
, size
);
2310 case BGP_MSG_ROUTE_REFRESH_NEW
:
2311 case BGP_MSG_ROUTE_REFRESH_OLD
:
2313 bgp_route_refresh_receive (peer
, size
);
2315 case BGP_MSG_CAPABILITY
:
2316 peer
->dynamic_cap_in
++;
2317 bgp_capability_receive (peer
, size
);
2321 /* If reading this packet caused us to send a NOTIFICATION then store a copy
2322 * of the packet for troubleshooting purposes
2324 if (notify_out
< peer
->notify_out
)
2326 memcpy(peer
->last_reset_cause
, peer
->ibuf
->data
, peer
->packet_size
);
2327 peer
->last_reset_cause_size
= peer
->packet_size
;
2328 notify_out
= peer
->notify_out
;
2331 /* Clear input buffer. */
2332 peer
->packet_size
= 0;
2334 stream_reset (peer
->ibuf
);
2337 /* If reading this packet caused us to send a NOTIFICATION then store a copy
2338 * of the packet for troubleshooting purposes
2340 if (notify_out
< peer
->notify_out
)
2342 memcpy(peer
->last_reset_cause
, peer
->ibuf
->data
, peer
->packet_size
);
2343 peer
->last_reset_cause_size
= peer
->packet_size
;