Subversion Repositories planix.SVN

/*
 * User-level PPP over Ethernet (PPPoE) client.
 * See RFC 2516
 */

#include <u.h>
#include <libc.h>
#include <ip.h>

void dumppkt(uchar*);
uchar *findtag(uchar*, int, int*, int);
void hexdump(uchar*, int);
int malformed(uchar*, int, int);
int pppoe(char*);
void execppp(int);

int alarmed;
int debug;
int sessid;
char *keyspec;
int primary;
char *pppnetmtpt;
char *acname;
char *pppname = "/bin/ip/ppp";
char *srvname = "";
char *wantac;
uchar *cookie;
int cookielen;
uchar etherdst[6];
int mtu = 1492;

void
usage(void)
{
        fprint(2, "usage: pppoe [-Pd] [-A acname] [-S srvname] [-k keyspec] [-m mtu] [-x pppnet] [ether0]\n");
        exits("usage");
}

int
catchalarm(void *a, char *msg)
{
        USED(a);

        if(strstr(msg, "alarm")){
                alarmed = 1;
                return 1;
        }
        if(debug)
                fprint(2, "note rcved: %s\n", msg);
        return 0;
}

void
main(int argc, char **argv)
{
        int fd;
        char *dev;

        ARGBEGIN{
        case 'A':
                wantac = EARGF(usage());
                break;
        case 'P':
                primary = 1;
                break;
        case 'S':
                srvname = EARGF(usage());
                break;
        case 'd':
                debug++;
                break;
        case 'm':
                mtu = atoi(EARGF(usage()));
                break;
        case 'k':
                keyspec = EARGF(usage());
                break;
        case 'x':
                pppnetmtpt = EARGF(usage());
                break;
        default:
                usage();
        }ARGEND

        switch(argc){
        default:
                usage();
        case 0:
                dev = "ether0";
                break;
        case 1:
                dev = argv[0];
                break;
        }

        fmtinstall('E', eipfmt);

        atnotify(catchalarm, 1);
        fd = pppoe(dev);
        execppp(fd);
}

typedef struct Etherhdr Etherhdr;
struct Etherhdr {
        uchar dst[6];
        uchar src[6];
        uchar type[2];
};

enum {
        EtherHdrSz = 6+6+2,
        EtherMintu = 60,

        EtherPppoeDiscovery = 0x8863,
        EtherPppoeSession = 0x8864,
};

uchar etherbcast[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

int
etherhdr(uchar *pkt, uchar *dst, int type)
{
        Etherhdr *eh;

        eh = (Etherhdr*)pkt;
        memmove(eh->dst, dst, sizeof(eh->dst));
        hnputs(eh->type, type);
        return EtherHdrSz;
}

typedef struct Pppoehdr Pppoehdr;
struct Pppoehdr {
        uchar verstype;
        uchar code;
        uchar sessid[2];
        uchar length[2];        /* of payload */
};

enum {
        PppoeHdrSz = 1+1+2+2,
        Hdr = EtherHdrSz+PppoeHdrSz,
};

enum {
        VersType = 0x11,

        /* Discovery codes */
        CodeDiscInit = 0x09,    /* discovery init */
        CodeDiscOffer = 0x07,   /* discovery offer */
        CodeDiscReq = 0x19,     /* discovery request */
        CodeDiscSess = 0x65,    /* session confirmation */

        /* Session codes */
        CodeSession = 0x00,
};

int
pppoehdr(uchar *pkt, int code, int sessid)
{
        Pppoehdr *ph;

        ph = (Pppoehdr*)pkt;
        ph->verstype = VersType;
        ph->code = code;
        hnputs(ph->sessid, sessid);
        return PppoeHdrSz;
}

typedef struct Taghdr Taghdr;
struct Taghdr {
        uchar type[2];
        uchar length[2];        /* of value */
};

enum {
        TagEnd = 0x0000,                /* end of tag list */
        TagSrvName = 0x0101,    /* service name */
        TagAcName = 0x0102,     /* access concentrator name */
        TagHostUniq = 0x0103,   /* nonce */
        TagAcCookie = 0x0104,   /* a.c. cookie */
        TagVendSpec = 0x0105,   /* vendor specific */
        TagRelaySessId = 0x0110,        /* relay session id */
        TagSrvNameErr = 0x0201, /* service name error (ascii) */
        TagAcSysErr = 0x0202,   /* a.c. system error */
};

int
tag(uchar *pkt, int type, void *value, int nvalue)
{
        Taghdr *h;

        h = (Taghdr*)pkt;
        hnputs(h->type, type);
        hnputs(h->length, nvalue);
        memmove(pkt+4, value, nvalue);
        return 4+nvalue;
}

/* PPPoE Active Discovery Initiation */
int
padi(uchar *pkt)
{
        int sz, tagoff;
        uchar *length;

        sz = 0;
        sz += etherhdr(pkt+sz, etherbcast, EtherPppoeDiscovery);
        sz += pppoehdr(pkt+sz, CodeDiscInit, 0x0000);
        length = pkt+sz-2;
        tagoff = sz;
        sz += tag(pkt+sz, TagSrvName, srvname, strlen(srvname));
        hnputs(length, sz-tagoff);
        return sz;
}

/* PPPoE Active Discovery Request */
int
padr(uchar *pkt)
{
        int sz, tagoff;
        uchar *length;

        sz = 0;
        sz += etherhdr(pkt+sz, etherdst, EtherPppoeDiscovery);
        sz += pppoehdr(pkt+sz, CodeDiscReq, 0x0000);
        length = pkt+sz-2;
        tagoff = sz;
        sz += tag(pkt+sz, TagSrvName, srvname, strlen(srvname));
        sz += tag(pkt+sz, TagAcName, acname, strlen(acname));
        if(cookie)
                sz += tag(pkt+sz, TagAcCookie, cookie, cookielen);
        hnputs(length, sz-tagoff);
        return sz;
}

void
ewrite(int fd, void *buf, int nbuf)
{
        char e[ERRMAX], path[64];

        if(write(fd, buf, nbuf) != nbuf){
                rerrstr(e, sizeof e);
                strcpy(path, "unknown");
                fd2path(fd, path, sizeof path);
                sysfatal("write %d to %s: %s", nbuf, path, e);
        }
}

void*
emalloc(long n)
{
        void *v;

        v = malloc(n);
        if(v == nil)
                sysfatal("out of memory");
        return v;
}

int
aread(int timeout, int fd, void *buf, int nbuf)
{
        int n;

        alarmed = 0;
        alarm(timeout);
        n = read(fd, buf, nbuf);
        alarm(0);
        if(alarmed)
                return -1;
        if(n < 0)
                sysfatal("read: %r");
        if(n == 0)
                sysfatal("short read");
        return n;
}

int
pktread(int timeout, int fd, void *buf, int nbuf, int (*want)(uchar*))
{
        int n, t2;
        n = -1;
        for(t2=timeout; t2<16000; t2*=2){
                while((n = aread(t2, fd, buf, nbuf)) > 0){
                        if(malformed(buf, n, EtherPppoeDiscovery)){
                                if(debug)
                                        fprint(2, "dropping pkt: %r\n");
                                continue;
                        }
                        if(debug)
                                dumppkt(buf);
                        if(!want(buf)){
                                if(debug)
                                        fprint(2, "dropping unwanted pkt: %r\n");
                                continue;
                        }
                        break;
                }
                if(n > 0)
                        break;
        }
        return n;
}

int
bad(char *reason)
{
        werrstr(reason);
        return 0;
}

void*
copy(uchar *s, int len)
{
        uchar *v;

        v = emalloc(len+1);
        memmove(v, s, len);
        v[len] = '\0';
        return v;
}

void
clearstate(void)
{
        sessid = -1;
        free(acname);
        acname = nil;
        free(cookie);
        cookie = nil;
}

int
wantoffer(uchar *pkt)
{
        int i, len;
        uchar *s;
        Etherhdr *eh;
        Pppoehdr *ph;

        eh = (Etherhdr*)pkt;
        ph = (Pppoehdr*)(pkt+EtherHdrSz);

        if(ph->code != CodeDiscOffer)
                return bad("not an offer");
        if(nhgets(ph->sessid) != 0x0000)
                return bad("bad session id");

        for(i=0;; i++){
                if((s = findtag(pkt, TagSrvName, &len, i)) == nil)
                        return bad("no matching service name");
                if(len == strlen(srvname) && memcmp(s, srvname, len) == 0)
                        break;
        }

        if((s = findtag(pkt, TagAcName, &len, 0)) == nil)
                return bad("no ac name");
        acname = copy(s, len);
        if(wantac && strcmp(acname, wantac) != 0){
                free(acname);
                return bad("wrong ac name");
        }

        if(s = findtag(pkt, TagAcCookie, &len, 0)){
                cookie = copy(s, len);
                cookielen = len;
        }
        memmove(etherdst, eh->src, sizeof etherdst);
        return 1;
}

int
wantsession(uchar *pkt)
{
        int len;
        uchar *s;
        Pppoehdr *ph;

        ph = (Pppoehdr*)(pkt+EtherHdrSz);

        if(ph->code != CodeDiscSess)
                return bad("not a session confirmation");
        if(nhgets(ph->sessid) == 0x0000)
                return bad("bad session id");
        if(findtag(pkt, TagSrvName, &len, 0) == nil)
                return bad("no service name");
        if(findtag(pkt, TagSrvNameErr, &len, 0))
                return bad("service name error");
        if(findtag(pkt, TagAcSysErr, &len, 0))
                return bad("ac system error");

        /*
         * rsc said: ``if there is no -S option given, the current code
         * waits for an offer with service name == "".
         * that's silly.  it should take the first one it gets.''
         */
        if(srvname[0] != '\0') {
                if((s = findtag(pkt, TagSrvName, &len, 0)) == nil)
                        return bad("no matching service name");
                if(len != strlen(srvname) || memcmp(s, srvname, len) != 0)
                        return bad("no matching service name");
        }
        sessid = nhgets(ph->sessid);
        return 1;
}

int
pppoe(char *ether)
{
        char buf[64];
        uchar pkt[1520];
        int dfd, p[2], n, sfd, sz, timeout;
        Pppoehdr *ph;

        ph = (Pppoehdr*)(pkt+EtherHdrSz);
        snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeDiscovery);
        if((dfd = dial(buf, nil, nil, nil)) < 0)
                sysfatal("dial %s: %r", buf);

        snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeSession);
        if((sfd = dial(buf, nil, nil, nil)) < 0)
                sysfatal("dial %s: %r", buf);

        for(timeout=250; timeout<16000; timeout*=2){
                clearstate();
                memset(pkt, 0, sizeof pkt);
                sz = padi(pkt);
                if(debug)
                        dumppkt(pkt);
                if(sz < EtherMintu)
                        sz = EtherMintu;
                ewrite(dfd, pkt, sz);

                if(pktread(timeout, dfd, pkt, sizeof pkt, wantoffer) < 0)
                        continue;

                memset(pkt, 0, sizeof pkt);
                sz = padr(pkt);
                if(debug)
                        dumppkt(pkt);
                if(sz < EtherMintu)
                        sz = EtherMintu;
                ewrite(dfd, pkt, sz);

                if(pktread(timeout, dfd, pkt, sizeof pkt, wantsession) < 0)
                        continue;

                break;
        }
        if(sessid < 0)
                sysfatal("could not establish session");

        rfork(RFNOTEG);
        if(pipe(p) < 0)
                sysfatal("pipe: %r");

        switch(fork()){
        case -1:
                sysfatal("fork: %r");
        default:
                break;
        case 0:
                close(p[1]);
                while((n = read(p[0], pkt+Hdr, sizeof pkt-Hdr)) > 0){
                        etherhdr(pkt, etherdst, EtherPppoeSession);
                        pppoehdr(pkt+EtherHdrSz, 0x00, sessid);
                        hnputs(pkt+Hdr-2, n);
                        sz = Hdr+n;
                        if(debug > 1){
                                dumppkt(pkt);
                                hexdump(pkt, sz);
                        }
                        if(sz < EtherMintu)
                                sz = EtherMintu;
                        if(write(sfd, pkt, sz) < 0){
                                if(debug)
                                        fprint(2, "write to ether failed: %r");
                                _exits(nil);
                        }
                }
                _exits(nil);
        }

        switch(fork()){
        case -1:
                sysfatal("fork: %r");
        default:
                break;
        case 0:
                close(p[1]);
                while((n = read(sfd, pkt, sizeof pkt)) > 0){
                        if(malformed(pkt, n, EtherPppoeSession)
                        || ph->code != 0x00 || nhgets(ph->sessid) != sessid){
                                if(debug)
                                        fprint(2, "malformed session pkt: %r\n");
                                if(debug)
                                        dumppkt(pkt);
                                continue;
                        }
                        if(write(p[0], pkt+Hdr, nhgets(ph->length)) < 0){
                                if(debug)
                                        fprint(2, "write to ppp failed: %r\n");
                                _exits(nil);
                        }
                }
                _exits(nil);
        }
        close(p[0]);
        return p[1];
}

void
execppp(int fd)
{
        char *argv[16];
        int argc;
        char smtu[10];

        argc = 0;
        argv[argc++] = pppname;
        snprint(smtu, sizeof(smtu), "-m%d", mtu);
        argv[argc++] = smtu;
        argv[argc++] = "-F";
        if(debug)
                argv[argc++] = "-d";
        if(primary)
                argv[argc++] = "-P";
        if(pppnetmtpt){
                argv[argc++] = "-x";
                argv[argc++] = pppnetmtpt;
        }
        if(keyspec){
                argv[argc++] = "-k";
                argv[argc++] = keyspec;
        }
        argv[argc] = nil;

        dup(fd, 0);
        dup(fd, 1);
        exec(pppname, argv);
        sysfatal("exec: %r");
}

uchar*
findtag(uchar *pkt, int tagtype, int *plen, int skip)
{
        int len, sz, totlen;
        uchar *tagdat, *v;
        Etherhdr *eh;
        Pppoehdr *ph;
        Taghdr *t;

        eh = (Etherhdr*)pkt;
        ph = (Pppoehdr*)(pkt+EtherHdrSz);
        tagdat = pkt+Hdr;

        if(nhgets(eh->type) != EtherPppoeDiscovery)
                return nil;
        totlen = nhgets(ph->length);

        sz = 0;
        while(sz+4 <= totlen){
                t = (Taghdr*)(tagdat+sz);
                v = tagdat+sz+4;
                len = nhgets(t->length);
                if(sz+4+len > totlen)
                        break;
                if(nhgets(t->type) == tagtype && skip-- == 0){
                        *plen = len;
                        return v;
                }
                sz += 2+2+len;
        }
        return nil;     
}

void
dumptags(uchar *tagdat, int ntagdat)
{
        int i,len, sz;
        uchar *v;
        Taghdr *t;

        sz = 0;
        while(sz+4 <= ntagdat){
                t = (Taghdr*)(tagdat+sz);
                v = tagdat+sz+2+2;
                len = nhgets(t->length);
                if(sz+4+len > ntagdat)
                        break;
                fprint(2, "\t0x%x %d: ", nhgets(t->type), len);
                switch(nhgets(t->type)){
                case TagEnd:
                        fprint(2, "end of tag list\n");
                        break;
                case TagSrvName:
                        fprint(2, "service '%.*s'\n", len, (char*)v);
                        break;
                case TagAcName:
                        fprint(2, "ac '%.*s'\n", len, (char*)v);
                        break;
                case TagHostUniq:
                        fprint(2, "nonce ");
                Hex:
                        for(i=0; i<len; i++)
                                fprint(2, "%.2ux", v[i]);
                        fprint(2, "\n");
                        break;
                case TagAcCookie:
                        fprint(2, "ac cookie ");
                        goto Hex;
                case TagVendSpec:
                        fprint(2, "vend spec ");
                        goto Hex;
                case TagRelaySessId:
                        fprint(2, "relay ");
                        goto Hex;
                case TagSrvNameErr:
                        fprint(2, "srverr '%.*s'\n", len, (char*)v);
                        break;
                case TagAcSysErr:
                        fprint(2, "syserr '%.*s'\n", len, (char*)v);
                        break;
                }
                sz += 2+2+len;
        }
        if(sz != ntagdat)
                fprint(2, "warning: only dumped %d of %d bytes\n", sz, ntagdat);
}

void
dumppkt(uchar *pkt)
{
        int et;
        Etherhdr *eh;
        Pppoehdr *ph;

        eh = (Etherhdr*)pkt;
        ph = (Pppoehdr*)(pkt+EtherHdrSz);
        et = nhgets(eh->type);

        fprint(2, "%E -> %E type 0x%x\n", 
                eh->src, eh->dst, et);
        switch(et){
        case EtherPppoeDiscovery:
        case EtherPppoeSession:
                fprint(2, "\tvers %d type %d code 0x%x sessid 0x%x length %d\n",
                        ph->verstype>>4, ph->verstype&15,
                        ph->code, nhgets(ph->sessid), nhgets(ph->length));
                if(et == EtherPppoeDiscovery)
                        dumptags(pkt+Hdr, nhgets(ph->length));
        }
}

int
malformed(uchar *pkt, int n, int wantet)
{
        int et;
        Etherhdr *eh;
        Pppoehdr *ph;

        eh = (Etherhdr*)pkt;
        ph = (Pppoehdr*)(pkt+EtherHdrSz);

        if(n < Hdr || n < Hdr+nhgets(ph->length)){
                werrstr("packet too short %d != %d", n, Hdr+nhgets(ph->length));
                return 1;
        }

        et = nhgets(eh->type);
        if(et != wantet){
                werrstr("wrong ethernet packet type 0x%x != 0x%x", et, wantet);
                return 1;
        }

        return 0;
}

void
hexdump(uchar *a, int na)
{
        int i;
        char buf[80];

        buf[0] = '\0';
        for(i=0; i<na; i++){
                sprint(buf+strlen(buf), " %.2ux", a[i]);
                if(i%16 == 7)
                        sprint(buf+strlen(buf), " --");
                if(i%16==15){
                        sprint(buf+strlen(buf), "\n");
                        write(2, buf, strlen(buf));
                        buf[0] = 0;
                }
        }
        if(i%16){
                sprint(buf+strlen(buf), "\n");
                write(2, buf, strlen(buf));
        }
}