allow DNS servers to be specified using either old or new vendor-specific Ascend...

[l2tpns.git] / l2tpns.c

diff --git a/l2tpns.c b/l2tpns.c
index 0d9a2c2..0ed0337 100644 (file)
--- a/l2tpns.c
+++ b/l2tpns.c
@@ -1,10 +1,10 @@
 // L2TP Network Server
 // Adrian Kennard 2002
 // L2TP Network Server
 // Adrian Kennard 2002

-// Copyright (c) 2003, 2004, 2005 Optus Internet Engineering
+// Copyright (c) 2003, 2004, 2005, 2006 Optus Internet Engineering

 // 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.148 2005/11/14 21:08:30 bodea Exp $";
+char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.171 2006/08/02 13:35:39 bodea Exp $";

 
 #include <arpa/inet.h>
 #include <assert.h>
 
 #include <arpa/inet.h>
 #include <assert.h>


@@ -82,9 +82,13 @@ uint16_t MSS = 0;            // TCP MSS
 struct cli_session_actions *cli_session_actions = NULL;        // Pending session changes requested by CLI
 struct cli_tunnel_actions *cli_tunnel_actions = NULL;  // Pending tunnel changes required by CLI
 
 struct cli_session_actions *cli_session_actions = NULL;        // Pending session changes requested by CLI
 struct cli_tunnel_actions *cli_tunnel_actions = NULL;  // Pending tunnel changes required by CLI
 

-static void *ip_hash[256];     // Mapping from IP address to session structures.
+union iphash {
+       sessionidt sess;
+       union iphash *idx;
+} ip_hash[256];                        // Mapping from IP address to session structures.
+

 struct ipv6radix {
 struct ipv6radix {

-       int sess;
+       sessionidt sess;

        struct ipv6radix *branch;
 } ipv6_hash[256];              // Mapping from IPv6 address to session structures.
 
        struct ipv6radix *branch;
 } ipv6_hash[256];              // Mapping from IPv6 address to session structures.
 


@@ -96,9 +100,9 @@ uint32_t eth_tx = 0;
 static uint32_t ip_pool_size = 1;      // Size of the pool of addresses used for dynamic address allocation.
 time_t time_now = 0;                   // Current time in seconds since epoch.
 static char time_now_string[64] = {0}; // Current time as a string.
 static uint32_t ip_pool_size = 1;      // Size of the pool of addresses used for dynamic address allocation.
 time_t time_now = 0;                   // Current time in seconds since epoch.
 static char time_now_string[64] = {0}; // Current time as a string.

-int time_changed = 0;                  // time_now changed
+static int time_changed = 0;           // time_now changed

 char main_quit = 0;                    // True if we're in the process of exiting.
 char main_quit = 0;                    // True if we're in the process of exiting.

-char main_reload = 0;                  // Re-load pending
+static char main_reload = 0;           // Re-load pending

 linked_list *loaded_plugins;
 linked_list *plugins[MAX_PLUGIN_TYPES];
 
 linked_list *loaded_plugins;
 linked_list *plugins[MAX_PLUGIN_TYPES];
 


@@ -126,14 +130,16 @@ config_descriptt config_values[] = {
        CONFIG("radius_secret", radiussecret, STRING),
        CONFIG("radius_authtypes", radius_authtypes_s, STRING),
        CONFIG("radius_dae_port", radius_dae_port, SHORT),
        CONFIG("radius_secret", radiussecret, STRING),
        CONFIG("radius_authtypes", radius_authtypes_s, STRING),
        CONFIG("radius_dae_port", radius_dae_port, SHORT),

+       CONFIG("radius_bind_min", radius_bind_min, SHORT),
+       CONFIG("radius_bind_max", radius_bind_max, SHORT),

        CONFIG("allow_duplicate_users", allow_duplicate_users, BOOL),
        CONFIG("allow_duplicate_users", allow_duplicate_users, BOOL),

+       CONFIG("guest_account", guest_user, STRING),

        CONFIG("bind_address", bind_address, IPv4),
        CONFIG("peer_address", peer_address, IPv4),
        CONFIG("send_garp", send_garp, BOOL),
        CONFIG("throttle_speed", rl_rate, UNSIGNED_LONG),
        CONFIG("throttle_buckets", num_tbfs, INT),
        CONFIG("accounting_dir", accounting_dir, STRING),
        CONFIG("bind_address", bind_address, IPv4),
        CONFIG("peer_address", peer_address, IPv4),
        CONFIG("send_garp", send_garp, BOOL),
        CONFIG("throttle_speed", rl_rate, UNSIGNED_LONG),
        CONFIG("throttle_buckets", num_tbfs, INT),
        CONFIG("accounting_dir", accounting_dir, STRING),

-       CONFIG("setuid", target_uid, INT),

        CONFIG("dump_speed", dump_speed, BOOL),
        CONFIG("multi_read_count", multi_read_count, INT),
        CONFIG("scheduler_fifo", scheduler_fifo, BOOL),
        CONFIG("dump_speed", dump_speed, BOOL),
        CONFIG("multi_read_count", multi_read_count, INT),
        CONFIG("scheduler_fifo", scheduler_fifo, BOOL),


@@ -174,6 +180,8 @@ static sessiont shut_acct[8192];
 static sessionidt shut_acct_n = 0;
 
 tunnelt *tunnel = NULL;                        // Array of tunnel structures.
 static sessionidt shut_acct_n = 0;
 
 tunnelt *tunnel = NULL;                        // Array of tunnel structures.

+bundlet *bundle = NULL;                        // Array of bundle structures.
+fragmentationt *frag = NULL;           // Array of fragmentation structures.

 sessiont *session = NULL;              // Array of session structures.
 sessionlocalt *sess_local = NULL;      // Array of local per-session counters.
 radiust *radius = NULL;                        // Array of radius structures.
 sessiont *session = NULL;              // Array of session structures.
 sessionlocalt *sess_local = NULL;      // Array of local per-session counters.
 radiust *radius = NULL;                        // Array of radius structures.


@@ -185,9 +193,9 @@ struct Tstats *_statistics = NULL;
 struct Tringbuffer *ringbuffer = NULL;
 #endif
 
 struct Tringbuffer *ringbuffer = NULL;
 #endif
 

-static void cache_ipmap(in_addr_t ip, int s);
+static void cache_ipmap(in_addr_t ip, sessionidt s);

 static void uncache_ipmap(in_addr_t ip);
 static void uncache_ipmap(in_addr_t ip);

-static void cache_ipv6map(struct in6_addr ip, int prefixlen, int s);
+static void cache_ipv6map(struct in6_addr ip, int prefixlen, sessionidt s);

 static void free_ip_address(sessionidt s);
 static void dump_acct_info(int all);
 static void sighup_handler(int sig);
 static void free_ip_address(sessionidt s);
 static void dump_acct_info(int all);
 static void sighup_handler(int sig);


@@ -200,9 +208,10 @@ static void initplugins(void);
 static int add_plugin(char *plugin_name);
 static int remove_plugin(char *plugin_name);
 static void plugins_done(void);
 static int add_plugin(char *plugin_name);
 static int remove_plugin(char *plugin_name);
 static void plugins_done(void);

-static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen);
+static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen, struct in_addr *local);

 static tunnelidt new_tunnel(void);
 static void unhide_value(uint8_t *value, size_t len, uint16_t type, uint8_t *vector, size_t vec_len);
 static tunnelidt new_tunnel(void);
 static void unhide_value(uint8_t *value, size_t len, uint16_t type, uint8_t *vector, size_t vec_len);

+static void bundleclear(bundleidt b);

 
 // on slaves, alow BGP to withdraw cleanly before exiting
 #define QUIT_DELAY     5
 
 // on slaves, alow BGP to withdraw cleanly before exiting
 #define QUIT_DELAY     5


@@ -554,6 +563,13 @@ static void inittun(void)
                LOG(0, 0, 0, "Error setting tun queue length: %s\n", strerror(errno));
                exit(1);
        }
                LOG(0, 0, 0, "Error setting tun queue length: %s\n", strerror(errno));
                exit(1);
        }

+       /* set MTU to modem MRU */
+       ifr.ifr_mtu = MRU;
+       if (ioctl(ifrfd, SIOCSIFMTU, (void *) &ifr) < 0)
+       {
+               LOG(0, 0, 0, "Error setting tun MTU: %s\n", strerror(errno));
+               exit(1);
+       }

        ifr.ifr_flags = IFF_UP;
        if (ioctl(ifrfd, SIOCSIFFLAGS, (void *) &ifr) < 0)
        {
        ifr.ifr_flags = IFF_UP;
        if (ioctl(ifrfd, SIOCSIFFLAGS, (void *) &ifr) < 0)
        {


@@ -615,7 +631,7 @@ static void initudp(void)
                int flags = fcntl(udpfd, F_GETFL, 0);
                fcntl(udpfd, F_SETFL, flags | O_NONBLOCK);
        }
                int flags = fcntl(udpfd, F_GETFL, 0);
                fcntl(udpfd, F_SETFL, flags | O_NONBLOCK);
        }

-       if (bind(udpfd, (void *) &addr, sizeof(addr)) < 0)
+       if (bind(udpfd, (struct sockaddr *) &addr, sizeof(addr)) < 0)

        {
                LOG(0, 0, 0, "Error in UDP bind: %s\n", strerror(errno));
                exit(1);
        {
                LOG(0, 0, 0, "Error in UDP bind: %s\n", strerror(errno));
                exit(1);


@@ -627,7 +643,8 @@ static void initudp(void)
        addr.sin_port = htons(NSCTL_PORT);
        controlfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        setsockopt(controlfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
        addr.sin_port = htons(NSCTL_PORT);
        controlfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        setsockopt(controlfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

-       if (bind(controlfd, (void *) &addr, sizeof(addr)) < 0)
+       setsockopt(controlfd, SOL_IP, IP_PKTINFO, &on, sizeof(on)); // recvfromto
+       if (bind(controlfd, (struct sockaddr *) &addr, sizeof(addr)) < 0)

        {
                LOG(0, 0, 0, "Error in control bind: %s\n", strerror(errno));
                exit(1);
        {
                LOG(0, 0, 0, "Error in control bind: %s\n", strerror(errno));
                exit(1);


@@ -639,7 +656,8 @@ static void initudp(void)
        addr.sin_port = htons(config->radius_dae_port);
        daefd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        setsockopt(daefd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
        addr.sin_port = htons(config->radius_dae_port);
        daefd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        setsockopt(daefd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

-       if (bind(daefd, (void *) &addr, sizeof(addr)) < 0)
+       setsockopt(daefd, SOL_IP, IP_PKTINFO, &on, sizeof(on)); // recvfromto
+       if (bind(daefd, (struct sockaddr *) &addr, sizeof(addr)) < 0)

        {
                LOG(0, 0, 0, "Error in DAE bind: %s\n", strerror(errno));
                exit(1);
        {
                LOG(0, 0, 0, "Error in DAE bind: %s\n", strerror(errno));
                exit(1);


@@ -664,19 +682,19 @@ static void initudp(void)
 // IP address.
 //
 
 // IP address.
 //
 

-static int lookup_ipmap(in_addr_t ip)
+static sessionidt lookup_ipmap(in_addr_t ip)

 {
        uint8_t *a = (uint8_t *) &ip;
 {
        uint8_t *a = (uint8_t *) &ip;

-       uint8_t **d = (uint8_t **) ip_hash;
+       union iphash *h = ip_hash;

 
 

-       if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
-       if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
-       if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
+       if (!(h = h[*a++].idx)) return 0;
+       if (!(h = h[*a++].idx)) return 0;
+       if (!(h = h[*a++].idx)) return 0;

 
 

-       return (int) (intptr_t) d[(size_t) *a];
+       return h[*a].sess;

 }
 
 }
 

-static int lookup_ipv6map(struct in6_addr ip)
+static sessionidt lookup_ipv6map(struct in6_addr ip)

 {
        struct ipv6radix *curnode;
        int i;
 {
        struct ipv6radix *curnode;
        int i;


@@ -704,18 +722,18 @@ static int lookup_ipv6map(struct in6_addr ip)
 
 sessionidt sessionbyip(in_addr_t ip)
 {
 
 sessionidt sessionbyip(in_addr_t ip)
 {

-       int s = lookup_ipmap(ip);
+       sessionidt s = lookup_ipmap(ip);

        CSTAT(sessionbyip);
 
        if (s > 0 && s < MAXSESSION && session[s].opened)
        CSTAT(sessionbyip);
 
        if (s > 0 && s < MAXSESSION && session[s].opened)

-               return (sessionidt) s;
+               return s;

 
        return 0;
 }
 
 sessionidt sessionbyipv6(struct in6_addr ip)
 {
 
        return 0;
 }
 
 sessionidt sessionbyipv6(struct in6_addr ip)
 {

-       int s;
+       sessionidt s;

        CSTAT(sessionbyipv6);
 
        if (!memcmp(&config->ipv6_prefix, &ip, 8) ||
        CSTAT(sessionbyipv6);
 
        if (!memcmp(&config->ipv6_prefix, &ip, 8) ||


@@ -741,25 +759,22 @@ sessionidt sessionbyipv6(struct in6_addr ip)
 //
 // (It's actually cached in network order)
 //
 //
 // (It's actually cached in network order)
 //

-static void cache_ipmap(in_addr_t ip, int s)
+static void cache_ipmap(in_addr_t ip, sessionidt s)

 {
        in_addr_t nip = htonl(ip);      // MUST be in network order. I.e. MSB must in be ((char *) (&ip))[0]
        uint8_t *a = (uint8_t *) &nip;
 {
        in_addr_t nip = htonl(ip);      // MUST be in network order. I.e. MSB must in be ((char *) (&ip))[0]
        uint8_t *a = (uint8_t *) &nip;

-       uint8_t **d = (uint8_t **) ip_hash;
+       union iphash *h = ip_hash;

        int i;
 
        for (i = 0; i < 3; i++)
        {
        int i;
 
        for (i = 0; i < 3; i++)
        {

-               if (!d[(size_t) a[i]])
-               {
-                       if (!(d[(size_t) a[i]] = calloc(256, sizeof(void *))))
-                               return;
-               }
+               if (!(h[a[i]].idx || (h[a[i]].idx = calloc(256, sizeof(union iphash)))))
+                       return;

 
 

-               d = (uint8_t **) d[(size_t) a[i]];
+               h = h[a[i]].idx;

        }
 
        }
 

-       d[(size_t) a[3]] = (uint8_t *) (intptr_t) s;
+       h[a[3]].sess = s;

 
        if (s > 0)
                LOG(4, s, session[s].tunnel, "Caching ip address %s\n", fmtaddr(nip, 0));
 
        if (s > 0)
                LOG(4, s, session[s].tunnel, "Caching ip address %s\n", fmtaddr(nip, 0));


@@ -774,7 +789,7 @@ static void uncache_ipmap(in_addr_t ip)
        cache_ipmap(ip, 0);     // Assign it to the NULL session.
 }
 
        cache_ipmap(ip, 0);     // Assign it to the NULL session.
 }
 

-static void cache_ipv6map(struct in6_addr ip, int prefixlen, int s)
+static void cache_ipv6map(struct in6_addr ip, int prefixlen, sessionidt s)

 {
        int i;
        int bytes;
 {
        int i;
        int bytes;


@@ -815,7 +830,7 @@ static void cache_ipv6map(struct in6_addr ip, int prefixlen, int s)
 //
 int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 {
 //
 int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 {

-       char **d = (char **) ip_hash, **e, **f, **g;
+       union iphash *d = ip_hash, *e, *f, *g;

        int i, j, k, l;
        int count = 0;
 
        int i, j, k, l;
        int count = 0;
 


@@ -826,24 +841,28 @@ int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 
        for (i = 0; i < 256; ++i)
        {
 
        for (i = 0; i < 256; ++i)
        {

-               if (!d[i])
+               if (!d[i].idx)

                        continue;
                        continue;

-               e = (char **) d[i];
+
+               e = d[i].idx;

                for (j = 0; j < 256; ++j)
                {
                for (j = 0; j < 256; ++j)
                {

-                       if (!e[j])
+                       if (!e[j].idx)

                                continue;
                                continue;

-                       f = (char **) e[j];
+
+                       f = e[j].idx;

                        for (k = 0; k < 256; ++k)
                        {
                        for (k = 0; k < 256; ++k)
                        {

-                               if (!f[k])
+                               if (!f[k].idx)

                                        continue;
                                        continue;

-                               g = (char **)f[k];
+
+                               g = f[k].idx;

                                for (l = 0; l < 256; ++l)
                                {
                                for (l = 0; l < 256; ++l)
                                {

-                                       if (!g[l])
+                                       if (!g[l].sess)

                                                continue;
                                                continue;

-                                       cli_print(cli, "%7d %d.%d.%d.%d", (int) (intptr_t) g[l], i, j, k, l);
+
+                                       cli_print(cli, "%7d %d.%d.%d.%d", g[l].sess, i, j, k, l);

                                        ++count;
                                }
                        }
                                        ++count;
                                }
                        }


@@ -933,18 +952,14 @@ void tunnelsend(uint8_t * buf, uint16_t l, tunnelidt t)
 
        if (!t)
        {
 
        if (!t)
        {

-               static int backtrace_count = 0;

                LOG(0, 0, t, "tunnelsend called with 0 as tunnel id\n");
                STAT(tunnel_tx_errors);
                LOG(0, 0, t, "tunnelsend called with 0 as tunnel id\n");
                STAT(tunnel_tx_errors);

-               log_backtrace(backtrace_count, 5)

                return;
        }
 
        if (!tunnel[t].ip)
        {
                return;
        }
 
        if (!tunnel[t].ip)
        {

-               static int backtrace_count = 0;

                LOG(1, 0, t, "Error sending data out tunnel: no remote endpoint (tunnel not set up)\n");
                LOG(1, 0, t, "Error sending data out tunnel: no remote endpoint (tunnel not set up)\n");

-               log_backtrace(backtrace_count, 5)

                STAT(tunnel_tx_errors);
                return;
        }
                STAT(tunnel_tx_errors);
                return;
        }


@@ -1043,7 +1058,57 @@ void adjust_tcp_mss(sessionidt s, tunnelidt t, uint8_t *buf, int len, uint8_t *t
        sum = orig + (~MSS & 0xffff);
        sum += ntohs(*(uint16_t *) (tcp + 16));
        sum = (sum & 0xffff) + (sum >> 16);
        sum = orig + (~MSS & 0xffff);
        sum += ntohs(*(uint16_t *) (tcp + 16));
        sum = (sum & 0xffff) + (sum >> 16);

-       *(uint16_t *) (tcp + 16) = htons(sum);
+       *(uint16_t *) (tcp + 16) = htons(sum + (sum >> 16));
+}
+
+void processmpframe(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l, uint8_t extra)
+{
+       uint16_t proto;
+       if (extra) {
+               // Skip the four extra bytes
+               p += 4;
+               l -= 4;
+       }
+
+       // Process this frame
+       if (*p & 1)
+       {
+               proto = *p++;
+               l--;
+       }
+       else
+       {
+               proto = ntohs(*(uint16_t *) p);
+               p += 2;
+               l -= 2;
+       }
+
+       if (proto == PPPIP)
+       {
+               if (session[s].die)
+               {
+                       LOG(4, s, t, "MPPP: Session %u is closing.  Don't process PPP packets\n", s);
+                       return;              // closing session, PPP not processed
+               }
+
+               session[s].last_packet = session[s].last_data = time_now;
+               processipin(s, t, p, l);
+       }
+       else if (proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0])
+       {
+               if (session[s].die)
+               {
+                       LOG(4, s, t, "MPPP: Session %u is closing.  Don't process PPP packets\n", s);
+                       return;              // closing session, PPP not processed
+               }
+
+               session[s].last_packet = session[s].last_data = time_now;
+               processipv6in(s, t, p, l);
+       }
+       else
+       {
+               LOG(2, s, t, "MPPP: Unsupported MP protocol 0x%04X received\n",proto);
+       }

 }
 
 // process outgoing (to tunnel) IP
 }
 
 // process outgoing (to tunnel) IP


@@ -1058,7 +1123,8 @@ static void processipout(uint8_t *buf, int len)
        uint8_t *data = buf;    // Keep a copy of the originals.
        int size = len;
 
        uint8_t *data = buf;    // Keep a copy of the originals.
        int size = len;
 

-       uint8_t b[MAXETHER + 20];
+       uint8_t b1[MAXETHER + 20];
+       uint8_t b2[MAXETHER + 20];

 
        CSTAT(processipout);
 
 
        CSTAT(processipout);
 


@@ -1109,6 +1175,7 @@ static void processipout(uint8_t *buf, int len)
        }
        t = session[s].tunnel;
        sp = &session[s];
        }
        t = session[s].tunnel;
        sp = &session[s];

+       sp->last_data = time_now;

 
        // DoS prevention: enforce a maximum number of packets per 0.1s for a session
        if (config->max_packets > 0)
 
        // DoS prevention: enforce a maximum number of packets per 0.1s for a session
        if (config->max_packets > 0)


@@ -1170,20 +1237,51 @@ static void processipout(uint8_t *buf, int len)
                        master_throttle_packet(sp->tbf_out, data, size);
                return;
        }
                        master_throttle_packet(sp->tbf_out, data, size);
                return;
        }

-       else if (sp->walled_garden && !config->cluster_iam_master)
+
+       if (sp->walled_garden && !config->cluster_iam_master)

        {
                // We are walled-gardening this
                master_garden_packet(s, data, size);
                return;
        }
 
        {
                // We are walled-gardening this
                master_garden_packet(s, data, size);
                return;
        }
 

-       LOG(5, s, t, "Ethernet -> Tunnel (%d bytes)\n", len);
-

        // Add on L2TP header
        {
        // Add on L2TP header
        {

-               uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIP);
-               if (!p) return;
-               tunnelsend(b, len + (p-b), t); // send it...
+               bundleidt bid = 0;
+               if (session[s].bundle && bundle[session[s].bundle].num_of_links > 1)
+               {
+                       bid = session[s].bundle;
+                       s = bundle[bid].members[bundle[bid].current_ses = ++bundle[bid].current_ses % bundle[bid].num_of_links];
+                       LOG(4, s, t, "MPPP: (1)Session number becomes: %u\n", s);
+                       if (len > 256)
+                       {
+                               // Partition the packet to 2 fragments
+                               uint32_t frag1len = len / 2;
+                               uint32_t frag2len = len - frag1len;
+                               uint8_t *p = makeppp(b1, sizeof(b1), buf, frag1len, s, t, PPPIP, 0, bid, MP_BEGIN);
+                               uint8_t *q;
+
+                               if (!p) return;
+                               tunnelsend(b1, frag1len + (p-b1), t); // send it...
+                               s = bundle[bid].members[bundle[bid].current_ses = ++bundle[bid].current_ses % bundle[bid].num_of_links];
+                               LOG(4, s, t, "MPPP: (2)Session number becomes: %u\n", s);
+                               q = makeppp(b2, sizeof(b2), buf+frag1len, frag2len, s, t, PPPIP, 0, bid, MP_END);
+                               if (!q) return;
+                               tunnelsend(b2, frag2len + (q-b2), t); // send it...
+                       }
+                       else {
+                               // Send it as one frame
+                               uint8_t *p = makeppp(b1, sizeof(b1), buf, len, s, t, PPPIP, 0, bid, MP_BOTH_BITS);
+                               if (!p) return;
+                               tunnelsend(b1, len + (p-b1), t); // send it...
+                       }
+               }
+               else
+               {
+                       uint8_t *p = makeppp(b1, sizeof(b1), buf, len, s, t, PPPIP, 0, 0, 0);
+                       if (!p) return;
+                       tunnelsend(b1, len + (p-b1), t); // send it...
+               }

        }
 
        // Snooping this session, send it to intercept box
        }
 
        // Snooping this session, send it to intercept box


@@ -1267,8 +1365,15 @@ static void processipv6out(uint8_t * buf, int len)
                }
                return;
        }
                }
                return;
        }

+       if (session[s].bundle && bundle[session[s].bundle].num_of_links > 1)
+       {
+               bundleidt bid = session[s].bundle;
+               s = bundle[bid].members[bundle[bid].current_ses = ++bundle[bid].current_ses % bundle[bid].num_of_links];
+               LOG(3, s, session[s].tunnel, "MPPP: Session number becomes: %u\n", s);
+       }

        t = session[s].tunnel;
        sp = &session[s];
        t = session[s].tunnel;
        sp = &session[s];

+       sp->last_data = time_now;

 
        // FIXME: add DoS prevention/filters?
 
 
        // FIXME: add DoS prevention/filters?
 


@@ -1292,7 +1397,7 @@ static void processipv6out(uint8_t * buf, int len)
 
        // Add on L2TP header
        {
 
        // Add on L2TP header
        {

-               uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIPV6);
+               uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIPV6, 0, 0, 0);

                if (!p) return;
                tunnelsend(b, len + (p-b), t); // send it...
        }
                if (!p) return;
                tunnelsend(b, len + (p-b), t); // send it...
        }


@@ -1344,7 +1449,7 @@ static void send_ipout(sessionidt s, uint8_t *buf, int len)
 
        // Add on L2TP header
        {
 
        // Add on L2TP header
        {

-               uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIP);
+               uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIP, 0, 0, 0);

                if (!p) return;
                tunnelsend(b, len + (p-b), t); // send it...
        }
                if (!p) return;
                tunnelsend(b, len + (p-b), t); // send it...
        }


@@ -1553,7 +1658,7 @@ void filter_session(sessionidt s, int filter_in, int filter_out)
 }
 
 // start tidy shutdown of session
 }
 
 // start tidy shutdown of session

-void sessionshutdown(sessionidt s, char *reason, int result, int error)
+void sessionshutdown(sessionidt s, char const *reason, int cdn_result, int cdn_error, int term_cause)

 {
        int walled_garden = session[s].walled_garden;
 
 {
        int walled_garden = session[s].walled_garden;
 


@@ -1569,7 +1674,7 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
        if (!session[s].die)
        {
                struct param_kill_session data = { &tunnel[session[s].tunnel], &session[s] };
        if (!session[s].die)
        {
                struct param_kill_session data = { &tunnel[session[s].tunnel], &session[s] };

-               LOG(2, s, session[s].tunnel, "Shutting down session %d: %s\n", s, reason);
+               LOG(2, s, session[s].tunnel, "Shutting down session %u: %s\n", s, reason);

                run_plugins(PLUGIN_KILL_SESSION, &data);
        }
 
                run_plugins(PLUGIN_KILL_SESSION, &data);
        }
 


@@ -1581,7 +1686,11 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
                {
                        // stop, if not already trying
                        if (radius[r].state != RADIUSSTOP)
                {
                        // stop, if not already trying
                        if (radius[r].state != RADIUSSTOP)

+                       {
+                               radius[r].term_cause = term_cause;
+                               radius[r].term_msg = reason;

                                radiussend(r, RADIUSSTOP);
                                radiussend(r, RADIUSSTOP);

+                       }

                }
                else
                        LOG(1, s, session[s].tunnel, "No free RADIUS sessions for Stop message\n");
                }
                else
                        LOG(1, s, session[s].tunnel, "No free RADIUS sessions for Stop message\n");


@@ -1621,18 +1730,18 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
        if (session[s].throttle_in || session[s].throttle_out) // Unthrottle if throttled.
                throttle_session(s, 0, 0);
 
        if (session[s].throttle_in || session[s].throttle_out) // Unthrottle if throttled.
                throttle_session(s, 0, 0);
 

-       if (result)
+       if (cdn_result)

        {                            // Send CDN
                controlt *c = controlnew(14); // sending CDN
        {                            // Send CDN
                controlt *c = controlnew(14); // sending CDN

-               if (error)
+               if (cdn_error)

                {
                        uint8_t buf[4];
                {
                        uint8_t buf[4];

-                       *(uint16_t *) buf     = htons(result);
-                       *(uint16_t *) (buf+2) = htons(error);
+                       *(uint16_t *) buf     = htons(cdn_result);
+                       *(uint16_t *) (buf+2) = htons(cdn_error);

                        controlb(c, 1, buf, 4, 1);
                }
                else
                        controlb(c, 1, buf, 4, 1);
                }
                else

-                       control16(c, 1, result, 1);
+                       control16(c, 1, cdn_result, 1);

 
                control16(c, 14, s, 1);   // assigned session (our end)
                controladd(c, session[s].far, session[s].tunnel); // send the message
 
                control16(c, 14, s, 1);   // assigned session (our end)
                controladd(c, session[s].far, session[s].tunnel); // send the message


@@ -1669,7 +1778,7 @@ void sendipcp(sessionidt s, tunnelidt t)
                session[s].unique_id = last_id;
        }
 
                session[s].unique_id = last_id;
        }
 

-       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPCP);
+       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPCP, 0, 0, 0);

        if (!q) return;
 
        *q = ConfigReq;
        if (!q) return;
 
        *q = ConfigReq;


@@ -1693,7 +1802,7 @@ void sendipv6cp(sessionidt s, tunnelidt t)
        CSTAT(sendipv6cp);
        LOG(3, s, t, "IPV6CP: send ConfigReq\n");
 
        CSTAT(sendipv6cp);
        LOG(3, s, t, "IPV6CP: send ConfigReq\n");
 

-       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPV6CP);
+       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPV6CP, 0, 0, 0);

        if (!q) return;
 
        *q = ConfigReq;
        if (!q) return;
 
        *q = ConfigReq;


@@ -1725,6 +1834,7 @@ static void sessionclear(sessionidt s)
 // kill a session now
 void sessionkill(sessionidt s, char *reason)
 {
 // kill a session now
 void sessionkill(sessionidt s, char *reason)
 {

+       bundleidt b;

 
        CSTAT(sessionkill);
 
 
        CSTAT(sessionkill);
 


@@ -1733,16 +1843,48 @@ void sessionkill(sessionidt s, char *reason)
 
        if (session[s].next)
        {
 
        if (session[s].next)
        {

-               LOG(0, s, session[s].tunnel, "Tried to kill a session with next pointer set (%d)\n", session[s].next);
+               LOG(0, s, session[s].tunnel, "Tried to kill a session with next pointer set (%u)\n", session[s].next);

                return;
        }
 
        session[s].die = TIME;
                return;
        }
 
        session[s].die = TIME;

-       sessionshutdown(s, reason, 3, 0);  // close radius/routes, etc.
+       sessionshutdown(s, reason, CDN_ADMIN_DISC, TERM_ADMIN_RESET);  // close radius/routes, etc.

        if (sess_local[s].radius)
                radiusclear(sess_local[s].radius, s); // cant send clean accounting data, session is killed
 
        if (sess_local[s].radius)
                radiusclear(sess_local[s].radius, s); // cant send clean accounting data, session is killed
 

-       LOG(2, s, session[s].tunnel, "Kill session %d (%s): %s\n", s, session[s].user, reason);
+       LOG(2, s, session[s].tunnel, "Kill session %u (%s): %s\n", s, session[s].user, reason);
+       if ((b = session[s].bundle))
+       {
+               // This session was part of a bundle
+               bundle[b].num_of_links--;
+               LOG(3, s, 0, "MPPP: Dropping member link: %u from bundle %u\n", s, b);
+               if (bundle[b].num_of_links == 0)
+               {
+                       bundleclear(b);
+                       LOG(3, s, 0, "MPPP: Kill bundle: %u (No remaing member links)\n", b);
+               }
+               else
+               {
+                       // Adjust the members array to accomodate the new change
+                       uint8_t mem_num = 0;
+                       // It should be here num_of_links instead of num_of_links-1 (previous instruction "num_of_links--")
+                       if (bundle[b].members[bundle[b].num_of_links] != s)
+                       {
+                               uint8_t ml;
+                               for (ml = 0; ml<bundle[b].num_of_links; ml++)
+                               {
+                                       if (bundle[b].members[ml] == s)
+                                       {
+                                               mem_num = ml;
+                                               break;
+                                       }
+                               }
+                               bundle[b].members[mem_num] = bundle[b].members[bundle[b].num_of_links];
+                               LOG(3, s, 0, "MPPP: Adjusted member links array\n");
+                       }
+               }
+               cluster_send_bundle(b);
+       }

        sessionclear(s);
        cluster_send_session(s);
 }
        sessionclear(s);
        cluster_send_session(s);
 }


@@ -1754,6 +1896,13 @@ static void tunnelclear(tunnelidt t)
        tunnel[t].state = TUNNELFREE;
 }
 
        tunnel[t].state = TUNNELFREE;
 }
 

+static void bundleclear(bundleidt b)
+{
+       if (!b) return;
+       memset(&bundle[b], 0, sizeof(bundle[b]));
+       bundle[b].state = BUNDLEFREE;
+}
+

 // kill a tunnel now
 static void tunnelkill(tunnelidt t, char *reason)
 {
 // kill a tunnel now
 static void tunnelkill(tunnelidt t, char *reason)
 {


@@ -1780,7 +1929,7 @@ static void tunnelkill(tunnelidt t, char *reason)
 
        // free tunnel
        tunnelclear(t);
 
        // free tunnel
        tunnelclear(t);

-       LOG(1, 0, t, "Kill tunnel %d: %s\n", t, reason);
+       LOG(1, 0, t, "Kill tunnel %u: %s\n", t, reason);

        cli_tunnel_actions[t].action = 0;
        cluster_send_tunnel(t);
 }
        cli_tunnel_actions[t].action = 0;
        cluster_send_tunnel(t);
 }


@@ -1798,12 +1947,12 @@ static void tunnelshutdown(tunnelidt t, char *reason, int result, int error, cha
                tunnelkill(t, reason);
                return;
        }
                tunnelkill(t, reason);
                return;
        }

-       LOG(1, 0, t, "Shutting down tunnel %d (%s)\n", t, reason);
+       LOG(1, 0, t, "Shutting down tunnel %u (%s)\n", t, reason);

 
        // close session
        for (s = 1; s <= config->cluster_highest_sessionid ; ++s)
                if (session[s].tunnel == t)
 
        // close session
        for (s = 1; s <= config->cluster_highest_sessionid ; ++s)
                if (session[s].tunnel == t)

-                       sessionshutdown(s, reason, 0, 0);
+                       sessionshutdown(s, reason, CDN_NONE, TERM_ADMIN_RESET);

 
        tunnel[t].state = TUNNELDIE;
        tunnel[t].die = TIME + 700; // Clean up in 70 seconds
 
        tunnel[t].state = TUNNELDIE;
        tunnel[t].die = TIME + 700; // Clean up in 70 seconds


@@ -1861,7 +2010,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
        }
        if ((buf[1] & 0x0F) != 2)
        {
        }
        if ((buf[1] & 0x0F) != 2)
        {

-               LOG(1, 0, 0, "Bad L2TP ver %d\n", (buf[1] & 0x0F) != 2);
+               LOG(1, 0, 0, "Bad L2TP ver %d\n", buf[1] & 0x0F);

                STAT(tunnel_rx_errors);
                return;
        }
                STAT(tunnel_rx_errors);
                return;
        }


@@ -1958,7 +2107,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        }
                }
 
                        }
                }
 

-               LOG(3, s, t, "Control message (%d bytes): (unacked %d) l-ns %d l-nr %d r-ns %d r-nr %d\n",
+               LOG(3, s, t, "Control message (%d bytes): (unacked %d) l-ns %u l-nr %u r-ns %u r-nr %u\n",

                        l, tunnel[t].controlc, tunnel[t].ns, tunnel[t].nr, ns, nr);
 
                // if no tunnel specified, assign one
                        l, tunnel[t].controlc, tunnel[t].ns, tunnel[t].nr, ns, nr);
 
                // if no tunnel specified, assign one


@@ -1975,7 +2124,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        tunnel[t].port = ntohs(addr->sin_port);
                        tunnel[t].window = 4; // default window
                        STAT(tunnel_created);
                        tunnel[t].port = ntohs(addr->sin_port);
                        tunnel[t].window = 4; // default window
                        STAT(tunnel_created);

-                       LOG(1, 0, t, "   New tunnel from %s:%u ID %d\n",
+                       LOG(1, 0, t, "   New tunnel from %s:%u ID %u\n",

                                fmtaddr(htonl(tunnel[t].ip), 0), tunnel[t].port, t);
                }
 
                                fmtaddr(htonl(tunnel[t].ip), 0), tunnel[t].port, t);
                }
 


@@ -1989,7 +2138,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                {
                        // is this the sequence we were expecting?
                        STAT(tunnel_rx_errors);
                {
                        // is this the sequence we were expecting?
                        STAT(tunnel_rx_errors);

-                       LOG(1, 0, t, "   Out of sequence tunnel %d, (%d is not the expected %d)\n",
+                       LOG(1, 0, t, "   Out of sequence tunnel %u, (%u is not the expected %u)\n",

                                t, ns, tunnel[t].nr);
 
                        if (l)  // Is this not a ZLB?
                                t, ns, tunnel[t].nr);
 
                        if (l)  // Is this not a ZLB?


@@ -2042,6 +2191,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        int error = 0;
                        char *msg = 0;
 
                        int error = 0;
                        char *msg = 0;
 

+                       // Default disconnect cause/message on receipt of CDN.  Set to
+                       // more specific value from attribute 1 (result code) or 46
+                       // (disconnect cause) if present below.
+                       int disc_cause_set = 0;
+                       int disc_cause = TERM_NAS_REQUEST;
+                       char const *disc_reason = "Closed (Received CDN).";
+

                        // process AVPs
                        while (l && !(fatal & 0x80)) // 0x80 = mandatory AVP
                        {
                        // process AVPs
                        while (l && !(fatal & 0x80)) // 0x80 = mandatory AVP
                        {


@@ -2049,6 +2205,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                uint8_t *b = p;
                                uint8_t flags = *p;
                                uint16_t mtype;
                                uint8_t *b = p;
                                uint8_t flags = *p;
                                uint16_t mtype;

+

                                if (n > l)
                                {
                                        LOG(1, s, t, "Invalid length in AVP\n");
                                if (n > l)
                                {
                                        LOG(1, s, t, "Invalid length in AVP\n");


@@ -2069,7 +2226,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                b += 2;
                                if (*(uint16_t *) (b))
                                {
                                b += 2;
                                if (*(uint16_t *) (b))
                                {

-                                       LOG(2, s, t, "Unknown AVP vendor %d\n", ntohs(*(uint16_t *) (b)));
+                                       LOG(2, s, t, "Unknown AVP vendor %u\n", ntohs(*(uint16_t *) (b)));

                                        fatal = flags;
                                        result = 2; // general error
                                        error = 6; // generic vendor-specific error
                                        fatal = flags;
                                        result = 2; // general error
                                        error = 6; // generic vendor-specific error


@@ -2134,7 +2291,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        n = orig_len;
                                }
 
                                        n = orig_len;
                                }
 

-                               LOG(4, s, t, "   AVP %d (%s) len %d%s%s\n", mtype, l2tp_avp_name(mtype), n,
+                               LOG(4, s, t, "   AVP %u (%s) len %d%s%s\n", mtype, l2tp_avp_name(mtype), n,

                                        flags & 0x40 ? ", hidden" : "", flags & 0x80 ? ", mandatory" : "");
 
                                switch (mtype)
                                        flags & 0x40 ? ", hidden" : "", flags & 0x80 ? ", mandatory" : "");
 
                                switch (mtype)


@@ -2142,37 +2299,53 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                case 0:     // message type
                                        message = ntohs(*(uint16_t *) b);
                                        mandatory = flags & 0x80;
                                case 0:     // message type
                                        message = ntohs(*(uint16_t *) b);
                                        mandatory = flags & 0x80;

-                                       LOG(4, s, t, "   Message type = %d (%s)\n", *b, l2tp_code(message));
+                                       LOG(4, s, t, "   Message type = %u (%s)\n", *b, l2tp_code(message));

                                        break;
                                case 1:     // result code
                                        {
                                                uint16_t rescode = ntohs(*(uint16_t *) b);
                                        break;
                                case 1:     // result code
                                        {
                                                uint16_t rescode = ntohs(*(uint16_t *) b);

-                                               const char* resdesc = "(unknown)";
+                                               char const *resdesc = "(unknown)";
+                                               char const *errdesc = NULL;
+                                               int cause = 0;
+

                                                if (message == 4)
                                                { /* StopCCN */
                                                        resdesc = l2tp_stopccn_result_code(rescode);
                                                if (message == 4)
                                                { /* StopCCN */
                                                        resdesc = l2tp_stopccn_result_code(rescode);

+                                                       cause = TERM_LOST_SERVICE;

                                                }
                                                else if (message == 14)
                                                { /* CDN */
                                                        resdesc = l2tp_cdn_result_code(rescode);
                                                }
                                                else if (message == 14)
                                                { /* CDN */
                                                        resdesc = l2tp_cdn_result_code(rescode);

+                                                       if (rescode == 1)
+                                                               cause = TERM_LOST_CARRIER;
+                                                       else
+                                                               cause = TERM_ADMIN_RESET;

                                                }
 
                                                }
 

-                                               LOG(4, s, t, "   Result Code %d: %s\n", rescode, resdesc);
+                                               LOG(4, s, t, "   Result Code %u: %s\n", rescode, resdesc);

                                                if (n >= 4)
                                                {
                                                        uint16_t errcode = ntohs(*(uint16_t *)(b + 2));
                                                if (n >= 4)
                                                {
                                                        uint16_t errcode = ntohs(*(uint16_t *)(b + 2));

-                                                       LOG(4, s, t, "   Error Code %d: %s\n", errcode, l2tp_error_code(errcode));
+                                                       errdesc = l2tp_error_code(errcode);
+                                                       LOG(4, s, t, "   Error Code %u: %s\n", errcode, errdesc);

                                                }
                                                if (n > 4)
                                                        LOG(4, s, t, "   Error String: %.*s\n", n-4, b+4);
 
                                                }
                                                if (n > 4)
                                                        LOG(4, s, t, "   Error String: %.*s\n", n-4, b+4);
 

+                                               if (cause && disc_cause_set < mtype) // take cause from attrib 46 in preference
+                                               {
+                                                       disc_cause_set = mtype;
+                                                       disc_reason = errdesc ? errdesc : resdesc;
+                                                       disc_cause = cause;
+                                               }
+

                                                break;
                                        }
                                        break;
                                case 2:     // protocol version
                                        {
                                                version = ntohs(*(uint16_t *) (b));
                                                break;
                                        }
                                        break;
                                case 2:     // protocol version
                                        {
                                                version = ntohs(*(uint16_t *) (b));

-                                               LOG(4, s, t, "   Protocol version = %d\n", version);
+                                               LOG(4, s, t, "   Protocol version = %u\n", version);

                                                if (version && version != 0x0100)
                                                {   // allow 0.0 and 1.0
                                                        LOG(1, s, t, "   Bad protocol version %04X\n", version);
                                                if (version && version != 0x0100)
                                                {   // allow 0.0 and 1.0
                                                        LOG(1, s, t, "   Bad protocol version %04X\n", version);


@@ -2185,17 +2358,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        }
                                        break;
                                case 3:     // framing capabilities
                                        }
                                        break;
                                case 3:     // framing capabilities

-//                                     LOG(4, s, t, "Framing capabilities\n");

                                        break;
                                case 4:     // bearer capabilities
                                        break;
                                case 4:     // bearer capabilities

-//                                     LOG(4, s, t, "Bearer capabilities\n");

                                        break;
                                case 5:         // tie breaker
                                        // We never open tunnels, so we don't care about tie breakers
                                        break;
                                case 5:         // tie breaker
                                        // We never open tunnels, so we don't care about tie breakers

-//                                     LOG(4, s, t, "Tie breaker\n");

                                        continue;
                                case 6:     // firmware revision
                                        continue;
                                case 6:     // firmware revision

-//                                     LOG(4, s, t, "Firmware revision\n");

                                        break;
                                case 7:     // host name
                                        memset(tunnel[t].hostname, 0, sizeof(tunnel[t].hostname));
                                        break;
                                case 7:     // host name
                                        memset(tunnel[t].hostname, 0, sizeof(tunnel[t].hostname));


@@ -2210,13 +2379,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        break;
                                case 9:     // assigned tunnel
                                        tunnel[t].far = ntohs(*(uint16_t *) (b));
                                        break;
                                case 9:     // assigned tunnel
                                        tunnel[t].far = ntohs(*(uint16_t *) (b));

-                                       LOG(4, s, t, "   Remote tunnel id = %d\n", tunnel[t].far);
+                                       LOG(4, s, t, "   Remote tunnel id = %u\n", tunnel[t].far);

                                        break;
                                case 10:    // rx window
                                        tunnel[t].window = ntohs(*(uint16_t *) (b));
                                        if (!tunnel[t].window)
                                                tunnel[t].window = 1; // window of 0 is silly
                                        break;
                                case 10:    // rx window
                                        tunnel[t].window = ntohs(*(uint16_t *) (b));
                                        if (!tunnel[t].window)
                                                tunnel[t].window = 1; // window of 0 is silly

-                                       LOG(4, s, t, "   rx window = %d\n", tunnel[t].window);
+                                       LOG(4, s, t, "   rx window = %u\n", tunnel[t].window);

                                        break;
                                case 11:        // Challenge
                                        {
                                        break;
                                case 11:        // Challenge
                                        {


@@ -2231,17 +2400,17 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
 
                                case 14:    // assigned session
                                        asession = session[s].far = ntohs(*(uint16_t *) (b));
 
                                case 14:    // assigned session
                                        asession = session[s].far = ntohs(*(uint16_t *) (b));

-                                       LOG(4, s, t, "   assigned session = %d\n", asession);
+                                       LOG(4, s, t, "   assigned session = %u\n", asession);

                                        break;
                                case 15:    // call serial number
                                        break;
                                case 15:    // call serial number

-                                       LOG(4, s, t, "   call serial number = %d\n", ntohl(*(uint32_t *)b));
+                                       LOG(4, s, t, "   call serial number = %u\n", ntohl(*(uint32_t *)b));

                                        break;
                                case 18:    // bearer type
                                        break;
                                case 18:    // bearer type

-                                       LOG(4, s, t, "   bearer type = %d\n", ntohl(*(uint32_t *)b));
+                                       LOG(4, s, t, "   bearer type = %u\n", ntohl(*(uint32_t *)b));

                                        // TBA - for RADIUS
                                        break;
                                case 19:    // framing type
                                        // TBA - for RADIUS
                                        break;
                                case 19:    // framing type

-                                       LOG(4, s, t, "   framing type = %d\n", ntohl(*(uint32_t *)b));
+                                       LOG(4, s, t, "   framing type = %u\n", ntohl(*(uint32_t *)b));

                                        // TBA
                                        break;
                                case 21:    // called number
                                        // TBA
                                        break;
                                case 21:    // called number


@@ -2295,7 +2464,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                case 29:    // Proxy Authentication Type
                                        {
                                                uint16_t atype = ntohs(*(uint16_t *)b);
                                case 29:    // Proxy Authentication Type
                                        {
                                                uint16_t atype = ntohs(*(uint16_t *)b);

-                                               LOG(4, s, t, "   Proxy Auth Type %d (%s)\n", atype, ppp_auth_type(atype));
+                                               LOG(4, s, t, "   Proxy Auth Type %u (%s)\n", atype, ppp_auth_type(atype));

                                                break;
                                        }
                                case 30:    // Proxy Authentication Name
                                                break;
                                        }
                                case 30:    // Proxy Authentication Name


@@ -2315,7 +2484,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                case 32:    // Proxy Authentication ID
                                        {
                                                uint16_t authid = ntohs(*(uint16_t *)(b));
                                case 32:    // Proxy Authentication ID
                                        {
                                                uint16_t authid = ntohs(*(uint16_t *)(b));

-                                               LOG(4, s, t, "   Proxy Auth ID (%d)\n", authid);
+                                               LOG(4, s, t, "   Proxy Auth ID (%u)\n", authid);

                                                break;
                                        }
                                case 33:    // Proxy Authentication Response
                                                break;
                                        }
                                case 33:    // Proxy Authentication Response


@@ -2350,10 +2519,90 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        memcpy(session[s].random_vector, b, n);
                                        session[s].random_vector_length = n;
                                        break;
                                        memcpy(session[s].random_vector, b, n);
                                        session[s].random_vector_length = n;
                                        break;

+                               case 46:    // ppp disconnect cause
+                                       if (n >= 5)
+                                       {
+                                               uint16_t code = ntohs(*(uint16_t *) b);
+                                               uint16_t proto = ntohs(*(uint16_t *) (b + 2));
+                                               uint8_t dir = *(b + 4);
+
+                                               LOG(4, s, t, "   PPP disconnect cause "
+                                                       "(code=%u, proto=%04X, dir=%u, msg=\"%.*s\")\n",
+                                                       code, proto, dir, n - 5, b + 5);
+
+                                               disc_cause_set = mtype;
+
+                                               switch (code)
+                                               {
+                                               case 1: // admin disconnect
+                                                       disc_cause = TERM_ADMIN_RESET;
+                                                       disc_reason = "Administrative disconnect";
+                                                       break;
+                                               case 3: // lcp terminate
+                                                       if (dir != 2) break; // 1=peer (LNS), 2=local (LAC)
+                                                       disc_cause = TERM_USER_REQUEST;
+                                                       disc_reason = "Normal disconnection";
+                                                       break;
+                                               case 4: // compulsory encryption unavailable
+                                                       if (dir != 1) break; // 1=refused by peer, 2=local
+                                                       disc_cause = TERM_USER_ERROR;
+                                                       disc_reason = "Compulsory encryption refused";
+                                                       break;
+                                               case 5: // lcp: fsm timeout
+                                                       disc_cause = TERM_PORT_ERROR;
+                                                       disc_reason = "LCP: FSM timeout";
+                                                       break;
+                                               case 6: // lcp: no recognisable lcp packets received
+                                                       disc_cause = TERM_PORT_ERROR;
+                                                       disc_reason = "LCP: no recognisable LCP packets";
+                                                       break;
+                                               case 7: // lcp: magic-no error (possibly looped back)
+                                                       disc_cause = TERM_PORT_ERROR;
+                                                       disc_reason = "LCP: magic-no error (possible loop)";
+                                                       break;
+                                               case 8: // lcp: echo request timeout
+                                                       disc_cause = TERM_PORT_ERROR;
+                                                       disc_reason = "LCP: echo request timeout";
+                                                       break;
+                                               case 13: // auth: fsm timeout
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = "Authentication: FSM timeout";
+                                                       break;
+                                               case 15: // auth: unacceptable auth protocol
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = "Unacceptable authentication protocol";
+                                                       break;
+                                               case 16: // auth: authentication failed
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = "Authentication failed";
+                                                       break;
+                                               case 17: // ncp: fsm timeout
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = "NCP: FSM timeout";
+                                                       break;
+                                               case 18: // ncp: no ncps available
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = "NCP: no NCPs available";
+                                                       break;
+                                               case 19: // ncp: failure to converge on acceptable address
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = (dir == 1)
+                                                               ? "NCP: too many Configure-Naks received from peer"
+                                                               : "NCP: too many Configure-Naks sent to peer";
+                                                       break;
+                                               case 20: // ncp: user not permitted to use any address
+                                                       disc_cause = TERM_SERVICE_UNAVAILABLE;
+                                                       disc_reason = (dir == 1)
+                                                               ? "NCP: local link address not acceptable to peer"
+                                                               : "NCP: remote link address not acceptable";
+                                                       break;
+                                               }
+                                       }
+                                       break;

                                default:
                                        {
                                                static char e[] = "unknown AVP 0xXXXX";
                                default:
                                        {
                                                static char e[] = "unknown AVP 0xXXXX";

-                                               LOG(2, s, t, "   Unknown AVP type %d\n", mtype);
+                                               LOG(2, s, t, "   Unknown AVP type %u\n", mtype);

                                                fatal = flags;
                                                result = 2; // general error
                                                error = 8; // unknown mandatory AVP
                                                fatal = flags;
                                                result = 2; // general error
                                                error = 8; // unknown mandatory AVP


@@ -2423,8 +2672,8 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                                session[s].opened = time_now;
                                                session[s].tunnel = t;
                                                session[s].far = asession;
                                                session[s].opened = time_now;
                                                session[s].tunnel = t;
                                                session[s].far = asession;

-                                               session[s].last_packet = time_now;
-                                               LOG(3, s, t, "New session (%d/%d)\n", tunnel[t].far, session[s].far);
+                                               session[s].last_packet = session[s].last_data = time_now;
+                                               LOG(3, s, t, "New session (%u/%u)\n", tunnel[t].far, session[s].far);

                                                control16(c, 14, s, 1); // assigned session
                                                controladd(c, asession, t); // send the reply
 
                                                control16(c, 14, s, 1); // assigned session
                                                controladd(c, asession, t); // send the reply
 


@@ -2459,19 +2708,24 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        if (amagic == 0) amagic = time_now;
                                        session[s].magic = amagic; // set magic number
                                        session[s].flags = aflags; // set flags received
                                        if (amagic == 0) amagic = time_now;
                                        session[s].magic = amagic; // set magic number
                                        session[s].flags = aflags; // set flags received

-                                       session[s].mru = PPPMTU; // default
+                                       session[s].mru = PPPoE_MRU; // default

                                        controlnull(t); // ack
 
                                        // start LCP
                                        sess_local[s].lcp_authtype = config->radius_authprefer;
                                        sess_local[s].ppp_mru = MRU;
                                        controlnull(t); // ack
 
                                        // start LCP
                                        sess_local[s].lcp_authtype = config->radius_authprefer;
                                        sess_local[s].ppp_mru = MRU;

+
+                                       // Set multilink options before sending initial LCP packet
+                                       sess_local[s].mp_mrru = 1614;
+                                       sess_local[s].mp_epdis = config->bind_address ? config->bind_address : my_address;
+

                                        sendlcp(s, t);
                                        change_state(s, lcp, RequestSent);
                                        break;
 
                                case 14:      // CDN
                                        controlnull(t); // ack
                                        sendlcp(s, t);
                                        change_state(s, lcp, RequestSent);
                                        break;
 
                                case 14:      // CDN
                                        controlnull(t); // ack

-                                       sessionshutdown(s, "Closed (Received CDN).", 0, 0);
+                                       sessionshutdown(s, disc_reason, CDN_NONE, disc_cause);

                                        break;
                                case 0xFFFF:
                                        LOG(1, s, t, "Missing message type\n");
                                        break;
                                case 0xFFFF:
                                        LOG(1, s, t, "Missing message type\n");


@@ -2481,7 +2735,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        if (mandatory)
                                                tunnelshutdown(t, "Unknown message type", 2, 6, "unknown message type");
                                        else
                                        if (mandatory)
                                                tunnelshutdown(t, "Unknown message type", 2, 6, "unknown message type");
                                        else

-                                               LOG(1, s, t, "Unknown message type %d\n", message);
+                                               LOG(1, s, t, "Unknown message type %u\n", message);

                                        break;
                                }
                        if (chapresponse) free(chapresponse);
                                        break;
                                }
                        if (chapresponse) free(chapresponse);


@@ -2575,11 +2829,11 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                {
                        if (session[s].die)
                        {
                {
                        if (session[s].die)
                        {

-                               LOG(4, s, t, "Session %d is closing.  Don't process PPP packets\n", s);
+                               LOG(4, s, t, "Session %u is closing.  Don't process PPP packets\n", s);

                                return;              // closing session, PPP not processed
                        }
 
                                return;              // closing session, PPP not processed
                        }
 

-                       session[s].last_packet = time_now;
+                       session[s].last_packet = session[s].last_data = time_now;

                        if (session[s].walled_garden && !config->cluster_iam_master)
                        {
                                master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
                        if (session[s].walled_garden && !config->cluster_iam_master)
                        {
                                master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);


@@ -2588,15 +2842,32 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
 
                        processipin(s, t, p, l);
                }
 
                        processipin(s, t, p, l);
                }

+               else if (proto == PPPMP)
+               {
+                       if (session[s].die)
+                       {
+                               LOG(4, s, t, "Session %u is closing.  Don't process PPP packets\n", s);
+                               return;              // closing session, PPP not processed
+                       }
+
+                       session[s].last_packet = session[s].last_data = time_now;
+                       if (session[s].walled_garden && !config->cluster_iam_master)
+                       {
+                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
+                               return;
+                       }
+
+                       processmpin(s, t, p, l);
+               }

                else if (proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0])
                {
                        if (session[s].die)
                        {
                else if (proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0])
                {
                        if (session[s].die)
                        {

-                               LOG(4, s, t, "Session %d is closing.  Don't process PPP packets\n", s);
+                               LOG(4, s, t, "Session %u is closing.  Don't process PPP packets\n", s);

                                return;              // closing session, PPP not processed
                        }
 
                                return;              // closing session, PPP not processed
                        }
 

-                       session[s].last_packet = time_now;
+                       session[s].last_packet = session[s].last_data = time_now;

                        if (session[s].walled_garden && !config->cluster_iam_master)
                        {
                                master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
                        if (session[s].walled_garden && !config->cluster_iam_master)
                        {
                                master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);


@@ -2607,29 +2878,9 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                }
                else if (session[s].ppp.lcp == Opened)
                {
                }
                else if (session[s].ppp.lcp == Opened)
                {

-                       uint8_t buf[MAXETHER];
-                       uint8_t *q;
-                       int mru = session[s].mru;
-                       if (mru > sizeof(buf)) mru = sizeof(buf);
-
-                       l += 6;
-                       if (l > mru) l = mru;
-
-                       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPLCP);
-                       if (!q) return;
-
-                       *q = ProtocolRej;
-                       *(q + 1) = ++sess_local[s].lcp_ident;
-                       *(uint16_t *)(q + 2) = htons(l);
-                       *(uint16_t *)(q + 4) = htons(proto);
-                       memcpy(q + 6, p, l - 6);
-
-                       if (proto == PPPIPV6CP)
-                               LOG(3, s, t, "LCP: send ProtocolRej (IPV6CP: not configured)\n");
-                       else
-                               LOG(2, s, t, "LCP: sent ProtocolRej (0x%04X: unsupported)\n", proto);
-
-                       tunnelsend(buf, l + (q - buf), t);
+                       session[s].last_packet = time_now;
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
+                       protoreject(s, t, p, l, proto);

                }
                else
                {
                }
                else
                {


@@ -2821,7 +3072,7 @@ static void regular_cleanups(double period)
                                }
                                else
                                {
                                }
                                else
                                {

-                                       sessionshutdown(s, "No response to LCP ConfigReq.", 3, 0);
+                                       sessionshutdown(s, "No response to LCP ConfigReq.", CDN_ADMIN_DISC, TERM_LOST_SERVICE);

                                        STAT(session_timeout);
                                }
 
                                        STAT(session_timeout);
                                }
 


@@ -2850,7 +3101,7 @@ static void regular_cleanups(double period)
                                }
                                else
                                {
                                }
                                else
                                {

-                                       sessionshutdown(s, "No response to IPCP ConfigReq.", 3, 0);
+                                       sessionshutdown(s, "No response to IPCP ConfigReq.", CDN_ADMIN_DISC, TERM_LOST_SERVICE);

                                        STAT(session_timeout);
                                }
 
                                        STAT(session_timeout);
                                }
 


@@ -2916,7 +3167,7 @@ static void regular_cleanups(double period)
                // Drop sessions who have not responded within IDLE_TIMEOUT seconds
                if (session[s].last_packet && (time_now - session[s].last_packet >= IDLE_TIMEOUT))
                {
                // Drop sessions who have not responded within IDLE_TIMEOUT seconds
                if (session[s].last_packet && (time_now - session[s].last_packet >= IDLE_TIMEOUT))
                {

-                       sessionshutdown(s, "No response to LCP ECHO requests.", 3, 0);
+                       sessionshutdown(s, "No response to LCP ECHO requests.", CDN_ADMIN_DISC, TERM_LOST_SERVICE);

                        STAT(session_timeout);
                        s_actions++;
                        continue;
                        STAT(session_timeout);
                        s_actions++;
                        continue;


@@ -2928,13 +3179,13 @@ static void regular_cleanups(double period)
                {
                        uint8_t b[MAXETHER];
 
                {
                        uint8_t b[MAXETHER];
 

-                       uint8_t *q = makeppp(b, sizeof(b), 0, 0, s, session[s].tunnel, PPPLCP);
+                       uint8_t *q = makeppp(b, sizeof(b), 0, 0, s, session[s].tunnel, PPPLCP, 1, 0, 0);

                        if (!q) continue;
 
                        *q = EchoReq;
                        *(uint8_t *)(q + 1) = (time_now % 255); // ID
                        *(uint16_t *)(q + 2) = htons(8); // Length
                        if (!q) continue;
 
                        *q = EchoReq;
                        *(uint8_t *)(q + 1) = (time_now % 255); // ID
                        *(uint16_t *)(q + 2) = htons(8); // Length

-                       *(uint32_t *)(q + 4) = 0; // Magic Number (not supported)
+                       *(uint32_t *)(q + 4) = session[s].ppp.lcp == Opened ? htonl(session[s].magic) : 0; // Magic Number

 
                        LOG(4, s, session[s].tunnel, "No data in %d seconds, sending LCP ECHO\n",
                                        (int)(time_now - session[s].last_packet));
 
                        LOG(4, s, session[s].tunnel, "No data in %d seconds, sending LCP ECHO\n",
                                        (int)(time_now - session[s].last_packet));


@@ -2943,6 +3194,45 @@ static void regular_cleanups(double period)
                        s_actions++;
                }
 
                        s_actions++;
                }
 

+               // Drop sessions who have reached session_timeout seconds
+               if (session[s].session_timeout)
+               {
+                       bundleidt bid = session[s].bundle;
+                       if (bid)
+                       {
+                               if (time_now - bundle[bid].last_check >= 1)
+                               {
+                                       bundle[bid].online_time += (time_now - bundle[bid].last_check) * bundle[bid].num_of_links;
+                                       bundle[bid].last_check = time_now;
+                                       if (bundle[bid].online_time >= session[s].session_timeout)
+                                       {
+                                               int ses;
+                                               for (ses = bundle[bid].num_of_links - 1; ses >= 0; ses--)
+                                               {
+                                                       sessionshutdown(bundle[bid].members[ses], "Session timeout", CDN_ADMIN_DISC, TERM_SESSION_TIMEOUT);
+                                                       s_actions++;
+                                                       continue;
+                                               }
+                                       }
+                               }
+                       }
+                       else if (time_now - session[s].opened >= session[s].session_timeout)
+                       {
+                               sessionshutdown(s, "Session timeout", CDN_ADMIN_DISC, TERM_SESSION_TIMEOUT);
+                               s_actions++;
+                               continue;
+                       }
+               }
+
+               // Drop sessions who have reached idle_timeout seconds
+               if (session[s].last_data && session[s].idle_timeout && (time_now - session[s].last_data >= session[s].idle_timeout))
+               {
+                       sessionshutdown(s, "Idle Timeout Reached", CDN_ADMIN_DISC, TERM_IDLE_TIMEOUT);
+                       STAT(session_timeout);
+                       s_actions++;
+                       continue;
+               }
+

                // Check for actions requested from the CLI
                if ((a = cli_session_actions[s].action))
                {
                // Check for actions requested from the CLI
                if ((a = cli_session_actions[s].action))
                {


@@ -2952,7 +3242,7 @@ static void regular_cleanups(double period)
                        if (a & CLI_SESS_KILL)
                        {
                                LOG(2, s, session[s].tunnel, "Dropping session by CLI\n");
                        if (a & CLI_SESS_KILL)
                        {
                                LOG(2, s, session[s].tunnel, "Dropping session by CLI\n");

-                               sessionshutdown(s, "Requested by administrator.", 3, 0);
+                               sessionshutdown(s, "Requested by administrator.", CDN_ADMIN_DISC, TERM_ADMIN_RESET);

                                a = 0; // dead, no need to check for other actions
                                s_actions++;
                        }
                                a = 0; // dead, no need to check for other actions
                                s_actions++;
                        }


@@ -2967,7 +3257,7 @@ static void regular_cleanups(double period)
                        }
                        else if (a & CLI_SESS_SNOOP)
                        {
                        }
                        else if (a & CLI_SESS_SNOOP)
                        {

-                               LOG(2, s, session[s].tunnel, "Snooping session by CLI (to %s:%d)\n",
+                               LOG(2, s, session[s].tunnel, "Snooping session by CLI (to %s:%u)\n",

                                    fmtaddr(cli_session_actions[s].snoop_ip, 0),
                                    cli_session_actions[s].snoop_port);
 
                                    fmtaddr(cli_session_actions[s].snoop_ip, 0),
                                    cli_session_actions[s].snoop_port);
 


@@ -3110,7 +3400,7 @@ static int still_busy(void)
 
                if (last_talked != TIME)
                {
 
                if (last_talked != TIME)
                {

-                       LOG(2, 0, 0, "Tunnel %d still has un-acked control messages.\n", i);
+                       LOG(2, 0, 0, "Tunnel %u still has un-acked control messages.\n", i);

                        last_talked = TIME;
                }
                return 1;
                        last_talked = TIME;
                }
                return 1;


@@ -3132,7 +3422,7 @@ static int still_busy(void)
 
                if (last_talked != TIME)
                {
 
                if (last_talked != TIME)
                {

-                       LOG(2, 0, 0, "Radius session %d is still busy (sid %d)\n", i, radius[i].session);
+                       LOG(2, 0, 0, "Radius session %u is still busy (sid %u)\n", i, radius[i].session);

                        last_talked = TIME;
                }
                return 1;
                        last_talked = TIME;
                }
                return 1;


@@ -3184,9 +3474,12 @@ static void mainloop(void)
                e.events = EPOLLIN;
                i = 0;
 
                e.events = EPOLLIN;
                i = 0;
 

-               d[i].type = FD_TYPE_CLI;
-               e.data.ptr = &d[i++];
-               epoll_ctl(epollfd, EPOLL_CTL_ADD, clifd, &e);
+               if (clifd >= 0)
+               {
+                       d[i].type = FD_TYPE_CLI;
+                       e.data.ptr = &d[i++];
+                       epoll_ctl(epollfd, EPOLL_CTL_ADD, clifd, &e);
+               }

 
                d[i].type = FD_TYPE_CLUSTER;
                e.data.ptr = &d[i++];
 
                d[i].type = FD_TYPE_CLUSTER;
                e.data.ptr = &d[i++];


@@ -3264,6 +3557,7 @@ static void mainloop(void)
                if (n)
                {
                        struct sockaddr_in addr;
                if (n)
                {
                        struct sockaddr_in addr;

+                       struct in_addr local;

                        socklen_t alen;
                        int c, s;
                        int udp_ready = 0;
                        socklen_t alen;
                        int c, s;
                        int udp_ready = 0;


@@ -3280,6 +3574,7 @@ static void mainloop(void)
                        for (c = n, i = 0; i < c; i++)
                        {
                                struct event_data *d = events[i].data.ptr;
                        for (c = n, i = 0; i < c; i++)
                        {
                                struct event_data *d = events[i].data.ptr;

+

                                switch (d->type)
                                {
                                case FD_TYPE_CLI: // CLI connections
                                switch (d->type)
                                {
                                case FD_TYPE_CLI: // CLI connections


@@ -3306,20 +3601,30 @@ static void mainloop(void)
 
                                case FD_TYPE_CONTROL: // nsctl commands
                                        alen = sizeof(addr);
 
                                case FD_TYPE_CONTROL: // nsctl commands
                                        alen = sizeof(addr);

-                                       processcontrol(buf, recvfrom(controlfd, buf, sizeof(buf), MSG_WAITALL, (void *) &addr, &alen), &addr, alen);
+                                       s = recvfromto(controlfd, buf, sizeof(buf), MSG_WAITALL, (struct sockaddr *) &addr, &alen, &local);
+                                       if (s > 0) processcontrol(buf, s, &addr, alen, &local);

                                        n--;
                                        break;
 
                                case FD_TYPE_DAE: // DAE requests
                                        alen = sizeof(addr);
                                        n--;
                                        break;
 
                                case FD_TYPE_DAE: // DAE requests
                                        alen = sizeof(addr);

-                                       processdae(buf, recvfrom(daefd, buf, sizeof(buf), MSG_WAITALL, (void *) &addr, &alen), &addr, alen);
+                                       s = recvfromto(daefd, buf, sizeof(buf), MSG_WAITALL, (struct sockaddr *) &addr, &alen, &local);
+                                       if (s > 0) processdae(buf, s, &addr, alen, &local);

                                        n--;
                                        break;
 
                                case FD_TYPE_RADIUS: // RADIUS response
                                        n--;
                                        break;
 
                                case FD_TYPE_RADIUS: // RADIUS response

-                                       s = recv(radfds[d->index], buf, sizeof(buf), 0);
+                                       alen = sizeof(addr);
+                                       s = recvfrom(radfds[d->index], buf, sizeof(buf), MSG_WAITALL, (struct sockaddr *) &addr, &alen);

                                        if (s >= 0 && config->cluster_iam_master)
                                        if (s >= 0 && config->cluster_iam_master)

-                                               processrad(buf, s, d->index);
+                                       {
+                                               if (addr.sin_addr.s_addr == config->radiusserver[0] ||
+                                                   addr.sin_addr.s_addr == config->radiusserver[1])
+                                                       processrad(buf, s, d->index);
+                                               else
+                                                       LOG(3, 0, 0, "Dropping RADIUS packet from unknown source %s\n",
+                                                               fmtaddr(addr.sin_addr.s_addr, 0));
+                                       }

 
                                        n--;
                                        break;
 
                                        n--;
                                        break;


@@ -3628,6 +3933,16 @@ static void initdata(int optdebug, char *optconfig)
                LOG(0, 0, 0, "Error doing malloc for tunnels: %s\n", strerror(errno));
                exit(1);
        }
                LOG(0, 0, 0, "Error doing malloc for tunnels: %s\n", strerror(errno));
                exit(1);
        }

+       if (!(bundle = shared_malloc(sizeof(bundlet) * MAXBUNDLE)))
+       {
+               LOG(0, 0, 0, "Error doing malloc for bundles: %s\n", strerror(errno));
+               exit(1);
+       }
+       if (!(frag = shared_malloc(sizeof(fragmentationt) * MAXBUNDLE)))
+       {
+               LOG(0, 0, 0, "Error doing malloc for fragmentations: %s\n", strerror(errno));
+               exit(1);
+       }

        if (!(session = shared_malloc(sizeof(sessiont) * MAXSESSION)))
        {
                LOG(0, 0, 0, "Error doing malloc for sessions: %s\n", strerror(errno));
        if (!(session = shared_malloc(sizeof(sessiont) * MAXSESSION)))
        {
                LOG(0, 0, 0, "Error doing malloc for sessions: %s\n", strerror(errno));


@@ -3674,6 +3989,7 @@ static void initdata(int optdebug, char *optconfig)
        memset(cli_tunnel_actions, 0, sizeof(struct cli_tunnel_actions) * MAXSESSION);
 
        memset(tunnel, 0, sizeof(tunnelt) * MAXTUNNEL);
        memset(cli_tunnel_actions, 0, sizeof(struct cli_tunnel_actions) * MAXSESSION);
 
        memset(tunnel, 0, sizeof(tunnelt) * MAXTUNNEL);

+       memset(bundle, 0, sizeof(bundlet) * MAXBUNDLE);

        memset(session, 0, sizeof(sessiont) * MAXSESSION);
        memset(radius, 0, sizeof(radiust) * MAXRADIUS);
        memset(ip_address_pool, 0, sizeof(ippoolt) * MAXIPPOOL);
        memset(session, 0, sizeof(sessiont) * MAXSESSION);
        memset(radius, 0, sizeof(radiust) * MAXRADIUS);
        memset(ip_address_pool, 0, sizeof(ippoolt) * MAXIPPOOL);


@@ -3691,6 +4007,10 @@ static void initdata(int optdebug, char *optconfig)
        for (i = 1; i < MAXTUNNEL; i++)
                tunnel[i].state = TUNNELUNDEF;  // mark it as not filled in.
 
        for (i = 1; i < MAXTUNNEL; i++)
                tunnel[i].state = TUNNELUNDEF;  // mark it as not filled in.
 

+       for (i = 1; i < MAXBUNDLE; i++) {
+               bundle[i].state = BUNDLEUNDEF;
+       }
+

        if (!*hostname)
        {
                // Grab my hostname unless it's been specified
        if (!*hostname)
        {
                // Grab my hostname unless it's been specified


@@ -3825,7 +4145,7 @@ void rebuild_address_pool(void)
                        if (ipid < 1)                   // Not found in the pool either? good.
                                continue;
 
                        if (ipid < 1)                   // Not found in the pool either? good.
                                continue;
 

-                       LOG(0, i, 0, "Session %d has an IP address (%s) that was marked static, but is in the pool (%d)!\n",
+                       LOG(0, i, 0, "Session %u has an IP address (%s) that was marked static, but is in the pool (%d)!\n",

                                i, fmtaddr(session[i].ip, 0), ipid);
 
                        // Fall through and process it as part of the pool.
                                i, fmtaddr(session[i].ip, 0), ipid);
 
                        // Fall through and process it as part of the pool.


@@ -3834,7 +4154,7 @@ void rebuild_address_pool(void)
 
                if (ipid > MAXIPPOOL || ipid < 0)
                {
 
                if (ipid > MAXIPPOOL || ipid < 0)
                {

-                       LOG(0, i, 0, "Session %d has a pool IP that's not found in the pool! (%d)\n", i, ipid);
+                       LOG(0, i, 0, "Session %u has a pool IP that's not found in the pool! (%d)\n", i, ipid);

                        ipid = -1;
                        session[i].ip_pool_index = ipid;
                        continue;
                        ipid = -1;
                        session[i].ip_pool_index = ipid;
                        continue;


@@ -3965,7 +4285,7 @@ static void initippool()
                else
                {
                        // It's a single ip address
                else
                {
                        // It's a single ip address

-                       add_to_ip_pool(inet_addr(pool), 0);
+                       add_to_ip_pool(ntohl(inet_addr(pool)), 0);

                }
        }
        fclose(f);
                }
        }
        fclose(f);


@@ -3982,7 +4302,7 @@ void snoop_send_packet(uint8_t *packet, uint16_t size, in_addr_t destination, ui
        snoop_addr.sin_addr.s_addr = destination;
        snoop_addr.sin_port = ntohs(port);
 
        snoop_addr.sin_addr.s_addr = destination;
        snoop_addr.sin_port = ntohs(port);
 

-       LOG(5, 0, 0, "Snooping %d byte packet to %s:%d\n", size,
+       LOG(5, 0, 0, "Snooping %d byte packet to %s:%u\n", size,

                fmtaddr(snoop_addr.sin_addr.s_addr, 0),
                htons(snoop_addr.sin_port));
 
                fmtaddr(snoop_addr.sin_addr.s_addr, 0),
                htons(snoop_addr.sin_port));
 


@@ -4117,7 +4437,7 @@ int main(int argc, char *argv[])
        init_tbf(config->num_tbfs);
 
        LOG(0, 0, 0, "L2TPNS version " VERSION "\n");
        init_tbf(config->num_tbfs);
 
        LOG(0, 0, 0, "L2TPNS version " VERSION "\n");

-       LOG(0, 0, 0, "Copyright (c) 2003, 2004, 2005 Optus Internet Engineering\n");
+       LOG(0, 0, 0, "Copyright (c) 2003, 2004, 2005, 2006 Optus Internet Engineering\n");

        LOG(0, 0, 0, "Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced\n");
        {
                struct rlimit rlim;
        LOG(0, 0, 0, "Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced\n");
        {
                struct rlimit rlim;


@@ -4189,10 +4509,6 @@ int main(int argc, char *argv[])
                        LOG(0, 0, 0, "Can't lock pages: %s\n", strerror(errno));
        }
 
                        LOG(0, 0, 0, "Can't lock pages: %s\n", strerror(errno));
        }
 

-       // Drop privileges here
-       if (config->target_uid > 0 && geteuid() == 0)
-               setuid(config->target_uid);
-

        mainloop();
 
        /* remove plugins (so cleanup code gets run) */
        mainloop();
 
        /* remove plugins (so cleanup code gets run) */


@@ -4311,12 +4627,15 @@ static void update_config()
 #define L2TP_HDRS              (20+8+6+4)      // L2TP data encaptulation: ip + udp + l2tp (data) + ppp (inc hdlc)
 #define TCP_HDRS               (20+20)         // TCP encapsulation: ip + tcp
 
 #define L2TP_HDRS              (20+8+6+4)      // L2TP data encaptulation: ip + udp + l2tp (data) + ppp (inc hdlc)
 #define TCP_HDRS               (20+20)         // TCP encapsulation: ip + tcp
 

-       if (config->l2tp_mtu <= 0)              config->l2tp_mtu = PPPMTU;
+       if (config->l2tp_mtu <= 0)              config->l2tp_mtu = 1500; // ethernet default

        else if (config->l2tp_mtu < MINMTU)     config->l2tp_mtu = MINMTU;
        else if (config->l2tp_mtu > MAXMTU)     config->l2tp_mtu = MAXMTU;
 
        // reset MRU/MSS globals
        MRU = config->l2tp_mtu - L2TP_HDRS;
        else if (config->l2tp_mtu < MINMTU)     config->l2tp_mtu = MINMTU;
        else if (config->l2tp_mtu > MAXMTU)     config->l2tp_mtu = MAXMTU;
 
        // reset MRU/MSS globals
        MRU = config->l2tp_mtu - L2TP_HDRS;

+       if (MRU > PPPoE_MRU)
+               MRU = PPPoE_MRU;
+

        MSS = MRU - TCP_HDRS;
 
        // Update radius
        MSS = MRU - TCP_HDRS;
 
        // Update radius


@@ -4501,7 +4820,7 @@ int sessionsetup(sessionidt s, tunnelidt t)
                if (!session[s].ip)
                {
                        LOG(0, s, t, "   No IP allocated.  The IP address pool is FULL!\n");
                if (!session[s].ip)
                {
                        LOG(0, s, t, "   No IP allocated.  The IP address pool is FULL!\n");

-                       sessionshutdown(s, "No IP addresses available.", 2, 7); // try another
+                       sessionshutdown(s, "No IP addresses available.", CDN_TRY_ANOTHER, TERM_SERVICE_UNAVAILABLE);

                        return 0;
                }
                LOG(3, s, t, "   No IP allocated.  Assigned %s from pool\n",
                        return 0;
                }
                LOG(3, s, t, "   No IP allocated.  Assigned %s from pool\n",


@@ -4512,6 +4831,14 @@ int sessionsetup(sessionidt s, tunnelidt t)
        // Make sure this is right
        session[s].tunnel = t;
 
        // Make sure this is right
        session[s].tunnel = t;
 

+       // Join a bundle if the MRRU option is accepted
+       if (session[s].mrru > 0 && !session[s].bundle)
+       {
+               LOG(3, s, t, "This session can be part of multilink bundle\n");
+               if (join_bundle(s))
+                       cluster_send_bundle(session[s].bundle);
+       }
+

        // zap old sessions with same IP and/or username
        // Don't kill gardened sessions - doing so leads to a DoS
        // from someone who doesn't need to know the password
        // zap old sessions with same IP and/or username
        // Don't kill gardened sessions - doing so leads to a DoS
        // from someone who doesn't need to know the password


@@ -4528,8 +4855,21 @@ int sessionsetup(sessionidt s, tunnelidt t)
                                continue;
                        }
 
                                continue;
                        }
 

-                       if (config->allow_duplicate_users) continue;
-                       if (session[s].walled_garden || session[i].walled_garden) continue;
+                       if (config->allow_duplicate_users)
+                               continue;
+
+                       if (session[s].walled_garden || session[i].walled_garden)
+                               continue;
+
+                       // Allow duplicate sessions for guest account.
+                       if (*config->guest_user && !strcasecmp(user, config->guest_user))
+                               continue;
+
+                       // Allow duplicate sessions for multilink ones of the same bundle.
+                       if (session[s].bundle && session[i].bundle && session[s].bundle == session[i].bundle)
+                               continue;
+
+                       // Drop the new session in case of duplicate sessionss, not the old one.

                        if (!strcasecmp(user, session[i].user))
                                sessionkill(i, "Duplicate session for users");
                }
                        if (!strcasecmp(user, session[i].user))
                                sessionkill(i, "Duplicate session for users");
                }


@@ -4574,7 +4914,7 @@ int sessionsetup(sessionidt s, tunnelidt t)
        if (session[s].throttle_in || session[s].throttle_out)
                throttle_session(s, session[s].throttle_in, session[s].throttle_out);
 
        if (session[s].throttle_in || session[s].throttle_out)
                throttle_session(s, session[s].throttle_in, session[s].throttle_out);
 

-       session[s].last_packet = time_now;
+       session[s].last_packet = session[s].last_data = time_now;

 
        LOG(2, s, t, "Login by %s at %s from %s (%s)\n", session[s].user,
                fmtaddr(htonl(session[s].ip), 0),
 
        LOG(2, s, t, "Login by %s at %s from %s (%s)\n", session[s].user,
                fmtaddr(htonl(session[s].ip), 0),


@@ -4677,13 +5017,13 @@ int load_session(sessionidt s, sessiont *new)
        // check filters
        if (new->filter_in && (new->filter_in > MAXFILTER || !ip_filters[new->filter_in - 1].name[0]))
        {
        // check filters
        if (new->filter_in && (new->filter_in > MAXFILTER || !ip_filters[new->filter_in - 1].name[0]))
        {

-               LOG(2, s, session[s].tunnel, "Dropping invalid input filter %d\n", (int) new->filter_in);
+               LOG(2, s, session[s].tunnel, "Dropping invalid input filter %u\n", (int) new->filter_in);

                new->filter_in = 0;
        }
 
        if (new->filter_out && (new->filter_out > MAXFILTER || !ip_filters[new->filter_out - 1].name[0]))
        {
                new->filter_in = 0;
        }
 
        if (new->filter_out && (new->filter_out > MAXFILTER || !ip_filters[new->filter_out - 1].name[0]))
        {

-               LOG(2, s, session[s].tunnel, "Dropping invalid output filter %d\n", (int) new->filter_out);
+               LOG(2, s, session[s].tunnel, "Dropping invalid output filter %u\n", (int) new->filter_out);

                new->filter_out = 0;
        }
 
                new->filter_out = 0;
        }
 


@@ -4888,7 +5228,7 @@ static void plugins_done()
                run_plugin_done(p);
 }
 
                run_plugin_done(p);
 }
 

-static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen)
+static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen, struct in_addr *local)

 {
        struct nsctl request;
        struct nsctl response;
 {
        struct nsctl request;
        struct nsctl response;


@@ -5046,7 +5386,7 @@ static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int
        r = pack_control(buf, NSCTL_MAX_PKT_SZ, response.type, response.argc, response.argv);
        if (r > 0)
        {
        r = pack_control(buf, NSCTL_MAX_PKT_SZ, response.type, response.argc, response.argv);
        if (r > 0)
        {

-               sendto(controlfd, buf, r, 0, (const struct sockaddr *) addr, alen);
+               sendtofrom(controlfd, buf, r, 0, (const struct sockaddr *) addr, alen, local);

                if (log_stream && config->debug >= 4)
                {
                        LOG(4, 0, 0, "Sent [%s] ", fmtaddr(addr->sin_addr.s_addr, 0));
                if (log_stream && config->debug >= 4)
                {
                        LOG(4, 0, 0, "Sent [%s] ", fmtaddr(addr->sin_addr.s_addr, 0));


@@ -5067,7 +5407,7 @@ static tunnelidt new_tunnel()
        {
                if (tunnel[i].state == TUNNELFREE)
                {
        {
                if (tunnel[i].state == TUNNELFREE)
                {

-                       LOG(4, 0, i, "Assigning tunnel ID %d\n", i);
+                       LOG(4, 0, i, "Assigning tunnel ID %u\n", i);

                        if (i > config->cluster_highest_tunnelid)
                                config->cluster_highest_tunnelid = i;
                        return i;
                        if (i > config->cluster_highest_tunnelid)
                                config->cluster_highest_tunnelid = i;
                        return i;


@@ -5137,7 +5477,7 @@ int cmd_show_hist_idle(struct cli_def *cli, char *command, char **argv, int argc
                if (!session[s].opened)
                        continue;
 
                if (!session[s].opened)
                        continue;
 

-               idle = time_now - session[s].last_packet;
+               idle = time_now - session[s].last_data;

                idle /= 5 ; // In multiples of 5 seconds.
                if (idle < 0)
                        idle = 0;
                idle /= 5 ; // In multiples of 5 seconds.
                if (idle < 0)
                        idle = 0;