projects / l2tpns.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix intercepts: don't double-snoop throttled customers, ensure
[l2tpns.git] / bgp.c
diff --git a/bgp.c b/bgp.c
index ec084d1..5d7c578 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).
  */
 
-/* $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.5 2004/11/05 04:55:26 bodea Exp $";
 
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -66,7 +66,7 @@ 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, 0, "Can't allocate buffers for bgp peer (%s)\n",
                strerror(errno));
 
            return 0;
                strerror(errno));
 
            return 0;
@@ -108,7 +108,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable)
 
     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, 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;
@@ -212,7 +212,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable)
 
     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, 0, "Can't allocate path_attrs for %s (%s)\n",
            name, strerror(errno));
 
        return 0;
            name, strerror(errno));
 
        return 0;
@@ -220,7 +220,7 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int enable)
 
     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, 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 */
@@ -259,7 +259,7 @@ static void bgp_clear(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, 0, "BGP peer %s: state %s\n", peer->name,
            bgp_state_str(peer->next_state));
     }
 }
            bgp_state_str(peer->next_state));
     }
 }
@@ -267,14 +267,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, 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, 0, "Aborting BGP connection to %s\n", peer->name);
     peer->next_state = Disabled;
     bgp_clear(peer);
 }
     peer->next_state = Disabled;
     bgp_clear(peer);
 }
@@ -384,7 +384,7 @@ 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",
+       LOG(0, 0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
            inet_toa(add.dest.prefix), add.dest.len, strerror(errno));
 
        return 0;
            inet_toa(add.dest.prefix), add.dest.len, strerror(errno));
 
        return 0;
@@ -398,7 +398,7 @@ 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),
+    LOG(4, 0, 0, 0, "Registered BGP route %s/%d\n", inet_toa(add.dest.prefix),
        add.dest.len);
 
     return 1;
        add.dest.len);
 
     return 1;
@@ -447,7 +447,7 @@ 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),
+    LOG(4, 0, 0, 0, "Removed BGP route %s/%d\n", inet_toa(del.dest.prefix),
        del.dest.len);
 
     return 1;
        del.dest.len);
 
     return 1;
@@ -467,7 +467,7 @@ 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, 0, "%s BGP routing\n", enable ? "Enabled" : "Suspended");
 }
 
 /* return a bitmask indicating if the socket should be added to the
 }
 
 /* return a bitmask indicating if the socket should be added to the
@@ -573,7 +573,7 @@ int bgp_process(struct bgp_peer *peer, int readable, int writable)
     {
        if (time_now > peer->expire_time)
        {
     {
        if (time_now > peer->expire_time)
        {
-           log(1, 0, 0, 0, "No message from BGP peer %s in %ds\n",
+           LOG(1, 0, 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);
                peer->name, peer->hold);
 
            bgp_send_notification(peer, BGP_ERR_HOLD_TIMER_EXP, 0);
@@ -590,7 +590,7 @@ int bgp_process(struct bgp_peer *peer, int readable, int writable)
     }
     else if (time_now > peer->state_time + BGP_KEEPALIVE_TIME)
     {
     }
     else if (time_now > peer->state_time + BGP_KEEPALIVE_TIME)
     {
-       log(1, 0, 0, 0, "%s timer expired for BGP peer %s\n",
+       LOG(1, 0, 0, 0, "%s timer expired for BGP peer %s\n",
            bgp_state_str(peer->state), peer->name);
 
        return bgp_restart(peer);
            bgp_state_str(peer->state), peer->name);
 
        return bgp_restart(peer);
@@ -650,7 +650,7 @@ static int bgp_connect(struct bgp_peer *peer)
        struct servent *serv;
        if (!(serv = getservbyname("bgp", "tcp")))
        {
        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, 0, "Can't get bgp service (%s)\n", strerror(errno));
            return 0;
        }
 
            return 0;
        }
 
@@ -659,7 +659,7 @@ 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, 0, "Can't create a socket for BGP peer %s (%s)\n",
            peer->name, strerror(errno));
 
        peer->state = peer->next_state = Disabled;
            peer->name, strerror(errno));
 
        peer->state = peer->next_state = Disabled;
@@ -682,7 +682,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, 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);
@@ -692,7 +692,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, 0, "BGP peer %s: state Connect\n", peer->name);
        return 1;
     }
 
        return 1;
     }
 
@@ -700,7 +700,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, 0, "BGP peer %s: state Active\n", inet_ntoa(addr.sin_addr));
 
     return bgp_send_open(peer);
 }
 
     return bgp_send_open(peer);
 }
@@ -713,7 +713,7 @@ static int bgp_handle_connect(struct bgp_peer *peer)
     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, 0, "Can't connect to BGP peer %s (%s)\n", peer->name,
            strerror(err));
 
        bgp_set_retry(peer);
            strerror(err));
 
        bgp_set_retry(peer);
@@ -723,7 +723,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, 0, "BGP peer %s: state Active\n", peer->name);
 
     return bgp_send_open(peer);
 }
 
     return bgp_send_open(peer);
 }
@@ -744,9 +744,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, 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, 0, "Can't write to BGP peer %s (%s)\n", peer->name,
                strerror(errno));
 
        bgp_set_retry(peer);
                strerror(errno));
 
        bgp_set_retry(peer);
@@ -759,7 +759,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, 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;
@@ -779,7 +779,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, 0, "BGP peer %s: state %s\n", peer->name,
            bgp_state_str(peer->state));
     }
 
            bgp_state_str(peer->state));
     }
 
@@ -796,7 +796,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, 0, "Connection to BGP peer %s closed\n", peer->name);
        }
        else
        {
        }
        else
        {
@@ -806,7 +806,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, 0, "Can't read from BGP peer %s (%s)\n", peer->name,
                strerror(errno));
        }
 
                strerror(errno));
        }
 
@@ -826,7 +826,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, 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;
     }
@@ -834,7 +834,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, 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)
@@ -848,7 +848,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
            {
                if ((unsigned char) p->header.marker[i] != 0xff)
                {
            {
                if ((unsigned char) p->header.marker[i] != 0xff)
                {
-                   log(1, 0, 0, 0, "Invalid marker from BGP peer %s\n",
+                   LOG(1, 0, 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,
@@ -860,7 +860,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, 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);
@@ -871,7 +871,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, 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);
@@ -880,7 +880,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, 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);
 
@@ -890,7 +890,7 @@ static int bgp_handle_input(struct bgp_peer *peer)
 
            if ((peer->hold = ntohs(data.hold_time)) < 10)
            {
 
            if ((peer->hold = ntohs(data.hold_time)) < 10)
            {
-               log(1, 0, 0, 0, "Bad hold time (%d) from BGP peer %s\n",
+               LOG(1, 0, 0, 0, "Bad hold time (%d) from BGP peer %s\n",
                    peer->hold, peer->name);
 
                bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_HOLD_TIME);
                    peer->hold, peer->name);
 
                bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_HOLD_TIME);
@@ -915,7 +915,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, 0, "BGP peer %s: state Established\n", peer->name);
        }
 
        break;
        }
 
        break;
@@ -928,13 +928,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);
+               LOG(4, 0, 0, 0, "BGP peer %s sent CEASE\n", peer->name);
                bgp_halt(peer);
                return 0;
            }
 
            /* FIXME: should handle more notifications */
                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, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n",
                peer->name, (int) notification->error_code);
        }
 
                peer->name, (int) notification->error_code);
        }
 
@@ -1053,7 +1053,7 @@ 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",
+           LOG(5, 0, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n",
                inet_toa(tmp->dest.prefix), tmp->dest.len, peer->name);
 
            free(tmp);
                inet_toa(tmp->dest.prefix), tmp->dest.len, peer->name);
 
            free(tmp);
@@ -1103,7 +1103,7 @@ 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",
+           LOG(0, 0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
                inet_toa(add->dest.prefix), add->dest.len, strerror(errno));
 
            return 0;
                inet_toa(add->dest.prefix), add->dest.len, strerror(errno));
 
            return 0;
@@ -1127,7 +1127,7 @@ 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",
+       LOG(5, 0, 0, 0, "Advertising route %s/%d to BGP peer %s\n",
            inet_toa(add->dest.prefix), add->dest.len, peer->name);
     }
     else
            inet_toa(add->dest.prefix), add->dest.len, peer->name);
     }
     else
@@ -1188,6 +1188,12 @@ int cmd_show_bgp(struct cli_def *cli, char *command, char **argv, int argc)
     if (!bgp_configured)
        return CLI_OK;
 
     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);
     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);
@@ -1235,6 +1241,12 @@ int cmd_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc)
     if (!bgp_configured)
        return CLI_OK;
 
     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)
     for (i = 0; i < BGP_NUM_PEERS; i++)
     {
        if (bgp_peers[i].state != Established)
@@ -1262,6 +1274,12 @@ int cmd_no_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc
     if (!bgp_configured)
        return CLI_OK;
 
     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)
     for (i = 0; i < BGP_NUM_PEERS; i++)
     {
        if (bgp_peers[i].state != Established)
@@ -1290,6 +1308,12 @@ int cmd_restart_bgp(struct cli_def *cli, char *command, char **argv, int argc)
     if (!bgp_configured)
        return CLI_OK;
 
     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)
     for (i = 0; i < BGP_NUM_PEERS; i++)
     {
        if (!*bgp_peers[i].name)
for cloning use: "git clone git://git.sameswireless.fr/l2tpns.git" ; For add to your sources.list: "deb http://package.sameswifi.fr/ jessie main"