Subversion Repositories planix.SVN

/*
 * Point-to-point Tunneling Protocol (PPTP)
 * See RFC 2637, pptpd.c
 */

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

int     ack;
int     alarmed;
int     ctlechotime;
int     ctlfd;
int     ctlrcvtime;
int     debug;
int     grefd;
uchar localip[IPaddrlen];
int     localwin;
char    *keyspec;
int     now;
char    *pppnetmntpt;
int     pid;
Channel *pidchan;
int     pppfd;
int     primary;
int     rack;
Channel *rdchan;
int     rdexpect;
int     remid;
uchar remoteip[IPaddrlen];
int     remwin;
int     rseq;
int     seq;
char    tcpdir[40];
Channel *tickchan;
int     topppfd;

int     aread(int, int, void*, int);
int     catchalarm(void*, char*);
void    dumpctlpkt(uchar*);
void    getaddrs(void);
void    *emalloc(long);
void    ewrite(int, void*, int);
void    myfatal(char*, ...);
#pragma varargck argpos myfatal 1
int     pptp(char*);
void    pushppp(int);
void    recordack(int);
int     schedack(int, uchar*, int);
void    waitacks(void);

void
usage(void)
{
        fprint(2, "usage: ip/pptp [-Pd] [-k keyspec] [-x pppnetmntpt] [-w window] server\n");
        exits("usage");
}

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

        ARGBEGIN{
        case 'P':
                primary = 1;
                break;
        case 'd':
                debug++;
                break;
        case 'k':
                keyspec = EARGF(usage());
                break;
        case 'w':
                localwin = atoi(EARGF(usage()));
                break;
        case 'x':
                pppnetmntpt = EARGF(usage());
                break;
        default:
                usage();
        }ARGEND

        if(argc != 1)
                usage();

        fmtinstall('E', eipfmt);
        fmtinstall('I', eipfmt);

        rfork(RFNOTEG);
        atnotify(catchalarm, 1);
        fd = pptp(argv[0]);
        pushppp(fd);
        exits(nil);
}

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;
}

enum {
        Stack   = 8192,

        PptpProto       = 0x0100,

        Magic   = 0x1a2b3c4d,
        Window  = 16,           /* default window size */
        Timeout = 60,           /* timeout in seconds for control channel */
        Pktsize = 2000,         /* maximum packet size */
        Tick    = 500,          /* tick length in milliseconds */
        Sendtimeout = 4,        /* in ticks */

        Servertimeout = 5*60*1000/Tick,
        Echointerval = 60*1000/Tick,
};

enum {
        Syncframe       = 0x1,
        Asyncframe      = 0x2,
        Analog          = 0x1,
        Digital         = 0x2,
        Version         = 0x100,
};

enum {
        Tstart          = 1,
        Rstart          = 2,
        Tstop           = 3,
        Rstop           = 4,
        Techo           = 5,
        Recho           = 6,
        Tcallout        = 7,
        Rcallout        = 8,
        Tcallreq        = 9,
        Rcallreq        = 10,
        Acallcon        = 11,
        Tcallclear      = 12,
        Acalldis        = 13,
        Awaninfo        = 14,
        Alinkinfo       = 15,
};

void
recho(uchar *in)
{
        uchar out[20];

        if(nhgets(in) < 16)
                return;

        memset(out, 0, sizeof out);
        hnputs(out, sizeof out);
        hnputs(out+2, 1);
        hnputl(out+4, Magic);
        hnputs(out+8, Recho);
        memmove(out+12, in+12, 4);
        out[16] = 1;

        ewrite(ctlfd, out, sizeof out);
}

void
sendecho(void)
{
        uchar out[16];

        ctlechotime = now;      
        memset(out, 0, sizeof out);
        hnputs(out, sizeof out);
        hnputs(out+2, 1);
        hnputl(out+4, Magic);
        hnputs(out+8, Techo);

        ewrite(ctlfd, out, sizeof out);
}

void
pptpctlproc(void*)
{
        uchar pkt[1600], *p;
        int len;

        for(;;){
                if(readn(ctlfd, pkt, 2) != 2)
                        myfatal("pptpread: %r");
                len = nhgets(pkt);
                if(len < 12 || len+2 >= sizeof pkt)
                        myfatal("pptpread: bad length %d", len);
                if(readn(ctlfd, pkt+2, len-2) != len-2)
                        myfatal("pptpread: %r");
                if(nhgetl(pkt+4) != Magic)
                        myfatal("pptpread bad magic");
                if(nhgets(pkt+2) != 1)
                        myfatal("pptpread bad message type");
                if(debug)
                        dumpctlpkt(pkt);
                ctlrcvtime = now;

                switch(nhgets(pkt+8)){
                case Tstart:
                case Tstop:
                case Tcallout:
                case Tcallreq:
                case Tcallclear:
                case Acallcon:
                case Acalldis:
                case Awaninfo:
                        myfatal("unexpected msg type %d", nhgets(pkt+8));
                case Techo:
                        recho(pkt);
                        break;
                case Recho:
                        break;
                case Rstart:
                case Rstop:
                case Rcallout:
                case Rcallreq:
                        if(rdexpect != nhgets(pkt+8))
                                continue;
                        p = emalloc(len);
                        memmove(p, pkt, len);
                        sendp(rdchan, p);
                        break;
                case Alinkinfo:
                        myfatal("cannot change ppp params on the fly");
                }
        }
}

enum {
        Seqnum = 0x1000,
        Acknum = 0x0080,

        GrePPP = 0x880B,
};

void
grereadproc(void*)
{
        int datoff, flags, len, n, pass;
        uchar pkt[1600];
        uchar src[IPaddrlen], dst[IPaddrlen];

        rfork(RFFDG);
        close(pppfd);
        sendul(pidchan, getpid());

        while((n = read(grefd, pkt, sizeof pkt)) > 0){
                if(n == sizeof pkt)
                        myfatal("gre pkt buffer too small");
                if(n < 16){
                        if(debug)
                                fprint(2, "small pkt len %d ignored\n", n);
                        continue;
                }
                v4tov6(src, pkt);
                v4tov6(dst, pkt+4);
                if(ipcmp(src, remoteip) != 0 || ipcmp(dst, localip) != 0)
                        myfatal("%I: gre read bad address src=%I dst=%I",
                                remoteip, src, dst);
                if(nhgets(pkt+10) != GrePPP)
                        myfatal("%I: gre read bad protocol 0x%x",
                                remoteip, nhgets(pkt+10));

                flags = nhgets(pkt+8);
                if((flags&0xEF7F) != 0x2001){
                        if(debug)
                                fprint(2, "bad flags in gre hdr 0x%x\n", flags);
                        continue;
                }
                datoff = 8+8;
                pass = 0;
                len = nhgets(pkt+8+4);
                if(len > n-datoff){
                        fprint(2, "bad payload length %d > %d\n",
                                len, n-datoff);
                        continue;
                }
                if(flags&Seqnum)
                        datoff += 4;
                if(flags&Acknum){
                        recordack(nhgetl(pkt+datoff));
                        datoff += 4;
                }
                if(flags&Seqnum)
                        pass = schedack(nhgetl(pkt+8+8), pkt+datoff, len);
                if(debug)
                        fprint(2, "got gre callid %d len %d flag 0x%x pass %d seq %d rseq %d\n", nhgets(pkt+8+6),
                                len, flags, pass, nhgetl(pkt+8+8), rseq);
        }
        threadexits(nil);
}

void
pppreadproc(void*)
{
        int n, myrseq;
        uchar pkt[1600];
        enum {
                Hdr = 8+16,
        };

        rfork(RFFDG);
        close(pppfd);
        sendul(pidchan, getpid());

        while((n = read(topppfd, pkt+Hdr, sizeof pkt-Hdr)) > 0){
                if(n == sizeof pkt-Hdr)
                        myfatal("ppp pkt buffer too small");
                v6tov4(pkt+0, localip);
                v6tov4(pkt+4, remoteip);
                hnputs(pkt+8, 0x2001 | Seqnum | Acknum);
                hnputs(pkt+10, GrePPP);
                hnputs(pkt+12, n);
                hnputs(pkt+14, remid);
                hnputl(pkt+16, ++seq);
                myrseq = rseq;
                hnputl(pkt+20, myrseq);
                rack = myrseq;
                if(debug)
                        fprint(2, "wrote gre callid %d len %d flag 0x%x seq %d rseq %d\n", nhgets(pkt+8+6),
                                n, nhgets(pkt+8), nhgetl(pkt+16), nhgetl(pkt+20));
                if(write(grefd, pkt, n+Hdr) != n+Hdr)
                        myfatal("gre write: %r");
                waitacks();
        }
        threadexits(nil);
}

void
sendack(void)
{
        int myrseq;
        uchar pkt[20];

        v6tov4(pkt+0, localip);
        v6tov4(pkt+4, remoteip);
        hnputs(pkt+8, 0x2001 | Acknum);
        hnputs(pkt+10, GrePPP);
        hnputs(pkt+12, 0);
        hnputs(pkt+14, remid);
        myrseq = rseq;
        rack = myrseq;
        hnputs(pkt+16, myrseq);

        if(write(grefd, pkt, sizeof pkt) != sizeof pkt)
                myfatal("gre write: %r");
}

int
schedack(int n, uchar *dat, int len)
{
        static uchar sdat[1600];
        static int srseq, slen;

        if(n-rseq <= 0){
                fprint(2, "skipping pkt %d len %d, have %d\n", n, len, rseq);
                return 0;
        }

        /* missed one pkt, maybe a swap happened, save pkt */
        if(n==rseq+2){
                memmove(sdat, dat, len);
                slen = len;
                srseq = n;
                return 0;
        }

        if(n-rseq > 1){
                if(slen && srseq == n-1){       
                        fprint(2, "reswapped pkts %d and %d\n", srseq, n);
                        write(topppfd, sdat, slen);
                        slen = 0;
                }else
                        fprint(2, "missed pkts %d-%d, got %d len %d\n", rseq+1, n-1, n, len);
        }
        write(topppfd, dat, len);
        rseq = n;

        /* send ack if we haven't recently */
        if((int)(rseq-rack) > (localwin>>1))
                sendack();

        return 1;
}

void
gretimeoutproc(void*)
{
        for(;;){
                sleep(Tick);
                now++;
                nbsendul(tickchan, now);
                if(now - ctlrcvtime > Servertimeout)
                        myfatal("server timeout");
                if(now - ctlechotime > Echointerval)
                        sendecho();
        }
}

void
recordack(int n)
{
        ack = n;
}

void
waitacks(void)
{
/*
        int start;

        start = now;
        while(seq-ack > remwin && now-start < Sendtimeout){
                print("seq %d ack %d remwin %d now %d start %d\n",
                        seq, ack, remwin, now, start);
                recvul(tickchan);
        }
*/
}

void
tstart(void)
{
        char *name;
        uchar pkt[200], *rpkt;

        memset(pkt, 0, sizeof pkt);

        hnputs(pkt+0, 156);
        hnputs(pkt+2, 1);
        hnputl(pkt+4, Magic);
        hnputs(pkt+8, Tstart);
        hnputs(pkt+12, PptpProto);
        hnputl(pkt+16, 1);
        hnputl(pkt+20, 1);
        hnputs(pkt+24, 1);
        name = sysname();
        if(name == nil)
                name = "gnot";
        strcpy((char*)pkt+28, name);
        strcpy((char*)pkt+92, "plan 9");

        if(debug)
                dumpctlpkt(pkt);

        rdexpect = Rstart;
        ewrite(ctlfd, pkt, 156);

        rpkt = recvp(rdchan);
        if(rpkt == nil)
                myfatal("recvp: %r");
        if(nhgets(rpkt) != 156)
                myfatal("Rstart wrong length %d != 156", nhgets(rpkt));
        if(rpkt[14] != 1)
                myfatal("Rstart error %d", rpkt[15]);
        free(rpkt);
}

void
tcallout(void)
{
        uchar pkt[200], *rpkt;

        pid = getpid();

        memset(pkt, 0, sizeof pkt);
        hnputs(pkt+0, 168);
        hnputs(pkt+2, 1);
        hnputl(pkt+4, Magic);
        hnputs(pkt+8, Tcallout);

        hnputl(pkt+16, 56000);
        hnputl(pkt+20, 768000);
        hnputl(pkt+24, 3);
        hnputl(pkt+28, 3);
        if(localwin == 0)
                localwin = Window;
        hnputs(pkt+32, localwin);

        if(debug)
                dumpctlpkt(pkt);

        rdexpect = Rcallout;
        ewrite(ctlfd, pkt, 168);

        rpkt = recvp(rdchan);
        if(rpkt == nil)
                myfatal("recvp: %r");
        if(nhgets(rpkt) != 32)
                myfatal("Rcallreq wrong length %d != 32", nhgets(rpkt));
        if(rpkt[16] != 1)
                myfatal("Rcallreq error %d", rpkt[17]);
        remid = nhgets(pkt+12);
        remwin = nhgets(pkt+24);
        free(rpkt);
}

/*
void
tcallreq(void)
{
        uchar pkt[200], *rpkt;

        pid = getpid();

        memset(pkt, 0, sizeof pkt);
        hnputs(pkt+0, 220);
        hnputs(pkt+2, 1);
        hnputl(pkt+4, Magic);
        hnputs(pkt+8, Tcallreq);

        if(debug)
                dumpctlpkt(pkt);

        rdexpect = Rcallreq;
        ewrite(ctlfd, pkt, 220);

        rpkt = recvp(rdchan);
        if(rpkt == nil)
                myfatal("recvp: %r");
        if(nhgets(rpkt) != 24)
                myfatal("Rcallreq wrong length %d != 24", nhgets(rpkt));
        if(rpkt[16] != 1)
                myfatal("Rcallreq error %d", rpkt[17]);
        remid = nhgets(pkt+12);
        remwin = nhgets(pkt+18);
        free(rpkt);
}

void
acallcon(void)
{
        uchar pkt[200];

        memset(pkt, 0, sizeof pkt);
        hnputs(pkt+0, 28);
        hnputs(pkt+2, 1);
        hnputl(pkt+4, Magic);
        hnputs(pkt+8, Acallcon);
        hnputs(pkt+12, remid);
        if(localwin == 0)
                localwin = Window;
        hnputs(pkt+20, localwin);
        hnputl(pkt+24, 1);

        if(debug)
                dumpctlpkt(pkt);

        ewrite(ctlfd, pkt, 28);
}
*/

int
pptp(char *addr)
{
        int p[2];
        char greaddr[128];

        addr = netmkaddr(addr, "net", "pptp");
        ctlfd = dial(addr, nil, tcpdir, nil);
        if(ctlfd < 0)
                myfatal("dial %s: %r", addr);
        getaddrs();

        rdchan = chancreate(sizeof(void*), 0);
        proccreate(pptpctlproc, nil, Stack);

        tstart();
        tcallout();

        if(pipe(p) < 0)
                myfatal("pipe: %r");

        pppfd = p[0];
        topppfd = p[1];

        strcpy(greaddr, tcpdir);
        *strrchr(greaddr, '/') = '\0';
        sprint(strrchr(greaddr, '/')+1, "gre!%I!%d", remoteip, GrePPP);

        print("local %I remote %I gre %s remid %d remwin %d\n",
                localip, remoteip, greaddr, remid, remwin);

        grefd = dial(greaddr, nil, nil, nil);
        if(grefd < 0)
                myfatal("dial gre: %r");

        tickchan = chancreate(sizeof(int), 0);
        proccreate(gretimeoutproc, nil, Stack);

        pidchan = chancreate(sizeof(int), 0);
        proccreate(grereadproc, nil, Stack);
        recvul(pidchan);
        proccreate(pppreadproc, nil, Stack);
        recvul(pidchan);

        close(topppfd);
        return pppfd;
}
        
void
pushppp(int fd)
{
        char *argv[16];
        int argc;

        argc = 0;
        argv[argc++] = "/bin/ip/ppp";
        argv[argc++] = "-C";
        argv[argc++] = "-m1450";
        if(debug)
                argv[argc++] = "-d";
        if(primary)
                argv[argc++] = "-P";
        if(pppnetmntpt){
                argv[argc++] = "-x";
                argv[argc++] = pppnetmntpt;
        }
        if(keyspec){
                argv[argc++] = "-k";
                argv[argc++] = keyspec;
        }
        argv[argc] = nil;

        switch(fork()){
        case -1:
                myfatal("fork: %r");
        default:
                return;
        case 0:
                dup(fd, 0);
                dup(fd, 1);
                exec(argv[0], argv);
                myfatal("exec: %r");
        }
}

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)
                myfatal("read: %r");
        if(n == 0)
                myfatal("short read");
        return n;
}

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);
                myfatal("write %d to %s: %s", nbuf, path, e);
        }
}

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

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

int
thread(void(*f)(void*), void *a)
{
        int pid;
        pid=rfork(RFNOWAIT|RFMEM|RFPROC);
        if(pid < 0)
                myfatal("rfork: %r");
        if(pid != 0)
                return pid;
        (*f)(a);
        _exits(nil);
        return 0; // never reaches here
}

void
dumpctlpkt(uchar *pkt)
{
        fprint(2, "pkt len %d mtype %d cookie 0x%.8ux type %d\n",
                nhgets(pkt), nhgets(pkt+2),
                nhgetl(pkt+4), nhgets(pkt+8));

        switch(nhgets(pkt+8)){
        default:
                fprint(2, "\tunknown type\n");
                break;
        case Tstart:
                fprint(2, "\tTstart proto %d framing %d bearer %d maxchan %d firmware %d\n",
                        nhgets(pkt+12), nhgetl(pkt+16),
                        nhgetl(pkt+20), nhgets(pkt+24),
                        nhgets(pkt+26));
                fprint(2, "\thost %.64s\n", (char*)pkt+28);
                fprint(2, "\tvendor %.64s\n", (char*)pkt+92);
                break;
        case Rstart:
                fprint(2, "\tRstart proto %d res %d err %d framing %d bearer %d maxchan %d firmware %d\n",
                        nhgets(pkt+12), pkt[14], pkt[15],
                        nhgetl(pkt+16),
                        nhgetl(pkt+20), nhgets(pkt+24),
                        nhgets(pkt+26));
                fprint(2, "\thost %.64s\n", (char*)pkt+28);
                fprint(2, "\tvendor %.64s\n", (char*)pkt+92);
                break;

        case Tstop:
                fprint(2, "\tTstop reason %d\n", pkt[12]);
                break;

        case Rstop:
                fprint(2, "\tRstop res %d err %d\n", pkt[12], pkt[13]);
                break;

        case Techo:
                fprint(2, "\tTecho id %.8ux\n", nhgetl(pkt+12));
                break;

        case Recho:
                fprint(2, "\tRecho id %.8ux res %d err %d\n", nhgetl(pkt+12), pkt[16], pkt[17]);
                break;

        case Tcallout:
                fprint(2, "\tTcallout id %d serno %d bps %d-%d\n",
                        nhgets(pkt+12), nhgets(pkt+14),
                        nhgetl(pkt+16), nhgetl(pkt+20));
                fprint(2, "\tbearer 0x%x framing 0x%x recvwin %d delay %d\n",
                        nhgetl(pkt+24), nhgetl(pkt+28),
                        nhgets(pkt+32), nhgets(pkt+34));
                fprint(2, "\tphone len %d num %.64s\n", 
                        nhgets(pkt+36), (char*)pkt+40);
                fprint(2, "\tsubaddr %.64s\n", (char*)pkt+104);
                break;

        case Rcallout:
                fprint(2, "\tRcallout id %d peerid %d res %d err %d cause %d\n",
                        nhgets(pkt+12), nhgets(pkt+14),
                        pkt[16], pkt[17], nhgets(pkt+18));
                fprint(2, "\tconnect %d recvwin %d delay %d chan 0x%.8ux\n",
                        nhgetl(pkt+20), nhgets(pkt+24),
                        nhgets(pkt+26), nhgetl(pkt+28));
                break;

        case Tcallreq:
                fprint(2, "\tTcallreq id %d serno %d bearer 0x%x id 0x%x\n",
                        nhgets(pkt+12), nhgets(pkt+14),
                        nhgetl(pkt+16), nhgetl(pkt+20));
                fprint(2, "\tdialed len %d num %.64s\n",
                        nhgets(pkt+24), (char*)pkt+28);
                fprint(2, "\tdialing len %d num %.64s\n",
                        nhgets(pkt+26), (char*)pkt+92);
                fprint(2, "\tsubaddr %.64s\n", (char*)pkt+156);
                break;

        case Rcallreq:
                fprint(2, "\tRcallout id %d peerid %d res %d err %d recvwin %d delay %d\n",
                        nhgets(pkt+12), nhgets(pkt+14),
                        pkt[16], pkt[17], nhgets(pkt+18),
                        nhgets(pkt+20));
                break;

        case Acallcon:
                fprint(2, "\tAcallcon peerid %d connect %d recvwin %d delay %d framing 0x%x\n",
                        nhgets(pkt+12), nhgetl(pkt+16),
                        nhgets(pkt+20), nhgets(pkt+22),
                        nhgetl(pkt+24));
                break;

        case Tcallclear:
                fprint(2, "\tTcallclear callid %d\n",
                        nhgets(pkt+12));
                break;

        case Acalldis:
                fprint(2, "\tAcalldis callid %d res %d err %d cause %d\n",
                        nhgets(pkt+12), pkt[14], pkt[15],
                        nhgets(pkt+16));
                fprint(2, "\tstats %.128s\n", (char*)pkt+20);
                break;

        case Awaninfo:
                fprint(2, "\tAwaninfo peerid %d\n", nhgets(pkt+12));
                fprint(2, "\tcrc errors %d\n", nhgetl(pkt+16));
                fprint(2, "\tframe errors %d\n", nhgetl(pkt+20));
                fprint(2, "\thardware overruns %d\n", nhgetl(pkt+24));
                fprint(2, "\tbuffer overruns %d\n", nhgetl(pkt+28));
                fprint(2, "\ttime-out errors %d\n", nhgetl(pkt+32));
                fprint(2, "\talignment errors %d\n", nhgetl(pkt+36));
                break;

        case Alinkinfo:
                fprint(2, "\tAlinkinfo peerid %d sendaccm 0x%ux recvaccm 0x%ux\n",
                        nhgets(pkt+12), nhgetl(pkt+16),
                        nhgetl(pkt+20));
                break;
        }
}

void
getaddrs(void)
{
        char buf[128];
        int fd, n;

        sprint(buf, "%s/local", tcpdir);
        if((fd = open(buf, OREAD)) < 0)
                myfatal("could not open %s: %r", buf);
        if((n = read(fd, buf, sizeof(buf))) < 0)
                myfatal("could not read %s: %r", buf);
        buf[n] = 0;
        parseip(localip, buf);
        close(fd);

        sprint(buf, "%s/remote", tcpdir);
        if((fd = open(buf, OREAD)) < 0)
                myfatal("could not open %s: %r", buf);
        if((n = read(fd, buf, sizeof(buf))) < 0)
                myfatal("could not read %s: %r", buf);
        buf[n] = 0;
        parseip(remoteip, buf);
        close(fd);
}

void
myfatal(char *fmt, ...)
{
        char sbuf[512];
        va_list arg;
        uchar buf[16];

        memset(buf, 0, sizeof(buf));
        hnputs(buf+0, sizeof(buf));     /* length */
        hnputs(buf+2, 1);               /* message type */
        hnputl(buf+4, Magic);           /* magic */
        hnputs(buf+8, Tstop);           /* op */
        buf[12] = 3;                    /* local shutdown */
        write(ctlfd, buf, sizeof(buf));

        va_start(arg, fmt);
        vseprint(sbuf, sbuf+sizeof(sbuf), fmt, arg);
        va_end(arg);

        fprint(2, "fatal: %s\n", sbuf);
        threadexitsall(nil);
}