* nor RFC2385 (which requires a kernel patch on 2.4 kernels).
*/
-/* $Id: bgp.c,v 1.1 2004-06-23 03:52:24 fred_nerk Exp $ */
+char const *cvs_id_bgp = "$Id: bgp.c,v 1.10 2005-06-04 15:42:35 bodea Exp $";
#include <stdlib.h>
#include <unistd.h>
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);
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 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)
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)
}
/* 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;
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;
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;
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);
{
/* 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,
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;
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;
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 */
}
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;
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));
}
}
/* 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);
}
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;
/* 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;
}
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;
}
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;
}
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 <sys/epoll.h>
+#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->state == Disabled || peer->state == Idle)
+ continue;
+
+ 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->inbuf->done < BGP_MAX_PACKET_SIZE)
- flags |= 1;
+ if (peer->events != events)
+ {
+ struct epoll_event ev;
- if (peer->state == Connect || /* connection in progress */
- peer->update_routes || /* routing updates */
- peer->outbuf->packet.header.len) /* pending output */
- flags |= 2;
+ ev.events = peer->events = events;
+ ev.data.ptr = &peer->edata;
+ epoll_ctl(epollfd, EPOLL_CTL_MOD, peer->sock, &ev);
+ }
+ }
- return flags;
+ 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->name && peer->cli_flag == BGP_CLI_RESTART)
+ {
+ bgp_restart(peer);
+ continue;
+ }
- if (peer->state == Disabled)
- return 1;
+ if (peer->state == Disabled)
+ continue;
- if (peer->cli_flag)
- {
- switch (peer->cli_flag)
+ 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;
}
}
-static char const *bgp_state_str(enum bgp_state state)
+char const *bgp_state_str(enum bgp_state state)
{
switch (state)
{
return "?";
}
-static char const *bgp_msg_type_str(u8 type)
+static char const *bgp_msg_type_str(uint8_t type)
{
switch (type)
{
{
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;
}
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);
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);
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;
}
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));
return bgp_send_open(peer);
}
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);
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);
return bgp_send_open(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);
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)
{
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));
}
{
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
{
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));
}
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;
}
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)
case BGP_MSG_OPEN:
{
struct bgp_data_open data;
+ int hold;
int i;
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,
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);
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);
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);
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;
+
/* next transition requires an exchange of keepalives */
bgp_send_keepalive(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;
if (notification->error_code == BGP_ERR_CEASE)
{
- log(4, 0, 0, 0, "BGP peer %s sent CEASE\n", peer->name);
+ LOG(4, 0, 0, "BGP peer %s sent CEASE\n", peer->name);
bgp_halt(peer);
return 0;
}
/* 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);
}
static int bgp_send_open(struct bgp_peer *peer)
{
struct bgp_data_open data;
- u16 len = sizeof(peer->outbuf->packet.header);
+ uint16_t len = sizeof(peer->outbuf->packet.header);
memset(peer->outbuf->packet.header.marker, 0xff,
sizeof(peer->outbuf->packet.header.marker));
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;
/* 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;
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);
{
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;
}
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
{
}
/* 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)
{
struct bgp_data_notification data;
- u16 len = 0;
+ uint16_t len = 0;
data.error_code = code;
len += sizeof(data.error_code);
return bgp_write(peer);
}
-
-/* CLI stuff */
-
-#include <libcli.h>
-
-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;
-
- 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;
-
- 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;
-
- 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;
-
- 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;
-}
projects / l2tpns.git / blobdiff