Cleanups and sync
authorfred_nerk <fred_nerk>
Thu, 2 Sep 2004 04:18:07 +0000 (04:18 +0000)
committerfred_nerk <fred_nerk>
Thu, 2 Sep 2004 04:18:07 +0000 (04:18 +0000)
12 files changed:
.cvsignore
Changes
bgp.c
cli.c
cluster.c
l2tpns.c
l2tpns.h
ppp.c
radius.c
tbf.c
util.c
util.h

index c65a666..9aeeb4d 100644 (file)
@@ -3,4 +3,5 @@ l2tpns
 nsctl
 state.dump
 *.swp
 nsctl
 state.dump
 *.swp
-cluster_master
+bounce
+generateload
diff --git a/Changes b/Changes
index 53188bf..bd8f94c 100644 (file)
--- a/Changes
+++ b/Changes
@@ -15,6 +15,7 @@
 - Per-user upload and download throttle rates - Yuri
 - Make autothrottle.so understand cisco lcp:interface-config - Yuri
 - Show filter stats in show session - Yuri
 - Per-user upload and download throttle rates - Yuri
 - Make autothrottle.so understand cisco lcp:interface-config - Yuri
 - Show filter stats in show session - Yuri
+- Cleanup from Michael to change sid to unique_id
 
 * Tue Jul 13 2004 Brendan O'Dea <bod@optusnet.com.au> 2.0.1
 - Update INSTALL, Docs/manual.html documentation.
 
 * Tue Jul 13 2004 Brendan O'Dea <bod@optusnet.com.au> 2.0.1
 - Update INSTALL, Docs/manual.html documentation.
diff --git a/bgp.c b/bgp.c
index 4404484..8e5e377 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.3 2004/08/13 00:02:50 fred_nerk Exp $";
+char const *cvs_id_bgp = "$Id: bgp.c,v 1.4 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -31,7 +31,7 @@ static void bgp_clear(struct bgp_peer *peer);
 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);
 static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head,
 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);
 static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head,
-       struct bgp_route_list *new);
+    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 void bgp_free_routes(struct bgp_route_list *routes);
 static char const *bgp_state_str(enum bgp_state state);
@@ -51,303 +51,305 @@ static u16 our_as;
 /* prepare peer structure, globals */
 int bgp_setup(int as)
 {
 /* prepare peer structure, globals */
 int bgp_setup(int as)
 {
-       int i;
-       struct bgp_peer *peer;
+    int i;
+    struct bgp_peer *peer;
 
 
-       for (i = 0; i < BGP_NUM_PEERS; i++)
-       {
-               peer = &bgp_peers[i];
-               memset(peer, 0, sizeof(*peer));
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+    {
+       peer = &bgp_peers[i];
+       memset(peer, 0, sizeof(*peer));
 
 
-               peer->addr = INADDR_NONE;
-               peer->sock = -1;
-               peer->state = peer->next_state = Disabled;
+       peer->addr = INADDR_NONE;
+       peer->sock = -1;
+       peer->state = peer->next_state = Disabled;
 
 
-               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",
-                               strerror(errno));
+       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",
+               strerror(errno));
 
 
-                       return 0;
-               }
+           return 0;
        }
        }
+    }
 
 
-       if (as < 1)
-                       as = 0;
+    if (as < 1)
+       as = 0;
 
 
-       if ((our_as = as))
-                       return 0;
+    if ((our_as = as))
+       return 0;
 
 
-       bgp_routes = 0;
-       bgp_configured = 0; /* set by bgp_start */
+    bgp_routes = 0;
+    bgp_configured = 0; /* set by bgp_start */
 
 
-       return 1;
+    return 1;
 }
 
 /* start connection with a peer */
 int bgp_start(struct bgp_peer *peer, char *name, int as, int enable)
 {
 }
 
 /* start connection with a peer */
 int bgp_start(struct bgp_peer *peer, char *name, int as, int enable)
 {
-       struct hostent *h;
-       int ibgp;
-       int i;
-       struct bgp_path_attr a;
-       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);
-
-       if (!our_as)
-               return 0;
-
-       if (peer->state != Disabled)
-               bgp_halt(peer);
-
-       snprintf(peer->name, sizeof(peer->name), "%s", name);
-
-       if (!(h = gethostbyname(name)) || h->h_addrtype != AF_INET)
-       {
-               log(0, 0, 0, 0, "Can't get address for BGP peer %s (%s)\n", name, h ? "no address" : hstrerror(h_errno));
-
-               return 0;
-       }
-
-       memcpy(&peer->addr, h->h_addr, sizeof(peer->addr));
-       peer->as = as > 0 ? as : our_as;
-       ibgp = peer->as == our_as;
-
-       /* clear buffers, go to Idle state */
-       peer->next_state = Idle;
-       bgp_clear(peer);
-
-       /* set initial routing state */
-       peer->routing = enable;
-
-       /* all our routes use the same attributes, so prepare it in advance */
-       if (peer->path_attrs)
-                       free(peer->path_attrs);
-
-       peer->path_attr_len = 0;
-
-       /* ORIGIN */
-       a.flags = BGP_PATH_ATTR_FLAG_TRANS;
-       a.code = BGP_PATH_ATTR_CODE_ORIGIN;
-       a.data.s.len = 1;
-       a.data.s.value[0] = BGP_PATH_ATTR_CODE_ORIGIN_IGP;
-
-#define ADD_ATTRIBUTE()                                do { \
-       i = BGP_PATH_ATTR_SIZE(a);              \
-       memcpy(p, &a, i);                               \
-       p += i;                                                 \
-       peer->path_attr_len += i;               } while (0)
-
-       ADD_ATTRIBUTE();
-
-       /* AS_PATH */
-       a.flags = BGP_PATH_ATTR_FLAG_TRANS;
-       a.code = BGP_PATH_ATTR_CODE_AS_PATH;
-       if (ibgp)
-       {
-               /* empty path */
-               a.data.s.len = 0;
-       }
-       else
-       {
-               /* just our AS */
-               struct {
-                       u8 type;
-                       u8 len;
-                       u16 value;
-               } as_path = {
-                       BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE,
-                       1,
-                       htons(our_as),
-               };
-
-               a.data.s.len = sizeof(as_path);
-               memcpy(&a.data.s.value, &as_path, sizeof(as_path));
-       }
-
-       ADD_ATTRIBUTE();
-
-       /* NEXT_HOP */
+    struct hostent *h;
+    int ibgp;
+    int i;
+    struct bgp_path_attr a;
+    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);
+
+    if (!our_as)
+       return 0;
+
+    if (peer->state != Disabled)
+       bgp_halt(peer);
+
+    snprintf(peer->name, sizeof(peer->name), "%s", name);
+
+    if (!(h = gethostbyname(name)) || h->h_addrtype != AF_INET)
+    {
+       log(0, 0, 0, 0, "Can't get address for BGP peer %s (%s)\n",
+           name, h ? "no address" : hstrerror(h_errno));
+
+       return 0;
+    }
+
+    memcpy(&peer->addr, h->h_addr, sizeof(peer->addr));
+    peer->as = as > 0 ? as : our_as;
+    ibgp = peer->as == our_as;
+
+    /* clear buffers, go to Idle state */
+    peer->next_state = Idle;
+    bgp_clear(peer);
+
+    /* set initial routing state */
+    peer->routing = enable;
+
+    /* all our routes use the same attributes, so prepare it in advance */
+    if (peer->path_attrs)
+       free(peer->path_attrs);
+
+    peer->path_attr_len = 0;
+
+    /* ORIGIN */
+    a.flags = BGP_PATH_ATTR_FLAG_TRANS;
+    a.code = BGP_PATH_ATTR_CODE_ORIGIN;
+    a.data.s.len = 1;
+    a.data.s.value[0] = BGP_PATH_ATTR_CODE_ORIGIN_IGP;
+
+#define ADD_ATTRIBUTE()                do { \
+    i = BGP_PATH_ATTR_SIZE(a); \
+    memcpy(p, &a, i);          \
+    p += i;                    \
+    peer->path_attr_len += i;  } while (0)
+
+    ADD_ATTRIBUTE();
+
+    /* AS_PATH */
+    a.flags = BGP_PATH_ATTR_FLAG_TRANS;
+    a.code = BGP_PATH_ATTR_CODE_AS_PATH;
+    if (ibgp)
+    {
+       /* empty path */
+       a.data.s.len = 0;
+    }
+    else
+    {
+       /* just our AS */
+       struct {
+           u8 type;
+           u8 len;
+           u16 value;
+       } as_path = {
+           BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE,
+           1,
+           htons(our_as),
+       };
+
+       a.data.s.len = sizeof(as_path);
+       memcpy(&a.data.s.value, &as_path, sizeof(as_path));
+    }
+
+    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;
+    a.data.s.len = sizeof(metric);
+    memcpy(a.data.s.value, &metric, sizeof(metric));
+
+    ADD_ATTRIBUTE();
+
+    if (ibgp)
+    {
+       u32 local_pref = htonl(BGP_LOCAL_PREF);
+
+       /* LOCAL_PREF */
        a.flags = BGP_PATH_ATTR_FLAG_TRANS;
        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));
+       a.code = BGP_PATH_ATTR_CODE_LOCAL_PREF;
+       a.data.s.len = sizeof(local_pref);
+       memcpy(a.data.s.value, &local_pref, sizeof(local_pref));
 
        ADD_ATTRIBUTE();
 
        ADD_ATTRIBUTE();
+    }
 
 
-       /* MULTI_EXIT_DISC */
-       a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL;
-       a.code = BGP_PATH_ATTR_CODE_MULTI_EXIT_DISC;
-       a.data.s.len = sizeof(metric);
-       memcpy(a.data.s.value, &metric, sizeof(metric));
-
-       ADD_ATTRIBUTE();
-
-       if (ibgp)
-       {
-               u32 local_pref = htonl(BGP_LOCAL_PREF);
-
-               /* LOCAL_PREF */
-               a.flags = BGP_PATH_ATTR_FLAG_TRANS;
-               a.code = BGP_PATH_ATTR_CODE_LOCAL_PREF;
-               a.data.s.len = sizeof(local_pref);
-               memcpy(a.data.s.value, &local_pref, sizeof(local_pref));
-
-               ADD_ATTRIBUTE();
-       }
-
-       /* COMMUNITIES */
-       a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL | BGP_PATH_ATTR_FLAG_TRANS;
-       a.code = BGP_PATH_ATTR_CODE_COMMUNITIES;
-       a.data.s.len = sizeof(no_export);
-       memcpy(a.data.s.value, &no_export, sizeof(no_export));
+    /* COMMUNITIES */
+    a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL | BGP_PATH_ATTR_FLAG_TRANS;
+    a.code = BGP_PATH_ATTR_CODE_COMMUNITIES;
+    a.data.s.len = sizeof(no_export);
+    memcpy(a.data.s.value, &no_export, sizeof(no_export));
 
 
-       ADD_ATTRIBUTE();
+    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",
-                       name, strerror(errno));
+    if (!(peer->path_attrs = malloc(peer->path_attr_len)))
+    {
+       log(0, 0, 0, 0, "Can't allocate path_attrs for %s (%s)\n",
+           name, strerror(errno));
 
 
-               return 0;
-       }
+       return 0;
+    }
 
 
-       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",
-               name, enable ? "enabled" : "suspended");
+    log(4, 0, 0, 0, "Initiating BGP connection to %s (routing %s)\n",
+       name, enable ? "enabled" : "suspended");
 
 
-       /* we have at least one peer configured */
-       bgp_configured = 1;
+    /* we have at least one peer configured */
+    bgp_configured = 1;
 
 
-       /* connect */
-       return bgp_connect(peer);
+    /* connect */
+    return bgp_connect(peer);
 }
 
 /* clear counters, timers, routes and buffers; close socket; move to
    next_state, which may be Disabled or Idle */
 static void bgp_clear(struct bgp_peer *peer)
 {
 }
 
 /* clear counters, timers, routes and buffers; close socket; move to
    next_state, which may be Disabled or Idle */
 static void bgp_clear(struct bgp_peer *peer)
 {
-       if (peer->sock != -1)
-       {
-                       close(peer->sock);
-               peer->sock = -1;
-       }
+    if (peer->sock != -1)
+    {
+       close(peer->sock);
+       peer->sock = -1;
+    }
 
 
-       peer->keepalive_time = 0;
-       peer->hold = 0;
-       peer->expire_time = 0;
+    peer->keepalive_time = 0;
+    peer->hold = 0;
+    peer->expire_time = 0;
 
 
-       bgp_free_routes(peer->routes);
-       peer->routes = 0;
+    bgp_free_routes(peer->routes);
+    peer->routes = 0;
 
 
-       peer->outbuf->packet.header.len = 0;
-       peer->outbuf->done = 0;
-       peer->inbuf->packet.header.len = 0;
-       peer->inbuf->done = 0;
+    peer->outbuf->packet.header.len = 0;
+    peer->outbuf->done = 0;
+    peer->inbuf->packet.header.len = 0;
+    peer->inbuf->done = 0;
 
 
-       peer->cli_flag = 0;
+    peer->cli_flag = 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,
-                       bgp_state_str(peer->next_state));
-       }
+       log(4, 0, 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)
 {
 }
 
 /* initiate a clean shutdown */
 void bgp_stop(struct bgp_peer *peer)
 {
-       log(4, 0, 0, 0, "Terminating BGP connection to %s\n", peer->name);
-       bgp_send_notification(peer, BGP_ERR_CEASE, 0);
+    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)
 {
 }
 
 /* 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);
-       peer->next_state = Disabled;
-       bgp_clear(peer);
+    log(4, 0, 0, 0, "Aborting BGP connection to %s\n", peer->name);
+    peer->next_state = Disabled;
+    bgp_clear(peer);
 }
 
 /* drop connection (if any) and set to Idle for connection retry */
 int bgp_restart(struct bgp_peer *peer)
 {
 }
 
 /* drop connection (if any) and set to Idle for connection retry */
 int bgp_restart(struct bgp_peer *peer)
 {
-       peer->next_state = Idle;
-       bgp_clear(peer);
+    peer->next_state = Idle;
+    bgp_clear(peer);
 
 
-       /* restart now */
-       peer->retry_time = time_now;
-       peer->retry_count = 0;
+    /* restart now */
+    peer->retry_time = time_now;
+    peer->retry_count = 0;
 
 
-       /* connect */
-       return bgp_connect(peer);
+    /* connect */
+    return bgp_connect(peer);
 }
 
 static void bgp_set_retry(struct bgp_peer *peer)
 {
 }
 
 static void bgp_set_retry(struct bgp_peer *peer)
 {
-       if (peer->retry_count++ < BGP_MAX_RETRY)
-       {
-               peer->retry_time = time_now + (BGP_RETRY_BACKOFF * peer->retry_count);
-               peer->next_state = Idle;
-               bgp_clear(peer);
-       }
-       else
-                       bgp_halt(peer); /* give up */
+    if (peer->retry_count++ < BGP_MAX_RETRY)
+    {
+       peer->retry_time = time_now + (BGP_RETRY_BACKOFF * peer->retry_count);
+       peer->next_state = Idle;
+       bgp_clear(peer);
+    }
+    else
+       bgp_halt(peer); /* give up */
 }
 
 /* convert ip/mask to CIDR notation */
 static void bgp_cidr(in_addr_t ip, in_addr_t mask, struct bgp_ip_prefix *pfx)
 {
 }
 
 /* convert ip/mask to CIDR notation */
 static void bgp_cidr(in_addr_t ip, in_addr_t mask, struct bgp_ip_prefix *pfx)
 {
-       int i;
-       u32 b;
+    int i;
+    u32 b;
 
 
-       /* convert to prefix notation */
-       pfx->len = 32;
-       pfx->prefix = ip;
+    /* convert to prefix notation */
+    pfx->len = 32;
+    pfx->prefix = ip;
 
 
-       if (!mask) /* bogus */
-               mask = 0xffffffff;
+    if (!mask) /* bogus */
+       mask = 0xffffffff;
 
 
-       for (i = 0; i < 32 && ((b = ntohl(1 << i)), !(mask & b)); i++)
-       {
-               pfx->len--;
-               pfx->prefix &= ~b;
-       }
+    for (i = 0; i < 32 && ((b = ntohl(1 << i)), !(mask & b)); i++)
+    {
+       pfx->len--;
+       pfx->prefix &= ~b;
+    }
 }
 
 /* insert route into list; sorted */
 static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head,
 }
 
 /* insert route into list; sorted */
 static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head,
-       struct bgp_route_list *new)
+    struct bgp_route_list *new)
 {
 {
-       struct bgp_route_list *p = head;
-       struct bgp_route_list *e = 0;
-
-       while (p && memcmp(&p->dest, &new->dest, sizeof(p->dest)) < 0)
-       {
-               e = p;
-               p = p->next;
-       }
-
-       if (e)
-       {
-               new->next = e->next;
-               e->next = new;
-       }
-       else
-       {
-               new->next = head;
-               head = new;
-       }
-
-       return head;
+    struct bgp_route_list *p = head;
+    struct bgp_route_list *e = 0;
+
+    while (p && memcmp(&p->dest, &new->dest, sizeof(p->dest)) < 0)
+    {
+       e = p;
+       p = p->next;
+    }
+
+    if (e)
+    {
+       new->next = e->next;
+       e->next = new;
+    }
+    else
+    {
+       new->next = head;
+       head = new;
+    }
+
+    return head;
 }
 
 /* add route to list for peers */
 }
 
 /* add route to list for peers */
@@ -359,818 +361,818 @@ static struct bgp_route_list *bgp_insert_route(struct bgp_route_list *head,
  */
 int bgp_add_route(in_addr_t ip, in_addr_t mask)
 {
  */
 int bgp_add_route(in_addr_t ip, in_addr_t mask)
 {
-       struct bgp_route_list *r = bgp_routes;
-       struct bgp_route_list add;
-       int i;
+    struct bgp_route_list *r = bgp_routes;
+    struct bgp_route_list add;
+    int i;
 
 
-       bgp_cidr(ip, mask, &add.dest);
-       add.next = 0;
+    bgp_cidr(ip, mask, &add.dest);
+    add.next = 0;
 
 
-       /* check for duplicate */
-       while (r)
-       {
-               i = memcmp(&r->dest, &add.dest, sizeof(r->dest));
-               if (!i)
-                       return 1; /* already covered */
+    /* check for duplicate */
+    while (r)
+    {
+       i = memcmp(&r->dest, &add.dest, sizeof(r->dest));
+       if (!i)
+           return 1; /* already covered */
 
 
-               if (i > 0)
-                       break;
+       if (i > 0)
+           break;
 
 
-               r = r->next;
-       }
+       r = r->next;
+    }
 
 
-       /* 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));
+    /* 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));
 
 
-               return 0;
-       }
+       return 0;
+    }
 
 
-       memcpy(r, &add, sizeof(*r));
-       bgp_routes = bgp_insert_route(bgp_routes, r);
+    memcpy(r, &add, sizeof(*r));
+    bgp_routes = bgp_insert_route(bgp_routes, r);
 
 
-       /* flag established peers for update */
-       for (i = 0; i < BGP_NUM_PEERS; i++)
-               if (bgp_peers[i].state == Established)
-                       bgp_peers[i].update_routes = 1;
+    /* flag established peers for update */
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+       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, 0, "Registered BGP route %s/%d\n", inet_toa(add.dest.prefix),
+       add.dest.len);
 
 
-       return 1;
+    return 1;
 }
 
 /* remove route from list for peers */
 int bgp_del_route(in_addr_t ip, in_addr_t mask)
 {
 }
 
 /* remove route from list for peers */
 int bgp_del_route(in_addr_t ip, in_addr_t mask)
 {
-       struct bgp_route_list *r = bgp_routes;
-       struct bgp_route_list *e = 0;
-       struct bgp_route_list del;
-       int i;
-
-       bgp_cidr(ip, mask, &del.dest);
-       del.next = 0;
-
-       /* find entry in routes list and remove */
-       while (r)
+    struct bgp_route_list *r = bgp_routes;
+    struct bgp_route_list *e = 0;
+    struct bgp_route_list del;
+    int i;
+
+    bgp_cidr(ip, mask, &del.dest);
+    del.next = 0;
+
+    /* find entry in routes list and remove */
+    while (r)
+    {
+       i = memcmp(&r->dest, &del.dest, sizeof(r->dest));
+       if (!i)
        {
        {
-               i = memcmp(&r->dest, &del.dest, sizeof(r->dest));
-               if (!i)
-               {
-                       if (e)
-                               e->next = r->next;
-                       else
-                               bgp_routes = r->next;
+           if (e)
+               e->next = r->next;
+           else
+               bgp_routes = r->next;
 
 
-                       free(r);
-                       break;
-               }
+           free(r);
+           break;
+       }
 
 
-               e = r;
+       e = r;
 
 
-               if (i > 0)
-                       r = 0; /* stop */
-               else
-                       r = r->next;
-       }
+       if (i > 0)
+           r = 0; /* stop */
+       else
+           r = r->next;
+    }
 
 
-       /* not found */
-       if (!r)
-               return 1;
+    /* not found */
+    if (!r)
+       return 1;
 
 
-       /* flag established peers for update */
-       for (i = 0; i < BGP_NUM_PEERS; i++)
-               if (bgp_peers[i].state == Established)
-                       bgp_peers[i].update_routes = 1;
+    /* flag established peers for update */
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+       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, 0, "Removed BGP route %s/%d\n", inet_toa(del.dest.prefix),
+       del.dest.len);
 
 
-       return 1;
+    return 1;
 }
 
 /* enable or disable routing */
 void bgp_enable_routing(int enable)
 {
 }
 
 /* enable or disable routing */
 void bgp_enable_routing(int enable)
 {
-       int i;
+    int i;
 
 
-       for (i = 0; i < BGP_NUM_PEERS; i++)
-       {
-               bgp_peers[i].routing = enable;
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+    {
+       bgp_peers[i].routing = enable;
 
 
-               /* flag established peers for update */
-               if (bgp_peers[i].state == Established)
-                       bgp_peers[i].update_routes = 1;
-       }
+       /* flag established peers for update */
+       if (bgp_peers[i].state == Established)
+           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
    read set (1) and or write set (2) for select */
 int bgp_select_state(struct bgp_peer *peer)
 {
 }
 
 /* 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)
 {
-       int flags = 0;
+    int flags = 0;
 
 
-       if (!bgp_configured)
-                       return 0;
+    if (!bgp_configured)
+       return 0;
 
 
-       if (peer->state == Disabled || peer->state == Idle)
-                       return 0;
+    if (peer->state == Disabled || peer->state == Idle)
+       return 0;
 
 
-       if (peer->inbuf->done < BGP_MAX_PACKET_SIZE)
-               flags |= 1;
+    if (peer->inbuf->done < BGP_MAX_PACKET_SIZE)
+       flags |= 1;
 
 
-       if (peer->state == Connect ||                           /* connection in progress */
-               peer->update_routes ||                                          /* routing updates */
-               peer->outbuf->packet.header.len)                /* pending output */
-                       flags |= 2;
+    if (peer->state == Connect ||              /* connection in progress */
+       peer->update_routes ||                  /* routing updates */
+       peer->outbuf->packet.header.len)        /* pending output */
+       flags |= 2;
 
 
-       return flags;
+    return flags;
 }
 
 /* process bgp peer */
 int bgp_process(struct bgp_peer *peer, int readable, int writable)
 {
 }
 
 /* process bgp peer */
 int bgp_process(struct bgp_peer *peer, int readable, int writable)
 {
-       if (!bgp_configured)
-                       return 0;
-
-       if (*peer->name && peer->cli_flag == BGP_CLI_RESTART)
-               return bgp_restart(peer);
-
-       if (peer->state == Disabled)
-                       return 1;
-
-       if (peer->cli_flag)
-       {
-               switch (peer->cli_flag)
-               {
-                       case BGP_CLI_SUSPEND:
-                               if (peer->routing)
-                               {
-                                       peer->routing = 0;
-                                       if (peer->state == Established)
-                                               peer->update_routes = 1;
-                               }
-
-                               break;
-
-                       case BGP_CLI_ENABLE:
-                               if (!peer->routing)
-                               {
-                                       peer->routing = 1;
-                                       if (peer->state == Established)
-                                               peer->update_routes = 1;
-                               }
-
-                               break;
-               }
-
-               peer->cli_flag = 0;
-       }
+    if (!bgp_configured)
+       return 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);
-
-               if (!r)
-                       return 0;
-       }
+    if (*peer->name && peer->cli_flag == BGP_CLI_RESTART)
+       return bgp_restart(peer);
 
 
-       if (readable)
-       {
-               if (!bgp_read(peer))
-                       return 0;
-       }
+    if (peer->state == Disabled)
+       return 1;
 
 
-       /* 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 (peer->cli_flag)
+    {
+       switch (peer->cli_flag)
        {
        {
-               if (bgp_handle_input(peer) < 0)
-                       return 0;
+       case BGP_CLI_SUSPEND:
+           if (peer->routing)
+           {
+               peer->routing = 0;
+               if (peer->state == Established)
+                   peer->update_routes = 1;
+           }
+
+           break;
+
+       case BGP_CLI_ENABLE:
+           if (!peer->routing)
+           {
+               peer->routing = 1;
+               if (peer->state == Established)
+                   peer->update_routes = 1;
+           }
+
+           break;
        }
 
        }
 
-       /* process pending updates */
-       if (peer->update_routes
-               && !peer->outbuf->packet.header.len) /* ditto */
-       {
-               if (!bgp_send_update(peer))
-                       return 0;
-       }
-
-       /* process timers */
-       if (peer->state == Established)
-       {
-               if (time_now > peer->expire_time)
-               {
-                       log(1, 0, 0, 0, "No message from BGP peer %s in %ds\n",
-                               peer->name, peer->hold);
+       peer->cli_flag = 0;
+    }
 
 
-                       bgp_send_notification(peer, BGP_ERR_HOLD_TIMER_EXP, 0);
-                       return 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);
 
 
-               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)
+       if (!r)
+           return 0;
+    }
+
+    if (readable)
+    {
+       if (!bgp_read(peer))
+           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)
+           return 0;
+    }
+
+    /* process pending updates */
+    if (peer->update_routes
+       && !peer->outbuf->packet.header.len) /* ditto */
+    {
+       if (!bgp_send_update(peer))
+           return 0;
+    }
+
+    /* process timers */
+    if (peer->state == Established)
+    {
+       if (time_now > peer->expire_time)
        {
        {
-               log(1, 0, 0, 0, "%s timer expired for BGP peer %s\n",
-                       bgp_state_str(peer->state), peer->name);
+           log(1, 0, 0, 0, "No message from BGP peer %s in %ds\n",
+               peer->name, peer->hold);
 
 
-               return bgp_restart(peer);
+           bgp_send_notification(peer, BGP_ERR_HOLD_TIMER_EXP, 0);
+           return 0;
        }
 
        }
 
-       return 1;
+       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);
+
+       return bgp_restart(peer);
+    }
+
+    return 1;
 }
 
 static void bgp_free_routes(struct bgp_route_list *routes)
 {
 }
 
 static void bgp_free_routes(struct bgp_route_list *routes)
 {
-       struct bgp_route_list *tmp;
+    struct bgp_route_list *tmp;
 
 
-       while ((tmp = routes))
-       {
-               routes = tmp->next;
-               free(tmp);
-       }
+    while ((tmp = routes))
+    {
+       routes = tmp->next;
+       free(tmp);
+    }
 }
 
 static char const *bgp_state_str(enum bgp_state state)
 {
 }
 
 static char const *bgp_state_str(enum bgp_state state)
 {
-       switch (state)
-       {
-       case Disabled:          return "Disabled";
-       case Idle:                              return "Idle";
-       case Connect:           return "Connect";
-       case Active:            return "Active";
-       case OpenSent:          return "OpenSent";
-       case OpenConfirm:               return "OpenConfirm";
-       case Established:               return "Established";
-       }
-
-       return "?";
+    switch (state)
+    {
+    case Disabled:     return "Disabled";
+    case Idle:         return "Idle";
+    case Connect:      return "Connect";
+    case Active:       return "Active";
+    case OpenSent:     return "OpenSent";
+    case OpenConfirm:  return "OpenConfirm";
+    case Established:  return "Established";
+    }
+
+    return "?";
 }
 
 static char const *bgp_msg_type_str(u8 type)
 {
 }
 
 static char const *bgp_msg_type_str(u8 type)
 {
-       switch (type)
-       {
-       case BGP_MSG_OPEN:                              return "OPEN";
-       case BGP_MSG_UPDATE:            return "UPDATE";
-       case BGP_MSG_NOTIFICATION:              return "NOTIFICATION";
-       case BGP_MSG_KEEPALIVE:         return "KEEPALIVE";
-       }
-
-       return "?";
+    switch (type)
+    {
+    case BGP_MSG_OPEN:         return "OPEN";
+    case BGP_MSG_UPDATE:       return "UPDATE";
+    case BGP_MSG_NOTIFICATION: return "NOTIFICATION";
+    case BGP_MSG_KEEPALIVE:    return "KEEPALIVE";
+    }
+
+    return "?";
 }
 
 /* attempt to connect to peer */
 static int bgp_connect(struct bgp_peer *peer)
 {
 }
 
 /* attempt to connect to peer */
 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;
 
 
-       if (!bgp_port)
+    if (!bgp_port)
+    {
+       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));
-                       return 0;
-               }
-
-               bgp_port = serv->s_port;
+           log(0, 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",
-                       peer->name, strerror(errno));
-
-               peer->state = peer->next_state = Disabled;
-               return 0;
-       }
+       bgp_port = serv->s_port;
+    }
 
 
-       /* set to non-blocking */
-       fcntl(peer->sock, F_SETFL, fcntl(peer->sock, F_GETFL, 0) | O_NONBLOCK);
+    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",
+           peer->name, strerror(errno));
 
 
-       /* try connect */
-       memset(&addr, 0, sizeof(addr));
-       addr.sin_family = AF_INET;
-       addr.sin_port = bgp_port;
-       addr.sin_addr.s_addr = peer->addr;
+       peer->state = peer->next_state = Disabled;
+       return 0;
+    }
 
 
-       while (connect(peer->sock, (struct sockaddr *) &addr, sizeof(addr)) == -1)
-       {
-               if (errno == EINTR) /* SIGALARM handler */
-                       continue;
+    /* 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",
-                               inet_ntoa(addr.sin_addr), strerror(errno));
+    /* try connect */
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = bgp_port;
+    addr.sin_addr.s_addr = peer->addr;
 
 
-                       bgp_set_retry(peer);
-                       return 0;
-               }
+    while (connect(peer->sock, (struct sockaddr *) &addr, sizeof(addr)) == -1)
+    {
+       if (errno == EINTR) /* SIGALARM handler */
+           continue;
 
 
-               peer->state = Connect;
-               peer->state_time = time_now;
+       if (errno != EINPROGRESS)
+       {
+           log(1, 0, 0, 0, "Can't connect to BGP peer %s (%s)\n",
+               inet_ntoa(addr.sin_addr), strerror(errno));
 
 
-               log(4, 0, 0, 0, "BGP peer %s: state Connect\n", peer->name);
-               return 1;
+           bgp_set_retry(peer);
+           return 0;
        }
 
        }
 
-       peer->state = Active;
+       peer->state = Connect;
        peer->state_time = time_now;
        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 Connect\n", peer->name);
+       return 1;
+    }
+
+    peer->state = Active;
+    peer->state_time = time_now;
+    peer->retry_time = peer->retry_count = 0;
 
 
-       return bgp_send_open(peer);
+    log(4, 0, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr.sin_addr));
+
+    return bgp_send_open(peer);
 }
 
 /* complete partial connection (state = Connect) */
 static int bgp_handle_connect(struct bgp_peer *peer)
 {
 }
 
 /* complete partial connection (state = Connect) */
 static int bgp_handle_connect(struct bgp_peer *peer)
 {
-       int err = 0;
-       int 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,
-                       strerror(err));
+    int err = 0;
+    int 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,
+           strerror(err));
 
 
-               bgp_set_retry(peer);
-               return 0;
-       }
+       bgp_set_retry(peer);
+       return 0;
+    }
 
 
-       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);
 }
 
 /* initiate a write */
 static int bgp_write(struct bgp_peer *peer)
 {
 }
 
 /* initiate a write */
 static int bgp_write(struct bgp_peer *peer)
 {
-       int len = htons(peer->outbuf->packet.header.len);
-       int r;
+    int len = htons(peer->outbuf->packet.header.len);
+    int r;
 
 
-       while ((r = write(peer->sock, &peer->outbuf->packet + peer->outbuf->done,
-               len - peer->outbuf->done)) == -1)
-       {
-               if (errno == EINTR)
-                       continue;
+    while ((r = write(peer->sock, &peer->outbuf->packet + peer->outbuf->done,
+       len - peer->outbuf->done)) == -1)
+    {
+       if (errno == EINTR)
+           continue;
 
 
-               if (errno == EAGAIN)
-                       return 1;
+       if (errno == EAGAIN)
+           return 1;
 
 
-               if (errno == EPIPE)
-                       log(1, 0, 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,
-                               strerror(errno));
+       if (errno == EPIPE)
+           log(1, 0, 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,
+               strerror(errno));
 
 
-               bgp_set_retry(peer);
-               return 0;
-       }
+       bgp_set_retry(peer);
+       return 0;
+    }
 
 
-       if (r < len)
-       {
-               peer->outbuf->done += r;
-               return 1;
-       }
+    if (r < len)
+    {
+       peer->outbuf->done += r;
+       return 1;
+    }
 
 
-       log(4, 0, 0, 0, "Sent %s to BGP peer %s\n",
-               bgp_msg_type_str(peer->outbuf->packet.header.type), peer->name);
+    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;
-       peer->outbuf->done = 0;
+    peer->outbuf->packet.header.len = 0;
+    peer->outbuf->done = 0;
 
 
-       if (peer->state == Established)
-               peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME;
+    if (peer->state == Established)
+       peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME;
 
 
-       if (peer->state != peer->next_state)
+    if (peer->state != peer->next_state)
+    {
+       if (peer->next_state == Disabled || peer->next_state == Idle)
        {
        {
-               if (peer->next_state == Disabled || peer->next_state == Idle)
-               {
-                       bgp_clear(peer);
-                       return 0;
-               }
+           bgp_clear(peer);
+           return 0;
+       }
 
 
-               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,
-                       bgp_state_str(peer->state));
-       }
+       log(4, 0, 0, 0, "BGP peer %s: state %s\n", peer->name,
+           bgp_state_str(peer->state));
+    }
 
 
-       return 1;
+    return 1;
 }
 
 /* initiate a read */
 static int bgp_read(struct bgp_peer *peer)
 {
 }
 
 /* initiate a read */
 static int bgp_read(struct bgp_peer *peer)
 {
-       int r;
+    int r;
 
 
-       while ((r = read(peer->sock, &peer->inbuf->packet + peer->inbuf->done,
-               BGP_MAX_PACKET_SIZE - peer->inbuf->done)) < 1)
+    while ((r = read(peer->sock, &peer->inbuf->packet + peer->inbuf->done,
+       BGP_MAX_PACKET_SIZE - peer->inbuf->done)) < 1)
+    {
+       if (!r)
        {
        {
-               if (!r)
-               {
-                       log(1, 0, 0, 0, "Connection to BGP peer %s closed\n", peer->name);
-               }
-               else
-               {
-                       if (errno == EINTR)
-                               continue;
-
-                       if (errno == EAGAIN)
-                               return 1;
+           log(1, 0, 0, 0, "Connection to BGP peer %s closed\n", peer->name);
+       }
+       else
+       {
+           if (errno == EINTR)
+               continue;
 
 
-                       log(1, 0, 0, 0, "Can't read from BGP peer %s (%s)\n", peer->name,
-                               strerror(errno));
-               }
+           if (errno == EAGAIN)
+               return 1;
 
 
-               bgp_set_retry(peer);
-               return 0;
+           log(1, 0, 0, 0, "Can't read from BGP peer %s (%s)\n", peer->name,
+               strerror(errno));
        }
 
        }
 
-       peer->inbuf->done += r;
-       return 1;
+       bgp_set_retry(peer);
+       return 0;
+    }
+
+    peer->inbuf->done += r;
+    return 1;
 }
 
 /* process buffered packets */
 static int bgp_handle_input(struct bgp_peer *peer)
 {
 }
 
 /* process buffered packets */
 static int bgp_handle_input(struct bgp_peer *peer)
 {
-       struct bgp_packet *p = &peer->inbuf->packet;
-       int len = ntohs(p->header.len);
+    struct bgp_packet *p = &peer->inbuf->packet;
+    int len = ntohs(p->header.len);
 
 
-       if (len > BGP_MAX_PACKET_SIZE)
-       {
-               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;
-       }
+    if (len > BGP_MAX_PACKET_SIZE)
+    {
+       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;
+    }
 
 
-       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",
-               bgp_msg_type_str(p->header.type), peer->name);
+    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)
+    switch (p->header.type)
+    {
+    case BGP_MSG_OPEN:
        {
        {
-       case BGP_MSG_OPEN:
+           struct bgp_data_open data;
+           int i;
+
+           for (i = 0; i < sizeof(p->header.marker); i++)
+           {
+               if ((unsigned char) p->header.marker[i] != 0xff)
                {
                {
-                       struct bgp_data_open data;
-                       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",
-                                               peer->name);
-
-                                       bgp_send_notification(peer, BGP_ERR_HEADER,
-                                               BGP_ERR_HDR_NOT_SYNC);
-
-                                       return 0;
-                               }
-                       }
-
-                       if (peer->state != OpenSent)
-                       {
-                               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);
-                               return 0;
-                       }
-
-                       memcpy(&data, p->data, len - sizeof(p->header));
-
-                       if (data.version != BGP_VERSION)
-                       {
-                               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);
-                               return 0;
-                       }
-
-                       if (ntohs(data.as) != peer->as)
-                       {
-                               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);
-
-                               bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_BAD_AS);
-                               return 0;
-                       }
-
-                       if ((peer->hold = ntohs(data.hold_time)) < 10)
-                       {
-                               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);
-                               return 0;
-                       }
-
-                       /* next transition requires an exchange of keepalives */
-                       bgp_send_keepalive(peer);
-
-                       /* FIXME: may need to check for optional params */
-               }
+                   log(1, 0, 0, 0, "Invalid marker from BGP peer %s\n",
+                       peer->name);
 
 
-               break;
+                   bgp_send_notification(peer, BGP_ERR_HEADER,
+                       BGP_ERR_HDR_NOT_SYNC);
 
 
-       case BGP_MSG_KEEPALIVE:
-               if (peer->state == OpenConfirm)
-               {
-                       peer->state = peer->next_state = Established;
-                       peer->state_time = time_now;
-                       peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME;
-                       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);
+                   return 0;
                }
                }
+           }
 
 
-               break;
+           if (peer->state != OpenSent)
+           {
+               log(1, 0, 0, 0, "OPEN from BGP peer %s in %s state\n",
+                   peer->name, bgp_state_str(peer->state));
 
 
-       case BGP_MSG_NOTIFICATION:
-               if (len > sizeof(p->header))
-               {
-                       struct bgp_data_notification *notification =
-                               (struct bgp_data_notification *) p->data;
-
-                       if (notification->error_code == BGP_ERR_CEASE)
-                       {
-                               log(4, 0, 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",
-                               peer->name, (int) notification->error_code);
-               }
+               bgp_send_notification(peer, BGP_ERR_FSM, 0);
+               return 0;
+           }
+
+           memcpy(&data, p->data, len - sizeof(p->header));
 
 
-               break;
+           if (data.version != BGP_VERSION)
+           {
+               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);
+               return 0;
+           }
+
+           if (ntohs(data.as) != peer->as)
+           {
+               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);
+
+               bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_BAD_AS);
+               return 0;
+           }
+
+           if ((peer->hold = ntohs(data.hold_time)) < 10)
+           {
+               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);
+               return 0;
+           }
+
+           /* next transition requires an exchange of keepalives */
+           bgp_send_keepalive(peer);
+
+           /* FIXME: may need to check for optional params */
        }
 
        }
 
-       /* reset timer */
-       peer->expire_time = time_now + peer->hold;
+       break;
 
 
-       /* see if there's another message in the same packet/buffer */
-       if (peer->inbuf->done > len)
+    case BGP_MSG_KEEPALIVE:
+       if (peer->state == OpenConfirm)
        {
        {
-               peer->inbuf->done -= len;
-               memmove(p, (char *) p + len, peer->inbuf->done);
+           peer->state = peer->next_state = Established;
+           peer->state_time = time_now;
+           peer->keepalive_time = time_now + BGP_KEEPALIVE_TIME;
+           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);
        }
        }
-       else
+
+       break;
+
+    case BGP_MSG_NOTIFICATION:
+       if (len > sizeof(p->header))
        {
        {
-               peer->inbuf->packet.header.len = 0;
-               peer->inbuf->done = 0;
+           struct bgp_data_notification *notification =
+               (struct bgp_data_notification *) p->data;
+
+           if (notification->error_code == BGP_ERR_CEASE)
+           {
+               log(4, 0, 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",
+               peer->name, (int) notification->error_code);
        }
 
        }
 
-       return peer->inbuf->done;
+       break;
+    }
+
+    /* reset timer */
+    peer->expire_time = time_now + peer->hold;
+
+    /* see if there's another message in the same packet/buffer */
+    if (peer->inbuf->done > len)
+    {
+       peer->inbuf->done -= len;
+       memmove(p, (char *) p + len, peer->inbuf->done);
+    }
+    else
+    {
+       peer->inbuf->packet.header.len = 0;
+       peer->inbuf->done = 0;
+    }
+
+    return peer->inbuf->done;
 }
 
 /* send/buffer OPEN message */
 static int bgp_send_open(struct bgp_peer *peer)
 {
 }
 
 /* send/buffer OPEN message */
 static int bgp_send_open(struct bgp_peer *peer)
 {
-       struct bgp_data_open data;
-       u16 len = sizeof(peer->outbuf->packet.header);
+    struct bgp_data_open data;
+    u16 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));
 
 
-       peer->outbuf->packet.header.type = BGP_MSG_OPEN;
+    peer->outbuf->packet.header.type = BGP_MSG_OPEN;
 
 
-       data.version = BGP_VERSION;
-       data.as = htons(our_as);
-       data.hold_time = htons(BGP_HOLD_TIME);
-       data.identifier = my_address;
-       data.opt_len = 0;
+    data.version = BGP_VERSION;
+    data.as = htons(our_as);
+    data.hold_time = htons(BGP_HOLD_TIME);
+    data.identifier = my_address;
+    data.opt_len = 0;
 
 
-       memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE);
-       len += BGP_DATA_OPEN_SIZE;
+    memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE);
+    len += BGP_DATA_OPEN_SIZE;
 
 
-       peer->outbuf->packet.header.len = htons(len);
-       peer->outbuf->done = 0;
-       peer->next_state = OpenSent;
+    peer->outbuf->packet.header.len = htons(len);
+    peer->outbuf->done = 0;
+    peer->next_state = OpenSent;
 
 
-       return bgp_write(peer);
+    return bgp_write(peer);
 }
 
 /* send/buffer KEEPALIVE message */
 static int bgp_send_keepalive(struct bgp_peer *peer)
 {
 }
 
 /* send/buffer KEEPALIVE message */
 static int bgp_send_keepalive(struct bgp_peer *peer)
 {
-       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));
 
 
-       peer->outbuf->packet.header.type = BGP_MSG_KEEPALIVE;
-       peer->outbuf->packet.header.len =
-               htons(sizeof(peer->outbuf->packet.header));
+    peer->outbuf->packet.header.type = BGP_MSG_KEEPALIVE;
+    peer->outbuf->packet.header.len =
+       htons(sizeof(peer->outbuf->packet.header));
 
 
-       peer->outbuf->done = 0;
-       peer->next_state = (peer->state == OpenSent) ? OpenConfirm : peer->state;
+    peer->outbuf->done = 0;
+    peer->next_state = (peer->state == OpenSent) ? OpenConfirm : peer->state;
 
 
-       return bgp_write(peer);
+    return bgp_write(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);
-       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 *add = 0;
-       int s;
-
-       char *data = (char *) &peer->outbuf->packet.data;
-
-       /* need leave room for attr_len, bgp_path_attrs and one prefix */
-       char *max = (char *) &peer->outbuf->packet.data
-               + sizeof(peer->outbuf->packet.data)
-               - sizeof(attr_len) - peer->path_attr_len - sizeof(struct bgp_ip_prefix);
-
-       /* skip over unf_len */
-       data += sizeof(unf_len);
-       len += sizeof(unf_len);
-
-       memset(peer->outbuf->packet.header.marker, 0xff,
-               sizeof(peer->outbuf->packet.header.marker));
-
-       peer->outbuf->packet.header.type = BGP_MSG_UPDATE;
-
-       peer->update_routes = 0; /* tentatively clear */
+    u16 unf_len = 0;
+    u16 attr_len;
+    u16 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 *add = 0;
+    int s;
+
+    char *data = (char *) &peer->outbuf->packet.data;
+
+    /* need leave room for attr_len, bgp_path_attrs and one prefix */
+    char *max = (char *) &peer->outbuf->packet.data
+       + sizeof(peer->outbuf->packet.data)
+       - sizeof(attr_len) - peer->path_attr_len - sizeof(struct bgp_ip_prefix);
+
+    /* skip over unf_len */
+    data += sizeof(unf_len);
+    len += sizeof(unf_len);
+
+    memset(peer->outbuf->packet.header.marker, 0xff,
+       sizeof(peer->outbuf->packet.header.marker));
+
+    peer->outbuf->packet.header.type = BGP_MSG_UPDATE;
+
+    peer->update_routes = 0; /* tentatively clear */
+
+    /* find differences */
+    while ((have || want) && data < (max - sizeof(struct bgp_ip_prefix)))
+    {
+       if (have)
+           s = want
+               ? memcmp(&have->dest, &want->dest, sizeof(have->dest))
+               : -1;
+       else
+           s = 1;
 
 
-       /* find differences */
-       while ((have || want) && data < (max - sizeof(struct bgp_ip_prefix)))
+       if (s < 0) /* found one to delete */
        {
        {
-               if (have)
-                       s = want
-                               ? memcmp(&have->dest, &want->dest, sizeof(have->dest))
-                                       : -1;
-               else
-                       s = 1;
-
-               if (s < 0) /* found one to delete */
-               {
-                       struct bgp_route_list *tmp = have;
-                       have = have->next;
+           struct bgp_route_list *tmp = have;
+           have = have->next;
 
 
-                       s = BGP_IP_PREFIX_SIZE(tmp->dest);
-                       memcpy(data, &tmp->dest, s);
-                       data += s;
-                       unf_len += s;
-                       len += s;
+           s = BGP_IP_PREFIX_SIZE(tmp->dest);
+           memcpy(data, &tmp->dest, s);
+           data += 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, 0, "Withdrawing route %s/%d from BGP peer %s\n",
+               inet_toa(tmp->dest.prefix), tmp->dest.len, peer->name);
 
 
-                       free(tmp);
+           free(tmp);
 
 
-                       if (e)
-                               e->next = have;
-                       else
-                                       peer->routes = have;
-               }
-               else
-               {
-                       if (!s) /* same */
-                       {
-                               e = have; /* stash the last found to relink above */
-                               have = have->next;
-                               want = want->next;
-                       }
-                       else if (s > 0) /* addition reqd. */
-                       {
-                               if (add)
-                               {
-                                       peer->update_routes = 1; /* only one add per packet */
-                                       if (!have)
-                                                       break;
-                               }
-                               else
-                                       add = want;
-
-                               if (want)
-                                       want = want->next;
-                       }
-               }
+           if (e)
+               e->next = have;
+           else
+               peer->routes = have;
        }
        }
-
-       if (have || want)
-               peer->update_routes = 1; /* more to do */
-
-       /* anything changed? */
-       if (!(unf_len || add))
-               return 1;
-
-       /* go back and insert unf_len */
-       unf_len = htons(unf_len);
-       memcpy(&peer->outbuf->packet.data, &unf_len, sizeof(unf_len));
-
-       if (add)
+       else
        {
        {
-               if (!(e = malloc(sizeof(*e))))
+           if (!s) /* same */
+           {
+               e = have; /* stash the last found to relink above */
+               have = have->next;
+               want = want->next;
+           }
+           else if (s > 0) /* addition reqd. */
+           {
+               if (add)
                {
                {
-                       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;
+                   peer->update_routes = 1; /* only one add per packet */
+                   if (!have)
+                       break;
                }
                }
+               else
+                   add = want;
 
 
-               memcpy(e, add, sizeof(*e));
-               e->next = 0;
-               peer->routes = bgp_insert_route(peer->routes, e);
+               if (want)
+                   want = want->next;
+           }
+       }
+    }
 
 
-               attr_len = htons(peer->path_attr_len);
-               memcpy(data, &attr_len, sizeof(attr_len));
-               data += sizeof(attr_len);
-               len += sizeof(attr_len);
+    if (have || want)
+       peer->update_routes = 1; /* more to do */
 
 
-               memcpy(data, peer->path_attrs, peer->path_attr_len);
-               data += peer->path_attr_len;
-               len += peer->path_attr_len;
+    /* anything changed? */
+    if (!(unf_len || add))
+       return 1;
 
 
-               s = BGP_IP_PREFIX_SIZE(add->dest);
-               memcpy(data, &add->dest, s);
-               data += s;
-               len += s;
+    /* go back and insert unf_len */
+    unf_len = htons(unf_len);
+    memcpy(&peer->outbuf->packet.data, &unf_len, sizeof(unf_len));
 
 
-               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
+    if (add)
+    {
+       if (!(e = malloc(sizeof(*e))))
        {
        {
-               attr_len = 0;
-               memcpy(data, &attr_len, sizeof(attr_len));
-               data += sizeof(attr_len);
-               len += sizeof(attr_len);
-       }
+           log(0, 0, 0, 0, "Can't allocate route for %s/%d (%s)\n",
+               inet_toa(add->dest.prefix), add->dest.len, strerror(errno));
 
 
-       peer->outbuf->packet.header.len = htons(len);
-       peer->outbuf->done = 0;
+           return 0;
+       }
 
 
-       return bgp_write(peer);
+       memcpy(e, add, sizeof(*e));
+       e->next = 0;
+       peer->routes = bgp_insert_route(peer->routes, e);
+
+       attr_len = htons(peer->path_attr_len);
+       memcpy(data, &attr_len, sizeof(attr_len));
+       data += sizeof(attr_len);
+       len += sizeof(attr_len);
+
+       memcpy(data, peer->path_attrs, peer->path_attr_len);
+       data += peer->path_attr_len;
+       len += peer->path_attr_len;
+
+       s = BGP_IP_PREFIX_SIZE(add->dest);
+       memcpy(data, &add->dest, 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);
+    }
+    else
+    {
+       attr_len = 0;
+       memcpy(data, &attr_len, sizeof(attr_len));
+       data += sizeof(attr_len);
+       len += sizeof(attr_len);
+    }
+
+    peer->outbuf->packet.header.len = htons(len);
+    peer->outbuf->done = 0;
+
+    return bgp_write(peer);
 }
 
 /* send/buffer NOTIFICATION message */
 static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode)
 {
 }
 
 /* send/buffer NOTIFICATION message */
 static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode)
 {
-       struct bgp_data_notification data;
-       u16 len = 0;
+    struct bgp_data_notification data;
+    u16 len = 0;
 
 
-       data.error_code = code;
-       len += sizeof(data.error_code);
+    data.error_code = code;
+    len += sizeof(data.error_code);
 
 
-       data.error_subcode = subcode;
-       len += sizeof(data.error_code);
+    data.error_subcode = subcode;
+    len += sizeof(data.error_code);
 
 
-       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));
 
 
-       peer->outbuf->packet.header.type = BGP_MSG_NOTIFICATION;
-       peer->outbuf->packet.header.len =
-               htons(sizeof(peer->outbuf->packet.header) + len);
+    peer->outbuf->packet.header.type = BGP_MSG_NOTIFICATION;
+    peer->outbuf->packet.header.len =
+       htons(sizeof(peer->outbuf->packet.header) + len);
 
 
-       memcpy(peer->outbuf->packet.data, &data, len);
+    memcpy(peer->outbuf->packet.data, &data, len);
 
 
-       peer->outbuf->done = 0;
-       peer->next_state = code == BGP_ERR_CEASE ? Disabled : Idle;
+    peer->outbuf->done = 0;
+    peer->next_state = code == BGP_ERR_CEASE ? Disabled : Idle;
 
 
-       /* we're dying; ignore any pending input */
-       peer->inbuf->packet.header.len = 0;
-       peer->inbuf->done = 0;
+    /* we're dying; ignore any pending input */
+    peer->inbuf->packet.header.len = 0;
+    peer->inbuf->done = 0;
 
 
-       return bgp_write(peer);
+    return bgp_write(peer);
 }
 
 /* CLI stuff */
 }
 
 /* CLI stuff */
@@ -1179,151 +1181,152 @@ static int bgp_send_notification(struct bgp_peer *peer, u8 code, u8 subcode)
 
 int cmd_show_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
 
 int cmd_show_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
-       int i;
-       int hdr = 0;
-       char *addr;
+    int i;
+    int hdr = 0;
+    char *addr;
 
 
-       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);
+    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);
 
 
-       time(&time_now);
+    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;
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+    {
+       if (!*bgp_peers[i].name)
+           continue;
 
 
-               if (!hdr++)
-               {
-                       cli_print(cli, "");
-                       cli_print(cli, "Peer                              AS             Address "
-                               "State     Retries Retry in Route Pend");
-                       cli_print(cli, "------------------ ----- --------------- "
-                               "----------- ------- -------- ----- ----");
-               }
+       addr = inet_toa(bgp_peers[i].addr);
+       if (argc && strcmp(addr, argv[0]) &&
+         strncmp(bgp_peers[i].name, argv[0], strlen(argv[0])))
+           continue;
 
 
-               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");
+       if (!hdr++)
+       {
+           cli_print(cli, "");
+           cli_print(cli, "Peer                  AS         Address "
+               "State       Retries Retry in Route Pend");
+           cli_print(cli, "------------------ ----- --------------- "
+               "----------- ------- -------- ----- ----");
        }
 
        }
 
-       return CLI_OK;
+       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 cmd_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
-       int i;
-       char *addr;
+    int i;
+    char *addr;
 
 
-       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);
+    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;
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+    {
+       if (bgp_peers[i].state != Established)
+           continue;
 
 
-               if (!bgp_peers[i].routing)
-                       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;
+       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);
-       }
+       bgp_peers[i].cli_flag = BGP_CLI_SUSPEND;
+       cli_print(cli, "Suspending peer %s", bgp_peers[i].name);
+    }
 
 
-       return CLI_OK;
+    return CLI_OK;
 }
 
 int cmd_no_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
 }
 
 int cmd_no_suspend_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
-       int i;
-       char *addr;
+    int i;
+    char *addr;
 
 
-       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);
+    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;
+    for (i = 0; i < BGP_NUM_PEERS; i++)
+    {
+       if (bgp_peers[i].state != Established)
+           continue;
 
 
-               if (bgp_peers[i].routing)
-                       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;
+       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);
-       }
+       bgp_peers[i].cli_flag = BGP_CLI_ENABLE;
+       cli_print(cli, "Un-suspending peer %s", bgp_peers[i].name);
+    }
 
 
-       return CLI_OK;
+    return CLI_OK;
 }
 
 int cmd_restart_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
 }
 
 int cmd_restart_bgp(struct cli_def *cli, char *command, char **argv, int argc)
 {
-       int i;
-       char *addr;
+    int i;
+    char *addr;
 
 
-       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);
+    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;
+    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;
+       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);
-       }
+       bgp_peers[i].cli_flag = BGP_CLI_RESTART;
+       cli_print(cli, "Restarting peer %s", bgp_peers[i].name);
+    }
 
 
-       return CLI_OK;
+    return CLI_OK;
 }
 }
diff --git a/cli.c b/cli.c
index 772c32d..18d59ee 100644 (file)
--- a/cli.c
+++ b/cli.c
@@ -2,7 +2,7 @@
 // vim: sw=8 ts=8
 
 char const *cvs_name = "$Name:  $";
 // vim: sw=8 ts=8
 
 char const *cvs_name = "$Name:  $";
-char const *cvs_id_cli = "$Id: cli.c,v 1.14 2004/08/26 06:24:12 fred_nerk Exp $";
+char const *cvs_id_cli = "$Id: cli.c,v 1.15 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <stdio.h>
 #include <stdarg.h>
 
 #include <stdio.h>
 #include <stdarg.h>
@@ -397,7 +397,7 @@ int cmd_show_session(struct cli_def *cli, char *command, char **argv, int argc)
                        cli_print(cli, "                Called Num:             %s", session[s].called);
                        cli_print(cli, "                Tunnel ID:              %d", session[s].tunnel);
                        cli_print(cli, "                IP address:             %s", inet_toa(htonl(session[s].ip)));
                        cli_print(cli, "                Called Num:             %s", session[s].called);
                        cli_print(cli, "                Tunnel ID:              %d", session[s].tunnel);
                        cli_print(cli, "                IP address:             %s", inet_toa(htonl(session[s].ip)));
-                       cli_print(cli, "                HSD sid:                %lu", session[s].sid);
+                       cli_print(cli, "                Unique SID:             %lu", session[s].unique_id);
                        cli_print(cli, "                Idle time:              %u seconds", abs(time_now - session[s].last_packet));
                        cli_print(cli, "                Next Recv:              %u", session[s].nr);
                        cli_print(cli, "                Next Send:              %u", session[s].ns);
                        cli_print(cli, "                Idle time:              %u seconds", abs(time_now - session[s].last_packet));
                        cli_print(cli, "                Next Recv:              %u", session[s].nr);
                        cli_print(cli, "                Next Send:              %u", session[s].ns);
index 4348b5a..7caa8cc 100644 (file)
--- a/cluster.c
+++ b/cluster.c
@@ -1,6 +1,6 @@
 // L2TPNS Clustering Stuff
 
 // L2TPNS Clustering Stuff
 
-char const *cvs_id_cluster = "$Id: cluster.c,v 1.10 2004/08/02 06:06:28 fred_nerk Exp $";
+char const *cvs_id_cluster = "$Id: cluster.c,v 1.11 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <stdio.h>
 #include <sys/file.h>
 
 #include <stdio.h>
 #include <sys/file.h>
@@ -470,7 +470,7 @@ void cluster_check_slaves(void)
 //
 void cluster_check_master(void)
 {
 //
 void cluster_check_master(void)
 {
-       int i, count, tcount, high_sid = 0;
+       int i, count, tcount, high_unique_id = 0;
        int last_free = 0;
        clockt t = TIME;
        static int probed = 0;
        int last_free = 0;
        clockt t = TIME;
        static int probed = 0;
@@ -557,7 +557,7 @@ void cluster_check_master(void)
                // Re-string the free list.
                // Find the ID of the highest session.
        last_free = 0;
                // Re-string the free list.
                // Find the ID of the highest session.
        last_free = 0;
-       high_sid = 0;
+       high_unique_id = 0;
        config->cluster_highest_sessionid = 0;
        for (i = 0, count = 0; i < MAXSESSION; ++i) {
                if (session[i].tunnel == T_UNDEF) {
        config->cluster_highest_sessionid = 0;
        for (i = 0, count = 0; i < MAXSESSION; ++i) {
                if (session[i].tunnel == T_UNDEF) {
@@ -584,8 +584,8 @@ void cluster_check_master(void)
 
                session[i].radius = 0;  // Reset authentication as the radius blocks aren't up to date.
 
 
                session[i].radius = 0;  // Reset authentication as the radius blocks aren't up to date.
 
-               if (session[i].sid >= high_sid) // This is different to the index into the session table!!!
-                       high_sid = session[i].sid+1;
+               if (session[i].unique_id >= high_unique_id)     // This is different to the index into the session table!!!
+                       high_unique_id = session[i].unique_id+1;
 
 
                session[i].tbf_in = session[i].tbf_out = 0; // Remove stale pointers from old master.
 
 
                session[i].tbf_in = session[i].tbf_out = 0; // Remove stale pointers from old master.
@@ -603,7 +603,7 @@ void cluster_check_master(void)
        }
 
        session[last_free].next = 0;    // End of chain.
        }
 
        session[last_free].next = 0;    // End of chain.
-       last_sid = high_sid;            // Keep track of the highest used session ID.
+       last_id = high_unique_id;               // Keep track of the highest used session ID.
 
        become_master();
 
 
        become_master();
 
@@ -1389,7 +1389,7 @@ int processcluster(char * data, int size, u32 addr)
        return 0;
 
 shortpacket:
        return 0;
 
 shortpacket:
-       log(0,0,0,0, "I got an cluster heartbeat packet! This means I'm probably out of sync!!\n");
+       log(0,0,0,0, "I got a _short_ cluster heartbeat packet! This means I'm probably out of sync!!\n");
        return -1;
 }
 
        return -1;
 }
 
index 262ae31..eb7783b 100644 (file)
--- a/l2tpns.c
+++ b/l2tpns.c
@@ -4,7 +4,7 @@
 // Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced
 // vim: sw=8 ts=8
 
 // Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced
 // vim: sw=8 ts=8
 
-char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.24 2004/08/26 06:22:37 fred_nerk Exp $";
+char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.25 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <arpa/inet.h>
 #include <assert.h>
 
 #include <arpa/inet.h>
 #include <assert.h>
@@ -63,7 +63,7 @@ u32 sessionid = 0;            // session id for radius accounting
 int syslog_log = 0;            // are we logging to syslog
 FILE *log_stream = NULL;       // file handle for direct logging (i.e. direct into file, not via syslog).
 extern int cluster_sockfd;     // Intra-cluster communications socket.
 int syslog_log = 0;            // are we logging to syslog
 FILE *log_stream = NULL;       // file handle for direct logging (i.e. direct into file, not via syslog).
 extern int cluster_sockfd;     // Intra-cluster communications socket.
-u32 last_sid = 0;              // Last used PPP SID. Can I kill this?? -- mo
+u32 last_id = 0;               // Last used PPP SID. Can I kill this?? -- mo
 int clifd = 0;                 // Socket listening for CLI connections.
 
 struct cli_session_actions *cli_session_actions = NULL;        // Pending session changes requested by CLI
 int clifd = 0;                 // Socket listening for CLI connections.
 
 struct cli_session_actions *cli_session_actions = NULL;        // Pending session changes requested by CLI
@@ -1811,7 +1811,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
                                        // TBA
                                        break;
                                case 12:      // ICCN
                                        // TBA
                                        break;
                                case 12:      // ICCN
-                                       if ( amagic == 0) amagic = time_now;
+                                       if (amagic == 0) amagic = time_now;
                                        session[s].magic = amagic; // set magic number
                                        session[s].l2tp_flags = aflags; // set flags received
                                        log(3, ntohl(addr->sin_addr.s_addr), s, t, "Magic %X Flags %X\n", amagic, aflags);
                                        session[s].magic = amagic; // set magic number
                                        session[s].l2tp_flags = aflags; // set flags received
                                        log(3, ntohl(addr->sin_addr.s_addr), s, t, "Magic %X Flags %X\n", amagic, aflags);
@@ -2449,74 +2449,69 @@ void initdata(void)
 {
        int i;
 
 {
        int i;
 
-       _statistics = mmap(NULL, sizeof(struct Tstats), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (_statistics == MAP_FAILED)
+       if ((_statistics = shared_malloc(sizeof(struct Tstats))) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for _statistics: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for _statistics: %s\n", strerror(errno));
                exit(1);
        }
                exit(1);
        }
-       config = mmap(NULL, sizeof(struct configt), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (config == MAP_FAILED)
+       if ((config = shared_malloc(sizeof(struct configt))) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for configuration: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for configuration: %s\n", strerror(errno));
                exit(1);
        }
        memset(config, 0, sizeof(struct configt));
        time(&config->start_time);
        strncpy(config->config_file, CONFIGFILE, sizeof(config->config_file) - 1);
                exit(1);
        }
        memset(config, 0, sizeof(struct configt));
        time(&config->start_time);
        strncpy(config->config_file, CONFIGFILE, sizeof(config->config_file) - 1);
-       tunnel = mmap(NULL, sizeof(tunnelt) * MAXTUNNEL, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (tunnel == MAP_FAILED)
+       if ((tunnel = shared_malloc(sizeof(tunnelt) * MAXTUNNEL)) == MAP_FAILED);
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for tunnels: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for tunnels: %s\n", strerror(errno));
                exit(1);
        }
                exit(1);
        }
-       session = mmap(NULL, sizeof(sessiont) * MAXSESSION, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (session == MAP_FAILED)
+       if ((session = shared_malloc(sizeof(sessiont) * MAXSESSION)) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for sessions: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for sessions: %s\n", strerror(errno));
                exit(1);
        }
 
                exit(1);
        }
 
-       sess_count = mmap(NULL, sizeof(sessioncountt) * MAXSESSION, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (sess_count == MAP_FAILED)
+       if ((sess_count = shared_malloc(sizeof(sessioncountt) * MAXSESSION)) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for sessions_count: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for sessions_count: %s\n", strerror(errno));
                exit(1);
        }
 
                exit(1);
        }
 
-       radius = mmap(NULL, sizeof(radiust) * MAXRADIUS, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (radius == MAP_FAILED)
+       if ((radius = shared_malloc(sizeof(radiust) * MAXRADIUS)) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for radius: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for radius: %s\n", strerror(errno));
                exit(1);
        }
                exit(1);
        }
-       ip_address_pool = mmap(NULL, sizeof(ippoolt) * MAXIPPOOL, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (ip_address_pool == MAP_FAILED)
+
+       if ((ip_address_pool = shared_malloc(sizeof(ippoolt) * MAXIPPOOL)) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for ip_address_pool: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for ip_address_pool: %s\n", strerror(errno));
                exit(1);
        }
                exit(1);
        }
+
 #ifdef RINGBUFFER
 #ifdef RINGBUFFER
-       ringbuffer = mmap(NULL, sizeof(struct Tringbuffer), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (ringbuffer == MAP_FAILED)
+       if ((ringbuffer = shared_malloc(sizeof(struct Tringbuffer))) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for ringbuffer: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for ringbuffer: %s\n", strerror(errno));
                exit(1);
        }
        memset(ringbuffer, 0, sizeof(struct Tringbuffer));
 #endif
 
                exit(1);
        }
        memset(ringbuffer, 0, sizeof(struct Tringbuffer));
 #endif
 
-       cli_session_actions = mmap(NULL, sizeof(struct cli_session_actions) * MAXSESSION, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (cli_session_actions == MAP_FAILED)
+       if ((cli_session_actions = shared_malloc(sizeof(struct cli_session_actions) * MAXSESSION))
+                       == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for cli session actions: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for cli session actions: %s\n", strerror(errno));
                exit(1);
        }
        memset(cli_session_actions, 0, sizeof(struct cli_session_actions) * MAXSESSION);
                exit(1);
        }
        memset(cli_session_actions, 0, sizeof(struct cli_session_actions) * MAXSESSION);
-       cli_tunnel_actions = mmap(NULL, sizeof(struct cli_tunnel_actions) * MAXSESSION, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (cli_tunnel_actions == MAP_FAILED)
+
+       if ((cli_tunnel_actions = shared_malloc(sizeof(struct cli_tunnel_actions) * MAXSESSION))
+                       == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for cli tunnel actions: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for cli tunnel actions: %s\n", strerror(errno));
                exit(1);
        }
        memset(cli_tunnel_actions, 0, sizeof(struct cli_tunnel_actions) * MAXSESSION);
                exit(1);
        }
        memset(cli_tunnel_actions, 0, sizeof(struct cli_tunnel_actions) * MAXSESSION);
@@ -2549,10 +2544,9 @@ void initdata(void)
        _statistics->start_time = _statistics->last_reset = time(NULL);
 
 #ifdef BGP
        _statistics->start_time = _statistics->last_reset = time(NULL);
 
 #ifdef BGP
-       bgp_peers = mmap(NULL, sizeof(struct bgp_peer) * BGP_NUM_PEERS, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (bgp_peers == MAP_FAILED)
+       if ((bgp_peers = shared_malloc(sizeof(struct bgp_peer) * BGP_NUM_PEERS)) == MAP_FAILED)
        {
        {
-               log(0, 0, 0, 0, "Error doing mmap for bgp: %s\n", strerror(errno));
+               log(0, 0, 0, 0, "Error doing malloc for bgp: %s\n", strerror(errno));
                exit(1);
        }
 #endif /* BGP */
                exit(1);
        }
 #endif /* BGP */
@@ -3567,12 +3561,12 @@ int sessionsetup(tunnelidt t, sessionidt s)
        for (r = 0; r < MAXROUTE && session[s].route[r].ip; r++)
                routeset(s, session[s].route[r].ip, session[s].route[r].mask, session[s].ip, 1);
 
        for (r = 0; r < MAXROUTE && session[s].route[r].ip; r++)
                routeset(s, session[s].route[r].ip, session[s].route[r].mask, session[s].ip, 1);
 
-       if (!session[s].sid)
+       if (!session[s].unique_id)
        {
                // did this session just finish radius?
                log(3, session[s].ip, s, t, "Sending initial IPCP to client\n");
                sendipcp(t, s);
        {
                // did this session just finish radius?
                log(3, session[s].ip, s, t, "Sending initial IPCP to client\n");
                sendipcp(t, s);
-               session[s].sid = ++last_sid;
+               session[s].unique_id = ++last_id;
        }
 
        // Run the plugin's against this new session.
        }
 
        // Run the plugin's against this new session.
index 94e5cb4..31ee6a1 100644 (file)
--- a/l2tpns.h
+++ b/l2tpns.h
@@ -1,5 +1,5 @@
 // L2TPNS Global Stuff
 // L2TPNS Global Stuff
-// $Id: l2tpns.h,v 1.16 2004/08/26 04:44:26 fred_nerk Exp $
+// $Id: l2tpns.h,v 1.17 2004/09/02 04:18:07 fred_nerk Exp $
 
 #ifndef __L2TPNS_H__
 #define __L2TPNS_H__
 
 #ifndef __L2TPNS_H__
 #define __L2TPNS_H__
@@ -24,7 +24,7 @@
 
 #define RADIUS_SHIFT   5
 #define RADIUS_MASK    ((unsigned short)(((unsigned short)~0) >> (16 - RADIUS_SHIFT)))
 
 #define RADIUS_SHIFT   5
 #define RADIUS_MASK    ((unsigned short)(((unsigned short)~0) >> (16 - RADIUS_SHIFT)))
-#define        MAXRADIUS       ((2 << (RADIUS_SHIFT - 1)) * 255)
+#define        MAXRADIUS       ((unsigned long)(1L << RADIUS_SHIFT) * 255)
 
 #define T_UNDEF                (0xffff)        // A tunnel ID that won't ever be used. Mark session as undefined.
 #define T_FREE         (0)             // A tunnel ID that won't ever be used. Mark session as free.
 
 #define T_UNDEF                (0xffff)        // A tunnel ID that won't ever be used. Mark session as undefined.
 #define T_FREE         (0)             // A tunnel ID that won't ever be used. Mark session as free.
@@ -149,10 +149,10 @@ typedef struct sessions
 {
        sessionidt next;                // next session in linked list
        sessionidt far;                 // far end session ID
 {
        sessionidt next;                // next session in linked list
        sessionidt far;                 // far end session ID
-       tunnelidt tunnel;               // tunnel ID
+       tunnelidt tunnel;               // near end tunnel ID
        ipt ip;                         // IP of session set by RADIUS response (host byte order).
        int ip_pool_index;              // index to IP pool
        ipt ip;                         // IP of session set by RADIUS response (host byte order).
        int ip_pool_index;              // index to IP pool
-       unsigned long sid;              // session id for hsddb
+       unsigned long unique_id;        // unique session id
        u16 nr;                         // next receive
        u16 ns;                         // next send
        u32 magic;                      // ppp magic number
        u16 nr;                         // next receive
        u16 ns;                         // next send
        u32 magic;                      // ppp magic number
@@ -172,6 +172,7 @@ typedef struct sessions
        u16 tbf_in;                     // filter bucket for throttling in from the user.
        u16 tbf_out;                    // filter bucket for throttling out to the user.
        u8 l2tp_flags;                  // various bit flags from the ICCN on the l2tp tunnel.
        u16 tbf_in;                     // filter bucket for throttling in from the user.
        u16 tbf_out;                    // filter bucket for throttling out to the user.
        u8 l2tp_flags;                  // various bit flags from the ICCN on the l2tp tunnel.
+       u8 reserved_old_snoop;          // No longer used - remove at some time
        u8 walled_garden;               // is this session gardened?
        u8 flags1;                      // additional flags (currently unused);
        char random_vector[MAXTEL];
        u8 walled_garden;               // is this session gardened?
        u8 flags1;                      // additional flags (currently unused);
        char random_vector[MAXTEL];
@@ -184,7 +185,8 @@ typedef struct sessions
        u32 flags;                      // Various session flags.
        ipt snoop_ip;                   // Interception destination IP
        u16 snoop_port;                 // Interception destination port
        u32 flags;                      // Various session flags.
        ipt snoop_ip;                   // Interception destination IP
        u16 snoop_port;                 // Interception destination port
-       char reserved[28];              // Space to expand structure without changing HB_VERSION
+       u16 sid;                        // near end session id.
+       char reserved[20];              // Space to expand structure without changing HB_VERSION
 }
 sessiont;
 
 }
 sessiont;
 
@@ -589,7 +591,7 @@ if (count++ < max) { \
 extern struct configt *config;
 extern time_t basetime;                // Time when this process started.
 extern time_t time_now;                // Seconds since EPOCH.
 extern struct configt *config;
 extern time_t basetime;                // Time when this process started.
 extern time_t time_now;                // Seconds since EPOCH.
-extern u32 last_sid;
+extern u32 last_id;
 extern struct Tstats *_statistics;
 extern ipt my_address;
 extern int tun_write(u8 *data, int size);
 extern struct Tstats *_statistics;
 extern ipt my_address;
 extern int tun_write(u8 *data, int size);
diff --git a/ppp.c b/ppp.c
index 5c23833..669651d 100644 (file)
--- a/ppp.c
+++ b/ppp.c
@@ -1,6 +1,6 @@
 // L2TPNS PPP Stuff
 
 // L2TPNS PPP Stuff
 
-char const *cvs_id_ppp = "$Id: ppp.c,v 1.13 2004/08/26 04:44:26 fred_nerk Exp $";
+char const *cvs_id_ppp = "$Id: ppp.c,v 1.14 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>
@@ -676,7 +676,7 @@ void processipin(tunnelidt t, sessionidt s, u8 * p, u16 l)
 
        if (session[s].snoop_ip && session[s].snoop_port)
        {
 
        if (session[s].snoop_ip && session[s].snoop_port)
        {
-               // Snooping this session, send it to ASIO
+               // Snooping this session
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
        STAT(tun_tx_packets);
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
        STAT(tun_tx_packets);
@@ -814,7 +814,6 @@ void sendchap(tunnelidt t, sessionidt s)
 // returns start of PPP frame
 u8 *makeppp(u8 * b, int size, u8 * p, int l, tunnelidt t, sessionidt s, u16 mtype)
 {
 // returns start of PPP frame
 u8 *makeppp(u8 * b, int size, u8 * p, int l, tunnelidt t, sessionidt s, u16 mtype)
 {
-
        if (size < 12)
                return NULL;    // Need more space than this!!
 
        if (size < 12)
                return NULL;    // Need more space than this!!
 
index aa31ae2..5634775 100644 (file)
--- a/radius.c
+++ b/radius.c
@@ -1,6 +1,6 @@
 // L2TPNS Radius Stuff
 
 // L2TPNS Radius Stuff
 
-char const *cvs_id_radius = "$Id: radius.c,v 1.9 2004/07/26 00:20:41 fred_nerk Exp $";
+char const *cvs_id_radius = "$Id: radius.c,v 1.10 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include <time.h>
 #include <stdio.h>
 
 #include <time.h>
 #include <stdio.h>
@@ -606,7 +606,7 @@ void processrad(u8 *buf, int len, char socket_index)
                        }
 
                        // Valid Session, set it up
                        }
 
                        // Valid Session, set it up
-                       session[s].sid = 0;
+                       session[s].unique_id = 0;
                        sessionsetup(t, s);
                }
                else
                        sessionsetup(t, s);
                }
                else
diff --git a/tbf.c b/tbf.c
index 7a83136..117ebd8 100644 (file)
--- a/tbf.c
+++ b/tbf.c
@@ -1,6 +1,6 @@
 // L2TPNS: token bucket filters
 
 // L2TPNS: token bucket filters
 
-char const *cvs_id_tbf = "$Id: tbf.c,v 1.5 2004/08/26 06:22:37 fred_nerk Exp $";
+char const *cvs_id_tbf = "$Id: tbf.c,v 1.6 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #define _GNU_SOURCE
 
 
 #define _GNU_SOURCE
 
@@ -21,8 +21,7 @@ static void tbf_run_queue(int tbf_id);
 
 void init_tbf(void)
 {
 
 void init_tbf(void)
 {
-       filter_list = mmap(NULL, sizeof(*filter_list) * MAXTBFS, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-       if (!filter_list)
+       if ((filter_list = shared_malloc(sizeof(*filter_list) * MAXTBFS)) == MAP_FAILED)
                return;
 
        filter_list_size = MAXTBFS;
                return;
 
        filter_list_size = MAXTBFS;
diff --git a/util.c b/util.c
index 22af256..dd0fbc3 100644 (file)
--- a/util.c
+++ b/util.c
@@ -1,6 +1,6 @@
 /* Misc util functions */
 
 /* Misc util functions */
 
-char const *cvs_id_util = "$Id: util.c,v 1.2 2004/06/28 02:43:13 fred_nerk Exp $";
+char const *cvs_id_util = "$Id: util.c,v 1.3 2004/09/02 04:18:07 fred_nerk Exp $";
 
 #include "l2tpns.h"
 
 
 #include "l2tpns.h"
 
@@ -8,6 +8,7 @@ char const *cvs_id_util = "$Id: util.c,v 1.2 2004/06/28 02:43:13 fred_nerk Exp $
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <string.h>
+#include <sys/mman.h>
 
 char *inet_toa(unsigned long addr)
 {
 
 char *inet_toa(unsigned long addr)
 {
@@ -16,3 +17,13 @@ char *inet_toa(unsigned long addr)
        return inet_ntoa(in);
 }
 
        return inet_ntoa(in);
 }
 
+void *shared_malloc(unsigned int size)
+{
+       void * p;
+       p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+
+       if (p == MAP_FAILED)
+               p = NULL;
+
+       return p;
+}
diff --git a/util.h b/util.h
index be797f8..21c82a3 100644 (file)
--- a/util.h
+++ b/util.h
@@ -2,5 +2,6 @@
 #define __UTIL_H__
 
 char *inet_toa(unsigned long addr);
 #define __UTIL_H__
 
 char *inet_toa(unsigned long addr);
+void *shared_malloc(unsigned int size);
 
 #endif /* __UTIL_H__ */
 
 #endif /* __UTIL_H__ */