dn.c 37 KB

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