Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <ip.h>

#include "dns.h"

static RR*	doextquery(DNSmsg*, Request*, int);

static void	hint(RR**, RR*);

/* set in dns.c */

int	norecursion;		/* don't allow recursive requests */

/*

 *  answer a dns request

 */

void

dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)

{

	int recursionflag;

	char *cp, *errmsg;

	char tname[32];

	DN *nsdp, *dp;

	Area *myarea;

	RR *tp, *neg, *rp;

	dncheck(nil, 1);

	recursionflag = norecursion? 0: Fcanrec;

	memset(repp, 0, sizeof(*repp));

	repp->id = reqp->id;

	repp->flags = Fresp | recursionflag | Oquery;

	/* move one question from reqp to repp */

	tp = reqp->qd;

	reqp->qd = tp->next;

	tp->next = nil;

	repp->qd = tp;

	if (rcode) {

		errmsg = "";

		if (rcode >= 0 && rcode < nrname)

			errmsg = rname[rcode];

		dnslog("server: response code 0%o (%s), req from %I",

			rcode, errmsg, srcip);

		/* provide feedback to clients who send us trash */

		repp->flags = (rcode&Rmask) | Fresp | Fcanrec | Oquery;

		return;

	}

	if(!rrsupported(repp->qd->type)){

		dnslog("server: unsupported request %s from %I",

			rrname(repp->qd->type, tname, sizeof tname), srcip);

		repp->flags = Runimplimented | Fresp | Fcanrec | Oquery;

		return;

	}

	if(repp->qd->owner->class != Cin){

		dnslog("server: unsupported class %d from %I",

			repp->qd->owner->class, srcip);

		repp->flags = Runimplimented | Fresp | Fcanrec | Oquery;

		return;

	}

	myarea = inmyarea(repp->qd->owner->name);

	if(myarea != nil) {

		if(repp->qd->type == Tixfr || repp->qd->type == Taxfr){

			dnslog("server: unsupported xfr request %s for %s from %I",

				rrname(repp->qd->type, tname, sizeof tname),

				repp->qd->owner->name, srcip);

			repp->flags = Runimplimented | Fresp | recursionflag |

				Oquery;

			return;

		}

	} else

		if(norecursion) {

			/* we don't recurse and we're not authoritative */

			repp->flags = Rok | Fresp | Oquery;

			return;

		}

	/*

	 *  get the answer if we can, in *repp

	 */

	if(reqp->flags & Frecurse)

		neg = doextquery(repp, req, Recurse);

	else

		neg = doextquery(repp, req, Dontrecurse);

	/* authority is transitive */

	if(myarea != nil || (repp->an && repp->an->auth))

		repp->flags |= Fauth;

	/* pass on error codes */

	if(repp->an == nil){

		dp = dnlookup(repp->qd->owner->name, repp->qd->owner->class, 0);

		if(dp->rr == nil)

			if(reqp->flags & Frecurse)

				repp->flags |= dp->respcode | Fauth;

	}

	if(myarea == nil)

		/*

		 *  add name server if we know

		 */

		for(cp = repp->qd->owner->name; cp; cp = walkup(cp)){

			nsdp = dnlookup(cp, repp->qd->owner->class, 0);

			if(nsdp == nil)

				continue;

			repp->ns = rrlookup(nsdp, Tns, OKneg);

			if(repp->ns){

				/* don't pass on anything we know is wrong */

				if(repp->ns->negative){

					lock(&dnlock);

					rp = repp->ns;

					repp->ns = nil;

					rrfreelist(rp);

					unlock(&dnlock);

				}

				break;

			}

			if (strncmp(nsdp->name, "local#", 6) == 0)

				dnslog("returning %s as nameserver", nsdp->name);

			repp->ns = dblookup(cp, repp->qd->owner->class, Tns, 0, 0);

			if(repp->ns)

				break;

		}

	/*

	 *  add ip addresses as hints

	 */

	if(repp->qd->type != Taxfr && repp->qd->type != Tixfr){

		for(tp = repp->ns; tp; tp = tp->next)

			hint(&repp->ar, tp);

		for(tp = repp->an; tp; tp = tp->next)

			hint(&repp->ar, tp);

	}

	/* hint calls rrlookup which holds dnlock, so don't lock before this. */

	/*

	 *  add an soa to the authority section to help client

	 *  with negative caching

	 */

	if(repp->an == nil)

		if(myarea != nil){

			lock(&dnlock);

			rrcopy(myarea->soarr, &tp);

			rrcat(&repp->ns, tp);

			unlock(&dnlock);

		} else if(neg != nil) {

			if(neg->negsoaowner != nil) {

				tp = rrlookup(neg->negsoaowner, Tsoa, NOneg);

				lock(&dnlock);

				rrcat(&repp->ns, tp);

				unlock(&dnlock);

			}

			repp->flags |= neg->negrcode;

		}

	/*

	 *  get rid of duplicates

	 */

	lock(&dnlock);

	unique(repp->an);

	unique(repp->ns);

	unique(repp->ar);

	rrfreelist(neg);

	unlock(&dnlock);

	dncheck(nil, 1);

}

/*

 *  satisfy a recursive request.  dnlookup will handle cnames.

 */

static RR*

doextquery(DNSmsg *mp, Request *req, int recurse)

{

	ushort type;

	char *name;

	RR *rp, *neg;

	name = mp->qd->owner->name;

	type = mp->qd->type;

	rp = dnresolve(name, Cin, type, req, &mp->an, 0, recurse, 1, 0);

	lock(&dnlock);

	/* don't return soa hints as answers, it's wrong */

	if(rp && rp->db && !rp->auth && rp->type == Tsoa) {

		rrfreelist(rp);

		rp = nil;

	}

	/* don't let negative cached entries escape */

	neg = rrremneg(&rp);

	rrcat(&mp->an, rp);

	unlock(&dnlock);

	return neg;

}

static void

hint(RR **last, RR *rp)

{

	RR *hp;

	switch(rp->type){

	case Tns:

	case Tmx:

	case Tmb:

	case Tmf:

	case Tmd:

		assert(rp->host != nil);

		hp = rrlookup(rp->host, Ta, NOneg);

		if(hp == nil)

			hp = dblookup(rp->host->name, Cin, Ta, 0, 0);

		if(hp == nil)

			hp = rrlookup(rp->host, Taaaa, NOneg);

		if(hp == nil)

			hp = dblookup(rp->host->name, Cin, Taaaa, 0, 0);

		if (hp && hp->owner && hp->owner->name &&

		    strncmp(hp->owner->name, "local#", 6) == 0)

			dnslog("returning %s as hint", hp->owner->name);

		lock(&dnlock);

		rrcat(last, hp);

		unlock(&dnlock);

		break;

	}

}