X-Git-Url: http://git.sameswireless.fr/l2tpns.git/blobdiff_plain/272e831e8071da5296e8dd2061f8a166fd70fd07..02611e54fc55643ec109b255707ce9832e005ddf:/bgp.c diff --git a/bgp.c b/bgp.c index 8e5e377..10f06a3 100644 --- a/bgp.c +++ b/bgp.c @@ -10,7 +10,7 @@ * nor RFC2385 (which requires a kernel patch on 2.4 kernels). */ -char const *cvs_id_bgp = "$Id: bgp.c,v 1.4 2004/09/02 04:18:07 fred_nerk Exp $"; +char const *cvs_id_bgp = "$Id: bgp.c,v 1.12 2005/09/02 23:39:36 bodea Exp $"; #include #include @@ -34,8 +34,7 @@ static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head, struct bgp_route_list *new); static void bgp_free_routes(struct bgp_route_list *routes); -static char const *bgp_state_str(enum bgp_state state); -static char const *bgp_msg_type_str(u8 type); +static char const *bgp_msg_type_str(uint8_t type); static int bgp_connect(struct bgp_peer *peer); static int bgp_handle_connect(struct bgp_peer *peer); static int bgp_write(struct bgp_peer *peer); @@ -44,9 +43,16 @@ static int bgp_handle_input(struct bgp_peer *peer); static int bgp_send_open(struct bgp_peer *peer); static int bgp_send_keepalive(struct bgp_peer *peer); static int bgp_send_update(struct bgp_peer *peer); -static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode); +static int bgp_send_notification(struct bgp_peer *peer, uint8_t code, + uint8_t subcode); +static int bgp_send_notification_full(struct bgp_peer *peer, uint8_t code, + uint8_t subcode, char *notification_data, uint16_t data_len); -static u16 our_as; +static uint16_t our_as; +static struct bgp_route_list *bgp_routes = 0; + +int bgp_configured = 0; +struct bgp_peer *bgp_peers = 0; /* prepare peer structure, globals */ int bgp_setup(int as) @@ -66,11 +72,15 @@ int bgp_setup(int as) if (!((peer->outbuf = malloc(sizeof(*peer->outbuf))) && (peer->inbuf = malloc(sizeof(*peer->inbuf))))) { - log(0, 0, 0, 0, "Can't allocate buffers for bgp peer (%s)\n", + LOG(0, 0, 0, "Can't allocate buffers for bgp peer (%s)\n", strerror(errno)); return 0; } + + peer->edata.type = FD_TYPE_BGP; + peer->edata.index = i; + peer->events = 0; } if (as < 1) @@ -86,7 +96,8 @@ int bgp_setup(int as) } /* start connection with a peer */ -int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) +int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, + int hold, int enable) { struct hostent *h; int ibgp; @@ -95,8 +106,8 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) char path_attrs[64]; char *p = path_attrs; in_addr_t ip; - u32 metric = htonl(BGP_METRIC); - u32 no_export = htonl(BGP_COMMUNITY_NO_EXPORT); + uint32_t metric = htonl(BGP_METRIC); + uint32_t no_export = htonl(BGP_COMMUNITY_NO_EXPORT); if (!our_as) return 0; @@ -108,7 +119,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) if (!(h = gethostbyname(name)) || h->h_addrtype != AF_INET) { - log(0, 0, 0, 0, "Can't get address for BGP peer %s (%s)\n", + LOG(0, 0, 0, "Can't get address for BGP peer %s (%s)\n", name, h ? "no address" : hstrerror(h_errno)); return 0; @@ -118,6 +129,16 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) peer->as = as > 0 ? as : our_as; ibgp = peer->as == our_as; + /* set initial timer values */ + peer->init_keepalive = keepalive == -1 ? BGP_KEEPALIVE_TIME : keepalive; + peer->init_hold = hold == -1 ? BGP_HOLD_TIME : hold; + + if (peer->init_hold < 3) + peer->init_hold = 3; + + if (peer->init_keepalive * 3 > peer->init_hold) + peer->init_keepalive = peer->init_hold / 3; + /* clear buffers, go to Idle state */ peer->next_state = Idle; bgp_clear(peer); @@ -157,9 +178,9 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) { /* just our AS */ struct { - u8 type; - u8 len; - u16 value; + uint8_t type; + uint8_t len; + uint16_t value; } as_path = { BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE, 1, @@ -172,15 +193,6 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) ADD_ATTRIBUTE(); - /* NEXT_HOP */ - a.flags = BGP_PATH_ATTR_FLAG_TRANS; - a.code = BGP_PATH_ATTR_CODE_NEXT_HOP; - ip = my_address; /* we're it */ - a.data.s.len = sizeof(ip); - memcpy(a.data.s.value, &ip, sizeof(ip)); - - ADD_ATTRIBUTE(); - /* MULTI_EXIT_DISC */ a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL; a.code = BGP_PATH_ATTR_CODE_MULTI_EXIT_DISC; @@ -191,7 +203,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) if (ibgp) { - u32 local_pref = htonl(BGP_LOCAL_PREF); + uint32_t local_pref = htonl(BGP_LOCAL_PREF); /* LOCAL_PREF */ a.flags = BGP_PATH_ATTR_FLAG_TRANS; @@ -210,9 +222,21 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) ADD_ATTRIBUTE(); + /* remember the len before adding NEXT_HOP */ + peer->path_attr_len_without_nexthop = peer->path_attr_len; + + /* NEXT_HOP */ + a.flags = BGP_PATH_ATTR_FLAG_TRANS; + a.code = BGP_PATH_ATTR_CODE_NEXT_HOP; + ip = my_address; /* we're it */ + a.data.s.len = sizeof(ip); + memcpy(a.data.s.value, &ip, sizeof(ip)); + + ADD_ATTRIBUTE(); + if (!(peer->path_attrs = malloc(peer->path_attr_len))) { - log(0, 0, 0, 0, "Can't allocate path_attrs for %s (%s)\n", + LOG(0, 0, 0, "Can't allocate path_attrs for %s (%s)\n", name, strerror(errno)); return 0; @@ -220,7 +244,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable) memcpy(peer->path_attrs, path_attrs, peer->path_attr_len); - log(4, 0, 0, 0, "Initiating BGP connection to %s (routing %s)\n", + LOG(4, 0, 0, "Initiating BGP connection to %s (routing %s)\n", name, enable ? "enabled" : "suspended"); /* we have at least one peer configured */ @@ -241,9 +265,11 @@ static void bgp_clear(struct bgp_peer *peer) } peer->keepalive_time = 0; - peer->hold = 0; peer->expire_time = 0; + peer->keepalive = peer->init_keepalive; + peer->hold = peer->init_hold; + bgp_free_routes(peer->routes); peer->routes = 0; @@ -253,13 +279,14 @@ static void bgp_clear(struct bgp_peer *peer) peer->inbuf->done = 0; peer->cli_flag = 0; + peer->events = 0; if (peer->state != peer->next_state) { peer->state = peer->next_state; peer->state_time = time_now; - log(4, 0, 0, 0, "BGP peer %s: state %s\n", peer->name, + LOG(4, 0, 0, "BGP peer %s: state %s\n", peer->name, bgp_state_str(peer->next_state)); } } @@ -267,14 +294,14 @@ static void bgp_clear(struct bgp_peer *peer) /* initiate a clean shutdown */ void bgp_stop(struct bgp_peer *peer) { - log(4, 0, 0, 0, "Terminating BGP connection to %s\n", peer->name); + LOG(4, 0, 0, "Terminating BGP connection to %s\n", peer->name); bgp_send_notification(peer, BGP_ERR_CEASE, 0); } /* drop connection (if any) and set state to Disabled */ void bgp_halt(struct bgp_peer *peer) { - log(4, 0, 0, 0, "Aborting BGP connection to %s\n", peer->name); + LOG(4, 0, 0, "Aborting BGP connection to %s\n", peer->name); peer->next_state = Disabled; bgp_clear(peer); } @@ -309,7 +336,7 @@ static void bgp_set_retry(struct bgp_peer *peer) static void bgp_cidr(in_addr_t ip, in_addr_t mask, struct bgp_ip_prefix *pfx) { int i; - u32 b; + uint32_t b; /* convert to prefix notation */ pfx->len = 32; @@ -384,8 +411,8 @@ int bgp_add_route(in_addr_t ip, in_addr_t mask) /* insert into route list; sorted */ if (!(r = malloc(sizeof(*r)))) { - log(0, 0, 0, 0, "Can't allocate route for %s/%d (%s)\n", - inet_toa(add.dest.prefix), add.dest.len, strerror(errno)); + LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n", + fmtaddr(add.dest.prefix, 0), add.dest.len, strerror(errno)); return 0; } @@ -398,8 +425,8 @@ int bgp_add_route(in_addr_t ip, in_addr_t mask) if (bgp_peers[i].state == Established) bgp_peers[i].update_routes = 1; - log(4, 0, 0, 0, "Registered BGP route %s/%d\n", inet_toa(add.dest.prefix), - add.dest.len); + LOG(4, 0, 0, "Registered BGP route %s/%d\n", + fmtaddr(add.dest.prefix, 0), add.dest.len); return 1; } @@ -447,8 +474,8 @@ int bgp_del_route(in_addr_t ip, in_addr_t mask) if (bgp_peers[i].state == Established) bgp_peers[i].update_routes = 1; - log(4, 0, 0, 0, "Removed BGP route %s/%d\n", inet_toa(del.dest.prefix), - del.dest.len); + LOG(4, 0, 0, "Removed BGP route %s/%d\n", + fmtaddr(del.dest.prefix, 0), del.dest.len); return 1; } @@ -467,133 +494,163 @@ void bgp_enable_routing(int enable) bgp_peers[i].update_routes = 1; } - log(4, 0, 0, 0, "%s BGP routing\n", enable ? "Enabled" : "Suspended"); + LOG(4, 0, 0, "%s BGP routing\n", enable ? "Enabled" : "Suspended"); } -/* return a bitmask indicating if the socket should be added to the - read set (1) and or write set (2) for select */ -int bgp_select_state(struct bgp_peer *peer) +#ifdef HAVE_EPOLL +# include +#else +# include "fake_epoll.h" +#endif + +/* return a bitmask of the events required to poll this peer's fd */ +int bgp_set_poll() { - int flags = 0; + int i; if (!bgp_configured) return 0; - if (peer->state == Disabled || peer->state == Idle) - return 0; + for (i = 0; i < BGP_NUM_PEERS; i++) + { + struct bgp_peer *peer = &bgp_peers[i]; + int events = 0; - if (peer->inbuf->done < BGP_MAX_PACKET_SIZE) - flags |= 1; + if (peer->state == Disabled || peer->state == Idle) + continue; - if (peer->state == Connect || /* connection in progress */ - peer->update_routes || /* routing updates */ - peer->outbuf->packet.header.len) /* pending output */ - flags |= 2; + if (peer->inbuf->done < BGP_MAX_PACKET_SIZE) + events |= EPOLLIN; + + if (peer->state == Connect || /* connection in progress */ + peer->update_routes || /* routing updates */ + peer->outbuf->packet.header.len) /* pending output */ + events |= EPOLLOUT; + + if (peer->events != events) + { + struct epoll_event ev; - return flags; + ev.events = peer->events = events; + ev.data.ptr = &peer->edata; + epoll_ctl(epollfd, EPOLL_CTL_MOD, peer->sock, &ev); + } + } + + return 1; } -/* process bgp peer */ -int bgp_process(struct bgp_peer *peer, int readable, int writable) +/* process bgp events/timers */ +int bgp_process(uint32_t events[]) { + int i; + if (!bgp_configured) return 0; - if (*peer->name && peer->cli_flag == BGP_CLI_RESTART) - return bgp_restart(peer); + for (i = 0; i < BGP_NUM_PEERS; i++) + { + struct bgp_peer *peer = &bgp_peers[i]; - if (peer->state == Disabled) - return 1; + if (*peer->name && peer->cli_flag == BGP_CLI_RESTART) + { + bgp_restart(peer); + continue; + } - if (peer->cli_flag) - { - switch (peer->cli_flag) + if (peer->state == Disabled) + continue; + + if (peer->cli_flag) { - case BGP_CLI_SUSPEND: - if (peer->routing) + switch (peer->cli_flag) { - peer->routing = 0; - if (peer->state == Established) - peer->update_routes = 1; - } + case BGP_CLI_SUSPEND: + if (peer->routing) + { + peer->routing = 0; + if (peer->state == Established) + peer->update_routes = 1; + } - break; + break; - case BGP_CLI_ENABLE: - if (!peer->routing) - { - peer->routing = 1; - if (peer->state == Established) - peer->update_routes = 1; + case BGP_CLI_ENABLE: + if (!peer->routing) + { + peer->routing = 1; + if (peer->state == Established) + peer->update_routes = 1; + } + + break; } - break; + peer->cli_flag = 0; } - peer->cli_flag = 0; - } - - /* handle empty/fill of buffers */ - if (writable) - { - int r = 1; - if (peer->state == Connect) - r = bgp_handle_connect(peer); - else if (peer->outbuf->packet.header.len) - r = bgp_write(peer); + /* handle empty/fill of buffers */ + if (events[i] & EPOLLOUT) + { + int r = 1; + if (peer->state == Connect) + r = bgp_handle_connect(peer); + else if (peer->outbuf->packet.header.len) + r = bgp_write(peer); - if (!r) - return 0; - } + if (!r) + continue; + } - if (readable) - { - if (!bgp_read(peer)) - return 0; - } + if (events[i] & (EPOLLIN|EPOLLHUP)) + { + if (!bgp_read(peer)) + continue; + } - /* process input buffer contents */ - while (peer->inbuf->done >= sizeof(peer->inbuf->packet.header) - && !peer->outbuf->packet.header.len) /* may need to queue a response */ - { - if (bgp_handle_input(peer) < 0) - return 0; - } + /* process input buffer contents */ + while (peer->inbuf->done >= sizeof(peer->inbuf->packet.header) + && !peer->outbuf->packet.header.len) /* may need to queue a response */ + { + if (bgp_handle_input(peer) < 0) + continue; + } - /* process pending updates */ - if (peer->update_routes - && !peer->outbuf->packet.header.len) /* ditto */ - { - if (!bgp_send_update(peer)) - return 0; - } + /* process pending updates */ + if (peer->update_routes + && !peer->outbuf->packet.header.len) /* ditto */ + { + if (!bgp_send_update(peer)) + continue; + } - /* process timers */ - if (peer->state == Established) - { - if (time_now > peer->expire_time) + /* process timers */ + if (peer->state == Established) { - log(1, 0, 0, 0, "No message from BGP peer %s in %ds\n", - peer->name, peer->hold); + if (time_now > peer->expire_time) + { + LOG(1, 0, 0, "No message from BGP peer %s in %ds\n", + peer->name, peer->hold); - bgp_send_notification(peer, BGP_ERR_HOLD_TIMER_EXP, 0); - return 0; - } + bgp_send_notification(peer, BGP_ERR_HOLD_TIMER_EXP, 0); + continue; + } - if (time_now > peer->keepalive_time && !peer->outbuf->packet.header.len) - bgp_send_keepalive(peer); - } - else if (peer->state == Idle) - { - if (time_now > peer->retry_time) - return bgp_connect(peer); - } - else if (time_now > peer->state_time + BGP_KEEPALIVE_TIME) - { - log(1, 0, 0, 0, "%s timer expired for BGP peer %s\n", - bgp_state_str(peer->state), peer->name); + if (time_now > peer->keepalive_time && !peer->outbuf->packet.header.len) + bgp_send_keepalive(peer); + } + else if (peer->state == Idle) + { + if (time_now > peer->retry_time) + bgp_connect(peer); + } + else if (time_now > peer->state_time + BGP_STATE_TIME) + { + LOG(1, 0, 0, "%s timer expired for BGP peer %s\n", + bgp_state_str(peer->state), peer->name); - return bgp_restart(peer); + bgp_restart(peer); + } } return 1; @@ -610,7 +667,7 @@ static void bgp_free_routes(struct bgp_route_list *routes) } } -static char const *bgp_state_str(enum bgp_state state) +char const *bgp_state_str(enum bgp_state state) { switch (state) { @@ -626,7 +683,7 @@ static char const *bgp_state_str(enum bgp_state state) return "?"; } -static char const *bgp_msg_type_str(u8 type) +static char const *bgp_msg_type_str(uint8_t type) { switch (type) { @@ -644,13 +701,14 @@ static int bgp_connect(struct bgp_peer *peer) { static int bgp_port = 0; struct sockaddr_in addr; + struct epoll_event ev; if (!bgp_port) { struct servent *serv; if (!(serv = getservbyname("bgp", "tcp"))) { - log(0, 0, 0, 0, "Can't get bgp service (%s)\n", strerror(errno)); + LOG(0, 0, 0, "Can't get bgp service (%s)\n", strerror(errno)); return 0; } @@ -659,13 +717,18 @@ static int bgp_connect(struct bgp_peer *peer) if ((peer->sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { - log(0, 0, 0, 0, "Can't create a socket for BGP peer %s (%s)\n", + LOG(0, 0, 0, "Can't create a socket for BGP peer %s (%s)\n", peer->name, strerror(errno)); peer->state = peer->next_state = Disabled; return 0; } + /* add to poll set */ + ev.events = peer->events = EPOLLOUT; + ev.data.ptr = &peer->edata; + epoll_ctl(epollfd, EPOLL_CTL_ADD, peer->sock, &ev); + /* set to non-blocking */ fcntl(peer->sock, F_SETFL, fcntl(peer->sock, F_GETFL, 0) | O_NONBLOCK); @@ -682,7 +745,7 @@ static int bgp_connect(struct bgp_peer *peer) if (errno != EINPROGRESS) { - log(1, 0, 0, 0, "Can't connect to BGP peer %s (%s)\n", + LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n", inet_ntoa(addr.sin_addr), strerror(errno)); bgp_set_retry(peer); @@ -692,7 +755,7 @@ static int bgp_connect(struct bgp_peer *peer) peer->state = Connect; peer->state_time = time_now; - log(4, 0, 0, 0, "BGP peer %s: state Connect\n", peer->name); + LOG(4, 0, 0, "BGP peer %s: state Connect\n", peer->name); return 1; } @@ -700,7 +763,9 @@ static int bgp_connect(struct bgp_peer *peer) peer->state_time = time_now; peer->retry_time = peer->retry_count = 0; - log(4, 0, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr.sin_addr)); + LOG(4, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr.sin_addr)); + + peer->handle_ipv6_routes = 0; return bgp_send_open(peer); } @@ -709,11 +774,11 @@ static int bgp_connect(struct bgp_peer *peer) static int bgp_handle_connect(struct bgp_peer *peer) { int err = 0; - int len = sizeof(int); + socklen_t len = sizeof(int); getsockopt(peer->sock, SOL_SOCKET, SO_ERROR, &err, &len); if (err) { - log(1, 0, 0, 0, "Can't connect to BGP peer %s (%s)\n", peer->name, + LOG(1, 0, 0, "Can't connect to BGP peer %s (%s)\n", peer->name, strerror(err)); bgp_set_retry(peer); @@ -723,7 +788,9 @@ static int bgp_handle_connect(struct bgp_peer *peer) peer->state = Active; peer->state_time = time_now; - log(4, 0, 0, 0, "BGP peer %s: state Active\n", peer->name); + LOG(4, 0, 0, "BGP peer %s: state Active\n", peer->name); + + peer->handle_ipv6_routes = 0; return bgp_send_open(peer); } @@ -744,9 +811,9 @@ static int bgp_write(struct bgp_peer *peer) return 1; if (errno == EPIPE) - log(1, 0, 0, 0, "Connection to BGP peer %s closed\n", peer->name); + LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer->name); else - log(1, 0, 0, 0, "Can't write to BGP peer %s (%s)\n", peer->name, + LOG(1, 0, 0, "Can't write to BGP peer %s (%s)\n", peer->name, strerror(errno)); bgp_set_retry(peer); @@ -759,14 +826,14 @@ static int bgp_write(struct bgp_peer *peer) return 1; } - log(4, 0, 0, 0, "Sent %s to BGP peer %s\n", + LOG(4, 0, 0, "Sent %s to BGP peer %s\n", bgp_msg_type_str(peer->outbuf->packet.header.type), peer->name); peer->outbuf->packet.header.len = 0; peer->outbuf->done = 0; if (peer->state == Established) - peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME; + peer->keepalive_time = time_now + peer->keepalive; if (peer->state != peer->next_state) { @@ -779,7 +846,7 @@ static int bgp_write(struct bgp_peer *peer) peer->state = peer->next_state; peer->state_time = time_now; - log(4, 0, 0, 0, "BGP peer %s: state %s\n", peer->name, + LOG(4, 0, 0, "BGP peer %s: state %s\n", peer->name, bgp_state_str(peer->state)); } @@ -796,7 +863,7 @@ static int bgp_read(struct bgp_peer *peer) { if (!r) { - log(1, 0, 0, 0, "Connection to BGP peer %s closed\n", peer->name); + LOG(1, 0, 0, "Connection to BGP peer %s closed\n", peer->name); } else { @@ -806,7 +873,7 @@ static int bgp_read(struct bgp_peer *peer) if (errno == EAGAIN) return 1; - log(1, 0, 0, 0, "Can't read from BGP peer %s (%s)\n", peer->name, + LOG(1, 0, 0, "Can't read from BGP peer %s (%s)\n", peer->name, strerror(errno)); } @@ -826,7 +893,7 @@ static int bgp_handle_input(struct bgp_peer *peer) if (len > BGP_MAX_PACKET_SIZE) { - log(1, 0, 0, 0, "Bad header length from BGP %s\n", peer->name); + LOG(1, 0, 0, "Bad header length from BGP %s\n", peer->name); bgp_send_notification(peer, BGP_ERR_HEADER, BGP_ERR_HDR_BAD_LEN); return 0; } @@ -834,7 +901,7 @@ static int bgp_handle_input(struct bgp_peer *peer) if (peer->inbuf->done < len) return 0; - log(4, 0, 0, 0, "Received %s from BGP peer %s\n", + LOG(4, 0, 0, "Received %s from BGP peer %s\n", bgp_msg_type_str(p->header.type), peer->name); switch (p->header.type) @@ -842,13 +909,20 @@ static int bgp_handle_input(struct bgp_peer *peer) case BGP_MSG_OPEN: { struct bgp_data_open data; + int hold; int i; + off_t param_offset, capability_offset; + struct bgp_opt_param *param; + uint8_t capabilities_len; + char *capabilities = NULL; + struct bgp_capability *capability; + struct bgp_mp_cap_param *mp_cap; for (i = 0; i < sizeof(p->header.marker); i++) { if ((unsigned char) p->header.marker[i] != 0xff) { - log(1, 0, 0, 0, "Invalid marker from BGP peer %s\n", + LOG(1, 0, 0, "Invalid marker from BGP peer %s\n", peer->name); bgp_send_notification(peer, BGP_ERR_HEADER, @@ -860,7 +934,7 @@ static int bgp_handle_input(struct bgp_peer *peer) if (peer->state != OpenSent) { - log(1, 0, 0, 0, "OPEN from BGP peer %s in %s state\n", + LOG(1, 0, 0, "OPEN from BGP peer %s in %s state\n", peer->name, bgp_state_str(peer->state)); bgp_send_notification(peer, BGP_ERR_FSM, 0); @@ -871,7 +945,7 @@ static int bgp_handle_input(struct bgp_peer *peer) if (data.version != BGP_VERSION) { - log(1, 0, 0, 0, "Bad version (%d) sent by BGP peer %s\n", + LOG(1, 0, 0, "Bad version (%d) sent by BGP peer %s\n", (int) data.version, peer->name); bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_VERSION); @@ -880,7 +954,7 @@ static int bgp_handle_input(struct bgp_peer *peer) if (ntohs(data.as) != peer->as) { - log(1, 0, 0, 0, "Bad AS sent by BGP peer %s (got %d, " + LOG(1, 0, 0, "Bad AS sent by BGP peer %s (got %d, " "expected %d)\n", peer->name, (int) htons(data.as), (int) peer->as); @@ -888,19 +962,108 @@ static int bgp_handle_input(struct bgp_peer *peer) return 0; } - if ((peer->hold = ntohs(data.hold_time)) < 10) + if ((hold = ntohs(data.hold_time)) < 3) { - log(1, 0, 0, 0, "Bad hold time (%d) from BGP peer %s\n", - peer->hold, peer->name); + LOG(1, 0, 0, "Bad hold time (%d) from BGP peer %s\n", + hold, peer->name); bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_HOLD_TIME); return 0; } + /* pick lowest hold time */ + if (hold < peer->hold) + peer->hold = hold; + + /* adjust our keepalive based on negotiated hold value */ + if (peer->keepalive * 3 > peer->hold) + peer->keepalive = peer->hold / 3; + + /* check for optional parameters */ + /* 2 is for the size of type + len (both uint8_t) */ + for (param_offset = 0; + param_offset < data.opt_len; + param_offset += 2 + param->len) + { + param = (struct bgp_opt_param *)(&data.opt_params + param_offset); + + /* sensible check */ + if (data.opt_len - param_offset < 2 + || param->len > data.opt_len - param_offset - 2) + { + LOG(1, 0, 0, "Malformed Optional Parameter list from BGP peer %s\n", + peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_UNSPEC); + return 0; + } + + /* we know only one parameter type */ + if (param->type != BGP_PARAM_TYPE_CAPABILITY) + { + LOG(1, 0, 0, "Unsupported Optional Parameter type %d from BGP peer %s\n", + param->type, peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_PARAM); + return 0; + } + + capabilities_len = param->len; + capabilities = (char *)¶m->value; + } + + /* look for BGP multiprotocol capability */ + if (capabilities) + { + for (capability_offset = 0; + capability_offset < capabilities_len; + capability_offset += 2 + capability->len) + { + capability = (struct bgp_capability *)(capabilities + capability_offset); + + /* sensible check */ + if (capabilities_len - capability_offset < 2 + || capability->len > capabilities_len - capability_offset - 2) + { + LOG(1, 0, 0, "Malformed Capabilities list from BGP peer %s\n", + peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_UNSPEC); + return 0; + } + + /* we only know one capability code */ + if (capability->code != BGP_CAP_CODE_MP + && capability->len != sizeof(struct bgp_mp_cap_param)) + { + LOG(4, 0, 0, "Unsupported Capability code %d from BGP peer %s\n", + capability->code, peer->name); + + bgp_send_notification_full(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_CAP, + (char *)capability, 2 + capability->len); + /* we don't terminate, still; we just jump to the next one */ + continue; + } + + mp_cap = (struct bgp_mp_cap_param *)&capability->value; + /* the only tuple we support */ + if (ntohs(mp_cap->afi) != AF_INET6 && mp_cap->safi != BGP_MP_SAFI_UNICAST) + { + LOG(4, 0, 0, "Unsupported multiprotocol AFI %d and SAFI %d from BGP peer %s\n", + mp_cap->afi, mp_cap->safi, peer->name); + + bgp_send_notification_full(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_CAP, + (char *)capability, 2 + capability->len); + /* we don't terminate, still; we just jump to the next one */ + continue; + } + + peer->handle_ipv6_routes = 1; + } + } + /* next transition requires an exchange of keepalives */ bgp_send_keepalive(peer); - - /* FIXME: may need to check for optional params */ } break; @@ -910,12 +1073,12 @@ static int bgp_handle_input(struct bgp_peer *peer) { peer->state = peer->next_state = Established; peer->state_time = time_now; - peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME; + peer->keepalive_time = time_now + peer->keepalive; peer->update_routes = 1; peer->retry_count = 0; peer->retry_time = 0; - log(4, 0, 0, 0, "BGP peer %s: state Established\n", peer->name); + LOG(4, 0, 0, "BGP peer %s: state Established\n", peer->name); } break; @@ -928,13 +1091,24 @@ static int bgp_handle_input(struct bgp_peer *peer) if (notification->error_code == BGP_ERR_CEASE) { - log(4, 0, 0, 0, "BGP peer %s sent CEASE\n", peer->name); - bgp_halt(peer); + LOG(4, 0, 0, "BGP peer %s sent CEASE\n", peer->name); + bgp_restart(peer); return 0; } + if (notification->error_code == BGP_ERR_OPEN + && notification->error_subcode == BGP_ERR_OPN_UNSUP_CAP) + { + /* the only capability we advertise is this one, so upon receiving + an "unsupported capability" message, we disable IPv6 routes for + this peer */ + LOG(4, 0, 0, "BGP peer %s doesn't support IPv6 routes advertisement\n", peer->name); + peer->handle_ipv6_routes = 0; + break; + } + /* FIXME: should handle more notifications */ - log(4, 0, 0, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n", + LOG(4, 0, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n", peer->name, (int) notification->error_code); } @@ -963,7 +1137,10 @@ static int bgp_handle_input(struct bgp_peer *peer) static int bgp_send_open(struct bgp_peer *peer) { struct bgp_data_open data; - u16 len = sizeof(peer->outbuf->packet.header); + struct bgp_mp_cap_param mp_ipv6 = { htons(AF_INET6), 0, BGP_MP_SAFI_UNICAST }; + struct bgp_capability cap_mp_ipv6; + struct bgp_opt_param param_cap_mp_ipv6; + uint16_t len = sizeof(peer->outbuf->packet.header); memset(peer->outbuf->packet.header.marker, 0xff, sizeof(peer->outbuf->packet.header.marker)); @@ -972,9 +1149,20 @@ static int bgp_send_open(struct bgp_peer *peer) data.version = BGP_VERSION; data.as = htons(our_as); - data.hold_time = htons(BGP_HOLD_TIME); + data.hold_time = htons(peer->hold); data.identifier = my_address; - data.opt_len = 0; + + /* construct the param and capability */ + cap_mp_ipv6.code = BGP_CAP_CODE_MP; + cap_mp_ipv6.len = sizeof(mp_ipv6); + memcpy(&cap_mp_ipv6.value, &mp_ipv6, cap_mp_ipv6.len); + + param_cap_mp_ipv6.type = BGP_PARAM_TYPE_CAPABILITY; + param_cap_mp_ipv6.len = 2 + sizeof(mp_ipv6); + memcpy(¶m_cap_mp_ipv6.value, &cap_mp_ipv6, param_cap_mp_ipv6.len); + + data.opt_len = 2 + param_cap_mp_ipv6.len; + memcpy(&data.opt_params, ¶m_cap_mp_ipv6, data.opt_len); memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE); len += BGP_DATA_OPEN_SIZE; @@ -1005,9 +1193,9 @@ static int bgp_send_keepalive(struct bgp_peer *peer) /* send/buffer UPDATE message */ static int bgp_send_update(struct bgp_peer *peer) { - u16 unf_len = 0; - u16 attr_len; - u16 len = sizeof(peer->outbuf->packet.header); + uint16_t unf_len = 0; + uint16_t attr_len; + uint16_t len = sizeof(peer->outbuf->packet.header); struct bgp_route_list *have = peer->routes; struct bgp_route_list *want = peer->routing ? bgp_routes : 0; struct bgp_route_list *e = 0; @@ -1053,8 +1241,8 @@ static int bgp_send_update(struct bgp_peer *peer) unf_len += s; len += s; - log(5, 0, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n", - inet_toa(tmp->dest.prefix), tmp->dest.len, peer->name); + LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n", + fmtaddr(tmp->dest.prefix, 0), tmp->dest.len, peer->name); free(tmp); @@ -1103,8 +1291,8 @@ static int bgp_send_update(struct bgp_peer *peer) { if (!(e = malloc(sizeof(*e)))) { - log(0, 0, 0, 0, "Can't allocate route for %s/%d (%s)\n", - inet_toa(add->dest.prefix), add->dest.len, strerror(errno)); + LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n", + fmtaddr(add->dest.prefix, 0), add->dest.len, strerror(errno)); return 0; } @@ -1127,8 +1315,8 @@ static int bgp_send_update(struct bgp_peer *peer) data += s; len += s; - log(5, 0, 0, 0, "Advertising route %s/%d to BGP peer %s\n", - inet_toa(add->dest.prefix), add->dest.len, peer->name); + LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n", + fmtaddr(add->dest.prefix, 0), add->dest.len, peer->name); } else { @@ -1145,10 +1333,17 @@ static int bgp_send_update(struct bgp_peer *peer) } /* send/buffer NOTIFICATION message */ -static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode) +static int bgp_send_notification(struct bgp_peer *peer, uint8_t code, + uint8_t subcode) +{ + return bgp_send_notification_full(peer, code, subcode, NULL, 0); +} + +static int bgp_send_notification_full(struct bgp_peer *peer, uint8_t code, + uint8_t subcode, char *notification_data, uint16_t data_len) { struct bgp_data_notification data; - u16 len = 0; + uint16_t len = 0; data.error_code = code; len += sizeof(data.error_code); @@ -1156,6 +1351,9 @@ static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode) data.error_subcode = subcode; len += sizeof(data.error_code); + memcpy(data.data, notification_data, data_len); + len += data_len; + memset(peer->outbuf->packet.header.marker, 0xff, sizeof(peer->outbuf->packet.header.marker)); @@ -1174,159 +1372,3 @@ static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode) return bgp_write(peer); } - -/* CLI stuff */ - -#include - -int cmd_show_bgp(struct cli_def *cli, char *command, char **argv, int argc) -{ - int i; - int hdr = 0; - char *addr; - - if (!bgp_configured) - return CLI_OK; - - if (CLI_HELP_REQUESTED) - return cli_arg_help(cli, 1, - "A.B.C.D", "BGP peer address", - "NAME", "BGP peer name", - NULL); - - cli_print(cli, "BGPv%d router identifier %s, local AS number %d, " - "hold time %ds", BGP_VERSION, inet_toa(my_address), (int) our_as, - BGP_HOLD_TIME); - - time(&time_now); - - for (i = 0; i < BGP_NUM_PEERS; i++) - { - if (!*bgp_peers[i].name) - continue; - - addr = inet_toa(bgp_peers[i].addr); - if (argc && strcmp(addr, argv[0]) && - strncmp(bgp_peers[i].name, argv[0], strlen(argv[0]))) - continue; - - if (!hdr++) - { - cli_print(cli, ""); - cli_print(cli, "Peer AS Address " - "State Retries Retry in Route Pend"); - cli_print(cli, "------------------ ----- --------------- " - "----------- ------- -------- ----- ----"); - } - - cli_print(cli, "%-18.18s %5d %15s %-11s %7d %7ds %5s %4s", - bgp_peers[i].name, - bgp_peers[i].as, - addr, - bgp_state_str(bgp_peers[i].state), - bgp_peers[i].retry_count, - bgp_peers[i].retry_time ? bgp_peers[i].retry_time - time_now : 0, - bgp_peers[i].routing ? "yes" : "no", - bgp_peers[i].update_routes ? "yes" : "no"); - } - - return CLI_OK; -} - -int cmd_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc) -{ - int i; - char *addr; - - if (!bgp_configured) - return CLI_OK; - - if (CLI_HELP_REQUESTED) - return cli_arg_help(cli, 1, - "A.B.C.D", "BGP peer address", - "NAME", "BGP peer name", - NULL); - - for (i = 0; i < BGP_NUM_PEERS; i++) - { - if (bgp_peers[i].state != Established) - continue; - - if (!bgp_peers[i].routing) - continue; - - addr = inet_toa(bgp_peers[i].addr); - if (argc && strcmp(addr, argv[0]) && strcmp(bgp_peers[i].name, argv[0])) - continue; - - bgp_peers[i].cli_flag = BGP_CLI_SUSPEND; - cli_print(cli, "Suspending peer %s", bgp_peers[i].name); - } - - return CLI_OK; -} - -int cmd_no_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc) -{ - int i; - char *addr; - - if (!bgp_configured) - return CLI_OK; - - if (CLI_HELP_REQUESTED) - return cli_arg_help(cli, 1, - "A.B.C.D", "BGP peer address", - "NAME", "BGP peer name", - NULL); - - for (i = 0; i < BGP_NUM_PEERS; i++) - { - if (bgp_peers[i].state != Established) - continue; - - if (bgp_peers[i].routing) - continue; - - addr = inet_toa(bgp_peers[i].addr); - if (argc && strcmp(addr, argv[0]) && - strncmp(bgp_peers[i].name, argv[0], strlen(argv[0]))) - continue; - - bgp_peers[i].cli_flag = BGP_CLI_ENABLE; - cli_print(cli, "Un-suspending peer %s", bgp_peers[i].name); - } - - return CLI_OK; -} - -int cmd_restart_bgp(struct cli_def *cli, char *command, char **argv, int argc) -{ - int i; - char *addr; - - if (!bgp_configured) - return CLI_OK; - - if (CLI_HELP_REQUESTED) - return cli_arg_help(cli, 1, - "A.B.C.D", "BGP peer address", - "NAME", "BGP peer name", - NULL); - - for (i = 0; i < BGP_NUM_PEERS; i++) - { - if (!*bgp_peers[i].name) - continue; - - addr = inet_toa(bgp_peers[i].addr); - if (argc && strcmp(addr, argv[0]) && - strncmp(bgp_peers[i].name, argv[0], strlen(argv[0]))) - continue; - - bgp_peers[i].cli_flag = BGP_CLI_RESTART; - cli_print(cli, "Restarting peer %s", bgp_peers[i].name); - } - - return CLI_OK; -}