开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
domain.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：41k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

domain.c：源码内容
  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.  */
  13. #include <stdio.h>
  14. #include <ctype.h>
  15. #include <time.h>
  16. #include <sys/stat.h>
  17. #include "global.h"
  18. #include "mbuf.h"
  19. #include "proc.h"
  20. #include "ip.h"
  21. #include "netuser.h"
  22. #include "session.h"
  23. #include "socket.h"
  24. #include "cmdparse.h"
  25. #include "commands.h"
  26. #include "files.h"
  27. #include "main.h"
  28. #include "domain.h"
  30. #undef DEBUG /* for certain trace messages */
  31. #undef DEBUG_PAIN /* for painful debugging */
  33. static struct rr *Dcache = NULL; /* Cache of resource records */
  34. static int Dcache_size = 20; /* size limit */
  35. static time_t Dcache_time = 0L;  /* timestamp */
  37. static int Dfile_clean = FALSE;  /* discard expired records (flag) */
  38. static int Dfile_reading = 0; /* read interlock (count) */
  39. static int Dfile_writing = 0; /* write interlock (count) */
  41. struct proc *Dfile_updater = NULL;
  42. static int32 Dfile_wait_absolute = 0L; /* timeout Clock time */
  43. static int Dfile_wait_relative = 300; /* timeout file activity (seconds) */
  45. static struct dserver *Dservers = NULL; /* List of potential servers */
  46. static int Dserver_retries = 2; /* Attempts to reach servers */
  48. static char *Dsuffix = NULL; /* Default suffix for names without periods */
  49. static int Dtrace = FALSE;
  50. static char *Dtypes[] = {
  51. "",
  52. "A",
  53. "NS",
  54. "MD",
  55. "MF",
  56. "CNAME",
  57. "SOA",
  58. "MB",
  59. "MG",
  60. "MR",
  61. "NULL",
  62. "WKS",
  63. "PTR",
  64. "HINFO",
  65. "MINFO",
  66. "MX",
  67. "TXT"
  68. };
  69. static int Ndtypes = 17;
  70. static char delim[] = " trn";
  72. static int docache(int argc,char *argv[],void *p);
  73. static int dosuffix(int argc,char *argv[],void *p);
  75. static int docacheclean(int argc,char *argv[],void *p);
  76. static int docachelist(int argc,char *argv[],void *p);
  77. static int docachesize(int argc,char *argv[],void *p);
  78. static int docachewait(int argc,char *argv[],void *p);
  80. static void dlist_add(struct dserver *dp);
  81. static void dlist_drop(struct dserver *dp);
  82. static int dodnsadd(int argc,char *argv[],void *p);
  83. static int dodnsdrop(int argc,char *argv[],void *p);
  84. static int dodnslist(int argc,char *argv[],void *p);
  85. static int dodnsquery(int argc,char *argv[],void *p);
  86. static int dodnsretry(int argc,char *argv[],void *p);
  87. static int dodnstrace(int argc,char *argv[],void *p);
  89. static char * dtype(int value);
  90. static int check_ttl(struct rr *rrlp);
  91. static int compare_rr(struct rr *search_rrp,struct rr *target_rrp);
  92. static int compare_rr_list(struct rr *rrlp,struct rr *target_rrp);
  93. static struct rr *copy_rr(struct rr *rrp);
  94. static struct rr *copy_rr_list(struct rr *rrlp);
  95. static struct rr *make_rr(int source,
  96. char *dname,uint16 class,uint16 type,int32 ttl,uint16 rdl,void *data);
  98. static void dcache_add(struct rr *rrlp);
  99. static void dcache_drop(struct rr *rrp);
  100. static struct rr *dcache_search(struct rr *rrlp);
  101. static void dcache_update(struct rr *rrlp);
  103. static struct rr *get_rr(FILE *fp, struct rr *lastrrp);
  104. static void put_rr(FILE *fp,struct rr *rrp);
  105. static struct rr *dfile_search(struct rr *rrlp);
  106. static void dfile_update(int s,void *unused,void *p);
  108. static void dumpdomain(struct dhdr *dhp,int32 rtt);
  109. static int dns_makequery(uint16 op,struct rr *rrp,
  110. uint8 *buffer,uint16 buflen);
  111. static int dns_query(struct rr *rrlp);
  113. static int isaddr(char *s);
  114. static char *checksuffix(char *dname);
  115. static struct rr *resolver(struct rr *rrlp);
  118. /**
  119.  ** Domain Resolver Commands
  120.  **/
  122. static struct cmds Dcmds[] = {
  123. "addserver", dodnsadd, 0, 2, "add <hostid>",
  124. "dropserver", dodnsdrop, 0, 2, "drop <hostid>",
  125. "list", dodnslist, 0, 0, NULL,
  126. "query", dodnsquery,   512, 2, "query <hostid>",
  127. "retry", dodnsretry, 0, 0, NULL,
  128. "suffix", dosuffix, 0, 0, NULL,
  129. "trace", dodnstrace, 0, 0, NULL,
  130. "cache", docache, 0, 0, NULL,
  131. NULL,
  132. };
  134. static struct cmds Dcachecmds[] = {
  135. "clean", docacheclean, 0, 0, NULL,
  136. "list", docachelist,  512, 0, NULL,
  137. "size", docachesize, 0, 0, NULL,
  138. "wait", docachewait, 0, 0, NULL,
  139. NULL,
  140. };
  142. int
  143. dodomain(argc,argv,p)
  144. int argc;
  145. char *argv[];
  146. void *p;
  147. {
  148. return subcmd(Dcmds,argc,argv,p);
  149. }
  151. static int
  152. docache(argc,argv,p)
  153. int argc;
  154. char *argv[];
  155. void *p;
  156. {
  157. return subcmd(Dcachecmds,argc,argv,p);
  158. }
  160. static int
  161. dosuffix(argc,argv,p)
  162. int argc;
  163. char *argv[];
  164. void *p;
  165. {
  166. if(argc < 2){
  167. if(Dsuffix != NULL)
  168. printf("%sn",Dsuffix);
  169. return 0;
  170. }
  171. free(Dsuffix);
  172. Dsuffix = strdup(argv[1]);
  173. return 0;
  174. }
  176. static int
  177. docacheclean(argc,argv,p)
  178. int argc;
  179. char *argv[];
  180. void *p;
  181. {
  182. return setbool( &Dfile_clean, "discard expired records", argc,argv );
  183. }
  185. static int
  186. docachelist(argc,argv,p)
  187. int argc;
  188. char *argv[];
  189. void *p;
  190. {
  191. struct rr *rrp;
  192. struct session *sp;
  193. int row = 25;
  195. if((sp = newsession(Cmdline,DCLIST,1)) == NULL){
  196. return -1;
  197. }
  199. (void)dcache_search(NULL); /* update ttl */
  201. /* Put tty into raw mode so single-char responses will work */
  202. sp->ttystate.echo = sp->ttystate.edit = 0;
  204. for(rrp=Dcache;rrp!=NULL;rrp=rrp->next)
  205. {
  206. put_rr(stdout,rrp);
  207. if(--row == 0){
  208. row = keywait("--More--",0);
  209. switch(row){
  210. case -1:
  211. case 'q':
  212. case 'Q':
  213. rrp = NULL;
  214. break;
  215. case 'n':
  216. case 'r':
  217. row = 1;
  218. break;
  219. case ' ':
  220. default:
  221. row = 25;
  222. };
  223. }
  224. }
  225. fflush(stdout);
  226. keywait(NULL,1);
  227. freesession(sp);
  228. return 0;
  229. }
  231. static int
  232. docachesize(argc,argv,p)
  233. int argc;
  234. char *argv[];
  235. void *p;
  236. {
  237. int newsize;
  238. int oldsize;
  239. int result;
  241. newsize = oldsize = Dcache_size;
  242. result = setint( &newsize, "memory cache size", argc,argv );
  244. if(newsize > 0){
  245. Dcache_size = newsize;
  246. if(newsize < oldsize){
  247. (void)dcache_search(NULL); /* update size */
  248. }
  249. }
  250. return result;
  251. }
  253. static int
  254. docachewait(argc,argv,p)
  255. int argc;
  256. char *argv[];
  257. void *p;
  258. {
  259. return setint( &Dfile_wait_relative, "time before file update (seconds)", argc,argv );
  260. }
  262. static void
  263. dlist_add(dp)
  264. register struct dserver *dp;
  265. {
  266. dp->prev = NULL;
  267. dp->next = Dservers;
  268. if(Dservers != NULL)
  269. Dservers->prev = dp;
  270. Dservers = dp;
  271. }
  273. static void
  274. dlist_drop(dp)
  275. register struct dserver *dp;
  276. {
  277. if(dp->prev != NULL)
  278. dp->prev->next = dp->next;
  279. else
  280. Dservers = dp->next;
  281. if(dp->next != NULL)
  282. dp->next->prev = dp->prev;
  283. }
  285. static int
  286. dodnsadd(argc,argv,p)
  287. int argc;
  288. char *argv[];
  289. void *p;
  290. {
  291. int32 address;
  293. if((address = resolve(argv[1])) == 0L){
  294. printf("Resolver %s unknownn",argv[1]);
  295. return 1;
  296. }
  297. return add_nameserver(address);
  298. }
  299. int
  300. add_nameserver(address)
  301. int32 address;
  302. {
  303. struct dserver *dp;
  305. dp = (struct dserver *)callocw(1,sizeof(struct dserver));
  306. dp->address = address;
  307. dp->srtt = INITRTT;
  308. dp->mdev = 0;
  309. dp->timeout = 2 * dp->mdev + dp->srtt + 3;
  310. dlist_add(dp);
  311. return 0;
  312. }
  314. static int
  315. dodnsdrop(argc,argv,p)
  316. int argc;
  317. char *argv[];
  318. void *p;
  319. {
  320. struct dserver *dp;
  321. int32 addr;
  323. addr = resolve(argv[1]);
  324. for(dp = Dservers;dp != NULL;dp = dp->next)
  325. if(addr == dp->address)
  326. break;
  328. if(dp == NULL){
  329. printf("Not foundn");
  330. return 1;
  331. }
  333. dlist_drop(dp);
  334. free(dp);
  335. return 0;
  336. }
  338. static int
  339. dodnslist(argc,argv,p)
  340. int argc;
  341. char *argv[];
  342. void *p;
  343. {
  344. register struct dserver *dp;
  346. printf("Server address          srtt    mdev   timeout   queries responsesn");
  347. for(dp = Dservers;dp != NULL;dp = dp->next){
  348. printf("%-20s%8lu%8lu%10lu%10lu%10lun",
  349.  inet_ntoa(dp->address),
  350.  dp->srtt,dp->mdev,dp->timeout,
  351.  dp->queries,dp->responses);
  352. }
  353. return 0;
  354. }
  356. static int
  357. dodnsquery(argc,argv,p)
  358. int argc;
  359. char *argv[];
  360. void *p;
  361. {
  362. struct rr *rrp;
  363. struct rr *result_rrlp;
  364. char *sname;
  365. struct session *sp;
  366. int row = 25;
  368. if((sp = newsession(Cmdline,DQUERY,1)) == NULL){
  369. return -1;
  370. }
  372. if ( isaddr( argv[1] ) ) {
  373. result_rrlp = inverse_a( aton( argv[1] ) );
  374. } else {
  375. sname = checksuffix( argv[1] );
  376. rrp = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_ANY,0,0,NULL);
  377. FREE(sname);
  379. dns_query(rrp);
  380. result_rrlp = dcache_search(rrp);
  381. free_rr(rrp);
  382. }
  384. /* Put tty into raw mode so single-char responses will work */
  385. sp->ttystate.echo = sp->ttystate.edit = 0;
  387. for( rrp=result_rrlp; rrp!=NULL; rrp=rrp->next)
  388. {
  389. put_rr(stdout,rrp);
  390. if(--row == 0){
  391. row = keywait("--More--",0);
  392. switch(row){
  393. case -1:
  394. case 'q':
  395. case 'Q':
  396. rrp = NULL;
  397. break;
  398. case 'n':
  399. case 'r':
  400. row = 1;
  401. break;
  402. case ' ':
  403. default:
  404. row = 25;
  405. };
  406. }
  407. }
  408. fflush(stdout);
  409. free_rr(result_rrlp);
  410. keywait(NULL,1);
  411. freesession(sp);
  412. return 0;
  413. }
  415. static int
  416. dodnsretry(argc,argv,p)
  417. int argc;
  418. char *argv[];
  419. void *p;
  420. {
  421. return setint( &Dserver_retries, "server retries", argc,argv );
  422. }
  424. static int
  425. dodnstrace(argc,argv,p)
  426. int argc;
  427. char *argv[];
  428. void *p;
  429. {
  430. return setbool(&Dtrace,"server trace",argc,argv);
  431. }
  434. /**
  435.  ** Domain Resource Record Utilities
  436.  **/
  438. static char *
  439. dtype(value)
  440. int value;
  441. {
  442. static char buf[10];
  444. if (value < Ndtypes)
  445. return Dtypes[value];
  447. sprintf( buf, "{%d}", value);
  448. return buf;
  449. }
  451. /* check list of resource records for any expired ones.
  452.  * returns number of expired records.
  453.  */
  454. static int
  455. check_ttl(rrlp)
  456. register struct rr *rrlp;
  457. {
  458. int count = 0;
  460. while(rrlp != NULL){
  461. if(rrlp->ttl == 0L)
  462. count++;
  463. rrlp = rrlp->next;
  464. }
  465. return count;
  466. }
  468. /* Compare two resource records.
  469.  * returns 0 if match, nonzero otherwise.
  470.  */
  471. static int
  472. compare_rr(search_rrp,target_rrp)
  473. register struct rr *search_rrp,*target_rrp;
  474. {
  475. int i;
  477. if(search_rrp == NULL || target_rrp == NULL)
  478. return -32765;
  480. if(search_rrp->class != target_rrp->class)
  481. return -32763;
  483. if(search_rrp->type != TYPE_ANY
  484. && search_rrp->type != target_rrp->type
  485. && (search_rrp->source != RR_QUERY
  486.  || (target_rrp->type != TYPE_CNAME
  487.   && target_rrp->type != TYPE_PTR)))
  488. return -32761;
  490. if(search_rrp->source != RR_INQUERY){
  491. if((i = strlen(search_rrp->name)) != strlen(target_rrp->name))
  492. return -32759;
  493. if((i = strnicmp(search_rrp->name,target_rrp->name,i)) != 0)
  494. return i;
  496. /* match negative records so that they are replaced */
  497. if(target_rrp->rdlength == 0)
  498. return 0;
  499. }
  501. /* if a query has gotten this far, match it */
  502. if(search_rrp->source == RR_QUERY)
  503. return 0;
  505. /* ensure negative records don't replace older records */
  506. if(search_rrp->rdlength == 0)
  507. return -32757;
  509. /* match expired records so that they are replaced */
  510. if(search_rrp->source != RR_INQUERY){
  511. if(target_rrp->ttl == 0L)
  512. return 0;
  513. }
  515. /* Note: rdlengths are not compared because they vary depending
  516.  * on the representation (ASCII or encoded) this record was
  517.  * generated from.
  518.  */
  520. switch(search_rrp->type){
  521. case TYPE_A:
  522. i = search_rrp->rdata.addr != target_rrp->rdata.addr;
  523. break;
  524. case TYPE_CNAME:
  525. case TYPE_MB:
  526. case TYPE_MG:
  527. case TYPE_MR:
  528. case TYPE_NS:
  529. case TYPE_PTR:
  530. case TYPE_TXT:
  531. i = stricmp(search_rrp->rdata.data,target_rrp->rdata.data);
  532. break;
  533. case TYPE_HINFO:
  534. i = strcmp(search_rrp->rdata.hinfo.cpu,target_rrp->rdata.hinfo.cpu) ||
  535. strcmp(search_rrp->rdata.hinfo.os,target_rrp->rdata.hinfo.os);
  536. break;
  537. case TYPE_MX:
  538. i = stricmp(search_rrp->rdata.mx.exch,target_rrp->rdata.mx.exch);
  539. break;
  540. case TYPE_SOA:
  541. i = search_rrp->rdata.soa.serial != target_rrp->rdata.soa.serial;
  542. break;
  543. default:
  544. i = -32755; /* unsupported */
  545. }
  546. return i;
  547. }
  549. static int
  550. compare_rr_list(rrlp,target_rrp)
  551. register struct rr *rrlp,*target_rrp;
  552. {
  553. while(rrlp != NULL){
  554. if(compare_rr(rrlp,target_rrp) == 0)
  555. return 0;
  556. #ifdef DEBUG_PAIN
  557. if(Dtrace)
  558. printf("%15d %sn",
  559. compare_rr(rrlp,target_rrp),
  560. target_rrp->name);
  561. #endif
  562. rrlp = rrlp->next;
  563. }
  564. return -32767;
  565. }
  567. /* Make a new copy of a resource record */
  568. static struct rr *
  569. copy_rr(rrp)
  570. register struct rr *rrp;
  571. {
  572. register struct rr *newrr;
  574. if(rrp == NULL)
  575. return NULL;
  577. newrr = (struct rr *)callocw(1,sizeof(struct rr));
  578. newrr->source = rrp->source;
  579. newrr->name = strdup(rrp->name);
  580. newrr->type = rrp->type;
  581. newrr->class = rrp->class;
  582. newrr->ttl = rrp->ttl;
  583. if((newrr->rdlength = rrp->rdlength) == 0)
  584. return newrr;
  586. switch(rrp->type){
  587. case TYPE_A:
  588. newrr->rdata.addr = rrp->rdata.addr;
  589. break;
  590. case TYPE_CNAME:
  591. case TYPE_MB:
  592. case TYPE_MG:
  593. case TYPE_MR:
  594. case TYPE_NS:
  595. case TYPE_PTR:
  596. case TYPE_TXT:
  597. newrr->rdata.name = strdup(rrp->rdata.name);
  598. break;
  599. case TYPE_HINFO:
  600. newrr->rdata.hinfo.cpu = strdup(rrp->rdata.hinfo.cpu);
  601. newrr->rdata.hinfo.os = strdup(rrp->rdata.hinfo.os);
  602. break;
  603. case TYPE_MX:
  604. newrr->rdata.mx.pref = rrp->rdata.mx.pref;
  605. newrr->rdata.mx.exch = strdup(rrp->rdata.mx.exch);
  606. break;
  607. case TYPE_SOA:
  608. newrr->rdata.soa.mname =  strdup(rrp->rdata.soa.mname);
  609. newrr->rdata.soa.rname =  strdup(rrp->rdata.soa.rname);
  610. newrr->rdata.soa.serial =  rrp->rdata.soa.serial;
  611. newrr->rdata.soa.refresh =  rrp->rdata.soa.refresh;
  612. newrr->rdata.soa.retry =  rrp->rdata.soa.retry;
  613. newrr->rdata.soa.expire =  rrp->rdata.soa.expire;
  614. newrr->rdata.soa.minimum =  rrp->rdata.soa.minimum;
  615. break;
  616. }
  617. return newrr;
  618. }
  620. static struct rr *
  621. copy_rr_list(rrlp)
  622. register struct rr *rrlp;
  623. {
  624. register struct rr **rrpp;
  625. struct rr *result_rrlp;
  627. rrpp = &result_rrlp;
  628. while(rrlp != NULL){
  629. *rrpp = copy_rr(rrlp);
  630. rrpp = &(*rrpp)->next;
  631. rrlp = rrlp->next;
  632. }
  633. *rrpp = NULL;
  634. return result_rrlp;
  635. }
  637. /* Free (list of) resource records */
  638. void
  639. free_rr(rrlp)
  640. register struct rr *rrlp;
  641. {
  642. register struct rr *rrp;
  644. while((rrp = rrlp) != NULL){
  645. rrlp = rrlp->next;
  647. free(rrp->comment);
  648. free(rrp->name);
  649. if(rrp->rdlength > 0){
  650. switch(rrp->type){
  651. case TYPE_A:
  652. break; /* Nothing allocated in rdata section */
  653. case TYPE_CNAME:
  654. case TYPE_MB:
  655. case TYPE_MG:
  656. case TYPE_MR:
  657. case TYPE_NS:
  658. case TYPE_PTR:
  659. case TYPE_TXT:
  660. free(rrp->rdata.name);
  661. break;
  662. case TYPE_HINFO:
  663. free(rrp->rdata.hinfo.cpu);
  664. free(rrp->rdata.hinfo.os);
  665. break;
  666. case TYPE_MX:
  667. free(rrp->rdata.mx.exch);
  668. break;
  669. case TYPE_SOA:
  670. free(rrp->rdata.soa.mname);
  671. free(rrp->rdata.soa.rname);
  672. break;
  673. }
  674. }
  675. free(rrp);
  676. }
  677. }
  679. static struct rr *
  680. make_rr(source,dname,dclass,dtype,ttl,rdl,data)
  681. int source;
  682. char *dname;
  683. uint16 dclass;
  684. uint16 dtype;
  685. int32 ttl;
  686. uint16 rdl;
  687. void *data;
  688. {
  689. register struct rr *newrr;
  691. newrr = (struct rr *)callocw(1,sizeof(struct rr));
  692. newrr->source = source;
  693. newrr->name = strdup(dname);
  694. newrr->class = dclass;
  695. newrr->type = dtype;
  696. newrr->ttl = ttl;
  697. if((newrr->rdlength = rdl) == 0)
  698. return newrr;
  700. switch(dtype){
  701. case TYPE_A:
  702.   {
  703. register int32 *ap = (int32 *)data;
  704. newrr->rdata.addr = *ap;
  705. break;
  706.   }
  707. case TYPE_CNAME:
  708. case TYPE_MB:
  709. case TYPE_MG:
  710. case TYPE_MR:
  711. case TYPE_NS:
  712. case TYPE_PTR:
  713. case TYPE_TXT:
  714.   {
  715. newrr->rdata.name = strdup((char *)data);
  716. break;
  717.   }
  718. case TYPE_HINFO:
  719.   {
  720. register struct hinfo *hinfop = (struct hinfo *)data;
  721. newrr->rdata.hinfo.cpu = strdup(hinfop->cpu);
  722. newrr->rdata.hinfo.os = strdup(hinfop->os);
  723. break;
  724.   }
  725. case TYPE_MX:
  726.   {
  727. register struct mx *mxp = (struct mx *)data;
  728. newrr->rdata.mx.pref = mxp->pref;
  729. newrr->rdata.mx.exch = strdup(mxp->exch);
  730. break;
  731.   }
  732. case TYPE_SOA:
  733.   {
  734. register struct soa *soap = (struct soa *)data;
  735. newrr->rdata.soa.mname =  strdup(soap->mname);
  736. newrr->rdata.soa.rname =  strdup(soap->rname);
  737. newrr->rdata.soa.serial =  soap->serial;
  738. newrr->rdata.soa.refresh =  soap->refresh;
  739. newrr->rdata.soa.retry =  soap->retry;
  740. newrr->rdata.soa.expire =  soap->expire;
  741. newrr->rdata.soa.minimum =  soap->minimum;
  742. break;
  743.   }
  744. }
  745. return newrr;
  746. }
  749. /**
  750.  ** Domain Cache Utilities
  751.  **/
  753. static void
  754. dcache_add(rrlp)
  755. register struct rr *rrlp;
  756. {
  757. register struct rr *last_rrp;
  758. struct rr *save_rrp;
  760. if(rrlp == NULL)
  761. return;
  763. save_rrp = rrlp;
  764. last_rrp = NULL;
  765. while(rrlp != NULL){
  766. rrlp->last = last_rrp;
  767. last_rrp = rrlp;
  768. rrlp = rrlp->next;
  769. }
  770. last_rrp->next = Dcache;
  771. if(Dcache != NULL)
  772. Dcache->last = last_rrp;
  773. Dcache = save_rrp;
  774. }
  776. static void
  777. dcache_drop(rrp)
  778. register struct rr *rrp;
  779. {
  780. if(rrp->last != NULL)
  781. rrp->last->next = rrp->next;
  782. else
  783. Dcache = rrp->next;
  784. if(rrp->next != NULL)
  785. rrp->next->last = rrp->last;
  786. rrp->last =
  787. rrp->next = NULL;
  788. }
  790. /* Search cache for resource records, removing them from the cache.
  791.  * Also, timeout cache entries, and trim cache to size.
  792.  * (Calling with NULL is legal -- will timeout & trim only.)
  793.  * Note that an answer from the cache cannot be authoritative, because
  794.  * we cannot guarantee that all the entries remain from a previous request.
  795.  * Returns RR list, or NULL if no record found.
  796.  */
  797. static struct rr *
  798. dcache_search(rrlp)
  799. struct rr *rrlp;
  800. {
  801. register struct rr *rrp, *test_rrp;
  802. struct rr **rrpp, *result_rrlp;
  803. int32 elapsed;
  804. time_t now;
  805. int count = 0;
  807. #ifdef DEBUG
  808. if(Dtrace && rrlp != NULL){
  809. printf("dcache_search: searching for %sn",rrlp->name);
  810. }
  811. #endif
  813. elapsed = (int32)(time(&now) - Dcache_time);
  814. Dcache_time = now;
  816. rrpp = &result_rrlp;
  817. for(rrp = Dcache; (test_rrp = rrp) != NULL;){
  818. rrp = rrp->next;
  819. /* timeout entries */
  820. if(test_rrp->ttl > 0L
  821. && (test_rrp->ttl -= elapsed) <= 0L)
  822. test_rrp->ttl = 0L;
  824. if(compare_rr_list(rrlp,test_rrp) == 0){
  825. dcache_drop( *rrpp = test_rrp );
  826. rrpp = &(*rrpp)->next;
  827. } else if(test_rrp->source == RR_FILE && ++count > Dcache_size){
  828. dcache_drop(test_rrp);
  829. free_rr(test_rrp);
  830. }
  831. }
  832. *rrpp = NULL;
  833. return result_rrlp;
  834. }
  836. /* Move a list of resource records to the cache, removing duplicates. */
  837. static void
  838. dcache_update(rrlp)
  839. register struct rr *rrlp;
  840. {
  841. if(rrlp == NULL)
  842. return;
  844. free_rr(dcache_search(rrlp)); /* remove duplicates, first */
  845. dcache_add(rrlp);
  846. }
  849. /**
  850.  ** File Utilities
  851.  **/
  853. static struct rr *
  854. get_rr(fp,lastrrp)
  855. FILE *fp;
  856. struct rr *lastrrp;
  857. {
  858. char *line,*lp,*strtok();
  859. struct rr *rrp;
  860. char *name,*ttl,*class,*type,*data;
  861. int i;
  863. line = mallocw(256);
  864. if(fgets(line,256,fp) == NULL){
  865. free(line);
  866. return NULL;
  867. }
  869. rrp = (struct rr *)callocw(1,sizeof(struct rr));
  870. rrp->source = RR_FILE;
  872. if(line[0] == '' || line[0] == '#' || line[0] == ';'){
  873. rrp->comment = line;
  874. return rrp;
  875. }
  877. if(!isspace(line[0]) || lastrrp == NULL){
  878. name = strtok(line,delim);
  879. lp = NULL;
  880. } else { /* Name field is missing */
  881. name = lastrrp->name;
  882. lp = line;
  883. }
  884. if(name == NULL || (i = strlen(name)) == 0){
  885. rrp->comment = strdup("n");
  886. free(line);
  887. return rrp;
  888. }
  890. if(name[i-1] != '.'){
  891. /* Tack on a trailing period if it's not there */
  892. /* !!! need to implement $ORIGIN suffix here */
  893. rrp->name = mallocw(i+2);
  894. strcpy(rrp->name,name);
  895. strcat(rrp->name,".");
  896. } else
  897. rrp->name = strdup(name);
  899. ttl = strtok(lp,delim);
  901. if(ttl == NULL || (!isdigit(ttl[0]) && ttl[0] != '-')){
  902. /* Optional ttl field is missing */
  903. rrp->ttl = TTL_MISSING;
  904. class = ttl;
  905. } else {
  906. rrp->ttl = atol(ttl);
  907. class = strtok(NULL,delim);
  908. }
  910. if(class == NULL){
  911. /* we're in trouble, but keep processing */
  912. rrp->class = CLASS_MISSING;
  913. type = class;
  914. } else if(class[0] == '<'){
  915. rrp->class = atoi(&class[1]);
  916. type = strtok(NULL,delim);
  917. } else if(stricmp(class,"IN") == 0){
  918. rrp->class = CLASS_IN;
  919. type = strtok(NULL,delim);
  920. } else {
  921. /* Optional class field is missing; assume IN */
  922. rrp->class = CLASS_IN;
  923. type = class;
  924. }
  926. if(type == NULL){
  927. /* we're in trouble, but keep processing */
  928. rrp->type = TYPE_MISSING;
  929. data = type;
  930. } else if(type[0] == '{'){
  931. rrp->type = atoi(&class[1]);
  932. data = strtok(NULL,delim);
  933. } else {
  934. rrp->type = TYPE_MISSING;
  935. for(i=1;i<Ndtypes;i++){
  936. if(stricmp(type,Dtypes[i]) == 0){
  937. rrp->type = i;
  938. data = strtok(NULL,delim);
  939. break;
  940. }
  941. }
  942. }
  944. if(rrp->type == TYPE_MISSING){
  945. data = NULL;
  946. }
  948. if(data == NULL){
  949. /* Empty record, just return */
  950. free(line);
  951. return rrp;
  952. }
  953. switch(rrp->type){
  954. case TYPE_A:
  955. rrp->rdlength = 4;
  956. rrp->rdata.addr = aton(data);
  957. break;
  958. case TYPE_CNAME:
  959. case TYPE_MB:
  960. case TYPE_MG:
  961. case TYPE_MR:
  962. case TYPE_NS:
  963. case TYPE_PTR:
  964. case TYPE_TXT:
  965. rrp->rdlength = strlen(data);
  966. rrp->rdata.name = strdup(data);
  967. break;
  968. case TYPE_HINFO:
  969. rrp->rdlength = strlen(data);
  970. rrp->rdata.hinfo.cpu = strdup(data);
  971. if((data = strtok(NULL,delim)) != NULL){
  972. rrp->rdlength += strlen(data);
  973. rrp->rdata.hinfo.os = strdup(data);
  974. }
  975. break;
  976. case TYPE_MX:
  977. rrp->rdata.mx.pref = atoi(data);
  978. rrp->rdlength = 2;
  980. /* Get domain name of exchanger */
  981. if((data = strtok(NULL,delim)) != NULL){
  982. rrp->rdlength += strlen(data);
  983. rrp->rdata.mx.exch = strdup(data);
  984. }
  985. break;
  986. case TYPE_SOA:
  987. /* Get domain name of master name server */
  988. rrp->rdlength = strlen(data);
  989. rrp->rdata.soa.mname = strdup(data);
  991. /* Get domain name of irresponsible person */
  992. if((data = strtok(NULL,delim)) != NULL){
  993. rrp->rdata.soa.rname = strdup(data);
  994. rrp->rdlength += strlen(data);
  995. }
  996. data = strtok(NULL,delim);
  997. rrp->rdata.soa.serial = atol(data);
  998. data = strtok(NULL,delim);
  999. rrp->rdata.soa.refresh = atol(data);
  1000. data = strtok(NULL,delim);
  1001. rrp->rdata.soa.retry = atol(data);
  1002. data = strtok(NULL,delim);
  1003. rrp->rdata.soa.expire = atol(data);
  1004. data = strtok(NULL,delim);
  1005. rrp->rdata.soa.minimum = atol(data);
  1006. rrp->rdlength += 20;
  1007. break;
  1008. }
  1010. /* !!! need to handle trailing comments */
  1011. free(line);
  1012. return rrp;
  1013. }
  1015. /* Print a resource record */
  1016. static void
  1017. put_rr(fp,rrp)
  1018. FILE *fp;
  1019. struct rr *rrp;
  1020. {
  1021. char * stuff;
  1023. if(fp == NULL || rrp == NULL)
  1024. return;
  1026. if(rrp->name == NULL && rrp->comment != NULL){
  1027. fprintf(fp,"%s",rrp->comment);
  1028. return;
  1029. }
  1031. fprintf(fp,"%s",rrp->name);
  1032. if(rrp->ttl != TTL_MISSING)
  1033. fprintf(fp,"t%ld",rrp->ttl);
  1034. if(rrp->class == CLASS_IN)
  1035. fprintf(fp,"tIN");
  1036. else
  1037. fprintf(fp,"t<%u>",rrp->class);
  1039. stuff = dtype(rrp->type);
  1040. fprintf(fp,"t%s",stuff);
  1041. if(rrp->rdlength == 0){
  1042. /* Null data portion, indicates nonexistent record */
  1043. /* or unsupported type.  Hopefully, these will filter */
  1044. /* as time goes by. */
  1045. fprintf(fp,"n");
  1046. return;
  1047. }
  1048. switch(rrp->type){
  1049. case TYPE_A:
  1050. fprintf(fp,"t%sn",inet_ntoa(rrp->rdata.addr));
  1051. break;
  1052. case TYPE_CNAME:
  1053. case TYPE_MB:
  1054. case TYPE_MG:
  1055. case TYPE_MR:
  1056. case TYPE_NS:
  1057. case TYPE_PTR:
  1058. case TYPE_TXT:
  1059. /* These are all printable text strings */
  1060. fprintf(fp,"t%sn",rrp->rdata.data);
  1061. break;
  1062. case TYPE_HINFO:
  1063. fprintf(fp,"t%st%sn",
  1064.  rrp->rdata.hinfo.cpu,
  1065.  rrp->rdata.hinfo.os);
  1066. break;
  1067. case TYPE_MX:
  1068. fprintf(fp,"t%ut%sn",
  1069.  rrp->rdata.mx.pref,
  1070.  rrp->rdata.mx.exch);
  1071. break;
  1072. case TYPE_SOA:
  1073. fprintf(fp,"t%st%st%lut%lut%lut%lut%lun",
  1074.  rrp->rdata.soa.mname,rrp->rdata.soa.rname,
  1075.  rrp->rdata.soa.serial,rrp->rdata.soa.refresh,
  1076.  rrp->rdata.soa.retry,rrp->rdata.soa.expire,
  1077.  rrp->rdata.soa.minimum);
  1078. break;
  1079. default:
  1080. fprintf(fp,"n");
  1081. break;
  1082. }
  1083. }
  1085. /* Search local database for resource records.
  1086.  * Returns RR list, or NULL if no record found.
  1087.  */
  1088. static struct rr *
  1089. dfile_search(rrlp)
  1090. struct rr *rrlp;
  1091. {
  1092. register struct rr *frrp;
  1093. struct rr **rrpp, *result_rrlp, *oldrrp;
  1094. int32 elapsed;
  1095. FILE *dbase;
  1096. struct stat dstat;
  1098. #ifdef DEBUG
  1099. if(Dtrace){
  1100. printf("dfile_search: searching for %sn",rrlp->name);
  1101. }
  1102. #endif
  1104. while(Dfile_writing > 0)
  1105. kwait(&Dfile_reading);
  1106. Dfile_reading++;
  1108. if((dbase = fopen(Dfile,READ_TEXT)) == NULL){
  1109. Dfile_reading--;
  1110. return NULL;
  1111. }
  1112. if(fstat(fileno(dbase),&dstat) != 0){
  1113. printf("dfile_search: can't get file statusn");
  1114. fclose(dbase);
  1115. Dfile_reading--;
  1116. return NULL;
  1117. }
  1118. if((elapsed = (int32)(Dcache_time - (time_t)dstat.st_ctime)) < 0L)
  1119. elapsed = -elapsed; /* arbitrary time mismatch */
  1121. result_rrlp = NULL; /* for contiguous test below */
  1122. oldrrp = NULL;
  1123. rrpp = &result_rrlp;
  1124. while((frrp = get_rr(dbase,oldrrp)) != NULL){
  1125. free_rr(oldrrp);
  1126. if(frrp->type != TYPE_MISSING
  1127. && frrp->rdlength > 0
  1128. && compare_rr_list(rrlp,frrp) == 0){
  1129. if(frrp->ttl > 0L
  1130. && (frrp->ttl -= elapsed) <= 0L)
  1131. frrp->ttl = 0L;
  1132. *rrpp = frrp;
  1133. rrpp = &(*rrpp)->next;
  1134. oldrrp = copy_rr(frrp);
  1135. } else {
  1136. oldrrp = frrp;
  1137. /*
  1138. All records of the same name and the same type
  1139. are contiguous.  Therefore, for a single query,
  1140. we can stop searching.  Multiple queries must
  1141. read the whole file.
  1142. */
  1143. if(rrlp->type != TYPE_ANY
  1144. && rrlp->next == NULL
  1145. && result_rrlp != NULL)
  1146. break;
  1147. }
  1148. if(!main_exit)
  1149. kwait(NULL); /* run multiple sessions */
  1150. }
  1151. free_rr(oldrrp);
  1152. *rrpp = NULL;
  1154. fclose(dbase);
  1156. if(--Dfile_reading <= 0){
  1157. Dfile_reading = 0;
  1158. ksignal(&Dfile_writing,0);
  1159. }
  1161. return result_rrlp;
  1162. }
  1164. /* Process which will add new resource records from the cache
  1165.  * to the local file, eliminating duplicates while it goes.
  1166.  */
  1167. static void
  1168. dfile_update(s,unused,p)
  1169. int s;
  1170. void *unused;
  1171. void *p;
  1172. {
  1173. struct rr **rrpp, *rrlp, *oldrrp;
  1174. char *newname;
  1175. FILE *old_fp, *new_fp;
  1176. struct stat old_stat, new_stat;
  1178. logmsg(-1,"update Domain.txt initiated");
  1180. /* Produce output on command session rather than the one
  1181.  * that invoked us
  1182.  */
  1183. fclose(stdin);
  1184. stdin = fdup(Cmdpp->input);
  1185. fclose(stdout);
  1186. stdout = fdup(Cmdpp->output);
  1188. newname = strdup(Dfile);
  1189. strcpy(&newname[strlen(newname)-3],"tmp");
  1191. while(Dfile_wait_absolute != 0L && !main_exit){
  1192. register struct rr *frrp;
  1193. int32 elapsed;
  1195. while(Dfile_wait_absolute != 0L){
  1196. elapsed = Dfile_wait_absolute - secclock();
  1197. Dfile_wait_absolute = 0L;
  1198. if(elapsed > 0L && !main_exit){
  1199. kalarm(elapsed*1000L);
  1200. kwait(&Dfile_wait_absolute);
  1201. kalarm(0L);
  1202. }
  1203. }
  1205. logmsg(-1,"update Domain.txt");
  1207. /* create new file for copy */
  1208. if((new_fp = fopen(newname,WRITE_TEXT)) == NULL){
  1209. printf("dfile_update: can't create %s!n",newname);
  1210. break;
  1211. }
  1212. if(fstat(fileno(new_fp),&new_stat) != 0){
  1213. printf("dfile_update: can't get new_file status!n");
  1214. fclose(new_fp);
  1215. break;
  1216. }
  1218. kwait(NULL); /* file operations can be slow */
  1220. /* timeout the cache one last time before writing */
  1221. (void)dcache_search(NULL);
  1223. /* copy new RRs out to the new file */
  1224. /* (can't wait here, the cache might change) */
  1225. rrpp = &rrlp;
  1226. for(frrp = Dcache; frrp != NULL; frrp = frrp->next ){
  1227. switch(frrp->source){
  1228. case RR_QUESTION:
  1229. case RR_ANSWER:
  1230. case RR_AUTHORITY:
  1231. case RR_ADDITIONAL:
  1232. *rrpp = copy_rr(frrp);
  1233. if(frrp->type != TYPE_MISSING
  1234. && frrp->rdlength > 0)
  1235. put_rr(new_fp,frrp);
  1236. rrpp = &(*rrpp)->next;
  1237. frrp->source = RR_FILE;
  1238. break;
  1239. }
  1240. }
  1241. *rrpp = NULL;
  1243. /* open up the old file, concurrently with everyone else */
  1244. if((old_fp = fopen(Dfile,READ_TEXT)) == NULL){
  1245. /* great! no old file, so we're ready to go. */
  1246. fclose(new_fp);
  1247. rename(newname,Dfile);
  1248. free_rr(rrlp);
  1249. break;
  1250. }
  1251. if(fstat(fileno(old_fp),&old_stat) != 0){
  1252. printf("dfile_update: can't get old_file status!n");
  1253. fclose(new_fp);
  1254. fclose(old_fp);
  1255. free_rr(rrlp);
  1256. break;
  1257. }
  1258. if((elapsed = (int32)(new_stat.st_ctime - old_stat.st_ctime)) < 0L)
  1259. elapsed = -elapsed; /* file times are inconsistant */
  1261. /* Now append any non-duplicate records */
  1262. oldrrp = NULL;
  1263. while((frrp = get_rr(old_fp,oldrrp)) != NULL){
  1264. free_rr(oldrrp);
  1265. if(frrp->name == NULL
  1266. && frrp->comment != NULL)
  1267. put_rr(new_fp,frrp);
  1268. if(frrp->type != TYPE_MISSING
  1269. && frrp->rdlength > 0
  1270. && compare_rr_list(rrlp,frrp) != 0){
  1271. if(frrp->ttl > 0L
  1272. && (frrp->ttl -= elapsed) <= 0L)
  1273. frrp->ttl = 0L;
  1274. if(frrp->ttl != 0 || !Dfile_clean)
  1275. put_rr(new_fp,frrp);
  1276. }
  1277. oldrrp = frrp;
  1278. if(!main_exit)
  1279. kwait(NULL); /* run in background */
  1280. }
  1281. free_rr(oldrrp);
  1282. fclose(new_fp);
  1283. fclose(old_fp);
  1284. free_rr(rrlp);
  1286. /* wait for everyone else to finish reading */
  1287. Dfile_writing++;
  1288. while(Dfile_reading > 0)
  1289. kwait(&Dfile_writing);
  1291. unlink(Dfile);
  1292. rename(newname,Dfile);
  1294. Dfile_writing = 0;
  1295. ksignal(&Dfile_reading,0);
  1296. }
  1297. free(newname);
  1299. logmsg(-1,"update Domain.txt finished");
  1300. Dfile_updater = NULL;
  1301. }
  1304. /**
  1305.  ** Domain Server Utilities
  1306.  **/
  1308. static void
  1309. dumpdomain(dhp,rtt)
  1310. struct dhdr *dhp;
  1311. int32 rtt;
  1312. {
  1313. struct rr *rrp;
  1314. char * stuff;
  1316. printf("response id %u (rtt %lu sec) qr %u opcode %u aa %u tc %u rd %u ra %u rcode %un",
  1317.  dhp->id,(long)rtt / 1000L,
  1318.  dhp->qr,dhp->opcode,dhp->aa,dhp->tc,dhp->rd,
  1319.  dhp->ra,dhp->rcode);
  1320. printf("%u questions:n",dhp->qdcount);
  1321. for(rrp = dhp->questions; rrp != NULL; rrp = rrp->next){
  1322. stuff = dtype(rrp->type);
  1323. printf("%s type %s class %un",rrp->name,
  1324.  stuff,rrp->class);
  1325. }
  1326. printf("%u answers:n",dhp->ancount);
  1327. for(rrp = dhp->answers; rrp != NULL; rrp = rrp->next){
  1328. put_rr(stdout,rrp);
  1329. }
  1330. printf("%u authority:n",dhp->nscount);
  1331. for(rrp = dhp->authority; rrp != NULL; rrp = rrp->next){
  1332. put_rr(stdout,rrp);
  1333. }
  1334. printf("%u additional:n",dhp->arcount);
  1335. for(rrp = dhp->additional; rrp != NULL; rrp = rrp->next){
  1336. put_rr(stdout,rrp);
  1337. }
  1338. fflush(stdout);
  1339. }
  1341. static int
  1342. dns_makequery(op,srrp,buffer,buflen)
  1343. uint16 op; /* operation */
  1344. struct rr *srrp;/* Search RR */
  1345. uint8 *buffer; /* Area for query */
  1346. uint16 buflen; /* Length of same */
  1347. {
  1348. uint8 *cp;
  1349. char *cp1;
  1350. char *dname, *sname;
  1351. uint16 parameter;
  1352. uint16 dlen,len;
  1354. cp = buffer;
  1355. /* Use millisecond clock for timestamping */
  1356. cp = put16(cp,(uint16)msclock());
  1357. parameter = (op << 11)
  1358. | 0x0100; /* Recursion desired */
  1359. cp = put16(cp,parameter);
  1360. cp = put16(cp,1);
  1361. cp = put16(cp,0);
  1362. cp = put16(cp,0);
  1363. cp = put16(cp,0);
  1365. sname = strdup(srrp->name);
  1366. dname = sname;
  1367. dlen = strlen(dname);
  1368. for(;;){
  1369. /* Look for next dot */
  1370. cp1 = strchr(dname,'.');
  1371. if(cp1 != NULL)
  1372. len = cp1-dname; /* More to come */
  1373. else
  1374. len = dlen; /* Last component */
  1375. *cp++ = len; /* Write length of component */
  1376. if(len == 0)
  1377. break;
  1378. /* Copy component up to (but not including) dot */
  1379. strncpy((char *)cp,dname,len);
  1380. cp += len;
  1381. if(cp1 == NULL){
  1382. *cp++ = 0; /* Last one; write null and finish */
  1383. break;
  1384. }
  1385. dname += len+1;
  1386. dlen -= len+1;
  1387. }
  1388. free(sname);
  1389. cp = put16(cp,srrp->type);
  1390. cp = put16(cp,srrp->class);
  1391. return cp - buffer;
  1392. }
  1394. /* domain server resolution loop
  1395.  * returns: any answers in cache.
  1396.  * (future features)
  1397.  * multiple queries.
  1398.  * inverse queries.
  1399.  * return value: 0 if something added to cache, -1 if error
  1400.  */
  1401. static int
  1402. dns_query(rrlp)
  1403. struct rr *rrlp;
  1404. {
  1405. struct mbuf *bp;
  1406. struct dhdr *dhp;
  1407. struct dserver *dp; /* server list */
  1408. int32 rtt,abserr;
  1409. int tried = 0; /* server list has been retried (count) */
  1411. if((dp = Dservers) == NULL)
  1412. return -1;
  1414. for(;;){
  1415. uint8 *buf;
  1416. int len;
  1417. struct sockaddr_in server_in;
  1418. int s;
  1419. int rval;
  1421. dp->queries++;
  1423. s = socket(AF_INET,SOCK_DGRAM,0);
  1424. server_in.sin_family = AF_INET;
  1425. server_in.sin_port = IPPORT_DOMAIN;
  1426. server_in.sin_addr.s_addr = dp->address;
  1428. if(Dtrace){
  1429. printf("dns_query: querying server %s for %sn",
  1430.  inet_ntoa(dp->address),rrlp->name);
  1431. }
  1433. buf = mallocw(512);
  1434. len = dns_makequery(0,rrlp,buf,512);
  1435. if(sendto(s,buf,len,0,(struct sockaddr *)&server_in,sizeof(server_in)) == -1)
  1436. perror("domain sendto");
  1437. FREE(buf);
  1438. kalarm(max(dp->timeout,100));
  1439. /* Wait for something to happen */
  1440. rval = recv_mbuf(s,&bp,0,NULL,0);
  1441. kalarm(0L);
  1442. close_s(s);
  1444. if(Dtrace){
  1445. if(errno == 0)
  1446. printf("dns_query: received message length %dn",rval);
  1447. else
  1448. perror("dns_query");
  1449. }
  1451. if(rval > 0)
  1452. break;
  1454. if(errno == EABORT)
  1455. return -1; /* Killed by "reset" command */
  1457. /* Timeout; back off this one and try another server */
  1458. dp->timeout <<= 1;
  1459. if((dp = dp->next) == NULL){
  1460. dp = Dservers;
  1461. if(Dserver_retries > 0 && ++tried > Dserver_retries)
  1462. return -1;
  1463. }
  1464. }
  1466. /* got a response */
  1467. dp->responses++;
  1468. dhp = (struct dhdr *) mallocw(sizeof(struct dhdr));
  1469. ntohdomain(dhp,&bp); /* Convert to local format */
  1471. /* Compute and update the round trip time */
  1472. rtt = (int32) ((uint16)msclock() - dhp->id);
  1473. abserr = rtt > dp->srtt ? rtt - dp->srtt : dp->srtt - rtt;
  1474. dp->srtt = ((AGAIN-1) * dp->srtt + rtt + (AGAIN/2)) >> LAGAIN;
  1475. dp->mdev = ((DGAIN-1) * dp->mdev + abserr + (DGAIN/2)) >> LDGAIN;
  1476. dp->timeout = 4 * dp->mdev + dp->srtt;
  1478. /* move to top of list for next time */
  1479. if(dp->prev != NULL){
  1480. dlist_drop(dp);
  1481. dlist_add(dp);
  1482. }
  1484. if(Dtrace)
  1485. dumpdomain(dhp,rtt);
  1487. /* Add negative reply to answers.  This assumes that there was
  1488.  * only one question, which is true for all questions we send.
  1489.  */
  1490. if(dhp->aa && (dhp->rcode == NAME_ERROR || dhp->ancount == 0)){
  1491. register struct rr *rrp;
  1492. long ttl = 600L; /* Default TTL for negative records */
  1494. /* look for SOA ttl */
  1495. for(rrp = dhp->authority; rrp != NULL; rrp = rrp->next){
  1496. if(rrp->type == TYPE_SOA)
  1497. ttl = rrp->ttl;
  1498. }
  1500. /* make the questions the negative answers */
  1501. for(rrp = dhp->questions; rrp != NULL; rrp = rrp->next)
  1502. rrp->ttl = ttl;
  1503. } else {
  1504. free_rr(dhp->questions);
  1505. dhp->questions = NULL;
  1506. }
  1508. /* post in reverse order to maintain original order */
  1509. dcache_update(dhp->additional);
  1510. dcache_update(dhp->authority);
  1511. dcache_update(dhp->answers);
  1512. dcache_update(dhp->questions);
  1514. Dfile_wait_absolute = secclock() + Dfile_wait_relative;
  1515. if(Dfile_updater == NULL){
  1516. Dfile_updater = newproc("domain update",
  1517. 512,dfile_update,0,NULL,NULL,0);
  1518. }
  1520. #ifdef DEBUG
  1521. if(Dtrace)
  1522. keywait(NULL,1); /* so we can look around */
  1523. #endif
  1524. free(dhp);
  1525. return 0;
  1526. }
  1529. /**
  1530.  ** Resolver Utilities
  1531.  **/
  1533. /* Return TRUE if string appears to be an IP address in dotted decimal;
  1534.  * return FALSE otherwise (i.e., if string is a domain name)
  1535.  */
  1536. static int
  1537. isaddr(s)
  1538. register char *s;
  1539. {
  1540. char c;
  1542. if(s == NULL)
  1543. return TRUE; /* Can't happen */
  1545. while((c = *s++) != ''){
  1546. if(c != '[' && c != ']' && !isdigit(c) && c != '.')
  1547. return FALSE;
  1548. }
  1549. return TRUE;
  1550. }
  1552. /* Return "normalized" domain name, with default suffix and trailing '.'
  1553.  */
  1554. static char *
  1555. checksuffix(dname)
  1556. char *dname;
  1557. {
  1558. char *sname, *tname;
  1560. sname = strdup(dname);
  1561. if(strchr(sname,'.') == NULL && Dsuffix != NULL){
  1562. /* Append default suffix */
  1563. tname = mallocw(strlen(sname)+strlen(Dsuffix)+2);
  1564. sprintf(tname,"%s.%s",sname,Dsuffix);
  1565. free(sname);
  1566. sname = tname;
  1567. }
  1568. if(sname[strlen(sname)-1] != '.'){
  1569. /* Append trailing dot */
  1570. tname = mallocw(strlen(sname)+2);
  1571. sprintf(tname,"%s.",sname);
  1572. free(sname);
  1573. sname = tname;
  1574. }
  1575. return sname;
  1576. }
  1578. /* Search for resource records.
  1579.  * Returns RR list, or NULL if no record found.
  1580.  */
  1581. static struct rr *
  1582. resolver(rrlp)
  1583. register struct rr *rrlp;
  1584. {
  1585. register struct rr *result_rrlp;
  1587. if((result_rrlp = dcache_search(rrlp)) == NULL){
  1588. result_rrlp = dfile_search(rrlp);
  1589. }
  1590. if(result_rrlp == NULL || check_ttl(result_rrlp) != 0){
  1591. dcache_add(result_rrlp);  /* save any expired RRs */
  1592. if(dns_query(rrlp) == -1)
  1593. return NULL;
  1594. result_rrlp = dcache_search(rrlp);
  1595. }
  1596. dcache_add(copy_rr_list(result_rrlp));
  1597. return result_rrlp;
  1598. }
  1600. /* general entry point for address -> domain name resolution.
  1601.  * Returns RR list, or NULL if no record found.
  1602.  */
  1603. struct rr *
  1604. inverse_a(ip_address)
  1605. int32 ip_address;
  1606. {
  1607. struct rr *prrp;
  1608. struct rr *result_rrlp;
  1609. char pname[30];
  1611. if(ip_address == 0L)
  1612. return NULL;
  1614. sprintf( pname, "%u.%u.%u.%u.IN-ADDR.ARPA.",
  1615. lobyte(loword(ip_address)),
  1616. hibyte(loword(ip_address)),
  1617. lobyte(hiword(ip_address)),
  1618. hibyte(hiword(ip_address)) );
  1620. prrp = make_rr(RR_QUERY,pname,CLASS_IN,TYPE_PTR,0,0,NULL);
  1622. prrp->next =  /* make list to speed search */
  1623. make_rr(RR_INQUERY,NULL,CLASS_IN,TYPE_A,0,4,&ip_address);
  1625. result_rrlp = resolver(prrp);
  1627. free_rr(prrp);
  1628. return result_rrlp;
  1629. }
  1631. /* general entry point for domain name -> resource resolution.
  1632.  * Returns RR list, or NULL if no record found.
  1633.  */
  1634. struct rr *
  1635. resolve_rr(dname,dtype)
  1636. char *dname;
  1637. uint16 dtype;
  1638. {
  1639. struct rr *qrrp;
  1640. struct rr *result_rrlp;
  1641. char *sname;
  1642. int looping = MAXCNAME;
  1644. if(dname == NULL)
  1645. return NULL;
  1647. sname = checksuffix(dname);
  1648. qrrp = make_rr(RR_QUERY,sname,CLASS_IN,dtype,0,0,NULL);
  1649. FREE(sname);
  1651. while(looping > 0){
  1652. if((result_rrlp=resolver(qrrp)) == NULL
  1653. || result_rrlp->type == dtype)
  1654. break;
  1655. #ifdef DEBUG
  1656. if(Dtrace)
  1657. put_rr(stdout,result_rrlp);
  1658. #endif
  1659. /* Should be CNAME or PTR record */
  1660. /* Replace name and try again */
  1661. free(qrrp->name);
  1662. qrrp->name = strdup(result_rrlp->rdata.name);
  1663. free_rr(result_rrlp);
  1664. result_rrlp = NULL;
  1665. looping--;
  1666. }
  1667. free_rr(qrrp);
  1668. return result_rrlp;
  1669. }
  1671. /* main entry point for address -> domain name resolution.
  1672.  * Returns string, or NULL if no name found.
  1673.  */
  1674. char *
  1675. resolve_a(ip_address,shorten)
  1676. int32 ip_address; /* search address */
  1677. int shorten; /* return only first part of name (flag)*/
  1678. {
  1679. struct rr *save_rrlp, *rrlp;
  1680. char *result = NULL;
  1682. for( rrlp = save_rrlp = inverse_a(ip_address);
  1683.      rrlp != NULL && result == NULL;
  1684.      rrlp = rrlp->next ){
  1685. if(rrlp->rdlength > 0){
  1686. switch(rrlp->type){
  1687. case TYPE_PTR:
  1688. result = strdup(rrlp->rdata.name);
  1689. break;
  1690. case TYPE_A:
  1691. result = strdup(rrlp->name);
  1692. break;
  1693. }
  1694. }
  1695. }
  1696. free_rr(save_rrlp);
  1698. if(result != NULL && shorten){
  1699. int dot;
  1700. char *shortened;
  1702. if((dot = strcspn(result, ".")) == 0){
  1703. shortened = mallocw(dot+1);
  1704. strncpy(shortened, result, dot);
  1705. shortened[dot] = '';
  1706. free(result);
  1707. result = shortened;
  1708. }
  1709. }
  1710. return result;
  1711. }
  1713. /* Main entry point for domain name -> address resolution.
  1714.  * Returns 0 if name is currently unresolvable.
  1715.  */
  1716. int32
  1717. resolve(name)
  1718. char *name;
  1719. {
  1720. register struct rr *rrlp;
  1721. int32 ip_address = 0;
  1723. if(name == NULL)
  1724. return 0;
  1726. if(isaddr(name))
  1727. return aton(name);
  1729. if((rrlp = resolve_rr(name,TYPE_A)) != NULL
  1730.  && rrlp->rdlength > 0)
  1731. ip_address = rrlp->rdata.addr;
  1733. /* multi-homed hosts are handled here */
  1734. if(rrlp != NULL && rrlp->next != NULL) {
  1735. register struct rr *rrp;
  1736. register struct route *rp;
  1737. uint16 cost = MAXINT16;
  1738. rrp = rrlp;
  1739. /* choose the best of a set of routes */
  1740. while(rrp != NULL) {
  1741. if(rrp->rdlength > 0
  1742.  && (rp = rt_lookup(rrp->rdata.addr)) != NULL
  1743.  && rp->metric <= cost) {
  1744. ip_address = rrp->rdata.addr;
  1745. cost = rp->metric;
  1746. }
  1747. rrp = rrp->next;
  1748. }
  1749. }
  1751. free_rr(rrlp);
  1752. return ip_address;
  1753. }
  1756. /* Main entry point for MX record lookup.
  1757.  * Returns 0 if name is currently unresolvable.
  1758.  */
  1759. int32
  1760. resolve_mx(name)
  1761. char *name;
  1762. {
  1763. register struct rr *rrp, *arrp;
  1764. char *sname, *tmp, *cp;
  1765. int32 addr, ip_address = 0;
  1766. uint16 pref = MAXINT16;
  1768. if(name == NULL)
  1769. return 0;
  1771. if(isaddr(name)){
  1772. if((sname = resolve_a(aton(name),FALSE)) == NULL)
  1773. return 0;
  1774. }
  1775. else
  1776. sname = strdup(name);
  1778. cp = sname;
  1779. while(1){
  1780. rrp = arrp = resolve_rr(sname,TYPE_MX);
  1781. /* Search this list of rr's for an MX record */
  1782. while(rrp != NULL){
  1783. if(rrp->rdlength > 0 && rrp->rdata.mx.pref <= pref &&
  1784.    (addr = resolve(rrp->rdata.mx.exch)) != 0L){
  1785. pref = rrp->rdata.mx.pref;
  1786. ip_address = addr;
  1787. }
  1788. rrp = rrp->next;
  1789. }
  1790. free_rr(arrp);
  1791. if(ip_address != 0)
  1792. break;
  1793. /* Compose wild card one level up */
  1794. if((cp = strchr(cp,'.')) == NULL)
  1795. break;
  1796. tmp = mallocw(strlen(cp)+2);
  1797. sprintf(tmp,"*%s",cp); /* wildcard expansion */
  1798. free(sname);
  1799. sname = tmp;
  1800. cp = sname + 2;
  1801. }
  1802. free(sname);
  1803. return ip_address;
  1804. }
  1806. /* Search for local records of the MB, MG and MR type. Returns list of
  1807.  * matching records.
  1808.  */
  1809. struct rr *
  1810. resolve_mailb(name)
  1811. char *name; /* local username, without trailing dot */
  1812. {
  1813. register struct rr *result_rrlp;
  1814. struct rr *rrlp;
  1815. char *sname;
  1817. /* Append trailing dot */
  1818. sname = mallocw(strlen(name)+2);
  1819. sprintf(sname,"%s.",name);
  1820. rrlp = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MB,0,0,NULL);
  1821. rrlp->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MG,0,0,NULL);
  1822. rrlp->next->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MR,0,0,NULL);
  1823. FREE(sname);
  1824. if((result_rrlp = dcache_search(rrlp)) == NULL){
  1825. result_rrlp = dfile_search(rrlp);
  1826. }
  1827. free_rr(rrlp);
  1828. if(Dsuffix != NULL){
  1829. rrlp = result_rrlp;
  1830. while(rrlp != NULL){ /* add domain suffix to data */
  1831. if(rrlp->rdlength > 0 &&
  1832.    rrlp->rdata.name[rrlp->rdlength-1] != '.'){
  1833. sname = mallocw(rrlp->rdlength +
  1834. strlen(Dsuffix)+2);
  1835. sprintf(sname,"%s.%s",rrlp->rdata.name,Dsuffix);
  1836. free(rrlp->rdata.name);
  1837. rrlp->rdata.name = sname;
  1838. rrlp->rdlength = strlen(sname);
  1839. }
  1840. rrlp = rrlp->next;
  1841. }
  1842. }
  1843. dcache_add(copy_rr_list(result_rrlp));
  1844. return result_rrlp;
  1845. }