Merge branch 'common-cvs-git-upstream' into fdn-mods
[l2tpns.git] / ppp.c
diff --git a/ppp.c b/ppp.c
index 3584fe4..4d01e90 100644 (file)
--- a/ppp.c
+++ b/ppp.c
@@ -1,7 +1,5 @@
 // L2TPNS PPP Stuff
 
 // L2TPNS PPP Stuff
 
-char const *cvs_id_ppp = "$Id: ppp.c,v 1.97 2006-03-27 03:01:08 bodea Exp $";
-
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -15,6 +13,8 @@ char const *cvs_id_ppp = "$Id: ppp.c,v 1.97 2006-03-27 03:01:08 bodea Exp $";
 #include "cluster.h"
 
 extern tunnelt *tunnel;
 #include "cluster.h"
 
 extern tunnelt *tunnel;
+extern bundlet *bundle;
+extern fragmentationt *frag;
 extern sessiont *session;
 extern radiust *radius;
 extern int tunfd;
 extern sessiont *session;
 extern radiust *radius;
 extern int tunfd;
@@ -24,6 +24,20 @@ extern time_t time_now;
 extern configt *config;
 
 static int add_lcp_auth(uint8_t *b, int size, int authtype);
 extern configt *config;
 
 static int add_lcp_auth(uint8_t *b, int size, int authtype);
+static bundleidt new_bundle(void);
+static int epdiscmp(epdist, epdist);
+static void setepdis(epdist *, epdist);
+static void ipcp_open(sessionidt s, tunnelidt t);
+
+static int first_session_in_bundle(sessionidt s)
+{
+       bundleidt i;
+       for (i = 1; i < MAXBUNDLE; i++)
+               if (bundle[i].state != BUNDLEFREE)
+                       if (epdiscmp(session[s].epdis,bundle[i].epdis) && !strcmp(session[s].user, bundle[i].user))
+                               return 0;
+       return 1;       
+}
 
 // Process PAP messages
 void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
 
 // Process PAP messages
 void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
@@ -40,7 +54,7 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Short PAP %u bytes\n", l);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Short PAP %u bytes\n", l);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "Short PAP packet.", 3, 0);
+               sessionshutdown(s, "Short PAP packet.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -48,7 +62,7 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Length mismatch PAP %u/%u\n", hl, l);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Length mismatch PAP %u/%u\n", hl, l);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "PAP length mismatch.", 3, 0);
+               sessionshutdown(s, "PAP length mismatch.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
        l = hl;
                return;
        }
        l = hl;
@@ -57,7 +71,7 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Unexpected PAP code %d\n", *p);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Unexpected PAP code %d\n", *p);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "Unexpected PAP code.", 3, 0);
+               sessionshutdown(s, "Unexpected PAP code.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -90,7 +104,7 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                // respond now, either no RADIUS available or already authenticated
                uint8_t b[MAXETHER];
                uint8_t id = p[1];
                // respond now, either no RADIUS available or already authenticated
                uint8_t b[MAXETHER];
                uint8_t id = p[1];
-               uint8_t *p = makeppp(b, sizeof(b), 0, 0, s, t, PPPPAP);
+               uint8_t *p = makeppp(b, sizeof(b), 0, 0, s, t, PPPPAP, 0, 0, 0);
                if (!p) return;
 
                if (session[s].ip)
                if (!p) return;
 
                if (session[s].ip)
@@ -110,7 +124,7 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                else
                {
                        LOG(1, s, t, "No RADIUS session available to authenticate session...\n");
                else
                {
                        LOG(1, s, t, "No RADIUS session available to authenticate session...\n");
-                       sessionshutdown(s, "No free RADIUS sessions.", 4, 0);
+                       sessionshutdown(s, "No free RADIUS sessions.", CDN_UNAVAILABLE, TERM_SERVICE_UNAVAILABLE);
                }
        }
        else
                }
        }
        else
@@ -134,7 +148,10 @@ void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
 
                radius[r].id = p[1];
                LOG(3, s, t, "Sending login for %s/%s to RADIUS\n", user, pass);
 
                radius[r].id = p[1];
                LOG(3, s, t, "Sending login for %s/%s to RADIUS\n", user, pass);
-               radiussend(r, RADIUSAUTH);
+               if ((session[s].mrru) && (!first_session_in_bundle(s)))
+                       radiussend(r, RADIUSJUSTAUTH);
+               else
+                       radiussend(r, RADIUSAUTH);
        }
 }
 
        }
 }
 
@@ -152,7 +169,7 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Short CHAP %u bytes\n", l);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Short CHAP %u bytes\n", l);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "Short CHAP packet.", 3, 0);
+               sessionshutdown(s, "Short CHAP packet.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -160,7 +177,7 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Length mismatch CHAP %u/%u\n", hl, l);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Length mismatch CHAP %u/%u\n", hl, l);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "CHAP length mismatch.", 3, 0);
+               sessionshutdown(s, "CHAP length mismatch.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
        l = hl;
                return;
        }
        l = hl;
@@ -169,20 +186,28 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Unexpected CHAP response code %d\n", *p);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Unexpected CHAP response code %d\n", *p);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "CHAP length mismatch.", 3, 0);
+               sessionshutdown(s, "CHAP length mismatch.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
-       r = sess_local[s].radius;
-       if (!r)
+       if (session[s].ppp.phase != Authenticate)
        {
        {
-               LOG(3, s, t, "Unexpected CHAP message\n");
+               LOG(2, s, t, "CHAP ignored in %s phase\n", ppp_phase(session[s].ppp.phase));
                return;
        }
 
                return;
        }
 
-       if (session[s].ppp.phase != Authenticate)
+       r = sess_local[s].radius;
+       if (!r)
        {
        {
-               LOG(2, s, t, "CHAP ignored in %s phase\n", ppp_phase(session[s].ppp.phase));
+               LOG(3, s, t, "Unexpected CHAP message\n");
+
+               // Some modems (Netgear DM602, possibly others) persist in using CHAP even
+               // after ACKing our ConfigReq for PAP.
+               if (sess_local[s].lcp_authtype == AUTHPAP && config->radius_authtypes & AUTHCHAP)
+               {
+                       sess_local[s].lcp_authtype = AUTHCHAP;
+                       sendchap(s, t);
+               }
                return;
        }
 
                return;
        }
 
@@ -190,7 +215,7 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Wrong CHAP response ID %d (should be %d) (%d)\n", p[1], radius[r].id, r);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Wrong CHAP response ID %d (should be %d) (%d)\n", p[1], radius[r].id, r);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "Unexpected CHAP response ID.", 3, 0);
+               sessionshutdown(s, "Unexpected CHAP response ID.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -198,7 +223,7 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "Bad CHAP response length %d\n", l < 5 ? -1 : p[4]);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "Bad CHAP response length %d\n", l < 5 ? -1 : p[4]);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "Bad CHAP response length.", 3, 0);
+               sessionshutdown(s, "Bad CHAP response length.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -208,7 +233,7 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                LOG(1, s, t, "CHAP user too long %d\n", l - 16);
                STAT(tunnel_rx_errors);
        {
                LOG(1, s, t, "CHAP user too long %d\n", l - 16);
                STAT(tunnel_rx_errors);
-               sessionshutdown(s, "CHAP username too long.", 3, 0);
+               sessionshutdown(s, "CHAP username too long.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                return;
        }
 
                return;
        }
 
@@ -243,7 +268,10 @@ void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
 
        radius[r].chap = 1;
        LOG(3, s, t, "CHAP login %s\n", session[s].user);
 
        radius[r].chap = 1;
        LOG(3, s, t, "CHAP login %s\n", session[s].user);
-       radiussend(r, RADIUSAUTH);
+       if ((session[s].mrru) && (!first_session_in_bundle(s)))
+               radiussend(r, RADIUSJUSTAUTH);
+       else
+               radiussend(r, RADIUSAUTH);
 }
 
 static void dumplcp(uint8_t *p, int l)
 }
 
 static void dumplcp(uint8_t *p, int l)
@@ -352,16 +380,25 @@ void lcp_open(sessionidt s, tunnelidt t)
        }
        else
        {
        }
        else
        {
-               // This-Layer-Up
-               sendipcp(s, t);
-               change_state(s, ipcp, RequestSent);
-               // move to passive state for IPv6 (if configured), CCP
-               if (config->ipv6_prefix.s6_addr[0])
-                       change_state(s, ipv6cp, Stopped);
-               else
-                       change_state(s, ipv6cp, Closed);
+               if(session[s].bundle == 0 || bundle[session[s].bundle].num_of_links == 1)
+               {
+                       // This-Layer-Up
+                       sendipcp(s, t);
+                       change_state(s, ipcp, RequestSent);
+                       // move to passive state for IPv6 (if configured), CCP
+                       if (config->ipv6_prefix.s6_addr[0])
+                               change_state(s, ipv6cp, Stopped);
+                       else
+                               change_state(s, ipv6cp, Closed);
 
 
-               change_state(s, ccp, Stopped);
+                       change_state(s, ccp, Stopped);
+               }
+               else
+               {
+                       sessionidt first_ses = bundle[session[s].bundle].members[0];
+                       LOG(3, s, t, "MPPP: Skipping IPCP negotiation for session:%d, first session of bundle is:%d\n",s,first_ses);
+                       ipcp_open(s, t);
+                }
        }
 }
 
        }
 }
 
@@ -379,7 +416,7 @@ static uint8_t *ppp_conf_rej(sessionidt s, uint8_t *buf, size_t blen, uint16_t m
 {
        if (!*response || **response != ConfigRej)
        {
 {
        if (!*response || **response != ConfigRej)
        {
-               queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype);
+               queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype, 0, 0, 0);
                if (!queued)
                        return 0;
 
                if (!queued)
                        return 0;
 
@@ -423,7 +460,7 @@ static uint8_t *ppp_conf_nak(sessionidt s, uint8_t *buf, size_t blen, uint16_t m
                if (*nak_sent >= config->ppp_max_failure)
                        return ppp_conf_rej(s, buf, blen, mtype, response, 0, packet, option);
 
                if (*nak_sent >= config->ppp_max_failure)
                        return ppp_conf_rej(s, buf, blen, mtype, response, 0, packet, option);
 
-               queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype);
+               queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype, 0, 0, 0);
                if (!queued)
                        return 0;
 
                if (!queued)
                        return 0;
 
@@ -455,7 +492,7 @@ static void ppp_code_rej(sessionidt s, tunnelidt t, uint16_t proto,
        l += 4;
        if (l > mru) l = mru;
 
        l += 4;
        if (l > mru) l = mru;
 
-       q = makeppp(buf, size, 0, 0, s, t, proto);
+       q = makeppp(buf, size, 0, 0, s, t, proto, 0, 0, 0);
        if (!q) return;
 
        *q = CodeRej;
        if (!q) return;
 
        *q = CodeRej;
@@ -567,6 +604,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                uint8_t *response = 0;
                static uint8_t asyncmap[4] = { 0, 0, 0, 0 }; // all zero
                static uint8_t authproto[5];
                uint8_t *response = 0;
                static uint8_t asyncmap[4] = { 0, 0, 0, 0 }; // all zero
                static uint8_t authproto[5];
+               int changed = 0;
 
                while (x > 2)
                {
 
                while (x > 2)
                {
@@ -582,7 +620,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                                                if (mru >= MINMTU)
                                                {
                                                        session[s].mru = mru;
                                                if (mru >= MINMTU)
                                                {
                                                        session[s].mru = mru;
-                                                       cluster_send_session(s);
+                                                       changed++;
                                                        break;
                                                }
 
                                                        break;
                                                }
 
@@ -655,6 +693,64 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                                case 8: // Address-And-Control-Field-Compression
                                        break;
 
                                case 8: // Address-And-Control-Field-Compression
                                        break;
 
+                               case 17: // Multilink Max-Receive-Reconstructed-Unit
+                                       {
+                                               uint16_t mrru = ntohs(*(uint16_t *)(o + 2));
+                                               session[s].mrru = mrru;
+                                               changed++;
+                                               LOG(3, s, t, "    Received PPP LCP option MRRU: %d\n",mrru);
+                                       }
+                                       break;
+                                       
+                               case 18: // Multilink Short Sequence Number Header Format
+                                       {
+                                               session[s].mssf = 1;
+                                               changed++;
+                                               LOG(3, s, t, "    Received PPP LCP option MSSN format\n");
+                                       }
+                                       break;
+                                       
+                               case 19: // Multilink Endpoint Discriminator
+                                       {
+                                               uint8_t epdis_class = o[2];
+                                               int addr;
+
+                                               session[s].epdis.addr_class = epdis_class;
+                                               session[s].epdis.length = length - 3;
+                                               if (session[s].epdis.length > 20)
+                                               {
+                                                       LOG(1, s, t, "Error: received EndDis Address Length more than 20: %d\n", session[s].epdis.length);
+                                                       session[s].epdis.length = 20;
+                                               }
+
+                                               for (addr = 0; addr < session[s].epdis.length; addr++)
+                                                       session[s].epdis.address[addr] = o[3+addr];
+
+                                               changed++;
+
+                                               switch (epdis_class)
+                                               {
+                                               case LOCALADDR:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis Local Address Class: %d\n",epdis_class);
+                                                       break;
+                                               case IPADDR:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis IP Address Class: %d\n",epdis_class);
+                                                       break;
+                                               case IEEEMACADDR:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis IEEE MAC Address Class: %d\n",epdis_class);
+                                                       break;
+                                               case PPPMAGIC:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis PPP Magic No Class: %d\n",epdis_class);
+                                                       break;
+                                               case PSNDN:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis PSND No Class: %d\n",epdis_class);
+                                                       break;
+                                               default:
+                                                       LOG(3, s, t, "    Received PPP LCP option Multilink EndDis NULL Class %d\n",epdis_class);
+                                               }
+                                       }
+                                       break;
+
                                default: // Reject any unknown options
                                        LOG(3, s, t, "    Rejecting unknown PPP LCP option %d\n", type);
                                        q = ppp_conf_rej(s, b, sizeof(b), PPPLCP, &response, q, p, o);
                                default: // Reject any unknown options
                                        LOG(3, s, t, "    Rejecting unknown PPP LCP option %d\n", type);
                                        q = ppp_conf_rej(s, b, sizeof(b), PPPLCP, &response, q, p, o);
@@ -663,6 +759,9 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                        o += length;
                }
 
                        o += length;
                }
 
+               if (changed)
+                       cluster_send_session(s);
+
                if (response)
                {
                        l = q - response; // LCP packet length
                if (response)
                {
                        l = q - response; // LCP packet length
@@ -671,7 +770,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                else
                {
                        // Send packet back as ConfigAck
                else
                {
                        // Send packet back as ConfigAck
-                       response = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
+                       response = makeppp(b, sizeof(b), p, l, s, t, PPPLCP, 0, 0, 0);
                        if (!response) return;
                        *response = ConfigAck;
                }
                        if (!response) return;
                        *response = ConfigAck;
                }
@@ -679,7 +778,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                switch (session[s].ppp.lcp)
                {
                case Closed:
                switch (session[s].ppp.lcp)
                {
                case Closed:
-                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP);
+                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP, 0, 0, 0);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
@@ -720,6 +819,10 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
 
                        break;
 
 
                        break;
 
+               case Closing:
+                       sessionshutdown(s, "LCP: ConfigReq in state Closing. This should not happen. Killing session.", CDN_ADMIN_DISC, TERM_LOST_SERVICE);
+                       break;
+
                default:
                        LOG(2, s, t, "LCP: ignoring %s in state %s\n", ppp_code(*p), ppp_state(session[s].ppp.lcp));
                        return;
                default:
                        LOG(2, s, t, "LCP: ignoring %s in state %s\n", ppp_code(*p), ppp_state(session[s].ppp.lcp));
                        return;
@@ -812,9 +915,53 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                                        cluster_send_session(s);
                                        break;
 
                                        cluster_send_session(s);
                                        break;
 
+                               case 17: // Multilink Max-Receive-Reconstructed-Unit
+                               {
+                                       if (*p == ConfigNak)
+                                       {
+                                               sess_local[s].mp_mrru = ntohs(*(uint16_t *)(o + 2));
+                                               LOG(3, s, t, "    Remote requested MRRU of %u\n", sess_local[s].mp_mrru);
+                                       }
+                                       else
+                                       {
+                                               sess_local[s].mp_mrru = 0;
+                                               LOG(3, s, t, "    Remote rejected MRRU negotiation\n");
+                                       }
+                               }
+                               break;
+
+                               case 18: // Multilink Short Sequence Number Header Format
+                               {
+                                       if (*p == ConfigNak)
+                                       {
+                                               sess_local[s].mp_mssf = 0;
+                                               LOG(3, s, t, "    Remote requested Naked mssf\n");
+                                       }
+                                       else
+                                       {
+                                               sess_local[s].mp_mssf = 0;
+                                               LOG(3, s, t, "    Remote rejected mssf\n");
+                                       }
+                               }
+                               break;
+
+                               case 19: // Multilink Endpoint Discriminator
+                               {
+                                       if (*p == ConfigNak)
+                                       {
+                                               LOG(2, s, t, "    Remote should not configNak Endpoint Dis!\n");
+                                       }
+                                       else
+                                       {
+                                               sess_local[s].mp_epdis = 0;
+                                               LOG(3, s, t, "    Remote rejected Endpoint Discriminator\n");
+                                       }
+                               }
+                               break;
+
                                default:
                                        LOG(2, s, t, "LCP: remote sent %s for type %u?\n", ppp_code(*p), type);
                                default:
                                        LOG(2, s, t, "LCP: remote sent %s for type %u?\n", ppp_code(*p), type);
-                                       sessionshutdown(s, "Unable to negotiate LCP.", 3, 0);
+                                       sessionshutdown(s, "Unable to negotiate LCP.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                                        return;
                        }
                        x -= length;
                                        return;
                        }
                        x -= length;
@@ -823,7 +970,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
 
                if (!authtype)
                {
 
                if (!authtype)
                {
-                       sessionshutdown(s, "Unsupported authentication.", 3, 0);
+                       sessionshutdown(s, "Unsupported authentication.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                        return;
                }
 
                        return;
                }
 
@@ -835,7 +982,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                case Closed:
                case Stopped:
                        {
                case Closed:
                case Stopped:
                        {
-                               uint8_t *response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP);
+                               uint8_t *response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP, 0, 0, 0);
                                if (!response) return;
                                *response = TerminateAck;
                                *((uint16_t *) (response + 2)) = htons(l = 4);
                                if (!response) return;
                                *response = TerminateAck;
                                *((uint16_t *) (response + 2)) = htons(l = 4);
@@ -870,19 +1017,36 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        }
        else if (*p == TerminateReq)
        {
        }
        else if (*p == TerminateReq)
        {
-               *p = TerminateAck;      // close
-               q = makeppp(b, sizeof(b),  p, l, s, t, PPPLCP);
+               switch (session[s].ppp.lcp)
+               {
+               case Closed:
+               case Stopped:
+               case Closing:
+               case Stopping:
+               case RequestSent:
+               case AckReceived:
+               case AckSent:
+                       break;
+
+               case Opened:
+                       lcp_restart(s);
+                       zero_restart_count(s, lcp);
+                       change_state(s, lcp, Closing);
+                       break;
+
+               default:
+                       LOG(2, s, t, "LCP: ignoring %s in state %s\n", ppp_code(*p), ppp_state(session[s].ppp.lcp));
+                       return;
+               }
+
+               *p = TerminateAck;      // send ack
+               q = makeppp(b, sizeof(b),  p, l, s, t, PPPLCP, 0, 0, 0);
                if (!q) return;
 
                LOG(3, s, t, "LCP: send %s\n", ppp_code(*q));
                if (config->debug > 3) dumplcp(q, l);
 
                tunnelsend(b, l + (q - b), t); // send it
                if (!q) return;
 
                LOG(3, s, t, "LCP: send %s\n", ppp_code(*q));
                if (config->debug > 3) dumplcp(q, l);
 
                tunnelsend(b, l + (q - b), t); // send it
-               sessionshutdown(s, "Remote end closed connection.", 3, 0);
-       }
-       else if (*p == TerminateAck)
-       {
-               sessionshutdown(s, "Connection closed.", 3, 0);
        }
        else if (*p == ProtocolRej)
        {
        }
        else if (*p == ProtocolRej)
        {
@@ -912,7 +1076,7 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        {
                *p = EchoReply;         // reply
                *(uint32_t *) (p + 4) = htonl(session[s].magic); // our magic number
        {
                *p = EchoReply;         // reply
                *(uint32_t *) (p + 4) = htonl(session[s].magic); // our magic number
-               q = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
+               q = makeppp(b, sizeof(b), p, l, s, t, PPPLCP, 0, 0, 0);
                if (!q) return;
 
                LOG(4, s, t, "LCP: send %s\n", ppp_code(*q));
                if (!q) return;
 
                LOG(4, s, t, "LCP: send %s\n", ppp_code(*q));
@@ -930,6 +1094,112 @@ void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        }
 }
 
        }
 }
 
+int join_bundle(sessionidt s)
+{
+       // Search for a bundle to join
+       bundleidt i;
+       bundleidt b;
+       for (i = 1; i < MAXBUNDLE; i++)
+       {
+               if (bundle[i].state != BUNDLEFREE)
+               {
+                       if (epdiscmp(session[s].epdis,bundle[i].epdis) && !strcmp(session[s].user, bundle[i].user))
+                       {
+                               sessionidt first_ses = bundle[i].members[0];
+                               if (bundle[i].mssf != session[s].mssf)
+                               {
+                                       // uniformity of sequence number format must be insured
+                                       LOG(3, s, session[s].tunnel, "MPPP: unable to bundle session %d in bundle %d cause of different mssf\n", s, i);
+                                       return -1;
+                               }
+                               session[s].bundle = i;
+                               session[s].ip = session[first_ses].ip;
+                               session[s].dns1 = session[first_ses].dns1;
+                               session[s].dns2 = session[first_ses].dns2;
+                               session[s].timeout = session[first_ses].timeout;
+
+                               if(session[s].epdis.length > 0)
+                                       setepdis(&bundle[i].epdis, session[s].epdis);
+
+                               strcpy(bundle[i].user, session[s].user);
+                               bundle[i].members[bundle[i].num_of_links] = s;
+                               bundle[i].num_of_links++;
+                               LOG(3, s, session[s].tunnel, "MPPP: Bundling additional line in bundle (%d), lines:%d\n",i,bundle[i].num_of_links);
+                               return i;
+                       }
+               }
+       }
+
+       // No previously created bundle was found for this session, so create a new one
+       if (!(b = new_bundle())) return 0;
+
+       session[s].bundle = b;
+       bundle[b].mrru = session[s].mrru;
+       bundle[b].mssf = session[s].mssf;
+       // FIXME !!! to enable l2tpns reading mssf frames receiver_max_seq, sender_max_seq must be introduce
+       // now session[s].mssf flag indecates that the receiver wish to receive frames in mssf, so max_seq (i.e. recv_max_seq) = 1<<24
+       /*
+       if (bundle[b].mssf)
+               bundle[b].max_seq = 1 << 12;
+       else */
+               bundle[b].max_seq = 1 << 24;
+       if(session[s].epdis.length > 0)
+               setepdis(&bundle[b].epdis, session[s].epdis);
+
+       strcpy(bundle[b].user, session[s].user);
+       bundle[b].members[0] = s;
+       bundle[b].timeout = session[s].timeout;
+       LOG(3, s, session[s].tunnel, "MPPP: Created a new bundle (%d)\n", b);
+       return b;
+}
+
+static int epdiscmp(epdist ep1, epdist ep2)
+{
+       int ad;
+       if (ep1.length != ep2.length)
+               return 0;
+
+       if (ep1.addr_class != ep2.addr_class)
+               return 0;
+
+       for (ad = 0; ad < ep1.length; ad++)
+               if (ep1.address[ad] != ep2.address[ad])
+                       return 0;
+
+       return 1;
+}
+
+static void setepdis(epdist *ep1, epdist ep2)
+{
+       int ad;
+       ep1->length = ep2.length;
+       ep1->addr_class = ep2.addr_class;
+       for (ad = 0; ad < ep2.length; ad++)
+               ep1->address[ad] = ep2.address[ad];
+}
+
+static bundleidt new_bundle()
+{
+        bundleidt i;
+        for (i = 1; i < MAXBUNDLE; i++)
+        {
+                if (bundle[i].state == BUNDLEFREE)
+                {
+                        LOG(4, 0, 0, "MPPP: Assigning bundle ID %d\n", i);
+                        bundle[i].num_of_links = 1;
+                        bundle[i].last_check = time_now;        // Initialize last_check value
+                        bundle[i].state = BUNDLEOPEN;
+                        bundle[i].current_ses = -1;     // This is to enforce the first session 0 to be used at first
+                       memset(&frag[i], 0, sizeof(fragmentationt));
+                        if (i > config->cluster_highest_bundleid)
+                                config->cluster_highest_bundleid = i;
+                        return i;
+                }
+        }
+        LOG(0, 0, 0, "MPPP: Can't find a free bundle! There shouldn't be this many in use!\n");
+        return 0;
+}
+
 static void ipcp_open(sessionidt s, tunnelidt t)
 {
        LOG(3, s, t, "IPCP: Opened, session is now active\n");
 static void ipcp_open(sessionidt s, tunnelidt t)
 {
        LOG(3, s, t, "IPCP: Opened, session is now active\n");
@@ -1039,7 +1309,7 @@ void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                                        q = ppp_conf_nak(s, b, sizeof(b), PPPIPCP, &response, q, p, o, (uint8_t *) &addr, sizeof(addr));
                                        if (!q || (q != oq && *response == ConfigRej))
                                        {
                                        q = ppp_conf_nak(s, b, sizeof(b), PPPIPCP, &response, q, p, o, (uint8_t *) &addr, sizeof(addr));
                                        if (!q || (q != oq && *response == ConfigRej))
                                        {
-                                               sessionshutdown(s, "Can't negotiate IPCP.", 3, 0);
+                                               sessionshutdown(s, "Can't negotiate IPCP.", CDN_ADMIN_DISC, TERM_USER_ERROR);
                                                return;
                                        }
                                }
                                                return;
                                        }
                                }
@@ -1088,7 +1358,7 @@ void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                else if (gotip)
                {
                        // Send packet back as ConfigAck
                else if (gotip)
                {
                        // Send packet back as ConfigAck
-                       response = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP);
+                       response = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP, 0, 0, 0);
                        if (!response) return;
                        *response = ConfigAck;
                }
                        if (!response) return;
                        *response = ConfigAck;
                }
@@ -1102,7 +1372,7 @@ void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                switch (session[s].ppp.ipcp)
                {
                case Closed:
                switch (session[s].ppp.ipcp)
                {
                case Closed:
-                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPCP);
+                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPCP, 0, 0, 0);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
@@ -1153,12 +1423,33 @@ void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        }
        else if (*p == TerminateReq)
        {
        }
        else if (*p == TerminateReq)
        {
-               *p = TerminateAck;
-               q = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP);
+               switch (session[s].ppp.ipcp)
+               {
+               case Closed:
+               case Stopped:
+               case Closing:
+               case Stopping:
+               case RequestSent:
+               case AckReceived:
+               case AckSent:
+                       break;
+
+               case Opened:
+                       zero_restart_count(s, ipcp);
+                       change_state(s, ipcp, Closing);
+                       break;
+
+               default:
+                       LOG(2, s, t, "IPCP: ignoring %s in state %s\n", ppp_code(*p), ppp_state(session[s].ppp.ipcp));
+                       return;
+               }
+
+               *p = TerminateAck;      // send ack
+               q = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP, 0, 0, 0);
                if (!q) return;
                if (!q) return;
+
                LOG(3, s, t, "IPCP: send %s\n", ppp_code(*q));
                LOG(3, s, t, "IPCP: send %s\n", ppp_code(*q));
-               tunnelsend(b, l + (q - b), t);
-               change_state(s, ipcp, Stopped);
+               tunnelsend(b, l + (q - b), t); // send it
        }
        else if (*p != CodeRej)
        {
        }
        else if (*p != CodeRej)
        {
@@ -1247,7 +1538,7 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                uint8_t *o = p + 4;
                int length = l - 4;
                int gotip = 0;
                uint8_t *o = p + 4;
                int length = l - 4;
                int gotip = 0;
-               uint8_t ident[8];
+               uint32_t ident[2];
 
                while (length > 2)
                {
 
                while (length > 2)
                {
@@ -1259,12 +1550,12 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                                gotip++; // seen address
                                if (o[1] != 10) return;
 
                                gotip++; // seen address
                                if (o[1] != 10) return;
 
-                               *(uint32_t *) ident = htonl(session[s].ip);
-                               *(uint32_t *) (ident + 4) = 0;
+                               ident[0] = htonl(session[s].ip);
+                               ident[1] = 0;
 
                                if (memcmp(o + 2, ident, sizeof(ident)))
                                {
 
                                if (memcmp(o + 2, ident, sizeof(ident)))
                                {
-                                       q = ppp_conf_nak(s, b, sizeof(b), PPPIPV6CP, &response, q, p, o, ident, sizeof(ident));
+                                       q = ppp_conf_nak(s, b, sizeof(b), PPPIPV6CP, &response, q, p, o, (uint8_t *)ident, sizeof(ident));
                                        if (!q) return;
                                }
 
                                        if (!q) return;
                                }
 
@@ -1288,7 +1579,7 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                else if (gotip)
                {
                        // Send packet back as ConfigAck
                else if (gotip)
                {
                        // Send packet back as ConfigAck
-                       response = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP);
+                       response = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP, 0, 0, 0);
                        if (!response) return;
                        *response = ConfigAck;
                }
                        if (!response) return;
                        *response = ConfigAck;
                }
@@ -1302,7 +1593,7 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                switch (session[s].ppp.ipv6cp)
                {
                case Closed:
                switch (session[s].ppp.ipv6cp)
                {
                case Closed:
-                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPV6CP);
+                       response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPV6CP, 0, 0, 0);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
                        if (!response) return;
                        *response = TerminateAck;
                        *((uint16_t *) (response + 2)) = htons(l = 4);
@@ -1353,12 +1644,33 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        }
        else if (*p == TerminateReq)
        {
        }
        else if (*p == TerminateReq)
        {
-               *p = TerminateAck;
-               q = makeppp(b, sizeof(b),  p, l, s, t, PPPIPV6CP);
+               switch (session[s].ppp.ipv6cp)
+               {
+               case Closed:
+               case Stopped:
+               case Closing:
+               case Stopping:
+               case RequestSent:
+               case AckReceived:
+               case AckSent:
+                       break;
+
+               case Opened:
+                       zero_restart_count(s, ipv6cp);
+                       change_state(s, ipv6cp, Closing);
+                       break;
+
+               default:
+                       LOG(2, s, t, "IPV6CP: ignoring %s in state %s\n", ppp_code(*p), ppp_state(session[s].ppp.ipv6cp));
+                       return;
+               }
+
+               *p = TerminateAck;      // send ack
+               q = makeppp(b, sizeof(b),  p, l, s, t, PPPIPV6CP, 0, 0, 0);
                if (!q) return;
                if (!q) return;
+
                LOG(3, s, t, "IPV6CP: send %s\n", ppp_code(*q));
                LOG(3, s, t, "IPV6CP: send %s\n", ppp_code(*q));
-               tunnelsend(b, l + (q - b), t);
-               change_state(s, ipv6cp, Stopped);
+               tunnelsend(b, l + (q - b), t); // send it
        }
        else if (*p != CodeRej)
        {
        }
        else if (*p != CodeRej)
        {
@@ -1366,6 +1678,39 @@ void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        }
 }
 
        }
 }
 
+static void update_sessions_in_stat(sessionidt s, uint16_t l)
+{
+       bundleidt b = session[s].bundle;
+       if (!b)
+       {
+               increment_counter(&session[s].cin, &session[s].cin_wrap, l);
+               session[s].cin_delta += l;
+                       session[s].pin++;
+
+               sess_local[s].cin += l;
+               sess_local[s].pin++;
+       }
+       else
+       {
+               int i = frag[b].re_frame_begin_index;
+               int end = frag[b].re_frame_end_index;
+               for (;;)
+               {
+                       l = frag[b].fragment[i].length;
+                       s = frag[b].fragment[i].sid;
+                       increment_counter(&session[s].cin, &session[s].cin_wrap, l);
+                       session[s].cin_delta += l;
+                               session[s].pin++;
+
+                       sess_local[s].cin += l;
+                       sess_local[s].pin++;
+                       if (i == end)
+                               return;
+                       i = (i + 1) & MAXFRAGNUM_MASK;
+               }
+       }
+}
+
 // process IP packet received
 //
 // This MUST be called with at least 4 byte behind 'p'.
 // process IP packet received
 //
 // This MUST be called with at least 4 byte behind 'p'.
@@ -1397,11 +1742,14 @@ void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        if (session[s].ppp.phase != Network || session[s].ppp.ipcp != Opened)
                return;
 
        if (session[s].ppp.phase != Network || session[s].ppp.ipcp != Opened)
                return;
 
-       // no spoof (do sessionbyip to handled statically routed subnets)
-       if (ip != session[s].ip && sessionbyip(htonl(ip)) != s)
+       if (!session[s].bundle || bundle[session[s].bundle].num_of_links < 2) // FIXME: 
        {
        {
-               LOG(5, s, t, "Dropping packet with spoofed IP %s\n", fmtaddr(htonl(ip), 0));
-               return;
+               // no spoof (do sessionbyip to handled statically routed subnets)
+               if (ip != session[s].ip && sessionbyip(htonl(ip)) != s)
+               {
+                       LOG(4, s, t, "Dropping packet with spoofed IP %s\n", fmtaddr(htonl(ip), 0));
+                       return;
+               }
        }
 
        // run access-list if any
        }
 
        // run access-list if any
@@ -1421,17 +1769,13 @@ void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        *(uint32_t *) p = htonl(PKTIP);
        l += 4;
 
        *(uint32_t *) p = htonl(PKTIP);
        l += 4;
 
-       // Are we throttled and a slave?
-       if (session[s].tbf_in && !config->cluster_iam_master) {
-               // Pass it to the master for handling.
-               master_throttle_packet(session[s].tbf_in, p, l);
-               return;
-       }
-
-       // Are we throttled and a master??
-       if (session[s].tbf_in && config->cluster_iam_master) {
-               // Actually handle the throttled packets.
-               tbf_queue_packet(session[s].tbf_in, p, l);
+       if (session[s].tbf_in)
+       {
+               // Are we throttling this session?
+               if (config->cluster_iam_master)
+                       tbf_queue_packet(session[s].tbf_in, p, l);
+               else
+                       master_throttle_packet(session[s].tbf_in, p, l);
                return;
        }
 
                return;
        }
 
@@ -1454,12 +1798,7 @@ void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
 
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
 
-       increment_counter(&session[s].cin, &session[s].cin_wrap, l);
-       session[s].cin_delta += l;
-       session[s].pin++;
-
-       sess_local[s].cin += l;
-       sess_local[s].pin++;
+       update_sessions_in_stat(s, l);
 
        eth_tx += l;
 
 
        eth_tx += l;
 
@@ -1467,6 +1806,195 @@ void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
        INC_STAT(tun_tx_bytes, l);
 }
 
        INC_STAT(tun_tx_bytes, l);
 }
 
+// process Multilink PPP packet received
+void processmpin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
+{
+        bundleidt b = session[s].bundle;
+       bundlet * this_bundle = &bundle[b];
+       uint32_t frag_offset, M_offset;
+       uint16_t frag_index, M_index;
+       fragmentationt *this_fragmentation = &frag[b];
+       uint8_t begin_frame = (*p & MP_BEGIN);
+        uint8_t end_frame = (*p & MP_END);
+        uint32_t seq_num;
+       uint8_t flags = *p;
+       uint16_t begin_index, end_index;
+
+       // Perform length checking
+        if(l > MAXFRAGLEN)
+        {
+               LOG(2, s, t, "MPPP: discarding fragment larger than MAXFRAGLEN\n");
+               return;
+        }
+
+        if(!b)
+        {
+                LOG(2, s, t, "MPPP: Invalid bundle id: 0\n");
+                return;
+        }
+       // FIXME !! session[s].mssf means that the receiver wants to receive frames in mssf not means the receiver will send frames in mssf
+        /* if(session[s].mssf)
+        {
+                // Get 12 bit for seq number
+                seq_num = ntohs((*(uint16_t *) p) & 0xFF0F);
+                p += 2;
+                l -= 2;
+                // After this point the pointer should be advanced 2 bytes
+                LOG(3, s, t, "MPPP: 12 bits, sequence number: %d\n",seq_num);
+        }
+        else */
+        {
+                // Get 24 bit for seq number
+                seq_num = ntohl((*(uint32_t *) p) & 0xFFFFFF00);
+                p += 4;
+                l -= 4;
+                // After this point the pointer should be advanced 4 bytes
+                LOG(4, s, t, "MPPP: 24 bits sequence number:%d\n",seq_num);
+        }
+
+       // calculate this fragment's offset from the begin seq in the bundle
+       frag_offset = (seq_num + this_bundle->max_seq - this_fragmentation->start_seq) & (this_bundle->max_seq-1);
+
+       // discard this fragment if frag_offset is bigger that the fragmentation buffer size
+       if (frag_offset >= MAXFRAGNUM)
+        {
+               LOG(3, s, t, "MPPP: Index out of range, received more than MAXFRAGNUM fragment (lost frag) seq:%d, begin_seq:%d, bundle:%d, max:%d\n",seq_num, this_fragmentation->start_seq, b, this_bundle->max_seq);
+                return;
+        }
+       
+       // update M
+       sess_local[s].last_seq = seq_num;
+       if (seq_num < this_fragmentation->M)
+               this_fragmentation->M = seq_num;
+       else
+       {
+               uint32_t i, min = sess_local[(this_bundle->members[0])].last_seq;;
+               for (i = 1; i < this_bundle->num_of_links; i++)
+               {
+                       uint32_t s_seq = sess_local[(this_bundle->members[i])].last_seq; 
+                       if (s_seq < min)
+                               min = s_seq;
+               }
+               this_fragmentation->M = min;
+       }
+
+       LOG(4, s, t, "MPPP: Setting M to %d\n", this_fragmentation->M); 
+       //calculate M's offset from the begin seq in the bundle
+       M_offset = (this_fragmentation->M + this_bundle->max_seq - this_fragmentation->start_seq) & (this_bundle->max_seq-1);
+
+       //caculate M's index in the fragment array
+       M_index = (M_offset + this_fragmentation->start_index) & MAXFRAGNUM_MASK;
+       
+       //caculate received fragment's index in the fragment array
+       frag_index = (frag_offset + this_fragmentation->start_index) & MAXFRAGNUM_MASK;
+
+       //frame with a single fragment
+       if (begin_frame && end_frame)
+       {
+               // process and reset fragmentation
+                LOG(4, s, t, "MPPP: Both bits are set (Begin and End).\n");
+               this_fragmentation->fragment[frag_index].length = l;
+               this_fragmentation->fragment[frag_index].sid = s;
+               this_fragmentation->fragment[frag_index].flags = flags;
+               this_fragmentation->fragment[frag_index].seq = seq_num;
+               this_fragmentation->re_frame_begin_index = frag_index;
+               this_fragmentation->re_frame_end_index = frag_index;
+               processmpframe(s, t, p, l, 0);
+               this_fragmentation->fragment[frag_index].length = 0;
+               this_fragmentation->fragment[frag_index].flags = 0;
+               end_index = frag_index;
+       }
+       else
+       {
+               // insert the frame in it's place
+               fragmentt *this_frag = &this_fragmentation->fragment[frag_index];
+               this_frag->length = l;
+               this_frag->sid = s;
+               this_frag->flags = flags;
+               this_frag->seq = seq_num;
+                memcpy(this_frag->data, p, l);
+
+               // try to assemble the frame that has the received fragment as a member         
+               // get the beginning of this frame
+               begin_index = end_index = frag_index;
+               while (this_fragmentation->fragment[begin_index].length)
+               {
+                       if (this_fragmentation->fragment[begin_index].flags & MP_BEGIN)
+                               break;
+                       begin_index = (begin_index ? (begin_index -1) : (MAXFRAGNUM -1)); 
+               }
+
+               // return if a lost fragment is found
+               if (!(this_fragmentation->fragment[begin_index].length))
+                       return; // assembling frame failed
+               // get the end of his frame
+               while (this_fragmentation->fragment[end_index].length)
+               {
+                       if (this_fragmentation->fragment[end_index].flags & MP_END)
+                               break;
+                       end_index = (end_index +1) & MAXFRAGNUM_MASK; 
+               }
+
+               // return if a lost fragment is found
+               if (!(this_fragmentation->fragment[end_index].length))
+                       return; // assembling frame failed
+
+               // assemble the packet
+               //assemble frame, process it, reset fragmentation
+               uint16_t cur_len = 4;   // This is set to 4 to leave 4 bytes for function processipin
+               uint32_t i;
+
+                       LOG(4, s, t, "MPPP: processing fragments from %d to %d\n", begin_index, end_index);
+                       // Push to the receive buffer
+                                       
+               for (i = begin_index;; i = (i + 1) & MAXFRAGNUM_MASK)
+                {
+                       this_frag = &this_fragmentation->fragment[i];
+                        if(cur_len + this_frag->length > MAXETHER)
+                        {
+                                LOG(2, s, t, "MPPP: discarding reassembled frames larger than MAXETHER\n");                            
+                                break;
+                        }
+                        memcpy(this_fragmentation->reassembled_frame+cur_len, this_frag->data, this_frag->length);
+                       LOG(5, s, t, "MPPP: processing frame at %d, with len %d\n", i, this_frag->length);
+                        cur_len += this_frag->length;
+                       if (i == end_index)
+                       {
+                               this_fragmentation->re_frame_len = cur_len;
+                               this_fragmentation->re_frame_begin_index = begin_index;
+                               this_fragmentation->re_frame_end_index = end_index;
+                               // Process the resassembled frame
+                               LOG(5, s, t, "MPPP: Process the reassembled frame, len=%d\n",cur_len);
+                               processmpframe(s, t, this_fragmentation->reassembled_frame, this_fragmentation->re_frame_len, 1);
+                               break;
+                       }
+                }
+                // Set reassembled frame length to zero after processing it
+                this_fragmentation->re_frame_len = 0;
+               for (i = begin_index;; i = (i + 1) & MAXFRAGNUM_MASK)
+               {
+                       this_fragmentation->fragment[i].length = 0;      // Indicates that this fragment has been consumed
+                       this_fragmentation->fragment[i].flags = 0;
+                       if (i == end_index)
+                               break;
+               }
+       }
+       //discard fragments received before the recently assembled frame
+       begin_index = this_fragmentation->start_index;
+       this_fragmentation->start_index = (end_index + 1) & MAXFRAGNUM_MASK;
+        this_fragmentation->start_seq = (this_fragmentation->fragment[end_index].seq + 1) & (this_bundle->max_seq-1);
+       //clear length and flags of the discarded fragments
+       while (begin_index != this_fragmentation->start_index)
+        {
+                this_fragmentation->fragment[begin_index].flags = 0;
+               this_fragmentation->fragment[begin_index].length = 0;
+                begin_index = (begin_index + 1) & MAXFRAGNUM_MASK;
+        }
+
+       LOG(4, s, t, "MPPP after assembling: M index is =%d, start index is = %d, start seq=%d\n",M_index, this_fragmentation->start_index, this_fragmentation->start_seq);     
+       return;
+}
+
 // process IPv6 packet received
 //
 // This MUST be called with at least 4 byte behind 'p'.
 // process IPv6 packet received
 //
 // This MUST be called with at least 4 byte behind 'p'.
@@ -1550,12 +2078,7 @@ void processipv6in(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
 
                snoop_send_packet(p, l, session[s].snoop_ip, session[s].snoop_port);
        }
 
-       increment_counter(&session[s].cin, &session[s].cin_wrap, l);
-       session[s].cin_delta += l;
-       session[s].pin++;
-
-       sess_local[s].cin += l;
-       sess_local[s].pin++;
+       update_sessions_in_stat(s, l);
 
        eth_tx += l;
 
 
        eth_tx += l;
 
@@ -1626,7 +2149,7 @@ void processccp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                STAT(tunnel_rx_errors);
        }
 
                STAT(tunnel_rx_errors);
        }
 
-       LOG(3, s, t, "CCP: recv %s\n", ppp_code(*p));
+       LOG(4, s, t, "CCP: recv %s\n", ppp_code(*p));
        if (*p == ConfigAck)
        {
                switch (session[s].ppp.ccp)
        if (*p == ConfigAck)
        {
                switch (session[s].ppp.ccp)
@@ -1659,13 +2182,13 @@ void processccp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                else // compression requested--reject
                        *p = ConfigRej;
 
                else // compression requested--reject
                        *p = ConfigRej;
 
-               q = makeppp(b, sizeof(b), p, l, s, t, PPPCCP);
+               q = makeppp(b, sizeof(b), p, l, s, t, PPPCCP, 0, 0, 0);
                if (!q) return;
 
                switch (session[s].ppp.ccp)
                {
                case Closed:
                if (!q) return;
 
                switch (session[s].ppp.ccp)
                {
                case Closed:
-                       q = makeppp(b, sizeof(b), p, 2, s, t, PPPCCP);
+                       q = makeppp(b, sizeof(b), p, 2, s, t, PPPCCP, 0, 0, 0);
                        if (!q) return;
                        *q = TerminateAck;
                        *((uint16_t *) (q + 2)) = htons(l = 4);
                        if (!q) return;
                        *q = TerminateAck;
                        *((uint16_t *) (q + 2)) = htons(l = 4);
@@ -1711,13 +2234,13 @@ void processccp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
                        return;
                }
 
                        return;
                }
 
-               LOG(3, s, t, "CCP: send %s\n", ppp_code(*q));
+               LOG(4, s, t, "CCP: send %s\n", ppp_code(*q));
                tunnelsend(b, l + (q - b), t);
        }
        else if (*p == TerminateReq)
        {
                *p = TerminateAck;
                tunnelsend(b, l + (q - b), t);
        }
        else if (*p == TerminateReq)
        {
                *p = TerminateAck;
-               q = makeppp(b, sizeof(b),  p, l, s, t, PPPCCP);
+               q = makeppp(b, sizeof(b),  p, l, s, t, PPPCCP, 0, 0, 0);
                if (!q) return;
                LOG(3, s, t, "CCP: send %s\n", ppp_code(*q));
                tunnelsend(b, l + (q - b), t);
                if (!q) return;
                LOG(3, s, t, "CCP: send %s\n", ppp_code(*q));
                tunnelsend(b, l + (q - b), t);
@@ -1757,11 +2280,11 @@ void sendchap(sessionidt s, tunnelidt t)
        radius[r].retry = backoff(radius[r].try++);
        if (radius[r].try > 5)
        {
        radius[r].retry = backoff(radius[r].try++);
        if (radius[r].try > 5)
        {
-               sessionshutdown(s, "CHAP timeout.", 3, 0);
+               sessionshutdown(s, "CHAP timeout.", CDN_ADMIN_DISC, TERM_REAUTHENTICATION_FAILURE);
                STAT(tunnel_tx_errors);
                return ;
        }
                STAT(tunnel_tx_errors);
                return ;
        }
-       q = makeppp(b, sizeof(b), 0, 0, s, t, PPPCHAP);
+       q = makeppp(b, sizeof(b), 0, 0, s, t, PPPCHAP, 0, 0, 0);
        if (!q) return;
 
        *q = 1;                                 // challenge
        if (!q) return;
 
        *q = 1;                                 // challenge
@@ -1775,37 +2298,86 @@ void sendchap(sessionidt s, tunnelidt t)
 
 // fill in a L2TP message with a PPP frame,
 // returns start of PPP frame
 
 // fill in a L2TP message with a PPP frame,
 // returns start of PPP frame
-uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, sessionidt s, tunnelidt t, uint16_t mtype)
+uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, sessionidt s, tunnelidt t, uint16_t mtype, uint8_t prio, bundleidt bid, uint8_t mp_bits)
 {
 {
-       if (size < 12) // Need more space than this!!
+       uint16_t hdr = 0x0002; // L2TP with no options
+       uint16_t type = mtype;
+       uint8_t *start = b;
+
+       if (size < 16) // Need more space than this!!
        {
                LOG(0, s, t, "makeppp buffer too small for L2TP header (size=%d)\n", size);
                return NULL;
        }
 
        {
                LOG(0, s, t, "makeppp buffer too small for L2TP header (size=%d)\n", size);
                return NULL;
        }
 
-       *(uint16_t *) (b + 0) = htons(0x0002); // L2TP with no options
+       if (prio) hdr |= 0x0100; // set priority bit
+
+       *(uint16_t *) (b + 0) = htons(hdr);
        *(uint16_t *) (b + 2) = htons(tunnel[t].far); // tunnel
        *(uint16_t *) (b + 4) = htons(session[s].far); // session
        b += 6;
        *(uint16_t *) (b + 2) = htons(tunnel[t].far); // tunnel
        *(uint16_t *) (b + 4) = htons(session[s].far); // session
        b += 6;
-       if (mtype == PPPLCP || !(session[s].flags & SESSION_ACFC))
+
+       // Check whether this session is part of multilink
+       if (bid)
+       {
+               if (bundle[bid].num_of_links > 1)
+                       type = PPPMP; // Change PPP message type to the PPPMP
+               else
+                       bid = 0;
+       }
+
+       if (type == PPPLCP || !(session[s].flags & SESSION_ACFC))
        {
                *(uint16_t *) b = htons(0xFF03); // HDLC header
                b += 2;
        }
        {
                *(uint16_t *) b = htons(0xFF03); // HDLC header
                b += 2;
        }
-       if (mtype < 0x100 && session[s].flags & SESSION_PFC)
-               *b++ = mtype;
+
+       if (type < 0x100 && session[s].flags & SESSION_PFC)
+       {
+               *b++ = type;
+       }
        else
        {
        else
        {
-               *(uint16_t *) b = htons(mtype);
+               *(uint16_t *) b = htons(type);
                b += 2;
        }
 
                b += 2;
        }
 
-       if (l + 12 > size)
+       if (bid)
        {
        {
-               LOG(2, s, t, "makeppp would overflow buffer (size=%d, header+payload=%d)\n", size, l + 12);
+               // Set the sequence number and (B)egin (E)nd flags
+               if (session[s].mssf)
+               {
+                       // Set the multilink bits
+                       uint16_t bits_send = mp_bits;
+                       *(uint16_t *) b = htons((bundle[bid].seq_num_t & 0x0FFF)|bits_send);
+                       b += 2;
+               }
+               else
+               {
+                       *(uint32_t *) b = htonl(bundle[bid].seq_num_t);
+                       // Set the multilink bits
+                       *b = mp_bits;
+                       b += 4;
+               }
+
+               bundle[bid].seq_num_t++;
+
+               // Add the message type if this fragment has the begin bit set
+               if (mp_bits & MP_BEGIN)
+               {
+                       //*b++ = mtype; // The next two lines are instead of this 
+                       *(uint16_t *) b = htons(mtype); // Message type
+                       b += 2;
+               }
+       }
+
+       if ((b - start) + l > size)
+       {
+               LOG(2, s, t, "makeppp would overflow buffer (size=%d, header+payload=%ld)\n", size, (b - start) + l);
                return NULL;
        }
 
                return NULL;
        }
 
+       // Copy the payload
        if (p && l)
                memcpy(b, p, l);
 
        if (p && l)
                memcpy(b, p, l);
 
@@ -1844,10 +2416,10 @@ void sendlcp(sessionidt s, tunnelidt t)
        uint8_t b[500], *q, *l;
        int authtype = sess_local[s].lcp_authtype;
 
        uint8_t b[500], *q, *l;
        int authtype = sess_local[s].lcp_authtype;
 
-       if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPLCP)))
+        if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPLCP, 0, 0, 0)))
                return;
 
                return;
 
-       LOG(3, s, t, "LCP: send ConfigReq%s%s%s\n",
+        LOG(3, s, t, "LCP: send ConfigReq%s%s%s including MP options\n",
            authtype ? " (" : "",
            authtype ? (authtype == AUTHCHAP ? "CHAP" : "PAP") : "",
            authtype ? ")" : "");
            authtype ? " (" : "",
            authtype ? (authtype == AUTHCHAP ? "CHAP" : "PAP") : "",
            authtype ? ")" : "");
@@ -1874,6 +2446,20 @@ void sendlcp(sessionidt s, tunnelidt t)
                l += 4;
        }
 
                l += 4;
        }
 
+        if (sess_local[s].mp_mrru)
+        {
+               *l++ = 17; *l++ = 4; // Multilink Max-Receive-Reconstructed-Unit (length 4)
+               *(uint16_t *) l = htons(sess_local[s].mp_mrru); l += 2;
+       }
+
+        if (sess_local[s].mp_epdis)
+        {
+               *l++ = 19; *l++ = 7;    // Multilink Endpoint Discriminator (length 7)
+               *l++ = IPADDR;  // Endpoint Discriminator class
+               *(uint32_t *) l = htonl(sess_local[s].mp_epdis);
+               l += 4;
+       }
+
        *(uint16_t *)(q + 2) = htons(l - q); // Length
 
        LOG_HEX(5, "PPPLCP", q, l - q);
        *(uint16_t *)(q + 2) = htons(l - q); // Length
 
        LOG_HEX(5, "PPPLCP", q, l - q);
@@ -1888,7 +2474,7 @@ void sendccp(sessionidt s, tunnelidt t)
 {
        uint8_t b[500], *q;
 
 {
        uint8_t b[500], *q;
 
-       if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPCCP)))
+       if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPCCP, 0, 0, 0)))
                return;
 
        LOG(3, s, t, "CCP: send ConfigReq (no compression)\n");
                return;
 
        LOG(3, s, t, "CCP: send ConfigReq (no compression)\n");
@@ -1915,7 +2501,7 @@ void protoreject(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l, uint16_t pro
        l += 6;
        if (l > mru) l = mru;
 
        l += 6;
        if (l > mru) l = mru;
 
-       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPLCP);
+       q = makeppp(buf, sizeof(buf), 0, 0, s, t, PPPLCP, 0, 0, 0);
        if (!q) return;
 
        *q = ProtocolRej;
        if (!q) return;
 
        *q = ProtocolRej;