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
, int prefixlen
, 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_process_timers(struct bgp_peer
*peer
);
39 static void bgp_free_routes(struct bgp_route_list
*routes
);
40 static void bgp_free_routes6(struct bgp_route6_list
*routes
);
41 static char const *bgp_msg_type_str(uint8_t type
);
42 static int bgp_connect(struct bgp_peer
*peer
);
43 static int bgp_handle_connect(struct bgp_peer
*peer
);
44 static int bgp_write(struct bgp_peer
*peer
);
45 static int bgp_read(struct bgp_peer
*peer
);
46 static int bgp_handle_input(struct bgp_peer
*peer
);
47 static int bgp_send_open(struct bgp_peer
*peer
);
48 static int bgp_send_keepalive(struct bgp_peer
*peer
);
49 static int bgp_send_update(struct bgp_peer
*peer
);
50 static int bgp_send_update6(struct bgp_peer
*peer
);
51 static int bgp_send_notification(struct bgp_peer
*peer
, uint8_t code
,
54 static uint16_t our_as
;
55 static struct bgp_route_list
*bgp_routes
= 0;
56 static struct bgp_route6_list
*bgp_routes6
= 0;
58 int bgp_configured
= 0;
59 struct bgp_peer
*bgp_peers
= 0;
61 /* prepare peer structure, globals */
65 struct bgp_peer
*peer
;
67 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
70 memset(peer
, 0, sizeof(*peer
));
72 peer
->addr
= INADDR_NONE
;
74 peer
->state
= peer
->next_state
= Disabled
;
76 if (!((peer
->outbuf
= malloc(sizeof(*peer
->outbuf
)))
77 && (peer
->inbuf
= malloc(sizeof(*peer
->inbuf
)))))
79 LOG(0, 0, 0, "Can't allocate buffers for bgp peer (%s)\n",
85 peer
->edata
.type
= FD_TYPE_BGP
;
86 peer
->edata
.index
= i
;
98 bgp_configured
= 0; /* set by bgp_start */
103 /* start connection with a peer */
104 int bgp_start(struct bgp_peer
*peer
, char *name
, int as
, int keepalive
,
105 int hold
, struct in_addr update_source
, int enable
)
110 struct bgp_path_attr a
;
112 char *p
= path_attrs
;
114 uint32_t metric
= htonl(BGP_METRIC
);
115 uint32_t no_export
= htonl(BGP_COMMUNITY_NO_EXPORT
);
120 if (peer
->state
!= Disabled
)
123 snprintf(peer
->name
, sizeof(peer
->name
), "%s", name
);
125 if (!(h
= gethostbyname(name
)) || h
->h_addrtype
!= AF_INET
)
127 LOG(0, 0, 0, "Can't get address for BGP peer %s (%s)\n",
128 name
, h
? "no address" : hstrerror(h_errno
));
133 memcpy(&peer
->addr
, h
->h_addr
, sizeof(peer
->addr
));
134 peer
->source_addr
= update_source
.s_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 if (config
->nexthop_address
)
239 ip
= config
->nexthop_address
;
243 ip
= my_address
; /* we're it */
245 a
.data
.s
.len
= sizeof(ip
);
246 memcpy(a
.data
.s
.value
, &ip
, sizeof(ip
));
250 if (!(peer
->path_attrs
= malloc(peer
->path_attr_len
)))
252 LOG(0, 0, 0, "Can't allocate path_attrs for %s (%s)\n",
253 name
, strerror(errno
));
258 memcpy(peer
->path_attrs
, path_attrs
, peer
->path_attr_len
);
260 /* multiprotocol attributes initialization */
261 if (config
->ipv6_prefix
.s6_addr
[0])
263 struct bgp_attr_mp_reach_nlri_partial mp_reach_nlri_partial
;
264 struct bgp_attr_mp_unreach_nlri_partial mp_unreach_nlri_partial
;
266 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
;
267 a
.code
= BGP_PATH_ATTR_CODE_MP_REACH_NLRI
;
268 a
.data
.s
.len
= 0; /* will be set on UPDATE */
270 mp_reach_nlri_partial
.afi
= htons(BGP_MP_AFI_IPv6
);
271 mp_reach_nlri_partial
.safi
= BGP_MP_SAFI_UNICAST
;
272 mp_reach_nlri_partial
.reserved
= 0;
273 mp_reach_nlri_partial
.next_hop_len
= 16;
275 /* use the defined nexthop6, or our address in ipv6_prefix */
276 if (config
->nexthop6_address
.s6_addr
[0])
277 memcpy(&mp_reach_nlri_partial
.next_hop
,
278 &config
->nexthop6_address
.s6_addr
, 16);
281 /* our address is ipv6prefix::1 */
282 memcpy(&mp_reach_nlri_partial
.next_hop
,
283 &config
->ipv6_prefix
.s6_addr
, 16);
284 mp_reach_nlri_partial
.next_hop
[15] = 1;
287 memcpy(&a
.data
.s
.value
, &mp_reach_nlri_partial
,
288 sizeof(struct bgp_attr_mp_reach_nlri_partial
));
289 memcpy(&peer
->mp_reach_nlri_partial
, &a
,
290 BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
);
292 a
.flags
= BGP_PATH_ATTR_FLAG_OPTIONAL
| BGP_PATH_ATTR_FLAG_EXTLEN
;
293 a
.code
= BGP_PATH_ATTR_CODE_MP_UNREACH_NLRI
;
294 a
.data
.e
.len
= 0; /* will be set on UPDATE */
296 mp_unreach_nlri_partial
.afi
= htons(BGP_MP_AFI_IPv6
);
297 mp_unreach_nlri_partial
.safi
= BGP_MP_SAFI_UNICAST
;
299 memcpy(&a
.data
.e
.value
, &mp_unreach_nlri_partial
,
300 sizeof(struct bgp_attr_mp_unreach_nlri_partial
));
301 memcpy(&peer
->mp_unreach_nlri_partial
, &a
,
302 BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
);
305 peer
->mp_handling
= HandlingUnknown
;
307 LOG(4, 0, 0, "Initiating BGP connection to %s (routing %s)\n",
308 name
, enable
? "enabled" : "suspended");
310 /* we have at least one peer configured */
314 return bgp_connect(peer
);
317 /* clear counters, timers, routes and buffers; close socket; move to
318 next_state, which may be Disabled or Idle */
319 static void bgp_clear(struct bgp_peer
*peer
)
321 if (peer
->sock
!= -1)
327 peer
->keepalive_time
= 0;
328 peer
->expire_time
= 0;
330 peer
->keepalive
= peer
->init_keepalive
;
331 peer
->hold
= peer
->init_hold
;
333 bgp_free_routes(peer
->routes
);
335 bgp_free_routes6(peer
->routes6
);
338 peer
->outbuf
->packet
.header
.len
= 0;
339 peer
->outbuf
->done
= 0;
340 peer
->inbuf
->packet
.header
.len
= 0;
341 peer
->inbuf
->done
= 0;
346 if (peer
->state
!= peer
->next_state
)
348 peer
->state
= peer
->next_state
;
349 peer
->state_time
= time_now
;
351 LOG(4, 0, 0, "BGP peer %s: state %s\n", peer
->name
,
352 bgp_state_str(peer
->next_state
));
356 /* initiate a clean shutdown */
357 void bgp_stop(struct bgp_peer
*peer
)
359 LOG(4, 0, 0, "Terminating BGP connection to %s\n", peer
->name
);
360 bgp_send_notification(peer
, BGP_ERR_CEASE
, 0);
363 /* drop connection (if any) and set state to Disabled */
364 void bgp_halt(struct bgp_peer
*peer
)
366 LOG(4, 0, 0, "Aborting BGP connection to %s\n", peer
->name
);
367 peer
->next_state
= Disabled
;
371 /* drop connection (if any) and set to Idle for connection retry */
372 int bgp_restart(struct bgp_peer
*peer
)
374 peer
->next_state
= Idle
;
378 peer
->retry_time
= time_now
;
379 peer
->retry_count
= 0;
382 return bgp_connect(peer
);
385 static void bgp_set_retry(struct bgp_peer
*peer
)
387 if (peer
->retry_count
++ < BGP_MAX_RETRY
)
389 peer
->retry_time
= time_now
+ (BGP_RETRY_BACKOFF
* peer
->retry_count
);
390 peer
->next_state
= Idle
;
394 bgp_halt(peer
); /* give up */
397 /* insert route into list; sorted */
398 static struct bgp_route_list
*bgp_insert_route(struct bgp_route_list
*head
,
399 struct bgp_route_list
*new)
401 struct bgp_route_list
*p
= head
;
402 struct bgp_route_list
*e
= 0;
404 while (p
&& memcmp(&p
->dest
, &new->dest
, sizeof(p
->dest
)) < 0)
424 /* insert route6 into list; sorted */
425 static struct bgp_route6_list
*bgp_insert_route6(struct bgp_route6_list
*head
,
426 struct bgp_route6_list
*new)
428 struct bgp_route6_list
*p
= head
;
429 struct bgp_route6_list
*e
= 0;
431 while (p
&& memcmp(&p
->dest
, &new->dest
, sizeof(p
->dest
)) < 0)
451 /* add route to list for peers */
453 * Note: this doesn't do route aggregation, nor drop routes if a less
454 * specific match already exists (partly because I'm lazy, but also so
455 * that if that route is later deleted we don't have to be concerned
456 * about adding back the more specific one).
458 int bgp_add_route(in_addr_t ip
, int prefixlen
)
460 struct bgp_route_list
*r
= bgp_routes
;
461 struct bgp_route_list add
;
464 add
.dest
.prefix
= ip
;
465 add
.dest
.len
= prefixlen
;
468 /* check for duplicate */
471 i
= memcmp(&r
->dest
, &add
.dest
, sizeof(r
->dest
));
473 return 1; /* already covered */
481 /* insert into route list; sorted */
482 if (!(r
= malloc(sizeof(*r
))))
484 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
485 fmtaddr(add
.dest
.prefix
, 0), add
.dest
.len
, strerror(errno
));
490 memcpy(r
, &add
, sizeof(*r
));
491 bgp_routes
= bgp_insert_route(bgp_routes
, r
);
493 /* flag established peers for update */
494 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
495 if (bgp_peers
[i
].state
== Established
)
496 bgp_peers
[i
].update_routes
= 1;
498 LOG(4, 0, 0, "Registered BGP route %s/%d\n",
499 fmtaddr(add
.dest
.prefix
, 0), add
.dest
.len
);
504 /* add route to list for peers */
506 * Note: same provisions as above
508 int bgp_add_route6(struct in6_addr ip
, int prefixlen
)
510 struct bgp_route6_list
*r
= bgp_routes6
;
511 struct bgp_route6_list add
;
513 char ipv6addr
[INET6_ADDRSTRLEN
];
515 memcpy(&add
.dest
.prefix
, &ip
.s6_addr
, 16);
516 add
.dest
.len
= prefixlen
;
519 /* check for duplicate */
522 i
= memcmp(&r
->dest
, &add
.dest
, sizeof(r
->dest
));
524 return 1; /* already covered */
532 /* insert into route list; sorted */
533 if (!(r
= malloc(sizeof(*r
))))
535 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
536 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), add
.dest
.len
,
542 memcpy(r
, &add
, sizeof(*r
));
543 bgp_routes6
= bgp_insert_route6(bgp_routes6
, r
);
545 /* flag established peers for update */
546 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
547 if (bgp_peers
[i
].state
== Established
548 && bgp_peers
[i
].mp_handling
== HandleIPv6Routes
)
549 bgp_peers
[i
].update_routes6
= 1;
551 LOG(4, 0, 0, "Registered BGP route %s/%d\n",
552 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), add
.dest
.len
);
557 /* remove route from list for peers */
558 int bgp_del_route(in_addr_t ip
, int prefixlen
)
560 struct bgp_route_list
*r
= bgp_routes
;
561 struct bgp_route_list
*e
= 0;
562 struct bgp_route_list del
;
565 del
.dest
.prefix
= ip
;
566 del
.dest
.len
= prefixlen
;
569 /* find entry in routes list and remove */
572 i
= memcmp(&r
->dest
, &del
.dest
, sizeof(r
->dest
));
578 bgp_routes
= r
->next
;
596 /* flag established peers for update */
597 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
598 if (bgp_peers
[i
].state
== Established
)
599 bgp_peers
[i
].update_routes
= 1;
601 LOG(4, 0, 0, "Removed BGP route %s/%d\n",
602 fmtaddr(del
.dest
.prefix
, 0), del
.dest
.len
);
607 /* remove route from list for peers */
608 int bgp_del_route6(struct in6_addr ip
, int prefixlen
)
610 struct bgp_route6_list
*r
= bgp_routes6
;
611 struct bgp_route6_list
*e
= 0;
612 struct bgp_route6_list del
;
614 char ipv6addr
[INET6_ADDRSTRLEN
];
616 memcpy(&del
.dest
.prefix
, &ip
.s6_addr
, 16);
617 del
.dest
.len
= prefixlen
;
620 /* find entry in routes list and remove */
623 i
= memcmp(&r
->dest
, &del
.dest
, sizeof(r
->dest
));
629 bgp_routes6
= r
->next
;
647 /* flag established peers for update */
648 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
649 if (bgp_peers
[i
].state
== Established
650 && bgp_peers
[i
].mp_handling
== HandleIPv6Routes
)
651 bgp_peers
[i
].update_routes6
= 1;
653 LOG(4, 0, 0, "Removed BGP route %s/%d\n",
654 inet_ntop(AF_INET6
, &ip
, ipv6addr
, INET6_ADDRSTRLEN
), del
.dest
.len
);
659 /* enable or disable routing */
660 void bgp_enable_routing(int enable
)
664 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
666 bgp_peers
[i
].routing
= enable
;
668 /* flag established peers for update */
669 if (bgp_peers
[i
].state
== Established
)
670 bgp_peers
[i
].update_routes
= 1;
673 LOG(4, 0, 0, "%s BGP routing\n", enable
? "Enabled" : "Suspended");
677 # include <sys/epoll.h>
679 # include "fake_epoll.h"
682 /* return a bitmask of the events required to poll this peer's fd */
690 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
692 struct bgp_peer
*peer
= &bgp_peers
[i
];
695 if (peer
->state
== Disabled
|| peer
->state
== Idle
)
698 if (peer
->inbuf
->done
< BGP_MAX_PACKET_SIZE
)
701 if (peer
->state
== Connect
|| /* connection in progress */
702 peer
->update_routes
|| /* routing updates */
703 peer
->outbuf
->packet
.header
.len
) /* pending output */
706 if (peer
->events
!= events
)
708 struct epoll_event ev
;
710 ev
.events
= peer
->events
= events
;
711 ev
.data
.ptr
= &peer
->edata
;
712 epoll_ctl(epollfd
, EPOLL_CTL_MOD
, peer
->sock
, &ev
);
719 /* process bgp events/timers */
720 int bgp_process(uint32_t events
[])
727 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
729 struct bgp_peer
*peer
= &bgp_peers
[i
];
731 if (*peer
->name
&& peer
->cli_flag
== BGP_CLI_RESTART
)
737 if (peer
->state
== Disabled
)
742 switch (peer
->cli_flag
)
744 case BGP_CLI_SUSPEND
:
748 if (peer
->state
== Established
)
749 peer
->update_routes
= 1;
758 if (peer
->state
== Established
)
759 peer
->update_routes
= 1;
768 /* handle empty/fill of buffers */
769 if (events
[i
] & EPOLLOUT
)
772 if (peer
->state
== Connect
)
773 r
= bgp_handle_connect(peer
);
774 else if (peer
->outbuf
->packet
.header
.len
)
781 if (events
[i
] & (EPOLLIN
|EPOLLHUP
))
787 /* process input buffer contents */
788 while (peer
->inbuf
->done
>= sizeof(peer
->inbuf
->packet
.header
)
789 && !peer
->outbuf
->packet
.header
.len
) /* may need to queue a response */
791 if (bgp_handle_input(peer
) < 0)
795 /* process pending updates */
796 if (peer
->update_routes
797 && !peer
->outbuf
->packet
.header
.len
) /* ditto */
799 if (!bgp_send_update(peer
))
803 /* process pending IPv6 updates */
804 if (peer
->update_routes6
805 && !peer
->outbuf
->packet
.header
.len
) /* ditto */
807 if (!bgp_send_update6(peer
))
812 bgp_process_timers(peer
);
818 /* process bgp timers only */
819 void bgp_process_peers_timers()
826 for (i
= 0; i
< BGP_NUM_PEERS
; i
++)
828 struct bgp_peer
*peer
= &bgp_peers
[i
];
830 if (peer
->state
== Disabled
)
833 bgp_process_timers(peer
);
837 static void bgp_process_timers(struct bgp_peer
*peer
)
839 if (peer
->state
== Established
)
841 if (time_now
> peer
->expire_time
)
843 LOG(1, 0, 0, "No message from BGP peer %s in %ds\n",
844 peer
->name
, peer
->hold
);
846 bgp_send_notification(peer
, BGP_ERR_HOLD_TIMER_EXP
, 0);
850 if (time_now
> peer
->keepalive_time
&& !peer
->outbuf
->packet
.header
.len
)
851 bgp_send_keepalive(peer
);
853 else if (peer
->state
== Idle
)
855 if (time_now
> peer
->retry_time
)
858 else if (time_now
> peer
->state_time
+ BGP_STATE_TIME
)
860 LOG(1, 0, 0, "%s timer expired for BGP peer %s\n",
861 bgp_state_str(peer
->state
), peer
->name
);
867 static void bgp_free_routes(struct bgp_route_list
*routes
)
869 struct bgp_route_list
*tmp
;
871 while ((tmp
= routes
))
878 static void bgp_free_routes6(struct bgp_route6_list
*routes
)
880 struct bgp_route6_list
*tmp
;
882 while ((tmp
= routes
))
889 char const *bgp_state_str(enum bgp_state state
)
893 case Disabled
: return "Disabled";
894 case Idle
: return "Idle";
895 case Connect
: return "Connect";
896 case Active
: return "Active";
897 case OpenSent
: return "OpenSent";
898 case OpenConfirm
: return "OpenConfirm";
899 case Established
: return "Established";
905 static char const *bgp_msg_type_str(uint8_t type
)
909 case BGP_MSG_OPEN
: return "OPEN";
910 case BGP_MSG_UPDATE
: return "UPDATE";
911 case BGP_MSG_NOTIFICATION
: return "NOTIFICATION";
912 case BGP_MSG_KEEPALIVE
: return "KEEPALIVE";
918 /* attempt to connect to peer */
919 static int bgp_connect(struct bgp_peer
*peer
)
921 static int bgp_port
= 0;
922 struct sockaddr_in addr
;
923 struct sockaddr_in source_addr
;
924 struct epoll_event ev
;
928 struct servent
*serv
;
929 if (!(serv
= getservbyname("bgp", "tcp")))
931 LOG(0, 0, 0, "Can't get bgp service (%s)\n", strerror(errno
));
935 bgp_port
= serv
->s_port
;
938 if ((peer
->sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
)) < 0)
940 LOG(0, 0, 0, "Can't create a socket for BGP peer %s (%s)\n",
941 peer
->name
, strerror(errno
));
943 peer
->state
= peer
->next_state
= Disabled
;
947 /* add to poll set */
948 ev
.events
= peer
->events
= EPOLLOUT
;
949 ev
.data
.ptr
= &peer
->edata
;
950 epoll_ctl(epollfd
, EPOLL_CTL_ADD
, peer
->sock
, &ev
);
952 /* set to non-blocking */
953 fcntl(peer
->sock
, F_SETFL
, fcntl(peer
->sock
, F_GETFL
, 0) | O_NONBLOCK
);
955 /* set source address */
956 memset(&source_addr
, 0, sizeof(source_addr
));
957 source_addr
.sin_family
= AF_INET
;
958 source_addr
.sin_addr
.s_addr
= peer
->source_addr
; /* defaults to INADDR_ANY */
959 if (bind(peer
->sock
, (struct sockaddr
*) &source_addr
, sizeof(source_addr
)) < 0)
961 LOG(1, 0, 0, "Can't set source address to %s: %s\n",
962 inet_ntoa(source_addr
.sin_addr
), strerror(errno
));
969 memset(&addr
, 0, sizeof(addr
));
970 addr
.sin_family
= AF_INET
;
971 addr
.sin_port
= bgp_port
;
972 addr
.sin_addr
.s_addr
= peer
->addr
;
974 while (connect(peer
->sock
, (struct sockaddr
*) &addr
, sizeof(addr
)) == -1)
976 if (errno
== EINTR
) /* SIGALARM handler */
979 if (errno
!= EINPROGRESS
)
981 LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n",
982 inet_ntoa(addr
.sin_addr
), strerror(errno
));
988 peer
->state
= Connect
;
989 peer
->state_time
= time_now
;
991 LOG(4, 0, 0, "BGP peer %s: state Connect\n", peer
->name
);
995 peer
->state
= Active
;
996 peer
->state_time
= time_now
;
997 peer
->retry_time
= peer
->retry_count
= 0;
999 LOG(4, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr
.sin_addr
));
1001 return bgp_send_open(peer
);
1004 /* complete partial connection (state = Connect) */
1005 static int bgp_handle_connect(struct bgp_peer
*peer
)
1008 socklen_t len
= sizeof(int);
1009 getsockopt(peer
->sock
, SOL_SOCKET
, SO_ERROR
, &err
, &len
);
1012 LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n", peer
->name
,
1015 bgp_set_retry(peer
);
1019 peer
->state
= Active
;
1020 peer
->state_time
= time_now
;
1022 LOG(4, 0, 0, "BGP peer %s: state Active\n", peer
->name
);
1024 return bgp_send_open(peer
);
1027 /* initiate a write */
1028 static int bgp_write(struct bgp_peer
*peer
)
1030 int len
= htons(peer
->outbuf
->packet
.header
.len
);
1033 while ((r
= write(peer
->sock
, &peer
->outbuf
->packet
+ peer
->outbuf
->done
,
1034 len
- peer
->outbuf
->done
)) == -1)
1039 if (errno
== EAGAIN
)
1043 LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer
->name
);
1045 LOG(1, 0, 0, "Can't write to BGP peer %s (%s)\n", peer
->name
,
1048 bgp_set_retry(peer
);
1054 peer
->outbuf
->done
+= r
;
1058 LOG(4, 0, 0, "Sent %s to BGP peer %s\n",
1059 bgp_msg_type_str(peer
->outbuf
->packet
.header
.type
), peer
->name
);
1061 peer
->outbuf
->packet
.header
.len
= 0;
1062 peer
->outbuf
->done
= 0;
1064 if (peer
->state
== Established
)
1065 peer
->keepalive_time
= time_now
+ peer
->keepalive
;
1067 if (peer
->state
!= peer
->next_state
)
1069 if (peer
->next_state
== Disabled
|| peer
->next_state
== Idle
)
1075 peer
->state
= peer
->next_state
;
1076 peer
->state_time
= time_now
;
1078 LOG(4, 0, 0, "BGP peer %s: state %s\n", peer
->name
,
1079 bgp_state_str(peer
->state
));
1085 /* initiate a read */
1086 static int bgp_read(struct bgp_peer
*peer
)
1090 while ((r
= read(peer
->sock
, &peer
->inbuf
->packet
+ peer
->inbuf
->done
,
1091 BGP_MAX_PACKET_SIZE
- peer
->inbuf
->done
)) < 1)
1095 LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer
->name
);
1102 if (errno
== EAGAIN
)
1105 LOG(1, 0, 0, "Can't read from BGP peer %s (%s)\n", peer
->name
,
1109 bgp_set_retry(peer
);
1113 peer
->inbuf
->done
+= r
;
1117 /* process buffered packets */
1118 static int bgp_handle_input(struct bgp_peer
*peer
)
1120 struct bgp_packet
*p
= &peer
->inbuf
->packet
;
1121 int len
= ntohs(p
->header
.len
);
1123 if (len
> BGP_MAX_PACKET_SIZE
)
1125 LOG(1, 0, 0, "Bad header length from BGP %s\n", peer
->name
);
1126 bgp_send_notification(peer
, BGP_ERR_HEADER
, BGP_ERR_HDR_BAD_LEN
);
1130 if (peer
->inbuf
->done
< len
)
1133 LOG(4, 0, 0, "Received %s from BGP peer %s\n",
1134 bgp_msg_type_str(p
->header
.type
), peer
->name
);
1136 switch (p
->header
.type
)
1140 struct bgp_data_open data
;
1143 off_t param_offset
, capability_offset
;
1144 struct bgp_opt_param
*param
;
1145 uint8_t capabilities_len
;
1146 char *capabilities
= NULL
;
1147 struct bgp_capability
*capability
;
1148 struct bgp_mp_cap_param
*mp_cap
;
1150 for (i
= 0; i
< sizeof(p
->header
.marker
); i
++)
1152 if ((unsigned char) p
->header
.marker
[i
] != 0xff)
1154 LOG(1, 0, 0, "Invalid marker from BGP peer %s\n",
1157 bgp_send_notification(peer
, BGP_ERR_HEADER
,
1158 BGP_ERR_HDR_NOT_SYNC
);
1164 if (peer
->state
!= OpenSent
)
1166 LOG(1, 0, 0, "OPEN from BGP peer %s in %s state\n",
1167 peer
->name
, bgp_state_str(peer
->state
));
1169 bgp_send_notification(peer
, BGP_ERR_FSM
, 0);
1173 memcpy(&data
, p
->data
, len
- sizeof(p
->header
));
1175 if (data
.version
!= BGP_VERSION
)
1177 LOG(1, 0, 0, "Bad version (%d) sent by BGP peer %s\n",
1178 (int) data
.version
, peer
->name
);
1180 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_VERSION
);
1184 if (ntohs(data
.as
) != peer
->as
)
1186 LOG(1, 0, 0, "Bad AS sent by BGP peer %s (got %d, "
1187 "expected %d)\n", peer
->name
, (int) htons(data
.as
),
1190 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_BAD_AS
);
1194 if ((hold
= ntohs(data
.hold_time
)) < 3)
1196 LOG(1, 0, 0, "Bad hold time (%d) from BGP peer %s\n",
1199 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_HOLD_TIME
);
1203 /* pick lowest hold time */
1204 if (hold
< peer
->hold
)
1207 /* adjust our keepalive based on negotiated hold value */
1208 if (peer
->keepalive
* 3 > peer
->hold
)
1209 peer
->keepalive
= peer
->hold
/ 3;
1211 /* check for optional parameters */
1212 /* 2 is for the size of type + len (both uint8_t) */
1213 for (param_offset
= 0;
1214 param_offset
< data
.opt_len
;
1215 param_offset
+= 2 + param
->len
)
1217 param
= (struct bgp_opt_param
*)((char *)&data
.opt_params
+ param_offset
);
1219 /* sensible check */
1220 if (data
.opt_len
- param_offset
< 2
1221 || param
->len
> data
.opt_len
- param_offset
- 2)
1223 LOG(1, 0, 0, "Malformed Optional Parameter list from BGP peer %s\n",
1226 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_UNSPEC
);
1230 /* we know only one parameter type */
1231 if (param
->type
!= BGP_PARAM_TYPE_CAPABILITY
)
1233 LOG(1, 0, 0, "Unsupported Optional Parameter type %d from BGP peer %s\n",
1234 param
->type
, peer
->name
);
1236 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_OPN_UNSUP_PARAM
);
1240 capabilities_len
= param
->len
;
1241 capabilities
= (char *)¶m
->value
;
1243 /* look for BGP multiprotocol capability */
1244 for (capability_offset
= 0;
1245 capability_offset
< capabilities_len
;
1246 capability_offset
+= 2 + capability
->len
)
1248 capability
= (struct bgp_capability
*)(capabilities
+ capability_offset
);
1250 /* sensible check */
1251 if (capabilities_len
- capability_offset
< 2
1252 || capability
->len
> capabilities_len
- capability_offset
- 2)
1254 LOG(1, 0, 0, "Malformed Capabilities list from BGP peer %s\n",
1257 bgp_send_notification(peer
, BGP_ERR_OPEN
, BGP_ERR_UNSPEC
);
1261 /* we only know one capability code */
1262 if (capability
->code
!= BGP_CAP_CODE_MP
1263 && capability
->len
!= sizeof(struct bgp_mp_cap_param
))
1265 LOG(4, 0, 0, "Unsupported Capability code %d from BGP peer %s\n",
1266 capability
->code
, peer
->name
);
1268 /* we don't terminate, still; we just jump to the next one */
1272 mp_cap
= (struct bgp_mp_cap_param
*)&capability
->value
;
1273 /* the only <AFI, SAFI> tuple we support */
1274 if (ntohs(mp_cap
->afi
) != BGP_MP_AFI_IPv6
&& mp_cap
->safi
!= BGP_MP_SAFI_UNICAST
)
1276 LOG(4, 0, 0, "Unsupported multiprotocol AFI %d and SAFI %d from BGP peer %s\n",
1277 mp_cap
->afi
, mp_cap
->safi
, peer
->name
);
1279 /* we don't terminate, still; we just jump to the next one */
1284 peer
->mp_handling
= HandleIPv6Routes
;
1288 if (peer
->mp_handling
!= HandleIPv6Routes
)
1290 peer
->mp_handling
= DoesntHandleIPv6Routes
;
1291 if (config
->ipv6_prefix
.s6_addr
[0])
1292 LOG(1, 0, 0, "Warning: BGP peer %s doesn't handle IPv6 prefixes updates\n",
1296 /* next transition requires an exchange of keepalives */
1297 bgp_send_keepalive(peer
);
1302 case BGP_MSG_KEEPALIVE
:
1303 if (peer
->state
== OpenConfirm
)
1305 peer
->state
= peer
->next_state
= Established
;
1306 peer
->state_time
= time_now
;
1307 peer
->keepalive_time
= time_now
+ peer
->keepalive
;
1308 peer
->update_routes
= 1;
1309 peer
->retry_count
= 0;
1310 peer
->retry_time
= 0;
1312 LOG(4, 0, 0, "BGP peer %s: state Established\n", peer
->name
);
1317 case BGP_MSG_NOTIFICATION
:
1318 if (len
> sizeof(p
->header
))
1320 struct bgp_data_notification
*notification
=
1321 (struct bgp_data_notification
*) p
->data
;
1323 if (notification
->error_code
== BGP_ERR_CEASE
)
1325 LOG(4, 0, 0, "BGP peer %s sent CEASE\n", peer
->name
);
1326 bgp_set_retry(peer
);
1330 if (notification
->error_code
== BGP_ERR_OPEN
1331 && notification
->error_subcode
== BGP_ERR_OPN_UNSUP_PARAM
)
1333 LOG(4, 0, 0, "BGP peer %s doesn't support BGP Capabilities\n", peer
->name
);
1334 peer
->mp_handling
= DoesntHandleIPv6Routes
;
1335 bgp_set_retry(peer
);
1339 if (notification
->error_code
== BGP_ERR_OPEN
1340 && notification
->error_subcode
== BGP_ERR_OPN_UNSUP_CAP
)
1342 /* the only capability we advertise is this one, so upon receiving
1343 an "unsupported capability" message, we disable IPv6 routes for
1345 LOG(4, 0, 0, "BGP peer %s doesn't support IPv6 routes advertisement\n", peer
->name
);
1346 peer
->mp_handling
= DoesntHandleIPv6Routes
;
1350 /* FIXME: should handle more notifications */
1351 LOG(4, 0, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n",
1352 peer
->name
, (int) notification
->error_code
);
1359 peer
->expire_time
= time_now
+ peer
->hold
;
1361 /* see if there's another message in the same packet/buffer */
1362 if (peer
->inbuf
->done
> len
)
1364 peer
->inbuf
->done
-= len
;
1365 memmove(p
, (char *) p
+ len
, peer
->inbuf
->done
);
1369 peer
->inbuf
->packet
.header
.len
= 0;
1370 peer
->inbuf
->done
= 0;
1373 return peer
->inbuf
->done
;
1376 /* send/buffer OPEN message */
1377 static int bgp_send_open(struct bgp_peer
*peer
)
1379 struct bgp_data_open data
;
1380 struct bgp_mp_cap_param mp_ipv6
= { htons(BGP_MP_AFI_IPv6
), 0, BGP_MP_SAFI_UNICAST
};
1381 struct bgp_capability cap_mp_ipv6
;
1382 struct bgp_opt_param param_cap_mp_ipv6
;
1383 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1385 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1386 sizeof(peer
->outbuf
->packet
.header
.marker
));
1388 peer
->outbuf
->packet
.header
.type
= BGP_MSG_OPEN
;
1390 data
.version
= BGP_VERSION
;
1391 data
.as
= htons(our_as
);
1392 data
.hold_time
= htons(peer
->hold
);
1393 /* use the source IP we use as identifier, if available */
1394 if (peer
->source_addr
!= INADDR_ANY
)
1395 data
.identifier
= peer
->source_addr
;
1397 data
.identifier
= my_address
;
1399 /* if we know peer doesn't support MP (mp_handling == DoesntHandleIPv6Routes)
1400 then don't add this parameter */
1401 if (config
->ipv6_prefix
.s6_addr
[0]
1402 && (peer
->mp_handling
== HandlingUnknown
1403 || peer
->mp_handling
== HandleIPv6Routes
))
1405 /* construct the param and capability */
1406 cap_mp_ipv6
.code
= BGP_CAP_CODE_MP
;
1407 cap_mp_ipv6
.len
= sizeof(mp_ipv6
);
1408 memcpy(&cap_mp_ipv6
.value
, &mp_ipv6
, cap_mp_ipv6
.len
);
1410 param_cap_mp_ipv6
.type
= BGP_PARAM_TYPE_CAPABILITY
;
1411 param_cap_mp_ipv6
.len
= 2 + sizeof(mp_ipv6
);
1412 memcpy(¶m_cap_mp_ipv6
.value
, &cap_mp_ipv6
, param_cap_mp_ipv6
.len
);
1414 data
.opt_len
= 2 + param_cap_mp_ipv6
.len
;
1415 memcpy(&data
.opt_params
, ¶m_cap_mp_ipv6
, data
.opt_len
);
1420 memcpy(peer
->outbuf
->packet
.data
, &data
, BGP_DATA_OPEN_SIZE
+ data
.opt_len
);
1421 len
+= BGP_DATA_OPEN_SIZE
+ data
.opt_len
;
1423 peer
->outbuf
->packet
.header
.len
= htons(len
);
1424 peer
->outbuf
->done
= 0;
1425 peer
->next_state
= OpenSent
;
1427 return bgp_write(peer
);
1430 /* send/buffer KEEPALIVE message */
1431 static int bgp_send_keepalive(struct bgp_peer
*peer
)
1433 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1434 sizeof(peer
->outbuf
->packet
.header
.marker
));
1436 peer
->outbuf
->packet
.header
.type
= BGP_MSG_KEEPALIVE
;
1437 peer
->outbuf
->packet
.header
.len
=
1438 htons(sizeof(peer
->outbuf
->packet
.header
));
1440 peer
->outbuf
->done
= 0;
1441 peer
->next_state
= (peer
->state
== OpenSent
) ? OpenConfirm
: peer
->state
;
1443 return bgp_write(peer
);
1446 /* send/buffer UPDATE message */
1447 static int bgp_send_update(struct bgp_peer
*peer
)
1449 uint16_t unf_len
= 0;
1451 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1452 struct bgp_route_list
*have
= peer
->routes
;
1453 struct bgp_route_list
*want
= peer
->routing
? bgp_routes
: 0;
1454 struct bgp_route_list
*e
= 0;
1455 struct bgp_route_list
*add
= 0;
1458 char *data
= (char *) &peer
->outbuf
->packet
.data
;
1460 /* need leave room for attr_len, bgp_path_attrs and one prefix */
1461 char *max
= (char *) &peer
->outbuf
->packet
.data
1462 + sizeof(peer
->outbuf
->packet
.data
)
1463 - sizeof(attr_len
) - peer
->path_attr_len
- sizeof(struct bgp_ip_prefix
);
1465 /* skip over unf_len */
1466 data
+= sizeof(unf_len
);
1467 len
+= sizeof(unf_len
);
1469 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1470 sizeof(peer
->outbuf
->packet
.header
.marker
));
1472 peer
->outbuf
->packet
.header
.type
= BGP_MSG_UPDATE
;
1474 peer
->update_routes
= 0; /* tentatively clear */
1476 /* find differences */
1477 while ((have
|| want
) && data
< (max
- sizeof(struct bgp_ip_prefix
)))
1481 ? memcmp(&have
->dest
, &want
->dest
, sizeof(have
->dest
))
1486 if (s
< 0) /* found one to delete */
1488 struct bgp_route_list
*tmp
= have
;
1491 s
= BGP_IP_PREFIX_SIZE(tmp
->dest
);
1492 memcpy(data
, &tmp
->dest
, s
);
1497 LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n",
1498 fmtaddr(tmp
->dest
.prefix
, 0), tmp
->dest
.len
, peer
->name
);
1505 peer
->routes
= have
;
1511 e
= have
; /* stash the last found to relink above */
1515 else if (s
> 0) /* addition reqd. */
1519 peer
->update_routes
= 1; /* only one add per packet */
1533 peer
->update_routes
= 1; /* more to do */
1535 /* anything changed? */
1536 if (!(unf_len
|| add
))
1539 /* go back and insert unf_len */
1540 unf_len
= htons(unf_len
);
1541 memcpy(&peer
->outbuf
->packet
.data
, &unf_len
, sizeof(unf_len
));
1545 if (!(e
= malloc(sizeof(*e
))))
1547 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
1548 fmtaddr(add
->dest
.prefix
, 0), add
->dest
.len
, strerror(errno
));
1553 memcpy(e
, add
, sizeof(*e
));
1555 peer
->routes
= bgp_insert_route(peer
->routes
, e
);
1557 attr_len
= htons(peer
->path_attr_len
);
1558 memcpy(data
, &attr_len
, sizeof(attr_len
));
1559 data
+= sizeof(attr_len
);
1560 len
+= sizeof(attr_len
);
1562 memcpy(data
, peer
->path_attrs
, peer
->path_attr_len
);
1563 data
+= peer
->path_attr_len
;
1564 len
+= peer
->path_attr_len
;
1566 s
= BGP_IP_PREFIX_SIZE(add
->dest
);
1567 memcpy(data
, &add
->dest
, s
);
1571 LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n",
1572 fmtaddr(add
->dest
.prefix
, 0), add
->dest
.len
, peer
->name
);
1577 memcpy(data
, &attr_len
, sizeof(attr_len
));
1578 data
+= sizeof(attr_len
);
1579 len
+= sizeof(attr_len
);
1582 peer
->outbuf
->packet
.header
.len
= htons(len
);
1583 peer
->outbuf
->done
= 0;
1585 return bgp_write(peer
);
1588 /* send/buffer UPDATE message for IPv6 routes */
1589 static int bgp_send_update6(struct bgp_peer
*peer
)
1592 uint16_t unreach_len
= 0;
1593 char *unreach_len_pos
;
1595 uint16_t len
= sizeof(peer
->outbuf
->packet
.header
);
1596 struct bgp_route6_list
*have
= peer
->routes6
;
1597 struct bgp_route6_list
*want
= peer
->routing
? bgp_routes6
: 0;
1598 struct bgp_route6_list
*e
= 0;
1599 struct bgp_route6_list
*add
= 0;
1601 char ipv6addr
[INET6_ADDRSTRLEN
];
1603 char *data
= (char *) &peer
->outbuf
->packet
.data
;
1605 /* need leave room for attr_len, bgp_path_attrs and one prefix */
1606 char *max
= (char *) &peer
->outbuf
->packet
.data
1607 + sizeof(peer
->outbuf
->packet
.data
)
1608 - sizeof(attr_len
) - peer
->path_attr_len_without_nexthop
1609 - BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
- sizeof(struct bgp_ip6_prefix
);
1611 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1612 sizeof(peer
->outbuf
->packet
.header
.marker
));
1614 peer
->outbuf
->packet
.header
.type
= BGP_MSG_UPDATE
;
1616 /* insert non-MP unfeasible routes length */
1617 memcpy(data
, &unreach_len
, sizeof(unreach_len
));
1618 /* skip over it and attr_len too; it will be filled when known */
1619 data
+= sizeof(unreach_len
) + sizeof(attr_len
);
1620 len
+= sizeof(unreach_len
) + sizeof(attr_len
);
1622 /* copy usual attributes */
1623 memcpy(data
, peer
->path_attrs
, peer
->path_attr_len_without_nexthop
);
1624 data
+= peer
->path_attr_len_without_nexthop
;
1625 attr_len
= peer
->path_attr_len_without_nexthop
;
1627 /* copy MP unreachable NLRI heading */
1628 memcpy(data
, peer
->mp_unreach_nlri_partial
,
1629 BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
);
1630 /* remember where to update this attr len */
1631 unreach_len_pos
= data
+ 2;
1632 data
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1633 attr_len
+= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1635 peer
->update_routes6
= 0; /* tentatively clear */
1637 /* find differences */
1638 while ((have
|| want
) && data
< (max
- sizeof(struct bgp_ip6_prefix
)))
1642 ? memcmp(&have
->dest
, &want
->dest
, sizeof(have
->dest
))
1647 if (s
< 0) /* found one to delete */
1649 struct bgp_route6_list
*tmp
= have
;
1652 s
= BGP_IP_PREFIX_SIZE(tmp
->dest
);
1653 memcpy(data
, &tmp
->dest
, s
);
1658 LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n",
1659 inet_ntop(AF_INET6
, &tmp
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1660 tmp
->dest
.len
, peer
->name
);
1667 peer
->routes6
= have
;
1673 e
= have
; /* stash the last found to relink above */
1677 else if (s
> 0) /* addition reqd. */
1681 peer
->update_routes6
= 1; /* only one add per packet */
1695 peer
->update_routes6
= 1; /* more to do */
1697 /* anything changed? */
1698 if (!(unreach_len
|| add
))
1703 /* go back and insert MP unreach_len */
1704 unreach_len
+= sizeof(struct bgp_attr_mp_unreach_nlri_partial
);
1705 unreach_len
= htons(unreach_len
);
1706 memcpy(unreach_len_pos
, &unreach_len
, sizeof(unreach_len
));
1710 /* we can remove this attribute, then */
1711 data
-= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1712 attr_len
-= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE
;
1717 if (!(e
= malloc(sizeof(*e
))))
1719 LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
1720 inet_ntop(AF_INET6
, &add
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1721 add
->dest
.len
, strerror(errno
));
1726 memcpy(e
, add
, sizeof(*e
));
1728 peer
->routes6
= bgp_insert_route6(peer
->routes6
, e
);
1730 /* copy MP reachable NLRI heading */
1731 memcpy(data
, peer
->mp_reach_nlri_partial
,
1732 BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
);
1733 /* with proper len */
1734 reach_len
= BGP_IP_PREFIX_SIZE(add
->dest
);
1735 data
[2] = sizeof(struct bgp_attr_mp_reach_nlri_partial
) + reach_len
;
1736 data
+= BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
;
1737 attr_len
+= BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE
;
1739 memcpy(data
, &add
->dest
, reach_len
);
1741 attr_len
+= reach_len
;
1743 LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n",
1744 inet_ntop(AF_INET6
, &add
->dest
.prefix
, ipv6addr
, INET6_ADDRSTRLEN
),
1745 add
->dest
.len
, peer
->name
);
1748 /* update len with attributes we added */
1751 /* go back and insert attr_len */
1752 attr_len
= htons(attr_len
);
1753 memcpy((char *)&peer
->outbuf
->packet
.data
+ 2, &attr_len
, sizeof(attr_len
));
1755 peer
->outbuf
->packet
.header
.len
= htons(len
);
1756 peer
->outbuf
->done
= 0;
1758 return bgp_write(peer
);
1761 /* send/buffer NOTIFICATION message */
1762 static int bgp_send_notification(struct bgp_peer
*peer
, uint8_t code
,
1765 struct bgp_data_notification data
;
1768 data
.error_code
= code
;
1769 len
+= sizeof(data
.error_code
);
1771 data
.error_subcode
= subcode
;
1772 len
+= sizeof(data
.error_code
);
1774 memset(peer
->outbuf
->packet
.header
.marker
, 0xff,
1775 sizeof(peer
->outbuf
->packet
.header
.marker
));
1777 peer
->outbuf
->packet
.header
.type
= BGP_MSG_NOTIFICATION
;
1778 peer
->outbuf
->packet
.header
.len
=
1779 htons(sizeof(peer
->outbuf
->packet
.header
) + len
);
1781 memcpy(peer
->outbuf
->packet
.data
, &data
, len
);
1783 peer
->outbuf
->done
= 0;
1784 peer
->next_state
= code
== BGP_ERR_CEASE
? Disabled
: Idle
;
1786 /* we're dying; ignore any pending input */
1787 peer
->inbuf
->packet
.header
.len
= 0;
1788 peer
->inbuf
->done
= 0;
1790 return bgp_write(peer
);