#include <u.h>
#include <libc.h>
#include <ip.h>
#include <libsec.h>
#include "dat.h"
#include "protos.h"

/* PPP stuff */
enum {
       PPP_addr=       0xff,
       PPP_ctl=        0x3,
       PPP_period=     3*1000, /* period of retransmit process (in ms) */
};

/* PPP protocols */
enum {
       PPP_ip=         0x21,           /* internet */
       PPP_vjctcp=     0x2d,           /* compressing van jacobson tcp */
       PPP_vjutcp=     0x2f,           /* uncompressing van jacobson tcp */
       PPP_ml=         0x3d,           /* multi link */
       PPP_comp=       0xfd,           /* compressed packets */
       PPP_ipcp=       0x8021,         /* ip control */
       PPP_ccp=        0x80fd,         /* compression control */
       PPP_passwd=     0xc023,         /* passwd authentication */
       PPP_lcp=        0xc021,         /* link control */
       PPP_lqm=        0xc025,         /* link quality monitoring */
       PPP_chap=       0xc223,         /* challenge/response */
};

/* LCP protocol (and IPCP) */


typedef struct Lcppkt   Lcppkt;
struct Lcppkt
{
       uchar   code;
       uchar   id;
       uchar   len[2];
       uchar   data[1];
};

typedef struct Lcpopt   Lcpopt;
struct Lcpopt
{
       uchar   type;
       uchar   len;
       uchar   data[1];
};

enum
{
       /* LCP codes */
       Lconfreq=       1,
       Lconfack=       2,
       Lconfnak=       3,
       Lconfrej=       4,
       Ltermreq=       5,
       Ltermack=       6,
       Lcoderej=       7,
       Lprotorej=      8,
       Lechoreq=       9,
       Lechoack=       10,
       Ldiscard=       11,
       Lresetreq=      14,     /* for ccp only */
       Lresetack=      15,     /* for ccp only */

       /* Lcp configure options */
       Omtu=           1,
       Octlmap=        2,
       Oauth=          3,
       Oquality=       4,
       Omagic=         5,
       Opc=            7,
       Oac=            8,

       /* authentication protocols */
       APmd5=          5,
       APmschap=       128,

       /* Chap codes */
       Cchallenge=     1,
       Cresponse=      2,
       Csuccess=       3,
       Cfailure=       4,

       /* ipcp configure options */
       Oipaddrs=       1,
       Oipcompress=    2,
       Oipaddr=        3,
       Oipdns=         129,
       Oipwins=        130,
       Oipdns2=        131,
       Oipwins2=       132,
};

char *
lcpcode[] = {
       0,
       "confreq",
       "confack",
       "confnak",
       "confrej",
       "termreq",
       "termack",
       "coderej",
       "protorej",
       "echoreq",
       "echoack",
       "discard",
       "id",
       "timeremain",
       "resetreq",
       "resetack",
};

static Mux p_mux[] =
{
       {"ip",          PPP_ip, },
       {"ppp_vjctcp",  PPP_vjctcp, },
       {"ppp_vjutcp",  PPP_vjutcp, },
       {"ppp_ml",      PPP_ml, },
       {"ppp_comp",    PPP_comp, },
       {"ppp_ipcp",    PPP_ipcp, },
       {"ppp_ccp",     PPP_ccp, },
       {"ppp_passwd",  PPP_passwd, },
       {"ppp_lcp",     PPP_lcp, },
       {"ppp_lqm",     PPP_lqm, },
       {"ppp_chap",    PPP_chap, },
       {0},
};

enum
{
       OOproto,
};

static void
p_compile(Filter *f)
{
       Mux *m;

       for(m = p_mux; m->name != nil; m++)
               if(strcmp(f->s, m->name) == 0){
                       f->pr = m->pr;
                       f->ulv = m->val;
                       f->subop = OOproto;
                       return;
               }

       sysfatal("unknown ppp field or protocol: %s", f->s);
}

static int
p_filter(Filter *f, Msg *m)
{
       int proto;
       int len;

       if(f->subop != OOproto)
               return 0;

       len = m->pe - m->ps;
       if(len < 3)
               return -1;

       if(m->ps[0] == PPP_addr && m->ps[1] == PPP_ctl)
               m->ps += 2;

       proto = *m->ps++;
       if((proto&1) == 0)
               proto = (proto<<8) | *m->ps++;

       if(proto == f->ulv)
               return 1;

       return 0;
}

static int
p_seprint(Msg *m)
{
       int proto;
       int len;

       len = m->pe - m->ps;
       if(len < 3)
               return -1;

       if(m->ps[0] == PPP_addr && m->ps[1] == PPP_ctl)
               m->ps += 2;

       proto = *m->ps++;
       if((proto&1) == 0)
               proto = (proto<<8) | *m->ps++;

       m->p = seprint(m->p, m->e, "pr=%ud len=%d", proto, len);
       demux(p_mux, proto, proto, m, &dump);

       return 0;
}

static int
p_seprintchap(Msg *m)
{
       Lcppkt *lcp;
       char *p, *e;
       int len;

       if(m->pe-m->ps < 4)
               return -1;

       p = m->p;
       e = m->e;
       m->pr = nil;

       /* resize packet */
       lcp = (Lcppkt*)m->ps;
       len = NetS(lcp->len);
       if(m->ps+len < m->pe)
               m->pe = m->ps+len;
       else if(m->ps+len > m->pe)
               return -1;

       p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
       switch(lcp->code) {
       default:
               p = seprint(p, e, " data=%.*H", len>64?64:len, lcp->data);
               break;
       case 1:
       case 2:
               if(lcp->data[0] > len-4){
                       p = seprint(p, e, "%.*H", len-4, lcp->data);
               } else {
                       p = seprint(p, e, " %s=", lcp->code==1?"challenge ":"response ");
                       p = seprint(p, e, "%.*H", lcp->data[0], lcp->data+1);
                       p = seprint(p, e, " name=");
                       p = seprint(p, e, "%.*H", len-4-lcp->data[0]-1, lcp->data+lcp->data[0]+1);
               }
               break;
       case 3:
       case 4:
               if(len > 64)
                       len = 64;
               p = seprint(p, e, " %s=%.*H", lcp->code==3?"success ":"failure",
                               len>64?64:len, lcp->data);
               break;
       }
       m->p = seprint(p, e, " len=%d", len);
       return 0;
}

static char*
seprintlcpopt(char *p, char *e, void *a, int len)
{
       Lcpopt *o;
       int proto, x, period;
       uchar *cp, *ecp;

       cp = a;
       ecp = cp+len;

       for(; cp < ecp; cp += o->len){
               o = (Lcpopt*)cp;
               if(cp + o->len > ecp || o->len == 0){
                       p = seprint(p, e, " bad-opt-len=%d", o->len);
                       return p;
               }

               switch(o->type){
               default:
                       p = seprint(p, e, " (type=%d len=%d)", o->type, o->len);
                       break;
               case Omtu:
                       p = seprint(p, e, " mtu=%d", NetS(o->data));
                       break;
               case Octlmap:
                       p = seprint(p, e, " ctlmap=%ux", NetL(o->data));
                       break;
               case Oauth:
                       proto = NetS(o->data);
                       switch(proto) {
                       default:
                               p = seprint(p, e, " auth=%d", proto);
                               break;
                       case PPP_passwd:
                               p = seprint(p, e, " auth=passwd");
                               break;
                       case PPP_chap:
                               p = seprint(p, e, " (auth=chap data=%2.2ux)", o->data[2]);
                               break;
                       }
                       break;
               case Oquality:
                       proto = NetS(o->data);
                       switch(proto) {
                       default:
                               p = seprint(p, e, " qproto=%d", proto);
                               break;
                       case PPP_lqm:
                               x = NetL(o->data+2)*10;
                               period = (x+(PPP_period-1))/PPP_period;
                               p = seprint(p, e, " (qproto=lqm period=%d)", period);
                               break;
                       }
               case Omagic:
                       p = seprint(p, e, " magic=%ux", NetL(o->data));
                       break;
               case Opc:
                       p = seprint(p, e, " protocol-compress");
                       break;
               case Oac:
                       p = seprint(p, e, " addr-compress");
                       break;
               }
       }
       return p;
}


static int
p_seprintlcp(Msg *m)
{
       Lcppkt *lcp;
       char *p, *e;
       int len;

       if(m->pe-m->ps < 4)
               return -1;

       p = m->p;
       e = m->e;
       m->pr = nil;

       lcp = (Lcppkt*)m->ps;
       len = NetS(lcp->len);
       if(m->ps+len < m->pe)
               m->pe = m->ps+len;
       else if(m->ps+len > m->pe)
               return -1;

       p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
       switch(lcp->code) {
       default:
               p = seprint(p, e, " data=%.*H", len>64?64:len, lcp->data);
               break;
       case Lconfreq:
       case Lconfack:
       case Lconfnak:
       case Lconfrej:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               p = seprintlcpopt(p, e, lcp->data, len-4);
               break;
       case Ltermreq:
       case Ltermack:
       case Lcoderej:
       case Lprotorej:
       case Lechoreq:
       case Lechoack:
       case Ldiscard:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               break;
       }
       m->p = seprint(p, e, " len=%d", len);
       return 0;
}

static char*
seprintipcpopt(char *p, char *e, void *a, int len)
{
       Lcpopt *o;
       uchar *cp, *ecp;

       cp = a;
       ecp = cp+len;

       for(; cp < ecp; cp += o->len){
               o = (Lcpopt*)cp;
               if(cp + o->len > ecp){
                       p = seprint(p, e, " bad opt len %ux", o->type);
                       return p;
               }

               switch(o->type){
               default:
                       p = seprint(p, e, " (type=%d len=%d)", o->type, o->len);
                       break;
               case Oipaddrs:
                       p = seprint(p, e, " ipaddrs(deprecated)");
                       break;
               case Oipcompress:
                       p = seprint(p, e, " ipcompress");
                       break;
               case Oipaddr:
                       p = seprint(p, e, " ipaddr=%V", o->data);
                       break;
               case Oipdns:
                       p = seprint(p, e, " dnsaddr=%V", o->data);
                       break;
               case Oipwins:
                       p = seprint(p, e, " winsaddr=%V", o->data);
                       break;
               case Oipdns2:
                       p = seprint(p, e, " dns2addr=%V", o->data);
                       break;
               case Oipwins2:
                       p = seprint(p, e, " wins2addr=%V", o->data);
                       break;
               }
       }
       return p;
}

static int
p_seprintipcp(Msg *m)
{
       Lcppkt *lcp;
       char *p, *e;
       int len;

       if(m->pe-m->ps < 4)
               return -1;

       p = m->p;
       e = m->e;
       m->pr = nil;

       lcp = (Lcppkt*)m->ps;
       len = NetS(lcp->len);
       if(m->ps+len < m->pe)
               m->pe = m->ps+len;
       else if(m->ps+len > m->pe)
               return -1;

       p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
       switch(lcp->code) {
       default:
               p = seprint(p, e, " data=%.*H", len>64?64:len, lcp->data);
               break;
       case Lconfreq:
       case Lconfack:
       case Lconfnak:
       case Lconfrej:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               p = seprintipcpopt(p, e, lcp->data, len-4);
               break;
       case Ltermreq:
       case Ltermack:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               break;
       }
       m->p = seprint(p, e, " len=%d", len);
       return 0;
}

static char*
seprintccpopt(char *p, char *e, void *a, int len)
{
       Lcpopt *o;
       uchar *cp, *ecp;

       cp = a;
       ecp = cp+len;

       for(; cp < ecp; cp += o->len){
               o = (Lcpopt*)cp;
               if(cp + o->len > ecp){
                       p = seprint(p, e, " bad opt len %ux", o->type);
                       return p;
               }

               switch(o->type){
               default:
                       p = seprint(p, e, " type=%d ", o->type);
                       break;
               case 0:
                       p = seprint(p, e, " OUI=(%d %.2ux%.2ux%.2ux) ", o->type,
                               o->data[0], o->data[1], o->data[2]);
                       break;
               case 17:
                       p = seprint(p, e, " Stac-LZS");
                       break;
               case 18:
                       p = seprint(p, e, " Microsoft-PPC=%ux", NetL(o->data));
                       break;
               }
       }
       return p;
}

static int
p_seprintccp(Msg *m)
{
       Lcppkt *lcp;
       char *p, *e;
       int len;

       if(m->pe-m->ps < 4)
               return -1;

       p = m->p;
       e = m->e;
       m->pr = nil;

       lcp = (Lcppkt*)m->ps;
       len = NetS(lcp->len);
       if(m->ps+len < m->pe)
               m->pe = m->ps+len;
       else if(m->ps+len > m->pe)
               return -1;

       p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
       switch(lcp->code) {
       default:
               p = seprint(p, e, " data=%.*H", len>64?64:len, lcp->data);
               break;
       case Lconfreq:
       case Lconfack:
       case Lconfnak:
       case Lconfrej:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               p = seprintccpopt(p, e, lcp->data, len-4);
               break;
       case Ltermreq:
       case Ltermack:
       case Lresetreq:
       case Lresetack:
               p = seprint(p, e, "=%s", lcpcode[lcp->code]);
               break;
       }
       m->p = seprint(p, e, " len=%d", len);

       return 0;
}

static int
p_seprintcomp(Msg *m)
{
       char compflag[5];
       ushort x;
       int i;
       int len;

       len = m->pe-m->ps;
       if(len < 2)
               return -1;

       x = NetS(m->ps);
       m->ps += 2;
       i = 0;
       if(x & (1<<15))
               compflag[i++] = 'r';
       if(x & (1<<14))
               compflag[i++] = 'f';
       if(x & (1<<13))
               compflag[i++] = 'c';
       if(x & (1<<12))
               compflag[i++] = 'e';
       compflag[i] = 0;
       m->p = seprint(m->p, m->e, "flag=%s count=%.3ux", compflag, x&0xfff);
       m->p = seprint(m->p, m->e, " data=%.*H", len>64?64:len, m->ps);
       m->pr = nil;
       return 0;
}

Proto ppp =
{
       "ppp",
       p_compile,
       p_filter,
       p_seprint,
       p_mux,
       "%#.4lux",
       nil,
       defaultframer,
};

Proto ppp_ipcp =
{
       "ppp_ipcp",
       p_compile,
       p_filter,
       p_seprintipcp,
       nil,
       nil,
       nil,
       defaultframer,
};

Proto ppp_lcp =
{
       "ppp_lcp",
       p_compile,
       p_filter,
       p_seprintlcp,
       nil,
       nil,
       nil,
       defaultframer,
};

Proto ppp_ccp =
{
       "ppp_ccp",
       p_compile,
       p_filter,
       p_seprintccp,
       nil,
       nil,
       nil,
       defaultframer,
};

Proto ppp_chap =
{
       "ppp_chap",
       p_compile,
       p_filter,
       p_seprintchap,
       nil,
       nil,
       nil,
       defaultframer,
};

Proto ppp_comp =
{
       "ppp_comp",
       p_compile,
       p_filter,
       p_seprintcomp,
       nil,
       nil,
       nil,
       defaultframer,
};

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.