home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 024 / psi110g.zip / DOMAIN.C < prev    next >
C/C++ Source or Header  |  1994-04-17  |  67KB  |  2,370 lines
  1. /*
  2.  *      DOMAIN.C -- domain name system stub resolver
  3.  *
  4.  *      Original code by Phil Karn, KA9Q
  5.  *
  6.  *      04-90 -- Bill Simpson added address->name resolution, time-to-live,
  7.  *      thru     memory caching, generalized multi-record multi-type searches,
  8.  *      10-90    and many minor changes to conform more closely to the RFCs.
  9.  *
  10.  *  06-89 -- Gerard van der Grinten, PA0GRI
  11.  *      thru     Lots of changes and inprovements including server code.
  12.  *      02-91
  13.  *
  14.  *  Jan 92  Bill Simpson added CNAME support to domainsuffix routine.
  15.  *
  16.  *  Jun 92  Johan. K. Reinalda, WG7J
  17.  *          Ported the Domain Name Server from PA0GRI's 910828 .
  18.  *          Version info see down below
  19.  *
  20.  */
  21.   
  22. #include <ctype.h>
  23. #include <time.h>
  24. #include <sys/types.h>
  25. #include <sys/stat.h>
  26. #include "global.h"
  27. #include "mbuf.h"
  28. #include "netuser.h"
  29. #include "ip.h"
  30. #include "socket.h"
  31. #include "cmdparse.h"
  32. #include "proc.h"
  33. #include "domain.h"
  34. #include "commands.h"
  35. #include "files.h"
  36. #include "getline.h"
  37.   
  38. #ifdef LINUX
  39. #define fprintf tfprintf
  40. #define printf tprintf
  41. #endif
  42.   
  43. #undef  DEBUG               /* for certain trace messages */
  44. #undef  DEBUG_PAIN                      /* for painful debugging */
  45.   
  46. extern int main_exit;                   /* from main program (flag) */
  47. extern int Mprunning;                   /* from main program (flag) */
  48. int DTranslate;                 /* do IP address to domain name translation */
  49. int DVerbose;                   /* Use all of resolved name or first element */
  50.   
  51.   
  52. static struct rr *Dcache;       /* Cache of resource records */
  53. static int Dcache_size = 20;            /* size limit */
  54. static time_t Dcache_time = 0L;         /* timestamp */
  55.   
  56. static int Dfile_clean;             /* discard expired records (flag) */
  57. static int Dfile_reading;           /* read interlock (count) */
  58. static int Dfile_writing;           /* write interlock (count) */
  59.   
  60. struct proc *Dfile_updater;
  61. static int32 Dfile_wait_absolute;       /* timeout Clock time */
  62. static int Dfile_wait_relative = 300;   /* timeout file activity (seconds) */
  63.   
  64. static struct dserver *Dservers;        /* List of potential servers */
  65. static int Dserver_retries = 2;         /* Attempts to reach servers */
  66. static int32 Dserver_maxwait = 60L;     /* maximum server timeout limit (seconds) */
  67.   
  68. /* KG7CP -  */
  69. static int Dfile_upd = 1;        /* update the domain file (flag) */
  70. #ifdef DOMAINSERVER
  71. static int32 Dns_ttl = 0L;      /* time-to-live of dns answers */
  72. #endif
  73. /* N7IPB */
  74. static int Dsubnet_translate = 1;   /* Translate subnet and broadcast addresses */
  75.   
  76. static char *Dsuffix;           /* Default suffix for names without periods */
  77. static int Dsuffixl;            /* size of Dsuffix (less computing to do */
  78. static int Dtrace;
  79. static char *Dtypes[] = {
  80.     "",
  81.     "A",
  82.     "NS",
  83.     "MD",
  84.     "MF",
  85.     "CNAME",
  86.     "SOA",
  87.     "MB",
  88.     "MG",
  89.     "MR",
  90.     "NULL",
  91.     "WKS",
  92.     "PTR",
  93.     "HINFO",
  94.     "MINFO",
  95.     "MX",
  96.     "TXT"
  97. };
  98. #define NDTYPES 17
  99. static char delim[] = " \t\r\n";
  100.   
  101. static int docache __ARGS((int argc,char *argv[],void *p));
  102. static int dosuffix __ARGS((int argc,char *argv[],void *p));
  103. static int dotranslate __ARGS((int argc,char *argv[],void *p));
  104. static int doverbose __ARGS((int argc,char *argv[],void *p));
  105.   
  106. static int docacheclean __ARGS((int argc,char *argv[],void *p));
  107. static int docachelist __ARGS((int argc,char *argv[],void *p));
  108. static int docachesize __ARGS((int argc,char *argv[],void *p));
  109. static int docachewait __ARGS((int argc,char *argv[],void *p));
  110.   
  111. static int dofileupdate __ARGS((int argc,char *argv[],void *p));
  112. static int dodns_ttl __ARGS((int argc,char *argv[],void *p));
  113. static int docachedump __ARGS((int argc,char *argv[],void *p));
  114. static int dosubnet_translate __ARGS((int argc,char *argv[],void *p));
  115.   
  116. static void dlist_add __ARGS((struct dserver *dp));
  117. static void dlist_drop __ARGS((struct dserver *dp));
  118. static int dodnsadd __ARGS((int argc,char *argv[],void *p));
  119. static int dodnsdrop __ARGS((int argc,char *argv[],void *p));
  120. static int dodnslist __ARGS((int argc,char *argv[],void *p));
  121. static int dodnsmaxw __ARGS((int argc,char *argv[],void *p));
  122. static int dodnsretry __ARGS((int argc,char *argv[],void *p));
  123. static int dodnstrace __ARGS((int argc,char *argv[],void *p));
  124. static int dodnsserver __ARGS((int argc,char *argv[],void *p));
  125. static int dodomlook __ARGS((int argc,char *argv[],void *p));
  126.   
  127. static int check_ttl __ARGS((struct rr *rrlp));
  128. static int compare_rr __ARGS((struct rr *search_rrp,struct rr *target_rrp));
  129. static int compare_rr_list __ARGS((struct rr *rrlp,struct rr *target_rrp));
  130. static struct rr *copy_rr __ARGS((struct rr *rrp));
  131. static struct rr *copy_rr_list __ARGS((struct rr *rrlp));
  132. static struct rr *make_rr __ARGS((int source,
  133. char *dname,int16 class,int16 type,int32 ttl,int16 rdl,void *data));
  134.   
  135. static void dcache_add __ARGS((struct rr *rrlp));
  136. static void dcache_drop __ARGS((struct rr *rrp));
  137. static struct rr *dcache_search __ARGS((struct rr *rrlp));
  138. static void dcache_update __ARGS((struct rr *rrlp));
  139.   
  140. static struct rr *get_rr __ARGS((FILE *fp, struct rr *lastrrp));
  141. static void put_rr __ARGS((FILE *fp,struct rr *rrp));
  142. static struct rr *dfile_search __ARGS((struct rr *rrlp));
  143. static void dfile_update __ARGS((int s,void *unused,void *p));
  144.   
  145. static void dumpdomain __ARGS((struct dhdr *dhp,int32 rtt));
  146. static int dns_makequery __ARGS((int16 op,struct rr *rrp,
  147. char *buffer,int16 buflen));
  148. static void dns_query __ARGS((struct rr *rrlp));
  149.   
  150. static int isaddr __ARGS((char *s));
  151. static struct rr *resolver __ARGS((struct rr *rrlp));
  152.   
  153. static void free_dhdr __ARGS((struct dhdr *));
  154. static void proc_query __ARGS((int,void *,void *));
  155. static void drx __ARGS((int,void *,void *));
  156.   
  157. /**
  158.  **     Domain Resolver Commands
  159.  **/
  160.   
  161. static struct cmds Dcmds[] = {
  162.     "addserver",    dodnsadd,       0, 2, "add <hostid>",
  163.     "cache",        docache,        0, 0, NULLCHAR,
  164. #ifdef DOMAINSERVER
  165.     "dns",      dodnsserver,0, 0, NULLCHAR,
  166. #endif
  167.     "dropserver",   dodnsdrop,      0, 2, "drop <hostid>",
  168.     "list",         dodnslist,      0, 0, NULLCHAR,
  169. #ifdef MORESESSION
  170.     "look",     dodomlook,  512, 2, "look <search text>",
  171. #endif
  172.     "maxwait",  dodnsmaxw,  0, 0, NULLCHAR,
  173.     "retry",        dodnsretry,     0, 0, NULLCHAR,
  174.     "subnet",   dosubnet_translate,     0, 0, NULLCHAR,
  175.     "suffix",       dosuffix,       0, 0, NULLCHAR,
  176.     "trace",    dodnstrace, 0, 0, NULLCHAR,
  177.     "translate",    dotranslate,    0, 0, NULLCHAR,
  178. #ifdef DOMAINSERVER
  179. /*KG7CP - */
  180.     "ttl",          dodns_ttl,      0, 0, NULLCHAR,
  181. #endif
  182.     "update",       dofileupdate,   0, 0, NULLCHAR,
  183.     "verbose",      doverbose,      0, 0, NULLCHAR,
  184.     NULLCHAR,
  185. };
  186.   
  187. static struct cmds Dcachecmds[] = {
  188.     "clean",        docacheclean,   0, 0, NULLCHAR,
  189.     "dump",         docachedump,    0, 0, NULLCHAR,
  190.     "list",         docachelist,    0, 0, NULLCHAR,
  191.     "size",         docachesize,    0, 0, NULLCHAR,
  192.     "wait",         docachewait,    0, 0, NULLCHAR,
  193.     NULLCHAR,
  194. };
  195.   
  196. int
  197. dodomain(argc,argv,p)
  198. int argc;
  199. char *argv[];
  200. void *p;
  201. {
  202.     return subcmd(Dcmds,argc,argv,p);
  203. }
  204.   
  205. int
  206. docache(argc,argv,p)
  207. int argc;
  208. char *argv[];
  209. void *p;
  210. {
  211.     return subcmd(Dcachecmds,argc,argv,p);
  212. }
  213.   
  214. static int
  215. dosuffix(argc,argv,p)
  216. int argc;
  217. char *argv[];
  218. void *p;
  219. {
  220.     if(argc < 2){
  221.         if(Dsuffix != NULLCHAR)
  222.             tprintf("%s\n",Dsuffix);
  223.         else
  224.             tputs("No domain suffix defined.\n");
  225.         return 0;
  226.     }
  227.     if(strcmp(argv[1],"none") == 0){
  228.         if(Dsuffix != NULLCHAR){
  229.             free(Dsuffix);
  230.             Dsuffix = NULLCHAR ;    /* clear out suffix */
  231.             Dsuffixl = 0;
  232.         }
  233.     } else
  234.         if(argv[1][strlen(argv[1])-1] != '.'){
  235.             tprintf(" %s is not a valid suffix.\n",argv[1]);
  236.             return 1;
  237.         } else {
  238.             free(Dsuffix);
  239.             Dsuffix = strdup(argv[1]);
  240.             Dsuffixl = strlen(Dsuffix);
  241.         }
  242.     return 0;
  243. }
  244.   
  245. static int
  246. dotranslate(argc,argv,p)
  247. int argc;
  248. char *argv[];
  249. void *p;
  250. {
  251.     return setbool( &DTranslate, "Tranlslate IP address to host names", argc,argv );
  252. }
  253.   
  254. static int
  255. doverbose(argc,argv,p)
  256. int argc;
  257. char *argv[];
  258. void *p;
  259. {
  260.     return setbool( &DVerbose, "Verbose translation of host names", argc,argv );
  261. }
  262.   
  263. static int
  264. dodnsmaxw(argc,argv,p)
  265. int argc;
  266. char *argv[];
  267. void *p;
  268. {
  269.     return setlong(&Dserver_maxwait,"Server response timeout limit (sec)",argc,argv);
  270. }
  271.   
  272. static int
  273. docacheclean(argc,argv,p)
  274. int argc;
  275. char *argv[];
  276. void *p;
  277. {
  278.     return setbool( &Dfile_clean, "discard expired records", argc,argv );
  279. }
  280.   
  281. #ifdef DOMAINSERVER
  282. /*KG7CP -  set the standard time-to-live for nameserver answers */
  283. static int
  284. dodns_ttl(argc,argv,p)
  285. int argc;
  286. char *argv[];
  287. void *p;
  288. {
  289.     return setlong( &Dns_ttl, "ttl of nameserver answers (seconds)", argc,argv );
  290. }
  291. #endif
  292.   
  293. /* KG7CP -   remove all entries from the cache */
  294. static int
  295. docachedump(argc, argv, p)
  296. int argc;
  297. char *argv[];
  298. void *p;
  299. {
  300.     struct rr *dump_rrlp;
  301.     dump_rrlp = Dcache;
  302.     Dcache = NULLRR;
  303.     free_rr(dump_rrlp);
  304.     return 0;
  305. }
  306.   
  307. /* KG7CP -  flag whether the domain file is updated from name server
  308.  * quey responses
  309.  */
  310. static int
  311. dofileupdate(argc, argv, p)
  312. int argc;
  313. char *argv[];
  314. void *p;
  315. {
  316.     return setbool( &Dfile_upd, "update domain file", argc,argv );
  317. }
  318.   
  319. /* N7IPB - Enable or Disable translation of subnet and broadcast addresses */
  320. static int
  321. dosubnet_translate(argc, argv, p)
  322. int argc;
  323. char *argv[];
  324. void *p;
  325. {
  326.     return setbool( &Dsubnet_translate, "Translate subnet and broadcast addresses", argc,argv );
  327. }
  328.   
  329. static int
  330. docachelist(argc,argv,p)
  331. int argc;
  332. char *argv[];
  333. void *p;
  334. {
  335.     struct rr *rrp;
  336.   
  337.     (void)dcache_search(NULLRR); /* update ttl */
  338. #ifndef LINUX
  339.     rflush();
  340. #endif
  341.     for(rrp=Dcache;rrp!=NULLRR;rrp=rrp->next)
  342.     {
  343.         put_rr(stdout,rrp);
  344.     }
  345.     return 0;
  346. }
  347.   
  348. static int
  349. docachesize(argc,argv,p)
  350. int argc;
  351. char *argv[];
  352. void *p;
  353. {
  354.     int newsize;
  355.     int oldsize;
  356.     int result;
  357.   
  358.     newsize = oldsize = Dcache_size;
  359.     result = setint( &newsize, "memory cache size", argc,argv );
  360.   
  361.     if(newsize > 0){
  362.         Dcache_size = newsize;
  363.         if(newsize < oldsize){
  364.             (void)dcache_search(NULLRR); /* update size */
  365.         }
  366.     }
  367.     return result;
  368. }
  369.   
  370. static int
  371. docachewait(argc,argv,p)
  372. int argc;
  373. char *argv[];
  374. void *p;
  375. {
  376.     return setint( &Dfile_wait_relative, "time before file update (seconds)", argc,argv );
  377. }
  378.   
  379. static void
  380. dlist_add(dp)
  381. register struct dserver *dp;
  382. {
  383.     dp->prev = NULLDOM;
  384.     dp->next = Dservers;
  385.     if(Dservers != NULLDOM)
  386.         Dservers->prev = dp;
  387.     Dservers = dp;
  388. }
  389.   
  390. static void
  391. dlist_drop(dp)
  392. register struct dserver *dp;
  393. {
  394.     if(dp->prev != NULLDOM)
  395.         dp->prev->next = dp->next;
  396.     else
  397.         Dservers = dp->next;
  398.     if(dp->next != NULLDOM)
  399.         dp->next->prev = dp->prev;
  400. }
  401.   
  402. static int
  403. dodnsadd(argc,argv,p)
  404. int argc;
  405. char *argv[];
  406. void *p;
  407. {
  408.     int32 address;
  409.     int timeout = 0;
  410.   
  411.     if((address = resolve(argv[1])) == 0L){
  412.         tprintf("Resolver %s unknown\n",argv[1]);
  413.         return 1;
  414.     }
  415.     if(argc > 1)
  416.         timeout = atoi(argv[2]);
  417.     return add_nameserver(address,timeout);
  418. }
  419. int
  420. add_nameserver(address,timeout)
  421. int32 address;
  422. int timeout;
  423. {
  424.     extern int32 Tcp_irtt;
  425.     struct dserver *dp;
  426.   
  427.     dp = (struct dserver *)callocw(1,sizeof(struct dserver));
  428.     dp->address = address;
  429.     if(timeout)
  430.         dp->srtt = timeout * 1000L;
  431.     else
  432.         dp->srtt = 3 * Tcp_irtt;  /* Round trip plus processing time */
  433.     dp->mdev = 0;
  434.     dp->timeout = dp->srtt;    /* 4 * dp->mdev + dp->srtt;*/
  435.     dlist_add(dp);
  436.     return 0;
  437. }
  438.   
  439. static int
  440. dodnsdrop(argc,argv,p)
  441. int argc;
  442. char *argv[];
  443. void *p;
  444. {
  445.     struct dserver *dp;
  446.     int32 addr;
  447.   
  448.     addr = resolve(argv[1]);
  449.     for(dp = Dservers;dp != NULLDOM;dp = dp->next)
  450.         if(addr == dp->address)
  451.             break;
  452.   
  453.     if(dp == NULLDOM){
  454.         tputs("Not found\n");
  455.         return 1;
  456.     }
  457.   
  458.     dlist_drop(dp);
  459.     free((char *)dp);
  460.     return 0;
  461. }
  462.   
  463. static int
  464. dodnslist(argc,argv,p)
  465. int argc;
  466. char *argv[];
  467. void *p;
  468. {
  469.     register struct dserver *dp;
  470.   
  471.     tputs("Server address          srtt    mdev    timeout  queries responses timeouts\n");
  472.     for(dp = Dservers;dp != NULLDOM;dp = dp->next){
  473.         tprintf("%-20s%8lu%8lu%10lu%10lu%10lu%10lu\n",
  474.         inet_ntoa(dp->address),
  475.         dp->srtt,dp->mdev,dp->timeout,
  476.         dp->queries,dp->responses,dp->timeouts);
  477.     }
  478.     return 0;
  479. }
  480.   
  481. static int
  482. dodnsretry(argc,argv,p)
  483. int argc;
  484. char *argv[];
  485. void *p;
  486. {
  487.     return setint( &Dserver_retries, "server retries", argc,argv );
  488. }
  489.   
  490. static int
  491. dodnstrace(argc,argv,p)
  492. int argc;
  493. char *argv[];
  494. void *p;
  495. {
  496.     return setbool(&Dtrace,"server trace",argc,argv);
  497. }
  498.   
  499.   
  500. /**
  501.  **     Domain Resource Record Utilities
  502.  **/
  503.   
  504. /* check list of resource records for any expired ones.
  505.  * returns number of expired records.
  506.  */
  507. static int
  508. check_ttl(rrlp)
  509. register struct rr *rrlp;
  510. {
  511.     int count = 0;
  512.   
  513.     while(rrlp != NULLRR){
  514.         if(rrlp->ttl == 0L)
  515.             count++;
  516.         rrlp = rrlp->next;
  517.     }
  518.     return count;
  519. }
  520.   
  521. /* Compare two resource records.
  522.  * returns 0 if match, nonzero otherwise.
  523.  */
  524. static int
  525. compare_rr(search_rrp,target_rrp)
  526. register struct rr *search_rrp,*target_rrp;
  527. {
  528.     int i, j, k;
  529.   
  530.     if(search_rrp == NULLRR || target_rrp == NULLRR)
  531.         return -32765;
  532.   
  533.     if(search_rrp->class != target_rrp->class)
  534.         return -32763;
  535.   
  536.     if(search_rrp->type != target_rrp->type
  537.         && (search_rrp->source != RR_QUERY
  538.         || (target_rrp->type != TYPE_CNAME
  539.         && target_rrp->type != TYPE_PTR)))
  540.         return -32761;
  541.   
  542.     if(search_rrp->source != RR_INQUERY){
  543.         i = strlen(search_rrp->name);
  544.         j = strlen(target_rrp->name);
  545.         if(i == j){
  546.             if((k = strnicmp(search_rrp->name,target_rrp->name,i)) != 0){
  547.                 return k;
  548.             }
  549.         } else {
  550.   
  551.             if(Dsuffix != NULLCHAR){
  552.                 if(i != j+Dsuffixl+1){
  553.                     return -32759;
  554.                 } else {
  555.                     if(search_rrp->name[j] != '.')
  556.                         return -32755;
  557.                     if(strnicmp(target_rrp->name
  558.                         ,search_rrp->name,j) != 0)
  559.                         return -32757;
  560.                 }
  561.             } else {
  562.                 return -32759;
  563.             }
  564.   
  565.         /* match negative records so that they are replaced */
  566.             if(target_rrp->rdlength == 0)
  567.                 return 0;
  568.         }
  569.     }
  570.   
  571.     /* if a query has gotten this far, match it */
  572.     if(search_rrp->source == RR_QUERY)
  573.         return 0;
  574.   
  575.     /* ensure negative records don't replace older records */
  576.     if(search_rrp->rdlength == 0)
  577.         return -32757;
  578.   
  579.     /* match expired records so that they are replaced */
  580.     if(search_rrp->source != RR_INQUERY){
  581.         if(target_rrp->ttl == 0L)
  582.             return 0;
  583.     }
  584.   
  585.     /* Note: rdlengths are not compared because they vary depending
  586.      * on the representation (ASCII or encoded) this record was
  587.      * generated from.
  588.      */
  589.   
  590.     switch(search_rrp->type){
  591.         case TYPE_A:
  592.             i = search_rrp->rdata.addr != target_rrp->rdata.addr;
  593.             break;
  594.         case TYPE_CNAME:
  595.         case TYPE_MB:
  596.         case TYPE_MG:
  597.         case TYPE_MR:
  598.         case TYPE_NS:
  599.         case TYPE_PTR:
  600.         case TYPE_TXT:
  601.             i = stricmp(search_rrp->rdata.data,target_rrp->rdata.data);
  602.             break;
  603.         case TYPE_HINFO:
  604.             i = strcmp(search_rrp->rdata.hinfo.cpu,target_rrp->rdata.hinfo.cpu) ||
  605.             strcmp(search_rrp->rdata.hinfo.os,target_rrp->rdata.hinfo.os);
  606.             break;
  607.         case TYPE_MX:
  608.             i = stricmp(search_rrp->rdata.mx.exch,target_rrp->rdata.mx.exch);
  609.             break;
  610.         case TYPE_SOA:
  611.             i = search_rrp->rdata.soa.serial != target_rrp->rdata.soa.serial;
  612.             break;
  613.         default:
  614.             i = -32755;     /* unsupported */
  615.     }
  616.     return i;
  617. }
  618.   
  619. static int
  620. compare_rr_list(rrlp,target_rrp)
  621. register struct rr *rrlp,*target_rrp;
  622. {
  623.     while(rrlp != NULLRR){
  624.         if(compare_rr(rrlp,target_rrp) == 0)
  625.             return 0;
  626. #ifdef DEBUG_PAIN
  627.         if(Dtrace)
  628.             printf("%15d %s\n",
  629.             compare_rr(rrlp,target_rrp),
  630.             target_rrp->name);
  631. #endif
  632.         rrlp = rrlp->next;
  633.     }
  634.     return -32767;
  635. }
  636.   
  637. /* Make a new copy of a resource record */
  638. static struct rr *
  639. copy_rr(rrp)
  640. register struct rr *rrp;
  641. {
  642.     register struct rr *newrr;
  643.   
  644.     if(rrp == NULLRR)
  645.         return NULLRR;
  646.   
  647.     newrr = (struct rr *)callocw(1,sizeof(struct rr));
  648.     newrr->source = rrp->source;
  649.     newrr->name =   strdup(rrp->name);
  650.     newrr->type =   rrp->type;
  651.     newrr->class =  rrp->class;
  652.     newrr->ttl =    rrp->ttl;
  653.     if(rrp->suffix != NULLCHAR)
  654.         newrr->suffix = strdup(rrp->suffix);
  655.     if((newrr->rdlength = rrp->rdlength) == 0)
  656.         return newrr;
  657.   
  658.     switch(rrp->type){
  659.         case TYPE_A:
  660.             newrr->rdata.addr = rrp->rdata.addr;
  661.             break;
  662.         case TYPE_CNAME:
  663.         case TYPE_MB:
  664.         case TYPE_MG:
  665.         case TYPE_MR:
  666.         case TYPE_NS:
  667.         case TYPE_PTR:
  668.         case TYPE_TXT:
  669.             newrr->rdata.name = strdup(rrp->rdata.name);
  670.             break;
  671.         case TYPE_HINFO:
  672.             newrr->rdata.hinfo.cpu = strdup(rrp->rdata.hinfo.cpu);
  673.             newrr->rdata.hinfo.os = strdup(rrp->rdata.hinfo.os);
  674.             break;
  675.         case TYPE_MX:
  676.             newrr->rdata.mx.pref = rrp->rdata.mx.pref;
  677.             newrr->rdata.mx.exch = strdup(rrp->rdata.mx.exch);
  678.             break;
  679.         case TYPE_SOA:
  680.             newrr->rdata.soa.mname =        strdup(rrp->rdata.soa.mname);
  681.             newrr->rdata.soa.rname =        strdup(rrp->rdata.soa.rname);
  682.             newrr->rdata.soa.serial =       rrp->rdata.soa.serial;
  683.             newrr->rdata.soa.refresh =      rrp->rdata.soa.refresh;
  684.             newrr->rdata.soa.retry =        rrp->rdata.soa.retry;
  685.             newrr->rdata.soa.expire =       rrp->rdata.soa.expire;
  686.             newrr->rdata.soa.minimum =      rrp->rdata.soa.minimum;
  687.             break;
  688.     }
  689.     return newrr;
  690. }
  691.   
  692. static struct rr *
  693. copy_rr_list(rrlp)
  694. register struct rr *rrlp;
  695. {
  696.     register struct rr **rrpp;
  697.     struct rr *result_rrlp;
  698.   
  699.     rrpp = &result_rrlp;
  700.     while(rrlp != NULLRR){
  701.         *rrpp = copy_rr(rrlp);
  702.         rrpp = &(*rrpp)->next;
  703.         rrlp = rrlp->next;
  704.     }
  705.     *rrpp = NULLRR;
  706.     return result_rrlp;
  707. }
  708.   
  709. /* Free (list of) resource records */
  710. void
  711. free_rr(rrlp)
  712. register struct rr *rrlp;
  713. {
  714.     register struct rr *rrp;
  715.   
  716.     while((rrp = rrlp) != NULLRR){
  717.         rrlp = rrlp->next;
  718.   
  719.         free(rrp->comment);
  720.         free(rrp->suffix);
  721.         free(rrp->name);
  722.         if(rrp->rdlength > 0){
  723.             switch(rrp->type){
  724.                 case TYPE_A:
  725.                     break;  /* Nothing allocated in rdata section */
  726.                 case TYPE_CNAME:
  727.                 case TYPE_MB:
  728.                 case TYPE_MG:
  729.                 case TYPE_MR:
  730.                 case TYPE_NS:
  731.                 case TYPE_PTR:
  732.                 case TYPE_TXT:
  733.                     free(rrp->rdata.name);
  734.                     break;
  735.                 case TYPE_HINFO:
  736.                     free(rrp->rdata.hinfo.cpu);
  737.                     free(rrp->rdata.hinfo.os);
  738.                     break;
  739.                 case TYPE_MX:
  740.                     free(rrp->rdata.mx.exch);
  741.                     break;
  742.                 case TYPE_SOA:
  743.                     free(rrp->rdata.soa.mname);
  744.                     free(rrp->rdata.soa.rname);
  745.                     break;
  746.             }
  747.         }
  748.         free((char *)rrp);
  749.     }
  750. }
  751.   
  752. static struct rr *
  753. make_rr(source,dname,dclass,dtype,ttl,rdl,data)
  754. int source;
  755. char *dname;
  756. int16 dclass;
  757. int16 dtype;
  758. int32 ttl;
  759. int16 rdl;
  760. void *data;
  761. {
  762.     register struct rr *newrr;
  763.   
  764.     newrr = (struct rr *)callocw(1,sizeof(struct rr));
  765.     newrr->source = source;
  766.     newrr->name = strdup(dname);
  767.     newrr->class = dclass;
  768.     newrr->type = dtype;
  769.     newrr->ttl = ttl;
  770.     if((newrr->rdlength = rdl) == 0)
  771.         return newrr;
  772.   
  773.     switch(dtype){
  774.         case TYPE_A:
  775.         {
  776.             register int32 *ap = (int32 *)data;
  777.             newrr->rdata.addr = *ap;
  778.             break;
  779.         }
  780.         case TYPE_CNAME:
  781.         case TYPE_MB:
  782.         case TYPE_MG:
  783.         case TYPE_MR:
  784.         case TYPE_NS:
  785.         case TYPE_PTR:
  786.         case TYPE_TXT:
  787.         {
  788.             newrr->rdata.name = strdup((char *)data);
  789.             break;
  790.         }
  791.         case TYPE_HINFO:
  792.         {
  793.             register struct hinfo *hinfop = (struct hinfo *)data;
  794.             newrr->rdata.hinfo.cpu = strdup(hinfop->cpu);
  795.             newrr->rdata.hinfo.os = strdup(hinfop->os);
  796.             break;
  797.         }
  798.         case TYPE_MX:
  799.         {
  800.             register struct mx *mxp = (struct mx *)data;
  801.             newrr->rdata.mx.pref = mxp->pref;
  802.             newrr->rdata.mx.exch = strdup(mxp->exch);
  803.             break;
  804.         }
  805.         case TYPE_SOA:
  806.         {
  807.             register struct soa *soap = (struct soa *)data;
  808.             newrr->rdata.soa.mname =        strdup(soap->mname);
  809.             newrr->rdata.soa.rname =        strdup(soap->rname);
  810.             newrr->rdata.soa.serial =       soap->serial;
  811.             newrr->rdata.soa.refresh =      soap->refresh;
  812.             newrr->rdata.soa.retry =        soap->retry;
  813.             newrr->rdata.soa.expire =       soap->expire;
  814.             newrr->rdata.soa.minimum =      soap->minimum;
  815.             break;
  816.         }
  817.     }
  818.     return newrr;
  819. }
  820.   
  821.   
  822. /**
  823.  **     Domain Cache Utilities
  824.  **/
  825.   
  826. static void
  827. dcache_add(rrlp)
  828. register struct rr *rrlp;
  829. {
  830.     register struct rr *last_rrp;
  831.     struct rr *save_rrp;
  832.   
  833.     if(rrlp == NULLRR)
  834.         return;
  835.   
  836.     save_rrp = rrlp;
  837.     last_rrp = NULLRR;
  838.     while(rrlp != NULLRR){
  839.         rrlp->last = last_rrp;
  840.         last_rrp = rrlp;
  841.         rrlp = rrlp->next;
  842.     }
  843.     last_rrp->next = Dcache;
  844.     if(Dcache != NULLRR)
  845.         Dcache->last = last_rrp;
  846.     Dcache = save_rrp;
  847. }
  848.   
  849. static void
  850. dcache_drop(rrp)
  851. register struct rr *rrp;
  852. {
  853.     if(rrp->last != NULLRR)
  854.         rrp->last->next = rrp->next;
  855.     else
  856.         Dcache = rrp->next;
  857.     if(rrp->next != NULLRR)
  858.         rrp->next->last = rrp->last;
  859.     rrp->last =
  860.     rrp->next = NULLRR;
  861. }
  862.   
  863. /* Search cache for resource records, removing them from the cache.
  864.  * Also, timeout cache entries, and trim cache to size.
  865.  * (Calling with NULLRR is legal -- will timeout & trim only.)
  866.  * Note that an answer from the cache cannot be authoritative, because
  867.  * we cannot guarantee that all the entries remain from a previous request.
  868.  * Returns RR list, or NULLRR if no record found.
  869.  */
  870. static struct rr *
  871. dcache_search(rrlp)
  872. struct rr *rrlp;
  873. {
  874.     register struct rr *rrp, *test_rrp;
  875.     struct rr **rrpp, *result_rrlp;
  876.     int32 elapsed;
  877.     time_t now;
  878.     int count = 0;
  879.   
  880. #ifdef DEBUG
  881.     if(Dtrace && rrlp != NULLRR){
  882.         printf("dcache_search: searching for %s\n",rrlp->name);
  883.     }
  884. #endif
  885.   
  886.     elapsed = (int32)(time(&now) - Dcache_time);
  887.     Dcache_time = now;
  888.   
  889.     rrpp = &result_rrlp;
  890.     for(rrp = Dcache; (test_rrp = rrp) != NULLRR;){
  891.         rrp = rrp->next;
  892.                     /* timeout entries */
  893.         if(test_rrp->ttl > 0L
  894.             && (test_rrp->ttl -= elapsed) <= 0L)
  895.             test_rrp->ttl = 0L;
  896.   
  897.         if(compare_rr_list(rrlp,test_rrp) == 0){
  898.             dcache_drop( *rrpp = test_rrp );
  899.             rrpp = &(*rrpp)->next;
  900. /*        } else if(test_rrp->source == RR_FILE && ++count > Dcache_size){ */
  901.         } else if(++count > Dcache_size){
  902.             dcache_drop(test_rrp);
  903.             free_rr(test_rrp);
  904.         }
  905.     }
  906.     *rrpp = NULLRR;
  907.     return result_rrlp;
  908. }
  909.   
  910. /* Move a list of resource records to the cache, removing duplicates. */
  911. static void
  912. dcache_update(rrlp)
  913. register struct rr *rrlp;
  914. {
  915.     if(rrlp == NULLRR)
  916.         return;
  917.   
  918.     free_rr(dcache_search(rrlp));   /* remove duplicates, first */
  919.     dcache_add(rrlp);
  920. }
  921.   
  922.   
  923. /**
  924.  **     File Utilities
  925.  **/
  926.   
  927. static struct rr *
  928. get_rr(fp,lastrrp)
  929. FILE *fp;
  930. struct rr *lastrrp;
  931. {
  932.     char *line,*lp;
  933.     char *getline __ARGS((FILE *));
  934.     struct rr *rrp;
  935.     char *name,*ttl,*class,*type,*data;
  936.     int i;
  937.   
  938. #ifdef notdef
  939.     line = mallocw(256);
  940.     if(fgets(line,256,fp) == NULL){
  941.         free(line);
  942.         return NULLRR;
  943.     }
  944. #else
  945.     line = getline(fp);
  946.     if(line == NULLCHAR)            /* eof or error */
  947.         return NULLRR;
  948. #endif
  949.   
  950.     rrp = (struct rr *)callocw(1,sizeof(struct rr));
  951.     rrp->source = RR_FILE;
  952.   
  953. #ifdef notdef
  954.     /* This is handled in getline() */
  955.     if(line[0] == '\0' || line[0] == '#' || line[0] == ';'){
  956.         rrp->comment = line;
  957.         return rrp;
  958.     }
  959. #endif
  960.   
  961.     if(line[0] == '$') {
  962.         data = strtok(line,delim);
  963.         if(strnicmp(data,"$origin",7) == 0) {
  964.             data = strtok(NULLCHAR,delim);
  965.             rrp->suffix = strdup(data);
  966.             rrp->comment = strdup(line);
  967.             rrp->type = TYPE_MISSING;
  968.             free(line);
  969.             return rrp;
  970.         }
  971.     } else {
  972.         if(lastrrp != NULLRR)
  973.             if(lastrrp->suffix != NULLCHAR)
  974.                 rrp->suffix = strdup(lastrrp->suffix);
  975.     }
  976.   
  977.     if(!isspace(line[0]) || lastrrp == NULLRR){
  978.         name = strtok(line,delim);
  979.         lp = NULLCHAR;
  980.     } else {        /* Name field is missing */
  981.         name = lastrrp->name;
  982.         lp = line;
  983.     }
  984. #ifdef notdef
  985.     if(name == NULLCHAR || (name != NULLCHAR && (i = strlen(name)) == 0)){
  986.         rrp->comment = strdup("\n");
  987.         free(line);
  988.         return rrp;
  989.     }
  990. #endif
  991.   
  992.     if(name[0] == '@') {
  993.         if(rrp->suffix != NULLCHAR)
  994.             name = rrp->suffix;
  995.         else
  996.             if(Dsuffix != NULLCHAR)
  997.                 name = Dsuffix;
  998.             else
  999.                 name = "ampr.org.";
  1000.     }
  1001.   
  1002.     i=strlen(name);
  1003.     if(name[i-1] != '.'){
  1004.         /* Tack on the current domain suffix if defined */
  1005.         if(rrp->suffix != NULLCHAR && Dsuffix != NULLCHAR) {
  1006.             rrp->name = mallocw(i+strlen(rrp->suffix)+2);
  1007.             sprintf(rrp->name,"%s.%s",name,rrp->suffix);
  1008.         } else {
  1009.         /* Tack on a trailing period if it's not there */
  1010.             rrp->name = mallocw(i+2);
  1011.             strcpy(rrp->name,name);
  1012.             strcat(rrp->name,".");
  1013.         }
  1014.     } else
  1015.         /* fully qualified domain name */
  1016.         rrp->name = strdup(name);
  1017.   
  1018.     ttl = strtok(lp,delim);
  1019.   
  1020.     if(ttl == NULLCHAR || (!isdigit(ttl[0]) && ttl[0] != '-')){
  1021.         /* Optional ttl field is missing */
  1022.         rrp->ttl = TTL_MISSING;
  1023.         class = ttl;
  1024.     } else {
  1025.         rrp->ttl = atol(ttl);
  1026.         class = strtok(NULLCHAR,delim);
  1027.     }
  1028.   
  1029.     if(class == NULLCHAR){
  1030.         /* we're in trouble, but keep processing */
  1031.         rrp->class = CLASS_MISSING;
  1032.         type = class;
  1033.     } else if(class[0] == '<'){
  1034.         rrp->class = atoi(&class[1]);
  1035.         type = strtok(NULLCHAR,delim);
  1036.     } else if(stricmp(class,"IN") == 0){
  1037.         rrp->class = CLASS_IN;
  1038.         type = strtok(NULLCHAR,delim);
  1039.     } else {
  1040.         /* Optional class field is missing; assume IN */
  1041.         rrp->class = CLASS_IN;
  1042.         type = class;
  1043.     }
  1044.   
  1045.     if(type == NULLCHAR){
  1046.         /* we're in trouble, but keep processing */
  1047.         rrp->type = TYPE_MISSING;
  1048.         data = type;
  1049.     } else if(type[0] == '{'){
  1050.         rrp->type = atoi(&class[1]);
  1051.         data = strtok(NULLCHAR,delim);
  1052.     } else {
  1053.         rrp->type = TYPE_MISSING;
  1054.         for(i=1;i<NDTYPES;i++){
  1055.             if(stricmp(type,Dtypes[i]) == 0){
  1056.                 rrp->type = i;
  1057.                 data = strtok(NULLCHAR,delim);
  1058.                 break;
  1059.             }
  1060.         }
  1061.     }
  1062.   
  1063.     if(rrp->type == TYPE_MISSING){
  1064.         data = NULLCHAR;
  1065.     }
  1066.   
  1067.     if(data == NULLCHAR){
  1068.         /* Empty record, just return */
  1069.         free(line);
  1070.         return rrp;
  1071.     }
  1072.     switch(rrp->type){
  1073.         case TYPE_A:
  1074.             rrp->rdlength = 4;
  1075.             rrp->rdata.addr = aton(data);
  1076.             break;
  1077.         case TYPE_CNAME:
  1078.         case TYPE_MB:
  1079.         case TYPE_MG:
  1080.         case TYPE_MR:
  1081.         case TYPE_NS:
  1082.         case TYPE_PTR:
  1083.         case TYPE_TXT:
  1084.             rrp->rdlength = strlen(data);
  1085.             rrp->rdata.name = strdup(data);
  1086.             break;
  1087.         case TYPE_HINFO:
  1088.             rrp->rdlength = strlen(data);
  1089.             rrp->rdata.hinfo.cpu = strdup(data);
  1090.             if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1091.                 rrp->rdlength += strlen(data);
  1092.                 rrp->rdata.hinfo.os = strdup(data);
  1093.             }
  1094.             break;
  1095.         case TYPE_MX:
  1096.             rrp->rdata.mx.pref = atoi(data);
  1097.             rrp->rdlength = 2;
  1098.   
  1099.         /* Get domain name of exchanger */
  1100.             if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1101.                 rrp->rdlength += strlen(data);
  1102.                 rrp->rdata.mx.exch = strdup(data);
  1103.             }
  1104.             break;
  1105.         case TYPE_SOA:
  1106.         /* Get domain name of master name server */
  1107.             rrp->rdlength = strlen(data);
  1108.             rrp->rdata.soa.mname = strdup(data);
  1109.   
  1110.         /* Get domain name of irresponsible person */
  1111.             if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1112.                 rrp->rdata.soa.rname = strdup(data);
  1113.                 rrp->rdlength += strlen(data);
  1114.             }
  1115.             data = strtok(NULLCHAR,delim);
  1116.             rrp->rdata.soa.serial = atol(data);
  1117.             data = strtok(NULLCHAR,delim);
  1118.             rrp->rdata.soa.refresh = atol(data);
  1119.             data = strtok(NULLCHAR,delim);
  1120.             rrp->rdata.soa.retry = atol(data);
  1121.             data = strtok(NULLCHAR,delim);
  1122.             rrp->rdata.soa.expire = atol(data);
  1123.             data = strtok(NULLCHAR,delim);
  1124.             rrp->rdata.soa.minimum = atol(data);
  1125.             rrp->rdlength += 20;
  1126.             break;
  1127.     }
  1128.   
  1129.     /* !!! need to handle trailing comments */
  1130.     free(line);
  1131.     return rrp;
  1132. }
  1133.   
  1134. /* Print a resource record */
  1135. static void
  1136. put_rr(fp,rrp)
  1137. FILE *fp;
  1138. struct rr *rrp;
  1139. {
  1140.     int trans;
  1141.   
  1142.     if(fp == NULLFILE || rrp == NULLRR)
  1143.         return;
  1144.   
  1145.     if(rrp->name == NULLCHAR && rrp->comment != NULLCHAR){
  1146.         fprintf(fp,"%s",rrp->comment);
  1147.         return;
  1148.     }
  1149.   
  1150.     fprintf(fp,"%s",rrp->name);
  1151.     if(rrp->ttl != TTL_MISSING)
  1152.         fprintf(fp,"\t%ld",rrp->ttl);
  1153.     if(rrp->class == CLASS_IN)
  1154.         fprintf(fp,"\tIN");
  1155.     else
  1156.         fprintf(fp,"\t<%u>",rrp->class);
  1157.     if(rrp->type < NDTYPES)
  1158.         fprintf(fp,"\t%s",Dtypes[rrp->type]);
  1159.     else
  1160.         fprintf(fp,"\t{%u}",rrp->type);
  1161.     if(rrp->rdlength == 0){
  1162.         /* Null data portion, indicates nonexistent record */
  1163.         /* or unsupported type.  Hopefully, these will filter */
  1164.         /* as time goes by. */
  1165.         fprintf(fp,"\n");
  1166.         return;
  1167.     }
  1168.     switch(rrp->type){
  1169.         case TYPE_A:
  1170.             trans = DTranslate;             /* Save IP address translation state */
  1171.             DTranslate = 0;                 /* Force output to be numeric IP addr */
  1172.             fprintf(fp,"\t%s\n",inet_ntoa(rrp->rdata.addr));
  1173.             DTranslate = trans;             /* Restore original state */
  1174.             break;
  1175.         case TYPE_CNAME:
  1176.         case TYPE_MB:
  1177.         case TYPE_MG:
  1178.         case TYPE_MR:
  1179.         case TYPE_NS:
  1180.         case TYPE_PTR:
  1181.         case TYPE_TXT:
  1182.         /* These are all printable text strings */
  1183.             fprintf(fp,"\t%s\n",rrp->rdata.data);
  1184.             break;
  1185.         case TYPE_HINFO:
  1186.             fprintf(fp,"\t%s\t%s\n",
  1187.             rrp->rdata.hinfo.cpu,
  1188.             rrp->rdata.hinfo.os);
  1189.             break;
  1190.         case TYPE_MX:
  1191.             fprintf(fp,"\t%u\t%s\n",
  1192.             rrp->rdata.mx.pref,
  1193.             rrp->rdata.mx.exch);
  1194.             break;
  1195.         case TYPE_SOA:
  1196.             fprintf(fp,"\t%s\t%s\t%lu\t%lu\t%lu\t%lu\t%lu\n",
  1197.             rrp->rdata.soa.mname,rrp->rdata.soa.rname,
  1198.             rrp->rdata.soa.serial,rrp->rdata.soa.refresh,
  1199.             rrp->rdata.soa.retry,rrp->rdata.soa.expire,
  1200.             rrp->rdata.soa.minimum);
  1201.             break;
  1202.         default:
  1203.             fprintf(fp,"\n");
  1204.             break;
  1205.     }
  1206. }
  1207.   
  1208. /* Search local database for resource records.
  1209.  * Returns RR list, or NULLRR if no record found.
  1210.  */
  1211. static struct rr *
  1212. dfile_search(rrlp)
  1213. struct rr *rrlp;
  1214. {
  1215.     register struct rr *frrp;
  1216.     struct rr **rrpp, *result_rrlp, *oldrrp;
  1217.     int32 elapsed;
  1218.     FILE *dbase;
  1219.     struct stat dstat;
  1220.   
  1221. #ifdef DEBUG
  1222.     if(Dtrace){
  1223.         printf("dfile_search: searching for %s\n",rrlp->name);
  1224.     }
  1225. #endif
  1226.   
  1227.     while(Dfile_writing > 0)
  1228.         pwait(&Dfile_reading);
  1229.     Dfile_reading++;
  1230.   
  1231.     if((dbase = fopen(Dfile,READ_TEXT)) == NULLFILE){
  1232.         Dfile_reading--;
  1233.         return NULLRR;
  1234.     }
  1235.     if(fstat(fileno(dbase),&dstat) != 0){
  1236.         tputs("dfile_search: can't get file status\n");
  1237.         fclose(dbase);
  1238.         Dfile_reading--;
  1239.         return NULLRR;
  1240.     }
  1241.     if((elapsed = (int32)(Dcache_time - (time_t)dstat.st_ctime)) < 0L)
  1242.         elapsed = -elapsed;     /* arbitrary time mismatch */
  1243.   
  1244.     result_rrlp = NULLRR;           /* for contiguous test below */
  1245.     oldrrp = NULLRR;
  1246.     rrpp = &result_rrlp;
  1247.     while((frrp = get_rr(dbase,oldrrp)) != NULLRR){
  1248.         free_rr(oldrrp);
  1249.         if(frrp->type != TYPE_MISSING
  1250.             && frrp->rdlength > 0
  1251.         && compare_rr_list(rrlp,frrp) == 0){
  1252.             if(frrp->ttl > 0L
  1253.                 && (frrp->ttl -= elapsed) <= 0L)
  1254.                 frrp->ttl = 0L;
  1255.             *rrpp = frrp;
  1256.             rrpp = &(*rrpp)->next;
  1257.             oldrrp = copy_rr(frrp);
  1258.         } else {
  1259.             oldrrp = frrp;
  1260.             /*
  1261.                 All records of the same name and the same type
  1262.                 are contiguous.  Therefore, for a single query,
  1263.                 we can stop searching.  Multiple queries must
  1264.                 read the whole file.
  1265.             */
  1266.             if(rrlp->next == NULLRR && result_rrlp != NULLRR){
  1267.                 break;
  1268.             }
  1269.         }
  1270.         if(!main_exit)
  1271.             pwait(NULL);    /* run multiple sessions */
  1272.     }
  1273.     free_rr(oldrrp);
  1274.     *rrpp = NULLRR;
  1275.   
  1276.     fclose(dbase);
  1277.   
  1278.     if(--Dfile_reading <= 0){
  1279.         Dfile_reading = 0;
  1280.         psignal(&Dfile_writing,0);
  1281.     }
  1282.   
  1283.     return result_rrlp;
  1284. }
  1285.   
  1286. /* Process which will add new resource records from the cache
  1287.  * to the local file, eliminating duplicates while it goes.
  1288.  */
  1289. static void
  1290. dfile_update(s,unused,p)
  1291. int s;
  1292. void *unused;
  1293. void *p;
  1294. {
  1295.     struct rr **rrpp, *rrlp, *oldrrp;
  1296.     char *newname;
  1297.     FILE *old_fp, *new_fp;
  1298.     struct stat old_stat, new_stat;
  1299.   
  1300.     log(-1,"update Domain.txt initiated");
  1301.   
  1302.     close_s(Curproc->input);
  1303.     Curproc->input = -1;
  1304.     close_s(Curproc->output);
  1305.     Curproc->output = -1;
  1306.   
  1307.     newname = strdup(Dfile);
  1308.     strcpy(&newname[strlen(newname)-3],"tmp");
  1309.   
  1310.     while(Dfile_wait_absolute != 0L && !main_exit){
  1311.         register struct rr *frrp;
  1312.         int32 elapsed;
  1313.   
  1314.         while(Dfile_wait_absolute != 0L){
  1315.             elapsed = Dfile_wait_absolute - secclock();
  1316.             Dfile_wait_absolute = 0L;
  1317.             if(elapsed > 0L && !main_exit){
  1318.                 alarm(elapsed*1000L);
  1319.                 pwait(&Dfile_wait_absolute);
  1320.                 alarm(0L);
  1321.             }
  1322.         }
  1323.   
  1324.         log(-1,"update Domain.txt");
  1325.   
  1326.         /* create new file for copy */
  1327.         if((new_fp = fopen(newname,WRITE_TEXT)) == NULLFILE){
  1328.             printf("dfile_update: can't create %s!\n",newname);
  1329.             break;
  1330.         }
  1331.         if(fstat(fileno(new_fp),&new_stat) != 0){
  1332.             printf("dfile_update: can't get new_file status!\n");
  1333.             fclose(new_fp);
  1334.             break;
  1335.         }
  1336.   
  1337.         pwait(NULL);    /* file operations can be slow */
  1338.   
  1339.         /* timeout the cache one last time before writing */
  1340.         (void)dcache_search(NULLRR);
  1341.   
  1342.         /* copy new RRs out to the new file */
  1343.         /* (can't wait here, the cache might change) */
  1344.         rrpp = &rrlp;
  1345.         for(frrp = Dcache; frrp != NULLRR; frrp = frrp->next ){
  1346.             switch(frrp->source){
  1347.                 case RR_QUESTION:
  1348.                 case RR_ANSWER:
  1349.                 case RR_AUTHORITY:
  1350.                 case RR_ADDITIONAL:
  1351.                     *rrpp = copy_rr(frrp);
  1352.                     if(frrp->type != TYPE_MISSING
  1353.                         && frrp->rdlength > 0)
  1354.                         put_rr(new_fp,frrp);
  1355.                     rrpp = &(*rrpp)->next;
  1356.                     frrp->source = RR_FILE;
  1357.                     break;
  1358.             }
  1359.         }
  1360.         *rrpp = NULLRR;
  1361.   
  1362.         /* open up the old file, concurrently with everyone else */
  1363.         if((old_fp = fopen(Dfile,READ_TEXT)) == NULLFILE){
  1364.             /* great! no old file, so we're ready to go. */
  1365.             fclose(new_fp);
  1366.             rename(newname,Dfile);
  1367.             free_rr(rrlp);
  1368.             break;
  1369.         }
  1370.         if(fstat(fileno(old_fp),&old_stat) != 0){
  1371.             printf("dfile_update: can't get old_file status!\n");
  1372.             fclose(new_fp);
  1373.             fclose(old_fp);
  1374.             free_rr(rrlp);
  1375.             break;
  1376.         }
  1377.         if((elapsed = (int32)(new_stat.st_ctime - old_stat.st_ctime)) < 0L)
  1378.             elapsed = -elapsed;     /* file times are inconsistant */
  1379.   
  1380.         /* Now append any non-duplicate records */
  1381.         oldrrp = NULLRR;
  1382.         while((frrp = get_rr(old_fp,oldrrp)) != NULLRR){
  1383.             free_rr(oldrrp);
  1384.             if(frrp->name == NULLCHAR
  1385.                 && frrp->comment != NULLCHAR)
  1386.                 put_rr(new_fp,frrp);
  1387.             if(frrp->type != TYPE_MISSING
  1388.                 && frrp->rdlength > 0
  1389.             && compare_rr_list(rrlp,frrp) != 0){
  1390.                 if(frrp->ttl > 0L
  1391.                     && (frrp->ttl -= elapsed) <= 0L)
  1392.                     frrp->ttl = 0L;
  1393.                 if(frrp->ttl != 0 || !Dfile_clean)
  1394.                     put_rr(new_fp,frrp);
  1395.             }
  1396.             oldrrp = frrp;
  1397.             if(!main_exit)
  1398.                 pwait(NULL);    /* run in background */
  1399.         }
  1400.         free_rr(oldrrp);
  1401.         fclose(new_fp);
  1402.         fclose(old_fp);
  1403.         free_rr(rrlp);
  1404.   
  1405.         /* wait for everyone else to finish reading */
  1406.         Dfile_writing++;
  1407.         while(Dfile_reading > 0)
  1408.             pwait(&Dfile_writing);
  1409.   
  1410.         unlink(Dfile);
  1411.         rename(newname,Dfile);
  1412.   
  1413.         Dfile_writing = 0;
  1414.         psignal(&Dfile_reading,0);
  1415.     }
  1416.     free(newname);
  1417.   
  1418.     log(-1,"update Domain.txt finished");
  1419.     Dfile_updater = NULLPROC;
  1420. }
  1421.   
  1422.   
  1423. /**
  1424.  **     Domain Server Utilities
  1425.  **/
  1426.   
  1427. static void
  1428. dumpdomain(dhp,rtt)
  1429. struct dhdr *dhp;
  1430. int32 rtt;
  1431. {
  1432.     struct rr *rrp;
  1433.   
  1434.     printf("response id %u (rtt %lu ms) qr %u opcode %u aa %u tc %u rd %u ra %u rcode %u\n",
  1435.     dhp->id,rtt,
  1436.     dhp->qr,dhp->opcode,dhp->aa,dhp->tc,dhp->rd,
  1437.     dhp->ra,dhp->rcode);
  1438.     printf("%u questions:\n",dhp->qdcount);
  1439.     for(rrp = dhp->questions; rrp != NULLRR; rrp = rrp->next){
  1440.         printf("%s type %s class %u\n",rrp->name,
  1441.         Dtypes[rrp->type],rrp->class);
  1442.     }
  1443.     printf("%u answers:\n",dhp->ancount);
  1444.     for(rrp = dhp->answers; rrp != NULLRR; rrp = rrp->next){
  1445.         put_rr(stdout,rrp);
  1446.     }
  1447.     printf("%u authority:\n",dhp->nscount);
  1448.     for(rrp = dhp->authority; rrp != NULLRR; rrp = rrp->next){
  1449.         put_rr(stdout,rrp);
  1450.     }
  1451.     printf("%u additional:\n",dhp->arcount);
  1452.     for(rrp = dhp->additional; rrp != NULLRR; rrp = rrp->next){
  1453.         put_rr(stdout,rrp);
  1454.     }
  1455. #ifndef LINUX
  1456.     fflush(stdout);
  1457. #endif
  1458. }
  1459.   
  1460. static int
  1461. dns_makequery(op,srrp,buffer,buflen)
  1462. int16 op;       /* operation */
  1463. struct rr *srrp;/* Search RR */
  1464. char *buffer;   /* Area for query */
  1465. int16 buflen;   /* Length of same */
  1466. {
  1467.     char *cp,*cp1;
  1468.     char *dname, *sname;
  1469.     int16 parameter;
  1470.     int16 dlen,len;
  1471.   
  1472.     cp = buffer;
  1473.     /* Use millisecond clock for timestamping */
  1474.     cp = put16(cp,(int16)msclock());
  1475.     parameter = (op << 11)
  1476.     | 0x0100;       /* Recursion desired */
  1477.     cp = put16(cp,parameter);
  1478.     cp = put16(cp,1);
  1479.     cp = put16(cp,0);
  1480.     cp = put16(cp,0);
  1481.     cp = put16(cp,0);
  1482.   
  1483.     sname = strdup(srrp->name);
  1484.     dname = sname;
  1485.     dlen = strlen(dname);
  1486.     for(;;){
  1487.         /* Look for next dot */
  1488.         cp1 = strchr(dname,'.');
  1489.         if(cp1 != NULLCHAR)
  1490.             len = cp1-dname;        /* More to come */
  1491.         else
  1492.             len = dlen;     /* Last component */
  1493.         *cp++ = len;            /* Write length of component */
  1494.         if(len == 0)
  1495.             break;
  1496.         /* Copy component up to (but not including) dot */
  1497.         strncpy(cp,dname,len);
  1498.         cp += len;
  1499.         if(cp1 == NULLCHAR){
  1500.             *cp++ = 0;      /* Last one; write null and finish */
  1501.             break;
  1502.         }
  1503.         dname += len+1;
  1504.         dlen -= len+1;
  1505.     }
  1506.     free(sname);
  1507.     cp = put16(cp,srrp->type);
  1508.     cp = put16(cp,srrp->class);
  1509.     return (int)(cp - buffer);
  1510. }
  1511.   
  1512. /* domain server resolution loop
  1513.  * returns: any answers in cache.
  1514.  *      (future features)
  1515.  *      multiple queries.
  1516.  *      inverse queries.
  1517.  */
  1518. static void
  1519. dns_query(rrlp)
  1520. struct rr *rrlp;
  1521. {
  1522.     struct mbuf *bp;
  1523.     struct dhdr *dhp;
  1524.     struct dserver *dp;     /* server list */
  1525.     int32 rtt,abserr;
  1526.     int tried = 0;          /* server list has been retried (count) */
  1527.   
  1528.     if((dp = Dservers) == NULLDOM){
  1529.         return;
  1530.     }
  1531.   
  1532.     if(!Mprunning)
  1533.         return;
  1534.   
  1535.     for(;;){
  1536.         char *buf;
  1537.         int len;
  1538.         struct sockaddr_in server_in;
  1539.         int s;
  1540.         int rval;
  1541.   
  1542.         dp->queries++;
  1543.   
  1544.         s = socket(AF_INET,SOCK_DGRAM,0);
  1545.         server_in.sin_family = AF_INET;
  1546.         server_in.sin_port = IPPORT_DOMAIN;
  1547.         server_in.sin_addr.s_addr = dp->address;
  1548.   
  1549.         if(Dtrace){
  1550.             printf("dns_query: querying server %s for %s\n",
  1551.             inet_ntoa(dp->address),rrlp->name);
  1552.         }
  1553.   
  1554.         buf = mallocw(512);
  1555.         len = dns_makequery(0,rrlp,buf,512);
  1556.         sendto(s,buf,len,0,(char *)&server_in,sizeof(server_in));
  1557.         free(buf);
  1558.         alarm(max(dp->timeout,100));
  1559.         /* Wait for something to happen */
  1560.         rval = recv_mbuf(s,&bp,0,NULLCHAR,0);
  1561.         alarm(0L);
  1562.         close_s(s);
  1563.   
  1564.         if(Dtrace){
  1565.             printf("dns_query: received message length %d, errno %d\n", rval, errno );
  1566.         }
  1567.   
  1568.         if(rval > 0)
  1569.             break;
  1570.   
  1571.         if(errno == EABORT){
  1572.             return;         /* Killed by "reset" command */
  1573.         }
  1574.   
  1575.         /* Timeout; back off this one and try another server */
  1576.         dp->timeouts++;
  1577.         dp->timeout <<= 1;
  1578.   
  1579.         /* But we must have some sort of sensible limit - surely? */
  1580.         if(dp->timeout > (Dserver_maxwait * 1000L)){
  1581.             dp->timeout = Dserver_maxwait * 1000L;
  1582.         }
  1583.   
  1584.         if((dp = dp->next) == NULLDOM){
  1585.             dp = Dservers;
  1586.             if(Dserver_retries > 0 && ++tried > Dserver_retries)
  1587.                 return;
  1588.         }
  1589.     }
  1590.   
  1591.     /* got a response */
  1592.     dp->responses++;
  1593.     dhp = (struct dhdr *) mallocw(sizeof(struct dhdr));
  1594.     ntohdomain(dhp,&bp);    /* Convert to local format */
  1595.   
  1596.     /* Compute and update the round trip time */
  1597.     rtt = (int32) ((int16)msclock() - dhp->id);
  1598.     abserr = rtt > dp->srtt ? rtt - dp->srtt : dp->srtt - rtt;
  1599.     dp->srtt = ((AGAIN-1) * dp->srtt + rtt + (AGAIN/2)) >> LAGAIN;
  1600.     dp->mdev = ((DGAIN-1) * dp->mdev + abserr + (DGAIN/2)) >> LDGAIN;
  1601.     dp->timeout = 4 * dp->mdev + dp->srtt;
  1602.   
  1603.     /* move to top of list for next time */
  1604.     if(dp->prev != NULLDOM){
  1605.         dlist_drop(dp);
  1606.         dlist_add(dp);
  1607.     }
  1608.   
  1609.     if(Dtrace)
  1610.         dumpdomain(dhp,rtt);
  1611.   
  1612.     /* Add negative reply to answers.  This assumes that there was
  1613.      * only one question, which is true for all questions we send.
  1614.      */
  1615.     if(dhp->aa && (dhp->rcode == NAME_ERROR || dhp->ancount == 0)){
  1616.         register struct rr *rrp;
  1617.         long ttl = 600L; /* Default TTL for negative records */
  1618.   
  1619.         /* look for SOA ttl */
  1620.         for(rrp = dhp->authority; rrp != NULLRR; rrp = rrp->next){
  1621.             if(rrp->type == TYPE_SOA)
  1622.                 ttl = rrp->ttl;
  1623.         }
  1624.   
  1625.         /* make the questions the negative answers */
  1626.         for(rrp = dhp->questions; rrp != NULLRR; rrp = rrp->next)
  1627.             rrp->ttl = ttl;
  1628.     } else {
  1629.         free_rr(dhp->questions);
  1630.         dhp->questions = NULLRR;
  1631.     }
  1632.   
  1633.     /* post in reverse order to maintain original order */
  1634.     dcache_update(dhp->additional);
  1635.     dcache_update(dhp->authority);
  1636.     dcache_update(dhp->answers);
  1637.     dcache_update(dhp->questions);
  1638.   
  1639.     Dfile_wait_absolute = secclock() + Dfile_wait_relative;
  1640.     if(Dfile_upd && Dfile_updater == NULLPROC){
  1641.         Dfile_updater = newproc("domain update",
  1642.         512,dfile_update,0,NULL,NULL,0);
  1643.     }
  1644.   
  1645. #ifdef DEBUG
  1646.     if(Dtrace)
  1647.         keywait(NULLCHAR,1);    /* so we can look around */
  1648. #endif
  1649.     free((char *)dhp);
  1650.     return;
  1651. }
  1652.   
  1653.   
  1654. /**
  1655.  **     Resolver Utilities
  1656.  **/
  1657.   
  1658. /* Return TRUE if string appears to be an IP address in dotted decimal;
  1659.  * return FALSE otherwise (i.e., if string is a domain name)
  1660.  */
  1661. static int
  1662. isaddr(s)
  1663. register char *s;
  1664. {
  1665.     char c;
  1666.   
  1667.     if(s == NULLCHAR)
  1668.         return TRUE;       /* Can't happen */
  1669.   
  1670.     while((c = *s++) != '\0'){
  1671.         if(c != '[' && c != ']' && !isdigit(c) && c != '.')
  1672.             return FALSE;
  1673.     }
  1674.     return TRUE;
  1675. }
  1676.   
  1677. /* Search for resource records.
  1678.  * Returns RR list, or NULLRR if no record found.
  1679.  */
  1680. static struct rr *
  1681. resolver(rrlp)
  1682. register struct rr *rrlp;
  1683. {
  1684.     register struct rr *result_rrlp;
  1685.   
  1686.     if((result_rrlp = dcache_search(rrlp)) == NULLRR){
  1687.         result_rrlp = dfile_search(rrlp);
  1688.     }
  1689.     if(result_rrlp == NULLRR || check_ttl(result_rrlp) != 0){
  1690.         dcache_add(result_rrlp);        /* save any expired RRs */
  1691.         dns_query(rrlp);
  1692.         result_rrlp = dcache_search(rrlp);
  1693.     }
  1694.     dcache_add(copy_rr_list(result_rrlp));
  1695.     return result_rrlp;
  1696. }
  1697.   
  1698. /* general entry point for address -> domain name resolution.
  1699.  * Returns RR list, or NULLRR if no record found.
  1700.  */
  1701. struct rr *
  1702. inverse_a(ip_address)
  1703. int32 ip_address;
  1704. {
  1705.     struct rr *prrp;
  1706.     struct rr *result_rrlp;
  1707.     char pname[30];
  1708.   
  1709.     if(ip_address == 0L)
  1710.         return NULLRR;
  1711.   
  1712.     sprintf( pname, "%u.%u.%u.%u.IN-ADDR.ARPA.",
  1713.     lobyte(loword(ip_address)),
  1714.     hibyte(loword(ip_address)),
  1715.     lobyte(hiword(ip_address)),
  1716.     hibyte(hiword(ip_address)) );
  1717.   
  1718.     prrp = make_rr(RR_QUERY,pname,CLASS_IN,TYPE_PTR,0,0,NULL);
  1719.   
  1720.     prrp->next =            /* make list to speed search */
  1721.     make_rr(RR_INQUERY,NULLCHAR,CLASS_IN,TYPE_A,0,4,&ip_address);
  1722.   
  1723.     result_rrlp = resolver(prrp);
  1724.   
  1725.     free_rr(prrp);
  1726.     return result_rrlp;
  1727. }
  1728.   
  1729. /* general entry point for domain name -> resource resolution.
  1730.  * Returns RR list, or NULLRR if no record found.
  1731.  */
  1732. /* Optional recursive search to resolve CNAME records that
  1733.    prevents proper handling of CNAME queries.  Forces recursion to take
  1734.    place only at the resolver of the node originating the query.
  1735.    Modification introducted by Don Sandstrom, KG7CP, October 15, 1992.
  1736.    Additional mod by WG7J .
  1737.    */
  1738.   
  1739. struct rr *
  1740. resolve_rr(dname,dtype,recurse)
  1741. char *dname;
  1742. int16 dtype;
  1743. int recurse;
  1744. {
  1745.     struct rr *qrrp;
  1746.     struct rr *result_rrlp;
  1747.     char *sname;
  1748.     int looping;
  1749.   
  1750.     if(dname == NULLCHAR)
  1751.         return NULLRR;
  1752.   
  1753.     sname = domainsuffix(dname);
  1754.     qrrp = make_rr(RR_QUERY,sname,CLASS_IN,dtype,0,0,NULL);
  1755.     free(sname);
  1756.   
  1757.     if(!recurse) {
  1758.         result_rrlp = resolver(qrrp);
  1759. #ifdef DEBUG
  1760.         if(Dtrace)
  1761.             put_rr(stdout,result_rrlp);
  1762. #endif
  1763.     } else {
  1764.         looping = MAXCNAME;
  1765.         while(looping > 0){
  1766.             if((result_rrlp=resolver(qrrp)) == NULLRR
  1767.                 || result_rrlp->type == dtype)
  1768.                 break;
  1769. #ifdef DEBUG
  1770.             if(Dtrace)
  1771.                 put_rr(stdout,result_rrlp);
  1772. #endif
  1773.         /* Should be CNAME or PTR record */
  1774.         /* Replace name and try again */
  1775.             free(qrrp->name);
  1776.             qrrp->name = strdup(result_rrlp->rdata.name);
  1777.             free_rr(result_rrlp);
  1778.             result_rrlp = NULLRR;
  1779.             looping--;
  1780.         }
  1781.     }
  1782.     free_rr(qrrp);
  1783.     return result_rrlp;
  1784. }
  1785.   
  1786. /* main entry point for address -> domain name resolution.
  1787.  * Returns string, or NULLCHAR if no name found.
  1788.  */
  1789. char *
  1790. resolve_a(ip_address,shorten)
  1791. int32 ip_address;               /* search address */
  1792. int shorten;                    /* return only first part of name (flag)*/
  1793. {
  1794.     struct rr *save_rrlp, *rrlp;
  1795.     char *result = NULLCHAR, *p;
  1796.   
  1797. /* N7IPB - When we have a lot of unresolvable addresses such as subnet routes in
  1798.  *         the routing table, domain translation can take a long time.  The
  1799.  *         following allows us to skip the translation process for any address
  1800.  *         ending in .000 or .255.  These are assumed to be either subnets or
  1801.  *         broadcast addresses.  Can be turned on and off with the 'domain subnet'
  1802.  *         command.
  1803.  */
  1804.   
  1805.     if(((ip_address & 0x0ff) && ((ip_address & 0x0ff) ^ 0x0ff)) || Dsubnet_translate ) {
  1806.         for(rrlp = save_rrlp = inverse_a(ip_address);
  1807.             rrlp != NULLRR && result == NULLCHAR;
  1808.         rrlp = rrlp->next ){
  1809.             if(rrlp->rdlength > 0){
  1810.                 switch(rrlp->type){
  1811.                     case TYPE_PTR:
  1812.                         result = strdup(rrlp->rdata.name);
  1813.                         break;
  1814.                     case TYPE_A:
  1815.                         result = strdup(rrlp->name);
  1816.                         break;
  1817.                 }
  1818.             }
  1819.         }
  1820.         free_rr(save_rrlp);
  1821.   
  1822.         /* From Dennis Goodwin, kb7dz.
  1823.          * when domain verbose is off,
  1824.          * this make a domain name line bbs.wg7j.ampr.org show as bbs.wg7j
  1825.          * as opposed to bbs, as the above code does.
  1826.          */
  1827.         if(result != NULLCHAR && shorten) {
  1828.             if (Dsuffix != NULLCHAR)
  1829.             /* domain name minus domain suffix */
  1830.                 p = strstr(result, Dsuffix);
  1831.             else
  1832.             /* domain name up to, and including the first period */
  1833.                 p = strchr(result, '.') + 1;
  1834.             if(p != NULLCHAR)
  1835.                 *p = '\0';
  1836.         }
  1837.         if(result != NULLCHAR && *result) {
  1838.         /* remove trailing . */
  1839.             for (p=result; *p; ++p)
  1840.                 ;
  1841.             if (*(--p) == '.')
  1842.                 *p = (char) 0;
  1843.         }
  1844.         /* end of mod */
  1845.     }
  1846.     return result;
  1847. }
  1848.   
  1849. /* Main entry point for domain name -> address resolution.
  1850.  * Returns 0 if name is currently unresolvable.
  1851.  */
  1852. int32
  1853. resolve(name)
  1854. char *name;
  1855. {
  1856.     register struct rr *rrlp;
  1857.     int32 ip_address = 0;
  1858.   
  1859.     if(name == NULLCHAR)
  1860.         return 0;
  1861.   
  1862.     if(isaddr(name))
  1863.         return aton(name);
  1864.   
  1865.     if((rrlp = resolve_rr(name,TYPE_A,1)) != NULLRR
  1866.         && rrlp->rdlength > 0)
  1867.         ip_address = rrlp->rdata.addr;
  1868.   
  1869.     /* multi-homed hosts are handled here */
  1870.     if(rrlp != NULLRR && rrlp->next != NULLRR) {
  1871.         register struct rr *rrp;
  1872.         register struct route *rp;
  1873.         int16 cost = MAXINT16;
  1874.         rrp = rrlp;
  1875.         while(rrp != NULLRR) { /* choose the best of a set of routes */
  1876.             if(rrp->rdlength > 0 &&
  1877.                 (rp = rt_lookup(rrp->rdata.addr)) != NULLROUTE &&
  1878.             rp->metric <= cost) {
  1879.                 ip_address = rrp->rdata.addr;
  1880.                 cost = rp->metric;
  1881.             }
  1882.             rrp = rrp->next;
  1883.         }
  1884.     }
  1885.   
  1886.     free_rr(rrlp);
  1887.     return ip_address;
  1888. }
  1889.   
  1890.   
  1891. /* Main entry point for MX record lookup.
  1892.  * Returns 0 if name is currently unresolvable.
  1893.  */
  1894. int32
  1895. resolve_mx(name)
  1896. char *name;
  1897. {
  1898.     register struct rr *rrp, *arrp;
  1899.     char *sname, *tmp, *cp;
  1900.     int32 addr, ip_address = 0;
  1901.     int16 pref = MAXINT16;
  1902.   
  1903.     if(name == NULLCHAR)
  1904.         return 0;
  1905.   
  1906.     if(isaddr(name)){
  1907.         if((sname = resolve_a(aton(name),FALSE)) == NULLCHAR)
  1908.             return 0;
  1909.     }
  1910.     else
  1911.         sname = strdup(name);
  1912.   
  1913.     cp = sname;
  1914.     while(1){
  1915.         rrp = arrp = resolve_rr(sname,TYPE_MX,1);
  1916.         /* Search this list of rr's for an MX record */
  1917.         while(rrp != NULLRR){
  1918.             if(rrp->rdlength > 0 && rrp->rdata.mx.pref <= pref &&
  1919.             (addr = resolve(rrp->rdata.mx.exch)) != 0L){
  1920.                 pref = rrp->rdata.mx.pref;
  1921.                 ip_address = addr;
  1922.             }
  1923.             rrp = rrp->next;
  1924.         }
  1925.         free_rr(arrp);
  1926.         if(ip_address != 0)
  1927.             break;
  1928.         /* Compose wild card one level up */
  1929.         if((cp = strchr(cp,'.')) == NULLCHAR)
  1930.             break;
  1931.         tmp = mallocw(strlen(cp)+2);
  1932.         sprintf(tmp,"*%s",cp);          /* wildcard expansion */
  1933.         free(sname);
  1934.         sname = tmp;
  1935.         cp = sname + 2;
  1936.     }
  1937.     free(sname);
  1938.     return ip_address;
  1939. }
  1940.   
  1941. /* Search for local records of the MB, MG and MR type. Returns list of
  1942.  * matching records.
  1943.  */
  1944. struct rr *
  1945. resolve_mailb(name)
  1946. char *name;             /* local username, without trailing dot */
  1947. {
  1948.     register struct rr *result_rrlp;
  1949.     struct rr *rrlp;
  1950.     char *sname;
  1951.   
  1952. #ifdef notdef
  1953.     /* Append trailing dot */
  1954.     sname = mallocw(strlen(name)+2);
  1955.     sprintf(sname,"%s.",name);
  1956. #else
  1957.     sname = strdup(name);
  1958. #endif
  1959.     rrlp = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MB,0,0,NULL);
  1960.     rrlp->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MG,0,0,NULL);
  1961.     rrlp->next->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MR,0,0,NULL);
  1962.     free(sname);
  1963.     if((result_rrlp = dcache_search(rrlp)) == NULLRR){
  1964.         result_rrlp = dfile_search(rrlp);
  1965.     }
  1966.     free_rr(rrlp);
  1967.     if(Dsuffix != NULLCHAR){
  1968.         rrlp = result_rrlp;
  1969.         while(rrlp != NULLRR){  /* add domain suffix to data */
  1970.             if(rrlp->rdlength > 0 &&
  1971.             rrlp->rdata.name[rrlp->rdlength-1] != '.'){
  1972.                 sname = mallocw(rrlp->rdlength +
  1973.                 Dsuffixl+2);
  1974.                 sprintf(sname,"%s.%s",rrlp->rdata.name,Dsuffix);
  1975.                 free(rrlp->rdata.name);
  1976.                 rrlp->rdata.name = sname;
  1977.                 rrlp->rdlength = strlen(sname);
  1978.             }
  1979.             rrlp = rrlp->next;
  1980.         }
  1981.     }
  1982.     dcache_add(copy_rr_list(result_rrlp));
  1983.     return result_rrlp;
  1984. }
  1985.   
  1986. /* Return "normalized" domain name, with default suffix and trailing '.'
  1987.  * Searches local cache for CNAME expansions.
  1988.  */
  1989. char *
  1990. domainsuffix(dname)
  1991. char *dname;
  1992. {
  1993.     char *sname, *tname, *pp;
  1994.     int l;
  1995.   
  1996.     if ( dname == NULLCHAR )
  1997.         return NULLCHAR;
  1998.   
  1999.     if(isaddr(dname)) {
  2000.         /* convert to our canonic form */
  2001.         return strdup( inet_ntoa( aton(dname) ) );
  2002.     }
  2003.   
  2004.     sname = strdup(dname);
  2005.     l = strlen(sname);
  2006.     if((pp = strrchr(sname,'.')) == NULLCHAR){
  2007.         /* No dot in name. Try to add default suffix */
  2008.         if(Dsuffix != NULLCHAR){
  2009.             /* Append default suffix */
  2010.             tname = mallocw(l+Dsuffixl+2);
  2011.             sprintf(tname,"%s.%s",sname,Dsuffix);
  2012.             free(sname);
  2013.             sname = tname;
  2014.         }
  2015.     } else {
  2016.         /* There is a dot in the name. Check last part of
  2017.          * name. If longer than 4 char it must be a name
  2018.          * 4 or less is probably a domain (org, army, uk)
  2019.          */
  2020.         if(Dsuffix != NULLCHAR){
  2021.             if(strlen(pp) <= 5){
  2022.                 for(++pp;*pp;pp++){
  2023.                     if(isdigit(*pp))
  2024.                         break;
  2025.                 }
  2026.                 if(*pp){
  2027.             /* Append default suffix */
  2028.                     tname = mallocw(l+Dsuffixl+2);
  2029.                     sprintf(tname,"%s.%s",sname,Dsuffix);
  2030.                     free(sname);
  2031.                     sname = tname;
  2032.                 }
  2033.             } else {
  2034.             /* name with dot (must be call + local domain) */
  2035.                 tname = mallocw(l+Dsuffixl+2);
  2036.                 sprintf(tname,"%s.%s",sname,Dsuffix);
  2037.                 free(sname);
  2038.                 sname = tname;
  2039.             }
  2040.         }
  2041.     }
  2042.   
  2043.     if(sname[strlen(sname)-1] != '.'){
  2044.         /* Append trailing dot */
  2045.         tname = mallocw(strlen(sname)+2);
  2046.         sprintf(tname,"%s.",sname);
  2047.         free(sname);
  2048.         sname = tname;
  2049.     }
  2050.   
  2051. #ifdef notdef
  2052.     struct rr *qrrp;
  2053.     struct rr *result_rrlp;
  2054.   
  2055.     qrrp = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_CNAME,0,0,NULL);
  2056.     if ( (result_rrlp = dcache_search(qrrp)) != NULLRR
  2057.     || (result_rrlp = dfile_search(qrrp)) != NULLRR ) {
  2058.         free(sname);
  2059.         sname = strdup(result_rrlp->rdata.name);
  2060.     }
  2061.     free_rr(qrrp);
  2062.     free_rr(result_rrlp);
  2063. #endif
  2064.     return sname;
  2065. }
  2066.   
  2067. #ifdef DOMAINSERVER
  2068.   
  2069. /* Domain Name Server - based on the server in GRI-Nos 910828
  2070.  * ported to current NOS code by Johan. K. Reinalda, WG7J/PA3DIS
  2071.  *
  2072.  * - Does not answer more then one query per frame
  2073.  * - Gives non-authoritative answers to all queries.
  2074.  * - Does not reply with authority or additional RR's
  2075.  * - If no answers are found in local cache or domain.txt file,
  2076.  *   remote servers, if configured, are queried.
  2077.  *
  2078.  *
  2079.  * v0.93  10/19/92   queries do not recurse anymore, but let the requester
  2080.  *                   do the recursion (Solves problem with CNAME queries)
  2081.  * v0.92  06/24/92   RR length bug fixed.
  2082.  *                   A,CNAME,MX,HINFO,PTR,NS,SOA queries now work
  2083.  * v0.91  06/22/92   MX has small bug with RR length indication
  2084.  * v0.90  06/20/92   Only supports a single type 'A' request per frame
  2085.  */
  2086.   
  2087. int Dsocket = -1;
  2088.   
  2089. /* Process a query received by the DNS server */
  2090. static void
  2091. proc_query(unused,d,b)
  2092. int unused;
  2093. void *d;
  2094. void *b;
  2095. {
  2096.     struct dserver *dp;
  2097.     struct dhdr *dhdr;
  2098.     int i,len;
  2099.     char *buf;
  2100.     struct sockaddr_in server;
  2101.     struct rr *rrp, *rrans, *rrns, *rradd, *rrtmp;
  2102.     struct rr *qp;
  2103.   
  2104.     dp = (struct dserver *) d;      /* The query address */
  2105.     dhdr = (struct dhdr *) b;       /* The query in host format */
  2106.   
  2107.     rrans = rrns = rradd = NULLRR;
  2108.     qp = dhdr->questions;
  2109.   
  2110.     /* This loop does NOT support multiple questions yet */
  2111. #ifdef notdef
  2112.     for(i=0;i<dhdr->qdcount;i++){
  2113. #endif
  2114.   
  2115. #ifdef notdef
  2116.     /* For now, assume we don't have authority */
  2117.         if(haveaa(qp->name))
  2118.             dhdr->aa = 1;
  2119.         else
  2120. #endif
  2121.             dhdr->aa = 0;
  2122.         switch(qp->type) {
  2123.             case TYPE_A:
  2124.             case TYPE_MX:
  2125.             case TYPE_CNAME:
  2126.             case TYPE_HINFO:
  2127.             case TYPE_PTR:
  2128.             case TYPE_NS:
  2129.             case TYPE_SOA:
  2130.     /* Not all of the below types are implemented in resolve_rr() */
  2131. #ifdef notdef
  2132.             case TYPE_TXT:
  2133.             case TYPE_ANY:
  2134. #endif
  2135.         /* Let the other side resolve CNAME references, do not recurse ! */
  2136.                 if((rrp = resolve_rr(qp->name,qp->type,0)) != NULLRR) {
  2137.         /* we found an entry, go tell him */
  2138.                     dhdr->rcode = NO_ERROR;
  2139.                     dhdr->qr = RESPONSE;
  2140.                 } else {
  2141.         /* we did not find an entry, go tell him */
  2142.                     rrp = (struct rr *)callocw(1,sizeof(struct rr));
  2143.                     rrp->name = strdup(qp->name);
  2144.                     rrp->type = qp->type;
  2145.                     rrp->class = qp->class;
  2146.                     rrp->ttl = 500L;
  2147.                     rrp->rdata.addr = 0L;
  2148.                     rrp->rdlength = 4;  /* size of addr data */
  2149.                     dhdr->rcode = NAME_ERROR;
  2150.                     dhdr->qr = RESPONSE;
  2151.                 }
  2152.                 rrans = rrp;
  2153.                 break;
  2154.     /* Search only the local cache and domain file for these next few */
  2155.     /* Is this a good idea ??? */
  2156.             case TYPE_MB:
  2157.             case TYPE_MG:
  2158.             case TYPE_MR:
  2159.                 rrp = make_rr(RR_QUERY,qp->name,CLASS_IN,qp->type,0,0,NULL);
  2160.                 if((rrans = dcache_search(rrp)) == NULLRR){
  2161.                     rrans = dfile_search(rrp);
  2162.                 }
  2163.                 free_rr(rrp);
  2164.                 break;
  2165. #ifdef notdef
  2166.     /* Not implemented, yet (?) */
  2167.             case TYPE_MD:
  2168.             case TYPE_MF:
  2169.             case TYPE_WKS:
  2170.             case TYPE_NULL:
  2171.             case TYPE_MINFO:
  2172. #endif
  2173.             default:
  2174.                 dhdr->rcode = NOT_IMPL;
  2175.                 dhdr->qr = RESPONSE;
  2176.         }
  2177.     /* This loop does NOT support multiple questions yet */
  2178. #ifdef notdef
  2179.         qp = qp->next;  /* next question */
  2180.     }
  2181. #endif
  2182.   
  2183.     /* Find the number of answer records */
  2184.     i = 0;
  2185.     rrtmp = rrans;
  2186.     while(rrtmp != NULLRR) {
  2187.         i++;
  2188.         /* KG7CP -  - if no ttl in database, set the time-to-live value for
  2189.          * dns responses, unless no ttl value has been defined.
  2190.          */
  2191.         if(rrtmp->ttl == TTL_MISSING && Dns_ttl > 0L)
  2192.             rrtmp->ttl = Dns_ttl;
  2193.         rrtmp = rrtmp->next;
  2194.     }
  2195.     dhdr->ancount = i;
  2196.     dhdr->answers = rrans;
  2197.   
  2198.     /* Authority and Additional RR's not implemented yet. */
  2199.     dhdr->nscount = 0;
  2200.     dhdr->authority = NULLRR;
  2201.     dhdr->arcount = 0;
  2202.     dhdr->additional = NULLRR;
  2203.   
  2204. #ifdef notdef
  2205.     /* Find the number of authority records */
  2206.     i = 0;
  2207.     rrtmp = rrns;
  2208.     while(rrtmp != NULLRR) {
  2209.         i++;
  2210.         rrtmp = rrtmp->next;
  2211.     }
  2212.     dhdr->nscount = i;
  2213.     dhdr->authority = rrns;
  2214.   
  2215.     /* Find the number of additional records */
  2216.     i = 0;
  2217.     rrtmp = rradd;
  2218.     while(rrtmp != NULLRR) {
  2219.         i++;
  2220.         rrtmp = rrtmp->next;
  2221.     }
  2222.     dhdr->arcount = i;
  2223.     dhdr->additional = rradd;
  2224. #endif
  2225.   
  2226.     if(Dtrace) {
  2227.         puts("DNS: replying");
  2228.         dumpdomain(dhdr,0);
  2229.     }
  2230.   
  2231.     /* Maximum reply size is 512, see rfc1034/1035 */
  2232.     buf = mallocw(1024);
  2233.     len = htondomain(dhdr,buf,512);
  2234.     free_dhdr(dhdr);
  2235.   
  2236.     server.sin_family = AF_INET;
  2237.     server.sin_port = dp->port;
  2238.     server.sin_addr.s_addr = dp->address;
  2239.     sendto(Dsocket,buf,len,0,(char *)&server,sizeof(server));
  2240.     free(buf);
  2241.     free((char *)dp);
  2242. }
  2243.   
  2244.   
  2245. /* Process to receive all domain server related messages */
  2246. static void
  2247. drx(unused,u,p)
  2248. int unused;
  2249. void *u;
  2250. void *p;
  2251. {
  2252.     struct sockaddr_in sock,from;
  2253.     int fromlen;
  2254.     struct mbuf *bp;
  2255.     struct dhdr *dhdr;
  2256.     struct dserver *dp;
  2257.     int foo;
  2258.   
  2259.     Dsocket = socket(AF_INET,SOCK_DGRAM,0);
  2260.     sock.sin_family = AF_INET;
  2261.     sock.sin_addr.s_addr = INADDR_ANY;
  2262.     sock.sin_port = IPPORT_DOMAIN;
  2263.     if(bind(Dsocket,(char *)&sock,sizeof(sock)) == -1) {
  2264.         tputs("DNS: can't bind\n");
  2265.         Dsocket = -1;
  2266.         return;
  2267.     }
  2268.     /* Now loop forever, processing queries */
  2269.     for(;;){
  2270.         fromlen = sizeof(from);
  2271.         if((foo = recv_mbuf(Dsocket,&bp,0,(char *)&from,&fromlen)) == -1)
  2272.             break;  /* Server closing */
  2273.         if(foo == 0)
  2274.             continue;
  2275.         dhdr = mallocw(sizeof(struct dhdr));
  2276.         ntohdomain(dhdr,&bp);
  2277.         if(Dtrace) {
  2278.             printf("DNS: %u bytes from %s\n",foo,
  2279.             psocket((struct sockaddr *)&from));
  2280.             dumpdomain(dhdr,0);
  2281.         }
  2282.     /* Process queries only */
  2283.         if(dhdr->qr == QUERY) {
  2284.         /* Queries from ourself will cause a loop ! */
  2285.             if(ismyaddr(from.sin_addr.s_addr) != NULLIF) {
  2286.                 if(Dtrace)
  2287.                     tputs("DNS: question from myself ignored\n");
  2288.                 free_dhdr(dhdr);
  2289.                 continue;
  2290.             } else {
  2291.                 dp=(struct dserver *)callocw(1,sizeof(struct dserver));
  2292.                 dp->address = from.sin_addr.s_addr;
  2293.                 dp->srtt = (Dserver_maxwait * 1000L) / MSPTICK;
  2294.                 dp->timeout = dp->srtt * 2;
  2295.                 dp->port = from.sin_port;
  2296.                 if(dhdr->opcode == ZONEINIT) {
  2297.             /* ZONEINIT not implemented */
  2298.                     free_dhdr(dhdr);
  2299.                     free(dp);
  2300. #ifdef notdef
  2301.                     newproc("Domain zoneinit",1024,proc_bootp
  2302.                     ,0,(void *)dp,(void *)dhdr,0);
  2303. #endif
  2304.                 } else
  2305.                     newproc("Domain server",1024,proc_query
  2306.                     ,0,(void *)dp,(void *)dhdr,0);
  2307.             }
  2308.         }
  2309.     }
  2310. }
  2311.   
  2312. static int
  2313. dodnsserver(argc,argv,p)
  2314. int argc;
  2315. char *argv[];
  2316. void *p;
  2317. {
  2318.     if(argc == 1) {
  2319.         tputs((Dsocket != -1) ? "on\n" : "off\n");
  2320.     } else {
  2321.         if(!stricmp(argv[1],"on")) {
  2322.             if(Dsocket == -1)
  2323.         /* Start domain server task */
  2324.                 newproc("Domain listener",1024,drx,0,NULL,NULL,0);
  2325.         } else {
  2326.             close_s(Dsocket);
  2327.             Dsocket = -1;
  2328.         }
  2329.     }
  2330.     return 0;
  2331. }
  2332.   
  2333. /* Free a domain message */
  2334. static void
  2335. free_dhdr(dp)
  2336. struct dhdr *dp;
  2337. {
  2338.     if(dp->qdcount != 0)
  2339.         free_rr(dp->questions);
  2340.     if(dp->ancount != 0)
  2341.         free_rr(dp->answers);
  2342.     if(dp->nscount != 0)
  2343.         free_rr(dp->authority);
  2344.     if(dp->arcount != 0)
  2345.         free_rr(dp->additional);
  2346.     free((char *)dp);
  2347. }
  2348.   
  2349. #endif /* DOMAINSERVER */
  2350.   
  2351. #ifdef MORESESSION
  2352. int
  2353. dodomlook(argc,argv,p)
  2354. int argc;
  2355. char *argv[];
  2356. void *p;
  2357. {
  2358.     char **margv;
  2359.     margv = (char **)callocw(3,sizeof(char *));
  2360.     margv[1] = strdup(Dfile);
  2361.     margv[2] = strdup(argv[1]);
  2362.     domore(3,margv,p);
  2363.     free(margv[1]);
  2364.     free(margv[2]);
  2365.     free(margv);
  2366.     return 0;
  2367. }
  2368. #endif
  2369.   
  2370.