sys/src/cmd/ndb/cs.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4 #include <fcall.h>
   5 #include <bio.h>
   6 #include <ctype.h>
   7 #include <ndb.h>
   8 #include <ip.h>
   9 #include <String.h>
  10
  11 enum
  12 {
  13         Nreply=                 20,
  14         Maxreply=               256,
  15         Maxrequest=             128,
  16         Maxpath=                128,
  17         Maxfdata=               8192,
  18         Maxhost=                64,             /* maximum host name size */
  19         Maxservice=             64,             /* maximum service name size */
  20         Maxactive=              200,            /* maximum number of active slave procs */
  21
  22         Qdir=                   0,
  23         Qcs=                    1,
  24 };
  25
  26 typedef struct Mfile    Mfile;
  27 typedef struct Mlist    Mlist;
  28 typedef struct Network  Network;
  29 typedef struct Flushreq Flushreq;
  30 typedef struct Job      Job;
  31
  32 int vers;               /* incremented each clone/attach */
  33
  34 struct Mfile
  35 {
  36         int             busy;   /* fid in use */
  37         int             ref;    /* cleanup when drops to zero */
  38
  39         char            *user;
  40         Qid             qid;
  41         int             fid;
  42
  43         /*
  44          *  current request
  45          */
  46         char            *net;
  47         char            *host;
  48         char            *serv;
  49         char            *rem;
  50
  51         /*
  52          *  result of the last lookup
  53          */
  54         Network         *nextnet;
  55         int             nreply;
  56         char            *reply[Nreply];
  57         int             replylen[Nreply];
  58 };
  59
  60 struct Mlist
  61 {
  62         Mlist   *next;
  63         Mfile   mf;
  64 };
  65
  66
  67 /*
  68  *  active requests
  69  */
  70 struct Job
  71 {
  72         Job     *next;
  73         int     flushed;
  74         Fcall   request;
  75         Fcall   reply;
  76 };
  77 QLock   joblock;
  78 Job     *joblist;
  79
  80 Mlist   *mlist;
  81 int     mfd[2];
  82 int     debug;
  83
  84 jmp_buf masterjmp;      /* return through here after a slave process has been created */
  85 int     *isslave;       /* *isslave non-zero means this is a slave process */
  86 long    active;         /* number of active slaves */
  87 char    *dbfile;
  88 Ndb     *db, *netdb;
  89 char    *csuser;
  90
  91 void    rversion(Job*);
  92 void    rflush(Job*);
  93 void    rattach(Job*, Mfile*);
  94 char*   rwalk(Job*, Mfile*);
  95 void    ropen(Job*, Mfile*);
  96 void    rcreate(Job*, Mfile*);
  97 void    rread(Job*, Mfile*);
  98 void    rwrite(Job*, Mfile*);
  99 void    rclunk(Job*, Mfile*);
 100 void    rremove(Job*, Mfile*);
 101 void    rstat(Job*, Mfile*);
 102 void    rwstat(Job*, Mfile*);
 103 void    rauth(Job*);
 104 void    sendmsg(Job*, char*);
 105 void    error(char*);
 106 void    mountinit(char*, char*);
 107 void    io(void);
 108 void    ndbinit(void);
 109 void    netinit(int);
 110 void    netadd(char*);
 111 char    *genquery(Mfile*, char*);
 112 char*   ipinfoquery(Mfile*, char**, int);
 113 int     needproto(Network*, Ndbtuple*);
 114 int     lookup(Mfile*);
 115 void    ipid(void);
 116 void    readipinterfaces(void);
 117 void*   emalloc(int);
 118 char*   estrdup(char*);
 119 Job*    newjob(void);
 120 void    freejob(Job*);
 121 void    setext(char*, int, char*);
 122 void    cleanmf(Mfile*);
 123
 124 QLock   dblock;         /* mutex on database operations */
 125 QLock   netlock;        /* mutex for netinit() */
 126
 127 char    *logfile = "cs";
 128
 129 char    mntpt[Maxpath];
 130 char    netndb[Maxpath];
 131
 132 /*
 133  *  Network specific translators
 134  */
 135 Ndbtuple*       iplookup(Network*, char*, char*);
 136 char*           iptrans(Ndbtuple*, Network*, char*, char*, int);
 137 Ndbtuple*       telcolookup(Network*, char*, char*);
 138 char*           telcotrans(Ndbtuple*, Network*, char*, char*, int);
 139
 140 Ndbtuple*       dnsiplookup(char*, Ndbs*, int);
 141 Ndbtuple*       myipinfo(Ndb *db, char **list, int n);
 142
 143 struct Network
 144 {
 145         char            *net;
 146         Ndbtuple        *(*lookup)(Network*, char*, char*);
 147         char            *(*trans)(Ndbtuple*, Network*, char*, char*, int);
 148
 149         char            considered;             /* flag: ignored for "net!"? */
 150         char            fasttimeout;            /* flag. was for IL */
 151         char            ipvers;                 /* flag: V4, V6 */
 152
 153         Network         *next;
 154 };
 155
 156 enum {
 157         Ntcp = 1,
 158
 159         V4 = 1,
 160         V6 = 2,
 161 };
 162
 163 /*
 164  *  net doesn't apply to (r)udp, icmp(v6), or telco (for speed).
 165  */
 166 Network network[] = {
 167         { "il",         iplookup,       iptrans,        0, 1, V4,       },
 168         { "tcp",        iplookup,       iptrans,        0, 0, V4|V6,    },
 169         { "il",         iplookup,       iptrans,        0, 0, V4,       },
 170         { "udp",        iplookup,       iptrans,        1, 0, V4|V6,    },
 171         { "icmp",       iplookup,       iptrans,        1, 0, V4,       },
 172         { "icmpv6",     iplookup,       iptrans,        1, 0, V6,       },
 173         { "rudp",       iplookup,       iptrans,        1, 0, V4,       },
 174         { "ssh",        iplookup,       iptrans,        1, 0, V4|V6,    },
 175         { "telco",      telcolookup,    telcotrans,     1, 0, 0,        },
 176         { 0 },
 177 };
 178
 179 QLock ipifclock;
 180 Ipifc *ipifcs;
 181 int confipvers;
 182 int dnsipvers;
 183 int lookipvers = V4|V6;
 184
 185 char *mysysname;
 186
 187 Network *netlist;               /* networks ordered by preference */
 188 Network *last;
 189
 190 static void
 191 nstrcpy(char *to, char *from, int len)
 192 {
 193         strncpy(to, from, len);
 194         to[len-1] = 0;
 195 }
 196
 197 void
 198 usage(void)
 199 {
 200         fprint(2, "usage: %s [-46dn] [-f ndb-file] [-x netmtpt]\n", argv0);
 201         exits("usage");
 202 }
 203
 204 void
 205 main(int argc, char *argv[])
 206 {
 207         int justsetname;
 208         char ext[Maxpath], servefile[Maxpath];
 209
 210         justsetname = 0;
 211         setnetmtpt(mntpt, sizeof(mntpt), nil);
 212         ext[0] = 0;
 213         ARGBEGIN{
 214         case '4':
 215                 lookipvers = V4;
 216                 break;
 217         case '6':
 218                 lookipvers = V6;
 219                 break;
 220         case 'd':
 221                 debug = 1;
 222                 break;
 223         case 'f':
 224                 dbfile = EARGF(usage());
 225                 break;
 226         case 'n':
 227                 justsetname = 1;
 228                 break;
 229         case 'x':
 230                 setnetmtpt(mntpt, sizeof(mntpt), EARGF(usage()));
 231                 setext(ext, sizeof(ext), mntpt);
 232                 break;
 233         }ARGEND
 234         USED(argc);
 235         USED(argv);
 236
 237         snprint(netndb, sizeof(netndb), "%s/ndb", mntpt);
 238
 239         fmtinstall('E', eipfmt);
 240         fmtinstall('I', eipfmt);
 241         fmtinstall('M', eipfmt);
 242         fmtinstall('F', fcallfmt);
 243
 244         ndbinit();
 245         netinit(0);
 246
 247         if(!justsetname){
 248                 snprint(servefile, sizeof(servefile), "#s/cs%s", ext);
 249                 unmount(servefile, mntpt);
 250                 remove(servefile);
 251
 252                 rfork(RFREND|RFNOTEG);
 253                 csuser = estrdup(getuser());
 254                 mountinit(servefile, mntpt);
 255                 io();
 256         }
 257         exits(0);
 258 }
 259
 260 /*
 261  *  if a mount point is specified, set the cs extention to be the mount point
 262  *  with '_'s replacing '/'s
 263  */
 264 void
 265 setext(char *ext, int n, char *p)
 266 {
 267         int i, c;
 268
 269         n--;
 270         for(i = 0; i < n; i++){
 271                 c = p[i];
 272                 if(c == 0)
 273                         break;
 274                 if(c == '/')
 275                         c = '_';
 276                 ext[i] = c;
 277         }
 278         ext[i] = 0;
 279 }
 280
 281 void
 282 mountinit(char *service, char *mntpt)
 283 {
 284         int f;
 285         int p[2];
 286         char buf[32];
 287
 288         if(pipe(p) < 0)
 289                 error("pipe failed");
 290
 291         /*
 292          *  make a /srv/cs
 293          */
 294         f = create(service, OWRITE|ORCLOSE, 0666);
 295         if(f < 0)
 296                 error(service);
 297         snprint(buf, sizeof(buf), "%d", p[1]);
 298         if(write(f, buf, strlen(buf)) != strlen(buf))
 299                 error("write /srv/cs");
 300
 301         switch(rfork(RFFDG|RFPROC|RFNAMEG)){
 302         case 0:
 303                 close(p[1]);
 304                 procsetname("%s", mntpt);
 305                 break;
 306         case -1:
 307                 error("fork failed");
 308         default:
 309                 /*
 310                  *  put ourselves into the file system
 311                  */
 312                 close(p[0]);
 313                 if(mount(p[1], -1, mntpt, MAFTER, "") == -1)
 314                         error("mount failed");
 315                 _exits(0);
 316         }
 317         mfd[0] = mfd[1] = p[0];
 318 }
 319
 320 void
 321 ndbinit(void)
 322 {
 323         db = ndbopen(dbfile);
 324         if(db == nil)
 325                 error("can't open network database");
 326
 327         for(netdb = db; netdb != nil; netdb = netdb->next)
 328                 if(strcmp(netdb->file, netndb) == 0)
 329                         return;
 330
 331         netdb = ndbopen(netndb);
 332         if(netdb != nil){
 333                 netdb->nohash = 1;
 334                 db = ndbcat(netdb, db);
 335         }
 336 }
 337
 338 Mfile*
 339 newfid(int fid)
 340 {
 341         Mlist *f, *ff;
 342         Mfile *mf;
 343
 344         ff = nil;
 345         for(f = mlist; f != nil; f = f->next)
 346                 if(f->mf.busy && f->mf.fid == fid)
 347                         return &f->mf;
 348                 else if(ff == nil && !f->mf.busy && !f->mf.ref)
 349                         ff = f;
 350         if(ff == nil){
 351                 ff = emalloc(sizeof *f);
 352                 ff->next = mlist;
 353                 mlist = ff;
 354         }
 355         mf = &ff->mf;
 356         memset(mf, 0, sizeof *mf);
 357         mf->fid = fid;
 358         return mf;
 359 }
 360
 361 Job*
 362 newjob(void)
 363 {
 364         Job *job;
 365
 366         job = emalloc(sizeof *job);
 367         qlock(&joblock);
 368         job->next = joblist;
 369         joblist = job;
 370         job->request.tag = -1;
 371         qunlock(&joblock);
 372         return job;
 373 }
 374
 375 void
 376 freejob(Job *job)
 377 {
 378         Job **l;
 379
 380         qlock(&joblock);
 381         for(l = &joblist; *l != nil; l = &(*l)->next){
 382                 if((*l) == job){
 383                         *l = job->next;
 384                         break;
 385                 }
 386         }
 387         qunlock(&joblock);
 388         free(job);
 389 }
 390
 391 void
 392 flushjob(int tag)
 393 {
 394         Job *job;
 395
 396         qlock(&joblock);
 397         for(job = joblist; job != nil; job = job->next){
 398                 if(job->request.tag == tag && job->request.type != Tflush){
 399                         job->flushed = 1;
 400                         break;
 401                 }
 402         }
 403         qunlock(&joblock);
 404 }
 405
 406 void
 407 io(void)
 408 {
 409         long n;
 410         Mfile *mf;
 411         int slaveflag;
 412         uchar mdata[IOHDRSZ + Maxfdata];
 413         Job *job;
 414
 415         /*
 416          *  if we ask dns to fulfill requests,
 417          *  a slave process is created to wait for replies.  The
 418          *  master process returns immediately via a longjmp
 419          *  through 'masterjmp'.
 420          *
 421          *  *isslave is a pointer into the call stack to a variable
 422          *  that tells whether or not the current process is a slave.
 423          */
 424         slaveflag = 0;          /* init slave variable */
 425         isslave = &slaveflag;
 426         setjmp(masterjmp);
 427
 428         for(;;){
 429                 n = read9pmsg(mfd[0], mdata, sizeof mdata);
 430                 if(n < 0)
 431                         error("mount read");
 432                 if(n == 0)
 433                         break;
 434                 job = newjob();
 435                 if(convM2S(mdata, n, &job->request) != n){
 436                         syslog(1, logfile, "format error %ux %ux %ux %ux %ux",
 437                                 mdata[0], mdata[1], mdata[2], mdata[3], mdata[4]);
 438                         freejob(job);
 439                         break;
 440                 }
 441                 qlock(&dblock);
 442                 mf = newfid(job->request.fid);
 443                 if(debug)
 444                         syslog(0, logfile, "%F", &job->request);
 445
 446                 switch(job->request.type){
 447                 default:
 448                         syslog(1, logfile, "unknown request type %d", job->request.type);
 449                         break;
 450                 case Tversion:
 451                         rversion(job);
 452                         break;
 453                 case Tauth:
 454                         rauth(job);
 455                         break;
 456                 case Tflush:
 457                         rflush(job);
 458                         break;
 459                 case Tattach:
 460                         rattach(job, mf);
 461                         break;
 462                 case Twalk:
 463                         rwalk(job, mf);
 464                         break;
 465                 case Topen:
 466                         ropen(job, mf);
 467                         break;
 468                 case Tcreate:
 469                         rcreate(job, mf);
 470                         break;
 471                 case Tread:
 472                         rread(job, mf);
 473                         break;
 474                 case Twrite:
 475                         rwrite(job, mf);
 476                         break;
 477                 case Tclunk:
 478                         rclunk(job, mf);
 479                         break;
 480                 case Tremove:
 481                         rremove(job, mf);
 482                         break;
 483                 case Tstat:
 484                         rstat(job, mf);
 485                         break;
 486                 case Twstat:
 487                         rwstat(job, mf);
 488                         break;
 489                 }
 490                 qunlock(&dblock);
 491
 492                 freejob(job);
 493
 494                 /*
 495                  *  slave processes die after replying
 496                  */
 497                 if(*isslave){
 498                         if(debug)
 499                                 syslog(0, logfile, "slave death %d", getpid());
 500                         adec(&active);
 501                         _exits(0);
 502                 }
 503         }
 504 }
 505
 506 void
 507 rversion(Job *job)
 508 {
 509         if(job->request.msize > IOHDRSZ + Maxfdata)
 510                 job->reply.msize = IOHDRSZ + Maxfdata;
 511         else
 512                 job->reply.msize = job->request.msize;
 513         job->reply.version = "9P2000";
 514         if(strncmp(job->request.version, "9P", 2) != 0)
 515                 job->reply.version = "unknown";
 516         sendmsg(job, nil);
 517 }
 518
 519 void
 520 rauth(Job *job)
 521 {
 522         sendmsg(job, "cs: authentication not required");
 523 }
 524
 525 /*
 526  *  don't flush till all the slaves are done
 527  */
 528 void
 529 rflush(Job *job)
 530 {
 531         flushjob(job->request.oldtag);
 532         sendmsg(job, nil);
 533 }
 534
 535 void
 536 rattach(Job *job, Mfile *mf)
 537 {
 538         if(mf->busy == 0){
 539                 mf->busy = 1;
 540                 mf->user = estrdup(job->request.uname);
 541         }
 542         mf->qid.vers = vers++;
 543         mf->qid.type = QTDIR;
 544         mf->qid.path = 0LL;
 545         job->reply.qid = mf->qid;
 546         sendmsg(job, nil);
 547 }
 548
 549
 550 char*
 551 rwalk(Job *job, Mfile *mf)
 552 {
 553         char *err;
 554         char **elems;
 555         int nelems;
 556         int i;
 557         Mfile *nmf;
 558         Qid qid;
 559
 560         err = nil;
 561         nmf = nil;
 562         elems = job->request.wname;
 563         nelems = job->request.nwname;
 564         job->reply.nwqid = 0;
 565
 566         if(job->request.newfid != job->request.fid){
 567                 /* clone fid */
 568                 nmf = newfid(job->request.newfid);
 569                 if(nmf->busy){
 570                         nmf = nil;
 571                         err = "clone to used channel";
 572                         goto send;
 573                 }
 574                 *nmf = *mf;
 575                 nmf->user = estrdup(mf->user);
 576                 nmf->fid = job->request.newfid;
 577                 nmf->qid.vers = vers++;
 578                 mf = nmf;
 579         }
 580         /* else nmf will be nil */
 581
 582         qid = mf->qid;
 583         if(nelems > 0){
 584                 /* walk fid */
 585                 for(i=0; i<nelems && i<MAXWELEM; i++){
 586                         if((qid.type & QTDIR) == 0){
 587                                 err = "not a directory";
 588                                 break;
 589                         }
 590                         if(strcmp(elems[i], "..") == 0 || strcmp(elems[i], ".") == 0){
 591                                 qid.type = QTDIR;
 592                                 qid.path = Qdir;
 593     Found:
 594                                 job->reply.wqid[i] = qid;
 595                                 job->reply.nwqid++;
 596                                 continue;
 597                         }
 598                         if(strcmp(elems[i], "cs") == 0){
 599                                 qid.type = QTFILE;
 600                                 qid.path = Qcs;
 601                                 goto Found;
 602                         }
 603                         err = "file does not exist";
 604                         break;
 605                 }
 606         }
 607
 608     send:
 609         if(nmf != nil && (err!=nil || job->reply.nwqid<nelems)){
 610                 cleanmf(nmf);
 611                 free(nmf->user);
 612                 nmf->user = nil;
 613                 nmf->busy = 0;
 614                 nmf->fid = 0;
 615         }
 616         if(err == nil)
 617                 mf->qid = qid;
 618         sendmsg(job, err);
 619         return err;
 620 }
 621
 622 void
 623 ropen(Job *job, Mfile *mf)
 624 {
 625         int mode;
 626         char *err;
 627
 628         err = nil;
 629         mode = job->request.mode;
 630         if(mf->qid.type & QTDIR){
 631                 if(mode)
 632                         err = "permission denied";
 633         }
 634         job->reply.qid = mf->qid;
 635         job->reply.iounit = 0;
 636         sendmsg(job, err);
 637 }
 638
 639 void
 640 rcreate(Job *job, Mfile *mf)
 641 {
 642         USED(mf);
 643         sendmsg(job, "creation permission denied");
 644 }
 645
 646 void
 647 rread(Job *job, Mfile *mf)
 648 {
 649         int i, n, cnt;
 650         long off, toff, clock;
 651         Dir dir;
 652         uchar buf[Maxfdata];
 653         char *err;
 654
 655         n = 0;
 656         err = nil;
 657         off = job->request.offset;
 658         cnt = job->request.count;
 659         mf->ref++;
 660
 661         if(mf->qid.type & QTDIR){
 662                 clock = time(0);
 663                 if(off == 0){
 664                         memset(&dir, 0, sizeof dir);
 665                         dir.name = "cs";
 666                         dir.qid.type = QTFILE;
 667                         dir.qid.vers = vers;
 668                         dir.qid.path = Qcs;
 669                         dir.mode = 0666;
 670                         dir.length = 0;
 671                         dir.uid = mf->user;
 672                         dir.gid = mf->user;
 673                         dir.muid = mf->user;
 674                         dir.atime = clock;      /* wrong */
 675                         dir.mtime = clock;      /* wrong */
 676                         n = convD2M(&dir, buf, sizeof buf);
 677                 }
 678                 job->reply.data = (char*)buf;
 679                 goto send;
 680         }
 681
 682         for(;;){
 683                 /* look for an answer at the right offset */
 684                 toff = 0;
 685                 for(i = 0; mf->reply[i] != nil && i < mf->nreply; i++){
 686                         n = mf->replylen[i];
 687                         if(off < toff + n)
 688                                 break;
 689                         toff += n;
 690                 }
 691                 if(i < mf->nreply)
 692                         break;          /* got something to return */
 693
 694                 /* try looking up more answers */
 695                 if(lookup(mf) == 0 || job->flushed){
 696                         /* no more */
 697                         n = 0;
 698                         goto send;
 699                 }
 700         }
 701
 702         /* give back a single reply (or part of one) */
 703         job->reply.data = mf->reply[i] + (off - toff);
 704         if(cnt > toff - off + n)
 705                 n = toff - off + n;
 706         else
 707                 n = cnt;
 708
 709 send:
 710         job->reply.count = n;
 711         sendmsg(job, err);
 712
 713         if(--mf->ref == 0 && mf->busy == 0)
 714                 cleanmf(mf);
 715 }
 716
 717 void
 718 cleanmf(Mfile *mf)
 719 {
 720         int i;
 721
 722         if(mf->net != nil){
 723                 free(mf->net);
 724                 mf->net = nil;
 725         }
 726         if(mf->host != nil){
 727                 free(mf->host);
 728                 mf->host = nil;
 729         }
 730         if(mf->serv != nil){
 731                 free(mf->serv);
 732                 mf->serv = nil;
 733         }
 734         if(mf->rem != nil){
 735                 free(mf->rem);
 736                 mf->rem = nil;
 737         }
 738         for(i = 0; i < mf->nreply; i++){
 739                 free(mf->reply[i]);
 740                 mf->reply[i] = nil;
 741                 mf->replylen[i] = 0;
 742         }
 743         mf->nreply = 0;
 744         mf->nextnet = netlist;
 745 }
 746
 747 void
 748 rwrite(Job *job, Mfile *mf)
 749 {
 750         int cnt, n;
 751         char *err;
 752         char *field[4];
 753         char curerr[64];
 754
 755         err = nil;
 756         cnt = job->request.count;
 757         if(mf->qid.type & QTDIR){
 758                 err = "can't write directory";
 759                 goto send;
 760         }
 761         if(cnt >= Maxrequest){
 762                 err = "request too long";
 763                 goto send;
 764         }
 765         job->request.data[cnt] = 0;
 766
 767         if(strcmp(mf->user, "none") == 0 || strcmp(mf->user, csuser) != 0)
 768                 goto query;     /* skip special commands if not owner */
 769
 770         /*
 771          *  toggle debugging
 772          */
 773         if(strncmp(job->request.data, "debug", 5)==0){
 774                 debug ^= 1;
 775                 syslog(1, logfile, "debug %d", debug);
 776                 goto send;
 777         }
 778
 779         /*
 780          *  toggle ipv4 lookups
 781          */
 782         if(strncmp(job->request.data, "ipv4", 4)==0){
 783                 lookipvers ^= V4;
 784                 syslog(1, logfile, "ipv4lookups %d", (lookipvers & V4) != 0);
 785                 goto send;
 786         }
 787
 788         /*
 789          *  toggle ipv6 lookups
 790          */
 791         if(strncmp(job->request.data, "ipv6", 4)==0){
 792                 lookipvers ^= V6;
 793                 syslog(1, logfile, "ipv6lookups %d", (lookipvers & V6) != 0);
 794                 goto send;
 795         }
 796
 797         /*
 798          *  add networks to the default list
 799          */
 800         if(strncmp(job->request.data, "add ", 4)==0){
 801                 if(job->request.data[cnt-1] == '\n')
 802                         job->request.data[cnt-1] = 0;
 803                 netadd(job->request.data+4);
 804                 readipinterfaces();
 805                 goto send;
 806         }
 807
 808         /*
 809          *  refresh all state
 810          */
 811         if(strncmp(job->request.data, "refresh", 7)==0){
 812                 netinit(1);
 813                 goto send;
 814         }
 815
 816 query:
 817         if(mf->ref){
 818                 err = "query already in progress";
 819                 goto send;
 820         }
 821         mf->ref++;
 822
 823         /* start transaction with a clean slate */
 824         cleanmf(mf);
 825
 826         /*
 827          *  look for a general query
 828          */
 829         if(*job->request.data == '!'){
 830                 err = genquery(mf, job->request.data+1);
 831                 goto done;
 832         }
 833
 834         if(debug)
 835                 syslog(0, logfile, "write %s", job->request.data);
 836         /*
 837          *  break up name
 838          */
 839         n = getfields(job->request.data, field, 4, 1, "!");
 840         switch(n){
 841         case 1:
 842                 mf->net = estrdup("net");
 843                 mf->host = estrdup(field[0]);
 844                 break;
 845         case 4:
 846                 mf->rem = estrdup(field[3]);
 847                 /* fall through */
 848         case 3:
 849                 mf->serv = estrdup(field[2]);
 850                 /* fall through */
 851         case 2:
 852                 mf->host = estrdup(field[1]);
 853                 mf->net = estrdup(field[0]);
 854                 break;
 855         }
 856
 857         /*
 858          *  do the first net worth of lookup
 859          */
 860         if(lookup(mf) == 0){
 861                 rerrstr(curerr, sizeof curerr);
 862                 err = curerr;
 863         }
 864
 865 done:
 866         if(--mf->ref == 0 && mf->busy == 0)
 867                 cleanmf(mf);
 868
 869 send:
 870         job->reply.count = cnt;
 871         sendmsg(job, err);
 872 }
 873
 874 void
 875 rclunk(Job *job, Mfile *mf)
 876 {
 877         if(mf->ref == 0)
 878                 cleanmf(mf);
 879         free(mf->user);
 880         mf->user = nil;
 881         mf->fid = 0;
 882         mf->busy = 0;
 883         sendmsg(job, nil);
 884 }
 885
 886 void
 887 rremove(Job *job, Mfile *mf)
 888 {
 889         USED(mf);
 890         sendmsg(job, "remove permission denied");
 891 }
 892
 893 void
 894 rstat(Job *job, Mfile *mf)
 895 {
 896         Dir dir;
 897         uchar buf[IOHDRSZ+Maxfdata];
 898
 899         memset(&dir, 0, sizeof dir);
 900         if(mf->qid.type & QTDIR){
 901                 dir.name = ".";
 902                 dir.mode = DMDIR|0555;
 903         } else {
 904                 dir.name = "cs";
 905                 dir.mode = 0666;
 906         }
 907         dir.qid = mf->qid;
 908         dir.length = 0;
 909         dir.uid = mf->user;
 910         dir.gid = mf->user;
 911         dir.muid = mf->user;
 912         dir.atime = dir.mtime = time(0);
 913         job->reply.nstat = convD2M(&dir, buf, sizeof buf);
 914         job->reply.stat = buf;
 915         sendmsg(job, nil);
 916 }
 917
 918 void
 919 rwstat(Job *job, Mfile *mf)
 920 {
 921         USED(mf);
 922         sendmsg(job, "wstat permission denied");
 923 }
 924
 925 void
 926 sendmsg(Job *job, char *err)
 927 {
 928         int n;
 929         uchar mdata[IOHDRSZ + Maxfdata];
 930         char ename[ERRMAX];
 931
 932         if(err){
 933                 job->reply.type = Rerror;
 934                 snprint(ename, sizeof(ename), "cs: %s", err);
 935                 job->reply.ename = ename;
 936         }else{
 937                 job->reply.type = job->request.type+1;
 938         }
 939         job->reply.tag = job->request.tag;
 940         n = convS2M(&job->reply, mdata, sizeof mdata);
 941         if(n == 0){
 942                 syslog(1, logfile, "sendmsg convS2M of %F returns 0", &job->reply);
 943                 abort();
 944         }
 945         qlock(&joblock);
 946         if(job->flushed == 0)
 947                 if(write(mfd[1], mdata, n)!=n)
 948                         error("mount write");
 949         qunlock(&joblock);
 950         if(debug)
 951                 syslog(0, logfile, "%F %d", &job->reply, n);
 952 }
 953
 954 void
 955 error(char *s)
 956 {
 957         syslog(1, logfile, "%s: %r", s);
 958         _exits(0);
 959 }
 960
 961 static uchar loopbacknet[IPaddrlen] = {
 962         0, 0, 0, 0,
 963         0, 0, 0, 0,
 964         0, 0, 0xff, 0xff,
 965         127, 0, 0, 0
 966 };
 967 static uchar loopbackmask[IPaddrlen] = {
 968         0xff, 0xff, 0xff, 0xff,
 969         0xff, 0xff, 0xff, 0xff,
 970         0xff, 0xff, 0xff, 0xff,
 971         0xff, 0, 0, 0
 972 };
 973 static uchar loopback6[IPaddrlen] = {
 974         0, 0, 0, 0,
 975         0, 0, 0, 0,
 976         0, 0, 0, 0,
 977         0, 0, 0, 1
 978 };
 979
 980 void
 981 readipinterfaces(void)
 982 {
 983         uchar mynet[IPaddrlen];
 984         Ipifc *ifc;
 985         Iplifc *lifc;
 986         int conf, dns;
 987
 988         conf = dns = 0;
 989         qlock(&ipifclock);
 990         ipifcs = readipifc(mntpt, ipifcs, -1);
 991         for(ifc = ipifcs; ifc != nil; ifc = ifc->next){
 992                 for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
 993                         if(ipcmp(lifc->ip, IPnoaddr) == 0)
 994                                 continue;
 995                         if(isv4(lifc->ip)){
 996                                 conf |= V4;
 997                                 maskip(lifc->ip, loopbackmask, mynet);
 998                                 if(ipcmp(mynet, loopbacknet) == 0)
 999                                         continue;
1000                                 dns |= V4;
1001                         } else {
1002                                 conf |= V6;
1003                                 if(ISIPV6LINKLOCAL(lifc->ip))
1004                                         continue;
1005                                 if(ipcmp(lifc->ip, loopback6) == 0)
1006                                         continue;
1007                                 dns |= V6;
1008                         }
1009                 }
1010         }
1011         qunlock(&ipifclock);
1012         confipvers = conf;
1013         dnsipvers = dns;
1014 }
1015
1016 /*
1017  *  get the system name
1018  */
1019 void
1020 ipid(void)
1021 {
1022         char eaddr[16], buf[Maxpath];
1023         uchar addr[6];
1024         Ndbtuple *t, *tt;
1025         char *p, *attr;
1026         Ndbs s;
1027         int f, n;
1028         Dir *d;
1029
1030         if(mysysname != nil)
1031                 return;
1032
1033         /*
1034          *  environment has priority.
1035          *
1036          *  on the sgi power the default system name
1037          *  is the ip address.  ignore that.
1038          *
1039          */
1040         p = getenv("sysname");
1041         if(p != nil && *p != 0){
1042                 attr = ipattr(p);
1043                 if(strcmp(attr, "ip") != 0) {
1044                         mysysname = p;
1045                         goto setsys;
1046                 }
1047                 free(p);
1048         }
1049
1050         /* try configured interfaces */
1051         attr = "sys";
1052         t = s.t = myipinfo(db, &attr, 1);
1053         if(t != nil)
1054                 goto found;
1055
1056         /* try ethernet interfaces */
1057         n = 0;
1058         d = nil;
1059         f = open(mntpt, OREAD);
1060         if(f >= 0){
1061                 n = dirreadall(f, &d);
1062                 close(f);
1063         }
1064         for(f = 0; f < n; f++){
1065                 if((d[f].mode & DMDIR) == 0 || strncmp(d[f].name, "ether", 5) != 0)
1066                         continue;
1067                 snprint(buf, sizeof buf, "%s/%s", mntpt, d[f].name);
1068                 if(myetheraddr(addr, buf) >= 0){
1069                         snprint(eaddr, sizeof(eaddr), "%E", addr);
1070                         free(ndbgetvalue(db, &s, "ether", eaddr, "sys", &t));
1071                         if(t != nil){
1072                                 free(d);
1073                                 goto found;
1074                         }
1075                 }
1076         }
1077         free(d);
1078
1079         /* nothing else worked, use ip address */
1080         attr = "ip";
1081         t = s.t = myipinfo(db, &attr, 1);
1082         if(t == nil)
1083                 return;
1084
1085 found:
1086         /* found in database */
1087         if((tt = ndbfindattr(t, s.t, "sys")) != nil)
1088                 mysysname = estrdup(tt->val);
1089         else if((tt = ndbfindattr(t, s.t, "ip")) != nil)
1090                 mysysname = estrdup(tt->val);
1091         ndbfree(t);
1092
1093         if(mysysname == nil)
1094                 return;
1095
1096 setsys:
1097         /* set /dev/sysname if we now know it */
1098         f = open("/dev/sysname", OWRITE);
1099         if(f >= 0){
1100                 write(f, mysysname, strlen(mysysname));
1101                 close(f);
1102         }
1103 }
1104
1105 /*
1106  *  Set up a list of default networks by looking for
1107  *  /net/^*^/clone.
1108  */
1109 void
1110 netinit(int background)
1111 {
1112         char clone[Maxpath];
1113         Network *np;
1114
1115         if(background){
1116                 if(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT) != 0)
1117                         return;
1118                 qlock(&netlock);
1119         }
1120
1121         /* add the mounted networks to the default list */
1122         for(np = network; np->net != nil; np++){
1123                 if(np->considered)
1124                         continue;
1125                 snprint(clone, sizeof(clone), "%s/%s/clone", mntpt, np->net);
1126                 if(access(clone, AEXIST) < 0)
1127                         continue;
1128                 if(netlist != nil)
1129                         last->next = np;
1130                 else
1131                         netlist = np;
1132                 last = np;
1133                 np->next = nil;
1134                 np->considered = 1;
1135         }
1136
1137         /* find out what our ip addresses are */
1138         readipinterfaces();
1139
1140         /* set the system name if we need to, these days ip is all we have */
1141         ipid();
1142
1143         if(debug)
1144                 syslog(0, logfile, "mysysname %s", mysysname?mysysname:"???");
1145
1146         if(background){
1147                 qunlock(&netlock);
1148                 _exits(0);
1149         }
1150 }
1151
1152 /*
1153  *  add networks to the standard list
1154  */
1155 void
1156 netadd(char *p)
1157 {
1158         Network *np;
1159         char *field[12];
1160         int i, n;
1161
1162         n = getfields(p, field, 12, 1, " ");
1163         for(i = 0; i < n; i++){
1164                 for(np = network; np->net != nil; np++){
1165                         if(strcmp(field[i], np->net) != 0)
1166                                 continue;
1167                         if(np->considered)
1168                                 break;
1169                         if(netlist != nil)
1170                                 last->next = np;
1171                         else
1172                                 netlist = np;
1173                         last = np;
1174                         np->next = nil;
1175                         np->considered = 1;
1176                 }
1177         }
1178 }
1179
1180 int
1181 lookforproto(Ndbtuple *t, char *proto)
1182 {
1183         for(; t != nil; t = t->entry)
1184                 if(strcmp(t->attr, "proto") == 0 && strcmp(t->val, proto) == 0)
1185                         return 1;
1186         return 0;
1187 }
1188
1189 /*
1190  *  lookup a request.  the network "net" means we should pick the
1191  *  best network to get there.
1192  */
1193 int
1194 lookup(Mfile *mf)
1195 {
1196         Network *np;
1197         char *cp;
1198         Ndbtuple *nt, *t;
1199         char reply[Maxreply];
1200         int i, rv, fasttimeout;
1201
1202         /* open up the standard db files */
1203         if(db == nil)
1204                 ndbinit();
1205         if(db == nil)
1206                 error("can't open mf->network database\n");
1207
1208         if(mf->net == nil)
1209                 return 0;       /* must have been a genquery */
1210
1211         rv = 0;
1212         if(strcmp(mf->net, "net") == 0){
1213                 /*
1214                  *  go through set of default nets
1215                  */
1216                 for(np = mf->nextnet; np != nil && rv == 0; np = np->next){
1217                         nt = (*np->lookup)(np, mf->host, mf->serv);
1218                         if(nt == nil)
1219                                 continue;
1220                         fasttimeout = np->fasttimeout && !lookforproto(nt, np->net);
1221                         for(t = nt; mf->nreply < Nreply && t != nil; t = t->entry){
1222                                 cp = (*np->trans)(t, np, mf->serv, mf->rem, fasttimeout);
1223                                 if(cp != nil){
1224                                         /* avoid duplicates */
1225                                         for(i = 0; i < mf->nreply; i++)
1226                                                 if(strcmp(mf->reply[i], cp) == 0)
1227                                                         break;
1228                                         if(i == mf->nreply){
1229                                                 /* save the reply */
1230                                                 mf->replylen[mf->nreply] = strlen(cp);
1231                                                 mf->reply[mf->nreply++] = cp;
1232                                                 rv++;
1233                                         } else
1234                                                 free(cp);
1235                                 }
1236                         }
1237                         ndbfree(nt);
1238                 }
1239                 mf->nextnet = np;
1240                 return rv;
1241         }
1242
1243         /*
1244          *  if not /net, we only get one lookup
1245          */
1246         if(mf->nreply != 0)
1247                 return 0;
1248
1249         /*
1250          *  look for a specific network
1251          */
1252         for(np = network; np->net != nil; np++){
1253                 if(np->fasttimeout)
1254                         continue;
1255                 if(strcmp(np->net, mf->net) == 0)
1256                         break;
1257         }
1258
1259         if(np->net != nil){
1260                 /*
1261                  *  known network
1262                  */
1263                 nt = (*np->lookup)(np, mf->host, mf->serv);
1264                 for(t = nt; mf->nreply < Nreply && t != nil; t = t->entry){
1265                         cp = (*np->trans)(t, np, mf->serv, mf->rem, 0);
1266                         if(cp != nil){
1267                                 mf->replylen[mf->nreply] = strlen(cp);
1268                                 mf->reply[mf->nreply++] = cp;
1269                                 rv++;
1270                         }
1271                 }
1272                 ndbfree(nt);
1273                 return rv;
1274         } else {
1275                 /*
1276                  *  not a known network, don't translate host or service
1277                  */
1278                 if(mf->serv != nil)
1279                         snprint(reply, sizeof(reply), "%s/%s/clone %s!%s",
1280                                 mntpt, mf->net, mf->host, mf->serv);
1281                 else
1282                         snprint(reply, sizeof(reply), "%s/%s/clone %s",
1283                                 mntpt, mf->net, mf->host);
1284                 mf->reply[0] = estrdup(reply);
1285                 mf->replylen[0] = strlen(reply);
1286                 mf->nreply = 1;
1287                 return 1;
1288         }
1289 }
1290
1291 /*
1292  *  translate an ip service name into a port number.  If it's a numeric port
1293  *  number, look for restricted access.
1294  *
1295  *  the service '*' needs no translation.
1296  */
1297 char*
1298 ipserv(Network *np, char *name, char *buf, int blen)
1299 {
1300         char *p;
1301         int alpha = 0;
1302         int restr = 0;
1303         Ndbtuple *t, *nt;
1304         Ndbs s;
1305
1306         /* '*' means any service */
1307         if(strcmp(name, "*") == 0){
1308                 nstrcpy(buf, name, blen);
1309                 return buf;
1310         }
1311
1312         /*  see if it's numeric or symbolic */
1313         for(p = name; *p; p++){
1314                 if(isdigit(*p))
1315                         {}
1316                 else if(isalpha(*p) || *p == '-' || *p == '$')
1317                         alpha = 1;
1318                 else
1319                         return nil;
1320         }
1321         t = nil;
1322         p = nil;
1323         if(alpha){
1324                 p = ndbgetvalue(db, &s, np->net, name, "port", &t);
1325                 if(p == nil)
1326                         return nil;
1327         } else {
1328                 /* look up only for tcp ports < 1024 to get the restricted
1329                  * attribute
1330                  */
1331                 if(atoi(name) < 1024 && strcmp(np->net, "tcp") == 0)
1332                         p = ndbgetvalue(db, &s, "port", name, "port", &t);
1333                 if(p == nil)
1334                         p = estrdup(name);
1335         }
1336
1337         if(t){
1338                 for(nt = t; nt != nil; nt = nt->entry)
1339                         if(strcmp(nt->attr, "restricted") == 0)
1340                                 restr = 1;
1341                 ndbfree(t);
1342         }
1343         snprint(buf, blen, "%s%s", p, restr ? "!r" : "");
1344         free(p);
1345
1346         return buf;
1347 }
1348
1349 Ndbtuple*
1350 myipinfo(Ndb *db, char **list, int n)
1351 {
1352         Ndbtuple *t, *nt;
1353         char ip[64];
1354         Ipifc *ifc;
1355         Iplifc *lifc;
1356
1357         t = nil;
1358         qlock(&ipifclock);
1359         for(ifc = ipifcs; ifc != nil; ifc = ifc->next){
1360                 for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
1361                         snprint(ip, sizeof(ip), "%I", lifc->ip);
1362                         nt = ndbipinfo(db, "ip", ip, list, n);
1363                         t = ndbconcatenate(t, nt);
1364                 }
1365         }
1366         qunlock(&ipifclock);
1367
1368         return ndbdedup(t);
1369 }
1370
1371 /*
1372  * reorder according to our interfaces
1373  */
1374 static Ndbtuple*
1375 ipreorder(Ndbtuple *t)
1376 {
1377         Ndbtuple *nt;
1378         uchar ip[IPaddrlen];
1379         uchar net[IPaddrlen];
1380         uchar tnet[IPaddrlen];
1381         Ipifc *ifc;
1382         Iplifc *lifc;
1383
1384         if(t == nil)
1385                 return nil;
1386
1387         qlock(&ipifclock);
1388         for(ifc = ipifcs; ifc != nil; ifc = ifc->next){
1389                 for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
1390                         maskip(lifc->ip, lifc->mask, net);
1391                         for(nt = t; nt != nil; nt = nt->entry){
1392                                 if(strcmp(nt->attr, "ip") != 0)
1393                                         continue;
1394                                 if(parseip(ip, nt->val) == -1)
1395                                         continue;
1396                                 maskip(ip, lifc->mask, tnet);
1397                                 if(memcmp(net, tnet, IPaddrlen) == 0){
1398                                         qunlock(&ipifclock);
1399                                         return ndbreorder(t, nt);
1400                                 }
1401                         }
1402                 }
1403         }
1404         qunlock(&ipifclock);
1405
1406         return t;
1407 }
1408
1409 static Ndbtuple*
1410 ndbline(Ndbtuple *t)
1411 {
1412         Ndbtuple *nt;
1413
1414         for(nt = t; nt != nil; nt = nt->entry){
1415                 if(nt->entry == nil)
1416                         nt->line = t;
1417                 else
1418                         nt->line = nt->entry;
1419         }
1420         return t;
1421 }
1422
1423 /*
1424  *  lookup an ip destination
1425  */
1426 static Ndbtuple*
1427 iplookuphost(Network *np, char *host)
1428 {
1429         char *attr, *dnsname;
1430         Ndbtuple *t, *nt;
1431         Ndbs s;
1432
1433         /*
1434          *  turn '[ip address]' into just 'ip address'
1435          */
1436         if(*host == '['){
1437                 char tmp[Maxhost], *x;
1438
1439                 nstrcpy(tmp, host, sizeof tmp);
1440                 host = tmp;
1441                 if((x = strchr(++host, ']')) != nil)
1442                         *x = 0;
1443         }
1444
1445         /* for dial strings with no host */
1446         if(strcmp(host, "*") == 0)
1447                 return ndbline(ndbnew("ip", "*"));
1448
1449         /*
1450          *  hack till we go v6 :: = 0.0.0.0
1451          */
1452         if(strcmp("::", host) == 0)
1453                 return ndbline(ndbnew("ip", "*"));
1454
1455         /*
1456          *  just accept addresses
1457          */
1458         attr = ipattr(host);
1459         if(strcmp(attr, "ip") == 0)
1460                 return ndbline(ndbnew("ip", host));
1461
1462         /*
1463          *  give the domain name server the first opportunity to
1464          *  resolve domain names.  if that fails try the database.
1465          */
1466         t = nil;
1467         if(strcmp(attr, "dom") == 0)
1468                 t = dnsiplookup(host, &s, np->ipvers);
1469         if(t == nil){
1470                 for(nt = ndbsearch(db, &s, attr, host); nt != nil; nt = ndbsnext(&s, attr, host)){
1471                         if(ndbfindattr(nt, s.t, "ip") == nil){
1472                                 ndbfree(nt);
1473                                 continue;
1474                         }
1475                         t = ndbconcatenate(t, ndbreorder(nt, s.t));
1476                 }
1477                 s.t = t;
1478         }
1479         if(t == nil){
1480                 if(strcmp(attr, "dom") != 0){
1481                         dnsname = ndbgetvalue(db, &s, attr, host, "dom", nil);
1482                         if(dnsname != nil){
1483                                 t = dnsiplookup(dnsname, &s, np->ipvers);
1484                                 free(dnsname);
1485                         }
1486                 }
1487                 if(t == nil)
1488                         t = dnsiplookup(host, &s, np->ipvers);
1489         }
1490         if(t == nil)
1491                 return nil;
1492
1493         /*
1494          *  reorder the tuple to have the matched line first and
1495          *  save that in the request structure.
1496          */
1497         return ndbreorder(t, s.t);
1498 }
1499
1500
1501 Ndbtuple*
1502 iplookup(Network *np, char *host, char *serv)
1503 {
1504         Ndbtuple *l, *t, *nt;
1505         char ts[Maxservice], *attr;
1506
1507         /*
1508          *  start with the service since it's the most likely to fail
1509          *  and costs the least
1510          */
1511         if(serv == nil || ipserv(np, serv, ts, sizeof ts) == nil){
1512                 werrstr("can't translate service");
1513                 return nil;
1514         }
1515
1516         /*
1517          *  '$' means the rest of the name is an attribute that we
1518          *  need to search for
1519          */
1520         werrstr("can't translate address");
1521         if(*host == '$'){
1522                 t = nil;
1523                 attr = host+1;
1524                 l = myipinfo(db, &attr, 1);
1525                 for(nt = l; nt != nil; nt = nt->entry){
1526                         if(strcmp(nt->attr, attr) == 0)
1527                                 t = ndbconcatenate(t, iplookuphost(np, nt->val));
1528                 }
1529                 ndbfree(l);
1530         } else
1531                 t = iplookuphost(np, host);
1532
1533         return ipreorder(t);
1534 }
1535
1536
1537 /*
1538  *  translate an ip address
1539  */
1540 char*
1541 iptrans(Ndbtuple *t, Network *np, char *serv, char *rem, int fasttimeout)
1542 {
1543         char ts[Maxservice];
1544         char reply[Maxreply];
1545         char x[Maxservice];
1546         uchar ip[IPaddrlen];
1547
1548         if(strcmp(t->attr, "ip") != 0)
1549                 return nil;
1550
1551         if(serv == nil || ipserv(np, serv, ts, sizeof ts) == nil){
1552                 werrstr("can't translate service");
1553                 return nil;
1554         }
1555
1556         if(rem != nil)
1557                 snprint(x, sizeof(x), "!%s", rem);
1558         else
1559                 *x = 0;
1560
1561         if(*t->val == '*')
1562                 snprint(reply, sizeof(reply), "%s/%s/clone %s%s",
1563                         mntpt, np->net, ts, x);
1564         else {
1565                 if(parseip(ip, t->val) == -1)
1566                         return nil;
1567                 if((np->ipvers & confipvers & (isv4(ip) ? V4 : V6)) == 0)
1568                         return nil;
1569                 snprint(reply, sizeof(reply), "%s/%s/clone %I!%s%s%s",
1570                         mntpt, np->net, ip, ts, x, fasttimeout? "!fasttimeout": "");
1571         }
1572
1573         return estrdup(reply);
1574 }
1575
1576 /*
1577  *  lookup a telephone number
1578  */
1579 Ndbtuple*
1580 telcolookup(Network *np, char *host, char *serv)
1581 {
1582         Ndbtuple *t;
1583         Ndbs s;
1584
1585         USED(np, serv);
1586
1587         werrstr("can't translate address");
1588         free(ndbgetvalue(db, &s, "sys", host, "telco", &t));
1589         if(t == nil)
1590                 return ndbline(ndbnew("telco", host));
1591
1592         return ndbreorder(t, s.t);
1593 }
1594
1595 /*
1596  *  translate a telephone address
1597  */
1598 char*
1599 telcotrans(Ndbtuple *t, Network *np, char *serv, char *rem, int)
1600 {
1601         char reply[Maxreply];
1602         char x[Maxservice];
1603
1604         if(strcmp(t->attr, "telco") != 0)
1605                 return nil;
1606
1607         if(rem != nil)
1608                 snprint(x, sizeof(x), "!%s", rem);
1609         else
1610                 *x = 0;
1611         if(serv != nil)
1612                 snprint(reply, sizeof(reply), "%s/%s/clone %s!%s%s", mntpt, np->net,
1613                         t->val, serv, x);
1614         else
1615                 snprint(reply, sizeof(reply), "%s/%s/clone %s%s", mntpt, np->net,
1616                         t->val, x);
1617         return estrdup(reply);
1618 }
1619
1620 /*
1621  *  create a slave process to handle a request to avoid one request blocking
1622  *  another.  parent returns to job loop.
1623  */
1624 void
1625 slave(char *host)
1626 {
1627         if(*isslave)
1628                 return;         /* we're already a slave process */
1629         if(ainc(&active) >= Maxactive){
1630                 adec(&active);
1631                 return;
1632         }
1633         switch(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT)){
1634         case -1:
1635                 adec(&active);
1636                 break;
1637         case 0:
1638                 *isslave = 1;
1639                 if(debug)
1640                         syslog(0, logfile, "slave %d", getpid());
1641                 procsetname("%s", host);
1642                 break;
1643         default:
1644                 longjmp(masterjmp, 1);
1645         }
1646
1647 }
1648
1649 static int
1650 mountdns(void)
1651 {
1652         static QLock mountlock;
1653         static int mounted;
1654         char buf[128], *p;
1655         int fd;
1656
1657         if(mounted)
1658                 return 0;
1659
1660         qlock(&mountlock);
1661         snprint(buf, sizeof(buf), "%s/dns", mntpt);
1662         if(access(buf, AEXIST) == 0)
1663                 goto done;
1664         if(strcmp(mntpt, "/net") == 0)
1665                 snprint(buf, sizeof(buf), "/srv/dns");
1666         else {
1667                 snprint(buf, sizeof(buf), "/srv/dns%s", mntpt);
1668                 while((p = strchr(buf+8, '/')) != nil)
1669                         *p = '_';
1670         }
1671         if((fd = open(buf, ORDWR)) < 0){
1672 err:
1673                 qunlock(&mountlock);
1674                 return -1;
1675         }
1676         if(mount(fd, -1, mntpt, MAFTER, "") == -1){
1677                 close(fd);
1678                 goto err;
1679         }
1680 done:
1681         mounted = 1;
1682         qunlock(&mountlock);
1683         return 0;
1684 }
1685
1686 static Ndbtuple*
1687 dnsip6lookup(char *mntpt, char *buf, Ndbtuple *t)
1688 {
1689         Ndbtuple *t6, *tt;
1690
1691         t6 = dnsquery(mntpt, buf, "ipv6");      /* lookup AAAA dns RRs */
1692         if (t6 == nil)
1693                 return t;
1694
1695         /* convert ipv6 attr to ip */
1696         for (tt = t6; tt != nil; tt = tt->entry)
1697                 if (strcmp(tt->attr, "ipv6") == 0)
1698                         strcpy(tt->attr, "ip");
1699
1700         /* append t6 list to t list */
1701         return ndbconcatenate(t, t6);
1702 }
1703
1704 /*
1705  *  call the dns process and have it try to translate a name
1706  */
1707 Ndbtuple*
1708 dnsiplookup(char *host, Ndbs *s, int ipvers)
1709 {
1710         char buf[Maxreply];
1711         Ndbtuple *t;
1712
1713         ipvers &= dnsipvers & lookipvers;
1714         if(ipvers == 0){
1715                 werrstr("no ip address");
1716                 return nil;
1717         }
1718         qunlock(&dblock);
1719         slave(host);
1720         if(*isslave == 0){
1721                 qlock(&dblock);
1722                 werrstr("too much activity");
1723                 return nil;
1724         }
1725
1726         if(mountdns() < 0){
1727                 qlock(&dblock);
1728                 return nil;
1729         }
1730
1731         if(strcmp(ipattr(host), "ip") == 0)
1732                 t = dnsquery(mntpt, host, "ptr");
1733         else {
1734                 t = nil;
1735                 if(ipvers & V4)
1736                         t = dnsquery(mntpt, host, "ip");
1737                 if(ipvers & V6)
1738                         t = dnsip6lookup(mntpt, host, t);
1739         }
1740         s->t = t;
1741
1742         if(t == nil){
1743                 rerrstr(buf, sizeof buf);
1744                 if(strstr(buf, "exist") != nil)
1745                         werrstr("can't translate address: %s", buf);
1746                 else if(strstr(buf, "dns failure") != nil)
1747                         werrstr("temporary problem: %s", buf);
1748         }
1749
1750         qlock(&dblock);
1751         return t;
1752 }
1753
1754 int
1755 qmatch(Ndbtuple *t, char **attr, char **val, int n)
1756 {
1757         int i, found;
1758         Ndbtuple *nt;
1759
1760         for(i = 1; i < n; i++){
1761                 found = 0;
1762                 for(nt = t; nt != nil; nt = nt->entry)
1763                         if(strcmp(attr[i], nt->attr) == 0)
1764                                 if(strcmp(val[i], "*") == 0
1765                                 || strcmp(val[i], nt->val) == 0){
1766                                         found = 1;
1767                                         break;
1768                                 }
1769                 if(found == 0)
1770                         break;
1771         }
1772         return i == n;
1773 }
1774
1775 void
1776 qreply(Mfile *mf, Ndbtuple *t)
1777 {
1778         Ndbtuple *nt;
1779         String *s;
1780
1781         s = s_new();
1782         for(nt = t; mf->nreply < Nreply && nt != nil; nt = nt->entry){
1783                 s_append(s, nt->attr);
1784                 s_append(s, "=");
1785                 s_append(s, nt->val);
1786
1787                 if(nt->line != nt->entry){
1788                         mf->replylen[mf->nreply] = s_len(s);
1789                         mf->reply[mf->nreply++] = estrdup(s_to_c(s));
1790                         s_restart(s);
1791                 } else
1792                         s_append(s, " ");
1793         }
1794         s_free(s);
1795 }
1796
1797 enum
1798 {
1799         Maxattr=        32,
1800 };
1801
1802 /*
1803  *  generic query lookup.  The query is of one of the following
1804  *  forms:
1805  *
1806  *  attr1=val1 attr2=val2 attr3=val3 ...
1807  *
1808  *  returns the matching tuple
1809  *
1810  *  ipinfo attr=val attr1 attr2 attr3 ...
1811  *
1812  *  is like ipinfo and returns the attr{1-n}
1813  *  associated with the ip address.
1814  */
1815 char*
1816 genquery(Mfile *mf, char *query)
1817 {
1818         int i, n;
1819         char *p;
1820         char *attr[Maxattr];
1821         char *val[Maxattr];
1822         Ndbtuple *t;
1823         Ndbs s;
1824
1825         n = getfields(query, attr, nelem(attr), 1, " ");
1826         if(n == 0)
1827                 return "bad query";
1828
1829         if(strcmp(attr[0], "ipinfo") == 0)
1830                 return ipinfoquery(mf, attr, n);
1831
1832         /* parse pairs */
1833         for(i = 0; i < n; i++){
1834                 p = strchr(attr[i], '=');
1835                 if(p == nil)
1836                         return "bad query";
1837                 *p++ = 0;
1838                 val[i] = p;
1839         }
1840
1841         /* give dns a chance */
1842         if((strcmp(attr[0], "dom") == 0 || strcmp(attr[0], "ip") == 0) && val[0]){
1843                 t = dnsiplookup(val[0], &s, lookipvers);
1844                 if(t != nil){
1845                         if(qmatch(t, attr, val, n)){
1846                                 qreply(mf, t);
1847                                 ndbfree(t);
1848                                 return nil;
1849                         }
1850                         ndbfree(t);
1851                 }
1852         }
1853
1854         /* first pair is always the key.  It can't be a '*' */
1855         t = ndbsearch(db, &s, attr[0], val[0]);
1856
1857         /* search is the and of all the pairs */
1858         while(t != nil){
1859                 if(qmatch(t, attr, val, n)){
1860                         qreply(mf, t);
1861                         ndbfree(t);
1862                         return nil;
1863                 }
1864
1865                 ndbfree(t);
1866                 t = ndbsnext(&s, attr[0], val[0]);
1867         }
1868
1869         return "no match";
1870 }
1871
1872 /*
1873  *  resolve an ip address
1874  */
1875 static Ndbtuple*
1876 ipresolve(char *attr, char *host)
1877 {
1878         Ndbtuple *t, *nt, **l;
1879
1880         t = iplookup(&network[Ntcp], host, "*");
1881         for(l = &t; *l != nil; ){
1882                 nt = *l;
1883                 if(strcmp(nt->attr, "ip") != 0){
1884                         *l = nt->entry;
1885                         nt->entry = nil;
1886                         ndbfree(nt);
1887                         continue;
1888                 }
1889                 nstrcpy(nt->attr, attr, sizeof(nt->attr));
1890                 l = &nt->entry;
1891         }
1892         return t;
1893 }
1894
1895 char*
1896 ipinfoquery(Mfile *mf, char **list, int n)
1897 {
1898         int i, nresolve;
1899         uchar resolve[Maxattr];
1900         Ndbtuple *t, *nt, **l;
1901         char *attr, *val;
1902
1903         /* skip 'ipinfo' */
1904         list++; n--;
1905
1906         if(n < 1)
1907                 return "bad query";
1908
1909         /* get search attribute=value, or assume myip */
1910         attr = *list;
1911         if((val = strchr(attr, '=')) != nil){
1912                 *val++ = 0;
1913                 list++;
1914                 n--;
1915         }else{
1916                 attr = nil;
1917                 val = nil;
1918         }
1919         if(n < 1)
1920                 return "bad query";
1921
1922
1923         /*
1924          *  don't let ndbipinfo resolve the addresses, we're
1925          *  better at it.
1926          */
1927         nresolve = 0;
1928         for(i = 0; i < n; i++)
1929                 if(*list[i] == '@'){            /* @attr=val ? */
1930                         list[i]++;
1931                         resolve[i] = 1;         /* we'll resolve it */
1932                         nresolve++;
1933                 } else
1934                         resolve[i] = 0;
1935
1936         if(attr == nil)
1937                 t = myipinfo(db, list, n);
1938         else
1939                 t = ndbipinfo(db, attr, val, list, n);
1940
1941         if(t == nil)
1942                 return "no match";
1943
1944         if(nresolve != 0){
1945                 for(l = &t; *l != nil;){
1946                         nt = *l;
1947
1948                         /* already an address? */
1949                         if(strcmp(ipattr(nt->val), "ip") == 0){
1950                                 l = &(*l)->entry;
1951                                 continue;
1952                         }
1953
1954                         /* user wants it resolved? */
1955                         for(i = 0; i < n; i++)
1956                                 if(strcmp(list[i], nt->attr) == 0)
1957                                         break;
1958                         if(i >= n || resolve[i] == 0){
1959                                 l = &(*l)->entry;
1960                                 continue;
1961                         }
1962
1963                         /* resolve address and replace entry */
1964                         *l = ipresolve(nt->attr, nt->val);
1965                         while(*l != nil)
1966                                 l = &(*l)->entry;
1967                         *l = nt->entry;
1968
1969                         nt->entry = nil;
1970                         ndbfree(nt);
1971                 }
1972
1973                 t = ndbdedup(t);
1974         }
1975
1976         /* make it all one line */
1977         t = ndbline(t);
1978
1979         qreply(mf, t);
1980
1981         return nil;
1982 }
1983
1984 void*
1985 emalloc(int size)
1986 {
1987         void *x;
1988
1989         x = malloc(size);
1990         if(x == nil)
1991                 error("out of memory");
1992         memset(x, 0, size);
1993         return x;
1994 }
1995
1996 char*
1997 estrdup(char *s)
1998 {
1999         int size;
2000         char *p;
2001
2002         size = strlen(s);
2003         p = malloc(size+1);
2004         if(p == nil)
2005                 error("out of memory");
2006         memmove(p, s, size);
2007         p[size] = 0;
2008         return p;
2009 }