3 * Used to advertise routes for upstream (l2tp port, rather than gratiutious
4 * arp) and downstream--allowing routers to load-balance both.
6 * Implementation limitations:
7 * - We never listen for incoming connections (session always initiated by us).
8 * - Any routes advertised by the peer are accepted, but ignored.
9 * - No password support; neither RFC1771 (which no-one seems to do anyway)
10 * nor RFC2385 (which requires a kernel patch on 2.4 kernels).
13 char const *cvs_id_bgp
= "$Id: bgp.c,v 1.12 2005/09/02 23:39:36 bodea Exp $";
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
30 static void bgp_clear(struct bgp_peer
*peer
);
31 static void bgp_set_retry(struct bgp_peer
*peer
);
32 static void bgp_cidr(in_addr_t ip
, in_addr_t mask
, struct bgp_ip_prefix
*pfx
);
33 static struct bgp_route_list
*bgp_insert_route(struct bgp_route_list
*head
,
34 struct bgp_route_list
*new);
35 static struct bgp_route6_list
*bgp_insert_route6(struct bgp_route6_list
*head
,
36 struct bgp_route6_list
*new);
38 static void bgp_free_routes(struct bgp_route_list
*routes
);
39 static void bgp_free_routes6(struct bgp_route6_list
*routes
);
40 static char const *bgp_msg_type_str(uint8_t type
);
41 static int bgp_connect(struct bgp_peer
*peer
);
42 static int bgp_handle_connect(struct bgp_peer
*peer
);
43 static int bgp_write(struct bgp_peer
*peer
);
44 static int bgp_read(struct bgp_peer
*peer
);
45 static int bgp_handle_input(struct bgp_peer
*peer
);
46 static int bgp_send_open(struct bgp_peer
*peer
);
47 static int bgp_send_keepalive(struct bgp_peer
*peer
);
48 static int bgp_send_update(struct bgp_peer
*peer
);
49 static int bgp_send_update6(struct bgp_peer
*peer
);
50 static int bgp_send_notification(struct bgp_peer
*peer
, uint8_t code
,
52 static int bgp_send_notification_full(struct bgp_peer
*peer
, uint8_t code
,
53 uint8_t subcode
, char *notification_data
, uint16_t data_len
);
55 static uint16_t our_as
;
56 static struct bgp_route_list
*bgp_routes
= 0;
57 static struct bgp_route6_list
*bgp_routes6
= 0;
59 int bgp_configured
= 0;
60 struct bgp_peer
*bgp_peers
= 0;
62 /* prepare peer structure, globals */
66 struct bgp_peer
*peer
;
68 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
71 memset(peer
, 0, sizeof(*peer
));
73 peer
->addr
= INADDR_NONE
;
75 peer
->state
= peer
->next_state
= Disabled
;
77 if (!((peer
->outbuf
= malloc(sizeof(*peer
->outbuf
)))
78 && (peer
->inbuf
= malloc(sizeof(*peer
->inbuf
)))))
80 LOG(0, 0, 0, "Can't allocate buffers for bgp peer (%s)\n",
86 peer
->edata
.type
= FD_TYPE_BGP
;
87 peer
->edata
.index
= i
;
99 bgp_configured
= 0; /* set by bgp_start */
104 /* start connection with a peer */
105 int bgp_start(struct bgp_peer
*peer
, char *name
, int as
, int keepalive
,
106 int hold
, int enable
)
111 struct bgp_path_attr a
;
113 char *p
= path_attrs
;
115 uint32_t metric
= htonl(BGP_METRIC
);
116 uint32_t no_export
= htonl(BGP_COMMUNITY_NO_EXPORT
);
121 if (peer
->state
!= Disabled
)
124 snprintf(peer
->name
, sizeof(peer
->name
), "%s", name
);
126 if (!(h
= gethostbyname(name
)) || h
->h_addrtype
!= AF_INET
)
128 LOG(0, 0, 0, "Can't get address for BGP peer %s (%s)\n",
129 name
, h
? "no address" : hstrerror(h_errno
));
134 memcpy(&peer
->addr
, h
->h_addr
, sizeof(peer
->addr
));
135 peer
->as
= as
> 0 ? as
: our_as
;
136 ibgp
= peer
->as
== our_as
;
138 /* set initial timer values */
139 peer
->init_keepalive
= keepalive
== -1 ? BGP_KEEPALIVE_TIME
: keepalive
;
140 peer
->init_hold
= hold
== -1 ? BGP_HOLD_TIME
: hold
;
142 if (peer
->init_hold
< 3)
145 if (peer
->init_keepalive
* 3 > peer
->init_hold
)
146 peer
->init_keepalive
= peer
->init_hold
/ 3;
148 /* clear buffers, go to Idle state */
149 peer
->next_state
= Idle
;
152 /* set initial routing state */
153 peer
->routing
= enable
;
155 /* all our routes use the same attributes, so prepare it in advance */
156 if (peer
->path_attrs
)
157 free(peer
->path_attrs
);
159 peer
->path_attr_len
= 0;
162 a
.flags
= BGP_PATH_ATTR_FLAG_TRANS
;
163 a
.code
= BGP_PATH_ATTR_CODE_ORIGIN
;
165 a
.data
.s
.value
[0] = BGP_PATH_ATTR_CODE_ORIGIN_IGP
;
167 #define ADD_ATTRIBUTE() do { \
168 i = BGP_PATH_ATTR_SIZE(a); \
171 peer->path_attr_len += i; } while (0)
176 a
.flags
= BGP_PATH_ATTR_FLAG_TRANS
;
177 a
.code
= BGP_PATH_ATTR_CODE_AS_PATH
;
191 BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE
,
196 a
.data
.s
.len
= sizeof(as_path
);
197 memcpy(&a
.data
.s
.value
, &as_path
, sizeof(as_path
));
202 /* MULTI_EXIT_DISC */
203 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
;
204 a
.code
= BGP_PATH_ATTR_CODE_MULTI_EXIT_DISC
;
205 a
.data
.s
.len
= sizeof(metric
);
206 memcpy(a
.data
.s
.value
, &metric
, sizeof(metric
));
212 uint32_t local_pref
= htonl(BGP_LOCAL_PREF
);
215 a
.flags
= BGP_PATH_ATTR_FLAG_TRANS
;
216 a
.code
= BGP_PATH_ATTR_CODE_LOCAL_PREF
;
217 a
.data
.s
.len
= sizeof(local_pref
);
218 memcpy(a
.data
.s
.value
, &local_pref
, sizeof(local_pref
));
224 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
| BGP_PATH_ATTR_FLAG_TRANS
;
225 a
.code
= BGP_PATH_ATTR_CODE_COMMUNITIES
;
226 a
.data
.s
.len
= sizeof(no_export
);
227 memcpy(a
.data
.s
.value
, &no_export
, sizeof(no_export
));
231 /* remember the len before adding NEXT_HOP */
232 peer
->path_attr_len_without_nexthop
= peer
->path_attr_len
;
235 a
.flags
= BGP_PATH_ATTR_FLAG_TRANS
;
236 a
.code
= BGP_PATH_ATTR_CODE_NEXT_HOP
;
237 ip
= my_address
; /* we're it */
238 a
.data
.s
.len
= sizeof(ip
);
239 memcpy(a
.data
.s
.value
, &ip
, sizeof(ip
));
243 if (!(peer
->path_attrs
= malloc(peer
->path_attr_len
)))
245 LOG(0, 0, 0, "Can't allocate path_attrs for %s (%s)\n",
246 name
, strerror(errno
));
251 memcpy(peer
->path_attrs
, path_attrs
, peer
->path_attr_len
);
253 /* multiprotocol attributes initialization */
254 if (config
->ipv6_prefix
.s6_addr
[0])
256 struct bgp_attr_mp_reach_nlri_partial mp_reach_nlri_partial
;
257 struct bgp_attr_mp_unreach_nlri_partial mp_unreach_nlri_partial
;
259 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
;
260 a
.code
= BGP_PATH_ATTR_CODE_MP_REACH_NLRI
;
261 a
.data
.s
.len
= 0; /* will be set on UPDATE */
263 mp_reach_nlri_partial
.afi
= htons(BGP_MP_AFI_IPv6
);
264 mp_reach_nlri_partial
.safi
= BGP_MP_SAFI_UNICAST
;
265 mp_reach_nlri_partial
.reserved
= 0;
266 mp_reach_nlri_partial
.next_hop_len
= 16;
268 /* use the defined nexthop6, or our address in ipv6_prefix */
269 if (config
->nexthop6_address
.s6_addr
[0])
270 memcpy(&mp_reach_nlri_partial
.next_hop
,
271 &config
->nexthop6_address
.s6_addr
, 16);
274 /* our address is ipv6prefix::1 */
275 memcpy(&mp_reach_nlri_partial
.next_hop
,
276 &config
->ipv6_prefix
.s6_addr
, 16);
277 mp_reach_nlri_partial
.next_hop
[15] = 1;
280 memcpy(&a
.data
.s
.value
, &mp_reach_nlri_partial
,
281 sizeof(struct bgp_attr_mp_reach_nlri_partial
));
282 memcpy(&peer
->mp_reach_nlri_partial
, &a
,
283 BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
);
285 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
| BGP_PATH_ATTR_FLAG_EXTLEN
;
286 a
.code
= BGP_PATH_ATTR_CODE_MP_UNREACH_NLRI
;
287 a
.data
.e
.len
= 0; /* will be set on UPDATE */
289 mp_unreach_nlri_partial
.afi
= htons(BGP_MP_AFI_IPv6
);
290 mp_unreach_nlri_partial
.safi
= BGP_MP_SAFI_UNICAST
;
292 memcpy(&a
.data
.e
.value
, &mp_unreach_nlri_partial
,
293 sizeof(struct bgp_attr_mp_unreach_nlri_partial
));
294 memcpy(&peer
->mp_unreach_nlri_partial
, &a
,
295 BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
);
298 peer
->mp_handling
= HandlingUnknown
;
300 LOG(4, 0, 0, "Initiating BGP connection to %s (routing %s)\n",
301 name
, enable
? "enabled" : "suspended");
303 /* we have at least one peer configured */
307 return bgp_connect(peer
);
310 /* clear counters, timers, routes and buffers; close socket; move to
311 next_state, which may be Disabled or Idle */
312 static void bgp_clear(struct bgp_peer
*peer
)
314 if (peer
->sock
!= -1)
320 peer
->keepalive_time
= 0;
321 peer
->expire_time
= 0;
323 peer
->keepalive
= peer
->init_keepalive
;
324 peer
->hold
= peer
->init_hold
;
326 bgp_free_routes(peer
->routes
);
328 bgp_free_routes6(peer
->routes6
);
331 peer
->outbuf
->packet
.header
.len
= 0;
332 peer
->outbuf
->done
= 0;
333 peer
->inbuf
->packet
.header
.len
= 0;
334 peer
->inbuf
->done
= 0;
339 if (peer
->state
!= peer
->next_state
)
341 peer
->state
= peer
->next_state
;
342 peer
->state_time
= time_now
;
344 LOG(4, 0, 0, "BGP peer %s: state %s\n", peer
->name
,
345 bgp_state_str(peer
->next_state
));
349 /* initiate a clean shutdown */
350 void bgp_stop(struct bgp_peer
*peer
)
352 LOG(4, 0, 0, "Terminating BGP connection to %s\n", peer
->name
);
353 bgp_send_notification(peer
, BGP_ERR_CEASE
, 0);
356 /* drop connection (if any) and set state to Disabled */
357 void bgp_halt(struct bgp_peer
*peer
)
359 LOG(4, 0, 0, "Aborting BGP connection to %s\n", peer
->name
);
360 peer
->next_state
= Disabled
;
364 /* drop connection (if any) and set to Idle for connection retry */
365 int bgp_restart(struct bgp_peer
*peer
)
367 peer
->next_state
= Idle
;
371 peer
->retry_time
= time_now
;
372 peer
->retry_count
= 0;
375 return bgp_connect(peer
);
378 static void bgp_set_retry(struct bgp_peer
*peer
)
380 if (peer
->retry_count
++ < BGP_MAX_RETRY
)
382 peer
->retry_time
= time_now
+ (BGP_RETRY_BACKOFF
* peer
->retry_count
);
383 peer
->next_state
= Idle
;
387 bgp_halt(peer
); /* give up */
390 /* convert ip/mask to CIDR notation */
391 static void bgp_cidr(in_addr_t ip
, in_addr_t mask
, struct bgp_ip_prefix
*pfx
)
396 /* convert to prefix notation */
400 if (!mask
) /* bogus */
403 for (i
= 0; i
< 32 && ((b
= ntohl(1 << i
)), !(mask
& b
)); i
++)
410 /* insert route into list; sorted */
411 static struct bgp_route_list
*bgp_insert_route(struct bgp_route_list
*head
,
412 struct bgp_route_list
*new)
414 struct bgp_route_list
*p
= head
;
415 struct bgp_route_list
*e
= 0;
417 while (p
&& memcmp(&p
->dest
, &new->dest
, sizeof(p
->dest
)) < 0)
437 /* insert route6 into list; sorted */
438 static struct bgp_route6_list
*bgp_insert_route6(struct bgp_route6_list
*head
,
439 struct bgp_route6_list
*new)
441 struct bgp_route6_list
*p
= head
;
442 struct bgp_route6_list
*e
= 0;
444 while (p
&& memcmp(&p
->dest
, &new->dest
, sizeof(p
->dest
)) < 0)
464 /* add route to list for peers */
466 * Note: this doesn't do route aggregation, nor drop routes if a less
467 * specific match already exists (partly because I'm lazy, but also so
468 * that if that route is later deleted we don't have to be concerned
469 * about adding back the more specific one).
471 int bgp_add_route(in_addr_t ip
, in_addr_t mask
)
473 struct bgp_route_list
*r
= bgp_routes
;
474 struct bgp_route_list add
;
477 bgp_cidr(ip
, mask
, &add
.dest
);
480 /* check for duplicate */
483 i
= memcmp(&r
->dest
, &add
.dest
, sizeof(r
->dest
));
485 return 1; /* already covered */
493 /* insert into route list; sorted */
494 if (!(r
= malloc(sizeof(*r
))))
496 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
497 fmtaddr(add
.dest
.prefix
, 0), add
.dest
.len
, strerror(errno
));
502 memcpy(r
, &add
, sizeof(*r
));
503 bgp_routes
= bgp_insert_route(bgp_routes
, r
);
505 /* flag established peers for update */
506 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
507 if (bgp_peers
[i
].state
== Established
)
508 bgp_peers
[i
].update_routes
= 1;
510 LOG(4, 0, 0, "Registered BGP route %s/%d\n",
511 fmtaddr(add
.dest
.prefix
, 0), add
.dest
.len
);
516 /* add route to list for peers */
518 * Note: same provisions as above
520 int bgp_add_route6(struct in6_addr ip
, int prefixlen
)
522 struct bgp_route6_list
*r
= bgp_routes6
;
523 struct bgp_route6_list add
;
525 char ipv6addr
[INET6_ADDRSTRLEN
];
527 memcpy(&add
.dest
.prefix
, &ip
.s6_addr
, 16);
528 add
.dest
.len
= prefixlen
;
531 /* check for duplicate */
534 i
= memcmp(&r
->dest
, &add
.dest
, sizeof(r
->dest
));
536 return 1; /* already covered */
544 /* insert into route list; sorted */
545 if (!(r
= malloc(sizeof(*r
))))
547 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
548 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), add
.dest
.len
,
554 memcpy(r
, &add
, sizeof(*r
));
555 bgp_routes6
= bgp_insert_route6(bgp_routes6
, r
);
557 /* flag established peers for update */
558 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
559 if (bgp_peers
[i
].state
== Established
)
560 bgp_peers
[i
].update_routes6
= 1;
562 LOG(4, 0, 0, "Registered BGP route %s/%d\n",
563 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), add
.dest
.len
);
568 /* remove route from list for peers */
569 int bgp_del_route(in_addr_t ip
, in_addr_t mask
)
571 struct bgp_route_list
*r
= bgp_routes
;
572 struct bgp_route_list
*e
= 0;
573 struct bgp_route_list del
;
576 bgp_cidr(ip
, mask
, &del
.dest
);
579 /* find entry in routes list and remove */
582 i
= memcmp(&r
->dest
, &del
.dest
, sizeof(r
->dest
));
588 bgp_routes
= r
->next
;
606 /* flag established peers for update */
607 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
608 if (bgp_peers
[i
].state
== Established
)
609 bgp_peers
[i
].update_routes
= 1;
611 LOG(4, 0, 0, "Removed BGP route %s/%d\n",
612 fmtaddr(del
.dest
.prefix
, 0), del
.dest
.len
);
617 /* remove route from list for peers */
618 int bgp_del_route6(struct in6_addr ip
, int prefixlen
)
620 struct bgp_route6_list
*r
= bgp_routes6
;
621 struct bgp_route6_list
*e
= 0;
622 struct bgp_route6_list del
;
624 char ipv6addr
[INET6_ADDRSTRLEN
];
626 memcpy(&del
.dest
.prefix
, &ip
.s6_addr
, 16);
627 del
.dest
.len
= prefixlen
;
630 /* find entry in routes list and remove */
633 i
= memcmp(&r
->dest
, &del
.dest
, sizeof(r
->dest
));
639 bgp_routes6
= r
->next
;
657 /* flag established peers for update */
658 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
659 if (bgp_peers
[i
].state
== Established
)
660 bgp_peers
[i
].update_routes6
= 1;
662 LOG(4, 0, 0, "Removed BGP route %s/%d\n",
663 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), del
.dest
.len
);
668 /* enable or disable routing */
669 void bgp_enable_routing(int enable
)
673 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
675 bgp_peers
[i
].routing
= enable
;
677 /* flag established peers for update */
678 if (bgp_peers
[i
].state
== Established
)
679 bgp_peers
[i
].update_routes
= 1;
682 LOG(4, 0, 0, "%s BGP routing\n", enable
? "Enabled" : "Suspended");
686 # include <sys/epoll.h>
688 # include "fake_epoll.h"
691 /* return a bitmask of the events required to poll this peer's fd */
699 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
701 struct bgp_peer
*peer
= &bgp_peers
[i
];
704 if (peer
->state
== Disabled
|| peer
->state
== Idle
)
707 if (peer
->inbuf
->done
< BGP_MAX_PACKET_SIZE
)
710 if (peer
->state
== Connect
|| /* connection in progress */
711 peer
->update_routes
|| /* routing updates */
712 peer
->outbuf
->packet
.header
.len
) /* pending output */
715 if (peer
->events
!= events
)
717 struct epoll_event ev
;
719 ev
.events
= peer
->events
= events
;
720 ev
.data
.ptr
= &peer
->edata
;
721 epoll_ctl(epollfd
, EPOLL_CTL_MOD
, peer
->sock
, &ev
);
728 /* process bgp events/timers */
729 int bgp_process(uint32_t events
[])
736 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
738 struct bgp_peer
*peer
= &bgp_peers
[i
];
740 if (*peer
->name
&& peer
->cli_flag
== BGP_CLI_RESTART
)
746 if (peer
->state
== Disabled
)
751 switch (peer
->cli_flag
)
753 case BGP_CLI_SUSPEND
:
757 if (peer
->state
== Established
)
758 peer
->update_routes
= 1;
767 if (peer
->state
== Established
)
768 peer
->update_routes
= 1;
777 /* handle empty/fill of buffers */
778 if (events
[i
] & EPOLLOUT
)
781 if (peer
->state
== Connect
)
782 r
= bgp_handle_connect(peer
);
783 else if (peer
->outbuf
->packet
.header
.len
)
790 if (events
[i
] & (EPOLLIN
|EPOLLHUP
))
796 /* process input buffer contents */
797 while (peer
->inbuf
->done
>= sizeof(peer
->inbuf
->packet
.header
)
798 && !peer
->outbuf
->packet
.header
.len
) /* may need to queue a response */
800 if (bgp_handle_input(peer
) < 0)
804 /* process pending updates */
805 if (peer
->update_routes
806 && !peer
->outbuf
->packet
.header
.len
) /* ditto */
808 if (!bgp_send_update(peer
))
812 /* process pending IPv6 updates */
813 if (peer
->update_routes6
814 && !peer
->outbuf
->packet
.header
.len
) /* ditto */
816 if (!bgp_send_update6(peer
))
821 if (peer
->state
== Established
)
823 if (time_now
> peer
->expire_time
)
825 LOG(1, 0, 0, "No message from BGP peer %s in %ds\n",
826 peer
->name
, peer
->hold
);
828 bgp_send_notification(peer
, BGP_ERR_HOLD_TIMER_EXP
, 0);
832 if (time_now
> peer
->keepalive_time
&& !peer
->outbuf
->packet
.header
.len
)
833 bgp_send_keepalive(peer
);
835 else if (peer
->state
== Idle
)
837 if (time_now
> peer
->retry_time
)
840 else if (time_now
> peer
->state_time
+ BGP_STATE_TIME
)
842 LOG(1, 0, 0, "%s timer expired for BGP peer %s\n",
843 bgp_state_str(peer
->state
), peer
->name
);
852 static void bgp_free_routes(struct bgp_route_list
*routes
)
854 struct bgp_route_list
*tmp
;
856 while ((tmp
= routes
))
863 static void bgp_free_routes6(struct bgp_route6_list
*routes
)
865 struct bgp_route6_list
*tmp
;
867 while ((tmp
= routes
))
874 char const *bgp_state_str(enum bgp_state state
)
878 case Disabled
: return "Disabled";
879 case Idle
: return "Idle";
880 case Connect
: return "Connect";
881 case Active
: return "Active";
882 case OpenSent
: return "OpenSent";
883 case OpenConfirm
: return "OpenConfirm";
884 case Established
: return "Established";
890 static char const *bgp_msg_type_str(uint8_t type
)
894 case BGP_MSG_OPEN
: return "OPEN";
895 case BGP_MSG_UPDATE
: return "UPDATE";
896 case BGP_MSG_NOTIFICATION
: return "NOTIFICATION";
897 case BGP_MSG_KEEPALIVE
: return "KEEPALIVE";
903 /* attempt to connect to peer */
904 static int bgp_connect(struct bgp_peer
*peer
)
906 static int bgp_port
= 0;
907 struct sockaddr_in addr
;
908 struct epoll_event ev
;
912 struct servent
*serv
;
913 if (!(serv
= getservbyname("bgp", "tcp")))
915 LOG(0, 0, 0, "Can't get bgp service (%s)\n", strerror(errno
));
919 bgp_port
= serv
->s_port
;
922 if ((peer
->sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
)) < 0)
924 LOG(0, 0, 0, "Can't create a socket for BGP peer %s (%s)\n",
925 peer
->name
, strerror(errno
));
927 peer
->state
= peer
->next_state
= Disabled
;
931 /* add to poll set */
932 ev
.events
= peer
->events
= EPOLLOUT
;
933 ev
.data
.ptr
= &peer
->edata
;
934 epoll_ctl(epollfd
, EPOLL_CTL_ADD
, peer
->sock
, &ev
);
936 /* set to non-blocking */
937 fcntl(peer
->sock
, F_SETFL
, fcntl(peer
->sock
, F_GETFL
, 0) | O_NONBLOCK
);
940 memset(&addr
, 0, sizeof(addr
));
941 addr
.sin_family
= AF_INET
;
942 addr
.sin_port
= bgp_port
;
943 addr
.sin_addr
.s_addr
= peer
->addr
;
945 while (connect(peer
->sock
, (struct sockaddr
*) &addr
, sizeof(addr
)) == -1)
947 if (errno
== EINTR
) /* SIGALARM handler */
950 if (errno
!= EINPROGRESS
)
952 LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n",
953 inet_ntoa(addr
.sin_addr
), strerror(errno
));
959 peer
->state
= Connect
;
960 peer
->state_time
= time_now
;
962 LOG(4, 0, 0, "BGP peer %s: state Connect\n", peer
->name
);
966 peer
->state
= Active
;
967 peer
->state_time
= time_now
;
968 peer
->retry_time
= peer
->retry_count
= 0;
970 LOG(4, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr
.sin_addr
));
972 return bgp_send_open(peer
);
975 /* complete partial connection (state = Connect) */
976 static int bgp_handle_connect(struct bgp_peer
*peer
)
979 socklen_t len
= sizeof(int);
980 getsockopt(peer
->sock
, SOL_SOCKET
, SO_ERROR
, &err
, &len
);
983 LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n", peer
->name
,
990 peer
->state
= Active
;
991 peer
->state_time
= time_now
;
993 LOG(4, 0, 0, "BGP peer %s: state Active\n", peer
->name
);
995 return bgp_send_open(peer
);
998 /* initiate a write */
999 static int bgp_write(struct bgp_peer
*peer
)
1001 int len
= htons(peer
->outbuf
->packet
.header
.len
);
1004 while ((r
= write(peer
->sock
, &peer
->outbuf
->packet
+ peer
->outbuf
->done
,
1005 len
- peer
->outbuf
->done
)) == -1)
1010 if (errno
== EAGAIN
)
1014 LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer
->name
);
1016 LOG(1, 0, 0, "Can't write to BGP peer %s (%s)\n", peer
->name
,
1019 bgp_set_retry(peer
);
1025 peer
->outbuf
->done
+= r
;
1029 LOG(4, 0, 0, "Sent %s to BGP peer %s\n",
1030 bgp_msg_type_str(peer
->outbuf
->packet
.header
.type
), peer
->name
);
1032 peer
->outbuf
->packet
.header
.len
= 0;
1033 peer
->outbuf
->done
= 0;
1035 if (peer
->state
== Established
)
1036 peer
->keepalive_time
= time_now
+ peer
->keepalive
;
1038 if (peer
->state
!= peer
->next_state
)
1040 if (peer
->next_state
== Disabled
|| peer
->next_state
== Idle
)
1046 peer
->state
= peer
->next_state
;
1047 peer
->state_time
= time_now
;
1049 LOG(4, 0, 0, "BGP peer %s: state %s\n", peer
->name
,
1050 bgp_state_str(peer
->state
));
1056 /* initiate a read */
1057 static int bgp_read(struct bgp_peer
*peer
)
1061 while ((r
= read(peer
->sock
, &peer
->inbuf
->packet
+ peer
->inbuf
->done
,
1062 BGP_MAX_PACKET_SIZE
- peer
->inbuf
->done
)) < 1)
1066 LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer
->name
);
1073 if (errno
== EAGAIN
)
1076 LOG(1, 0, 0, "Can't read from BGP peer %s (%s)\n", peer
->name
,
1080 bgp_set_retry(peer
);
1084 peer
->inbuf
->done
+= r
;
1088 /* process buffered packets */
1089 static int bgp_handle_input(struct bgp_peer
*peer
)
1091 struct bgp_packet
*p
= &peer
->inbuf
->packet
;
1092 int len
= ntohs(p
->header
.len
);
1094 if (len
> BGP_MAX_PACKET_SIZE
)
1096 LOG(1, 0, 0, "Bad header length from BGP %s\n", peer
->name
);
1097 bgp_send_notification(peer
, BGP_ERR_HEADER
, BGP_ERR_HDR_BAD_LEN
);
1101 if (peer
->inbuf
->done
< len
)
1104 LOG(4, 0, 0, "Received %s from BGP peer %s\n",
1105 bgp_msg_type_str(p
->header
.type
), peer
->name
);
1107 switch (p
->header
.type
)
1111 struct bgp_data_open data
;
1114 off_t param_offset
, capability_offset
;
1115 struct bgp_opt_param
*param
;
1116 uint8_t capabilities_len
;
1117 char *capabilities
= NULL
;
1118 struct bgp_capability
*capability
;
1119 struct bgp_mp_cap_param
*mp_cap
;
1121 for (i
= 0; i
< sizeof(p
->header
.marker
); i
++)
1123 if ((unsigned char) p
->header
.marker
[i
] != 0xff)
1125 LOG(1, 0, 0, "Invalid marker from BGP peer %s\n",
1128 bgp_send_notification(peer
, BGP_ERR_HEADER
,
1129 BGP_ERR_HDR_NOT_SYNC
);
1135 if (peer
->state
!= OpenSent
)
1137 LOG(1, 0, 0, "OPEN from BGP peer %s in %s state\n",
1138 peer
->name
, bgp_state_str(peer
->state
));
1140 bgp_send_notification(peer
, BGP_ERR_FSM
, 0);
1144 memcpy(&data
, p
->data
, len
- sizeof(p
->header
));
1146 if (data
.version
!= BGP_VERSION
)
1148 LOG(1, 0, 0, "Bad version (%d) sent by BGP peer %s\n",
1149 (int) data
.version
, peer
->name
);
1151 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_VERSION
);
1155 if (ntohs(data
.as
) != peer
->as
)
1157 LOG(1, 0, 0, "Bad AS sent by BGP peer %s (got %d, "
1158 "expected %d)\n", peer
->name
, (int) htons(data
.as
),
1161 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_BAD_AS
);
1165 if ((hold
= ntohs(data
.hold_time
)) < 3)
1167 LOG(1, 0, 0, "Bad hold time (%d) from BGP peer %s\n",
1170 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_HOLD_TIME
);
1174 /* pick lowest hold time */
1175 if (hold
< peer
->hold
)
1178 /* adjust our keepalive based on negotiated hold value */
1179 if (peer
->keepalive
* 3 > peer
->hold
)
1180 peer
->keepalive
= peer
->hold
/ 3;
1182 /* check for optional parameters */
1183 /* 2 is for the size of type + len (both uint8_t) */
1184 for (param_offset
= 0;
1185 param_offset
< data
.opt_len
;
1186 param_offset
+= 2 + param
->len
)
1188 param
= (struct bgp_opt_param
*)(&data
.opt_params
+ param_offset
);
1190 /* sensible check */
1191 if (data
.opt_len
- param_offset
< 2
1192 || param
->len
> data
.opt_len
- param_offset
- 2)
1194 LOG(1, 0, 0, "Malformed Optional Parameter list from BGP peer %s\n",
1197 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_UNSPEC
);
1201 /* we know only one parameter type */
1202 if (param
->type
!= BGP_PARAM_TYPE_CAPABILITY
)
1204 LOG(1, 0, 0, "Unsupported Optional Parameter type %d from BGP peer %s\n",
1205 param
->type
, peer
->name
);
1207 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_UNSUP_PARAM
);
1211 capabilities_len
= param
->len
;
1212 capabilities
= (char *)¶m
->value
;
1215 /* look for BGP multiprotocol capability */
1218 for (capability_offset
= 0;
1219 capability_offset
< capabilities_len
;
1220 capability_offset
+= 2 + capability
->len
)
1222 capability
= (struct bgp_capability
*)(capabilities
+ capability_offset
);
1224 /* sensible check */
1225 if (capabilities_len
- capability_offset
< 2
1226 || capability
->len
> capabilities_len
- capability_offset
- 2)
1228 LOG(1, 0, 0, "Malformed Capabilities list from BGP peer %s\n",
1231 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_UNSPEC
);
1235 /* we only know one capability code */
1236 if (capability
->code
!= BGP_CAP_CODE_MP
1237 && capability
->len
!= sizeof(struct bgp_mp_cap_param
))
1239 LOG(4, 0, 0, "Unsupported Capability code %d from BGP peer %s\n",
1240 capability
->code
, peer
->name
);
1242 bgp_send_notification_full(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_UNSUP_CAP
,
1243 (char *)capability
, 2 + capability
->len
);
1244 /* we don't terminate, still; we just jump to the next one */
1248 mp_cap
= (struct bgp_mp_cap_param
*)&capability
->value
;
1249 /* the only <AFI, SAFI> tuple we support */
1250 if (ntohs(mp_cap
->afi
) != BGP_MP_AFI_IPv6
&& mp_cap
->safi
!= BGP_MP_SAFI_UNICAST
)
1252 LOG(4, 0, 0, "Unsupported multiprotocol AFI %d and SAFI %d from BGP peer %s\n",
1253 mp_cap
->afi
, mp_cap
->safi
, peer
->name
);
1255 bgp_send_notification_full(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_UNSUP_CAP
,
1256 (char *)capability
, 2 + capability
->len
);
1257 /* we don't terminate, still; we just jump to the next one */
1261 peer
->mp_handling
= HandleIPv6Routes
;
1265 /* next transition requires an exchange of keepalives */
1266 bgp_send_keepalive(peer
);
1271 case BGP_MSG_KEEPALIVE
:
1272 if (peer
->state
== OpenConfirm
)
1274 peer
->state
= peer
->next_state
= Established
;
1275 peer
->state_time
= time_now
;
1276 peer
->keepalive_time
= time_now
+ peer
->keepalive
;
1277 peer
->update_routes
= 1;
1278 peer
->retry_count
= 0;
1279 peer
->retry_time
= 0;
1281 LOG(4, 0, 0, "BGP peer %s: state Established\n", peer
->name
);
1286 case BGP_MSG_NOTIFICATION
:
1287 if (len
> sizeof(p
->header
))
1289 struct bgp_data_notification
*notification
=
1290 (struct bgp_data_notification
*) p
->data
;
1292 if (notification
->error_code
== BGP_ERR_CEASE
)
1294 LOG(4, 0, 0, "BGP peer %s sent CEASE\n", peer
->name
);
1299 if (notification
->error_code
== BGP_ERR_OPEN
1300 && notification
->error_subcode
== BGP_ERR_OPN_UNSUP_PARAM
)
1302 LOG(4, 0, 0, "BGP peer %s doesn't support BGP Capabilities\n", peer
->name
);
1303 peer
->mp_handling
= DoesntHandleIPv6Routes
;
1308 if (notification
->error_code
== BGP_ERR_OPEN
1309 && notification
->error_subcode
== BGP_ERR_OPN_UNSUP_CAP
)
1311 /* the only capability we advertise is this one, so upon receiving
1312 an "unsupported capability" message, we disable IPv6 routes for
1314 LOG(4, 0, 0, "BGP peer %s doesn't support IPv6 routes advertisement\n", peer
->name
);
1315 peer
->mp_handling
= DoesntHandleIPv6Routes
;
1319 /* FIXME: should handle more notifications */
1320 LOG(4, 0, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n",
1321 peer
->name
, (int) notification
->error_code
);
1328 peer
->expire_time
= time_now
+ peer
->hold
;
1330 /* see if there's another message in the same packet/buffer */
1331 if (peer
->inbuf
->done
> len
)
1333 peer
->inbuf
->done
-= len
;
1334 memmove(p
, (char *) p
+ len
, peer
->inbuf
->done
);
1338 peer
->inbuf
->packet
.header
.len
= 0;
1339 peer
->inbuf
->done
= 0;
1342 return peer
->inbuf
->done
;
1345 /* send/buffer OPEN message */
1346 static int bgp_send_open(struct bgp_peer
*peer
)
1348 struct bgp_data_open data
;
1349 struct bgp_mp_cap_param mp_ipv6
= { htons(BGP_MP_AFI_IPv6
), 0, BGP_MP_SAFI_UNICAST
};
1350 struct bgp_capability cap_mp_ipv6
;
1351 struct bgp_opt_param param_cap_mp_ipv6
;
1352 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1354 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1355 sizeof(peer
->outbuf
->packet
.header
.marker
));
1357 peer
->outbuf
->packet
.header
.type
= BGP_MSG_OPEN
;
1359 data
.version
= BGP_VERSION
;
1360 data
.as
= htons(our_as
);
1361 data
.hold_time
= htons(peer
->hold
);
1362 data
.identifier
= my_address
;
1364 /* if we know peer doesn't support MP (mp_handling == DoesntHandleIPv6Routes)
1365 then don't add this parameter */
1366 if (peer
->mp_handling
== HandlingUnknown
1367 || peer
->mp_handling
== HandleIPv6Routes
)
1369 /* construct the param and capability */
1370 cap_mp_ipv6
.code
= BGP_CAP_CODE_MP
;
1371 cap_mp_ipv6
.len
= sizeof(mp_ipv6
);
1372 memcpy(&cap_mp_ipv6
.value
, &mp_ipv6
, cap_mp_ipv6
.len
);
1374 param_cap_mp_ipv6
.type
= BGP_PARAM_TYPE_CAPABILITY
;
1375 param_cap_mp_ipv6
.len
= 2 + sizeof(mp_ipv6
);
1376 memcpy(¶m_cap_mp_ipv6
.value
, &cap_mp_ipv6
, param_cap_mp_ipv6
.len
);
1378 data
.opt_len
= 2 + param_cap_mp_ipv6
.len
;
1379 memcpy(&data
.opt_params
, ¶m_cap_mp_ipv6
, data
.opt_len
);
1384 memcpy(peer
->outbuf
->packet
.data
, &data
, BGP_DATA_OPEN_SIZE
+ data
.opt_len
);
1385 len
+= BGP_DATA_OPEN_SIZE
+ data
.opt_len
;
1387 peer
->outbuf
->packet
.header
.len
= htons(len
);
1388 peer
->outbuf
->done
= 0;
1389 peer
->next_state
= OpenSent
;
1391 return bgp_write(peer
);
1394 /* send/buffer KEEPALIVE message */
1395 static int bgp_send_keepalive(struct bgp_peer
*peer
)
1397 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1398 sizeof(peer
->outbuf
->packet
.header
.marker
));
1400 peer
->outbuf
->packet
.header
.type
= BGP_MSG_KEEPALIVE
;
1401 peer
->outbuf
->packet
.header
.len
=
1402 htons(sizeof(peer
->outbuf
->packet
.header
));
1404 peer
->outbuf
->done
= 0;
1405 peer
->next_state
= (peer
->state
== OpenSent
) ? OpenConfirm
: peer
->state
;
1407 return bgp_write(peer
);
1410 /* send/buffer UPDATE message */
1411 static int bgp_send_update(struct bgp_peer
*peer
)
1413 uint16_t unf_len
= 0;
1415 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1416 struct bgp_route_list
*have
= peer
->routes
;
1417 struct bgp_route_list
*want
= peer
->routing
? bgp_routes
: 0;
1418 struct bgp_route_list
*e
= 0;
1419 struct bgp_route_list
*add
= 0;
1422 char *data
= (char *) &peer
->outbuf
->packet
.data
;
1424 /* need leave room for attr_len, bgp_path_attrs and one prefix */
1425 char *max
= (char *) &peer
->outbuf
->packet
.data
1426 + sizeof(peer
->outbuf
->packet
.data
)
1427 - sizeof(attr_len
) - peer
->path_attr_len
- sizeof(struct bgp_ip_prefix
);
1429 /* skip over unf_len */
1430 data
+= sizeof(unf_len
);
1431 len
+= sizeof(unf_len
);
1433 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1434 sizeof(peer
->outbuf
->packet
.header
.marker
));
1436 peer
->outbuf
->packet
.header
.type
= BGP_MSG_UPDATE
;
1438 peer
->update_routes
= 0; /* tentatively clear */
1440 /* find differences */
1441 while ((have
|| want
) && data
< (max
- sizeof(struct bgp_ip_prefix
)))
1445 ? memcmp(&have
->dest
, &want
->dest
, sizeof(have
->dest
))
1450 if (s
< 0) /* found one to delete */
1452 struct bgp_route_list
*tmp
= have
;
1455 s
= BGP_IP_PREFIX_SIZE(tmp
->dest
);
1456 memcpy(data
, &tmp
->dest
, s
);
1461 LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n",
1462 fmtaddr(tmp
->dest
.prefix
, 0), tmp
->dest
.len
, peer
->name
);
1469 peer
->routes
= have
;
1475 e
= have
; /* stash the last found to relink above */
1479 else if (s
> 0) /* addition reqd. */
1483 peer
->update_routes
= 1; /* only one add per packet */
1497 peer
->update_routes
= 1; /* more to do */
1499 /* anything changed? */
1500 if (!(unf_len
|| add
))
1503 /* go back and insert unf_len */
1504 unf_len
= htons(unf_len
);
1505 memcpy(&peer
->outbuf
->packet
.data
, &unf_len
, sizeof(unf_len
));
1509 if (!(e
= malloc(sizeof(*e
))))
1511 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
1512 fmtaddr(add
->dest
.prefix
, 0), add
->dest
.len
, strerror(errno
));
1517 memcpy(e
, add
, sizeof(*e
));
1519 peer
->routes
= bgp_insert_route(peer
->routes
, e
);
1521 attr_len
= htons(peer
->path_attr_len
);
1522 memcpy(data
, &attr_len
, sizeof(attr_len
));
1523 data
+= sizeof(attr_len
);
1524 len
+= sizeof(attr_len
);
1526 memcpy(data
, peer
->path_attrs
, peer
->path_attr_len
);
1527 data
+= peer
->path_attr_len
;
1528 len
+= peer
->path_attr_len
;
1530 s
= BGP_IP_PREFIX_SIZE(add
->dest
);
1531 memcpy(data
, &add
->dest
, s
);
1535 LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n",
1536 fmtaddr(add
->dest
.prefix
, 0), add
->dest
.len
, peer
->name
);
1541 memcpy(data
, &attr_len
, sizeof(attr_len
));
1542 data
+= sizeof(attr_len
);
1543 len
+= sizeof(attr_len
);
1546 peer
->outbuf
->packet
.header
.len
= htons(len
);
1547 peer
->outbuf
->done
= 0;
1549 return bgp_write(peer
);
1552 /* send/buffer UPDATE message for IPv6 routes */
1553 static int bgp_send_update6(struct bgp_peer
*peer
)
1555 uint16_t unf_len
= 0;
1559 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1560 struct bgp_route6_list
*have
= peer
->routes6
;
1561 struct bgp_route6_list
*want
= peer
->routing
? bgp_routes6
: 0;
1562 struct bgp_route6_list
*e
= 0;
1563 struct bgp_route6_list
*add
= 0;
1565 char ipv6addr
[INET6_ADDRSTRLEN
];
1567 char *data
= (char *) &peer
->outbuf
->packet
.data
;
1569 /* need leave room for attr_len, bgp_path_attrs and one prefix */
1570 char *max
= (char *) &peer
->outbuf
->packet
.data
1571 + sizeof(peer
->outbuf
->packet
.data
)
1572 - sizeof(attr_len
) - peer
->path_attr_len_without_nexthop
1573 - BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
- sizeof(struct bgp_ip6_prefix
);
1575 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1576 sizeof(peer
->outbuf
->packet
.header
.marker
));
1578 peer
->outbuf
->packet
.header
.type
= BGP_MSG_UPDATE
;
1580 /* insert non-MP unf_len */
1581 memcpy(data
, &unf_len
, sizeof(unf_len
));
1582 /* skip over attr_len too; will be filled when known */
1583 data
+= sizeof(unf_len
) + sizeof(attr_len
);
1584 len
+= sizeof(unf_len
) + sizeof(attr_len
);
1586 /* copy usual attributes */
1587 memcpy(data
, peer
->path_attrs
, peer
->path_attr_len_without_nexthop
);
1588 data
+= peer
->path_attr_len_without_nexthop
;
1589 len
+= peer
->path_attr_len_without_nexthop
;
1591 /* copy MP unreachable NLRI heading */
1592 memcpy(data
, peer
->mp_unreach_nlri_partial
,
1593 BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
);
1594 /* remember where to update this attr len */
1595 unreach_len
= data
+ 2;
1596 data
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1597 len
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1599 peer
->update_routes6
= 0; /* tentatively clear */
1601 /* find differences */
1602 while ((have
|| want
) && data
< (max
- sizeof(struct bgp_ip6_prefix
)))
1606 ? memcmp(&have
->dest
, &want
->dest
, sizeof(have
->dest
))
1611 if (s
< 0) /* found one to delete */
1613 struct bgp_route6_list
*tmp
= have
;
1616 s
= BGP_IP_PREFIX_SIZE(tmp
->dest
);
1617 memcpy(data
, &tmp
->dest
, s
);
1622 LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n",
1623 inet_ntop(AF_INET6
, &tmp
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1624 tmp
->dest
.len
, peer
->name
);
1631 peer
->routes6
= have
;
1637 e
= have
; /* stash the last found to relink above */
1641 else if (s
> 0) /* addition reqd. */
1645 peer
->update_routes6
= 1; /* only one add per packet */
1659 peer
->update_routes6
= 1; /* more to do */
1661 /* anything changed? */
1662 if (!(unf_len
|| add
))
1665 /* go back and insert MP unf_len */
1666 unf_len
+= sizeof(struct bgp_attr_mp_unreach_nlri_partial
);
1667 unf_len
= htons(unf_len
);
1668 memcpy(&unreach_len
, &unf_len
, sizeof(unf_len
));
1672 if (!(e
= malloc(sizeof(*e
))))
1674 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
1675 inet_ntop(AF_INET6
, &add
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1676 add
->dest
.len
, strerror(errno
));
1681 memcpy(e
, add
, sizeof(*e
));
1683 peer
->routes6
= bgp_insert_route6(peer
->routes6
, e
);
1685 /* copy MP reachable NLRI heading */
1686 memcpy(data
, peer
->mp_reach_nlri_partial
,
1687 BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
);
1688 /* with proper len */
1689 reach_len
= BGP_IP_PREFIX_SIZE(add
->dest
);
1690 data
[2] = reach_len
;
1691 data
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1692 len
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1694 memcpy(data
, &add
->dest
, reach_len
);
1698 LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n",
1699 inet_ntop(AF_INET6
, &add
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1700 add
->dest
.len
, peer
->name
);
1703 /* go back and insert attr_len */
1704 attr_len
= htons(len
- 4);
1705 memcpy(&peer
->outbuf
->packet
.data
+ 2, &attr_len
, sizeof(attr_len
));
1707 peer
->outbuf
->packet
.header
.len
= htons(len
);
1708 peer
->outbuf
->done
= 0;
1710 return bgp_write(peer
);
1713 /* send/buffer NOTIFICATION message */
1714 static int bgp_send_notification(struct bgp_peer
*peer
, uint8_t code
,
1717 return bgp_send_notification_full(peer
, code
, subcode
, NULL
, 0);
1720 static int bgp_send_notification_full(struct bgp_peer
*peer
, uint8_t code
,
1721 uint8_t subcode
, char *notification_data
, uint16_t data_len
)
1723 struct bgp_data_notification data
;
1726 data
.error_code
= code
;
1727 len
+= sizeof(data
.error_code
);
1729 data
.error_subcode
= subcode
;
1730 len
+= sizeof(data
.error_code
);
1732 memcpy(data
.data
, notification_data
, data_len
);
1735 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1736 sizeof(peer
->outbuf
->packet
.header
.marker
));
1738 peer
->outbuf
->packet
.header
.type
= BGP_MSG_NOTIFICATION
;
1739 peer
->outbuf
->packet
.header
.len
=
1740 htons(sizeof(peer
->outbuf
->packet
.header
) + len
);
1742 memcpy(peer
->outbuf
->packet
.data
, &data
, len
);
1744 peer
->outbuf
->done
= 0;
1745 peer
->next_state
= code
== BGP_ERR_CEASE
? Disabled
: Idle
;
1747 /* we're dying; ignore any pending input */
1748 peer
->inbuf
->packet
.header
.len
= 0;
1749 peer
->inbuf
->done
= 0;
1751 return bgp_write(peer
);