sys/src/cmd/telco/telco.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4 #include <fcall.h>
   5
   6 #define LOGFILE "telco"
   7
   8 /*
   9  * Rather than reading /adm/users, which is a lot of work for
  10  * a toy progdev, we assume all groups have the form
  11  *      NNN:user:user:
  12  * meaning that each user is the leader of his own group.
  13  */
  14
  15 enum
  16 {
  17         OPERM   = 0x3,          /* mask of all permission types in open mode */
  18         Ndev    = 8,
  19         Nreq    = (Ndev*3)/2,
  20         Nrbuf   = 32*1024,
  21 };
  22
  23 typedef struct Fid Fid;
  24 typedef struct Dev Dev;
  25 typedef struct Request Request;
  26 typedef struct Type Type;
  27
  28 struct Fid
  29 {
  30         Qid     qid;
  31         short   busy;
  32         short   open;
  33         int     fid;
  34         Fid     *next;
  35         char    *user;
  36 };
  37
  38 struct Request
  39 {
  40         Request *next;
  41
  42         Fid     *fid;
  43         ulong   tag;
  44         int     count;
  45         int     flushed;
  46 };
  47
  48 struct Dev
  49 {
  50         Lock;
  51
  52         /* device state */
  53         int     ctl;            /* control fd */
  54         int     data;           /* data fd */
  55         char    *path;          /* to device */
  56         Type    *t;
  57         Type    *baset;
  58         int     speed;
  59         int     fclass;
  60
  61         /* fs emulation */
  62         int     open;
  63         long    perm;
  64         char    *name;
  65         char    *user;
  66         char    msgbuf[128];
  67         Request *r;
  68         Request *rlast;
  69
  70         /* input reader */
  71         int     monitoring;     /* monitor pid */
  72         char    rbuf[Nrbuf];
  73         char    *rp;
  74         char    *wp;
  75         long    pid;
  76 };
  77
  78 enum
  79 {
  80         Devmask=        (Ndev-1)<<8,
  81
  82         Qlvl1=          0,
  83         Qlvl2=          1,
  84         Qclone=         2,
  85         Qlvl3=          3,
  86         Qdata=          4,
  87         Qctl=           5,
  88
  89         Pexec =         1,
  90         Pwrite =        2,
  91         Pread =         4,
  92         Pother =        1,
  93         Pgroup =        8,
  94         Powner =        64,
  95 };
  96
  97 char *names[] =
  98 {
  99 [Qlvl1]         "/",
 100 [Qlvl2]         "telco",
 101 [Qclone]        "clone",
 102 [Qlvl3]         "",
 103 [Qdata]         "data",
 104 [Qctl]          "ctl",
 105 };
 106
 107 #define DEV(q) ((((ulong)(q).path)&Devmask)>>8)
 108 #define TYPE(q) (((ulong)(q).path)&((1<<8)-1))
 109 #define MKQID(t, i) ((((i)<<8)&Devmask) | (t))
 110
 111 enum
 112 {
 113         /*
 114          *  modem specific commands
 115          */
 116         Cerrorcorrection        = 0,    /* error correction */
 117         Ccompression,                   /* compression */
 118         Cflowctl,                       /* CTS/RTS */
 119         Crateadjust,                    /* follow line speed */
 120         Cfclass2,                       /* set up for fax */
 121         Cfclass0,                       /* set up for data */
 122         Ncommand,
 123 };
 124
 125 struct Type
 126 {
 127         char    *name;
 128         char    *ident;         /* inquire request */
 129         char    *response;      /* inquire response (strstr) */
 130         char    *basetype;      /* name of base type */
 131
 132         char    *commands[Ncommand];
 133 };
 134
 135 /*
 136  *  Fax setup summary
 137  *
 138  *      FCLASS=2        - set to service class 2, i.e., one where the fax handles timing
 139  *      FTBC=0          - ???
 140  *      FREL=1          - ???
 141  *      FCQ=1           - receive copy quality checking enabled
 142  *      FBOR=1          - set reversed bit order for phase C data
 143  *      FCR=1           - the DCE can receive message data, bit 10 in the DIS or
 144  *                        DTC frame will be set
 145  *      FDIS=,3         - limit com speed to 9600 baud
 146  */
 147
 148 Type typetab[] =
 149 {
 150  {      "Rockwell",             0,      0,      0,
 151         "AT\\N7",       /* auto reliable (V.42, fall back to MNP, to none) */
 152         "AT%C1\\J0",    /* negotiate for compression, don't change port baud rate */
 153         "AT\\Q3",       /* CTS/RTS flow control */
 154         "AT\\J1",
 155         "AT+FCLASS=2\rAT+FCR=1\r",
 156         "AT+FCLASS=0",
 157  },
 158
 159  {      "ATT2400",      "ATI9", "E2400",        "Rockwell",
 160         "AT\\N3",       /* auto reliable (MNP, fall back to none) */
 161         0,
 162         0,
 163         0,
 164         0,
 165         0,
 166  },
 167
 168  {      "ATT14400",     "ATI9", "E14400",       "Rockwell",
 169         0,
 170         0,
 171         0,
 172         0,
 173         0,
 174         0,
 175  },
 176
 177  {      "MT1432",       "ATI2", "MT1432",       0,
 178         "AT&E1",        /* auto reliable (V.42, fall back to none) */
 179         "AT&E15$BA0",   /* negotiate for compression */
 180         "AT&E4",        /* CTS/RTS flow control */
 181         "AT$BA1",       /* don't change port baud rate */
 182         "AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1\rAT+FDIS=,3",
 183         "AT+FCLASS=0",
 184  },
 185
 186  {      "MT2834",       "ATI2", "MT2834",       "MT1432",
 187         0,
 188         0,
 189         0,
 190         0,
 191         "AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1",
 192         0,
 193  },
 194
 195  {      "VOCAL",        "ATI6", "144DPL+FAX",   "Rockwell",
 196         "AT\\N3",       /* auto reliable (V.42, fall back to MNP, fall back to none) */
 197         "AT%C3\\J0",    /* negotiate for compression, don't change port baud rate */
 198         0,
 199         0,
 200         "AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1",
 201         "AT+FCLASS=0",
 202  },
 203
 204  { 0, },
 205 };
 206
 207 /*
 208  *  modem return codes
 209  */
 210 enum
 211 {
 212         Ok,
 213         Success,
 214         Failure,
 215         Noise,
 216         Found,
 217 };
 218
 219 /*
 220  *  modem return messages
 221  */
 222 typedef struct Msg      Msg;
 223 struct Msg
 224 {
 225         char    *text;
 226         int     type;
 227 };
 228
 229 Msg msgs[] =
 230 {
 231         { "OK",                 Ok, },
 232         { "NO CARRIER",         Failure, },
 233         { "ERROR",              Failure, },
 234         { "NO DIALTONE",        Failure, },
 235         { "BUSY",               Failure, },
 236         { "NO ANSWER",          Failure, },
 237         { "CONNECT",            Success, },
 238         { 0,                    0 },
 239 };
 240
 241 Fid     *fids;
 242 Dev     *dev;
 243 int     ndev;
 244 int     mfd[2];
 245 char    *user;
 246 uchar   mdata[8192+IOHDRSZ];
 247 int     messagesize = sizeof mdata;
 248 Fcall   thdr;
 249 Fcall   rhdr;
 250 char    errbuf[ERRMAX];
 251 uchar   statbuf[STATMAX];
 252 int     pulsed;
 253 int     verbose;
 254 int     maxspeed = 56000;
 255 char    *srcid = "plan9";
 256 int     answer = 1;
 257
 258 Fid     *newfid(int);
 259 int     devstat(Dir*, uchar*, int);
 260 int     devgen(Qid, int, Dir*, uchar*, int);
 261 void    error(char*);
 262 void    io(void);
 263 void    *erealloc(void*, ulong);
 264 void    *emalloc(ulong);
 265 void    usage(void);
 266 int     perm(Fid*, Dev*, int);
 267 void    setspeed(Dev*, int);
 268 int     getspeed(char*, int);
 269 char    *dialout(Dev*, char*);
 270 void    onhook(Dev*);
 271 int     readmsg(Dev*, int, char*);
 272 void    monitor(Dev*);
 273 int     getinput(Dev*, char*, int);
 274 void    serve(Dev*);
 275 void    receiver(Dev*);
 276 char*   modemtype(Dev*, int, int);
 277
 278
 279 char    *rflush(Fid*), *rversion(Fid*),
 280         *rattach(Fid*), *rauth(Fid*), *rwalk(Fid*),
 281         *ropen(Fid*), *rcreate(Fid*),
 282         *rread(Fid*), *rwrite(Fid*), *rclunk(Fid*),
 283         *rremove(Fid*), *rstat(Fid*), *rwstat(Fid*);
 284
 285 char    *(*fcalls[])(Fid*) = {
 286         [Tflush]        rflush,
 287         [Tversion]      rversion,
 288         [Tattach]       rattach,
 289         [Tauth] rauth,
 290         [Twalk]         rwalk,
 291         [Topen]         ropen,
 292         [Tcreate]       rcreate,
 293         [Tread]         rread,
 294         [Twrite]        rwrite,
 295         [Tclunk]        rclunk,
 296         [Tremove]       rremove,
 297         [Tstat]         rstat,
 298         [Twstat]        rwstat,
 299 };
 300
 301 char    Eperm[] =       "permission denied";
 302 char    Enotdir[] =     "not a directory";
 303 char    Enotexist[] =   "file does not exist";
 304 char    Ebadaddr[] =    "bad address";
 305 char    Eattn[] =       "can't get modem's attention";
 306 char    Edial[] =       "can't dial";
 307 char    Enoauth[] =     "telco: authentication not required";
 308 char    Eisopen[] =     "file already open for I/O";
 309 char    Enodev[] =      "no free modems";
 310 char    Enostream[] =   "stream closed prematurely";
 311
 312 void
 313 usage(void)
 314 {
 315         fprint(2, "usage: %s [-vp] [-i srcid] dev ...\n", argv0);
 316         exits("usage");
 317 }
 318
 319 void
 320 notifyf(void *a, char *s)
 321 {
 322         USED(a);
 323         if(strncmp(s, "interrupt", 9) == 0)
 324                 noted(NCONT);
 325         noted(NDFLT);
 326 }
 327
 328 void
 329 main(int argc, char *argv[])
 330 {
 331         int p[2];
 332         int fd;
 333         char buf[10];
 334         Dev *d;
 335
 336         ARGBEGIN{
 337         case 'p':
 338                 pulsed = 1;
 339                 break;
 340         case 'v':
 341                 verbose = 1;
 342                 break;
 343         case 'i':
 344                 srcid = ARGF();
 345                 break;
 346         case 's':
 347                 maxspeed = atoi(ARGF());
 348                 break;
 349         case 'n':
 350                 answer = 0;
 351                 break;
 352         default:
 353                 usage();
 354         }ARGEND
 355
 356         if(argc == 0)
 357                 usage();
 358         if(argc > Ndev)
 359                 argc = Ndev;
 360
 361         if(pipe(p) < 0)
 362                 error("pipe failed");
 363
 364         notify(notifyf);
 365         fmtinstall('F', fcallfmt);
 366         user = getuser();
 367
 368         switch(rfork(RFFDG|RFPROC|RFREND|RFNOTEG)){
 369         case -1:
 370                 error("fork");
 371         case 0:
 372                 close(p[1]);
 373                 mfd[0] = mfd[1] = p[0];
 374                 break;
 375         default:
 376                 close(p[0]);
 377                 fd = create("/srv/telco", OWRITE, 0666);
 378                 if(fd < 0)
 379                         error("create of /srv/telco failed");
 380                 sprint(buf, "%d", p[1]);
 381                 if(write(fd, buf, strlen(buf)) < 0)
 382                         error("writing /srv/telco");
 383                 close(fd);
 384                 if(mount(p[1], -1, "/net", MBEFORE, "") < 0)
 385                         error("mount failed");
 386                 exits(0);
 387         }
 388
 389         dev = mallocz(argc*sizeof(Dev), 1);
 390         for(ndev = 0; ndev < argc; ndev++){
 391                 d = &dev[ndev];
 392                 d->path = argv[ndev];
 393                 d->rp = d->wp = d->rbuf;
 394                 monitor(d);
 395                 d->open++;
 396                 onhook(d);
 397                 d->open--;
 398         }
 399
 400         io();
 401 }
 402
 403 /*
 404  *  generate a stat structure for a qid
 405  */
 406 int
 407 devstat(Dir *dir, uchar *buf, int nbuf)
 408 {
 409         Dev *d;
 410         int t;
 411         static char tmp[10][32];
 412         static int ntmp;
 413
 414         t = TYPE(dir->qid);
 415         if(t != Qlvl3)
 416                 dir->name = names[t];
 417         else{
 418                 dir->name = tmp[ntmp % nelem(tmp)];
 419                 sprint(dir->name, "%lud", DEV(dir->qid));
 420                 ntmp++;
 421         }
 422         dir->mode = 0755;
 423         dir->uid = user;
 424         dir->gid = user;
 425         dir->muid = user;
 426         if(t >= Qlvl3){
 427                 d = &dev[DEV(dir->qid)];
 428                 if(d->open){
 429                         dir->mode = d->perm;
 430                         dir->uid = d->user;
 431                 }
 432         }
 433         if(dir->qid.type & QTDIR)
 434                 dir->mode |= DMDIR;
 435         if(t == Qdata){
 436                 d = &dev[DEV(dir->qid)];
 437                 dir->length = d->wp - d->rp;
 438                 if(dir->length < 0)
 439                         dir->length += Nrbuf;
 440         } else
 441                 dir->length = 0;
 442         dir->atime = time(0);
 443         dir->mtime = dir->atime;
 444         if(buf)
 445                 return convD2M(dir, buf, nbuf);
 446         return 0;
 447 }
 448
 449 /*
 450  *  enumerate file's we can walk to from q
 451  */
 452 int
 453 devgen(Qid q, int i, Dir *d, uchar *buf, int nbuf)
 454 {
 455         static ulong v;
 456
 457         d->qid.vers = v++;
 458         switch(TYPE(q)){
 459         case Qlvl1:
 460                 if(i != 0)
 461                         return -1;
 462                 d->qid.type = QTDIR;
 463                 d->qid.path = Qlvl2;
 464                 break;
 465         case Qlvl2:
 466                 switch(i){
 467                 case -1:
 468                         d->qid.type = QTDIR;
 469                         d->qid.path = Qlvl1;
 470                         break;
 471                 case 0:
 472                         d->qid.type = QTFILE;
 473                         d->qid.path = Qclone;
 474                         break;
 475                 default:
 476                         if(i > ndev)
 477                                 return -1;
 478                         d->qid.type = QTDIR;
 479                         d->qid.path = MKQID(Qlvl3, i-1);
 480                         break;
 481                 }
 482                 break;
 483         case Qlvl3:
 484                 switch(i){
 485                 case -1:
 486                         d->qid.type = QTDIR;
 487                         d->qid.path = Qlvl2;
 488                         break;
 489                 case 0:
 490                         d->qid.type = QTFILE;
 491                         d->qid.path = MKQID(Qdata, DEV(q));
 492                         break;
 493                 case 1:
 494                         d->qid.type = QTFILE;
 495                         d->qid.path = MKQID(Qctl, DEV(q));
 496                         break;
 497                 default:
 498                         return -1;
 499                 }
 500                 break;
 501         default:
 502                 return -1;
 503         }
 504         return devstat(d, buf, nbuf);
 505 }
 506
 507 char*
 508 rversion(Fid *)
 509 {
 510         Fid *f;
 511
 512         for(f = fids; f; f = f->next)
 513                 if(f->busy)
 514                         rclunk(f);
 515
 516         if(thdr.msize < 256)
 517                 return "version: message size too small";
 518         messagesize = thdr.msize;
 519         if(messagesize > sizeof mdata)
 520                 messagesize = sizeof mdata;
 521         rhdr.msize = messagesize;
 522         if(strncmp(thdr.version, "9P2000", 6) != 0)
 523                 return "unrecognized 9P version";
 524         rhdr.version = "9P2000";
 525         return 0;
 526 }
 527
 528 char*
 529 rflush(Fid *f)
 530 {
 531         Request *r, **l;
 532         Dev *d;
 533
 534         USED(f);
 535         for(d = dev; d < &dev[ndev]; d++){
 536                 lock(d);
 537                 for(l = &d->r; r = *l; l = &r->next)
 538                         if(r->tag == thdr.oldtag){
 539                                 *l = r->next;
 540                                 free(r);
 541                                 break;
 542                         }
 543                 unlock(d);
 544         }
 545         return 0;
 546 }
 547
 548 char *
 549 rauth(Fid *f)
 550 {
 551         USED(f);
 552         return Enoauth;
 553 }
 554
 555 char*
 556 rattach(Fid *f)
 557 {
 558         f->busy = 1;
 559         f->qid.type = QTDIR;
 560         f->qid.path = Qlvl1;
 561         f->qid.vers = 0;
 562         rhdr.qid = f->qid;
 563         if(thdr.uname[0])
 564                 f->user = strdup(thdr.uname);
 565         else
 566                 f->user = "none";
 567         return 0;
 568 }
 569
 570 char*
 571 rwalk(Fid *f)
 572 {
 573         Fid *nf;
 574         int i, nqid;
 575         char *name, *err;
 576         Dir dir;
 577         Qid q;
 578
 579         nf = nil;
 580         if(thdr.fid != thdr.newfid){
 581                 if(f->open)
 582                         return Eisopen;
 583                 if(f->busy == 0)
 584                         return Enotexist;
 585                 nf = newfid(thdr.newfid);
 586                 nf->busy = 1;
 587                 nf->open = 0;
 588                 nf->qid = f->qid;
 589                 nf->user = strdup(f->user);
 590                 f = nf; /* walk f */
 591         }
 592
 593         err = nil;
 594         dir.qid = f->qid;
 595         nqid = 0;
 596         if(thdr.nwname > 0){
 597                 for(; nqid < thdr.nwname; nqid++) {
 598                         if((dir.qid.type & QTDIR) == 0){
 599                                 err = Enotdir;
 600                                 break;
 601                         }
 602                         name = thdr.wname[nqid];
 603                         if(strcmp(name, ".") == 0){
 604                                 /* nothing to do */
 605                         }else if(strcmp(name, "..") == 0) {
 606                                 if(devgen(f->qid, -1, &dir, 0, 0) < 0)
 607                                         break;
 608                         }
 609                         else{
 610                                 q = dir.qid;
 611                                 for(i = 0;; i++){
 612                                         if(devgen(q, i, &dir, 0, 0) < 0)
 613                                                 goto Out;
 614                                         if(strcmp(name, dir.name) == 0)
 615                                                 break;
 616                                 }
 617                         }
 618                         rhdr.wqid[nqid] = dir.qid;
 619                 }
 620     Out:
 621                 if(nqid == 0 && err == nil)
 622                         err = Enotexist;
 623                 if(nf != nil && thdr.fid != thdr.newfid && nqid < thdr.nwname)
 624                         rclunk(nf);
 625         }
 626
 627         rhdr.nwqid = nqid;
 628         if(nqid > 0 && nqid == thdr.nwname)
 629                 f->qid = dir.qid;
 630         return err;
 631 }
 632
 633 char *
 634 ropen(Fid *f)
 635 {
 636         Dev *d;
 637         int mode, t;
 638
 639         if(f->open)
 640                 return Eisopen;
 641         mode = thdr.mode;
 642         mode &= OPERM;
 643         if(f->qid.type & QTDIR){
 644                 if(mode != OREAD)
 645                         return Eperm;
 646                 rhdr.qid = f->qid;
 647                 return 0;
 648         }
 649         if(mode==OEXEC)
 650                 return Eperm;
 651         t = TYPE(f->qid);
 652         if(t == Qclone){
 653                 for(d = dev; d < &dev[ndev]; d++)
 654                         if(d->open == 0)
 655                                 break;
 656                 if(d == &dev[ndev])
 657                         return Enodev;
 658                 f->qid.path = MKQID(Qctl, d-dev);
 659                 t = Qctl;
 660         }
 661         switch(t){
 662         case Qdata:
 663         case Qctl:
 664                 d = &dev[DEV(f->qid)];
 665                 if(d->open == 0){
 666                         d->user = strdup(f->user);
 667                         d->perm = 0660;
 668                 }else {
 669                         if(mode==OWRITE || mode==ORDWR)
 670                                 if(!perm(f, d, Pwrite))
 671                                         return Eperm;
 672                         if(mode==OREAD || mode==ORDWR)
 673                                 if(!perm(f, d, Pread))
 674                                         return Eperm;
 675                 }
 676                 d->open++;
 677                 break;
 678         }
 679         rhdr.qid = f->qid;
 680         rhdr.iounit = messagesize - IOHDRSZ;
 681         f->open = 1;
 682         return 0;
 683 }
 684
 685 char *
 686 rcreate(Fid *f)
 687 {
 688         USED(f);
 689         return Eperm;
 690 }
 691
 692 /*
 693  *  intercept a note
 694  */
 695 void
 696 takeanote(void *u, char *note)
 697 {
 698         USED(u);
 699         if(strstr(note, "interrupted"))
 700                 noted(NCONT);
 701         noted(NDFLT);
 702 }
 703
 704 char*
 705 rread(Fid *f)
 706 {
 707         char *buf;
 708         long off, start;
 709         int i, m, n, cnt, t;
 710         Dir dir;
 711         char num[32];
 712         Dev *d;
 713         Request *r;
 714
 715         n = 0;
 716         rhdr.count = 0;
 717         off = thdr.offset;
 718         cnt = thdr.count;
 719         buf = rhdr.data;
 720         t = TYPE(f->qid);
 721         switch(t){
 722         default:
 723                 start = 0;
 724                 for(i = 0; n < cnt; i++){
 725                         m = devgen(f->qid, i, &dir, (uchar*)buf+n, cnt-n);
 726                         if(m <= BIT16SZ)
 727                                 break;
 728                         if(start >= off)
 729                                 n += m;
 730                         start += m;
 731                 }
 732                 break;
 733         case Qctl:
 734                 i = sprint(num, "%lud", DEV(f->qid));
 735                 if(off < i){
 736                         n = cnt;
 737                         if(off + n > i)
 738                                 n = i - off;
 739                         memmove(buf, num + off, n);
 740                 } else
 741                         n = 0;
 742                 break;
 743         case Qdata:
 744                 d = &dev[DEV(f->qid)];
 745                 r = mallocz(sizeof(Request), 1);
 746                 r->tag = thdr.tag;
 747                 r->count = thdr.count;
 748                 r->fid = f;
 749                 r->flushed = 0;
 750                 lock(d);
 751                 if(d->r)
 752                         d->rlast->next = r;
 753                 else
 754                         d->r = r;
 755                 d->rlast = r;
 756                 serve(d);
 757                 unlock(d);
 758                 return "";
 759         }
 760         rhdr.count = n;
 761         return 0;
 762 }
 763
 764 char *cmsg = "connect ";
 765 int clen;
 766
 767 char*
 768 rwrite(Fid *f)
 769 {
 770         Dev *d;
 771         ulong off;
 772         int cnt;
 773         char *cp;
 774         char buf[64];
 775
 776         off = thdr.offset;
 777         cnt = thdr.count;
 778         switch(TYPE(f->qid)){
 779         default:
 780                 return "file is a directory";
 781         case Qctl:
 782                 d = &dev[DEV(f->qid)];
 783                 clen = strlen(cmsg);
 784                 if(cnt < clen || strncmp(thdr.data, cmsg, clen) != 0){
 785                         /*
 786                          *  send control message to real control file
 787                          */
 788                         if(seek(d->ctl, off, 0) < 0 || write(d->ctl, thdr.data, cnt) < 0){
 789                                 errstr(errbuf, sizeof errbuf);
 790                                 return errbuf;
 791                         }
 792                 } else {
 793                         /*
 794                          *  connect
 795                          */
 796                         cnt -= clen;
 797                         if(cnt >= sizeof(buf))
 798                                 cnt = sizeof(buf) - 1;
 799                         if(cnt < 0)
 800                                 return Ebadaddr;
 801                         strncpy(buf, &thdr.data[clen], cnt);
 802                         buf[cnt] = 0;
 803                         cp = dialout(d, buf);
 804                         if(cp)
 805                                 return cp;
 806                 }
 807                 rhdr.count = cnt;
 808                 break;
 809         case Qdata:
 810                 d = &dev[DEV(f->qid)];
 811                 if(write(d->data, thdr.data, cnt) < 0){
 812                         errstr(errbuf, sizeof errbuf);
 813                         return errbuf;
 814                 }
 815                 rhdr.count = cnt;
 816                 break;
 817         }
 818         return 0;
 819 }
 820
 821 char *
 822 rclunk(Fid *f)
 823 {
 824         Dev *d;
 825
 826         if(f->open)
 827                 switch(TYPE(f->qid)){
 828                 case Qdata:
 829                 case Qctl:
 830                         d = &dev[DEV(f->qid)];
 831                         if(d->open == 1)
 832                                 onhook(d);
 833                         d->open--;
 834                         break;
 835                 }
 836         free(f->user);
 837         f->busy = 0;
 838         f->open = 0;
 839         return 0;
 840 }
 841
 842 char *
 843 rremove(Fid *f)
 844 {
 845         USED(f);
 846         return Eperm;
 847 }
 848
 849 char *
 850 rstat(Fid *f)
 851 {
 852         Dir d;
 853
 854         d.qid = f->qid;
 855         rhdr.stat = statbuf;
 856         rhdr.nstat = devstat(&d, statbuf, sizeof statbuf);
 857         return 0;
 858 }
 859
 860 char *
 861 rwstat(Fid *f)
 862 {
 863         Dev *d;
 864         Dir dir;
 865
 866         if(TYPE(f->qid) < Qlvl3)
 867                 return Eperm;
 868
 869         convM2D(thdr.stat, thdr.nstat, &dir, rhdr.data);        /* rhdr.data is a known place to scribble */
 870         d = &dev[DEV(f->qid)];
 871
 872         /*
 873          * To change mode, must be owner
 874          */
 875         if(d->perm != dir.mode){
 876                 if(strcmp(f->user, d->user) != 0)
 877                 if(strcmp(f->user, user) != 0)
 878                         return Eperm;
 879         }
 880
 881         /* all ok; do it */
 882         d->perm = dir.mode & ~DMDIR;
 883         return 0;
 884 }
 885
 886 Fid *
 887 newfid(int fid)
 888 {
 889         Fid *f, *ff;
 890
 891         ff = 0;
 892         for(f = fids; f; f = f->next)
 893                 if(f->fid == fid)
 894                         return f;
 895                 else if(!ff && !f->busy)
 896                         ff = f;
 897         if(ff){
 898                 ff->fid = fid;
 899                 return ff;
 900         }
 901         f = emalloc(sizeof *f);
 902         f->fid = fid;
 903         f->next = fids;
 904         fids = f;
 905         return f;
 906 }
 907
 908 /*
 909  *  read fs requests and dispatch them
 910  */
 911 void
 912 io(void)
 913 {
 914         char *err;
 915         int n;
 916
 917         for(;;){
 918                 /*
 919                  * reading from a pipe or a network device
 920                  * will give an error after a few eof reads
 921                  * however, we cannot tell the difference
 922                  * between a zero-length read and an interrupt
 923                  * on the processes writing to us,
 924                  * so we wait for the error
 925                  */
 926                 n = read9pmsg(mfd[0], mdata, messagesize);
 927                 if(n == 0)
 928                         continue;
 929                 if(n < 0)
 930                         error("mount read");
 931                 if(convM2S(mdata, n, &thdr) != n)
 932                         error("convM2S error");
 933
 934                 rhdr.data = (char*)mdata + IOHDRSZ;
 935                 if(!fcalls[thdr.type])
 936                         err = "bad fcall type";
 937                 else
 938                         err = (*fcalls[thdr.type])(newfid(thdr.fid));
 939                 if(err){
 940                         if(*err == 0)
 941                                 continue;       /* assigned to a slave */
 942                         rhdr.type = Rerror;
 943                         rhdr.ename = err;
 944                 }else{
 945                         rhdr.type = thdr.type + 1;
 946                         rhdr.fid = thdr.fid;
 947                 }
 948                 rhdr.tag = thdr.tag;
 949                 n = convS2M(&rhdr, mdata, messagesize);
 950                 if(write(mfd[1], mdata, n) != n)
 951                         error("mount write");
 952         }
 953 }
 954
 955
 956 int
 957 perm(Fid *f, Dev *d, int p)
 958 {
 959         if((p*Pother) & d->perm)
 960                 return 1;
 961         if(strcmp(f->user, user)==0 && ((p*Pgroup) & d->perm))
 962                 return 1;
 963         if(strcmp(f->user, d->user)==0 && ((p*Powner) & d->perm))
 964                 return 1;
 965         return 0;
 966 }
 967
 968 void
 969 error(char *s)
 970 {
 971         fprint(2, "%s: %s: %r\n", argv0, s);
 972         syslog(0, LOGFILE, "%s: %r", s);
 973         remove("/srv/telco");
 974         postnote(PNGROUP, getpid(), "exit");
 975         exits(s);
 976 }
 977
 978 void *
 979 emalloc(ulong n)
 980 {
 981         void *p;
 982
 983         p = mallocz(n, 1);
 984         if(!p)
 985                 error("out of memory");
 986         return p;
 987 }
 988
 989 void *
 990 erealloc(void *p, ulong n)
 991 {
 992         p = realloc(p, n);
 993         if(!p)
 994                 error("out of memory");
 995         return p;
 996 }
 997
 998 /*
 999  *  send bytes to modem
1000  */
1001 int
1002 send(Dev *d, char *x)
1003 {
1004         if(verbose)
1005                 syslog(0, LOGFILE, "->%s", x);
1006         return write(d->data, x, strlen(x));
1007 }
1008
1009 /*
1010  *  apply a string of commands to modem
1011  */
1012 int
1013 apply(Dev *d, char *s, char *substr, int secs)
1014 {
1015         char buf[128];
1016         char *p;
1017         int c, m;
1018
1019         p = buf;
1020         m = Ok;
1021         while(*s){
1022                 c = *p++ = *s++;
1023                 if(c == '\r' || *s == 0){
1024                         if(c != '\r')
1025                                 *p++ = '\r';
1026                         *p = 0;
1027                         if(send(d, buf) < 0)
1028                                 return Failure;
1029                         m = readmsg(d, secs, substr);
1030                         p = buf;
1031                 }
1032         }
1033         return m;
1034 }
1035
1036 /*
1037  *  apply a command type
1038  */
1039 int
1040 applyspecial(Dev *d, int index)
1041 {
1042         char *cmd;
1043
1044         cmd = d->t->commands[index];
1045         if(cmd == 0 && d->baset)
1046                 cmd = d->baset->commands[index];
1047         if(cmd == 0)
1048                 return Failure;
1049
1050         return apply(d, cmd, 0, 2);
1051 }
1052
1053 /*
1054  *  get modem into command mode if it isn't already
1055  */
1056 int
1057 attention(Dev *d)
1058 {
1059         int i;
1060
1061         for(i = 0; i < 2; i++){
1062                 sleep(250);
1063                 if(send(d, "+") < 0)
1064                         continue;
1065                 sleep(250);
1066                 if(send(d, "+") < 0)
1067                         continue;
1068                 sleep(250);
1069                 if(send(d, "+") < 0)
1070                         continue;
1071                 sleep(250);
1072                 readmsg(d, 0, 0);
1073                 if(apply(d, "ATZH0", 0, 2) == Ok)
1074                         return Ok;
1075         }
1076         return Failure;
1077 }
1078
1079 int portspeed[] = { 56000, 38400, 19200, 14400, 9600, 4800, 2400, 1200, 600, 300, 0 };
1080
1081 /*
1082  *  get the modem's type and speed
1083  */
1084 char*
1085 modemtype(Dev *d, int limit,  int fax)
1086 {
1087         int *p;
1088         Type *t, *bt;
1089         char buf[28];
1090
1091         d->t = typetab;
1092         d->baset = 0;
1093
1094         /* assume we're at a good speed, try getting attention a few times */
1095         attention(d);
1096
1097         /* find a common port rate */
1098         for(p = portspeed; *p; p++){
1099                 if(*p > limit)
1100                         continue;
1101                 setspeed(d, *p);
1102                 if(attention(d) == Ok)
1103                         break;
1104         }
1105         if(*p == 0)
1106                 return Eattn;
1107         d->speed = *p;
1108         if(verbose)
1109                 syslog(0, LOGFILE, "port speed %d", *p);
1110
1111         /*
1112          *  basic Hayes commands everyone implements (we hope)
1113          *      Q0 = report result codes
1114          *      V1 = full word result codes
1115          *      E0 = don't echo commands
1116          *      M1 = speaker on until on-line
1117          *      S0=0 = autoanswer off
1118          */
1119         if(apply(d, "ATQ0V1E0M1S0=0", 0, 2) != Ok)
1120                 return Eattn;
1121
1122         /* find modem type */
1123         for(t = typetab; t->name; t++){
1124                 if(t->ident == 0 || t->response == 0)
1125                         continue;
1126                 if(apply(d, t->ident, t->response, 2) == Found)
1127                         break;
1128                 readmsg(d, 0, 0);
1129         }
1130         readmsg(d, 0, 0);
1131         if(t->name){
1132                 d->t = t;
1133                 if(t->basetype){
1134                         for(bt = typetab; bt->name; bt++)
1135                                 if(strcmp(bt->name, t->basetype) == 0)
1136                                         break;
1137                         if(bt->name)
1138                                 d->baset = bt;
1139                 }
1140         }
1141         if(verbose)
1142                 syslog(0, LOGFILE, "modem %s", d->t->name);
1143
1144         /* try setting fax modes */
1145         d->fclass = 0;
1146         if(fax){
1147                 /* set up fax parameters */
1148                 if(applyspecial(d, Cfclass2) != Failure)
1149                         d->fclass = 2;
1150
1151                 /* setup a source id */
1152                 if(srcid){
1153                         sprint(buf, "AT+FLID=\"%s\"", srcid);
1154                         apply(d, buf, 0, 2);
1155                 }
1156
1157                 /* allow both data and fax calls in */
1158                 apply(d, "AT+FAA=1", 0, 2);
1159         } else
1160                 applyspecial(d, Cfclass0);
1161         return 0;
1162 }
1163
1164 /*
1165  *  a process to read input from a modem.
1166  */
1167 void
1168 monitor(Dev *d)
1169 {
1170         int n;
1171         char *p;
1172         char file[256];
1173         int background;
1174
1175         background = 0;
1176         d->ctl = d->data = -1;
1177
1178         for(;;){
1179                 lock(d);
1180                 sprint(file, "%sctl", d->path);
1181                 d->ctl = open(file, ORDWR);
1182                 if(d->ctl < 0)
1183                         error("opening ctl");
1184                 d->data = open(d->path, ORDWR);
1185                 if(d->data < 0)
1186                         error("opening data");
1187                 d->wp = d->rp = d->rbuf;
1188                 unlock(d);
1189
1190                 if(!background){
1191                         background = 1;
1192                         switch(d->pid = rfork(RFPROC|RFMEM)){
1193                         case -1:
1194                                 error("out of processes");
1195                         case 0:
1196                                 break;
1197                         default:
1198                                 return;
1199                         }
1200                 }
1201
1202                 /* wait for ring or off hook */
1203                 while(d->open == 0){
1204                         d->rp = d->rbuf;
1205                         p = d->wp;
1206                         n = read(d->data, p, 1);
1207                         if(n < 1)
1208                                 continue;
1209                         if(p < &d->rbuf[Nrbuf] - 2)
1210                                 d->wp++;
1211                         if(*p == '\r' || *p == '\n'){
1212                                 *(p+1) = 0;
1213                                 if(verbose)
1214                                         syslog(0, LOGFILE, "<:-%s", d->rp);
1215                                 if(answer && strncmp(d->rp, "RING", 4) == 0){
1216                                         receiver(d);
1217                                         continue;
1218                                 }
1219                                 if(d->open == 0)
1220                                         d->wp = d->rbuf;
1221                         }
1222                 }
1223
1224                 /* shuttle bytes till on hook */
1225                 while(d->open){
1226                         if(d->wp >= d->rp)
1227                                 n = &d->rbuf[Nrbuf] - d->wp;
1228                         else
1229                                 n = d->rp - d->wp - 1;
1230                         if(n > 0)
1231                                 n = read(d->data, d->wp, n);
1232                         else {
1233                                 read(d->data, file, sizeof(file));
1234                                 continue;
1235                         }
1236                         if(n < 0)
1237                                 break;
1238                         lock(d);
1239                         if(d->wp + n >= &d->rbuf[Nrbuf])
1240                                 d->wp = d->rbuf;
1241                         else
1242                                 d->wp += n;
1243                         serve(d);
1244                         unlock(d);
1245                 }
1246
1247                 close(d->ctl);
1248                 close(d->data);
1249         }
1250 }
1251
1252 /*
1253  *  get bytes input by monitor() (only routine that changes d->rp)
1254  */
1255 int
1256 getinput(Dev *d, char *buf, int n)
1257 {
1258         char *p;
1259         int i;
1260
1261         p = buf;
1262         while(n > 0){
1263                 if(d->wp == d->rp)
1264                         break;
1265                 if(d->wp < d->rp)
1266                         i = &d->rbuf[Nrbuf] - d->rp;
1267                 else
1268                         i = d->wp - d->rp;
1269                 if(i > n)
1270                         i = n;
1271                 memmove(p, d->rp, i);
1272                 if(d->rp + i == &d->rbuf[Nrbuf])
1273                         d->rp = d->rbuf;
1274                 else
1275                         d->rp += i;
1276                 n -= i;
1277                 p += i;
1278         }
1279         return p - buf;
1280 }
1281
1282 /*
1283  *  fulfill a read request (we assume d is locked)
1284  */
1285 void
1286 serve(Dev *d)
1287 {
1288         Request *r;
1289         int n;
1290         Fcall rhdr;
1291         uchar *mdata;
1292         char *buf;
1293
1294         mdata = malloc(messagesize);
1295         buf = malloc(messagesize-IOHDRSZ);
1296
1297         for(;;){
1298                 if(d->r == 0 || d->rp == d->wp)
1299                         break;
1300                 r = d->r;
1301                 if(r->count > sizeof(buf))
1302                         r->count = sizeof(buf);
1303
1304                 n = getinput(d, buf, r->count);
1305                 if(n == 0)
1306                         break;
1307                 d->r = r->next;
1308
1309                 rhdr.type = Rread;
1310                 rhdr.fid = r->fid->fid;
1311                 rhdr.tag = r->tag;
1312                 rhdr.data = buf;
1313                 rhdr.count = n;
1314                 n = convS2M(&rhdr, mdata, messagesize);
1315                 if(write(mfd[1], mdata, n) != n)
1316                         fprint(2, "telco: error writing\n");
1317                 free(r);
1318         }
1319         free(mdata);
1320         free(buf);
1321 }
1322
1323 /*
1324  *  dial a number
1325  */
1326 char*
1327 dialout(Dev *d, char *number)
1328 {
1329         int i, m, compress, rateadjust, speed, fax;
1330         char *err;
1331         char *field[5];
1332         char dialstr[128];
1333
1334         compress = Ok;
1335         rateadjust = Failure;
1336         speed = maxspeed;
1337         fax = Failure;
1338
1339         m = getfields(number, field, 5, 1, "!");
1340         for(i = 1; i < m; i++){
1341                 if(field[i][0] >= '0' && field[i][0] <= '9')
1342                         speed = atoi(field[i]);
1343                 else if(strcmp(field[i], "nocompress") == 0)
1344                         compress = Failure;
1345                 else if(strcmp(field[i], "fax") == 0)
1346                         fax = Ok;
1347         }
1348
1349         syslog(0, LOGFILE, "dialing %s speed=%d %s", number, speed, fax==Ok?"fax":"");
1350
1351         err = modemtype(d, speed, fax == Ok);
1352         if(err)
1353                 return err;
1354
1355         /*
1356          *  extented Hayes commands, meaning depends on modem (VGA all over again)
1357          */
1358         if(fax != Ok){
1359                 if(d->fclass != 0)
1360                         applyspecial(d, Cfclass0);
1361                 applyspecial(d, Cerrorcorrection);
1362                 if(compress == Ok)
1363                         compress = applyspecial(d, Ccompression);
1364                 if(compress != Ok)
1365                         rateadjust = applyspecial(d, Crateadjust);
1366         }
1367         applyspecial(d, Cflowctl);
1368
1369         /* dialout */
1370         sprint(dialstr, "ATD%c%s\r", pulsed ? 'P' : 'T', number);
1371         if(send(d, dialstr) < 0)
1372                 return Edial;
1373
1374         if(fax == Ok)
1375                 return 0;               /* fax sender worries about the rest */
1376
1377         switch(readmsg(d, 120, 0)){
1378         case Success:
1379                 break;
1380         default:
1381                 return d->msgbuf;
1382         }
1383
1384         /* change line rate if not compressing */
1385         if(rateadjust == Ok)
1386                 setspeed(d, getspeed(d->msgbuf, d->speed));
1387
1388         return 0;
1389 }
1390
1391 /*
1392  *  start a receiving process
1393  */
1394 void
1395 receiver(Dev *d)
1396 {
1397         int fd;
1398         char file[256];
1399         char *argv[8];
1400         int argc;
1401         int pfd[2];
1402         char *prog;
1403
1404         pipe(pfd);
1405         switch(rfork(RFPROC|RFMEM|RFFDG|RFNAMEG)){
1406         case -1:
1407                 return;
1408         case 0:
1409                 fd = open("/srv/telco", ORDWR);
1410                 if(fd < 0){
1411                         syslog(0, LOGFILE, "can't open telco: %r");
1412                         exits(0);
1413                 }
1414                 if(mount(fd, -1, "/net", MAFTER, "") < 0){
1415                         syslog(0, LOGFILE, "can't mount: %r");
1416                         exits(0);
1417                 }
1418                 close(fd);
1419
1420                 /* open connection through the file system interface */
1421                 sprint(file, "/net/telco/%ld/data", d - dev);
1422                 fd = open(file, ORDWR);
1423                 if(fd < 0){
1424                         syslog(0, LOGFILE, "can't open %s: %r", file);
1425                         exits(0);
1426                 }
1427
1428                 /* let parent continue */
1429                 close(pfd[0]);
1430                 close(pfd[1]);
1431
1432                 /* answer the phone and see what flavor call this is */
1433                 prog = "/bin/service/telcodata";
1434                 switch(apply(d, "ATA", "+FCON", 30)){
1435                 case Success:
1436                         break;
1437                 case Found:
1438                         prog = "/bin/service/telcofax";
1439                         break;
1440                 default:
1441                         syslog(0, LOGFILE, "bad ATA response");
1442                         exits(0);
1443                 }
1444
1445                 /* fork a receiving process */
1446                 dup(fd, 0);
1447                 dup(fd, 1);
1448                 close(fd);
1449                 argc = 0;
1450                 argv[argc++] = strrchr(prog, '/')+1;
1451                 argv[argc++] = file;
1452                 argv[argc++] = dev->t->name;
1453                 argv[argc] = 0;
1454                 exec(prog, argv);
1455                 syslog(0, LOGFILE, "can't exec %s: %r\n", prog);
1456                 exits(0);
1457         default:
1458                 /* wait till child gets the device open */
1459                 close(pfd[1]);
1460                 read(pfd[0], file, 1);
1461                 close(pfd[0]);
1462                 break;
1463         }
1464 }
1465
1466 /*
1467  *  hang up an connections in progress
1468  */
1469 void
1470 onhook(Dev *d)
1471 {
1472         write(d->ctl, "d0", 2);
1473         write(d->ctl, "r0", 2);
1474         sleep(250);
1475         write(d->ctl, "r1", 2);
1476         write(d->ctl, "d1", 2);
1477         modemtype(d, maxspeed, 1);
1478 }
1479
1480 /*
1481  *  read till we see a message or we time out
1482  */
1483 int
1484 readmsg(Dev *d, int secs, char *substr)
1485 {
1486         ulong start;
1487         char *p;
1488         int i, len;
1489         Msg *pp;
1490         int found = 0;
1491
1492         p = d->msgbuf;
1493         len = sizeof(d->msgbuf) - 1;
1494         for(start = time(0); time(0) <= start+secs;){
1495                 if(len && d->rp == d->wp){
1496                         sleep(100);
1497                         continue;
1498                 }
1499                 i = getinput(d, p, 1);
1500                 if(i == 0)
1501                         continue;
1502                 if(*p == '\n' || *p == '\r' || len == 0){
1503                         *p = 0;
1504                         if(verbose && p != d->msgbuf)
1505                                 syslog(0, LOGFILE, "<-%s", d->msgbuf);
1506                         if(substr && strstr(d->msgbuf, substr))
1507                                 found = 1;
1508                         for(pp = msgs; pp->text; pp++)
1509                                 if(strncmp(pp->text, d->msgbuf, strlen(pp->text))==0)
1510                                         return found ? Found : pp->type;
1511                         start = time(0);
1512                         p = d->msgbuf;
1513                         len = sizeof(d->msgbuf) - 1;
1514                         continue;
1515                 }
1516                 len--;
1517                 p++;
1518         }
1519         strcpy(d->msgbuf, "No response from modem");
1520         return found ? Found : Noise;
1521 }
1522
1523 /*
1524  *  get baud rate from a connect message
1525  */
1526 int
1527 getspeed(char *msg, int speed)
1528 {
1529         char *p;
1530         int s;
1531
1532         p = msg + sizeof("CONNECT") - 1;
1533         while(*p == ' ' || *p == '\t')
1534                 p++;
1535         s = atoi(p);
1536         if(s <= 0)
1537                 return speed;
1538         else
1539                 return s;
1540 }
1541
1542 /*
1543  *  set speed and RTS/CTS modem flow control
1544  */
1545 void
1546 setspeed(Dev *d, int baud)
1547 {
1548         char buf[32];
1549
1550         if(d->ctl < 0)
1551                 return;
1552         sprint(buf, "b%d", baud);
1553         write(d->ctl, buf, strlen(buf));
1554         write(d->ctl, "m1", 2);
1555 }