dn.c 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <ip.h>
  4. #include <pool.h>
  5. #include <ctype.h>
  6. #include "dns.h"
  7. /*
  8. * Hash table for domain names. The hash is based only on the
  9. * first element of the domain name.
  10. */
  11. DN *ht[HTLEN];
  12. static struct
  13. {
  14. Lock;
  15. ulong names; /* names allocated */
  16. ulong oldest; /* longest we'll leave a name around */
  17. int active;
  18. int mutex;
  19. int id;
  20. } dnvars;
  21. /* names of RR types */
  22. char *rrtname[] =
  23. {
  24. [Ta] "ip",
  25. [Tns] "ns",
  26. [Tmd] "md",
  27. [Tmf] "mf",
  28. [Tcname] "cname",
  29. [Tsoa] "soa",
  30. [Tmb] "mb",
  31. [Tmg] "mg",
  32. [Tmr] "mr",
  33. [Tnull] "null",
  34. [Twks] "wks",
  35. [Tptr] "ptr",
  36. [Thinfo] "hinfo",
  37. [Tminfo] "minfo",
  38. [Tmx] "mx",
  39. [Ttxt] "txt",
  40. [Trp] "rp",
  41. [Tafsdb] "afsdb",
  42. [Tx25] "x.25",
  43. [Tisdn] "isdn",
  44. [Trt] "rt",
  45. [Tnsap] "nsap",
  46. [Tnsapptr] "nsap-ptr",
  47. [Tsig] "sig",
  48. [Tkey] "key",
  49. [Tpx] "px",
  50. [Tgpos] "gpos",
  51. [Taaaa] "ipv6",
  52. [Tloc] "loc",
  53. [Tnxt] "nxt",
  54. [Teid] "eid",
  55. [Tnimloc] "nimrod",
  56. [Tsrv] "srv",
  57. [Tatma] "atma",
  58. [Tnaptr] "naptr",
  59. [Tkx] "kx",
  60. [Tcert] "cert",
  61. [Ta6] "a6",
  62. [Tdname] "dname",
  63. [Tsink] "sink",
  64. [Topt] "opt",
  65. [Tapl] "apl",
  66. [Tds] "ds",
  67. [Tsshfp] "sshfp",
  68. [Tipseckey] "ipseckey",
  69. [Trrsig] "rrsig",
  70. [Tnsec] "nsec",
  71. [Tdnskey] "dnskey",
  72. [Tspf] "spf",
  73. [Tuinfo] "uinfo",
  74. [Tuid] "uid",
  75. [Tgid] "gid",
  76. [Tunspec] "unspec",
  77. [Ttkey] "tkey",
  78. [Ttsig] "tsig",
  79. [Tixfr] "ixfr",
  80. [Taxfr] "axfr",
  81. [Tmailb] "mailb",
  82. [Tmaila] "maila",
  83. [Tall] "all",
  84. 0,
  85. };
  86. /* names of response codes */
  87. char *rname[Rmask+1] =
  88. {
  89. [Rok] "ok",
  90. [Rformat] "format error",
  91. [Rserver] "server failure",
  92. [Rname] "bad name",
  93. [Runimplimented] "unimplemented",
  94. [Rrefused] "we don't like you",
  95. [Ryxdomain] "name should not exist",
  96. [Ryxrrset] "rr set should not exist",
  97. [Rnxrrset] "rr set should exist",
  98. [Rnotauth] "not authorative",
  99. [Rnotzone] "not in zone",
  100. [Rbadvers] "bad opt version",
  101. /* [Rbadsig] "bad signature", */
  102. [Rbadkey] "bad key",
  103. [Rbadtime] "bad signature time",
  104. [Rbadmode] "bad mode",
  105. [Rbadname] "duplicate key name",
  106. [Rbadalg] "bad algorithm",
  107. };
  108. /* names of op codes */
  109. char *opname[] =
  110. {
  111. [Oquery] "query",
  112. [Oinverse] "inverse query (retired)",
  113. [Ostatus] "status",
  114. [Oupdate] "update",
  115. };
  116. Lock dnlock;
  117. static int sencodefmt(Fmt*);
  118. /*
  119. * set up a pipe to use as a lock
  120. */
  121. void
  122. dninit(void)
  123. {
  124. fmtinstall('E', eipfmt);
  125. fmtinstall('I', eipfmt);
  126. fmtinstall('V', eipfmt);
  127. fmtinstall('R', rrfmt);
  128. fmtinstall('Q', rravfmt);
  129. fmtinstall('H', sencodefmt);
  130. dnvars.oldest = maxage;
  131. dnvars.names = 0;
  132. }
  133. /*
  134. * hash for a domain name
  135. */
  136. static ulong
  137. dnhash(char *name)
  138. {
  139. ulong hash;
  140. uchar *val = (uchar*)name;
  141. for(hash = 0; *val; val++)
  142. hash = (hash*13) + tolower(*val)-'a';
  143. return hash % HTLEN;
  144. }
  145. /*
  146. * lookup a symbol. if enter is not zero and the name is
  147. * not found, create it.
  148. */
  149. DN*
  150. dnlookup(char *name, int class, int enter)
  151. {
  152. DN **l;
  153. DN *dp;
  154. l = &ht[dnhash(name)];
  155. lock(&dnlock);
  156. for(dp = *l; dp; dp = dp->next) {
  157. assert(dp->magic == DNmagic);
  158. if(dp->class == class && cistrcmp(dp->name, name) == 0){
  159. dp->referenced = now;
  160. unlock(&dnlock);
  161. return dp;
  162. }
  163. l = &dp->next;
  164. }
  165. if(enter == 0){
  166. unlock(&dnlock);
  167. return 0;
  168. }
  169. dnvars.names++;
  170. dp = emalloc(sizeof(*dp));
  171. dp->magic = DNmagic;
  172. dp->name = estrdup(name);
  173. assert(dp->name != 0);
  174. dp->class = class;
  175. dp->rr = 0;
  176. dp->next = 0;
  177. dp->referenced = now;
  178. *l = dp;
  179. unlock(&dnlock);
  180. return dp;
  181. }
  182. /*
  183. * dump the cache
  184. */
  185. void
  186. dndump(char *file)
  187. {
  188. DN *dp;
  189. int i, fd;
  190. RR *rp;
  191. fd = open(file, OWRITE|OTRUNC);
  192. if(fd < 0)
  193. return;
  194. lock(&dnlock);
  195. for(i = 0; i < HTLEN; i++){
  196. for(dp = ht[i]; dp; dp = dp->next){
  197. fprint(fd, "%s\n", dp->name);
  198. for(rp = dp->rr; rp; rp = rp->next)
  199. fprint(fd, " %R %c%c %lud/%lud\n", rp, rp->auth?'A':'U',
  200. rp->db?'D':'N', rp->expire, rp->ttl);
  201. }
  202. }
  203. unlock(&dnlock);
  204. close(fd);
  205. }
  206. /*
  207. * purge all records
  208. */
  209. void
  210. dnpurge(void)
  211. {
  212. DN *dp;
  213. RR *rp, *srp;
  214. int i;
  215. lock(&dnlock);
  216. for(i = 0; i < HTLEN; i++)
  217. for(dp = ht[i]; dp; dp = dp->next){
  218. srp = rp = dp->rr;
  219. dp->rr = nil;
  220. for(; rp != nil; rp = rp->next)
  221. rp->cached = 0;
  222. rrfreelist(srp);
  223. }
  224. unlock(&dnlock);
  225. }
  226. /*
  227. * check the age of resource records, free any that have timed out
  228. */
  229. void
  230. dnage(DN *dp)
  231. {
  232. RR **l;
  233. RR *rp, *next;
  234. ulong diff;
  235. diff = now - dp->referenced;
  236. if(diff < Reserved)
  237. return;
  238. l = &dp->rr;
  239. for(rp = dp->rr; rp; rp = next){
  240. assert(rp->magic == RRmagic && rp->cached);
  241. next = rp->next;
  242. if(!rp->db)
  243. if(rp->expire < now || diff > dnvars.oldest){
  244. *l = next;
  245. rp->cached = 0;
  246. rrfree(rp);
  247. continue;
  248. }
  249. l = &rp->next;
  250. }
  251. }
  252. #define REF(x) if(x) x->refs++
  253. /*
  254. * our target is 4000 names cached, this should be larger on large servers
  255. */
  256. #define TARGET 4000
  257. /*
  258. * periodicly sweep for old records and remove unreferenced domain names
  259. *
  260. * only called when all other threads are locked out
  261. */
  262. void
  263. dnageall(int doit)
  264. {
  265. DN *dp, **l;
  266. int i;
  267. RR *rp;
  268. static ulong nextage;
  269. if(dnvars.names < TARGET && now < nextage && !doit){
  270. dnvars.oldest = maxage;
  271. return;
  272. }
  273. if(dnvars.names > TARGET)
  274. dnvars.oldest /= 2;
  275. nextage = now + maxage;
  276. lock(&dnlock);
  277. /* time out all old entries (and set refs to 0) */
  278. for(i = 0; i < HTLEN; i++)
  279. for(dp = ht[i]; dp; dp = dp->next){
  280. dp->refs = 0;
  281. dnage(dp);
  282. }
  283. /* mark all referenced domain names */
  284. for(i = 0; i < HTLEN; i++)
  285. for(dp = ht[i]; dp; dp = dp->next)
  286. for(rp = dp->rr; rp; rp = rp->next){
  287. REF(rp->owner);
  288. if(rp->negative){
  289. REF(rp->negsoaowner);
  290. continue;
  291. }
  292. switch(rp->type){
  293. case Thinfo:
  294. REF(rp->cpu);
  295. REF(rp->os);
  296. break;
  297. case Ttxt:
  298. break;
  299. case Tcname:
  300. case Tmb:
  301. case Tmd:
  302. case Tmf:
  303. case Tns:
  304. REF(rp->host);
  305. break;
  306. case Tmg:
  307. case Tmr:
  308. REF(rp->mb);
  309. break;
  310. case Tminfo:
  311. REF(rp->rmb);
  312. REF(rp->mb);
  313. break;
  314. case Trp:
  315. REF(rp->rmb);
  316. REF(rp->rp);
  317. break;
  318. case Tmx:
  319. REF(rp->host);
  320. break;
  321. case Ta:
  322. case Taaaa:
  323. REF(rp->ip);
  324. break;
  325. case Tptr:
  326. REF(rp->ptr);
  327. break;
  328. case Tsoa:
  329. REF(rp->host);
  330. REF(rp->rmb);
  331. break;
  332. }
  333. }
  334. /* sweep and remove unreferenced domain names */
  335. for(i = 0; i < HTLEN; i++){
  336. l = &ht[i];
  337. for(dp = *l; dp; dp = *l){
  338. if(dp->rr == 0 && dp->refs == 0){
  339. assert(dp->magic == DNmagic);
  340. *l = dp->next;
  341. if(dp->name)
  342. free(dp->name);
  343. dp->magic = ~dp->magic;
  344. dnvars.names--;
  345. free(dp);
  346. continue;
  347. }
  348. l = &dp->next;
  349. }
  350. }
  351. unlock(&dnlock);
  352. }
  353. /*
  354. * timeout all database records (used when rereading db)
  355. */
  356. void
  357. dnagedb(void)
  358. {
  359. DN *dp;
  360. int i;
  361. RR *rp;
  362. static ulong nextage;
  363. lock(&dnlock);
  364. /* time out all database entries */
  365. for(i = 0; i < HTLEN; i++)
  366. for(dp = ht[i]; dp; dp = dp->next)
  367. for(rp = dp->rr; rp; rp = rp->next)
  368. if(rp->db)
  369. rp->expire = 0;
  370. unlock(&dnlock);
  371. }
  372. /*
  373. * mark all local db records about my area as authoritative, time out any others
  374. */
  375. void
  376. dnauthdb(void)
  377. {
  378. DN *dp;
  379. int i;
  380. Area *area;
  381. RR *rp;
  382. static ulong nextage;
  383. lock(&dnlock);
  384. /* time out all database entries */
  385. for(i = 0; i < HTLEN; i++)
  386. for(dp = ht[i]; dp; dp = dp->next){
  387. area = inmyarea(dp->name);
  388. for(rp = dp->rr; rp; rp = rp->next)
  389. if(rp->db){
  390. if(area){
  391. if(rp->ttl < area->soarr->soa->minttl)
  392. rp->ttl = area->soarr->soa->minttl;
  393. rp->auth = 1;
  394. }
  395. if(rp->expire == 0){
  396. rp->db = 0;
  397. dp->referenced = now - Reserved - 1;
  398. }
  399. }
  400. }
  401. unlock(&dnlock);
  402. }
  403. /*
  404. * keep track of other processes to know if we can
  405. * garbage collect. block while garbage collecting.
  406. */
  407. int
  408. getactivity(Request *req, int recursive)
  409. {
  410. int rv;
  411. if(traceactivity) syslog(0, "dns", "get %d by %d from %p", dnvars.active, getpid(), getcallerpc(&req));
  412. lock(&dnvars);
  413. /*
  414. * can't block here if we're already holding one
  415. * of the dnvars.active (recursive). will deadlock.
  416. */
  417. while(!recursive && dnvars.mutex){
  418. unlock(&dnvars);
  419. sleep(200);
  420. lock(&dnvars);
  421. }
  422. rv = ++dnvars.active;
  423. now = time(0);
  424. req->id = ++dnvars.id;
  425. unlock(&dnvars);
  426. return rv;
  427. }
  428. void
  429. putactivity(int recursive)
  430. {
  431. static ulong lastclean;
  432. if(traceactivity) syslog(0, "dns", "put %d by %d", dnvars.active, getpid());
  433. lock(&dnvars);
  434. dnvars.active--;
  435. assert(dnvars.active >= 0); /* "dnvars.active %d", dnvars.active */;
  436. /*
  437. * clean out old entries and check for new db periodicly
  438. * can't block here if being called to let go a "recursive" lock
  439. * or we'll deadlock waiting for ourselves to give up the dnvars.active.
  440. */
  441. if(recursive || dnvars.mutex || (needrefresh == 0 && dnvars.active > 0)){
  442. unlock(&dnvars);
  443. return;
  444. }
  445. /* wait till we're alone */
  446. dnvars.mutex = 1;
  447. while(dnvars.active > 0){
  448. unlock(&dnvars);
  449. sleep(100);
  450. lock(&dnvars);
  451. }
  452. unlock(&dnvars);
  453. db2cache(needrefresh);
  454. dnageall(0);
  455. /* let others back in */
  456. lastclean = now;
  457. needrefresh = 0;
  458. dnvars.mutex = 0;
  459. }
  460. /*
  461. * Attach a single resource record to a domain name.
  462. * - Avoid duplicates with already present RR's
  463. * - Chain all RR's of the same type adjacent to one another
  464. * - chain authoritative RR's ahead of non-authoritative ones
  465. */
  466. static void
  467. rrattach1(RR *new, int auth)
  468. {
  469. RR **l;
  470. RR *rp;
  471. DN *dp;
  472. assert(new->magic == RRmagic && !new->cached);
  473. if(!new->db)
  474. new->expire = new->ttl;
  475. else
  476. new->expire = now + Year;
  477. dp = new->owner;
  478. assert(dp->magic == DNmagic);
  479. new->auth |= auth;
  480. new->next = 0;
  481. /*
  482. * find first rr of the right type
  483. */
  484. l = &dp->rr;
  485. for(rp = *l; rp; rp = *l){
  486. assert(rp->magic == RRmagic && rp->cached);
  487. if(rp->type == new->type)
  488. break;
  489. l = &rp->next;
  490. }
  491. /*
  492. * negative entries replace positive entries
  493. * positive entries replace negative entries
  494. * newer entries replace older entries with the same fields
  495. */
  496. for(rp = *l; rp; rp = *l){
  497. assert(rp->magic == RRmagic && rp->cached);
  498. if(rp->type != new->type)
  499. break;
  500. if(rp->db == new->db && rp->auth == new->auth){
  501. /* negative drives out positive and vice versa */
  502. if(rp->negative != new->negative){
  503. *l = rp->next;
  504. rp->cached = 0;
  505. rrfree(rp);
  506. continue;
  507. }
  508. /* all things equal, pick the newer one */
  509. if(rp->arg0 == new->arg0 && rp->arg1 == new->arg1){
  510. /* new drives out old */
  511. if(new->ttl > rp->ttl || new->expire > rp->expire){
  512. *l = rp->next;
  513. rp->cached = 0;
  514. rrfree(rp);
  515. continue;
  516. } else {
  517. rrfree(new);
  518. return;
  519. }
  520. }
  521. /* Hack for pointer records. This makes sure
  522. * the ordering in the list reflects the ordering
  523. * received or read from the database
  524. */
  525. if(rp->type == Tptr){
  526. if(!rp->negative && !new->negative
  527. && rp->ptr->ordinal > new->ptr->ordinal)
  528. break;
  529. }
  530. }
  531. l = &rp->next;
  532. }
  533. /*
  534. * add to chain
  535. */
  536. new->cached = 1;
  537. new->next = *l;
  538. *l = new;
  539. }
  540. /*
  541. * Attach a list of resource records to a domain name.
  542. * - Avoid duplicates with already present RR's
  543. * - Chain all RR's of the same type adjacent to one another
  544. * - chain authoritative RR's ahead of non-authoritative ones
  545. * - remove any expired RR's
  546. */
  547. void
  548. rrattach(RR *rp, int auth)
  549. {
  550. RR *next;
  551. lock(&dnlock);
  552. for(; rp; rp = next){
  553. next = rp->next;
  554. rp->next = 0;
  555. /* avoid any outside spoofing */
  556. if(cachedb && !rp->db && inmyarea(rp->owner->name))
  557. rrfree(rp);
  558. else
  559. rrattach1(rp, auth);
  560. }
  561. unlock(&dnlock);
  562. }
  563. /*
  564. * allocate a resource record of a given type
  565. */
  566. RR*
  567. rralloc(int type)
  568. {
  569. RR *rp;
  570. rp = emalloc(sizeof(*rp));
  571. rp->magic = RRmagic;
  572. rp->pc = getcallerpc(&type);
  573. rp->type = type;
  574. switch(type){
  575. case Tsoa:
  576. rp->soa = emalloc(sizeof(*rp->soa));
  577. rp->soa->slaves = nil;
  578. break;
  579. case Tkey:
  580. rp->key = emalloc(sizeof(*rp->key));
  581. break;
  582. case Tcert:
  583. rp->cert = emalloc(sizeof(*rp->cert));
  584. break;
  585. case Tsig:
  586. rp->sig = emalloc(sizeof(*rp->sig));
  587. break;
  588. case Tnull:
  589. rp->null = emalloc(sizeof(*rp->null));
  590. break;
  591. }
  592. rp->ttl = 0;
  593. rp->expire = 0;
  594. rp->next = 0;
  595. return rp;
  596. }
  597. /*
  598. * free a resource record and any related structs
  599. */
  600. void
  601. rrfree(RR *rp)
  602. {
  603. DN *dp;
  604. RR *nrp;
  605. Txt *t;
  606. assert(rp->magic = RRmagic);
  607. assert(!rp->cached);
  608. dp = rp->owner;
  609. if(dp){
  610. assert(dp->magic == DNmagic);
  611. for(nrp = dp->rr; nrp; nrp = nrp->next)
  612. assert(nrp != rp); /* "rrfree of live rr" */;
  613. }
  614. switch(rp->type){
  615. case Tsoa:
  616. freeserverlist(rp->soa->slaves);
  617. free(rp->soa);
  618. break;
  619. case Tkey:
  620. free(rp->key->data);
  621. free(rp->key);
  622. break;
  623. case Tcert:
  624. free(rp->cert->data);
  625. free(rp->cert);
  626. break;
  627. case Tsig:
  628. free(rp->sig->data);
  629. free(rp->sig);
  630. break;
  631. case Tnull:
  632. free(rp->null->data);
  633. free(rp->null);
  634. break;
  635. case Ttxt:
  636. while(rp->txt != nil){
  637. t = rp->txt;
  638. rp->txt = t->next;
  639. free(t->p);
  640. free(t);
  641. }
  642. break;
  643. }
  644. rp->magic = ~rp->magic;
  645. free(rp);
  646. }
  647. /*
  648. * free a list of resource records and any related structs
  649. */
  650. void
  651. rrfreelist(RR *rp)
  652. {
  653. RR *next;
  654. for(; rp; rp = next){
  655. next = rp->next;
  656. rrfree(rp);
  657. }
  658. }
  659. extern RR**
  660. rrcopy(RR *rp, RR **last)
  661. {
  662. RR *nrp;
  663. SOA *soa;
  664. Key *key;
  665. Cert *cert;
  666. Sig *sig;
  667. Null *null;
  668. Txt *t, *nt, **l;
  669. nrp = rralloc(rp->type);
  670. switch(rp->type){
  671. case Ttxt:
  672. *nrp = *rp;
  673. l = &nrp->txt;
  674. *l = nil;
  675. for(t = rp->txt; t != nil; t = t->next){
  676. nt = emalloc(sizeof(*nt));
  677. nt->p = estrdup(t->p);
  678. nt->next = nil;
  679. *l = nt;
  680. l = &nt->next;
  681. }
  682. break;
  683. case Tsoa:
  684. soa = nrp->soa;
  685. *nrp = *rp;
  686. nrp->soa = soa;
  687. *nrp->soa = *rp->soa;
  688. nrp->soa->slaves = copyserverlist(rp->soa->slaves);
  689. break;
  690. case Tkey:
  691. key = nrp->key;
  692. *nrp = *rp;
  693. nrp->key = key;
  694. *key = *rp->key;
  695. key->data = emalloc(key->dlen);
  696. memmove(key->data, rp->key->data, rp->key->dlen);
  697. break;
  698. case Tsig:
  699. sig = nrp->sig;
  700. *nrp = *rp;
  701. nrp->sig = sig;
  702. *sig = *rp->sig;
  703. sig->data = emalloc(sig->dlen);
  704. memmove(sig->data, rp->sig->data, rp->sig->dlen);
  705. break;
  706. case Tcert:
  707. cert = nrp->cert;
  708. *nrp = *rp;
  709. nrp->cert = cert;
  710. *cert = *rp->cert;
  711. cert->data = emalloc(cert->dlen);
  712. memmove(cert->data, rp->cert->data, rp->cert->dlen);
  713. break;
  714. case Tnull:
  715. null = nrp->null;
  716. *nrp = *rp;
  717. nrp->null = null;
  718. *null = *rp->null;
  719. null->data = emalloc(null->dlen);
  720. memmove(null->data, rp->null->data, rp->null->dlen);
  721. break;
  722. default:
  723. *nrp = *rp;
  724. break;
  725. }
  726. nrp->cached = 0;
  727. nrp->next = 0;
  728. *last = nrp;
  729. return &nrp->next;
  730. }
  731. /*
  732. * lookup a resource record of a particular type and
  733. * class attached to a domain name. Return copies.
  734. *
  735. * Priority ordering is:
  736. * db authoritative
  737. * not timed out network authoritative
  738. * not timed out network unauthoritative
  739. * unauthoritative db
  740. *
  741. * if flag NOneg is set, don't return negative cached entries.
  742. * return nothing instead.
  743. */
  744. RR*
  745. rrlookup(DN *dp, int type, int flag)
  746. {
  747. RR *rp, *first, **last;
  748. assert(dp->magic == DNmagic);
  749. first = 0;
  750. last = &first;
  751. lock(&dnlock);
  752. /* try for an authoritative db entry */
  753. for(rp = dp->rr; rp; rp = rp->next){
  754. assert(rp->magic == RRmagic && rp->cached);
  755. if(rp->db)
  756. if(rp->auth)
  757. if(tsame(type, rp->type))
  758. last = rrcopy(rp, last);
  759. }
  760. if(first)
  761. goto out;
  762. /* try for an living authoritative network entry */
  763. for(rp = dp->rr; rp; rp = rp->next){
  764. if(!rp->db)
  765. if(rp->auth)
  766. if(rp->ttl + 60 > now)
  767. if(tsame(type, rp->type)){
  768. if(flag == NOneg && rp->negative)
  769. goto out;
  770. last = rrcopy(rp, last);
  771. }
  772. }
  773. if(first)
  774. goto out;
  775. /* try for an living unauthoritative network entry */
  776. for(rp = dp->rr; rp; rp = rp->next){
  777. if(!rp->db)
  778. if(rp->ttl + 60 > now)
  779. if(tsame(type, rp->type)){
  780. if(flag == NOneg && rp->negative)
  781. goto out;
  782. last = rrcopy(rp, last);
  783. }
  784. }
  785. if(first)
  786. goto out;
  787. /* try for an unauthoritative db entry */
  788. for(rp = dp->rr; rp; rp = rp->next){
  789. if(rp->db)
  790. if(tsame(type, rp->type))
  791. last = rrcopy(rp, last);
  792. }
  793. if(first)
  794. goto out;
  795. /* otherwise, settle for anything we got (except for negative caches) */
  796. for(rp = dp->rr; rp; rp = rp->next){
  797. if(tsame(type, rp->type)){
  798. if(rp->negative)
  799. goto out;
  800. last = rrcopy(rp, last);
  801. }
  802. }
  803. out:
  804. unlock(&dnlock);
  805. unique(first);
  806. return first;
  807. }
  808. /*
  809. * convert an ascii RR type name to its integer representation
  810. */
  811. int
  812. rrtype(char *atype)
  813. {
  814. int i;
  815. for(i = 0; i <= Tall; i++)
  816. if(rrtname[i] && strcmp(rrtname[i], atype) == 0)
  817. return i;
  818. // make any a synonym for all
  819. if(strcmp(atype, "any") == 0)
  820. return Tall;
  821. return atoi(atype);
  822. }
  823. /*
  824. * convert an integer RR type to it's ascii name
  825. */
  826. char*
  827. rrname(int type, char *buf, int len)
  828. {
  829. char *t;
  830. t = 0;
  831. if(type <= Tall)
  832. t = rrtname[type];
  833. if(t==0){
  834. snprint(buf, len, "%d", type);
  835. t = buf;
  836. }
  837. return t;
  838. }
  839. /*
  840. * return 0 if not a supported rr type
  841. */
  842. int
  843. rrsupported(int type)
  844. {
  845. if(type < 0 || type >Tall)
  846. return 0;
  847. return rrtname[type] != 0;
  848. }
  849. /*
  850. * compare 2 types
  851. */
  852. int
  853. tsame(int t1, int t2)
  854. {
  855. return t1 == t2 || t1 == Tall;
  856. }
  857. /*
  858. * Add resource records to a list, duplicate them if they are cached
  859. * RR's since these are shared.
  860. */
  861. RR*
  862. rrcat(RR **start, RR *rp)
  863. {
  864. RR **last;
  865. last = start;
  866. while(*last != 0)
  867. last = &(*last)->next;
  868. *last = rp;
  869. return *start;
  870. }
  871. /*
  872. * remove negative cache rr's from an rr list
  873. */
  874. RR*
  875. rrremneg(RR **l)
  876. {
  877. RR **nl, *rp;
  878. RR *first;
  879. first = nil;
  880. nl = &first;
  881. while(*l != nil){
  882. rp = *l;
  883. if(rp->negative){
  884. *l = rp->next;
  885. *nl = rp;
  886. nl = &rp->next;
  887. *nl = nil;
  888. } else
  889. l = &rp->next;
  890. }
  891. return first;
  892. }
  893. /*
  894. * remove rr's of a particular type from an rr list
  895. */
  896. RR*
  897. rrremtype(RR **l, int type)
  898. {
  899. RR **nl, *rp;
  900. RR *first;
  901. first = nil;
  902. nl = &first;
  903. while(*l != nil){
  904. rp = *l;
  905. if(rp->type == type){
  906. *l = rp->next;
  907. *nl = rp;
  908. nl = &rp->next;
  909. *nl = nil;
  910. } else
  911. l = &(*l)->next;
  912. }
  913. return first;
  914. }
  915. /*
  916. * print conversion for rr records
  917. */
  918. int
  919. rrfmt(Fmt *f)
  920. {
  921. RR *rp;
  922. char *strp;
  923. Fmt fstr;
  924. int rv;
  925. char buf[Domlen];
  926. Server *s;
  927. Txt *t;
  928. fmtstrinit(&fstr);
  929. rp = va_arg(f->args, RR*);
  930. if(rp == 0){
  931. fmtprint(&fstr, "<null>");
  932. goto out;
  933. }
  934. fmtprint(&fstr, "%s %s", rp->owner->name,
  935. rrname(rp->type, buf, sizeof buf));
  936. if(rp->negative){
  937. fmtprint(&fstr, "\tnegative - rcode %d", rp->negrcode);
  938. goto out;
  939. }
  940. switch(rp->type){
  941. case Thinfo:
  942. fmtprint(&fstr, "\t%s %s", rp->cpu->name, rp->os->name);
  943. break;
  944. case Tcname:
  945. case Tmb:
  946. case Tmd:
  947. case Tmf:
  948. case Tns:
  949. fmtprint(&fstr, "\t%s", rp->host->name);
  950. break;
  951. case Tmg:
  952. case Tmr:
  953. fmtprint(&fstr, "\t%s", rp->mb->name);
  954. break;
  955. case Tminfo:
  956. fmtprint(&fstr, "\t%s %s", rp->mb->name, rp->rmb->name);
  957. break;
  958. case Tmx:
  959. fmtprint(&fstr, "\t%lud %s", rp->pref, rp->host->name);
  960. break;
  961. case Ta:
  962. case Taaaa:
  963. fmtprint(&fstr, "\t%s", rp->ip->name);
  964. break;
  965. case Tptr:
  966. // fmtprint(&fstr, "\t%s(%lud)", rp->ptr->name, rp->ptr->ordinal);
  967. fmtprint(&fstr, "\t%s", rp->ptr->name);
  968. break;
  969. case Tsoa:
  970. fmtprint(&fstr, "\t%s %s %lud %lud %lud %lud %lud", rp->host->name,
  971. rp->rmb->name, rp->soa->serial, rp->soa->refresh, rp->soa->retry,
  972. rp->soa->expire, rp->soa->minttl);
  973. for(s = rp->soa->slaves; s != nil; s = s->next)
  974. fmtprint(&fstr, " %s", s->name);
  975. break;
  976. case Tnull:
  977. fmtprint(&fstr, "\t%.*H", rp->null->dlen, rp->null->data);
  978. break;
  979. case Ttxt:
  980. fmtprint(&fstr, "\t");
  981. for(t = rp->txt; t != nil; t = t->next)
  982. fmtprint(&fstr, "%s", t->p);
  983. break;
  984. case Trp:
  985. fmtprint(&fstr, "\t%s %s", rp->rmb->name, rp->rp->name);
  986. break;
  987. case Tkey:
  988. fmtprint(&fstr, "\t%d %d %d", rp->key->flags, rp->key->proto,
  989. rp->key->alg);
  990. break;
  991. case Tsig:
  992. fmtprint(&fstr, "\t%d %d %d %lud %lud %lud %d %s",
  993. rp->sig->type, rp->sig->alg, rp->sig->labels, rp->sig->ttl,
  994. rp->sig->exp, rp->sig->incep, rp->sig->tag, rp->sig->signer->name);
  995. break;
  996. case Tcert:
  997. fmtprint(&fstr, "\t%d %d %d",
  998. rp->sig->type, rp->sig->tag, rp->sig->alg);
  999. break;
  1000. default:
  1001. break;
  1002. }
  1003. out:
  1004. strp = fmtstrflush(&fstr);
  1005. rv = fmtstrcpy(f, strp);
  1006. free(strp);
  1007. return rv;
  1008. }
  1009. /*
  1010. * print conversion for rr records in attribute value form
  1011. */
  1012. int
  1013. rravfmt(Fmt *f)
  1014. {
  1015. RR *rp;
  1016. char *strp;
  1017. Fmt fstr;
  1018. int rv;
  1019. Server *s;
  1020. Txt *t;
  1021. int quote;
  1022. fmtstrinit(&fstr);
  1023. rp = va_arg(f->args, RR*);
  1024. if(rp == 0){
  1025. fmtprint(&fstr, "<null>");
  1026. goto out;
  1027. }
  1028. if(rp->type == Tptr)
  1029. fmtprint(&fstr, "ptr=%s", rp->owner->name);
  1030. else
  1031. fmtprint(&fstr, "dom=%s", rp->owner->name);
  1032. switch(rp->type){
  1033. case Thinfo:
  1034. fmtprint(&fstr, " cpu=%s os=%s", rp->cpu->name, rp->os->name);
  1035. break;
  1036. case Tcname:
  1037. fmtprint(&fstr, " cname=%s", rp->host->name);
  1038. break;
  1039. case Tmb:
  1040. case Tmd:
  1041. case Tmf:
  1042. fmtprint(&fstr, " mbox=%s", rp->host->name);
  1043. break;
  1044. case Tns:
  1045. fmtprint(&fstr, " ns=%s", rp->host->name);
  1046. break;
  1047. case Tmg:
  1048. case Tmr:
  1049. fmtprint(&fstr, " mbox=%s", rp->mb->name);
  1050. break;
  1051. case Tminfo:
  1052. fmtprint(&fstr, " mbox=%s mbox=%s", rp->mb->name, rp->rmb->name);
  1053. break;
  1054. case Tmx:
  1055. fmtprint(&fstr, " pref=%lud mx=%s", rp->pref, rp->host->name);
  1056. break;
  1057. case Ta:
  1058. case Taaaa:
  1059. fmtprint(&fstr, " ip=%s", rp->ip->name);
  1060. break;
  1061. case Tptr:
  1062. fmtprint(&fstr, " dom=%s", rp->ptr->name);
  1063. break;
  1064. case Tsoa:
  1065. fmtprint(&fstr, " ns=%s mbox=%s serial=%lud refresh=%lud retry=%lud expire=%lud ttl=%lud",
  1066. rp->host->name, rp->rmb->name, rp->soa->serial,
  1067. rp->soa->refresh, rp->soa->retry,
  1068. rp->soa->expire, rp->soa->minttl);
  1069. for(s = rp->soa->slaves; s != nil; s = s->next)
  1070. fmtprint(&fstr, " dnsslave=%s", s->name);
  1071. break;
  1072. case Tnull:
  1073. fmtprint(&fstr, " null=%.*H", rp->null->dlen, rp->null->data);
  1074. break;
  1075. case Ttxt:
  1076. fmtprint(&fstr, " txt=");
  1077. quote = 0;
  1078. for(t = rp->txt; t != nil; t = t->next)
  1079. if(strchr(t->p, ' '))
  1080. quote = 1;
  1081. if(quote)
  1082. fmtprint(&fstr, "\"");
  1083. for(t = rp->txt; t != nil; t = t->next)
  1084. fmtprint(&fstr, "%s", t->p);
  1085. if(quote)
  1086. fmtprint(&fstr, "\"");
  1087. break;
  1088. case Trp:
  1089. fmtprint(&fstr, " rp=%s txt=%s", rp->rmb->name, rp->rp->name);
  1090. break;
  1091. case Tkey:
  1092. fmtprint(&fstr, " flags=%d proto=%d alg=%d",
  1093. rp->key->flags, rp->key->proto, rp->key->alg);
  1094. break;
  1095. case Tsig:
  1096. fmtprint(&fstr, " type=%d alg=%d labels=%d ttl=%lud exp=%lud incep=%lud tag=%d signer=%s",
  1097. rp->sig->type, rp->sig->alg, rp->sig->labels, rp->sig->ttl,
  1098. rp->sig->exp, rp->sig->incep, rp->sig->tag, rp->sig->signer->name);
  1099. break;
  1100. case Tcert:
  1101. fmtprint(&fstr, " type=%d tag=%d alg=%d",
  1102. rp->sig->type, rp->sig->tag, rp->sig->alg);
  1103. break;
  1104. default:
  1105. break;
  1106. }
  1107. out:
  1108. strp = fmtstrflush(&fstr);
  1109. rv = fmtstrcpy(f, strp);
  1110. free(strp);
  1111. return rv;
  1112. }
  1113. void
  1114. warning(char *fmt, ...)
  1115. {
  1116. char dnserr[128];
  1117. va_list arg;
  1118. va_start(arg, fmt);
  1119. vseprint(dnserr, dnserr+sizeof(dnserr), fmt, arg);
  1120. va_end(arg);
  1121. syslog(1, "dns", dnserr);
  1122. }
  1123. /*
  1124. * create a slave process to handle a request to avoid one request blocking
  1125. * another
  1126. */
  1127. void
  1128. slave(Request *req)
  1129. {
  1130. static int slaveid;
  1131. int ppid;
  1132. if(req->isslave)
  1133. return; /* we're already a slave process */
  1134. /*
  1135. * These calls to putactivity cannot block.
  1136. * After getactivity(), the current process is counted
  1137. * twice in dnvars.active (one will pass to the child).
  1138. * If putactivity tries to wait for dnvars.active == 0,
  1139. * it will never happen.
  1140. */
  1141. /* limit parallelism */
  1142. if(getactivity(req, 1) > Maxactive){
  1143. if(traceactivity) syslog(0, "dns", "[%d] too much activity", getpid());
  1144. putactivity(1);
  1145. return;
  1146. }
  1147. ppid = getpid();
  1148. switch(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT)){
  1149. case -1:
  1150. putactivity(1);
  1151. break;
  1152. case 0:
  1153. if(traceactivity) syslog(0, "dns", "[%d] take activity from %d", ppid, getpid());
  1154. req->isslave = 1;
  1155. break;
  1156. default:
  1157. longjmp(req->mret, 1);
  1158. }
  1159. }
  1160. /*
  1161. * chasing down double free's
  1162. */
  1163. void
  1164. dncheck(void *p, int dolock)
  1165. {
  1166. int i;
  1167. DN *dp;
  1168. RR *rp;
  1169. extern Pool *mainmem;
  1170. if(p != nil){
  1171. dp = p;
  1172. assert(dp->magic == DNmagic);
  1173. }
  1174. if(!testing)
  1175. return;
  1176. if(dolock)
  1177. lock(&dnlock);
  1178. poolcheck(mainmem);
  1179. for(i = 0; i < HTLEN; i++)
  1180. for(dp = ht[i]; dp; dp = dp->next){
  1181. assert(dp != p);
  1182. assert(dp->magic == DNmagic);
  1183. for(rp = dp->rr; rp; rp = rp->next){
  1184. assert(rp->magic == RRmagic);
  1185. assert(rp->cached);
  1186. assert(rp->owner == dp);
  1187. }
  1188. }
  1189. if(dolock)
  1190. unlock(&dnlock);
  1191. }
  1192. static int
  1193. rrequiv(RR *r1, RR *r2)
  1194. {
  1195. return r1->owner == r2->owner
  1196. && r1->type == r2->type
  1197. && r1->arg0 == r2->arg0
  1198. && r1->arg1 == r2->arg1;
  1199. }
  1200. void
  1201. unique(RR *rp)
  1202. {
  1203. RR **l, *nrp;
  1204. for(; rp; rp = rp->next){
  1205. l = &rp->next;
  1206. for(nrp = *l; nrp; nrp = *l){
  1207. if(rrequiv(rp, nrp)){
  1208. *l = nrp->next;
  1209. rrfree(nrp);
  1210. } else
  1211. l = &nrp->next;
  1212. }
  1213. }
  1214. }
  1215. /*
  1216. * true if second domain is subsumed by the first
  1217. */
  1218. int
  1219. subsume(char *higher, char *lower)
  1220. {
  1221. int hn, ln;
  1222. ln = strlen(lower);
  1223. hn = strlen(higher);
  1224. if(ln < hn)
  1225. return 0;
  1226. if(cistrcmp(lower + ln - hn, higher) != 0)
  1227. return 0;
  1228. if(ln > hn && hn != 0 && lower[ln - hn - 1] != '.')
  1229. return 0;
  1230. return 1;
  1231. }
  1232. /*
  1233. * randomize the order we return items to provide some
  1234. * load balancing for servers.
  1235. *
  1236. * only randomize the first class of entries
  1237. */
  1238. RR*
  1239. randomize(RR *rp)
  1240. {
  1241. RR *first, *last, *x, *base;
  1242. ulong n;
  1243. if(rp == nil || rp->next == nil)
  1244. return rp;
  1245. /* just randomize addresses and mx's */
  1246. for(x = rp; x; x = x->next)
  1247. if(x->type != Ta && x->type != Tmx && x->type != Tns)
  1248. return rp;
  1249. base = rp;
  1250. n = rand();
  1251. last = first = nil;
  1252. while(rp != nil){
  1253. /* stop randomizing if we've moved past our class */
  1254. if(base->auth != rp->auth || base->db != rp->db){
  1255. last->next = rp;
  1256. break;
  1257. }
  1258. /* unchain */
  1259. x = rp;
  1260. rp = x->next;
  1261. x->next = nil;
  1262. if(n&1){
  1263. /* add to tail */
  1264. if(last == nil)
  1265. first = x;
  1266. else
  1267. last->next = x;
  1268. last = x;
  1269. } else {
  1270. /* add to head */
  1271. if(last == nil)
  1272. last = x;
  1273. x->next = first;
  1274. first = x;
  1275. }
  1276. /* reroll the dice */
  1277. n >>= 1;
  1278. }
  1279. return first;
  1280. }
  1281. static int
  1282. sencodefmt(Fmt *f)
  1283. {
  1284. char *out;
  1285. char *buf;
  1286. int i, len;
  1287. int ilen;
  1288. int rv;
  1289. uchar *b;
  1290. char obuf[64]; // rsc optimization
  1291. if(!(f->flags&FmtPrec) || f->prec < 1)
  1292. goto error;
  1293. b = va_arg(f->args, uchar*);
  1294. if(b == nil)
  1295. goto error;
  1296. /* if it's a printable, go for it */
  1297. len = f->prec;
  1298. for(i = 0; i < len; i++)
  1299. if(!isprint(b[i]))
  1300. break;
  1301. if(i == len){
  1302. if(len >= sizeof obuf)
  1303. len = sizeof(obuf)-1;
  1304. memmove(obuf, b, len);
  1305. obuf[len] = 0;
  1306. fmtstrcpy(f, obuf);
  1307. return 0;
  1308. }
  1309. ilen = f->prec;
  1310. f->prec = 0;
  1311. f->flags &= ~FmtPrec;
  1312. switch(f->r){
  1313. case '<':
  1314. len = (8*ilen+4)/5 + 3;
  1315. break;
  1316. case '[':
  1317. len = (8*ilen+5)/6 + 4;
  1318. break;
  1319. case 'H':
  1320. len = 2*ilen + 1;
  1321. break;
  1322. default:
  1323. goto error;
  1324. }
  1325. if(len > sizeof(obuf)){
  1326. buf = malloc(len);
  1327. if(buf == nil)
  1328. goto error;
  1329. } else
  1330. buf = obuf;
  1331. // convert
  1332. out = buf;
  1333. switch(f->r){
  1334. case '<':
  1335. rv = enc32(out, len, b, ilen);
  1336. break;
  1337. case '[':
  1338. rv = enc64(out, len, b, ilen);
  1339. break;
  1340. case 'H':
  1341. rv = enc16(out, len, b, ilen);
  1342. break;
  1343. default:
  1344. rv = -1;
  1345. break;
  1346. }
  1347. if(rv < 0)
  1348. goto error;
  1349. fmtstrcpy(f, buf);
  1350. if(buf != obuf)
  1351. free(buf);
  1352. return 0;
  1353. error:
  1354. return fmtstrcpy(f, "<encodefmt>");
  1355. }
  1356. void*
  1357. emalloc(int size)
  1358. {
  1359. char *x;
  1360. x = mallocz(size, 1);
  1361. if(x == nil)
  1362. abort();
  1363. setmalloctag(x, getcallerpc(&size));
  1364. return x;
  1365. }
  1366. char*
  1367. estrdup(char *s)
  1368. {
  1369. int size;
  1370. char *p;
  1371. size = strlen(s)+1;
  1372. p = mallocz(size, 0);
  1373. if(p == nil)
  1374. abort();
  1375. memmove(p, s, size);
  1376. setmalloctag(p, getcallerpc(&s));
  1377. return p;
  1378. }
  1379. /*
  1380. * create a pointer record
  1381. */
  1382. static RR*
  1383. mkptr(DN *dp, char *ptr, ulong ttl)
  1384. {
  1385. DN *ipdp;
  1386. RR *rp;
  1387. ipdp = dnlookup(ptr, Cin, 1);
  1388. rp = rralloc(Tptr);
  1389. rp->ptr = dp;
  1390. rp->owner = ipdp;
  1391. rp->db = 1;
  1392. if(ttl)
  1393. rp->ttl = ttl;
  1394. return rp;
  1395. }
  1396. /*
  1397. * look for all ip addresses in this network and make
  1398. * pointer records for them.
  1399. */
  1400. void
  1401. dnptr(uchar *net, uchar *mask, char *dom, int bytes, int ttl)
  1402. {
  1403. int i, j;
  1404. DN *dp;
  1405. RR *rp, *nrp, *first, **l;
  1406. uchar ip[IPaddrlen];
  1407. uchar nnet[IPaddrlen];
  1408. char ptr[Domlen];
  1409. char *p, *e;
  1410. l = &first;
  1411. first = nil;
  1412. for(i = 0; i < HTLEN; i++){
  1413. for(dp = ht[i]; dp; dp = dp->next){
  1414. for(rp = dp->rr; rp; rp = rp->next){
  1415. if(rp->type != Ta || rp->negative)
  1416. continue;
  1417. parseip(ip, rp->ip->name);
  1418. maskip(ip, mask, nnet);
  1419. if(ipcmp(net, nnet) != 0)
  1420. continue;
  1421. p = ptr;
  1422. e = ptr+sizeof(ptr);
  1423. for(j = IPaddrlen-1; j >= IPaddrlen-bytes; j--)
  1424. p = seprint(p, e, "%d.", ip[j]);
  1425. seprint(p, e, "%s", dom);
  1426. nrp = mkptr(dp, ptr, ttl);
  1427. *l = nrp;
  1428. l = &nrp->next;
  1429. }
  1430. }
  1431. }
  1432. for(rp = first; rp != nil; rp = nrp){
  1433. nrp = rp->next;
  1434. rp->next = nil;
  1435. rrattach(rp, 1);
  1436. }
  1437. }
  1438. void
  1439. freeserverlist(Server *s)
  1440. {
  1441. Server *next;
  1442. for(; s != nil; s = next){
  1443. next = s->next;
  1444. free(s);
  1445. }
  1446. }
  1447. void
  1448. addserver(Server **l, char *name)
  1449. {
  1450. Server *s;
  1451. while(*l)
  1452. l = &(*l)->next;
  1453. s = malloc(sizeof(Server)+strlen(name)+1);
  1454. if(s == nil)
  1455. return;
  1456. s->name = (char*)(s+1);
  1457. strcpy(s->name, name);
  1458. s->next = nil;
  1459. *l = s;
  1460. }
  1461. Server*
  1462. copyserverlist(Server *s)
  1463. {
  1464. Server *ns;
  1465. for(ns = nil; s != nil; s = s->next)
  1466. addserver(&ns, s->name);
  1467. return ns;
  1468. }