1 #include <u.h>
2 #include <libc.h>
3 #include <auth.h>
4 #include <fcall.h>
5 #include <bio.h>
6 #include <ctype.h>
7 #include <ip.h>
8 #include <ndb.h>
9 #include <thread.h>
10 #include "dns.h"
11 
12 enum
13 {
14 	Maxrequest=		1024,
15 	Ncache=			8,
16 	Maxpath=		128,
17 	Maxreply=		512,
18 	Maxrrr=			16,
19 	Maxfdata=		8192,
20 
21 	Qdir=			0,
22 	Qdns=			1
23 };
24 
25 typedef struct Mfile	Mfile;
26 typedef struct Job	Job;
27 typedef struct Network	Network;
28 
29 int vers;		/* incremented each clone/attach */
30 
31 struct Mfile
32 {
33 	Mfile		*next;		/* next free mfile */
34 	int		ref;
35 
36 	char		*user;
37 	Qid		qid;
38 	int		fid;
39 
40 	int		type;		/* reply type */
41 	char		reply[Maxreply];
42 	ushort		rr[Maxrrr];	/* offset of rr's */
43 	ushort		nrr;		/* number of rr's */
44 };
45 
46 /*
47  * active local requests
48  */
49 struct Job
50 {
51 	Job	*next;
52 	int	flushed;
53 	Fcall	request;
54 	Fcall	reply;
55 };
56 Lock	joblock;
57 Job	*joblist;
58 
59 struct {
60 	Lock	lk;
61 	Mfile	*inuse;		/* active mfile's */
62 } mfalloc;
63 
64 int	mfd[2];
65 int	debug;
66 int traceactivity;
67 int	cachedb;
68 ulong	now;
69 int	testing;
70 char	*trace;
71 int	needrefresh;
72 int	resolver;
73 uchar	ipaddr[IPaddrlen];	/* my ip address */
74 int	maxage;
75 char	*zonerefreshprogram;
76 int	sendnotifies;
77 
78 void	rversion(Job*);
79 void	rauth(Job*);
80 void	rflush(Job*);
81 void	rattach(Job*, Mfile*);
82 char*	rwalk(Job*, Mfile*);
83 void	ropen(Job*, Mfile*);
84 void	rcreate(Job*, Mfile*);
85 void	rread(Job*, Mfile*);
86 void	rwrite(Job*, Mfile*, Request*);
87 void	rclunk(Job*, Mfile*);
88 void	rremove(Job*, Mfile*);
89 void	rstat(Job*, Mfile*);
90 void	rwstat(Job*, Mfile*);
91 void	sendmsg(Job*, char*);
92 void	mountinit(char*);
93 void	io(void);
94 int	fillreply(Mfile*, int);
95 Job*	newjob(void);
96 void	freejob(Job*);
97 void	setext(char*, int, char*);
98 
99 char *tcpaddr = "tcp!*!domain";
100 char *udpaddr = "udp!*!domain";
101 char	*logfile = "dns";
102 char	*dbfile;
103 char	mntpt[Maxpath];
104 char	*LOG;
105 
106 void
107 usage(void)
108 {
109 	fprint(2, "usage: dns [-dnrst] [-a maxage] [-f ndb-file] [-T tcpaddr] [-U udpaddr] [-x service] [-z zoneprog]\n");
110 	threadexitsall("usage");
111 }
112 
113 void
114 checkaddress(void)
115 {
116 	char *u, *t;
117 
118 	u = strchr(udpaddr, '!');
119 	t = strchr(tcpaddr, '!');
120 	if(u && t && strcmp(u, t) != 0)
121 		fprint(2, "warning: announce mismatch %s %s\n", udpaddr, tcpaddr);
122 }
123 
124 void
125 threadmain(int argc, char *argv[])
126 {
127 	int serveudp, servetcp;
128 	char *service;
129 
130 	serveudp = 0;
131 	servetcp = 0;
132 	service = "dns";
133 	ARGBEGIN{
134 	case 'd':
135 		debug = 1;
136 		traceactivity = 1;
137 		break;
138 	case 'f':
139 		dbfile = EARGF(usage());
140 		break;
141 	case 'x':
142 		service = EARGF(usage());
143 		break;
144 	case 'r':
145 		resolver = 1;
146 		break;
147 	case 's':
148 		serveudp = 1;
149 		cachedb = 1;
150 		break;
151 	case 't':
152 		servetcp = 1;
153 		cachedb = 1;
154 		break;
155 	case 'a':
156 		maxage = atoi(EARGF(usage()));
157 		break;
158 	case 'z':
159 		zonerefreshprogram = EARGF(usage());
160 		break;
161 	case 'n':
162 		sendnotifies = 1;
163 		break;
164 	case 'U':
165 		udpaddr = estrdup(netmkaddr(EARGF(usage()), "udp", "domain"));
166 		break;
167 	case 'T':
168 		tcpaddr = estrdup(netmkaddr(EARGF(usage()), "tcp", "domain"));
169 		break;
170 	default:
171 		usage();
172 	}ARGEND
173 	
174 	if(argc)
175 		usage();
176 	if(serveudp && servetcp)
177 		checkaddress();
178 
179 	rfork(RFNOTEG);
180 
181 	/* start syslog before we fork */
182 	fmtinstall('F', fcallfmt);
183 	dninit();
184 	if(myipaddr(ipaddr, mntpt) < 0)
185 		sysfatal("can't read my ip address");
186 
187 	syslog(0, logfile, "starting dns on %I", ipaddr);
188 
189 	opendatabase();
190 
191 	mountinit(service);
192 
193 	now = time(0);
194 	srand(now*getpid());
195 	db2cache(1);
196 
197 	if(serveudp)
198 		proccreate(dnudpserver, nil, STACK);
199 	if(servetcp)
200 		proccreate(dntcpserver, nil, STACK);
201 	if(sendnotifies)
202 		proccreate(notifyproc, nil, STACK);
203 
204 	io();
205 }
206 
207 /*
208  *  if a mount point is specified, set the cs extention to be the mount point
209  *  with '_'s replacing '/'s
210  */
211 void
212 setext(char *ext, int n, char *p)
213 {
214 	int i, c;
215 
216 	n--;
217 	for(i = 0; i < n; i++){
218 		c = p[i];
219 		if(c == 0)
220 			break;
221 		if(c == '/')
222 			c = '_';
223 		ext[i] = c;
224 	}
225 	ext[i] = 0;
226 }
227 
228 void
229 mountinit(char *service)
230 {
231 	int p[2];
232 
233 	if(pipe(p) < 0)
234 		abort(); /* "pipe failed" */;
235 	if(post9pservice(p[1], service) < 0)
236 		fprint(2, "post9pservice dns: %r\n");
237 	close(p[1]);
238 	mfd[0] = mfd[1] = p[0];
239 }
240 
241 Mfile*
242 newfid(int fid, int needunused)
243 {
244 	Mfile *mf;
245 
246 	lock(&mfalloc.lk);
247 	for(mf = mfalloc.inuse; mf != nil; mf = mf->next){
248 		if(mf->fid == fid){
249 			unlock(&mfalloc.lk);
250 			if(needunused)
251 				return nil;
252 			return mf;
253 		}
254 	}
255 	if(!needunused){
256 		unlock(&mfalloc.lk);
257 		return nil;
258 	}
259 	mf = emalloc(sizeof(*mf));
260 	if(mf == nil)
261 		sysfatal("out of memory");
262 	mf->fid = fid;
263 	mf->next = mfalloc.inuse;
264 	mfalloc.inuse = mf;
265 	unlock(&mfalloc.lk);
266 	return mf;
267 }
268 
269 void
270 freefid(Mfile *mf)
271 {
272 	Mfile **l;
273 
274 	lock(&mfalloc.lk);
275 	for(l = &mfalloc.inuse; *l != nil; l = &(*l)->next){
276 		if(*l == mf){
277 			*l = mf->next;
278 			if(mf->user)
279 				free(mf->user);
280 			free(mf);
281 			unlock(&mfalloc.lk);
282 			return;
283 		}
284 	}
285 	sysfatal("freeing unused fid");
286 }
287 
288 Mfile*
289 copyfid(Mfile *mf, int fid)
290 {
291 	Mfile *nmf;
292 
293 	nmf = newfid(fid, 1);
294 	if(nmf == nil)
295 		return nil;
296 	nmf->fid = fid;
297 	nmf->user = estrdup(mf->user);
298 	nmf->qid.type = mf->qid.type;
299 	nmf->qid.path = mf->qid.path;
300 	nmf->qid.vers = vers++;
301 	return nmf;
302 }
303 
304 Job*
305 newjob(void)
306 {
307 	Job *job;
308 
309 	job = emalloc(sizeof(*job));
310 	lock(&joblock);
311 	job->next = joblist;
312 	joblist = job;
313 	job->request.tag = -1;
314 	unlock(&joblock);
315 	return job;
316 }
317 
318 void
319 freejob(Job *job)
320 {
321 	Job **l;
322 
323 	lock(&joblock);
324 	for(l = &joblist; *l; l = &(*l)->next){
325 		if((*l) == job){
326 			*l = job->next;
327 			free(job);
328 			break;
329 		}
330 	}
331 	unlock(&joblock);
332 }
333 
334 void
335 flushjob(int tag)
336 {
337 	Job *job;
338 
339 	lock(&joblock);
340 	for(job = joblist; job; job = job->next){
341 		if(job->request.tag == tag && job->request.type != Tflush){
342 			job->flushed = 1;
343 			break;
344 		}
345 	}
346 	unlock(&joblock);
347 }
348 
349 void
350 ioproc0(void *v)
351 {
352 	long n;
353 	Mfile *mf;
354 	uchar mdata[IOHDRSZ + Maxfdata];
355 	Request req;
356 	Job *job;
357 
358 	USED(v);
359 
360 	for(;;){
361 		n = read9pmsg(mfd[0], mdata, sizeof mdata);
362 		if(n <= 0){
363 			syslog(0, logfile, "error reading mntpt: %r");
364 			break;
365 		}
366 		job = newjob();
367 		if(convM2S(mdata, n, &job->request) != n){
368 			freejob(job);
369 			continue;
370 		}
371 		if(debug)
372 			syslog(0, logfile, "%F", &job->request);
373 
374 		getactivity(&req);
375 		req.aborttime = now + 60;	/* don't spend more than 60 seconds */
376 
377 		mf = nil;
378 		switch(job->request.type){
379 		case Tversion:
380 		case Tauth:
381 		case Tflush:
382 			break;
383 		case Tattach:
384 			mf = newfid(job->request.fid, 1);
385 			if(mf == nil){
386 				sendmsg(job, "fid in use");
387 				goto skip;
388 			}
389 			break;
390 		default:
391 			mf = newfid(job->request.fid, 0);
392 			if(mf == nil){
393 				sendmsg(job, "unknown fid");
394 				goto skip;
395 			}
396 			break;
397 		}
398 
399 		switch(job->request.type){
400 		default:
401 			syslog(1, logfile, "unknown request type %d", job->request.type);
402 			break;
403 		case Tversion:
404 			rversion(job);
405 			break;
406 		case Tauth:
407 			rauth(job);
408 			break;
409 		case Tflush:
410 			rflush(job);
411 			break;
412 		case Tattach:
413 			rattach(job, mf);
414 			break;
415 		case Twalk:
416 			rwalk(job, mf);
417 			break;
418 		case Topen:
419 			ropen(job, mf);
420 			break;
421 		case Tcreate:
422 			rcreate(job, mf);
423 			break;
424 		case Tread:
425 			rread(job, mf);
426 			break;
427 		case Twrite:
428 			rwrite(job, mf, &req);
429 			break;
430 		case Tclunk:
431 			rclunk(job, mf);
432 			break;
433 		case Tremove:
434 			rremove(job, mf);
435 			break;
436 		case Tstat:
437 			rstat(job, mf);
438 			break;
439 		case Twstat:
440 			rwstat(job, mf);
441 			break;
442 		}
443 skip:
444 		freejob(job);
445 		putactivity();
446 	}
447 }
448 
449 void
450 io(void)
451 {
452 	int i;
453 
454 	for(i=0; i<Maxactive; i++)
455 		proccreate(ioproc0, 0, STACK);
456 }
457 
458 void
459 rversion(Job *job)
460 {
461 	if(job->request.msize > IOHDRSZ + Maxfdata)
462 		job->reply.msize = IOHDRSZ + Maxfdata;
463 	else
464 		job->reply.msize = job->request.msize;
465 	if(strncmp(job->request.version, "9P2000", 6) != 0)
466 		sendmsg(job, "unknown 9P version");
467 	else{
468 		job->reply.version = "9P2000";
469 		sendmsg(job, 0);
470 	}
471 }
472 
473 void
474 rauth(Job *job)
475 {
476 	sendmsg(job, "dns: authentication not required");
477 }
478 
479 /*
480  *  don't flush till all the slaves are done
481  */
482 void
483 rflush(Job *job)
484 {
485 	flushjob(job->request.oldtag);
486 	sendmsg(job, 0);
487 }
488 
489 void
490 rattach(Job *job, Mfile *mf)
491 {
492 	if(mf->user != nil)
493 		free(mf->user);
494 	mf->user = estrdup(job->request.uname);
495 	mf->qid.vers = vers++;
496 	mf->qid.type = QTDIR;
497 	mf->qid.path = 0LL;
498 	job->reply.qid = mf->qid;
499 	sendmsg(job, 0);
500 }
501 
502 char*
503 rwalk(Job *job, Mfile *mf)
504 {
505 	char *err;
506 	char **elems;
507 	int nelems;
508 	int i;
509 	Mfile *nmf;
510 	Qid qid;
511 
512 	err = 0;
513 	nmf = nil;
514 	elems = job->request.wname;
515 	nelems = job->request.nwname;
516 	job->reply.nwqid = 0;
517 
518 	if(job->request.newfid != job->request.fid){
519 		/* clone fid */
520 		if(job->request.newfid<0){
521 			err = "clone newfid out of range";
522 			goto send;
523 		}
524 		nmf = copyfid(mf, job->request.newfid);
525 		if(nmf == nil){
526 			err = "clone bad newfid";
527 			goto send;
528 		}
529 		mf = nmf;
530 	}
531 	/* else nmf will be nil */
532 
533 	qid = mf->qid;
534 	if(nelems > 0){
535 		/* walk fid */
536 		for(i=0; i<nelems && i<MAXWELEM; i++){
537 			if((qid.type & QTDIR) == 0){
538 				err = "not a directory";
539 				break;
540 			}
541 			if(strcmp(elems[i], "..") == 0 || strcmp(elems[i], ".") == 0){
542 				qid.type = QTDIR;
543 				qid.path = Qdir;
544     Found:
545 				job->reply.wqid[i] = qid;
546 				job->reply.nwqid++;
547 				continue;
548 			}
549 			if(strcmp(elems[i], "dns") == 0){
550 				qid.type = QTFILE;
551 				qid.path = Qdns;
552 				goto Found;
553 			}
554 			err = "file does not exist";
555 			break;
556 		}
557 	}
558 
559     send:
560 	if(nmf != nil && (err!=nil || job->reply.nwqid<nelems))
561 		freefid(nmf);
562 	if(err == nil)
563 		mf->qid = qid;
564 	sendmsg(job, err);
565 	return err;
566 }
567 
568 void
569 ropen(Job *job, Mfile *mf)
570 {
571 	int mode;
572 	char *err;
573 
574 	err = 0;
575 	mode = job->request.mode;
576 	if(mf->qid.type & QTDIR){
577 		if(mode)
578 			err = "permission denied";
579 	}
580 	job->reply.qid = mf->qid;
581 	job->reply.iounit = 0;
582 	sendmsg(job, err);
583 }
584 
585 void
586 rcreate(Job *job, Mfile *mf)
587 {
588 	USED(mf);
589 	sendmsg(job, "creation permission denied");
590 }
591 
592 void
593 rread(Job *job, Mfile *mf)
594 {
595 	int i, n, cnt;
596 	long off;
597 	Dir dir;
598 	uchar buf[Maxfdata];
599 	char *err;
600 	long clock;
601 
602 	n = 0;
603 	err = 0;
604 	off = job->request.offset;
605 	cnt = job->request.count;
606 	if(mf->qid.type & QTDIR){
607 		clock = time(0);
608 		if(off == 0){
609 			dir.name = "dns";
610 			dir.qid.type = QTFILE;
611 			dir.qid.vers = vers;
612 			dir.qid.path = Qdns;
613 			dir.mode = 0666;
614 			dir.length = 0;
615 			dir.uid = mf->user;
616 			dir.gid = mf->user;
617 			dir.muid = mf->user;
618 			dir.atime = clock;	/* wrong */
619 			dir.mtime = clock;	/* wrong */
620 			n = convD2M(&dir, buf, sizeof buf);
621 		}
622 		job->reply.data = (char*)buf;
623 	} else {
624 		for(i = 1; i <= mf->nrr; i++)
625 			if(mf->rr[i] > off)
626 				break;
627 		if(i > mf->nrr)
628 			goto send;
629 		if(off + cnt > mf->rr[i])
630 			n = mf->rr[i] - off;
631 		else
632 			n = cnt;
633 		job->reply.data = mf->reply + off;
634 	}
635 send:
636 	job->reply.count = n;
637 	sendmsg(job, err);
638 }
639 
640 void
641 rwrite(Job *job, Mfile *mf, Request *req)
642 {
643 	int cnt, rooted, status;
644 	long n;
645 	char *err, *p, *atype;
646 	RR *rp, *tp, *neg;
647 	int wantsav;
648 	static char *dumpfile;
649 
650 	err = 0;
651 	cnt = job->request.count;
652 	if(mf->qid.type & QTDIR){
653 		err = "can't write directory";
654 		goto send;
655 	}
656 	if(cnt >= Maxrequest){
657 		err = "request too long";
658 		goto send;
659 	}
660 	job->request.data[cnt] = 0;
661 	if(cnt > 0 && job->request.data[cnt-1] == '\n')
662 		job->request.data[cnt-1] = 0;
663 
664 	/*
665 	 *  special commands
666 	 */
667 	p = job->request.data;
668 	if(strcmp(p, "debug")==0){
669 		debug ^= 1;
670 		goto send;
671 	} else if(strcmp(p, "dump")==0){
672 		if(dumpfile == nil)
673 			dumpfile = unsharp("#9/ndb/dnsdump");
674 		dndump(dumpfile);
675 		goto send;
676 	} else if(strncmp(p, "dump ", 5) == 0){
677 		if(*(p+5))
678 			dndump(p+5);
679 		else
680 			err = "bad filename";
681 		goto send;
682 	} else if(strcmp(p, "refresh")==0){
683 		needrefresh = 1;
684 		goto send;
685 	}
686 
687 	/*
688 	 *  kill previous reply
689 	 */
690 	mf->nrr = 0;
691 	mf->rr[0] = 0;
692 
693 	/*
694 	 *  break up request (into a name and a type)
695 	 */
696 	atype = strchr(job->request.data, ' ');
697 	if(atype == 0){
698 		err = "illegal request";
699 		goto send;
700 	} else
701 		*atype++ = 0;
702 
703 	/*
704 	 *  tracing request
705 	 */
706 	if(strcmp(atype, "trace") == 0){
707 		if(trace)
708 			free(trace);
709 		if(*job->request.data)
710 			trace = estrdup(job->request.data);
711 		else
712 			trace = 0;
713 		goto send;
714 	}
715 
716 	mf->type = rrtype(atype);
717 	if(mf->type < 0){
718 		err = "unknown type";
719 		goto send;
720 	}
721 
722 	p = atype - 2;
723 	if(p >= job->request.data && *p == '.'){
724 		rooted = 1;
725 		*p = 0;
726 	} else
727 		rooted = 0;
728 
729 	p = job->request.data;
730 	if(*p == '!'){
731 		wantsav = 1;
732 		p++;
733 	} else
734 		wantsav = 0;
735 	dncheck(0, 1);
736 	rp = dnresolve(p, Cin, mf->type, req, 0, 0, Recurse, rooted, &status);
737 	dncheck(0, 1);
738 	neg = rrremneg(&rp);
739 	if(neg){
740 		status = neg->negrcode;
741 		rrfreelist(neg);
742 	}
743 	if(rp == 0){
744 		switch(status){
745 		case Rname:
746 			err = "name does not exist";
747 			break;
748 		case Rserver:
749 			err = "dns failure";
750 			break;
751 		default:
752 			err = "resource does not exist";
753 			break;
754 		}
755 	} else {
756 		lock(&joblock);
757 		if(!job->flushed){
758 			/* format data to be read later */
759 			n = 0;
760 			mf->nrr = 0;
761 			for(tp = rp; mf->nrr < Maxrrr-1 && n < Maxreply && tp &&
762 					tsame(mf->type, tp->type); tp = tp->next){
763 				mf->rr[mf->nrr++] = n;
764 				if(wantsav)
765 					n += snprint(mf->reply+n, Maxreply-n, "%Q", tp);
766 				else
767 					n += snprint(mf->reply+n, Maxreply-n, "%R", tp);
768 			}
769 			mf->rr[mf->nrr] = n;
770 		}
771 		unlock(&joblock);
772 		rrfreelist(rp);
773 	}
774 
775     send:
776 	dncheck(0, 1);
777 	job->reply.count = cnt;
778 	sendmsg(job, err);
779 }
780 
781 void
782 rclunk(Job *job, Mfile *mf)
783 {
784 	freefid(mf);
785 	sendmsg(job, 0);
786 }
787 
788 void
789 rremove(Job *job, Mfile *mf)
790 {
791 	USED(mf);
792 	sendmsg(job, "remove permission denied");
793 }
794 
795 void
796 rstat(Job *job, Mfile *mf)
797 {
798 	Dir dir;
799 	uchar buf[IOHDRSZ+Maxfdata];
800 
801 	if(mf->qid.type & QTDIR){
802 		dir.name = ".";
803 		dir.mode = DMDIR|0555;
804 	} else {
805 		dir.name = "dns";
806 		dir.mode = 0666;
807 	}
808 	dir.qid = mf->qid;
809 	dir.length = 0;
810 	dir.uid = mf->user;
811 	dir.gid = mf->user;
812 	dir.muid = mf->user;
813 	dir.atime = dir.mtime = time(0);
814 	job->reply.nstat = convD2M(&dir, buf, sizeof buf);
815 	job->reply.stat = buf;
816 	sendmsg(job, 0);
817 }
818 
819 void
820 rwstat(Job *job, Mfile *mf)
821 {
822 	USED(mf);
823 	sendmsg(job, "wstat permission denied");
824 }
825 
826 void
827 sendmsg(Job *job, char *err)
828 {
829 	int n;
830 	uchar mdata[IOHDRSZ + Maxfdata];
831 	char ename[ERRMAX];
832 
833 	if(err){
834 		job->reply.type = Rerror;
835 		snprint(ename, sizeof(ename), "dns: %s", err);
836 		job->reply.ename = ename;
837 	}else{
838 		job->reply.type = job->request.type+1;
839 	}
840 	job->reply.tag = job->request.tag;
841 	n = convS2M(&job->reply, mdata, sizeof mdata);
842 	if(n == 0){
843 		syslog(1, logfile, "sendmsg convS2M of %F returns 0", &job->reply);
844 		abort();
845 	}
846 	lock(&joblock);
847 	if(job->flushed == 0)
848 		if(write(mfd[1], mdata, n)!=n)
849 			sysfatal("mount write");
850 	unlock(&joblock);
851 	if(debug)
852 		syslog(0, logfile, "%F %d", &job->reply, n);
853 }
854 
855 /*
856  *  the following varies between dnsdebug and dns
857  */
858 void
859 logreply(int id, uchar *addr, DNSmsg *mp)
860 {
861 	RR *rp;
862 
863 	syslog(0, LOG, "%d: rcvd %I flags:%s%s%s%s%s", id, addr,
864 		mp->flags & Fauth ? " auth" : "",
865 		mp->flags & Ftrunc ? " trunc" : "",
866 		mp->flags & Frecurse ? " rd" : "",
867 		mp->flags & Fcanrec ? " ra" : "",
868 		mp->flags & (Fauth|Rname) == (Fauth|Rname) ?
869 		" nx" : "");
870 	for(rp = mp->qd; rp != nil; rp = rp->next)
871 		syslog(0, LOG, "%d: rcvd %I qd %s", id, addr, rp->owner->name);
872 	for(rp = mp->an; rp != nil; rp = rp->next)
873 		syslog(0, LOG, "%d: rcvd %I an %R", id, addr, rp);
874 	for(rp = mp->ns; rp != nil; rp = rp->next)
875 		syslog(0, LOG, "%d: rcvd %I ns %R", id, addr, rp);
876 	for(rp = mp->ar; rp != nil; rp = rp->next)
877 		syslog(0, LOG, "%d: rcvd %I ar %R", id, addr, rp);
878 }
879 
880 void
881 logsend(int id, int subid, uchar *addr, char *sname, char *rname, int type)
882 {
883 	char buf[12];
884 
885 	syslog(0, LOG, "%d.%d: sending to %I/%s %s %s",
886 		id, subid, addr, sname, rname, rrname(type, buf, sizeof buf));
887 }
888 
889 RR*
890 getdnsservers(int class)
891 {
892 	return dnsservers(class);
893 }