projects / l2tpns.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cleanup clash between timeout and session_timout
[l2tpns.git] / bgp.c
diff --git a/bgp.c b/bgp.c
index 2d411e7..6a868fa 100644 (file)
--- a/bgp.c
+++ b/bgp.c
@@ -10,7 +10,7 @@
  *   nor RFC2385 (which requires a kernel patch on 2.4 kernels).
  */
 
  *   nor RFC2385 (which requires a kernel patch on 2.4 kernels).
  */
 
-char const *cvs_id_bgp = "$Id: bgp.c,v 1.6 2004/11/11 03:07:42 bodea Exp $";
+char const *cvs_id_bgp = "$Id: bgp.c,v 1.12 2005/09/02 23:39:36 bodea Exp $";
 
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -34,7 +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);
     struct bgp_route_list *new);
 
 static void bgp_free_routes(struct bgp_route_list *routes);
-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_connect(struct bgp_peer *peer);
 static int bgp_handle_connect(struct bgp_peer *peer);
 static int bgp_write(struct bgp_peer *peer);
@@ -43,9 +43,10 @@ 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_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;
 static struct bgp_route_list *bgp_routes = 0;
 
 int bgp_configured = 0;
@@ -69,11 +70,15 @@ int bgp_setup(int as)
        if (!((peer->outbuf = malloc(sizeof(*peer->outbuf)))
            && (peer->inbuf = malloc(sizeof(*peer->inbuf)))))
        {
        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;
        }
                strerror(errno));
 
            return 0;
        }
+
+       peer->edata.type = FD_TYPE_BGP;
+       peer->edata.index = i;
+       peer->events = 0;
     }
 
     if (as < 1)
     }
 
     if (as < 1)
@@ -89,7 +94,8 @@ int bgp_setup(int as)
 }
 
 /* start connection with a peer */
 }
 
 /* start connection with a peer */
-int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold, int enable)
+int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive,
+    int hold, int enable)
 {
     struct hostent *h;
     int ibgp;
 {
     struct hostent *h;
     int ibgp;
@@ -98,8 +104,8 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
     char path_attrs[64];
     char *p = path_attrs;
     in_addr_t ip;
     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 (!our_as)
        return 0;
@@ -111,7 +117,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
 
     if (!(h = gethostbyname(name)) || h->h_addrtype != AF_INET)
     {
 
     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;
            name, h ? "no address" : hstrerror(h_errno));
 
        return 0;
@@ -170,9 +176,9 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
     {
        /* just our AS */
        struct {
     {
        /* 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,
        } as_path = {
            BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE,
            1,
@@ -204,7 +210,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
 
     if (ibgp)
     {
 
     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;
 
        /* LOCAL_PREF */
        a.flags = BGP_PATH_ATTR_FLAG_TRANS;
@@ -225,7 +231,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
 
     if (!(peer->path_attrs = malloc(peer->path_attr_len)))
     {
 
     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;
            name, strerror(errno));
 
        return 0;
@@ -233,7 +239,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, int hold
 
     memcpy(peer->path_attrs, path_attrs, peer->path_attr_len);
 
 
     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 */
        name, enable ? "enabled" : "suspended");
 
     /* we have at least one peer configured */
@@ -268,13 +274,14 @@ static void bgp_clear(struct bgp_peer *peer)
     peer->inbuf->done = 0;
 
     peer->cli_flag = 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;
 
 
     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));
     }
 }
            bgp_state_str(peer->next_state));
     }
 }
@@ -282,14 +289,14 @@ static void bgp_clear(struct bgp_peer *peer)
 /* initiate a clean shutdown */
 void bgp_stop(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)
 {
     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);
 }
     peer->next_state = Disabled;
     bgp_clear(peer);
 }
@@ -324,7 +331,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;
 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;
 
     /* convert to prefix notation */
     pfx->len = 32;
@@ -399,8 +406,8 @@ int bgp_add_route(in_addr_t ip, in_addr_t mask)
     /* insert into route list; sorted */
     if (!(r = malloc(sizeof(*r))))
     {
     /* 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;
     }
 
        return 0;
     }
@@ -413,8 +420,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;
 
        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;
 }
 
     return 1;
 }
@@ -462,8 +469,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;
 
        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;
 }
 
     return 1;
 }
@@ -482,133 +489,163 @@ void bgp_enable_routing(int enable)
            bgp_peers[i].update_routes = 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 (!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 (!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_STATE_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;
     }
 
     return 1;
@@ -641,7 +678,7 @@ char const *bgp_state_str(enum bgp_state state)
     return "?";
 }
 
     return "?";
 }
 
-static char const *bgp_msg_type_str(u8 type)
+static char const *bgp_msg_type_str(uint8_t type)
 {
     switch (type)
     {
 {
     switch (type)
     {
@@ -659,13 +696,14 @@ static int bgp_connect(struct bgp_peer *peer)
 {
     static int bgp_port = 0;
     struct sockaddr_in addr;
 {
     static int bgp_port = 0;
     struct sockaddr_in addr;
+    struct epoll_event ev;
 
     if (!bgp_port)
     {
        struct servent *serv;
        if (!(serv = getservbyname("bgp", "tcp")))
        {
 
     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;
        }
 
            return 0;
        }
 
@@ -674,13 +712,18 @@ static int bgp_connect(struct bgp_peer *peer)
 
     if ((peer->sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 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;
     }
 
            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);
 
     /* set to non-blocking */
     fcntl(peer->sock, F_SETFL, fcntl(peer->sock, F_GETFL, 0) | O_NONBLOCK);
 
@@ -697,7 +740,7 @@ static int bgp_connect(struct bgp_peer *peer)
 
        if (errno != EINPROGRESS)
        {
 
        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);
                inet_ntoa(addr.sin_addr), strerror(errno));
 
            bgp_set_retry(peer);
@@ -707,7 +750,7 @@ static int bgp_connect(struct bgp_peer *peer)
        peer->state = Connect;
        peer->state_time = time_now;
 
        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;
     }
 
        return 1;
     }
 
@@ -715,7 +758,7 @@ static int bgp_connect(struct bgp_peer *peer)
     peer->state_time = time_now;
     peer->retry_time = peer->retry_count = 0;
 
     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);
 }
 
     return bgp_send_open(peer);
 }
@@ -724,11 +767,11 @@ static int bgp_connect(struct bgp_peer *peer)
 static int bgp_handle_connect(struct bgp_peer *peer)
 {
     int err = 0;
 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)
     {
     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);
            strerror(err));
 
        bgp_set_retry(peer);
@@ -738,7 +781,7 @@ static int bgp_handle_connect(struct bgp_peer *peer)
     peer->state = Active;
     peer->state_time = time_now;
 
     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 bgp_send_open(peer);
 }
@@ -759,9 +802,9 @@ static int bgp_write(struct bgp_peer *peer)
            return 1;
 
        if (errno == EPIPE)
            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
        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);
                strerror(errno));
 
        bgp_set_retry(peer);
@@ -774,7 +817,7 @@ static int bgp_write(struct bgp_peer *peer)
        return 1;
     }
 
        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;
        bgp_msg_type_str(peer->outbuf->packet.header.type), peer->name);
 
     peer->outbuf->packet.header.len = 0;
@@ -794,7 +837,7 @@ static int bgp_write(struct bgp_peer *peer)
        peer->state = peer->next_state;
        peer->state_time = time_now;
 
        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));
     }
 
            bgp_state_str(peer->state));
     }
 
@@ -811,7 +854,7 @@ static int bgp_read(struct bgp_peer *peer)
     {
        if (!r)
        {
     {
        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
        {
        }
        else
        {
@@ -821,7 +864,7 @@ static int bgp_read(struct bgp_peer *peer)
            if (errno == EAGAIN)
                return 1;
 
            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));
        }
 
                strerror(errno));
        }
 
@@ -841,7 +884,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
     if (len > BGP_MAX_PACKET_SIZE)
     {
 
     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;
     }
        bgp_send_notification(peer, BGP_ERR_HEADER, BGP_ERR_HDR_BAD_LEN);
        return 0;
     }
@@ -849,7 +892,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
     if (peer->inbuf->done < 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)
        bgp_msg_type_str(p->header.type), peer->name);
 
     switch (p->header.type)
@@ -857,13 +900,14 @@ static int bgp_handle_input(struct bgp_peer *peer)
     case BGP_MSG_OPEN:
        {
            struct bgp_data_open data;
     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)
                {
            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,
                        peer->name);
 
                    bgp_send_notification(peer, BGP_ERR_HEADER,
@@ -875,7 +919,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
            if (peer->state != OpenSent)
            {
 
            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);
                    peer->name, bgp_state_str(peer->state));
 
                bgp_send_notification(peer, BGP_ERR_FSM, 0);
@@ -886,7 +930,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
            if (data.version != BGP_VERSION)
            {
 
            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);
                    (int) data.version, peer->name);
 
                bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_VERSION);
@@ -895,7 +939,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
            if (ntohs(data.as) != peer->as)
            {
 
            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);
 
                    "expected %d)\n", peer->name, (int) htons(data.as),
                    (int) peer->as);
 
@@ -903,15 +947,19 @@ static int bgp_handle_input(struct bgp_peer *peer)
                return 0;
            }
 
                return 0;
            }
 
-           if ((peer->hold = ntohs(data.hold_time)) < 3)
+           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;
            }
 
 
                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;
            /* adjust our keepalive based on negotiated hold value */
            if (peer->keepalive * 3 > peer->hold)
                peer->keepalive = peer->hold / 3;
@@ -934,7 +982,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
            peer->retry_count = 0;
            peer->retry_time = 0;
 
            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;
        }
 
        break;
@@ -947,13 +995,13 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
            if (notification->error_code == BGP_ERR_CEASE)
            {
 
            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;
            }
 
            /* FIXME: should handle more notifications */
                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);
        }
 
                peer->name, (int) notification->error_code);
        }
 
@@ -982,7 +1030,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 static int bgp_send_open(struct bgp_peer *peer)
 {
     struct bgp_data_open data;
 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));
 
     memset(peer->outbuf->packet.header.marker, 0xff,
        sizeof(peer->outbuf->packet.header.marker));
@@ -1024,9 +1072,9 @@ static int bgp_send_keepalive(struct bgp_peer *peer)
 /* send/buffer UPDATE message */
 static int bgp_send_update(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;
     struct bgp_route_list *have = peer->routes;
     struct bgp_route_list *want = peer->routing ? bgp_routes : 0;
     struct bgp_route_list *e = 0;
@@ -1072,8 +1120,8 @@ static int bgp_send_update(struct bgp_peer *peer)
            unf_len += s;
            len += s;
 
            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);
 
 
            free(tmp);
 
@@ -1122,8 +1170,8 @@ static int bgp_send_update(struct bgp_peer *peer)
     {
        if (!(e = malloc(sizeof(*e))))
        {
     {
        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;
        }
 
            return 0;
        }
@@ -1146,8 +1194,8 @@ static int bgp_send_update(struct bgp_peer *peer)
        data += s;
        len += s;
 
        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
     {
     }
     else
     {
@@ -1164,10 +1212,11 @@ static int bgp_send_update(struct bgp_peer *peer)
 }
 
 /* send/buffer NOTIFICATION message */
 }
 
 /* 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;
 {
     struct bgp_data_notification data;
-    u16 len = 0;
+    uint16_t len = 0;
 
     data.error_code = code;
     len += sizeof(data.error_code);
 
     data.error_code = code;
     len += sizeof(data.error_code);
for cloning use: "git clone git://git.sameswireless.fr/l2tpns.git" ; For add to your sources.list: "deb http://package.sameswifi.fr/ jessie main"