sys/src/cmd/ip/pptpd.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <ip.h>
   5
   6 #define LOG     "pptpd"
   7
   8 typedef struct Call     Call;
   9 typedef struct Event Event;
  10
  11 #define SDB     if(debug) fprint(2,
  12 #define EDB     );
  13
  14 enum {
  15         Magic   = 0x1a2b3c4d,
  16         Nhash   = 17,
  17         Nchan   = 10,           /* maximum number of channels */
  18         Window  = 8,            /* default window size */
  19         Timeout = 60,           /* timeout in seconds for control channel */
  20         Pktsize = 2000,         /* maximum packet size */
  21         Tick    = 500,          /* tick length in milliseconds */
  22         Sendtimeout = 4,        /* in ticks */
  23 };
  24
  25 enum {
  26         Syncframe       = 0x1,
  27         Asyncframe      = 0x2,
  28         Analog          = 0x1,
  29         Digital         = 0x2,
  30         Version         = 0x100,
  31 };
  32
  33 enum {
  34         Tstart          = 1,
  35         Rstart          = 2,
  36         Tstop           = 3,
  37         Rstop           = 4,
  38         Techo           = 5,
  39         Recho           = 6,
  40         Tcallout        = 7,
  41         Rcallout        = 8,
  42         Tcallreq        = 9,
  43         Rcallreq        = 10,
  44         Acallcon        = 11,
  45         Tcallclear      = 12,
  46         Acalldis        = 13,
  47         Awaninfo        = 14,
  48         Alinkinfo       = 15,
  49 };
  50
  51
  52 struct Event {
  53         QLock;
  54         QLock waitlk;
  55         int     wait;
  56         int ready;
  57 };
  58
  59 struct Call {
  60         int     ref;
  61         QLock   lk;
  62         int     id;
  63         int     serial;
  64         int     pppfd;
  65
  66         int     closed;
  67
  68         int     pac;    /* server is acting as a PAC */
  69
  70         int     recvwindow;     /* recv windows */
  71         int     sendwindow;     /* send windows */
  72         int     delay;
  73
  74         int     sendaccm;
  75         int     recvaccm;
  76
  77         uint    seq;            /* current seq number - for send */
  78         uint    ack;            /* current acked mesg - for send */
  79         uint    rseq;           /* highest recv seq number for in order packet  */
  80         uint    rack;           /* highest ack sent */
  81
  82         Event   eack;           /* recved ack - for send */
  83         ulong   tick;
  84
  85         uchar   remoteip[IPaddrlen];    /* remote ip address */
  86         int     dhcpfd[2];      /* pipe to dhcpclient */
  87
  88         /* error stats */
  89         struct {
  90                 int     crc;
  91                 int     frame;
  92                 int     hardware;
  93                 int     overrun;
  94                 int     timeout;
  95                 int     align;
  96         } err;
  97
  98         struct {
  99                 int     send;
 100                 int     sendack;
 101                 int     recv;
 102                 int     recvack;
 103                 int     dropped;
 104                 int     missing;
 105                 int     sendwait;
 106                 int     sendtimeout;
 107         } stat;
 108
 109         Call    *next;
 110 };
 111
 112 struct {
 113         QLock   lk;
 114         int     start;
 115         int     grefd;
 116         int     grecfd;
 117         uchar   local[IPaddrlen];
 118         uchar   remote[IPaddrlen];
 119         char    *tcpdir;
 120         uchar   ipaddr[IPaddrlen];              /* starting ip addresss to allocate */
 121
 122         int     recvwindow;
 123
 124         char    *pppdir;
 125         char    *pppexec;
 126
 127         double  rcvtime;        /* time at which last request was received */
 128         int     echoid;         /* id of last echo request */
 129
 130         Call    *hash[Nhash];
 131 } srv;
 132
 133 /* GRE flag bits */
 134 enum {
 135         GRE_chksum      = (1<<15),
 136         GRE_routing     = (1<<14),
 137         GRE_key         = (1<<13),
 138         GRE_seq         = (1<<12),
 139         GRE_srcrt       = (1<<11),
 140         GRE_recur       = (7<<8),
 141         GRE_ack         = (1<<7),
 142         GRE_ver         = 0x7,
 143 };
 144
 145 /* GRE protocols */
 146 enum {
 147         GRE_ppp         = 0x880b,
 148 };
 149
 150 int     debug;
 151 double  drop;
 152
 153 void    myfatal(char *fmt, ...);
 154
 155 #define PSHORT(p, v)            ((p)[0]=((v)>>8), (p)[1]=(v))
 156 #define PLONG(p, v)             (PSHORT(p, (v)>>16), PSHORT(p+2, (v)))
 157 #define PSTRING(d,s,n)          strncpy((char*)(d), s, n)
 158 #define GSHORT(p)               (((p)[0]<<8) | ((p)[1]<<0))
 159 #define GLONG(p)                ((GSHORT((p))<<16) | ((GSHORT((p)+2))<<0))
 160 #define GSTRING(d,s,n)          strncpy(d, (char*)(s), n), d[(n)-1] = 0
 161
 162 void    serve(void);
 163
 164 int     sstart(uchar*, int);
 165 int     sstop(uchar*, int);
 166 int     secho(uchar*, int);
 167 int     scallout(uchar*, int);
 168 int     scallreq(uchar*, int);
 169 int     scallcon(uchar*, int);
 170 int     scallclear(uchar*, int);
 171 int     scalldis(uchar*, int);
 172 int     swaninfo(uchar*, int);
 173 int     slinkinfo(uchar*, int);
 174
 175 Call    *callalloc(int id);
 176 void    callclose(Call*);
 177 void    callfree(Call*);
 178 Call    *calllookup(int id);
 179
 180 void    gretimeout(void*);
 181 void    pppread(void*);
 182
 183 void    srvinit(void);
 184 void    greinit(void);
 185 void    greread(void*);
 186 void    greack(Call *c);
 187
 188 void    timeoutthread(void*);
 189
 190 int     argatoi(char *p);
 191 void    usage(void);
 192 int     ipaddralloc(Call *c);
 193
 194 void    *emallocz(int size);
 195 void    esignal(Event *e);
 196 void    ewait(Event *e);
 197 int     proc(char **argv, int fd0, int fd1, int fd2);
 198 double  realtime(void);
 199 ulong   thread(void(*f)(void*), void *a);
 200
 201 void
 202 main(int argc, char *argv[])
 203 {
 204         ARGBEGIN{
 205         case 'd': debug++; break;
 206         case 'p': srv.pppdir = ARGF(); break;
 207         case 'P': srv.pppexec = ARGF(); break;
 208         case 'w': srv.recvwindow = argatoi(ARGF()); break;
 209         case 'D': drop = atof(ARGF()); break;
 210         default:
 211                 usage();
 212         }ARGEND
 213
 214         fmtinstall('I', eipfmt);
 215         fmtinstall('E', eipfmt);
 216         fmtinstall('V', eipfmt);
 217         fmtinstall('M', eipfmt);
 218
 219         rfork(RFNOTEG|RFREND);
 220
 221         if(argc != 1)
 222                 usage();
 223
 224         srv.tcpdir = argv[0];
 225
 226         srvinit();
 227
 228         syslog(0, LOG, ": src=%I: pptp started: %d", srv.remote, getpid());
 229
 230         SDB  "\n\n\n%I: pptp started\n", srv.remote EDB
 231
 232         greinit();
 233
 234         thread(timeoutthread, 0);
 235
 236         serve();
 237
 238         syslog(0, LOG, ": src=%I: server exits", srv.remote);
 239
 240         exits(0);
 241 }
 242
 243 void
 244 usage(void)
 245 {
 246         fprint(2, "usage: pptpd [-dD] [-p ppp-net] [-w window] tcpdir\n");
 247         exits("usage");
 248 }
 249
 250 void
 251 serve(void)
 252 {
 253         uchar buf[2000], *p;
 254         int n, n2, len;
 255         int magic;
 256         int op, type;
 257
 258         n = 0;
 259         for(;;) {
 260                 n2 = read(0, buf+n, sizeof(buf)-n);
 261                 if(n2 < 0)
 262                         myfatal("bad read on ctl channel: %r");
 263                 if(n2 == 0)
 264                         break;
 265                 n += n2;
 266                 p = buf;
 267                 for(;;) {
 268                         if(n < 12)
 269                                 break;
 270
 271                         qlock(&srv.lk);
 272                         srv.rcvtime = realtime();
 273                         qunlock(&srv.lk);
 274
 275                         len = GSHORT(p);
 276                         type = GSHORT(p+2);
 277                         magic = GLONG(p+4);
 278                         op = GSHORT(p+8);
 279                         if(magic != Magic)
 280                                 myfatal("bad magic number: got %x", magic);
 281                         if(type != 1)
 282                                 myfatal("bad message type: %d", type);
 283                         switch(op) {
 284                         default:
 285                                 myfatal("unknown control op: %d", op);
 286                         case Tstart:            /* start-control-connection-request */
 287                                 n2 = sstart(p, n);
 288                                 break;
 289                         case Tstop:
 290                                 n2 = sstop(p, n);
 291                                 if(n2 > 0)
 292                                         return;
 293                                 break;
 294                         case Techo:
 295                                 n2 = secho(p, n);
 296                                 break;
 297                         case Tcallout:
 298                                 n2 = scallout(p, n);
 299                                 break;
 300                         case Tcallreq:
 301                                 n2 = scallreq(p, n);
 302                                 break;
 303                         case Acallcon:
 304                                 n2 = scallcon(p, n);
 305                                 break;
 306                         case Tcallclear:
 307                                 n2 = scallclear(p, n);
 308                                 break;
 309                         case Acalldis:
 310                                 n2 = scalldis(p, n);
 311                                 break;
 312                         case Awaninfo:
 313                                 n2 = swaninfo(p, n);
 314                                 break;
 315                         case Alinkinfo:
 316                                 n2 = slinkinfo(p, n);
 317                                 break;
 318                         }
 319                         if(n2 == 0)
 320                                 break;
 321                         if(n2 != len)
 322                                 myfatal("op=%d: bad length: got %d expected %d", op, len, n2);
 323                         n -= n2;
 324                         p += n2;
 325
 326                 }
 327
 328                 /* move down partial message */
 329                 if(p != buf && n != 0)
 330                         memmove(buf, p, n);
 331         }
 332
 333 }
 334
 335 int
 336 sstart(uchar *p, int n)
 337 {
 338         int ver, frame, bearer, maxchan, firm;
 339         char host[64], vendor[64], *sysname;
 340         uchar buf[156];
 341
 342         if(n < 156)
 343                 return 0;
 344         ver = GSHORT(p+12);
 345         frame = GLONG(p+16);
 346         bearer = GLONG(p+20);
 347         maxchan = GSHORT(p+24);
 348         firm = GSHORT(p+26);
 349         GSTRING(host, p+28, 64);
 350         GSTRING(vendor, p+92, 64);
 351
 352         SDB "%I: start ver = %x f = %d b = %d maxchan = %d firm = %d host = %s vendor = %s\n",
 353                 srv.remote, ver, frame, bearer, maxchan, firm, host, vendor EDB
 354
 355         if(ver != Version)
 356                 myfatal("bad version: got %x expected %x", ver, Version);
 357
 358         if(srv.start)
 359                 myfatal("multiple start messages");
 360
 361         srv.start = 1;
 362
 363         sysname = getenv("sysname");
 364         if(sysname == 0)
 365                 strcpy(host, "gnot");
 366         else
 367                 strncpy(host, sysname, 64);
 368         free(sysname);
 369
 370         memset(buf, 0, sizeof(buf));
 371
 372         PSHORT(buf+0, sizeof(buf));     /* length */
 373         PSHORT(buf+2, 1);               /* message type */
 374         PLONG(buf+4, Magic);            /* magic */
 375         PSHORT(buf+8, Rstart);          /* op */
 376         PSHORT(buf+12, Version);        /* version */
 377         buf[14] = 1;                    /* result = ok */
 378         PLONG(buf+16, Syncframe|Asyncframe);    /* frameing */
 379         PLONG(buf+20, Digital|Analog);  /* berear capabilities */
 380         PSHORT(buf+24, Nchan);          /* max channels */
 381         PSHORT(buf+26, 1);              /* driver version */
 382         PSTRING(buf+28, host, 64);      /* host name */
 383         PSTRING(buf+92, "plan 9", 64);  /* vendor */
 384
 385         if(write(1, buf, sizeof(buf)) < sizeof(buf))
 386                 myfatal("write failed: %r");
 387
 388         return 156;
 389 }
 390
 391 int
 392 sstop(uchar *p, int n)
 393 {
 394         int reason;
 395         uchar buf[16];
 396
 397         if(n < 16)
 398                 return 0;
 399         reason = p[12];
 400
 401         SDB "%I: stop %d\n", srv.remote, reason EDB
 402
 403         memset(buf, 0, sizeof(buf));
 404         PSHORT(buf+0, sizeof(buf));     /* length */
 405         PSHORT(buf+2, 1);               /* message type */
 406         PLONG(buf+4, Magic);            /* magic */
 407         PSHORT(buf+8, Rstop);           /* op */
 408         buf[12] = 1;                    /* ok */
 409
 410         if(write(1, buf, sizeof(buf)) < sizeof(buf))
 411                 myfatal("write failed: %r");
 412
 413         return 16;
 414 }
 415
 416 int
 417 secho(uchar *p, int n)
 418 {
 419         int id;
 420         uchar buf[20];
 421
 422         if(n < 16)
 423                 return 0;
 424         id = GLONG(p+12);
 425
 426         SDB "%I: echo %d\n", srv.remote, id EDB
 427
 428         memset(buf, 0, sizeof(buf));
 429         PSHORT(buf+0, sizeof(buf));     /* length */
 430         PSHORT(buf+2, 1);               /* message type */
 431         PLONG(buf+4, Magic);            /* magic */
 432         PSHORT(buf+8, Recho);           /* op */
 433         PLONG(buf+12, id);              /* id */
 434         p[16] = 1;                      /* ok */
 435
 436         if(write(1, buf, sizeof(buf)) < sizeof(buf))
 437                 myfatal("write failed: %r");
 438
 439         return 16;
 440 }
 441
 442 int
 443 scallout(uchar *p, int n)
 444 {
 445         int id, serial;
 446         int minbps, maxbps, bearer, frame;
 447         int window, delay;
 448         int nphone;
 449         char phone[64], sub[64], buf[32];
 450         Call *c;
 451
 452         if(n < 168)
 453                 return 0;
 454
 455         if(!srv.start)
 456                 myfatal("%I: did not recieve start message", srv.remote);
 457
 458         id = GSHORT(p+12);
 459         serial = GSHORT(p+14);
 460         minbps = GLONG(p+16);
 461         maxbps = GLONG(p+20);
 462         bearer = GLONG(p+24);
 463         frame = GLONG(p+28);
 464         window = GSHORT(p+32);
 465         delay = GSHORT(p+34);
 466         nphone = GSHORT(p+36);
 467         GSTRING(phone, p+40, 64);
 468         GSTRING(sub, p+104, 64);
 469
 470         SDB "%I: callout id = %d serial = %d bps=[%d,%d] b=%x f=%x win = %d delay = %d np=%d phone=%s sub=%s\n",
 471                 srv.remote, id, serial, minbps, maxbps, bearer, frame, window, delay, nphone, phone, sub EDB
 472
 473         c = callalloc(id);
 474         c->sendwindow = window;
 475         c->delay = delay;
 476         c->pac = 1;
 477         c->recvwindow = srv.recvwindow;
 478
 479         memset(buf, 0, sizeof(buf));
 480         PSHORT(buf+0, sizeof(buf));     /* length */
 481         PSHORT(buf+2, 1);               /* message type */
 482         PLONG(buf+4, Magic);            /* magic */
 483         PSHORT(buf+8, Rcallout);        /* op */
 484         PSHORT(buf+12, id);             /* call id */
 485         PSHORT(buf+14, id);             /* peer id */
 486         buf[16] = 1;                    /* ok */
 487         PLONG(buf+20, 10000000);        /* speed */
 488         PSHORT(buf+24, c->recvwindow);  /* window size */
 489         PSHORT(buf+26, 0);              /* delay */
 490         PLONG(buf+28, 0);               /* channel id */
 491
 492         if(write(1, buf, sizeof(buf)) < sizeof(buf))
 493                 myfatal("write failed: %r");
 494
 495         return 168;
 496 }
 497
 498 int
 499 scallreq(uchar *p, int n)
 500 {
 501         USED(p);
 502         USED(n);
 503
 504         myfatal("callreq: not done yet");
 505         return 0;
 506 }
 507
 508 int
 509 scallcon(uchar *p, int n)
 510 {
 511         USED(p);
 512         USED(n);
 513
 514         myfatal("callcon: not done yet");
 515         return 0;
 516 }
 517
 518 int
 519 scallclear(uchar *p, int n)
 520 {
 521         Call *c;
 522         int id;
 523         uchar buf[148];
 524
 525         if(n < 16)
 526                 return 0;
 527         id = GSHORT(p+12);
 528
 529         SDB "%I: callclear id=%d\n", srv.remote, id EDB
 530
 531         if(c = calllookup(id)) {
 532                 callclose(c);
 533                 callfree(c);
 534         }
 535
 536         memset(buf, 0, sizeof(buf));
 537         PSHORT(buf+0, sizeof(buf));     /* length */
 538         PSHORT(buf+2, 1);               /* message type */
 539         PLONG(buf+4, Magic);            /* magic */
 540         PSHORT(buf+8, Acalldis);        /* op */
 541         PSHORT(buf+12, id);             /* id */
 542         buf[14] = 3;                    /* reply to callclear */
 543
 544         if(write(1, buf, sizeof(buf)) < sizeof(buf))
 545                 myfatal("write failed: %r");
 546
 547         return 16;
 548 }
 549
 550 int
 551 scalldis(uchar *p, int n)
 552 {
 553         Call *c;
 554         int id, res;
 555
 556         if(n < 148)
 557                 return 0;
 558         id = GSHORT(p+12);
 559         res = p[14];
 560
 561         SDB "%I: calldis id=%d res=%d\n", srv.remote, id, res EDB
 562
 563         if(c = calllookup(id)) {
 564                 callclose(c);
 565                 callfree(c);
 566         }
 567
 568         return 148;
 569 }
 570
 571 int
 572 swaninfo(uchar *p, int n)
 573 {
 574         Call *c;
 575         int id;
 576
 577         if(n < 40)
 578                 return 0;
 579
 580         id = GSHORT(p+12);
 581         SDB "%I: waninfo id = %d\n", srv.remote, id EDB
 582
 583         c = calllookup(id);
 584         if(c != 0) {
 585                 c->err.crc = GLONG(p+16);
 586                 c->err.frame = GLONG(p+20);
 587                 c->err.hardware = GLONG(p+24);
 588                 c->err.overrun = GLONG(p+28);
 589                 c->err.timeout = GLONG(p+32);
 590                 c->err.align = GLONG(p+36);
 591
 592                 callfree(c);
 593         }
 594
 595
 596         return 40;
 597 }
 598
 599 int
 600 slinkinfo(uchar *p, int n)
 601 {
 602         Call *c;
 603         int id;
 604         int sendaccm, recvaccm;
 605
 606         if(n < 24)
 607                 return 0;
 608         id = GSHORT(p+12);
 609         sendaccm = GLONG(p+16);
 610         recvaccm = GLONG(p+20);
 611
 612         SDB "%I: linkinfo id=%d saccm=%ux raccm=%ux\n", srv.remote, id, sendaccm, recvaccm EDB
 613
 614         if(c = calllookup(id)) {
 615                 c->sendaccm = sendaccm;
 616                 c->recvaccm = recvaccm;
 617
 618                 callfree(c);
 619         }
 620
 621         return 24;
 622 }
 623
 624 Call*
 625 callalloc(int id)
 626 {
 627         uint h;
 628         Call *c;
 629         char buf[300], *argv[30], local[20], remote[20], **p;
 630         int fd, pfd[2], n;
 631
 632         h = id%Nhash;
 633
 634         qlock(&srv.lk);
 635         for(c=srv.hash[h]; c; c=c->next)
 636                 if(c->id == id)
 637                         myfatal("callalloc: duplicate id: %d", id);
 638         c = emallocz(sizeof(Call));
 639         c->ref = 1;
 640         c->id = id;
 641         c->sendaccm = ~0;
 642         c->recvaccm = ~0;
 643
 644         if(!ipaddralloc(c))
 645                 myfatal("callalloc: could not alloc remote ip address");
 646
 647         if(pipe(pfd) < 0)
 648                 myfatal("callalloc: pipe failed: %r");
 649
 650         sprint(buf, "%s/ipifc/clone", srv.pppdir);
 651         fd = open(buf, OWRITE);
 652         if(fd < 0)
 653                 myfatal("callalloc: could not open %s: %r", buf);
 654
 655         n = sprint(buf, "iprouting");
 656         if(write(fd, buf, n) < n)
 657                 myfatal("callalloc: write to ifc failed: %r");
 658         close(fd);
 659
 660         p = argv;
 661         *p++ = srv.pppexec;
 662         *p++ = "-SC";
 663         *p++ = "-x";
 664         *p++ = srv.pppdir;
 665         if(debug)
 666                 *p++ = "-d";
 667         sprint(local, "%I", srv.ipaddr);
 668         *p++ = local;
 669         sprint(remote, "%I", c->remoteip);
 670         *p++ = remote;
 671         *p = 0;
 672
 673         proc(argv, pfd[0], pfd[0], 2);
 674
 675         close(pfd[0]);
 676
 677         c->pppfd = pfd[1];
 678
 679         c->next = srv.hash[h];
 680         srv.hash[h] = c;
 681
 682         qunlock(&srv.lk);
 683
 684         c->ref++;
 685         thread(pppread, c);
 686         c->ref++;
 687         thread(gretimeout, c);
 688
 689         syslog(0, LOG, ": src=%I: call started: id=%d: remote ip=%I", srv.remote, id, c->remoteip);
 690
 691         return c;
 692 }
 693
 694 void
 695 callclose(Call *c)
 696 {
 697         Call *oc;
 698         int id;
 699         uint h;
 700
 701         syslog(0, LOG, ": src=%I: call closed: id=%d: send=%d sendack=%d recv=%d recvack=%d dropped=%d missing=%d sendwait=%d sendtimeout=%d",
 702                 srv.remote, c->id, c->stat.send, c->stat.sendack, c->stat.recv, c->stat.recvack,
 703                 c->stat.dropped, c->stat.missing, c->stat.sendwait, c->stat.sendtimeout);
 704
 705         qlock(&srv.lk);
 706         if(c->closed) {
 707                 qunlock(&srv.lk);
 708                 return;
 709         }
 710         c->closed = 1;
 711
 712         close(c->dhcpfd[0]);
 713         close(c->dhcpfd[1]);
 714         close(c->pppfd);
 715         c->pppfd = -1;
 716
 717         h = c->id%Nhash;
 718         id = c->id;
 719         for(c=srv.hash[h],oc=0; c; oc=c,c=c->next)
 720                 if(c->id == id)
 721                         break;
 722         if(oc == 0)
 723                 srv.hash[h] = c->next;
 724         else
 725                 oc->next = c->next;
 726         c->next = 0;
 727         qunlock(&srv.lk);
 728
 729         callfree(c);
 730 }
 731
 732 void
 733 callfree(Call *c)
 734 {
 735         int ref;
 736
 737         qlock(&srv.lk);
 738         ref = --c->ref;
 739         qunlock(&srv.lk);
 740         if(ref > 0)
 741                 return;
 742
 743         /* already unhooked from hash list - see callclose */
 744         assert(c->closed == 1);
 745         assert(ref == 0);
 746         assert(c->next == 0);
 747
 748 SDB "call free\n" EDB
 749         free(c);
 750 }
 751
 752 Call*
 753 calllookup(int id)
 754 {
 755         uint h;
 756         Call *c;
 757
 758         h = id%Nhash;
 759
 760         qlock(&srv.lk);
 761         for(c=srv.hash[h]; c; c=c->next)
 762                 if(c->id == id)
 763                         break;
 764         if(c != 0)
 765                 c->ref++;
 766         qunlock(&srv.lk);
 767
 768         return c;
 769 }
 770
 771
 772 void
 773 srvinit(void)
 774 {
 775         char buf[100];
 776         int fd, n;
 777
 778         sprint(buf, "%s/local", srv.tcpdir);
 779         if((fd = open(buf, OREAD)) < 0)
 780                 myfatal("could not open %s: %r", buf);
 781         if((n = read(fd, buf, sizeof(buf))) < 0)
 782                 myfatal("could not read %s: %r", buf);
 783         buf[n] = 0;
 784         parseip(srv.local, buf);
 785         close(fd);
 786
 787         sprint(buf, "%s/remote", srv.tcpdir);
 788         if((fd = open(buf, OREAD)) < 0)
 789                 myfatal("could not open %s: %r", buf);
 790         if((n = read(fd, buf, sizeof(buf))) < 0)
 791                 myfatal("could not read %s: %r", buf);
 792         buf[n] = 0;
 793         parseip(srv.remote, buf);
 794         close(fd);
 795
 796         if(srv.pppdir == 0)
 797                 srv.pppdir = "/net";
 798
 799         if(srv.pppexec == 0)
 800                 srv.pppexec = "/bin/ip/ppp";
 801
 802         if(myipaddr(srv.ipaddr, srv.pppdir) < 0)
 803                 myfatal("could not read local ip addr: %r");
 804         if(srv.recvwindow == 0)
 805                 srv.recvwindow = Window;
 806 }
 807
 808 void
 809 greinit(void)
 810 {
 811         char addr[100], *p;
 812         int fd, cfd;
 813
 814         SDB "srv.tcpdir = %s\n", srv.tcpdir EDB
 815         strcpy(addr, srv.tcpdir);
 816         p = strrchr(addr, '/');
 817         if(p == 0)
 818                 myfatal("bad tcp dir: %s", srv.tcpdir);
 819         *p = 0;
 820         p = strrchr(addr, '/');
 821         if(p == 0)
 822                 myfatal("bad tcp dir: %s", srv.tcpdir);
 823         sprint(p, "/gre!%I!34827", srv.remote);
 824
 825         SDB "addr = %s\n", addr EDB
 826
 827         fd = dial(addr, 0, 0, &cfd);
 828
 829         if(fd < 0)
 830                 myfatal("%I: dial %s failed: %r", srv.remote, addr);
 831
 832         srv.grefd = fd;
 833         srv.grecfd = cfd;
 834
 835         thread(greread, 0);
 836 }
 837
 838 void
 839 greread(void *)
 840 {
 841         uchar buf[Pktsize], *p;
 842         int n, i;
 843         int flag, prot, len, callid;
 844         uchar src[IPaddrlen], dst[IPaddrlen];
 845         uint rseq, ack;
 846         Call *c;
 847         static double t, last;
 848
 849         for(;;) {
 850                 n = read(srv.grefd, buf, sizeof(buf));
 851                 if(n < 0)
 852                         myfatal("%I: bad read on gre: %r", srv.remote);
 853                 if(n == sizeof(buf))
 854                         myfatal("%I: gre read: buf too small", srv.remote);
 855
 856                 p = buf;
 857                 v4tov6(src, p);
 858                 v4tov6(dst, p+4);
 859                 flag = GSHORT(p+8);
 860                 prot = GSHORT(p+10);
 861                 p += 12; n -= 12;
 862
 863                 if(ipcmp(src, srv.remote) != 0 || ipcmp(dst, srv.local) != 0)
 864                         myfatal("%I: gre read bad address src=%I dst=%I", srv.remote, src, dst);
 865
 866                 if(prot != GRE_ppp)
 867                         myfatal("%I: gre read gave bad protocol", srv.remote);
 868
 869                 if(flag & (GRE_chksum|GRE_routing)){
 870                         p += 4; n -= 4;
 871                 }
 872
 873                 if(!(flag&GRE_key))
 874                         myfatal("%I: gre packet does not contain a key: f=%ux",
 875                                 srv.remote, flag);
 876
 877                 len = GSHORT(p);
 878                 callid = GSHORT(p+2);
 879                 p += 4; n -= 4;
 880
 881                 c = calllookup(callid);
 882                 if(c == 0) {
 883                         SDB "%I: unknown callid: %d\n", srv.remote, callid EDB
 884                         continue;
 885                 }
 886
 887                 qlock(&c->lk);
 888
 889                 c->stat.recv++;
 890
 891                 if(flag&GRE_seq) {
 892                         rseq = GLONG(p);
 893                         p += 4; n -= 4;
 894                 } else
 895                         rseq = c->rseq;
 896
 897                 if(flag&GRE_ack){
 898                         ack = GLONG(p);
 899                         p += 4; n -= 4;
 900                 } else
 901                         ack = c->ack;
 902
 903                 /* skip routing if present */
 904                 if(flag&GRE_routing) {
 905                         while((i=p[3]) != 0) {
 906                                 n -= i;
 907                                 p += i;
 908                         }
 909                 }
 910
 911                 if(len > n)
 912                         myfatal("%I: bad len in gre packet", srv.remote);
 913
 914                 if((int)(ack-c->ack) > 0) {
 915                         c->ack = ack;
 916                         esignal(&c->eack);
 917                 }
 918
 919                 if(debug)
 920                         t = realtime();
 921
 922                 if(len == 0) {
 923                         /* ack packet */
 924                         c->stat.recvack++;
 925
 926 SDB "%I: %.3f (%.3f): gre %d: recv ack a=%ux n=%d flag=%ux\n", srv.remote, t, t-last,
 927         c->id, ack, n, flag EDB
 928
 929                 } else {
 930
 931 SDB "%I: %.3f (%.3f): gre %d: recv s=%ux a=%ux len=%d\n", srv.remote, t, t-last,
 932         c->id, rseq, ack, len EDB
 933
 934                         /*
 935                          * the following handles the case of a single pair of packets
 936                          * received out of order
 937                          */
 938                         n = rseq-c->rseq;
 939                         if(n > 0 && (drop == 0. || frand() > drop)) {
 940                                 c->stat.missing += n-1;
 941                                 /* current packet */
 942                                 write(c->pppfd, p, len);
 943                         } else {
 944                                 /* out of sequence - drop on the floor */
 945                                 c->stat.dropped++;
 946
 947 SDB "%I: %.3f: gre %d: recv out of order or dup packet: seq=%ux len=%d\n",
 948 srv.remote, realtime(), c->id, rseq, len EDB
 949
 950                         }
 951                 }
 952
 953                 if((int)(rseq-c->rseq) > 0)
 954                         c->rseq = rseq;
 955
 956                 if(debug)
 957                         last=t;
 958
 959                 /* open up client window */
 960                 if((int)(c->rseq-c->rack) > (c->recvwindow>>1))
 961                         greack(c);
 962
 963                 qunlock(&c->lk);
 964
 965
 966                 callfree(c);
 967         }
 968 }
 969
 970 void
 971 greack(Call *c)
 972 {
 973         uchar buf[20];
 974
 975         c->stat.sendack++;
 976
 977 SDB "%I: %.3f: gre %d: send ack %ux\n", srv.remote, realtime(), c->id, c->rseq EDB
 978
 979         v6tov4(buf+0, srv.local);               /* source */
 980         v6tov4(buf+4, srv.remote);              /* source */
 981         PSHORT(buf+8, GRE_key|GRE_ack|1);
 982         PSHORT(buf+10, GRE_ppp);
 983         PSHORT(buf+12, 0);
 984         PSHORT(buf+14, c->id);
 985         PLONG(buf+16, c->rseq);
 986
 987         write(srv.grefd, buf, sizeof(buf));
 988
 989         c->rack = c->rseq;
 990
 991 }
 992
 993 void
 994 gretimeout(void *a)
 995 {
 996         Call *c;
 997
 998         c = a;
 999
1000         while(!c->closed) {
1001                 sleep(Tick);
1002                 qlock(&c->lk);
1003                 c->tick++;
1004                 qunlock(&c->lk);
1005                 esignal(&c->eack);
1006         }
1007         callfree(c);
1008         exits(0);
1009 }
1010
1011
1012 void
1013 pppread(void *a)
1014 {
1015         Call *c;
1016         uchar buf[2000], *p;
1017         int n;
1018         ulong tick;
1019
1020         c = a;
1021         for(;;) {
1022                 p = buf+24;
1023                 n = read(c->pppfd, p, sizeof(buf)-24);
1024                 if(n <= 0)
1025                         break;
1026
1027                 qlock(&c->lk);
1028
1029                 /* add gre header */
1030                 c->seq++;
1031                 tick = c->tick;
1032
1033                 while(c->seq-c->ack>c->sendwindow && c->tick-tick<Sendtimeout && !c->closed) {
1034                         c->stat.sendwait++;
1035 SDB "window full seq = %d ack = %ux window = %ux\n", c->seq, c->ack, c->sendwindow EDB
1036                         qunlock(&c->lk);
1037                         ewait(&c->eack);
1038                         qlock(&c->lk);
1039                 }
1040
1041                 if(c->tick-tick >= Sendtimeout) {
1042                         c->stat.sendtimeout++;
1043 SDB "send timeout = %d ack = %ux window = %ux\n", c->seq, c->ack, c->sendwindow EDB
1044                 }
1045
1046                 v6tov4(buf+0, srv.local);               /* source */
1047                 v6tov4(buf+4, srv.remote);              /* source */
1048                 PSHORT(buf+8, GRE_key|GRE_seq|GRE_ack|1);
1049                 PSHORT(buf+10, GRE_ppp);
1050                 PSHORT(buf+12, n);
1051                 PSHORT(buf+14, c->id);
1052                 PLONG(buf+16, c->seq);
1053                 PLONG(buf+20, c->rseq);
1054
1055                 c->stat.send++;
1056                 c->rack = c->rseq;
1057
1058 SDB "%I: %.3f: gre %d: send s=%ux a=%ux len=%d\n", srv.remote, realtime(),
1059         c->id,  c->seq, c->rseq, n EDB
1060
1061                 if(drop == 0. || frand() > drop)
1062                         if(write(srv.grefd, buf, n+24)<n+24)
1063                                 myfatal("pppread: write failed: %r");
1064
1065                 qunlock(&c->lk);
1066         }
1067
1068         SDB "pppread exit: %d\n", c->id);
1069
1070         callfree(c);
1071         exits(0);
1072 }
1073
1074 void
1075 timeoutthread(void*)
1076 {
1077         for(;;) {
1078                 sleep(30*1000);
1079
1080                 qlock(&srv.lk);
1081                 if(realtime() - srv.rcvtime > 5*60)
1082                         myfatal("server timedout");
1083                 qunlock(&srv.lk);
1084         }
1085 }
1086
1087
1088 /* use syslog() rather than fprint(2, ...) */
1089 void
1090 myfatal(char *fmt, ...)
1091 {
1092         char sbuf[512];
1093         va_list arg;
1094         uchar buf[16];
1095
1096         /* NT don't seem to like us just going away */
1097         memset(buf, 0, sizeof(buf));
1098         PSHORT(buf+0, sizeof(buf));     /* length */
1099         PSHORT(buf+2, 1);               /* message type */
1100         PLONG(buf+4, Magic);            /* magic */
1101         PSHORT(buf+8, Tstop);           /* op */
1102         buf[12] = 3;                    /* local shutdown */
1103
1104         write(1, buf, sizeof(buf));
1105
1106         va_start(arg, fmt);
1107         vseprint(sbuf, sbuf+sizeof(sbuf), fmt, arg);
1108         va_end(arg);
1109
1110         SDB "%I: fatal: %s\n", srv.remote, sbuf EDB
1111         syslog(0, LOG, ": src=%I: fatal: %s", srv.remote, sbuf);
1112
1113         close(0);
1114         close(1);
1115         close(srv.grefd);
1116         close(srv.grecfd);
1117
1118         postnote(PNGROUP, getpid(), "die");
1119         exits(sbuf);
1120 }
1121
1122 int
1123 argatoi(char *p)
1124 {
1125         char *q;
1126         int i;
1127
1128         if(p == 0)
1129                 usage();
1130
1131         i = strtol(p, &q, 0);
1132         if(q == p)
1133                 usage();
1134         return i;
1135 }
1136
1137 void
1138 dhcpclientwatch(void *a)
1139 {
1140         Call *c = a;
1141         uchar buf[1];
1142
1143         for(;;) {
1144                 if(read(c->dhcpfd[0], buf, sizeof(buf)) <= 0)
1145                         break;
1146         }
1147         if(!c->closed)
1148                 myfatal("dhcpclient terminated");
1149         callfree(c);
1150         exits(0);
1151 }
1152
1153 int
1154 ipaddralloc(Call *c)
1155 {
1156         int pfd[2][2];
1157         char *argv[4], *p;
1158         Biobuf bio;
1159
1160         argv[0] = "/bin/ip/dhcpclient";
1161         argv[1] = "-x";
1162         argv[2] = srv.pppdir;
1163         argv[3] = 0;
1164
1165         if(pipe(pfd[0])<0)
1166                 myfatal("ipaddralloc: pipe failed: %r");
1167         if(pipe(pfd[1])<0)
1168                 myfatal("ipaddralloc: pipe failed: %r");
1169
1170         if(proc(argv, pfd[0][0], pfd[1][1], 2) < 0)
1171                 myfatal("ipaddralloc: proc failed: %r");
1172
1173         close(pfd[0][0]);
1174         close(pfd[1][1]);
1175         c->dhcpfd[0] = pfd[1][0];
1176         c->dhcpfd[1] = pfd[0][1];
1177
1178         Binit(&bio, pfd[1][0], OREAD);
1179         for(;;) {
1180                 p = Brdline(&bio, '\n');
1181                 if(p == 0)
1182                         break;
1183                 if(strncmp(p, "ip=", 3) == 0) {
1184                         p += 3;
1185                         parseip(c->remoteip, p);
1186                 } else if(strncmp(p, "end\n", 4) == 0)
1187                         break;
1188         }
1189
1190         Bterm(&bio);
1191
1192         c->ref++;
1193
1194         thread(dhcpclientwatch, c);
1195
1196         return ipcmp(c->remoteip, IPnoaddr) != 0;
1197 }
1198
1199
1200 void
1201 esignal(Event *e)
1202 {
1203         qlock(e);
1204         if(e->wait == 0) {
1205                 e->ready = 1;
1206                 qunlock(e);
1207                 return;
1208         }
1209         assert(e->ready == 0);
1210         e->wait = 0;
1211         rendezvous(e, (void*)1);
1212         qunlock(e);
1213 }
1214
1215 void
1216 ewait(Event *e)
1217 {
1218         qlock(&e->waitlk);
1219         qlock(e);
1220         assert(e->wait == 0);
1221         if(e->ready) {
1222                 e->ready = 0;
1223         } else {
1224                 e->wait = 1;
1225                 qunlock(e);
1226                 rendezvous(e, (void*)2);
1227                 qlock(e);
1228         }
1229         qunlock(e);
1230         qunlock(&e->waitlk);
1231 }
1232
1233 ulong
1234 thread(void(*f)(void*), void *a)
1235 {
1236         int pid;
1237         pid=rfork(RFNOWAIT|RFMEM|RFPROC);
1238         if(pid < 0)
1239                 myfatal("rfork failed: %r");
1240         if(pid != 0)
1241                 return pid;
1242         (*f)(a);
1243         return 0; // never reaches here
1244 }
1245
1246 double
1247 realtime(void)
1248 {
1249         long times(long*);
1250
1251         return times(0) / 1000.0;
1252 }
1253
1254 void *
1255 emallocz(int size)
1256 {
1257         void *p;
1258         p = malloc(size);
1259         if(p == 0)
1260                 myfatal("malloc failed: %r");
1261         memset(p, 0, size);
1262         return p;
1263 }
1264
1265 static void
1266 fdclose(void)
1267 {
1268         int fd, n, i;
1269         Dir *d, *p;
1270
1271         if((fd = open("#d", OREAD)) < 0)
1272                 return;
1273
1274         n = dirreadall(fd, &d);
1275         for(p = d; n > 0; n--, p++) {
1276                 i = atoi(p->name);
1277                 if(i > 2)
1278                         close(i);
1279         }
1280         free(d);
1281 }
1282
1283 int
1284 proc(char **argv, int fd0, int fd1, int fd2)
1285 {
1286         int r, flag;
1287         char *arg0, file[200];
1288
1289         arg0 = argv[0];
1290
1291         strcpy(file, arg0);
1292
1293         if(access(file, 1) < 0) {
1294                 if(strncmp(arg0, "/", 1)==0
1295                 || strncmp(arg0, "#", 1)==0
1296                 || strncmp(arg0, "./", 2)==0
1297                 || strncmp(arg0, "../", 3)==0)
1298                         return 0;
1299                 sprint(file, "/bin/%s", arg0);
1300                 if(access(file, 1) < 0)
1301                         return 0;
1302         }
1303
1304         flag = RFPROC|RFFDG|RFENVG|RFNOWAIT;
1305         if((r = rfork(flag)) != 0) {
1306                 if(r < 0)
1307                         return 0;
1308                 return r;
1309         }
1310
1311         if(fd0 != 0) {
1312                 if(fd1 == 0)
1313                         fd1 = dup(0, -1);
1314                 if(fd2 == 0)
1315                         fd2 = dup(0, -1);
1316                 close(0);
1317                 if(fd0 >= 0)
1318                         dup(fd0, 0);
1319         }
1320
1321         if(fd1 != 1) {
1322                 if(fd2 == 1)
1323                         fd2 = dup(1, -1);
1324                 close(1);
1325                 if(fd1 >= 0)
1326                         dup(fd1, 1);
1327         }
1328
1329         if(fd2 != 2) {
1330                 close(2);
1331                 if(fd2 >= 0)
1332                         dup(fd2, 2);
1333         }
1334
1335         fdclose();
1336
1337         exec(file, argv);
1338         myfatal("proc: exec failed: %r");
1339         return 0;
1340 }
1341