Adding the possibility to listening multiple IP L2TP tunnels.
[l2tpns.git] / l2tpns.c
index 594b501..4545d6c 100644 (file)
--- a/l2tpns.c
+++ b/l2tpns.c
@@ -1,11 +1,9 @@
 // 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
 
-char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.116 2005/08/10 07:25:24 bodea Exp $";
-
 #include <arpa/inet.h>
 #include <assert.h>
 #include <errno.h>
@@ -14,7 +12,6 @@ char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.116 2005/08/10 07:25:24 bodea Exp
 #define SYSLOG_NAMES
 #include <syslog.h>
 #include <malloc.h>
-#include <math.h>
 #include <net/route.h>
 #include <sys/mman.h>
 #include <netdb.h>
@@ -31,7 +28,7 @@ char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.116 2005/08/10 07:25:24 bodea Exp
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/wait.h>
-#include <linux/if.h>
+#include <net/if.h>
 #include <stddef.h>
 #include <time.h>
 #include <dlfcn.h>
@@ -39,6 +36,8 @@ char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.116 2005/08/10 07:25:24 bodea Exp
 #include <sched.h>
 #include <sys/sysinfo.h>
 #include <libcli.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
 
 #include "md5.h"
 #include "l2tpns.h"
@@ -54,33 +53,52 @@ char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.116 2005/08/10 07:25:24 bodea Exp
 #include "bgp.h"
 #endif
 
+#include "l2tplac.h"
+#include "pppoe.h"
+
+char * Vendor_name = "Linux L2TPNS";
+uint32_t call_serial_number = 0;
+
 // Globals
 configt *config = NULL;                // all configuration
+int nlfd = -1;                 // netlink socket
 int tunfd = -1;                        // tun interface file handle. (network device)
-int udpfd = -1;                        // UDP file handle
+int udpfd[MAX_UDPFD + 1] = INIT_TABUDPFD;              // array UDP file handle + 1 for lac udp
+int udplacfd = -1;             // UDP LAC file handle
 int controlfd = -1;            // Control signal handle
 int clifd = -1;                        // Socket listening for CLI connections.
 int daefd = -1;                        // Socket listening for DAE connections.
 int snoopfd = -1;              // UDP file handle for sending out intercept data
 int *radfds = NULL;            // RADIUS requests file handles
-int ifrfd = -1;                        // File descriptor for routing, etc
-int ifr6fd = -1;               // File descriptor for IPv6 routing, etc
 int rand_fd = -1;              // Random data source
 int cluster_sockfd = -1;       // Intra-cluster communications socket.
 int epollfd = -1;              // event polling
 time_t basetime = 0;           // base clock
-char hostname[1000] = "";      // us.
+char hostname[MAXHOSTNAME] = "";       // us.
 static int tunidx;             // ifr_ifindex of tun device
+int nlseqnum = 0;              // netlink sequence number
+int min_initok_nlseqnum = 0;   // minimun seq number for messages after init is ok
 static int syslog_log = 0;     // are we logging to syslog
 static FILE *log_stream = 0;   // file handle for direct logging (i.e. direct into file, not via syslog).
 uint32_t last_id = 0;          // Unique ID for radius accounting
+// Guest change
+char guest_users[10][32];       // Array of guest users
+int guest_accounts_num = 0;     // Number of guest users
+
+// calculated from config->l2tp_mtu
+uint16_t MRU = 0;              // PPP MRU
+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
 
-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 {
-       int sess;
+       sessionidt sess;
        struct ipv6radix *branch;
 } ipv6_hash[256];              // Mapping from IPv6 address to session structures.
 
@@ -91,8 +109,11 @@ 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.
+uint64_t time_now_ms = 0;              // Current time in milliseconds since epoch.
 static char time_now_string[64] = {0}; // Current time as a string.
+static int time_changed = 0;           // time_now changed
 char main_quit = 0;                    // True if we're in the process of exiting.
+static char main_reload = 0;           // Re-load pending
 linked_list *loaded_plugins;
 linked_list *plugins[MAX_PLUGIN_TYPES];
 
@@ -104,7 +125,8 @@ config_descriptt config_values[] = {
        CONFIG("log_file", log_filename, STRING),
        CONFIG("pid_file", pid_file, STRING),
        CONFIG("random_device", random_device, STRING),
-       CONFIG("l2tp_secret", l2tpsecret, STRING),
+       CONFIG("l2tp_secret", l2tp_secret, STRING),
+       CONFIG("l2tp_mtu", l2tp_mtu, INT),
        CONFIG("ppp_restart_time", ppp_restart_time, INT),
        CONFIG("ppp_max_configure", ppp_max_configure, INT),
        CONFIG("ppp_max_failure", ppp_max_failure, INT),
@@ -119,14 +141,17 @@ 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_bind_min", radius_bind_min, SHORT),
+       CONFIG("radius_bind_max", radius_bind_max, SHORT),
        CONFIG("allow_duplicate_users", allow_duplicate_users, BOOL),
+       CONFIG("kill_timedout_sessions", kill_timedout_sessions, 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("setuid", target_uid, INT),
        CONFIG("dump_speed", dump_speed, BOOL),
        CONFIG("multi_read_count", multi_read_count, INT),
        CONFIG("scheduler_fifo", scheduler_fifo, BOOL),
@@ -135,25 +160,45 @@ config_descriptt config_values[] = {
        CONFIG("packet_limit", max_packets, INT),
        CONFIG("cluster_address", cluster_address, IPv4),
        CONFIG("cluster_interface", cluster_interface, STRING),
+       CONFIG("cluster_mcast_ttl", cluster_mcast_ttl, INT),
        CONFIG("cluster_hb_interval", cluster_hb_interval, INT),
        CONFIG("cluster_hb_timeout", cluster_hb_timeout, INT),
        CONFIG("cluster_master_min_adv", cluster_master_min_adv, INT),
        CONFIG("ipv6_prefix", ipv6_prefix, IPv6),
-       { NULL, 0, 0, 0 },
+       CONFIG("cli_bind_address", cli_bind_address, IPv4),
+       CONFIG("hostname", hostname, STRING),
+#ifdef BGP
+       CONFIG("nexthop_address", nexthop_address, IPv4),
+       CONFIG("nexthop6_address", nexthop6_address, IPv6),
+#endif
+       CONFIG("echo_timeout", echo_timeout, INT),
+       CONFIG("idle_echo_timeout", idle_echo_timeout, INT),
+       CONFIG("iftun_address", iftun_address, IPv4),
+       CONFIG("tundevicename", tundevicename, STRING),
+       CONFIG("disable_lac_func", disable_lac_func, BOOL),
+       CONFIG("auth_tunnel_change_addr_src", auth_tunnel_change_addr_src, BOOL),
+       CONFIG("bind_address_remotelns", bind_address_remotelns, IPv4),
+       CONFIG("bind_portremotelns", bind_portremotelns, SHORT),
+       CONFIG("pppoe_if_to_bind", pppoe_if_to_bind, STRING),
+       CONFIG("pppoe_service_name", pppoe_service_name, STRING),
+       CONFIG("pppoe_ac_name", pppoe_ac_name, STRING),
+       CONFIG("disable_sending_hello", disable_sending_hello, BOOL),
+       CONFIG("disable_no_spoof", disable_no_spoof, BOOL),
+       CONFIG("bind_multi_address", bind_multi_address, STRING),
+       { NULL, 0, 0, 0 }
 };
 
 static char *plugin_functions[] = {
        NULL,
        "plugin_pre_auth",
        "plugin_post_auth",
-       "plugin_packet_rx",
-       "plugin_packet_tx",
        "plugin_timer",
        "plugin_new_session",
        "plugin_kill_session",
        "plugin_control",
        "plugin_radius_response",
        "plugin_radius_reset",
+       "plugin_radius_account",
        "plugin_become_master",
        "plugin_new_session_master",
 };
@@ -165,6 +210,8 @@ static sessiont shut_acct[8192];
 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.
@@ -176,13 +223,14 @@ struct Tstats *_statistics = NULL;
 struct Tringbuffer *ringbuffer = NULL;
 #endif
 
-static void cache_ipmap(in_addr_t ip, int s);
+static ssize_t netlink_send(struct nlmsghdr *nh);
+static void netlink_addattr(struct nlmsghdr *nh, int type, const void *data, int alen);
+static void cache_ipmap(in_addr_t ip, sessionidt s);
 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 sigalrm_handler(int sig);
 static void shutdown_handler(int sig);
 static void sigchild_handler(int sig);
 static void build_chap_response(uint8_t *challenge, uint8_t id, uint16_t challenge_length, uint8_t **challenge_response);
@@ -192,23 +240,28 @@ static void initplugins(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);
-
-// on slaves, alow BGP to withdraw cleanly before exiting
-#define QUIT_DELAY     5
-
-// quit actions (master)
-#define QUIT_FAILOVER  1 // SIGTERM: exit when all control messages have been acked (for cluster failover)
-#define QUIT_SHUTDOWN  2 // SIGQUIT: shutdown sessions/tunnels, reject new connections
+static void bundleclear(bundleidt b);
 
 // return internal time (10ths since process startup), set f if given
+// as a side-effect sets time_now, and time_changed
 static clockt now(double *f)
 {
        struct timeval t;
        gettimeofday(&t, 0);
        if (f) *f = t.tv_sec + t.tv_usec / 1000000.0;
+       if (t.tv_sec != time_now)
+       {
+           time_now = t.tv_sec;
+           time_changed++;
+       }
+
+       // Time in milliseconds
+       // TODO FOR MLPPP DEV
+       //time_now_ms = (t.tv_sec * 1000) + (t.tv_usec/1000);
+
        return (t.tv_sec - basetime) * 10 + t.tv_usec / 100000 + 1;
 }
 
@@ -243,7 +296,7 @@ void _log(int level, sessionidt s, tunnelidt t, const char *format, ...)
                ringbuffer->buffer[ringbuffer->tail].session = s;
                ringbuffer->buffer[ringbuffer->tail].tunnel = t;
                va_start(ap, format);
-               vsnprintf(ringbuffer->buffer[ringbuffer->tail].message, 4095, format, ap);
+               vsnprintf(ringbuffer->buffer[ringbuffer->tail].message, MAX_LOG_LENGTH, format, ap);
                va_end(ap);
        }
 #endif
@@ -389,43 +442,65 @@ void random_data(uint8_t *buf, int len)
 // via BGP if enabled, and stuffs it into the
 // 'sessionbyip' cache.
 //
-// 'ip' and 'mask' must be in _host_ order.
+// 'ip' must be in _host_ order.
 //
-static void routeset(sessionidt s, in_addr_t ip, in_addr_t mask, in_addr_t gw, int add)
+static void routeset(sessionidt s, in_addr_t ip, int prefixlen, in_addr_t gw, int add)
 {
-       struct rtentry r;
+       struct {
+               struct nlmsghdr nh;
+               struct rtmsg rt;
+               char buf[32];
+       } req;
        int i;
+       in_addr_t n_ip;
+
+       if (!prefixlen) prefixlen = 32;
+
+       ip &= 0xffffffff << (32 - prefixlen);;  // Force the ip to be the first one in the route.
+
+       memset(&req, 0, sizeof(req));
+
+       if (add)
+       {
+               req.nh.nlmsg_type = RTM_NEWROUTE;
+               req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE;
+       }
+       else
+       {
+               req.nh.nlmsg_type = RTM_DELROUTE;
+               req.nh.nlmsg_flags = NLM_F_REQUEST;
+       }
 
-       if (!mask) mask = 0xffffffff;
+       req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.rt));
 
-       ip &= mask;             // Force the ip to be the first one in the route.
+       req.rt.rtm_family = AF_INET;
+       req.rt.rtm_dst_len = prefixlen;
+       req.rt.rtm_table = RT_TABLE_MAIN;
+       req.rt.rtm_protocol = 42;
+       req.rt.rtm_scope = RT_SCOPE_LINK;
+       req.rt.rtm_type = RTN_UNICAST;
 
-       memset(&r, 0, sizeof(r));
-       r.rt_dev = config->tundevice;
-       r.rt_dst.sa_family = AF_INET;
-       *(uint32_t *) & (((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr) = htonl(ip);
-       r.rt_gateway.sa_family = AF_INET;
-       *(uint32_t *) & (((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr) = htonl(gw);
-       r.rt_genmask.sa_family = AF_INET;
-       *(uint32_t *) & (((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr) = htonl(mask);
-       r.rt_flags = (RTF_UP | RTF_STATIC);
+       netlink_addattr(&req.nh, RTA_OIF, &tunidx, sizeof(int));
+       n_ip = htonl(ip);
+       netlink_addattr(&req.nh, RTA_DST, &n_ip, sizeof(n_ip));
        if (gw)
-               r.rt_flags |= RTF_GATEWAY;
-       else if (mask == 0xffffffff)
-               r.rt_flags |= RTF_HOST;
+       {
+               n_ip = htonl(gw);
+               netlink_addattr(&req.nh, RTA_GATEWAY, &n_ip, sizeof(n_ip));
+       }
 
-       LOG(1, s, 0, "Route %s %s/%s%s%s\n", add ? "add" : "del",
-           fmtaddr(htonl(ip), 0), fmtaddr(htonl(mask), 1),
+       LOG(1, s, session[s].tunnel, "Route %s %s/%d%s%s\n", add ? "add" : "del",
+           fmtaddr(htonl(ip), 0), prefixlen,
            gw ? " via" : "", gw ? fmtaddr(htonl(gw), 2) : "");
 
-       if (ioctl(ifrfd, add ? SIOCADDRT : SIOCDELRT, (void *) &r) < 0)
-               LOG(0, 0, 0, "routeset() error in ioctl: %s\n", strerror(errno));
+       if (netlink_send(&req.nh) < 0)
+               LOG(0, 0, 0, "routeset() error in sending netlink message: %s\n", strerror(errno));
 
 #ifdef BGP
        if (add)
-               bgp_add_route(htonl(ip), htonl(mask));
+               bgp_add_route(htonl(ip), prefixlen);
        else
-               bgp_del_route(htonl(ip), htonl(mask));
+               bgp_del_route(htonl(ip), prefixlen);
 #endif /* BGP */
 
                // Add/Remove the IPs to the 'sessionbyip' cache.
@@ -441,40 +516,68 @@ static void routeset(sessionidt s, in_addr_t ip, in_addr_t mask, in_addr_t gw, i
                if (!add)       // Are we deleting a route?
                        s = 0;  // Caching the session as '0' is the same as uncaching.
 
-               for (i = ip; (i&mask) == (ip&mask) ; ++i)
+               for (i = ip; i < ip+(1<<(32-prefixlen)) ; ++i)
                        cache_ipmap(i, s);
        }
 }
 
 void route6set(sessionidt s, struct in6_addr ip, int prefixlen, int add)
 {
-       struct in6_rtmsg rt;
+       struct {
+               struct nlmsghdr nh;
+               struct rtmsg rt;
+               char buf[64];
+       } req;
+       int metric;
        char ipv6addr[INET6_ADDRSTRLEN];
 
-       if (ifr6fd < 0)
+       if (!config->ipv6_prefix.s6_addr[0])
        {
                LOG(0, 0, 0, "Asked to set IPv6 route, but IPv6 not setup.\n");
                return;
        }
 
-       memset(&rt, 0, sizeof(rt));
+       memset(&req, 0, sizeof(req));
+
+       if (add)
+       {
+               req.nh.nlmsg_type = RTM_NEWROUTE;
+               req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE;
+       }
+       else
+       {
+               req.nh.nlmsg_type = RTM_DELROUTE;
+               req.nh.nlmsg_flags = NLM_F_REQUEST;
+       }
 
-       memcpy(&rt.rtmsg_dst, &ip, sizeof(struct in6_addr));
-       rt.rtmsg_dst_len = prefixlen;
-       rt.rtmsg_metric = 1;
-       rt.rtmsg_flags = RTF_UP;
-       rt.rtmsg_ifindex = tunidx;
+       req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.rt));
 
-       LOG(1, 0, 0, "Route %s %s/%d\n",
+       req.rt.rtm_family = AF_INET6;
+       req.rt.rtm_dst_len = prefixlen;
+       req.rt.rtm_table = RT_TABLE_MAIN;
+       req.rt.rtm_protocol = 42;
+       req.rt.rtm_scope = RT_SCOPE_LINK;
+       req.rt.rtm_type = RTN_UNICAST;
+
+       netlink_addattr(&req.nh, RTA_OIF, &tunidx, sizeof(int));
+       netlink_addattr(&req.nh, RTA_DST, &ip, sizeof(ip));
+       metric = 1;
+       netlink_addattr(&req.nh, RTA_METRICS, &metric, sizeof(metric));
+
+       LOG(1, s, session[s].tunnel, "Route %s %s/%d\n",
            add ? "add" : "del",
            inet_ntop(AF_INET6, &ip, ipv6addr, INET6_ADDRSTRLEN),
            prefixlen);
 
-       if (ioctl(ifr6fd, add ? SIOCADDRT : SIOCDELRT, (void *) &rt) < 0)
-               LOG(0, 0, 0, "route6set() error in ioctl: %s\n",
-                               strerror(errno));
+       if (netlink_send(&req.nh) < 0)
+               LOG(0, 0, 0, "route6set() error in sending netlink message: %s\n", strerror(errno));
 
-       // FIXME: need to add BGP routing (RFC2858)
+#ifdef BGP
+       if (add)
+               bgp_add_route6(ip, prefixlen);
+       else
+               bgp_del_route6(ip, prefixlen);
+#endif /* BGP */
 
        if (s)
        {
@@ -487,12 +590,86 @@ void route6set(sessionidt s, struct in6_addr ip, int prefixlen, int add)
        return;
 }
 
-// defined in linux/ipv6.h, but tricky to include from user-space
-// TODO: move routing to use netlink rather than ioctl
-struct in6_ifreq {
-       struct in6_addr ifr6_addr;
-       __u32 ifr6_prefixlen;
-       unsigned int ifr6_ifindex;
+//
+// Set up netlink socket
+static void initnetlink(void)
+{
+       struct sockaddr_nl nladdr;
+
+       nlfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+       if (nlfd < 0)
+       {
+               LOG(0, 0, 0, "Can't create netlink socket: %s\n", strerror(errno));
+               exit(1);
+       }
+
+       memset(&nladdr, 0, sizeof(nladdr));
+       nladdr.nl_family = AF_NETLINK;
+       nladdr.nl_pid = getpid();
+
+       if (bind(nlfd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0)
+       {
+               LOG(0, 0, 0, "Can't bind netlink socket: %s\n", strerror(errno));
+               exit(1);
+       }
+}
+
+static ssize_t netlink_send(struct nlmsghdr *nh)
+{
+       struct sockaddr_nl nladdr;
+       struct iovec iov;
+       struct msghdr msg;
+
+       nh->nlmsg_pid = getpid();
+       nh->nlmsg_seq = ++nlseqnum;
+
+       // set kernel address
+       memset(&nladdr, 0, sizeof(nladdr));
+       nladdr.nl_family = AF_NETLINK;
+
+       iov = (struct iovec){ (void *)nh, nh->nlmsg_len };
+       msg = (struct msghdr){ (void *)&nladdr, sizeof(nladdr), &iov, 1, NULL, 0, 0 };
+
+       return sendmsg(nlfd, &msg, 0);
+}
+
+static ssize_t netlink_recv(void *buf, ssize_t len)
+{
+       struct sockaddr_nl nladdr;
+       struct iovec iov;
+       struct msghdr msg;
+
+       // set kernel address
+       memset(&nladdr, 0, sizeof(nladdr));
+       nladdr.nl_family = AF_NETLINK;
+
+       iov = (struct iovec){ buf, len };
+       msg = (struct msghdr){ (void *)&nladdr, sizeof(nladdr), &iov, 1, NULL, 0, 0 };
+
+       return recvmsg(nlfd, &msg, 0);
+}
+
+/* adapted from iproute2 */
+static void netlink_addattr(struct nlmsghdr *nh, int type, const void *data, int alen)
+{
+       int len = RTA_LENGTH(alen);
+       struct rtattr *rta;
+
+       rta = (struct rtattr *)(((void *)nh) + NLMSG_ALIGN(nh->nlmsg_len));
+       rta->rta_type = type;
+       rta->rta_len = len;
+       memcpy(RTA_DATA(rta), data, alen);
+       nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + RTA_ALIGN(len);
+}
+
+// messages corresponding to different phases seq number
+static char *tun_nl_phase_msg[] = {
+       "initialized",
+       "getting tun interface index",
+       "setting tun interface parameters",
+       "setting tun IPv4 address",
+       "setting tun LL IPv6 address",
+       "setting tun global IPv6 address",
 };
 
 //
@@ -500,8 +677,7 @@ struct in6_ifreq {
 static void inittun(void)
 {
        struct ifreq ifr;
-       struct in6_ifreq ifr6;
-       struct sockaddr_in sin = {0};
+
        memset(&ifr, 0, sizeof(ifr));
        ifr.ifr_flags = IFF_TUN;
 
@@ -515,97 +691,192 @@ static void inittun(void)
                int flags = fcntl(tunfd, F_GETFL, 0);
                fcntl(tunfd, F_SETFL, flags | O_NONBLOCK);
        }
+
+   if (*config->tundevicename)
+               strncpy(ifr.ifr_name, config->tundevicename, IFNAMSIZ);
+
        if (ioctl(tunfd, TUNSETIFF, (void *) &ifr) < 0)
        {
                LOG(0, 0, 0, "Can't set tun interface: %s\n", strerror(errno));
                exit(1);
        }
-       assert(strlen(ifr.ifr_name) < sizeof(config->tundevice));
-       strncpy(config->tundevice, ifr.ifr_name, sizeof(config->tundevice) - 1);
-       ifrfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
-
-       sin.sin_family = AF_INET;
-       sin.sin_addr.s_addr = config->bind_address ? config->bind_address : 0x01010101; // 1.1.1.1
-       memcpy(&ifr.ifr_addr, &sin, sizeof(struct sockaddr));
+       assert(strlen(ifr.ifr_name) < sizeof(config->tundevicename) - 1);
+       strncpy(config->tundevicename, ifr.ifr_name, sizeof(config->tundevicename));
 
-       if (ioctl(ifrfd, SIOCSIFADDR, (void *) &ifr) < 0)
-       {
-               LOG(0, 0, 0, "Error setting tun address: %s\n", strerror(errno));
-               exit(1);
-       }
-       /* Bump up the qlen to deal with bursts from the network */
-       ifr.ifr_qlen = 1000;
-       if (ioctl(ifrfd, SIOCSIFTXQLEN, (void *) &ifr) < 0)
+       tunidx = if_nametoindex(config->tundevicename);
+       if (tunidx == 0)
        {
-               LOG(0, 0, 0, "Error setting tun queue length: %s\n", strerror(errno));
+               LOG(0, 0, 0, "Can't get tun interface index\n");
                exit(1);
        }
-       ifr.ifr_flags = IFF_UP;
-       if (ioctl(ifrfd, SIOCSIFFLAGS, (void *) &ifr) < 0)
-       {
-               LOG(0, 0, 0, "Error setting tun flags: %s\n", strerror(errno));
-               exit(1);
-       }
-       if (ioctl(ifrfd, SIOCGIFINDEX, (void *) &ifr) < 0)
+
        {
-               LOG(0, 0, 0, "Error getting tun ifindex: %s\n", strerror(errno));
-               exit(1);
-       }
-       tunidx = ifr.ifr_ifindex;
+               struct {
+                       // interface setting
+                       struct nlmsghdr nh;
+                       union {
+                               struct ifinfomsg ifinfo;
+                               struct ifaddrmsg ifaddr;
+                       } ifmsg;
+                       char rtdata[32]; // 32 should be enough
+               } req;
+               uint32_t txqlen, mtu;
+               in_addr_t ip;
+
+               memset(&req, 0, sizeof(req));
+
+               req.nh.nlmsg_type = RTM_NEWLINK;
+               req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_MULTI;
+               req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.ifmsg.ifinfo));
+
+               req.ifmsg.ifinfo.ifi_family = AF_UNSPEC;
+               req.ifmsg.ifinfo.ifi_index = tunidx;
+               req.ifmsg.ifinfo.ifi_flags |= IFF_UP; // set interface up
+               req.ifmsg.ifinfo.ifi_change = IFF_UP; // only change this flag
+
+               /* Bump up the qlen to deal with bursts from the network */
+               txqlen = 1000;
+               netlink_addattr(&req.nh, IFLA_TXQLEN, &txqlen, sizeof(txqlen));
+               /* set MTU to modem MRU */
+               mtu = MRU;
+               netlink_addattr(&req.nh, IFLA_MTU, &mtu, sizeof(mtu));
 
-       // Only setup IPv6 on the tun device if we have a configured prefix
-       if (config->ipv6_prefix.s6_addr[0]) {
-               ifr6fd = socket(PF_INET6, SOCK_DGRAM, 0);
+               if (netlink_send(&req.nh) < 0)
+                       goto senderror;
 
-               // Link local address is FE80::1
-               memset(&ifr6.ifr6_addr, 0, sizeof(ifr6.ifr6_addr));
-               ifr6.ifr6_addr.s6_addr[0] = 0xFE;
-               ifr6.ifr6_addr.s6_addr[1] = 0x80;
-               ifr6.ifr6_addr.s6_addr[15] = 1;
-               ifr6.ifr6_prefixlen = 64;
-               ifr6.ifr6_ifindex = ifr.ifr_ifindex;
-               if (ioctl(ifr6fd, SIOCSIFADDR, (void *) &ifr6) < 0)
+               memset(&req, 0, sizeof(req));
+
+               req.nh.nlmsg_type = RTM_NEWADDR;
+               req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE | NLM_F_MULTI;
+               req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.ifmsg.ifaddr));
+
+               req.ifmsg.ifaddr.ifa_family = AF_INET;
+               req.ifmsg.ifaddr.ifa_prefixlen = 32;
+               req.ifmsg.ifaddr.ifa_scope = RT_SCOPE_UNIVERSE;
+               req.ifmsg.ifaddr.ifa_index = tunidx;
+
+               if (config->nbmultiaddress > 1)
                {
-                       LOG(0, 0, 0, "Error setting tun IPv6 link local address:"
-                               " %s\n", strerror(errno));
+                       int i;
+                       for (i = 0; i < config->nbmultiaddress ; i++)
+                       {
+                               ip = config->iftun_n_address[i];
+                               netlink_addattr(&req.nh, IFA_LOCAL, &ip, sizeof(ip));
+                               if (netlink_send(&req.nh) < 0)
+                                       goto senderror;
+                       }
                }
-
-               // Global address is prefix::1
-               memset(&ifr6.ifr6_addr, 0, sizeof(ifr6.ifr6_addr));
-               ifr6.ifr6_addr = config->ipv6_prefix;
-               ifr6.ifr6_addr.s6_addr[15] = 1;
-               ifr6.ifr6_prefixlen = 64;
-               ifr6.ifr6_ifindex = ifr.ifr_ifindex;
-               if (ioctl(ifr6fd, SIOCSIFADDR, (void *) &ifr6) < 0)
+               else
                {
-                       LOG(0, 0, 0, "Error setting tun IPv6 global address: %s\n",
-                               strerror(errno));
+                       if (config->iftun_address)
+                               ip = config->iftun_address;
+                       else
+                               ip = 0x01010101; // 1.1.1.1
+                       netlink_addattr(&req.nh, IFA_LOCAL, &ip, sizeof(ip));
+
+                       if (netlink_send(&req.nh) < 0)
+                               goto senderror;
+               }
+
+
+
+               // Only setup IPv6 on the tun device if we have a configured prefix
+               if (config->ipv6_prefix.s6_addr[0]) {
+                       struct in6_addr ip6;
+
+                       memset(&req, 0, sizeof(req));
+
+                       req.nh.nlmsg_type = RTM_NEWADDR;
+                       req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE | NLM_F_MULTI;
+                       req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.ifmsg.ifaddr));
+
+                       req.ifmsg.ifaddr.ifa_family = AF_INET6;
+                       req.ifmsg.ifaddr.ifa_prefixlen = 64;
+                       req.ifmsg.ifaddr.ifa_scope = RT_SCOPE_LINK;
+                       req.ifmsg.ifaddr.ifa_index = tunidx;
+
+                       // Link local address is FE80::1
+                       memset(&ip6, 0, sizeof(ip6));
+                       ip6.s6_addr[0] = 0xFE;
+                       ip6.s6_addr[1] = 0x80;
+                       ip6.s6_addr[15] = 1;
+                       netlink_addattr(&req.nh, IFA_LOCAL, &ip6, sizeof(ip6));
+
+                       if (netlink_send(&req.nh) < 0)
+                               goto senderror;
+
+                       memset(&req, 0, sizeof(req));
+
+                       req.nh.nlmsg_type = RTM_NEWADDR;
+                       req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE | NLM_F_MULTI;
+                       req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.ifmsg.ifaddr));
+
+                       req.ifmsg.ifaddr.ifa_family = AF_INET6;
+                       req.ifmsg.ifaddr.ifa_prefixlen = 64;
+                       req.ifmsg.ifaddr.ifa_scope = RT_SCOPE_UNIVERSE;
+                       req.ifmsg.ifaddr.ifa_index = tunidx;
+
+                       // Global address is prefix::1
+                       ip6 = config->ipv6_prefix;
+                       ip6.s6_addr[15] = 1;
+                       netlink_addattr(&req.nh, IFA_LOCAL, &ip6, sizeof(ip6));
+
+                       if (netlink_send(&req.nh) < 0)
+                               goto senderror;
                }
+
+               memset(&req, 0, sizeof(req));
+
+               req.nh.nlmsg_type = NLMSG_DONE;
+               req.nh.nlmsg_len = NLMSG_LENGTH(0);
+
+               if (netlink_send(&req.nh) < 0)
+                       goto senderror;
+
+               // if we get an error for seqnum < min_initok_nlseqnum,
+               // we must exit as initialization went wrong
+               if (config->ipv6_prefix.s6_addr[0])
+                       min_initok_nlseqnum = 5 + 1; // idx + if + addr + 2*addr6
+               else
+                       min_initok_nlseqnum = 3 + 1; // idx + if + addr
        }
+
+       return;
+
+senderror:
+       LOG(0, 0, 0, "Error while setting up tun device: %s\n", strerror(errno));
+       exit(1);
 }
 
-// set up UDP ports
-static void initudp(void)
+// set up LAC UDP ports
+static void initlacudp(void)
 {
        int on = 1;
        struct sockaddr_in addr;
 
-       // Tunnel
+       // Tunnel to Remote LNS
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
-       addr.sin_port = htons(L2TPPORT);
-       addr.sin_addr.s_addr = config->bind_address;
-       udpfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-       setsockopt(udpfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+       addr.sin_port = htons(config->bind_portremotelns);
+       addr.sin_addr.s_addr = config->bind_address_remotelns;
+       udplacfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+       setsockopt(udplacfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
        {
-               int flags = fcntl(udpfd, F_GETFL, 0);
-               fcntl(udpfd, F_SETFL, flags | O_NONBLOCK);
+               int flags = fcntl(udplacfd, F_GETFL, 0);
+               fcntl(udplacfd, F_SETFL, flags | O_NONBLOCK);
        }
-       if (bind(udpfd, (void *) &addr, sizeof(addr)) < 0)
+       if (bind(udplacfd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
        {
-               LOG(0, 0, 0, "Error in UDP bind: %s\n", strerror(errno));
+               LOG(0, 0, 0, "Error in UDP REMOTE LNS bind: %s\n", strerror(errno));
                exit(1);
        }
+}
+
+// set up control ports
+static void initcontrol(void)
+{
+       int on = 1;
+       struct sockaddr_in addr;
 
        // Control
        memset(&addr, 0, sizeof(addr));
@@ -613,11 +884,19 @@ 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));
-       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);
        }
+}
+
+// set up Dynamic Authorization Extensions to RADIUS port
+static void initdae(void)
+{
+       int on = 1;
+       struct sockaddr_in addr;
 
        // Dynamic Authorization Extensions to RADIUS
        memset(&addr, 0, sizeof(addr));
@@ -625,14 +904,36 @@ 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));
-       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);
        }
+}
 
-       // Intercept
-       snoopfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+// set up UDP ports
+static void initudp(int * pudpfd, in_addr_t ip_bind)
+{
+       int on = 1;
+       struct sockaddr_in addr;
+
+       // Tunnel
+       memset(&addr, 0, sizeof(addr));
+       addr.sin_family = AF_INET;
+       addr.sin_port = htons(L2TPPORT);
+       addr.sin_addr.s_addr = ip_bind;
+       (*pudpfd) = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+       setsockopt((*pudpfd), SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+       {
+               int flags = fcntl((*pudpfd), F_GETFL, 0);
+               fcntl((*pudpfd), F_SETFL, flags | O_NONBLOCK);
+       }
+       if (bind((*pudpfd), (struct sockaddr *) &addr, sizeof(addr)) < 0)
+       {
+               LOG(0, 0, 0, "Error in UDP bind: %s\n", strerror(errno));
+               exit(1);
+       }
 }
 
 //
@@ -650,19 +951,19 @@ static void initudp(void)
 // 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 **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;
@@ -690,18 +991,18 @@ static int lookup_ipv6map(struct in6_addr 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)
-               return (sessionidt) s;
+               return s;
 
        return 0;
 }
 
 sessionidt sessionbyipv6(struct in6_addr ip)
 {
-       int s;
+       sessionidt s;
        CSTAT(sessionbyipv6);
 
        if (!memcmp(&config->ipv6_prefix, &ip, 8) ||
@@ -727,25 +1028,22 @@ sessionidt sessionbyipv6(struct in6_addr ip)
 //
 // (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;
-       uint8_t **d = (uint8_t **) ip_hash;
+       union iphash *h = ip_hash;
        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));
@@ -760,7 +1058,7 @@ static void uncache_ipmap(in_addr_t ip)
        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;
@@ -801,7 +1099,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)
 {
-       char **d = (char **) ip_hash, **e, **f, **g;
+       union iphash *d = ip_hash, *e, *f, *g;
        int i, j, k, l;
        int count = 0;
 
@@ -812,24 +1110,28 @@ int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 
        for (i = 0; i < 256; ++i)
        {
-               if (!d[i])
+               if (!d[i].idx)
                        continue;
-               e = (char **) d[i];
+
+               e = d[i].idx;
                for (j = 0; j < 256; ++j)
                {
-                       if (!e[j])
+                       if (!e[j].idx)
                                continue;
-                       f = (char **) e[j];
+
+                       f = e[j].idx;
                        for (k = 0; k < 256; ++k)
                        {
-                               if (!f[k])
+                               if (!f[k].idx)
                                        continue;
-                               g = (char **)f[k];
+
+                               g = f[k].idx;
                                for (l = 0; l < 256; ++l)
                                {
-                                       if (!g[l])
+                                       if (!g[l].sess)
                                                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;
                                }
                        }
@@ -919,18 +1221,20 @@ void tunnelsend(uint8_t * buf, uint16_t l, tunnelidt 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_backtrace(backtrace_count, 5)
+               return;
+       }
+
+       if (t == TUNNEL_ID_PPPOE)
+       {
+               pppoe_sess_send(buf, l, t);
                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_backtrace(backtrace_count, 5)
                STAT(tunnel_tx_errors);
                return;
        }
@@ -948,17 +1252,17 @@ void tunnelsend(uint8_t * buf, uint16_t l, tunnelidt t)
        {
                tunnel[t].last = time_now; // control message sent
                tunnel[t].retry = backoff(tunnel[t].try); // when to resend
-               if (tunnel[t].try > 1)
+               if (tunnel[t].try)
                {
                        STAT(tunnel_retries);
                        LOG(3, 0, t, "Control message resend try %d\n", tunnel[t].try);
                }
        }
 
-       if (sendto(udpfd, buf, l, 0, (void *) &addr, sizeof(addr)) < 0)
+       if (sendto(udpfd[tunnel[t].indexudp], buf, l, 0, (void *) &addr, sizeof(addr)) < 0)
        {
                LOG(0, ntohs((*(uint16_t *) (buf + 6))), t, "Error sending data out tunnel: %s (udpfd=%d, buf=%p, len=%d, dest=%s)\n",
-                               strerror(errno), udpfd, buf, l, inet_ntoa(addr.sin_addr));
+                               strerror(errno), udpfd[tunnel[t].indexudp], buf, l, inet_ntoa(addr.sin_addr));
                STAT(tunnel_tx_errors);
                return;
        }
@@ -977,9 +1281,133 @@ int tun_write(uint8_t * data, int size)
        return write(tunfd, data, size);
 }
 
+// adjust tcp mss to avoid fragmentation (called only for tcp packets with syn set)
+void adjust_tcp_mss(sessionidt s, tunnelidt t, uint8_t *buf, int len, uint8_t *tcp)
+{
+       int d = (tcp[12] >> 4) * 4;
+       uint8_t *mss = 0;
+       uint8_t *opts;
+       uint8_t *data;
+       uint16_t orig;
+       uint32_t sum;
+
+       if ((tcp[13] & 0x3f) & ~(TCP_FLAG_SYN|TCP_FLAG_ACK)) // only want SYN and SYN,ACK
+               return;
+
+       if (tcp + d > buf + len) // short?
+               return;
+
+       opts = tcp + 20;
+       data = tcp + d;
+
+       while (opts < data)
+       {
+               if (*opts == 2 && opts[1] == 4) // mss option (2), length 4
+               {
+                       mss = opts + 2;
+                       if (mss + 2 > data) return; // short?
+                       break;
+               }
+
+               if (*opts == 0) return; // end of options
+               if (*opts == 1 || !opts[1]) // no op (one byte), or no length (prevent loop)
+                       opts++;
+               else
+                       opts += opts[1]; // skip over option
+       }
+
+       if (!mss) return; // not found
+       orig = ntohs(*(uint16_t *) mss);
+
+       if (orig <= MSS) return; // mss OK
+
+       LOG(5, s, t, "TCP: %s:%u -> %s:%u SYN%s: adjusted mss from %u to %u\n",
+               fmtaddr(*(in_addr_t *) (buf + 12), 0), ntohs(*(uint16_t *) tcp),
+               fmtaddr(*(in_addr_t *) (buf + 16), 1), ntohs(*(uint16_t *) (tcp + 2)),
+               (tcp[13] & TCP_FLAG_ACK) ? ",ACK" : "", orig, MSS);
+
+       // set mss
+       *(int16_t *) mss = htons(MSS);
+
+       // adjust checksum (see rfc1141)
+       sum = orig + (~MSS & 0xffff);
+       sum += ntohs(*(uint16_t *) (tcp + 16));
+       sum = (sum & 0xffff) + (sum >> 16);
+       *(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;
+       }
+
+        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 %d 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 %d 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 if (proto == PPPIPCP)
+        {
+                session[s].last_packet = session[s].last_data = time_now;
+                processipcp(s, t, p, l);
+        }
+        else if (proto == PPPCCP)
+        {
+                session[s].last_packet = session[s].last_data = time_now;
+                processccp(s, t, p, l);
+        }
+        else
+        {
+                LOG(2, s, t, "MPPP: Unsupported MP protocol 0x%04X received\n",proto);
+        }
+}
+
+static void update_session_out_stat(sessionidt s, sessiont *sp, int len)
+{
+       increment_counter(&sp->cout, &sp->cout_wrap, len); // byte count
+       sp->cout_delta += len;
+       sp->pout++;
+       sp->last_data = time_now;
+
+       sess_local[s].cout += len;      // To send to master..
+       sess_local[s].pout++;
+}
+
 // process outgoing (to tunnel) IP
 //
-static void processipout(uint8_t *buf, int len)
+// (i.e. this routine writes to data[-8]).
+void processipout(uint8_t *buf, int len)
 {
        sessionidt s;
        sessiont *sp;
@@ -989,7 +1417,7 @@ static void processipout(uint8_t *buf, int len)
        uint8_t *data = buf;    // Keep a copy of the originals.
        int size = len;
 
-       uint8_t b[MAXETHER + 20];
+       uint8_t fragbuf[MAXETHER + 20];
 
        CSTAT(processipout);
 
@@ -1038,7 +1466,14 @@ static void processipout(uint8_t *buf, int len)
                }
                return;
        }
+
        t = session[s].tunnel;
+       if (len > session[s].mru || (session[s].mrru && len > session[s].mrru))
+       {
+               LOG(3, s, t, "Packet size more than session MRU\n");
+               return;
+       }
+
        sp = &session[s];
 
        // DoS prevention: enforce a maximum number of packets per 0.1s for a session
@@ -1084,6 +1519,14 @@ static void processipout(uint8_t *buf, int len)
        if (session[s].filter_out && !ip_filter(buf, len, session[s].filter_out - 1))
                return;
 
+       // adjust MSS on SYN and SYN,ACK packets with options
+       if ((ntohs(*(uint16_t *) (buf + 6)) & 0x1fff) == 0 && buf[9] == IPPROTO_TCP) // first tcp fragment
+       {
+               int ihl = (buf[0] & 0xf) * 4; // length of IP header
+               if (len >= ihl + 20 && (buf[ihl + 13] & TCP_FLAG_SYN) && ((buf[ihl + 12] >> 4) > 5))
+                       adjust_tcp_mss(s, t, buf, len, buf + ihl);
+       }
+
        if (sp->tbf_out)
        {
                // Are we throttling this session?
@@ -1093,33 +1536,135 @@ static void processipout(uint8_t *buf, int len)
                        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;
        }
 
-       LOG(5, s, t, "Ethernet -> Tunnel (%d bytes)\n", len);
+       if(session[s].bundle != 0 && bundle[session[s].bundle].num_of_links > 1)
+       {
 
-       // Add on L2TP header
+               if (!config->cluster_iam_master)
+               {
+                       // The MPPP packets must be managed by the Master.
+                       master_forward_mppp_packet(s, data, size);
+                       return;
+               }
+
+               // Add on L2TP header
+               sessionidt members[MAXBUNDLESES];
+               bundleidt bid = session[s].bundle;
+               bundlet *b = &bundle[bid];
+               uint32_t num_of_links, nb_opened;
+               int i;
+
+               num_of_links = b->num_of_links;
+               nb_opened = 0;
+               for (i = 0;i < num_of_links;i++)
+               {
+                       s = b->members[i];
+                       if (session[s].ppp.lcp == Opened)
+                       {
+                               members[nb_opened] = s;
+                               nb_opened++;
+                       }
+               }
+
+               if (nb_opened < 1)
+               {
+                       LOG(3, s, t, "MPPP: PROCESSIPOUT ERROR, no session opened in bundle:%d\n", bid);
+                       return;
+               }
+
+               num_of_links = nb_opened;
+               b->current_ses = (b->current_ses + 1) % num_of_links;
+               s = members[b->current_ses];
+               t = session[s].tunnel;
+               sp = &session[s];
+               LOG(4, s, t, "MPPP: (1)Session number becomes: %d\n", s);
+
+               if (num_of_links > 1)
+               {
+                       if(len > MINFRAGLEN)
+                       {
+                               //for rotate traffic among the member links
+                               uint32_t divisor = num_of_links;
+                               if (divisor > 2)
+                                       divisor = divisor/2 + (divisor & 1);
+
+                               // Partition the packet to "num_of_links" fragments
+                               uint32_t fraglen = len / divisor;
+                               uint32_t last_fraglen = fraglen + len % divisor;
+                               uint32_t remain = len;
+
+                               // send the first packet
+                               uint8_t *p = makeppp(fragbuf, sizeof(fragbuf), buf, fraglen, s, t, PPPIP, 0, bid, MP_BEGIN);
+                               if (!p) return;
+                               tunnelsend(fragbuf, fraglen + (p-fragbuf), t); // send it...
+
+                               // statistics
+                               update_session_out_stat(s, sp, fraglen);
+
+                               remain -= fraglen;
+                               while (remain > last_fraglen)
+                               {
+                                       b->current_ses = (b->current_ses + 1) % num_of_links;
+                                       s = members[b->current_ses];
+                                       t = session[s].tunnel;
+                                       sp = &session[s];
+                                       LOG(4, s, t, "MPPP: (2)Session number becomes: %d\n", s);
+                                       p = makeppp(fragbuf, sizeof(fragbuf), buf+(len - remain), fraglen, s, t, PPPIP, 0, bid, 0);
+                                       if (!p) return;
+                                       tunnelsend(fragbuf, fraglen + (p-fragbuf), t); // send it...
+                                       update_session_out_stat(s, sp, fraglen);
+                                       remain -= fraglen;
+                               }
+                               // send the last fragment
+                               b->current_ses = (b->current_ses + 1) % num_of_links;
+                               s = members[b->current_ses];
+                               t = session[s].tunnel;
+                               sp = &session[s];
+                               LOG(4, s, t, "MPPP: (2)Session number becomes: %d\n", s);
+                               p = makeppp(fragbuf, sizeof(fragbuf), buf+(len - remain), remain, s, t, PPPIP, 0, bid, MP_END);
+                               if (!p) return;
+                               tunnelsend(fragbuf, remain + (p-fragbuf), t); // send it...
+                               update_session_out_stat(s, sp, remain);
+                               if (remain != last_fraglen)
+                                       LOG(3, s, t, "PROCESSIPOUT ERROR REMAIN != LAST_FRAGLEN, %d != %d\n", remain, last_fraglen);
+                       }
+                       else
+                       {
+                               // Send it as one frame
+                               uint8_t *p = makeppp(fragbuf, sizeof(fragbuf), buf, len, s, t, PPPIP, 0, bid, MP_BOTH_BITS);
+                               if (!p) return;
+                               tunnelsend(fragbuf, len + (p-fragbuf), t); // send it...
+                               LOG(4, s, t, "MPPP: packet sent as one frame\n");
+                               update_session_out_stat(s, sp, len);
+                       }
+               }
+               else
+               {
+                       // Send it as one frame (NO MPPP Frame)
+                       uint8_t *p = opt_makeppp(buf, len, s, t, PPPIP, 0, 0, 0);
+                       tunnelsend(p, len + (buf-p), t); // send it...
+                       update_session_out_stat(s, sp, len);
+               }
+       }
+       else
        {
-               uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP);
-               if (!p) return;
-               tunnelsend(b, len + (p-b), t); // send it...
+               uint8_t *p = opt_makeppp(buf, len, s, t, PPPIP, 0, 0, 0);
+               tunnelsend(p, len + (buf-p), t); // send it...
+               update_session_out_stat(s, sp, len);
        }
 
        // Snooping this session, send it to intercept box
        if (sp->snoop_ip && sp->snoop_port)
                snoop_send_packet(buf, len, sp->snoop_ip, sp->snoop_port);
 
-       increment_counter(&sp->cout, &sp->cout_wrap, len); // byte count
-       sp->cout_delta += len;
-       sp->pout++;
        udp_tx += len;
-
-       sess_local[s].cout += len;      // To send to master..
-       sess_local[s].pout++;
 }
 
 // process outgoing (to tunnel) IPv6
@@ -1190,8 +1735,18 @@ static void processipv6out(uint8_t * buf, int len)
                }
                return;
        }
+       if (session[s].bundle && bundle[session[s].bundle].num_of_links > 1)
+       {
+               bundleidt bid = session[s].bundle;
+               bundlet *b = &bundle[bid];
+
+               b->current_ses = (b->current_ses + 1) % b->num_of_links;
+               s = b->members[b->current_ses];
+               LOG(3, s, session[s].tunnel, "MPPP: Session number becomes: %u\n", s);
+       }
        t = session[s].tunnel;
        sp = &session[s];
+       sp->last_data = time_now;
 
        // FIXME: add DoS prevention/filters?
 
@@ -1215,7 +1770,7 @@ static void processipv6out(uint8_t * buf, int len)
 
        // Add on L2TP header
        {
-               uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, 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...
        }
@@ -1241,7 +1796,6 @@ static void send_ipout(sessionidt s, uint8_t *buf, int len)
 {
        sessiont *sp;
        tunnelidt t;
-       in_addr_t ip;
 
        uint8_t b[MAXETHER + 20];
 
@@ -1255,8 +1809,6 @@ static void send_ipout(sessionidt s, uint8_t *buf, int len)
        buf += 4;
        len -= 4;
 
-       ip = *(in_addr_t *)(buf + 16);
-
        if (!session[s].ip)
                return;
 
@@ -1267,7 +1819,7 @@ static void send_ipout(sessionidt s, uint8_t *buf, int len)
 
        // Add on L2TP header
        {
-               uint8_t *p = makeppp(b, sizeof(b),  buf, len, t, s, 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...
        }
@@ -1342,7 +1894,8 @@ static controlt *controlnew(uint16_t mtype)
        }
        assert(c);
        c->next = 0;
-       *(uint16_t *) (c->buf + 0) = htons(0xC802); // flags/ver
+       c->buf[0] = 0xC8; // flags
+       c->buf[1] = 0x02; // ver
        c->length = 12;
        control16(c, 0, mtype, 1);
        return c;
@@ -1352,21 +1905,21 @@ static controlt *controlnew(uint16_t mtype)
 // (ZLB send).
 static void controlnull(tunnelidt t)
 {
-       uint8_t buf[12];
+       uint16_t buf[6];
        if (tunnel[t].controlc) // Messages queued; They will carry the ack.
                return;
 
-       *(uint16_t *) (buf + 0) = htons(0xC802); // flags/ver
-       *(uint16_t *) (buf + 2) = htons(12); // length
-       *(uint16_t *) (buf + 4) = htons(tunnel[t].far); // tunnel
-       *(uint16_t *) (buf + 6) = htons(0); // session
-       *(uint16_t *) (buf + 8) = htons(tunnel[t].ns); // sequence
-       *(uint16_t *) (buf + 10) = htons(tunnel[t].nr); // sequence
-       tunnelsend(buf, 12, t);
+       buf[0] = htons(0xC802); // flags/ver
+       buf[1] = htons(12); // length
+       buf[2] = htons(tunnel[t].far); // tunnel
+       buf[3] = htons(0); // session
+       buf[4] = htons(tunnel[t].ns); // sequence
+       buf[5] = htons(tunnel[t].nr); // sequence
+       tunnelsend((uint8_t *)buf, 12, t);
 }
 
 // add a control message to a tunnel, and send if within window
-static void controladd(controlt * c, tunnelidt t, sessionidt far)
+static void controladd(controlt *c, sessionidt far, tunnelidt t)
 {
        *(uint16_t *) (c->buf + 2) = htons(c->length); // length
        *(uint16_t *) (c->buf + 4) = htons(tunnel[t].far); // tunnel
@@ -1476,10 +2029,12 @@ void filter_session(sessionidt s, int filter_in, int filter_out)
 }
 
 // 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;
-
+       bundleidt b = session[s].bundle;
+       //delete routes only for last session in bundle (in case of MPPP)
+       int del_routes = !b || (bundle[b].num_of_links == 1);
 
        CSTAT(sessionshutdown);
 
@@ -1492,7 +2047,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] };
-               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);
        }
 
@@ -1504,7 +2059,11 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
                {
                        // stop, if not already trying
                        if (radius[r].state != RADIUSSTOP)
+                       {
+                               radius[r].term_cause = term_cause;
+                               radius[r].term_msg = reason;
                                radiussend(r, RADIUSSTOP);
+                       }
                }
                else
                        LOG(1, s, session[s].tunnel, "No free RADIUS sessions for Stop message\n");
@@ -1514,56 +2073,126 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
                        memcpy(&shut_acct[shut_acct_n++], &session[s], sizeof(session[s]));
        }
 
+       if (!session[s].die)
+               session[s].die = TIME + 150; // Clean up in 15 seconds
+
        if (session[s].ip)
        {                          // IP allocated, clear and unroute
                int r;
                int routed = 0;
                for (r = 0; r < MAXROUTE && session[s].route[r].ip; r++)
                {
-                       if ((session[s].ip & session[s].route[r].mask) ==
-                           (session[s].route[r].ip & session[s].route[r].mask))
+                       if ((session[s].ip >> (32-session[s].route[r].prefixlen)) ==
+                           (session[s].route[r].ip >> (32-session[s].route[r].prefixlen)))
                                routed++;
 
-                       routeset(s, session[s].route[r].ip, session[s].route[r].mask, 0, 0);
+                       if (del_routes) routeset(s, session[s].route[r].ip, session[s].route[r].prefixlen, 0, 0);
                        session[s].route[r].ip = 0;
                }
 
                if (session[s].ip_pool_index == -1) // static ip
                {
-                       if (!routed) routeset(s, session[s].ip, 0, 0, 0);
+                       if (!routed && del_routes) routeset(s, session[s].ip, 0, 0, 0);
                        session[s].ip = 0;
                }
                else
                        free_ip_address(s);
 
                // unroute IPv6, if setup
-               if (session[s].ppp.ipv6cp == Opened && session[s].ipv6prefixlen)
+               if (session[s].ppp.ipv6cp == Opened && session[s].ipv6prefixlen && del_routes)
                        route6set(s, session[s].ipv6route, session[s].ipv6prefixlen, 0);
+               
+               if (b)
+               {
+                       // This session was part of a bundle
+                       bundle[b].num_of_links--;
+                       LOG(3, s, session[s].tunnel, "MPPP: Dropping member link: %d from bundle %d\n",s,b);
+                       if(bundle[b].num_of_links == 0)
+                       {
+                               bundleclear(b);
+                               LOG(3, s, session[s].tunnel, "MPPP: Kill bundle: %d (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, session[s].tunnel, "MPPP: Adjusted member links array\n");
+
+                                       // If the killed session is the first of the bundle,
+                                       // the new first session must be stored in the cache_ipmap
+                                       // else the function sessionbyip return 0 and the sending not work any more (processipout).
+                                       if (mem_num == 0)
+                                       {
+                                               sessionidt new_s = bundle[b].members[0];
+
+                                               routed = 0;
+                                               // Add the route for this session.
+                                               for (r = 0; r < MAXROUTE && session[new_s].route[r].ip; r++)
+                                               {
+                                                       int i, prefixlen;
+                                                       in_addr_t ip;
+
+                                                       prefixlen = session[new_s].route[r].prefixlen;
+                                                       ip = session[new_s].route[r].ip;
+
+                                                       if (!prefixlen) prefixlen = 32;
+                                                       ip &= 0xffffffff << (32 - prefixlen);   // Force the ip to be the first one in the route.
+
+                                                       for (i = ip; i < ip+(1<<(32-prefixlen)) ; ++i)
+                                                               cache_ipmap(i, new_s);
+                                               }
+                                               cache_ipmap(session[new_s].ip, new_s);
+
+                                               // IPV6 route
+                                               if (session[new_s].ipv6prefixlen)
+                                                       cache_ipv6map(session[new_s].ipv6route, session[new_s].ipv6prefixlen, new_s);
+                                       }
+                               }
+                       }
+
+                       cluster_send_bundle(b);
+        }
        }
 
        if (session[s].throttle_in || session[s].throttle_out) // Unthrottle if throttled.
                throttle_session(s, 0, 0);
 
-       if (result)
-       {                            // Send CDN
-               controlt *c = controlnew(14); // sending CDN
-               if (error)
+       if (cdn_result)
+       {
+               if (session[s].tunnel == TUNNEL_ID_PPPOE)
                {
-                       uint8_t buf[4];
-                       *(uint16_t *) buf     = htons(result);
-                       *(uint16_t *) (buf+2) = htons(error);
-                       controlb(c, 1, buf, 4, 1);
+                       pppoe_shutdown_session(s);
                }
                else
-                       control16(c, 1, result, 1);
+               {
+                       // Send CDN
+                       controlt *c = controlnew(14); // sending CDN
+                       if (cdn_error)
+                       {
+                               uint16_t buf[2];
+                               buf[0] = htons(cdn_result);
+                               buf[1] = htons(cdn_error);
+                               controlb(c, 1, (uint8_t *)buf, 4, 1);
+                       }
+                       else
+                               control16(c, 1, cdn_result, 1);
 
-               control16(c, 14, s, 1);   // assigned session (our end)
-               controladd(c, session[s].tunnel, session[s].far); // send the message
+                       control16(c, 14, s, 1);   // assigned session (our end)
+                       controladd(c, session[s].far, session[s].tunnel); // send the message
+               }
        }
 
-       if (!session[s].die)
-               session[s].die = TIME + 150; // Clean up in 15 seconds
-
        // update filter refcounts
        if (session[s].filter_in) ip_filters[session[s].filter_in - 1].used--;
        if (session[s].filter_out) ip_filters[session[s].filter_out - 1].used--;
@@ -1578,12 +2207,13 @@ void sessionshutdown(sessionidt s, char *reason, int result, int error)
        cluster_send_session(s);
 }
 
-void sendipcp(tunnelidt t, sessionidt s)
+void sendipcp(sessionidt s, tunnelidt t)
 {
-       uint8_t buf[MAXCONTROL];
+       uint8_t buf[MAXETHER];
        uint8_t *q;
 
        CSTAT(sendipcp);
+       LOG(3, s, t, "IPCP: send ConfigReq\n");
 
        if (!session[s].unique_id)
        {
@@ -1591,7 +2221,7 @@ void sendipcp(tunnelidt t, sessionidt s)
                session[s].unique_id = last_id;
        }
 
-       q = makeppp(buf,sizeof(buf), 0, 0, t, s, PPPIPCP);
+       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPCP, 0, 0, 0);
        if (!q) return;
 
        *q = ConfigReq;
@@ -1600,20 +2230,22 @@ void sendipcp(tunnelidt t, sessionidt s)
        q[4] = 3;                               // ip address option
        q[5] = 6;                               // option length
        *(in_addr_t *) (q + 6) = config->peer_address ? config->peer_address :
-                                config->bind_address ? config->bind_address :
+                                config->iftun_n_address[tunnel[t].indexudp] ? config->iftun_n_address[tunnel[t].indexudp] :
                                 my_address; // send my IP
 
        tunnelsend(buf, 10 + (q - buf), t); // send it
+       restart_timer(s, ipcp);
 }
 
-void sendipv6cp(tunnelidt t, sessionidt s)
+void sendipv6cp(sessionidt s, tunnelidt t)
 {
-       uint8_t buf[MAXCONTROL];
+       uint8_t buf[MAXETHER];
        uint8_t *q;
 
        CSTAT(sendipv6cp);
+       LOG(3, s, t, "IPV6CP: send ConfigReq\n");
 
-       q = makeppp(buf,sizeof(buf), 0, 0, t, s, PPPIPV6CP);
+       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPIPV6CP, 0, 0, 0);
        if (!q) return;
 
        *q = ConfigReq;
@@ -1628,6 +2260,7 @@ void sendipv6cp(tunnelidt t, sessionidt s)
        q[13] = 1;
 
        tunnelsend(buf, 14 + (q - buf), t);     // send it
+       restart_timer(s, ipv6cp);
 }
 
 static void sessionclear(sessionidt s)
@@ -1644,7 +2277,6 @@ static void sessionclear(sessionidt s)
 // kill a session now
 void sessionkill(sessionidt s, char *reason)
 {
-
        CSTAT(sessionkill);
 
        if (!session[s].opened) // not alive
@@ -1652,15 +2284,26 @@ void sessionkill(sessionidt s, char *reason)
 
        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;
-       sessionshutdown(s, reason, 3, 0);  // close radius/routes, etc.
+       if (!session[s].die)
+               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 (session[s].forwardtosession)
+       {
+               sessionidt sess = session[s].forwardtosession;
+               if (session[sess].forwardtosession == s)
+               {
+                       // Shutdown the linked session also.
+                       sessionshutdown(sess, reason, CDN_ADMIN_DISC, TERM_ADMIN_RESET);
+               }
+       }
+
        LOG(2, s, session[s].tunnel, "Kill session %d (%s): %s\n", s, session[s].user, reason);
        sessionclear(s);
        cluster_send_session(s);
@@ -1673,6 +2316,13 @@ static void tunnelclear(tunnelidt t)
        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)
 {
@@ -1699,7 +2349,7 @@ static void tunnelkill(tunnelidt t, char *reason)
 
        // 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);
 }
@@ -1717,12 +2367,12 @@ static void tunnelshutdown(tunnelidt t, char *reason, int result, int error, cha
                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)
-                       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
@@ -1733,32 +2383,32 @@ static void tunnelshutdown(tunnelidt t, char *reason, int result, int error, cha
                controlt *c = controlnew(4);    // sending StopCCN
                if (error)
                {
-                       uint8_t buf[64];
+                       uint16_t buf[32];
                        int l = 4;
-                       *(uint16_t *) buf     = htons(result);
-                       *(uint16_t *) (buf+2) = htons(error);
+                       buf[0] = htons(result);
+                       buf[1] = htons(error);
                        if (msg)
                        {
                                int m = strlen(msg);
                                if (m + 4 > sizeof(buf))
                                    m = sizeof(buf) - 4;
 
-                               memcpy(buf+4, msg, m);
+                               memcpy(buf+2, msg, m);
                                l += m;
                        }
 
-                       controlb(c, 1, buf, l, 1);
+                       controlb(c, 1, (uint8_t *)buf, l, 1);
                }
                else
                        control16(c, 1, result, 1);
 
                control16(c, 9, t, 1);          // assigned tunnel (our end)
-               controladd(c, t, 0);            // send the message
+               controladd(c, 0, t);            // send the message
        }
 }
 
 // read and process packet on tunnel (UDP)
-void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
+void processudp(uint8_t *buf, int len, struct sockaddr_in *addr, uint16_t indexudpfd)
 {
        uint8_t *chapresponse = NULL;
        uint16_t l = len, t = 0, s = 0, ns = 0, nr = 0;
@@ -1780,7 +2430,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
        }
        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;
        }
@@ -1805,6 +2455,12 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                STAT(tunnel_rx_errors);
                return;
        }
+       if (t == TUNNEL_ID_PPPOE)
+       {
+               LOG(1, s, t, "Received UDP packet with tunnel ID reserved for pppoe\n");
+               STAT(tunnel_rx_errors);
+               return;
+       }
        if (*buf & 0x08)
        {                          // ns/nr
                ns = ntohs(*(uint16_t *) p);
@@ -1824,12 +2480,16 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                return;
        }
        l -= (p - buf);
+
+       // used to time out old tunnels
+       if (t && tunnel[t].state == TUNNELOPEN)
+               tunnel[t].lastrec = time_now;
+
        if (*buf & 0x80)
        {                          // control
                uint16_t message = 0xFFFF;      // message type
                uint8_t fatal = 0;
                uint8_t mandatory = 0;
-               uint8_t authtype = 0;           // proxy auth type
                uint16_t asession = 0;          // assigned session
                uint32_t amagic = 0;            // magic number
                uint8_t aflags = 0;             // flags from last LCF
@@ -1839,7 +2499,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
 
                if (!config->cluster_iam_master)
                {
-                       master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
+                       master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
                        return;
                }
 
@@ -1873,7 +2533,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
@@ -1889,8 +2549,9 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        tunnel[t].ip = ntohl(*(in_addr_t *) & addr->sin_addr);
                        tunnel[t].port = ntohs(addr->sin_port);
                        tunnel[t].window = 4; // default window
+                       tunnel[t].indexudp = indexudpfd;
                        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);
                }
 
@@ -1904,7 +2565,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                {
                        // 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?
@@ -1912,9 +2573,6 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        return;
                }
 
-               // This is used to time out old tunnels
-               tunnel[t].lastrec = time_now;
-
                // check sequence of this message
                {
                        int skip = tunnel[t].window; // track how many in-window packets are still in queue
@@ -1960,6 +2618,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                        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
                        {
@@ -1967,6 +2632,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                uint8_t *b = p;
                                uint8_t flags = *p;
                                uint16_t mtype;
+
                                if (n > l)
                                {
                                        LOG(1, s, t, "Invalid length in AVP\n");
@@ -1987,7 +2653,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                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
@@ -2004,7 +2670,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        uint16_t orig_len;
 
                                        // handle hidden AVPs
-                                       if (!*config->l2tpsecret)
+                                       if (!*config->l2tp_secret)
                                        {
                                                LOG(1, s, t, "Hidden AVP requested, but no L2TP secret.\n");
                                                fatal = flags;
@@ -2052,7 +2718,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        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)
@@ -2060,37 +2726,53 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                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", message, l2tp_code(message));
                                        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);
+                                                       cause = TERM_LOST_SERVICE;
                                                }
                                                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));
-                                                       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 (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));
-                                               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);
@@ -2103,17 +2785,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        }
                                        break;
                                case 3:     // framing capabilities
-//                                     LOG(4, s, t, "Framing capabilities\n");
                                        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
-//                                     LOG(4, s, t, "Tie breaker\n");
                                        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));
@@ -2128,13 +2806,13 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        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
-                                       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
                                        {
@@ -2143,23 +2821,30 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                        }
                                        break;
                                case 13:    // Response
+                                       if (tunnel[t].isremotelns)
+                                       {
+                                               chapresponse = calloc(17, 1);
+                                               memcpy(chapresponse, b, (n < 17) ? n : 16);
+                                               LOG(3, s, t, "received challenge response from REMOTE LNS\n");
+                                       }
+                                       else
                                        // Why did they send a response? We never challenge.
                                        LOG(2, s, t, "   received unexpected challenge response\n");
                                        break;
 
                                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
-                                       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
-                                       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
-                                       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
@@ -2213,12 +2898,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                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));
-                                               if (atype == 2)
-                                                       authtype = AUTHCHAP;
-                                               else if (atype == 3)
-                                                       authtype = AUTHPAP;
-
+                                               LOG(4, s, t, "   Proxy Auth Type %u (%s)\n", atype, ppp_auth_type(atype));
                                                break;
                                        }
                                case 30:    // Proxy Authentication Name
@@ -2233,16 +2913,12 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                case 31:    // Proxy Authentication Challenge
                                        {
                                                LOG(4, s, t, "   Proxy Auth Challenge\n");
-                                               if (sess_local[s].radius)
-                                                       memcpy(radius[sess_local[s].radius].auth, b, 16);
                                                break;
                                        }
                                case 32:    // Proxy Authentication ID
                                        {
                                                uint16_t authid = ntohs(*(uint16_t *)(b));
-                                               LOG(4, s, t, "   Proxy Auth ID (%d)\n", authid);
-                                               if (sess_local[s].radius)
-                                                       radius[sess_local[s].radius].id = authid;
+                                               LOG(4, s, t, "   Proxy Auth ID (%u)\n", authid);
                                                break;
                                        }
                                case 33:    // Proxy Authentication Response
@@ -2255,14 +2931,10 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                                {
                                                        if (*p == 5 && p[1] == 6) // Magic-Number
                                                                amagic = ntohl(*(uint32_t *) (p + 2));
-                                                       else if (*p == 3 && p[1] == 4 && *(uint16_t *) (p + 2) == htons(PPPPAP)) // Authentication-Protocol (PAP)
-                                                               authtype = AUTHPAP;
-                                                       else if (*p == 3 && p[1] == 5 && *(uint16_t *) (p + 2) == htons(PPPCHAP) && p[4] == 5) // Authentication-Protocol (CHAP)
-                                                               authtype = AUTHCHAP;
                                                        else if (*p == 7) // Protocol-Field-Compression
-                                                               aflags |= SESSIONPFC;
+                                                               aflags |= SESSION_PFC;
                                                        else if (*p == 8) // Address-and-Control-Field-Compression
-                                                               aflags |= SESSIONACFC;
+                                                               aflags |= SESSION_ACFC;
                                                        p += p[1];
                                                }
                                        }
@@ -2281,10 +2953,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;
+                               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";
-                                               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
@@ -2301,49 +3053,92 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                {
                                case 1:       // SCCRQ - Start Control Connection Request
                                        tunnel[t].state = TUNNELOPENING;
+                                       LOG(3, s, t, "Received SCCRQ\n");
                                        if (main_quit != QUIT_SHUTDOWN)
                                        {
+                                               LOG(3, s, t, "sending SCCRP\n");
                                                controlt *c = controlnew(2); // sending SCCRP
                                                control16(c, 2, version, 1); // protocol version
                                                control32(c, 3, 3, 1); // framing
-                                               controls(c, 7, tunnel[t].hostname, 1); // host name (TBA)
+                                               controls(c, 7, hostname, 1); // host name
                                                if (chapresponse) controlb(c, 13, chapresponse, 16, 1); // Challenge response
                                                control16(c, 9, t, 1); // assigned tunnel
-                                               controladd(c, t, 0); // send the resply
+                                               controladd(c, 0, t); // send the resply
+                                       }
+                                       else
+                                       {
+                                               tunnelshutdown(t, "Shutting down", 6, 0, 0);
+                                       }
+                                       break;
+                               case 2:       // SCCRP
+                                       tunnel[t].state = TUNNELOPEN;
+                                       tunnel[t].lastrec = time_now;
+                                       LOG(3, s, t, "Received SCCRP\n");
+                                       if (main_quit != QUIT_SHUTDOWN)
+                                       {
+                                               if (tunnel[t].isremotelns && chapresponse)
+                                               {
+                                                       hasht hash;
+
+                                                       lac_calc_rlns_auth(t, 2, hash); // id = 2 (SCCRP)
+                                                       // check authenticator
+                                                       if (memcmp(hash, chapresponse, 16) == 0)
+                                                       {
+                                                               LOG(3, s, t, "sending SCCCN to REMOTE LNS\n");
+                                                               controlt *c = controlnew(3); // sending SCCCN
+                                                               controls(c, 7, hostname, 1); // host name
+                                                               controls(c, 8, Vendor_name, 1); // Vendor name
+                                                               control16(c, 2, version, 1); // protocol version
+                                                               control32(c, 3, 3, 1); // framing Capabilities
+                                                               control16(c, 9, t, 1); // assigned tunnel
+                                                               controladd(c, 0, t); // send
+                                                       }
+                                                       else
+                                                       {
+                                                               tunnelshutdown(t, "Bad chap response from REMOTE LNS", 4, 0, 0);
+                                                       }
+                                               }
                                        }
                                        else
                                        {
                                                tunnelshutdown(t, "Shutting down", 6, 0, 0);
                                        }
                                        break;
-                               case 2:       // SCCRP
-                                       tunnel[t].state = TUNNELOPEN;
-                                       break;
                                case 3:       // SCCN
+                                       LOG(3, s, t, "Received SCCN\n");
                                        tunnel[t].state = TUNNELOPEN;
+                                       tunnel[t].lastrec = time_now;
                                        controlnull(t); // ack
                                        break;
                                case 4:       // StopCCN
+                                       LOG(3, s, t, "Received StopCCN\n");
                                        controlnull(t); // ack
                                        tunnelshutdown(t, "Stopped", 0, 0, 0); // Shut down cleanly
                                        break;
                                case 6:       // HELLO
+                                       LOG(3, s, t, "Received HELLO\n");
                                        controlnull(t); // simply ACK
                                        break;
                                case 7:       // OCRQ
                                        // TBA
+                                       LOG(3, s, t, "Received OCRQ\n");
                                        break;
                                case 8:       // OCRO
                                        // TBA
+                                       LOG(3, s, t, "Received OCRO\n");
                                        break;
                                case 9:       // OCCN
                                        // TBA
+                                       LOG(3, s, t, "Received OCCN\n");
                                        break;
                                case 10:      // ICRQ
+                                       LOG(3, s, t, "Received ICRQ\n");
                                        if (sessionfree && main_quit != QUIT_SHUTDOWN)
                                        {
                                                controlt *c = controlnew(11); // ICRP
 
+                                               LOG(3, s, t, "Sending ICRP\n");
+
                                                s = sessionfree;
                                                sessionfree = session[s].next;
                                                memset(&session[s], 0, sizeof(session[s]));
@@ -2354,10 +3149,10 @@ 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].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, t, asession); // send the reply
+                                               controladd(c, asession, t); // send the reply
 
                                                strncpy(session[s].called, called, sizeof(session[s].called) - 1);
                                                strncpy(session[s].calling, calling, sizeof(session[s].calling) - 1);
@@ -2371,6 +3166,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
 
                                        {
                                                controlt *c = controlnew(14); // CDN
+                                               LOG(3, s, t, "Sending CDN\n");
                                                if (!sessionfree)
                                                {
                                                        STAT(session_overflow);
@@ -2380,35 +3176,50 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                                                else
                                                        control16(c, 1, 2, 7); // shutting down, try another
 
-                                               controladd(c, t, asession); // send the message
+                                               controladd(c, asession, t); // send the message
                                        }
                                        return;
                                case 11:      // ICRP
-                                       // TBA
+                               LOG(3, s, t, "Received ICRP\n");
+                               if (session[s].forwardtosession)
+                               {
+                                       controlt *c = controlnew(12); // ICCN
+
+                                       session[s].opened = time_now;
+                                       session[s].tunnel = t;
+                                       session[s].far = asession;
+                                       session[s].last_packet = session[s].last_data = time_now;
+
+                                       control32(c, 19, 1, 1); // Framing Type
+                                       control32(c, 24, 10000000, 1); // Tx Connect Speed
+                                       controladd(c, asession, t); // send the message
+                                       LOG(3, s, t, "Sending ICCN\n");
+                               }
                                        break;
                                case 12:      // ICCN
+                                       LOG(3, s, t, "Received ICCN\n");
                                        if (amagic == 0) amagic = time_now;
                                        session[s].magic = amagic; // set magic number
-                                       session[s].l2tp_flags = aflags; // set flags received
-                                       LOG(3, s, t, "Magic %X Flags %X\n", amagic, aflags);
+                                       session[s].flags = aflags; // set flags received
+                                       session[s].mru = PPPoE_MRU; // default
                                        controlnull(t); // ack
 
-                                       // proxy authentication type is not supported
-                                       if (!(config->radius_authtypes & authtype))
-                                               authtype = config->radius_authprefer;
-
                                        // start LCP
-                                       sendlcp(t, s, authtype);
-                                       sess_local[s].lcp.restart = time_now + config->ppp_restart_time;
-                                       sess_local[s].lcp.conf_sent = 1;
-                                       sess_local[s].lcp.nak_sent = 0;
-                                       sess_local[s].lcp_authtype = authtype;
-                                       session[s].ppp.lcp = RequestSent;
+                                       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 = ntohl(config->iftun_n_address[tunnel[t].indexudp] ? config->iftun_n_address[tunnel[t].indexudp] : my_address);
 
+                                       sendlcp(s, t);
+                                       change_state(s, lcp, RequestSent);
                                        break;
+
                                case 14:      // CDN
+                                       LOG(3, s, t, "Received CDN\n");
                                        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");
@@ -2418,7 +3229,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
-                                               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);
@@ -2431,7 +3242,7 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
        }
        else
        {                          // data
-               uint16_t prot;
+               uint16_t proto;
 
                LOG_HEX(5, "Receive Tunnel Data", p, l);
                if (l > 2 && p[0] == 0xFF && p[1] == 0x03)
@@ -2447,115 +3258,154 @@ void processudp(uint8_t *buf, int len, struct sockaddr_in *addr)
                }
                if (*p & 1)
                {
-                       prot = *p++;
+                       proto = *p++;
                        l--;
                }
                else
                {
-                       prot = ntohs(*(uint16_t *) p);
+                       proto = ntohs(*(uint16_t *) p);
                        p += 2;
                        l -= 2;
                }
 
+               if (session[s].forwardtosession)
+               {
+                       LOG(5, s, t, "Forwarding data session to session %u\n", session[s].forwardtosession);
+                       // Forward to LAC/BAS or Remote LNS session
+                       lac_session_forward(buf, len, s, proto, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
+                       return;
+               }
+               else if (config->auth_tunnel_change_addr_src)
+               {
+                       if (tunnel[t].ip != ntohl(addr->sin_addr.s_addr) &&
+                               tunnel[t].port == ntohs(addr->sin_port))
+                       {
+                               // The remotes BAS are a clustered l2tpns server and the source IP has changed
+                               LOG(5, s, t, "The tunnel IP source (%s) has changed by new IP (%s)\n",
+                                       fmtaddr(htonl(tunnel[t].ip), 0), fmtaddr(addr->sin_addr.s_addr, 0));
+
+                               tunnel[t].ip = ntohl(addr->sin_addr.s_addr);
+                       }
+               }
+
                if (s && !session[s].opened)    // Is something wrong??
                {
                        if (!config->cluster_iam_master)
                        {
                                // Pass it off to the master to deal with..
-                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
+                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
                                return;
                        }
 
-
                        LOG(1, s, t, "UDP packet contains session which is not opened.  Dropping packet.\n");
                        STAT(tunnel_rx_errors);
                        return;
                }
 
-               if (prot == PPPPAP)
+               if (proto == PPPPAP)
                {
                        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; }
-                       processpap(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processpap(s, t, p, l);
                }
-               else if (prot == PPPCHAP)
+               else if (proto == PPPCHAP)
                {
                        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; }
-                       processchap(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processchap(s, t, p, l);
                }
-               else if (prot == PPPLCP)
+               else if (proto == PPPLCP)
                {
                        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; }
-                       processlcp(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processlcp(s, t, p, l);
                }
-               else if (prot == PPPIPCP)
+               else if (proto == PPPIPCP)
                {
                        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; }
-                       processipcp(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processipcp(s, t, p, l);
                }
-               else if (prot == PPPIPV6CP)
+               else if (proto == PPPIPV6CP && config->ipv6_prefix.s6_addr[0])
                {
                        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; }
-                       processipv6cp(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processipv6cp(s, t, p, l);
                }
-               else if (prot == PPPCCP)
+               else if (proto == PPPCCP)
                {
                        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; }
-                       processccp(t, s, p, l);
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       processccp(s, t, p, l);
                }
-               else if (prot == PPPIP)
+               else if (proto == PPPIP)
                {
                        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
                        }
 
-                       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);
+                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
                                return;
                        }
 
-                       processipin(t, s, p, l);
+                       processipin(s, t, p, l);
                }
-               else if (prot == PPPIPV6)
+               else if (proto == PPPMP)
                {
-                       if (!config->ipv6_prefix.s6_addr[0])
+                       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 (!config->cluster_iam_master)
                        {
-                               LOG(1, s, t, "IPv6 not configured; yet received IPv6 packet. Ignoring.\n");
+                               // The fragments reconstruction is managed by the Master.
+                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
                                return;
                        }
+
+                       processmpin(s, t, p, l);
+               }
+               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
                        }
 
-                       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);
+                               master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd);
                                return;
                        }
 
-                       processipv6in(t, s, p, l);
+                       processipv6in(s, t, p, l);
+               }
+               else if (session[s].ppp.lcp == Opened)
+               {
+                       session[s].last_packet = time_now;
+                       if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port, indexudpfd); return; }
+                       protoreject(s, t, p, l, proto);
                }
                else
                {
-                       STAT(tunnel_rx_errors);
-                       LOG(1, s, t, "Unknown PPP protocol %04X\n", prot);
+                       LOG(2, s, t, "Unknown PPP protocol 0x%04X received in LCP %s state\n",
+                               proto, ppp_state(session[s].ppp.lcp));
                }
        }
 }
 
 // read and process packet on tun
+// (i.e. this routine writes to buf[-8]).
 static void processtun(uint8_t * buf, int len)
 {
        LOG_HEX(5, "Receive TUN Data", buf, len);
@@ -2631,6 +3481,9 @@ static void regular_cleanups(double period)
                if (t > config->cluster_highest_tunnelid)
                        t = 1;
 
+               if (t == TUNNEL_ID_PPPOE)
+                       continue;
+
                // check for expired tunnels
                if (tunnel[t].die && tunnel[t].die <= TIME)
                {
@@ -2646,7 +3499,7 @@ static void regular_cleanups(double period)
                        if (tunnel[t].retry <= TIME)
                        {
                                controlt *c = tunnel[t].controls;
-                               uint8_t w = tunnel[t].window;
+                               uint16_t w = tunnel[t].window;
                                tunnel[t].try++; // another try
                                if (tunnel[t].try > 5)
                                        tunnelkill(t, "Timeout on control message"); // game over
@@ -2661,12 +3514,15 @@ static void regular_cleanups(double period)
                        }
                }
                // Send hello
-               if (tunnel[t].state == TUNNELOPEN && tunnel[t].lastrec < TIME + 600)
+               if (tunnel[t].state == TUNNELOPEN && !tunnel[t].controlc && (time_now - tunnel[t].lastrec) > 60)
                {
-                       controlt *c = controlnew(6); // sending HELLO
-                       controladd(c, t, 0); // send the message
-                       LOG(3, 0, t, "Sending HELLO message\n");
-                       t_actions++;
+                       if (!config->disable_sending_hello)
+                       {
+                               controlt *c = controlnew(6); // sending HELLO
+                               controladd(c, 0, t); // send the message
+                               LOG(3, 0, t, "Sending HELLO message\n");
+                               t_actions++;
+                       }
                }
 
                // Check for tunnel changes requested from the CLI
@@ -2719,7 +3575,7 @@ static void regular_cleanups(double period)
                }
 
                // PPP timeouts
-               if (sess_local[s].lcp.restart >= time_now)
+               if (sess_local[s].lcp.restart <= time_now)
                {
                        int next_state = session[s].ppp.lcp;
                        switch (session[s].ppp.lcp)
@@ -2732,14 +3588,12 @@ static void regular_cleanups(double period)
                                if (sess_local[s].lcp.conf_sent < config->ppp_max_configure)
                                {
                                        LOG(3, s, session[s].tunnel, "No ACK for LCP ConfigReq... resending\n");
-                                       sess_local[s].lcp.restart = time_now + config->ppp_restart_time;
-                                       sess_local[s].lcp.conf_sent++;
-                                       sendlcp(t, s, sess_local[s].lcp_authtype);
+                                       sendlcp(s, session[s].tunnel);
                                        change_state(s, lcp, next_state);
                                }
                                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);
                                }
 
@@ -2750,7 +3604,7 @@ static void regular_cleanups(double period)
                                continue;
                }
 
-               if (sess_local[s].ipcp.restart >= time_now)
+               if (sess_local[s].ipcp.restart <= time_now)
                {
                        int next_state = session[s].ppp.ipcp;
                        switch (session[s].ppp.ipcp)
@@ -2763,14 +3617,12 @@ static void regular_cleanups(double period)
                                if (sess_local[s].ipcp.conf_sent < config->ppp_max_configure)
                                {
                                        LOG(3, s, session[s].tunnel, "No ACK for IPCP ConfigReq... resending\n");
-                                       sess_local[s].ipcp.restart = time_now + config->ppp_restart_time;
-                                       sess_local[s].ipcp.conf_sent++;
-                                       sendipcp(t, s);
+                                       sendipcp(s, session[s].tunnel);
                                        change_state(s, ipcp, next_state);
                                }
                                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);
                                }
 
@@ -2781,7 +3633,7 @@ static void regular_cleanups(double period)
                                continue;
                }
 
-               if (sess_local[s].ipv6cp.restart >= time_now)
+               if (sess_local[s].ipv6cp.restart <= time_now)
                {
                        int next_state = session[s].ppp.ipv6cp;
                        switch (session[s].ppp.ipv6cp)
@@ -2794,9 +3646,7 @@ static void regular_cleanups(double period)
                                if (sess_local[s].ipv6cp.conf_sent < config->ppp_max_configure)
                                {
                                        LOG(3, s, session[s].tunnel, "No ACK for IPV6CP ConfigReq... resending\n");
-                                       sess_local[s].ipv6cp.restart = time_now + config->ppp_restart_time;
-                                       sess_local[s].ipv6cp.conf_sent++;
-                                       sendipv6cp(t, s);
+                                       sendipv6cp(s, session[s].tunnel);
                                        change_state(s, ipv6cp, next_state);
                                }
                                else
@@ -2809,7 +3659,7 @@ static void regular_cleanups(double period)
                        }
                }
 
-               if (sess_local[s].ccp.restart >= time_now)
+               if (sess_local[s].ccp.restart <= time_now)
                {
                        int next_state = session[s].ppp.ccp;
                        switch (session[s].ppp.ccp)
@@ -2822,9 +3672,7 @@ static void regular_cleanups(double period)
                                if (sess_local[s].ccp.conf_sent < config->ppp_max_configure)
                                {
                                        LOG(3, s, session[s].tunnel, "No ACK for CCP ConfigReq... resending\n");
-                                       sess_local[s].ccp.restart = time_now + config->ppp_restart_time;
-                                       sess_local[s].ccp.conf_sent++;
-                                       sendccp(t, s);
+                                       sendccp(s, session[s].tunnel);
                                        change_state(s, ccp, next_state);
                                }
                                else
@@ -2837,32 +3685,74 @@ 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_ECHO_TIMEOUT seconds
+               if (session[s].last_packet && (time_now - session[s].last_packet >= config->idle_echo_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;
                }
 
                // No data in ECHO_TIMEOUT seconds, send LCP ECHO
-               if (session[s].ppp.phase >= Establish && (time_now - session[s].last_packet >= ECHO_TIMEOUT))
+               if (session[s].ppp.phase >= Establish && (time_now - session[s].last_packet >= config->echo_timeout) &&
+                       (time_now - sess_local[s].last_echo >= ECHO_TIMEOUT))
                {
-                       uint8_t b[MAXCONTROL] = {0};
+                       uint8_t b[MAXETHER];
 
-                       uint8_t *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, 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
-                       *(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));
-                       tunnelsend(b, 24, session[s].tunnel); // send it
+
+                       tunnelsend(b, (q - b) + 8, session[s].tunnel); // send it
+                       sess_local[s].last_echo = time_now;
+                       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
@@ -2874,7 +3764,7 @@ static void regular_cleanups(double period)
                        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++;
                        }
@@ -2889,7 +3779,7 @@ static void regular_cleanups(double period)
                        }
                        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);
 
@@ -2943,7 +3833,8 @@ static void regular_cleanups(double period)
                if (config->radius_accounting && config->radius_interim > 0
                    && session[s].ip && !session[s].walled_garden
                    && !sess_local[s].radius // RADIUS already in progress
-                   && time_now - sess_local[s].last_interim >= config->radius_interim)
+                   && time_now - sess_local[s].last_interim >= config->radius_interim
+                   && session[s].flags & SESSION_STARTED)
                {
                        int rad = radiusnew(s);
                        if (!rad)
@@ -2976,35 +3867,36 @@ static int still_busy(void)
        static clockt last_talked = 0;
        static clockt start_busy_wait = 0;
 
-       if (!config->cluster_iam_master)
-       {
 #ifdef BGP
-               static time_t stopped_bgp = 0;
-               if (bgp_configured)
+       static time_t stopped_bgp = 0;
+       if (bgp_configured)
+       {
+               if (!stopped_bgp)
                {
-                       if (!stopped_bgp)
-                       {
-                               LOG(1, 0, 0, "Shutting down in %d seconds, stopping BGP...\n", QUIT_DELAY);
+                       LOG(1, 0, 0, "Shutting down in %d seconds, stopping BGP...\n", QUIT_DELAY);
 
-                               for (i = 0; i < BGP_NUM_PEERS; i++)
-                                       if (bgp_peers[i].state == Established)
-                                               bgp_stop(&bgp_peers[i]);
+                       for (i = 0; i < BGP_NUM_PEERS; i++)
+                               if (bgp_peers[i].state == Established)
+                                       bgp_stop(&bgp_peers[i]);
 
-                               stopped_bgp = time_now;
+                       stopped_bgp = time_now;
 
+                       if (!config->cluster_iam_master)
+                       {
                                // we don't want to become master
                                cluster_send_ping(0);
 
                                return 1;
                        }
-
-                       if (time_now < (stopped_bgp + QUIT_DELAY))
-                               return 1;
                }
+
+               if (!config->cluster_iam_master && time_now < (stopped_bgp + QUIT_DELAY))
+                       return 1;
+       }
 #endif /* BGP */
 
+       if (!config->cluster_iam_master)
                return 0;
-       }
 
        if (main_quit == QUIT_SHUTDOWN)
        {
@@ -3032,7 +3924,7 @@ static int still_busy(void)
 
                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;
@@ -3054,7 +3946,7 @@ static int still_busy(void)
 
                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;
@@ -3070,8 +3962,8 @@ static int still_busy(void)
 # include "fake_epoll.h"
 #endif
 
-// the base set of fds polled: cli, cluster, tun, udp, control, dae
-#define BASE_FDS       6
+// the base set of fds polled: cli, cluster, tun, udp (MAX_UDPFD), control, dae, netlink, udplac, pppoedisc, pppoesess
+#define BASE_FDS       (9 + MAX_UDPFD)
 
 // additional polled fds
 #ifdef BGP
@@ -3083,8 +3975,11 @@ static int still_busy(void)
 // main loop - gets packets on tun or udp and processes them
 static void mainloop(void)
 {
-       int i;
+       int i, j;
        uint8_t buf[65536];
+       uint8_t *p = buf + 32; // for the hearder of the forwarded MPPP packet (see C_MPPP_FORWARD)
+                                               // and the forwarded pppoe session
+       int size_bufp = sizeof(buf) - 32;
        clockt next_cluster_ping = 0;   // send initial ping immediately
        struct epoll_event events[BASE_FDS + RADIUS_FDS + EXTRA_FDS];
        int maxevent = sizeof(events)/sizeof(*events);
@@ -3095,8 +3990,8 @@ static void mainloop(void)
                exit(1);
        }
 
-       LOG(4, 0, 0, "Beginning of main loop.  clifd=%d, cluster_sockfd=%d, tunfd=%d, udpfd=%d, controlfd=%d, daefd=%d\n",
-               clifd, cluster_sockfd, tunfd, udpfd, controlfd, daefd);
+       LOG(4, 0, 0, "Beginning of main loop.  clifd=%d, cluster_sockfd=%d, tunfd=%d, udpfd=%d, controlfd=%d, daefd=%d, nlfd=%d , udplacfd=%d, pppoefd=%d, pppoesessfd=%d\n",
+               clifd, cluster_sockfd, tunfd, udpfd[0], controlfd, daefd, nlfd, udplacfd, pppoediscfd, pppoesessfd);
 
        /* setup our fds to poll for input */
        {
@@ -3106,9 +4001,12 @@ static void mainloop(void)
                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++];
@@ -3118,10 +4016,6 @@ static void mainloop(void)
                e.data.ptr = &d[i++];
                epoll_ctl(epollfd, EPOLL_CTL_ADD, tunfd, &e);
 
-               d[i].type = FD_TYPE_UDP;
-               e.data.ptr = &d[i++];
-               epoll_ctl(epollfd, EPOLL_CTL_ADD, udpfd, &e);
-
                d[i].type = FD_TYPE_CONTROL;
                e.data.ptr = &d[i++];
                epoll_ctl(epollfd, EPOLL_CTL_ADD, controlfd, &e);
@@ -3129,6 +4023,26 @@ static void mainloop(void)
                d[i].type = FD_TYPE_DAE;
                e.data.ptr = &d[i++];
                epoll_ctl(epollfd, EPOLL_CTL_ADD, daefd, &e);
+
+               d[i].type = FD_TYPE_NETLINK;
+               e.data.ptr = &d[i++];
+               epoll_ctl(epollfd, EPOLL_CTL_ADD, nlfd, &e);
+
+               d[i].type = FD_TYPE_PPPOEDISC;
+               e.data.ptr = &d[i++];
+               epoll_ctl(epollfd, EPOLL_CTL_ADD, pppoediscfd, &e);
+
+               d[i].type = FD_TYPE_PPPOESESS;
+               e.data.ptr = &d[i++];
+               epoll_ctl(epollfd, EPOLL_CTL_ADD, pppoesessfd, &e);
+
+               for (j = 0; j < config->nbudpfd; j++)
+               {
+                       d[i].type = FD_TYPE_UDP;
+                       d[i].index = j;
+                       e.data.ptr = &d[i++];
+                       epoll_ctl(epollfd, EPOLL_CTL_ADD, udpfd[j], &e);
+               }
        }
 
 #ifdef BGP
@@ -3142,7 +4056,8 @@ static void mainloop(void)
                if (config->neighbour[i].name[0])
                        bgp_start(&bgp_peers[i], config->neighbour[i].name,
                                config->neighbour[i].as, config->neighbour[i].keepalive,
-                               config->neighbour[i].hold, 0); /* 0 = routing disabled */
+                               config->neighbour[i].hold, config->neighbour[i].update_source,
+                               0); /* 0 = routing disabled */
        }
 #endif /* BGP */
 
@@ -3151,9 +4066,17 @@ static void mainloop(void)
                int more = 0;
                int n;
 
+
+               if (main_reload)
+               {
+                       main_reload = 0;
+                       read_config_file();
+                       config->reload_config++;
+               }
+
                if (config->reload_config)
                {
-                       // Update the config state based on config settings
+                       config->reload_config = 0;
                        update_config();
                }
 
@@ -3178,12 +4101,15 @@ static void mainloop(void)
                if (n)
                {
                        struct sockaddr_in addr;
+                       struct in_addr local;
                        socklen_t alen;
                        int c, s;
-                       int udp_ready = 0;
+                       int udp_ready[MAX_UDPFD + 1] = INIT_TABUDPVAR;
+                       int pppoesess_ready = 0;
+                       int pppoesess_pkts = 0;
                        int tun_ready = 0;
                        int cluster_ready = 0;
-                       int udp_pkts = 0;
+                       int udp_pkts[MAX_UDPFD + 1] = INIT_TABUDPVAR;
                        int tun_pkts = 0;
                        int cluster_pkts = 0;
 #ifdef BGP
@@ -3194,6 +4120,7 @@ static void mainloop(void)
                        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
@@ -3216,37 +4143,79 @@ static void mainloop(void)
                                // these are handled below, with multiple interleaved reads
                                case FD_TYPE_CLUSTER:   cluster_ready++; break;
                                case FD_TYPE_TUN:       tun_ready++; break;
-                               case FD_TYPE_UDP:       udp_ready++; break;
+                               case FD_TYPE_UDP:       udp_ready[d->index]++; break;
+                               case FD_TYPE_PPPOESESS: pppoesess_ready++; break;
+
+                               case FD_TYPE_PPPOEDISC: // pppoe discovery
+                                       s = read(pppoediscfd, p, size_bufp);
+                                       if (s > 0) process_pppoe_disc(p, s);
+                                       n--;
+                                       break;
 
                                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, p, size_bufp, MSG_WAITALL, (struct sockaddr *) &addr, &alen, &local);
+                                       if (s > 0) processcontrol(p, s, &addr, alen, &local);
                                        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, p, size_bufp, MSG_WAITALL, (struct sockaddr *) &addr, &alen, &local);
+                                       if (s > 0) processdae(p, s, &addr, alen, &local);
                                        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], p, size_bufp, MSG_WAITALL, (struct sockaddr *) &addr, &alen);
                                        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(p, 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;
 
 #ifdef BGP
                                case FD_TYPE_BGP:
-                                       bgp_events[d->index] = events[i].events;
-                                       n--;
+                                       bgp_events[d->index] = events[i].events;
+                                       n--;
                                        break;
 #endif /* BGP */
 
+                               case FD_TYPE_NETLINK:
+                               {
+                                       struct nlmsghdr *nh = (struct nlmsghdr *)p;
+                                       s = netlink_recv(p, size_bufp);
+                                       if (nh->nlmsg_type == NLMSG_ERROR)
+                                       {
+                                               struct nlmsgerr *errmsg = NLMSG_DATA(nh);
+                                               if (errmsg->error)
+                                               {
+                                                       if (errmsg->msg.nlmsg_seq < min_initok_nlseqnum)
+                                                       {
+                                                               LOG(0, 0, 0, "Got a fatal netlink error (while %s): %s\n", tun_nl_phase_msg[nh->nlmsg_seq], strerror(-errmsg->error));
+                                                               exit(1);
+                                                       }
+                                                       else
+                                                               LOG(0, 0, 0, "Got a netlink error: %s\n", strerror(-errmsg->error));
+                                               }
+                                               // else it's a ack
+                                       }
+                                       else
+                                               LOG(1, 0, 0, "Got a unknown netlink message: type %d seq %d flags %d\n", nh->nlmsg_type, nh->nlmsg_seq, nh->nlmsg_flags);
+                                       n--;
+                                       break;
+                               }
+
                                default:
-                                       LOG(0, 0, 0, "Unexpected fd type returned from epoll_wait: %d\n", d->type);
+                                       LOG(0, 0, 0, "Unexpected fd type returned from epoll_wait: %d\n", d->type);
                                }
                        }
 
@@ -3256,33 +4225,51 @@ static void mainloop(void)
 
                        for (c = 0; n && c < config->multi_read_count; c++)
                        {
-                               // L2TP
-                               if (udp_ready)
+                               for (j = 0; j < config->nbudpfd; j++)
                                {
-                                       alen = sizeof(addr);
-                                       if ((s = recvfrom(udpfd, buf, sizeof(buf), 0, (void *) &addr, &alen)) > 0)
+                                       // L2TP and L2TP REMOTE LNS
+                                       if (udp_ready[j])
+                                       {
+                                               alen = sizeof(addr);
+                                               if ((s = recvfrom(udpfd[j], p, size_bufp, 0, (void *) &addr, &alen)) > 0)
+                                               {
+                                                       processudp(p, s, &addr, j);
+                                                       udp_pkts[j]++;
+                                               }
+                                               else
+                                               {
+                                                       udp_ready[j] = 0;
+                                                       n--;
+                                               }
+                                       }
+                               }
+
+                               // incoming IP
+                               if (tun_ready)
+                               {
+                                       if ((s = read(tunfd, p, size_bufp)) > 0)
                                        {
-                                               processudp(buf, s, &addr);
-                                               udp_pkts++;
+                                               processtun(p, s);
+                                               tun_pkts++;
                                        }
                                        else
                                        {
-                                               udp_ready = 0;
+                                               tun_ready = 0;
                                                n--;
                                        }
                                }
 
-                               // incoming IP
-                               if (tun_ready)
+                               // pppoe session
+                               if (pppoesess_ready)
                                {
-                                       if ((s = read(tunfd, buf, sizeof(buf))) > 0)
+                                       if ((s = read(pppoesessfd, p, size_bufp)) > 0)
                                        {
-                                               processtun(buf, s);
-                                               tun_pkts++;
+                                               process_pppoe_sess(p, s);
+                                               pppoesess_pkts++;
                                        }
                                        else
                                        {
-                                               tun_ready = 0;
+                                               pppoesess_ready = 0;
                                                n--;
                                        }
                                }
@@ -3291,9 +4278,9 @@ static void mainloop(void)
                                if (cluster_ready)
                                {
                                        alen = sizeof(addr);
-                                       if ((s = recvfrom(cluster_sockfd, buf, sizeof(buf), MSG_WAITALL, (void *) &addr, &alen)) > 0)
+                                       if ((s = recvfrom(cluster_sockfd, p, size_bufp, MSG_WAITALL, (void *) &addr, &alen)) > 0)
                                        {
-                                               processcluster(buf, s, addr.sin_addr.s_addr);
+                                               processcluster(p, s, addr.sin_addr.s_addr);
                                                cluster_pkts++;
                                        }
                                        else
@@ -3304,18 +4291,51 @@ static void mainloop(void)
                                }
                        }
 
-                       if (udp_pkts > 1 || tun_pkts > 1 || cluster_pkts > 1)
+                       if (udp_pkts[0] > 1 || tun_pkts > 1 || cluster_pkts > 1)
                                STAT(multi_read_used);
 
                        if (c >= config->multi_read_count)
                        {
-                               LOG(3, 0, 0, "Reached multi_read_count (%d); processed %d udp, %d tun and %d cluster packets\n",
-                                       config->multi_read_count, udp_pkts, tun_pkts, cluster_pkts);
-
+                               LOG(3, 0, 0, "Reached multi_read_count (%d); processed %d udp, %d tun %d cluster and %d pppoe packets\n",
+                                       config->multi_read_count, udp_pkts[0], tun_pkts, cluster_pkts, pppoesess_pkts);
                                STAT(multi_read_exceeded);
                                more++;
                        }
                }
+#ifdef BGP
+               else
+                       /* no event received, but timers could still have expired */
+                       bgp_process_peers_timers();
+#endif /* BGP */
+
+               if (time_changed)
+               {
+                       double Mbps = 1024.0 * 1024.0 / 8 * time_changed;
+
+                       // Log current traffic stats
+                       snprintf(config->bandwidth, sizeof(config->bandwidth),
+                               "UDP-ETH:%1.0f/%1.0f  ETH-UDP:%1.0f/%1.0f  TOTAL:%0.1f   IN:%u OUT:%u",
+                               (udp_rx / Mbps), (eth_tx / Mbps), (eth_rx / Mbps), (udp_tx / Mbps),
+                               ((udp_tx + udp_rx + eth_tx + eth_rx) / Mbps),
+                               udp_rx_pkt / time_changed, eth_rx_pkt / time_changed);
+                
+                       udp_tx = udp_rx = 0;
+                       udp_rx_pkt = eth_rx_pkt = 0;
+                       eth_tx = eth_rx = 0;
+                       time_changed = 0;
+                
+                       if (config->dump_speed)
+                               printf("%s\n", config->bandwidth);
+                
+                       // Update the internal time counter
+                       strftime(time_now_string, sizeof(time_now_string), "%Y-%m-%d %H:%M:%S", localtime(&time_now));
+                
+                       {
+                               // Run timer hooks
+                               struct param_timer p = { time_now };
+                               run_plugins(PLUGIN_TIMER, &p);
+                       }
+               }
 
                        // Runs on every machine (master and slaves).
                if (next_cluster_ping <= TIME)
@@ -3485,11 +4505,16 @@ static void initdata(int optdebug, char *optconfig)
        config->debug = optdebug;
        config->num_tbfs = MAXTBFS;
        config->rl_rate = 28; // 28kbps
+       config->cluster_mcast_ttl = 1;
        config->cluster_master_min_adv = 1;
        config->ppp_restart_time = 3;
        config->ppp_max_configure = 10;
        config->ppp_max_failure = 5;
+       config->kill_timedout_sessions = 1;
        strcpy(config->random_device, RANDOMDEVICE);
+       // Set default value echo_timeout and idle_echo_timeout
+       config->echo_timeout = ECHO_TIMEOUT;
+       config->idle_echo_timeout = IDLE_ECHO_TIMEOUT;
 
        log_stream = stderr;
 
@@ -3512,6 +4537,16 @@ static void initdata(int optdebug, char *optconfig)
                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));
@@ -3558,6 +4593,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(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);
@@ -3575,6 +4611,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 < MAXBUNDLE; i++) {
+               bundle[i].state = BUNDLEUNDEF;
+       }
+
        if (!*hostname)
        {
                // Grab my hostname unless it's been specified
@@ -3591,6 +4631,8 @@ static void initdata(int optdebug, char *optconfig)
                exit(1);
        }
 #endif /* BGP */
+
+       lac_initremotelnsdata();
 }
 
 static int assign_ip_address(sessionidt s)
@@ -3709,7 +4751,7 @@ void rebuild_address_pool(void)
                        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.
@@ -3718,7 +4760,7 @@ void rebuild_address_pool(void)
 
                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;
@@ -3757,18 +4799,18 @@ static void fix_address_pool(int sid)
 //
 // Add a block of addresses to the IP pool to hand out.
 //
-static void add_to_ip_pool(in_addr_t addr, in_addr_t mask)
+static void add_to_ip_pool(in_addr_t addr, int prefixlen)
 {
        int i;
-       if (mask == 0)
-               mask = 0xffffffff;      // Host route only.
+       if (prefixlen == 0)
+               prefixlen = 32;         // Host route only.
 
-       addr &= mask;
+       addr &= 0xffffffff << (32 - prefixlen);
 
        if (ip_pool_size >= MAXIPPOOL)  // Pool is full!
                return ;
 
-       for (i = addr ;(i & mask) == addr; ++i)
+       for (i = addr ; i < addr+(1<<(32-prefixlen)); ++i)
        {
                if ((i & 0xff) == 0 || (i&0xff) == 255)
                        continue;       // Skip 0 and broadcast addresses.
@@ -3826,7 +4868,7 @@ static void initippool()
                {
                        // It's a range
                        int numbits = 0;
-                       in_addr_t start = 0, mask = 0;
+                       in_addr_t start = 0;
 
                        LOG(2, 0, 0, "Adding IP address range %s\n", buf);
                        *p++ = 0;
@@ -3836,20 +4878,19 @@ static void initippool()
                                continue;
                        }
                        start = ntohl(inet_addr(pool));
-                       mask = (in_addr_t) (pow(2, numbits) - 1) << (32 - numbits);
 
                        // Add a static route for this pool
-                       LOG(5, 0, 0, "Adding route for address pool %s/%u\n",
-                               fmtaddr(htonl(start), 0), 32 + mask);
+                       LOG(5, 0, 0, "Adding route for address pool %s/%d\n",
+                               fmtaddr(htonl(start), 0), numbits);
 
-                       routeset(0, start, mask, 0, 1);
+                       routeset(0, start, numbits, 0, 1);
 
-                       add_to_ip_pool(start, mask);
+                       add_to_ip_pool(start, numbits);
                }
                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);
@@ -3866,7 +4907,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);
 
-       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));
 
@@ -3878,7 +4919,7 @@ void snoop_send_packet(uint8_t *packet, uint16_t size, in_addr_t destination, ui
 
 static int dump_session(FILE **f, sessiont *s)
 {
-       if (!s->opened || !s->ip || !(s->cin_delta || s->cout_delta) || !*s->user || s->walled_garden)
+       if (!s->opened || (!s->ip && !s->forwardtosession) || !(s->cin_delta || s->cout_delta) || !*s->user || s->walled_garden)
                return 1;
 
        if (!*f)
@@ -3904,7 +4945,7 @@ static int dump_session(FILE **f, sessiont *s)
                        "# uptime: %ld\n"
                        "# format: username ip qos uptxoctets downrxoctets\n",
                        hostname,
-                       fmtaddr(config->bind_address ? config->bind_address : my_address, 0),
+                       fmtaddr(config->iftun_n_address[tunnel[s->tunnel].indexudp] ? config->iftun_n_address[tunnel[s->tunnel].indexudp] : my_address, 0),
                        now,
                        now - basetime);
        }
@@ -3991,18 +5032,21 @@ int main(int argc, char *argv[])
        // Start the timer routine off
        time(&time_now);
        strftime(time_now_string, sizeof(time_now_string), "%Y-%m-%d %H:%M:%S", localtime(&time_now));
-       signal(SIGALRM, sigalrm_handler);
-       siginterrupt(SIGALRM, 0);
 
        initplugins();
        initdata(optdebug, optconfig);
 
-       init_cli(hostname);
+       init_cli();
        read_config_file();
+       /* set hostname /after/ having read the config file */
+       if (*config->hostname)
+               strcpy(hostname, config->hostname);
+       cli_init_complete(hostname);
+       update_config();
        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;
@@ -4041,14 +5085,40 @@ int main(int argc, char *argv[])
                }
        }
 
+       initnetlink();
+
        /* Set up the cluster communications port. */
        if (cluster_init() < 0)
                exit(1);
 
        inittun();
-       LOG(1, 0, 0, "Set up on interface %s\n", config->tundevice);
+       LOG(1, 0, 0, "Set up on interface %s\n", config->tundevicename);
+
+       if (*config->pppoe_if_to_bind)
+       {
+               init_pppoe();
+               LOG(1, 0, 0, "Set up on pppoe interface %s\n", config->pppoe_if_to_bind);
+       }
+
+       if (!config->nbmultiaddress)
+       {
+               config->bind_n_address[0] = config->bind_address;
+               config->nbmultiaddress++;
+       }
+       config->nbudpfd = config->nbmultiaddress;
+       for (i = 0; i < config->nbudpfd; i++)
+               initudp(&udpfd[i], config->bind_n_address[i]);
+       initlacudp();
+       config->indexlacudpfd = config->nbudpfd;
+       udpfd[config->indexlacudpfd] = udplacfd;
+       config->nbudpfd++;
+
+       initcontrol();
+       initdae();
+
+       // Intercept
+       snoopfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 
-       initudp();
        initrad();
        initippool();
 
@@ -4074,12 +5144,6 @@ int main(int argc, char *argv[])
                        LOG(0, 0, 0, "Can't lock pages: %s\n", strerror(errno));
        }
 
-       alarm(1);
-
-       // Drop privileges here
-       if (config->target_uid > 0 && geteuid() == 0)
-               setuid(config->target_uid);
-
        mainloop();
 
        /* remove plugins (so cleanup code gets run) */
@@ -4097,53 +5161,11 @@ int main(int argc, char *argv[])
 
 static void sighup_handler(int sig)
 {
-       if (log_stream)
-       {
-               if (log_stream != stderr)
-                       fclose(log_stream);
-
-               log_stream = NULL;
-       }
-
-       read_config_file();
-}
-
-static void sigalrm_handler(int sig)
-{
-       // Log current traffic stats
-
-       snprintf(config->bandwidth, sizeof(config->bandwidth),
-               "UDP-ETH:%1.0f/%1.0f  ETH-UDP:%1.0f/%1.0f  TOTAL:%0.1f   IN:%u OUT:%u",
-               (udp_rx / 1024.0 / 1024.0 * 8),
-               (eth_tx / 1024.0 / 1024.0 * 8),
-               (eth_rx / 1024.0 / 1024.0 * 8),
-               (udp_tx / 1024.0 / 1024.0 * 8),
-               ((udp_tx + udp_rx + eth_tx + eth_rx) / 1024.0 / 1024.0 * 8),
-               udp_rx_pkt, eth_rx_pkt);
-
-       udp_tx = udp_rx = 0;
-       udp_rx_pkt = eth_rx_pkt = 0;
-       eth_tx = eth_rx = 0;
-
-       if (config->dump_speed)
-               printf("%s\n", config->bandwidth);
-
-       // Update the internal time counter
-       time(&time_now);
-       strftime(time_now_string, sizeof(time_now_string), "%Y-%m-%d %H:%M:%S", localtime(&time_now));
-       alarm(1);
-
-       {
-               // Run timer hooks
-               struct param_timer p = { time_now };
-               run_plugins(PLUGIN_TIMER, &p);
-       }
-
+       main_reload++;
 }
 
 static void shutdown_handler(int sig)
 {
-       LOG(1, 0, 0, "Shutting down\n");
        main_quit = (sig == SIGQUIT) ? QUIT_SHUTDOWN : QUIT_FAILOVER;
 }
 
@@ -4158,7 +5180,7 @@ static void build_chap_response(uint8_t *challenge, uint8_t id, uint16_t challen
        MD5_CTX ctx;
        *challenge_response = NULL;
 
-       if (!*config->l2tpsecret)
+       if (!*config->l2tp_secret)
        {
                LOG(0, 0, 0, "LNS requested CHAP authentication, but no l2tp secret is defined\n");
                return;
@@ -4170,7 +5192,7 @@ static void build_chap_response(uint8_t *challenge, uint8_t id, uint16_t challen
 
        MD5_Init(&ctx);
        MD5_Update(&ctx, &id, 1);
-       MD5_Update(&ctx, config->l2tpsecret, strlen(config->l2tpsecret));
+       MD5_Update(&ctx, config->l2tp_secret, strlen(config->l2tp_secret));
        MD5_Update(&ctx, challenge, challenge_length);
        MD5_Final(*challenge_response, &ctx);
 
@@ -4237,6 +5259,20 @@ static void update_config()
                setbuf(log_stream, NULL);
        }
 
+#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 = 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;
+       if (MRU > PPPoE_MRU)
+               MRU = PPPoE_MRU;
+
+       MSS = MRU - TCP_HDRS;
+
        // Update radius
        config->numradiusservers = 0;
        for (i = 0; i < MAXRADSERVER; i++)
@@ -4314,6 +5350,66 @@ static void update_config()
        if (!config->radius_dae_port)
                config->radius_dae_port = DAEPORT;
 
+       if(!config->bind_portremotelns)
+               config->bind_portremotelns = L2TPLACPORT;
+       if(!config->bind_address_remotelns)
+               config->bind_address_remotelns = INADDR_ANY;
+
+       if (*config->bind_multi_address)
+       {
+               char *sip = config->bind_multi_address;
+               char *n = sip;
+               char *e = config->bind_multi_address + strlen(config->bind_multi_address);
+               config->nbmultiaddress = 0;
+
+               while (*sip && (sip < e))
+               {
+                       in_addr_t ip = 0;
+                       uint8_t u = 0;
+
+                       while (n < e && (*n == ',' || *n == ' ')) n++;
+
+                       while (n < e && (isdigit(*n) || *n == '.'))
+                       {
+                                if (*n == '.')
+                                {
+                                        ip = (ip << 8) + u;
+                                        u = 0;
+                                }
+                                else
+                                       u = u * 10 + *n - '0';
+                                n++;
+                       }
+                       ip = (ip << 8) + u;
+                       n++;
+
+                       if (ip)
+                       {
+                               config->bind_n_address[config->nbmultiaddress] = htonl(ip);
+                               config->iftun_n_address[config->nbmultiaddress] = htonl(ip);
+                               config->nbmultiaddress++;
+                               LOG(1, 0, 0, "Bind address %s\n", fmtaddr(htonl(ip), 0));
+                       }
+
+                       sip = n;
+               }
+
+               if (config->nbmultiaddress >= 1)
+               {
+                       config->bind_address = config->bind_n_address[0];
+                       config->iftun_address = config->bind_address;
+               }
+       }
+
+       if(!config->iftun_address)
+       {
+               config->iftun_address = config->bind_address;
+               config->iftun_n_address[0] = config->iftun_address;
+       }
+
+       if (!*config->pppoe_ac_name)
+               strncpy(config->pppoe_ac_name, DEFAULT_PPPOE_AC_NAME, sizeof(config->pppoe_ac_name) - 1);
+
        // re-initialise the random number source
        initrandom(config->random_device);
 
@@ -4335,6 +5431,40 @@ static void update_config()
                }
        }
 
+       // Guest change
+        guest_accounts_num = 0;
+        char *p2 = config->guest_user;
+        while (p2 && *p2)
+        {
+                char *s = strpbrk(p2, " \t,");
+                if (s)
+                {
+                        *s++ = 0;
+                        while (*s == ' ' || *s == '\t')
+                                s++;
+
+                        if (!*s)
+                                s = 0;
+                }
+
+                strcpy(guest_users[guest_accounts_num], p2);
+                LOG(1, 0, 0, "Guest account[%d]: %s\n", guest_accounts_num, guest_users[guest_accounts_num]);
+                guest_accounts_num++;
+                p2 = s;
+        }
+        // Rebuild the guest_user array
+        strcpy(config->guest_user, "");
+        int ui = 0;
+        for (ui=0; ui<guest_accounts_num; ui++)
+        {
+                strcat(config->guest_user, guest_users[ui]);
+                if (ui<guest_accounts_num-1)
+                {
+                        strcat(config->guest_user, ",");
+                }
+        }
+
+
        memcpy(config->old_plugins, config->plugins, sizeof(config->plugins));
        if (!config->multi_read_count) config->multi_read_count = 10;
        if (!config->cluster_address) config->cluster_address = inet_addr(DEFAULT_MCAST_ADDR);
@@ -4382,8 +5512,6 @@ static void update_config()
                        LOG(0, 0, 0, "Can't write to PID file %s: %s\n", config->pid_file, strerror(errno));
                }
        }
-
-       config->reload_config = 0;
 }
 
 static void read_config_file()
@@ -4401,10 +5529,9 @@ static void read_config_file()
        cli_do_file(f);
        LOG(3, 0, 0, "Done reading config file\n");
        fclose(f);
-       update_config();
 }
 
-int sessionsetup(tunnelidt t, sessionidt s)
+int sessionsetup(sessionidt s, tunnelidt t)
 {
        // A session now exists, set it up
        in_addr_t ip;
@@ -4416,20 +5543,33 @@ int sessionsetup(tunnelidt t, sessionidt s)
 
        LOG(3, s, t, "Doing session setup for session\n");
 
+       // Join a bundle if the MRRU option is accepted
+       if(session[s].mrru > 0 && session[s].bundle == 0)
+       {
+               LOG(3, s, t, "This session can be part of multilink bundle\n");
+               if (join_bundle(s) > 0)
+                       cluster_send_bundle(session[s].bundle);
+               else
+               {
+                       LOG(0, s, t, "MPPP: Mismaching mssf option with other sessions in bundle\n");
+                       sessionshutdown(s, "Mismaching mssf option.", CDN_NONE, TERM_SERVICE_UNAVAILABLE);
+                       return 0;
+               }
+       }
+
        if (!session[s].ip)
        {
                assign_ip_address(s);
                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",
                        fmtaddr(htonl(session[s].ip), 0));
        }
 
-
        // Make sure this is right
        session[s].tunnel = t;
 
@@ -4442,31 +5582,50 @@ int sessionsetup(tunnelidt t, sessionidt s)
                for (i = 1; i <= config->cluster_highest_sessionid; i++)
                {
                        if (i == s) continue;
-                       if (!session[s].opened) continue;
+                       if (!session[s].opened) break;
+                       // Allow duplicate sessions for multilink ones of the same bundle.
+                       if (session[s].bundle && session[i].bundle && session[s].bundle == session[i].bundle) continue;
+
                        if (ip == session[i].ip)
                        {
-                               sessionkill(i, "Duplicate IP address");
+                               sessionshutdown(i, "Duplicate IP address", CDN_ADMIN_DISC, TERM_ADMIN_RESET);  // close radius/routes, etc.
                                continue;
                        }
 
                        if (config->allow_duplicate_users) continue;
                        if (session[s].walled_garden || session[i].walled_garden) continue;
+                       // Guest change
+                       int found = 0;
+                       int gu;
+                       for (gu = 0; gu < guest_accounts_num; gu++)
+                       {
+                               if (!strcasecmp(user, guest_users[gu]))
+                               {
+                                       found = 1;
+                                       break;
+                               }
+                       }
+                       if (found) 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");
+                               sessionshutdown(i, "Duplicate session for users", CDN_ADMIN_DISC, TERM_ADMIN_RESET);  // close radius/routes, etc.
                }
        }
 
+       // no need to set a route for the same IP address of the bundle
+       if (!session[s].bundle || (bundle[session[s].bundle].num_of_links == 1))
        {
-               int routed = 0;
+               int routed = 0;
 
                // Add the route for this session.
                for (r = 0; r < MAXROUTE && session[s].route[r].ip; r++)
                {
-                       if ((session[s].ip & session[s].route[r].mask) ==
-                           (session[s].route[r].ip & session[s].route[r].mask))
+                       if ((session[s].ip >> (32-session[s].route[r].prefixlen)) ==
+                           (session[s].route[r].ip >> (32-session[s].route[r].prefixlen)))
                                routed++;
 
-                       routeset(s, session[s].route[r].ip, session[s].route[r].mask, 0, 1);
+                       routeset(s, session[s].route[r].ip, session[s].route[r].prefixlen, 0, 1);
                }
 
                // Static IPs need to be routed if not already
@@ -4483,7 +5642,7 @@ int sessionsetup(tunnelidt t, sessionidt s)
        }
 
        sess_local[s].lcp_authtype = 0; // RADIUS authentication complete
-       lcp_open(t, s); // transition to Network phase and send initial IPCP
+       lcp_open(s, t); // transition to Network phase and send initial IPCP
 
        // Run the plugin's against this new session.
        {
@@ -4495,7 +5654,7 @@ int sessionsetup(tunnelidt t, sessionidt s)
        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),
@@ -4537,7 +5696,7 @@ int load_session(sessionidt s, sessiont *new)
 
        for (i = 0; !newip && i < MAXROUTE && (session[s].route[i].ip || new->route[i].ip); i++)
                if (new->route[i].ip != session[s].route[i].ip ||
-                   new->route[i].mask != session[s].route[i].mask)
+                   new->route[i].prefixlen != session[s].route[i].prefixlen)
                        newip++;
 
        // needs update
@@ -4548,11 +5707,11 @@ int load_session(sessionidt s, sessiont *new)
                // remove old routes...
                for (i = 0; i < MAXROUTE && session[s].route[i].ip; i++)
                {
-                       if ((session[s].ip & session[s].route[i].mask) ==
-                           (session[s].route[i].ip & session[s].route[i].mask))
+                       if ((session[s].ip >> (32-session[s].route[i].prefixlen)) ==
+                           (session[s].route[i].ip >> (32-session[s].route[i].prefixlen)))
                                routed++;
 
-                       routeset(s, session[s].route[i].ip, session[s].route[i].mask, 0, 0);
+                       routeset(s, session[s].route[i].ip, session[s].route[i].prefixlen, 0, 0);
                }
 
                // ...ip
@@ -4571,11 +5730,11 @@ int load_session(sessionidt s, sessiont *new)
                // add new routes...
                for (i = 0; i < MAXROUTE && new->route[i].ip; i++)
                {
-                       if ((new->ip & new->route[i].mask) ==
-                           (new->route[i].ip & new->route[i].mask))
+                       if ((new->ip >> (32-new->route[i].prefixlen)) ==
+                           (new->route[i].ip >> (32-new->route[i].prefixlen)))
                                routed++;
 
-                       routeset(s, new->route[i].ip, new->route[i].mask, 0, 1);
+                       routeset(s, new->route[i].ip, new->route[i].prefixlen, 0, 1);
                }
 
                // ...ip
@@ -4598,13 +5757,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]))
        {
-               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]))
        {
-               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;
        }
 
@@ -4809,7 +5968,7 @@ static void plugins_done()
                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;
@@ -4967,7 +6126,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)
        {
-               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));
@@ -4986,9 +6145,9 @@ static tunnelidt new_tunnel()
        tunnelidt i;
        for (i = 1; i < MAXTUNNEL; i++)
        {
-               if (tunnel[i].state == TUNNELFREE)
+               if ((tunnel[i].state == TUNNELFREE) && (i != TUNNEL_ID_PPPOE))
                {
-                       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;
@@ -5058,7 +6217,7 @@ int cmd_show_hist_idle(struct cli_def *cli, char *command, char **argv, int argc
                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;
@@ -5135,7 +6294,7 @@ static void unhide_value(uint8_t *value, size_t len, uint16_t type, uint8_t *vec
        // Compute initial pad
        MD5_Init(&ctx);
        MD5_Update(&ctx, (unsigned char *) &m, 2);
-       MD5_Update(&ctx, config->l2tpsecret, strlen(config->l2tpsecret));
+       MD5_Update(&ctx, config->l2tp_secret, strlen(config->l2tp_secret));
        MD5_Update(&ctx, vector, vec_len);
        MD5_Final(digest, &ctx);
 
@@ -5148,7 +6307,7 @@ static void unhide_value(uint8_t *value, size_t len, uint16_t type, uint8_t *vec
                if (d >= sizeof(digest))
                {
                        MD5_Init(&ctx);
-                       MD5_Update(&ctx, config->l2tpsecret, strlen(config->l2tpsecret));
+                       MD5_Update(&ctx, config->l2tp_secret, strlen(config->l2tp_secret));
                        MD5_Update(&ctx, last, sizeof(digest));
                        MD5_Final(digest, &ctx);
 
@@ -5271,7 +6430,9 @@ int ip_filter(uint8_t *buf, int len, uint8_t filter)
 
                if (frag_offset)
                {
-                       if (!rule->frag || rule->action == FILTER_ACTION_DENY)
+                       // layer 4 deny rules are skipped
+                       if (rule->action == FILTER_ACTION_DENY &&
+                           (rule->src_ports.op || rule->dst_ports.op || rule->tcp_flag_op))
                                continue;
                }
                else
@@ -5301,3 +6462,49 @@ int ip_filter(uint8_t *buf, int len, uint8_t filter)
        // default deny
        return 0;
 }
+
+tunnelidt lac_new_tunnel()
+{
+       return new_tunnel();
+}
+
+void lac_tunnelclear(tunnelidt t)
+{
+       tunnelclear(t);
+}
+
+void lac_send_SCCRQ(tunnelidt t, uint8_t * auth, unsigned int auth_len)
+{
+       uint16_t version = 0x0100;      // protocol version
+
+       tunnel[t].state = TUNNELOPENING;
+
+       // Sent SCCRQ - Start Control Connection Request
+       controlt *c = controlnew(1); // sending SCCRQ
+       controls(c, 7, hostname, 1); // host name
+       controls(c, 8, Vendor_name, 1); // Vendor name
+       control16(c, 2, version, 1); // protocol version
+       control32(c, 3, 3, 1); // framing Capabilities
+       control16(c, 9, t, 1); // assigned tunnel
+       controlb(c, 11, (uint8_t *) auth, auth_len, 1);  // CHAP Challenge
+       LOG(3, 0, t, "Sent SCCRQ to REMOTE LNS\n");
+       controladd(c, 0, t); // send
+}
+
+void lac_send_ICRQ(tunnelidt t, sessionidt s)
+{
+       // Sent ICRQ  Incoming-call-request
+       controlt *c = controlnew(10); // ICRQ
+
+       control16(c, 14, s, 1); // assigned sesion
+       call_serial_number++;
+       control32(c, 15, call_serial_number, 1);  // call serial number
+       LOG(3, s, t, "Sent ICRQ to REMOTE LNS (far ID %u)\n", tunnel[t].far);
+       controladd(c, 0, t); // send
+}
+
+void lac_tunnelshutdown(tunnelidt t, char *reason, int result, int error, char *msg)
+{
+       tunnelshutdown(t, reason, result, error, msg);
+}
+