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