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