xbill/DNS/Lookup.java

// Copyright (c) 2002-2004 Brian Wellington (bwelling@xbill.org)

package org.xbill.DNS;

import java.util.*;
import java.io.*;
import java.net.*;

/**
 * The Lookup object issues queries to caching DNS servers.  The input consists
 * of a name, an optional type, and an optional class.  Caching is enabled
 * by default and used when possible to reduce the number of DNS requests.
 * A Resolver, which defaults to an ExtendedResolver initialized with the
 * resolvers located by the ResolverConfig class, performs the queries.  A
 * search path of domain suffixes is used to resolve relative names, and is
 * also determined by the ResolverConfig class.
 *
 * A Lookup object may be reused, but should not be used by multiple threads.
 *
 * @see Cache
 * @see Resolver
 * @see ResolverConfig
 *
 * @author Brian Wellington
 */

public final class Lookup {

private static Resolver defaultResolver;
private static Name [] defaultSearchPath;
private static Map defaultCaches;
private static int defaultNdots;

private Resolver resolver;
private Name [] searchPath;
private Cache cache;
private boolean temporary_cache;
private int credibility;
private Name name;
private int type;
private int dclass;
private boolean verbose;
private int iterations;
private boolean foundAlias;
private boolean done;
private boolean doneCurrent;
private List aliases;
private Record [] answers;
private int result;
private String error;
private boolean nxdomain;
private boolean badresponse;
private String badresponse_error;
private boolean networkerror;
private boolean timedout;
private boolean nametoolong;
private boolean referral;

private static final Name [] noAliases = new Name[0];

/** The lookup was successful. */
public static final int SUCCESSFUL = 0;

/**
 * The lookup failed due to a data or server error. Repeating the lookup
 * would not be helpful.
 */
public static final int UNRECOVERABLE = 1;

/**
 * The lookup failed due to a network error. Repeating the lookup may be
 * helpful.
 */
public static final int TRY_AGAIN = 2;

/** The host does not exist. */
public static final int HOST_NOT_FOUND = 3;

/** The host exists, but has no records associated with the queried type. */
public static final int TYPE_NOT_FOUND = 4;

public static synchronized void
refreshDefault() {

	try {
		defaultResolver = new ExtendedResolver();
	}
	catch (UnknownHostException e) {
		throw new RuntimeException("Failed to initialize resolver");
	}
	defaultSearchPath = ResolverConfig.getCurrentConfig().searchPath();
	defaultCaches = new HashMap();
	defaultNdots = ResolverConfig.getCurrentConfig().ndots();
}

static {
	refreshDefault();
}

/**
 * Gets the Resolver that will be used as the default by future Lookups.
 * @return The default resolver.
 */
public static synchronized Resolver
getDefaultResolver() {
	return defaultResolver;
}

/**
 * Sets the default Resolver to be used as the default by future Lookups.
 * @param resolver The default resolver.
 */
public static synchronized void
setDefaultResolver(Resolver resolver) {
	defaultResolver = resolver;
}

/**
 * Gets the Cache that will be used as the default for the specified
 * class by future Lookups.
 * @param dclass The class whose cache is being retrieved.
 * @return The default cache for the specified class.
 */
public static synchronized Cache
getDefaultCache(int dclass) {
	DClass.check(dclass);
	Cache c = (Cache) defaultCaches.get(Mnemonic.toInteger(dclass));
	if (c == null) {
		c = new Cache(dclass);
		defaultCaches.put(Mnemonic.toInteger(dclass), c);
	}
	return c;
}

/**
 * Sets the Cache to be used as the default for the specified class by future
 * Lookups.
 * @param cache The default cache for the specified class.
 * @param dclass The class whose cache is being set.
 */
public static synchronized void
setDefaultCache(Cache cache, int dclass) {
	DClass.check(dclass);
	defaultCaches.put(Mnemonic.toInteger(dclass), cache);
}

/**
 * Gets the search path that will be used as the default by future Lookups.
 * @return The default search path.
 */
public static synchronized Name []
getDefaultSearchPath() {
	return defaultSearchPath;
}

/**
 * Sets the search path to be used as the default by future Lookups.
 * @param domains The default search path.
 */
public static synchronized void
setDefaultSearchPath(Name [] domains) {
	defaultSearchPath = domains;
}

/**
 * Sets the search path that will be used as the default by future Lookups.
 * @param domains The default search path.
 * @throws TextParseException A name in the array is not a valid DNS name.
 */
public static synchronized void
setDefaultSearchPath(String [] domains) throws TextParseException {
	if (domains == null) {
		defaultSearchPath = null;
		return;
	}
	Name [] newdomains = new Name[domains.length];
	for (int i = 0; i < domains.length; i++)
		newdomains[i] = Name.fromString(domains[i], Name.root);
	defaultSearchPath = newdomains;
}

private final void
reset() {
	iterations = 0;
	foundAlias = false;
	done = false;
	doneCurrent = false;
	aliases = null;
	answers = null;
	result = -1;
	error = null;
	nxdomain = false;
	badresponse = false;
	badresponse_error = null;
	networkerror = false;
	timedout = false;
	nametoolong = false;
	referral = false;
	if (temporary_cache)
		cache.clearCache();
}

/**
 * Create a Lookup object that will find records of the given name, type,
 * and class.  The lookup will use the default cache, resolver, and search
 * path, and look for records that are reasonably credible.
 * @param name The name of the desired records
 * @param type The type of the desired records
 * @param dclass The class of the desired records
 * @throws IllegalArgumentException The type is a meta type other than ANY.
 * @see Cache
 * @see Resolver
 * @see Credibility
 * @see Name
 * @see Type
 * @see DClass
 */
public
Lookup(Name name, int type, int dclass) {
	Type.check(type);
	DClass.check(dclass);
	if (!Type.isRR(type) && type != Type.ANY)
		throw new IllegalArgumentException("Cannot query for " +
						   "meta-types other than ANY");
	this.name = name;
	this.type = type;
	this.dclass = dclass;
	synchronized (Lookup.class) {
		this.resolver = getDefaultResolver();
		this.searchPath = getDefaultSearchPath();
		this.cache = getDefaultCache(dclass);
	}
	this.credibility = Credibility.NORMAL;
	this.verbose = Options.check("verbose");
	this.result = -1;
}

/**
 * Create a Lookup object that will find records of the given name and type
 * in the IN class.
 * @param name The name of the desired records
 * @param type The type of the desired records
 * @throws IllegalArgumentException The type is a meta type other than ANY.
 * @see #Lookup(Name,int,int)
 */
public
Lookup(Name name, int type) {
	this(name, type, DClass.IN);
}

/**
 * Create a Lookup object that will find records of type A at the given name
 * in the IN class.
 * @param name The name of the desired records
 * @see #Lookup(Name,int,int)
 */
public
Lookup(Name name) {
	this(name, Type.A, DClass.IN);
}

/**
 * Create a Lookup object that will find records of the given name, type,
 * and class.
 * @param name The name of the desired records
 * @param type The type of the desired records
 * @param dclass The class of the desired records
 * @throws TextParseException The name is not a valid DNS name
 * @throws IllegalArgumentException The type is a meta type other than ANY.
 * @see #Lookup(Name,int,int)
 */
public
Lookup(String name, int type, int dclass) throws TextParseException {
	this(Name.fromString(name), type, dclass);
}

/**
 * Create a Lookup object that will find records of the given name and type
 * in the IN class.
 * @param name The name of the desired records
 * @param type The type of the desired records
 * @throws TextParseException The name is not a valid DNS name
 * @throws IllegalArgumentException The type is a meta type other than ANY.
 * @see #Lookup(Name,int,int)
 */
public
Lookup(String name, int type) throws TextParseException {
	this(Name.fromString(name), type, DClass.IN);
}

/**
 * Create a Lookup object that will find records of type A at the given name
 * in the IN class.
 * @param name The name of the desired records
 * @throws TextParseException The name is not a valid DNS name
 * @see #Lookup(Name,int,int)
 */
public
Lookup(String name) throws TextParseException {
	this(Name.fromString(name), Type.A, DClass.IN);
}

/**
 * Sets the resolver to use when performing this lookup.  This overrides the
 * default value.
 * @param resolver The resolver to use.
 */
public void
setResolver(Resolver resolver) {
	this.resolver = resolver;
}

/**
 * Sets the search path to use when performing this lookup.  This overrides the
 * default value.
 * @param domains An array of names containing the search path.
 */
public void
setSearchPath(Name [] domains) {
	this.searchPath = domains;
}

/**
 * Sets the search path to use when performing this lookup. This overrides the
 * default value.
 * @param domains An array of names containing the search path.
 * @throws TextParseException A name in the array is not a valid DNS name.
 */
public void
setSearchPath(String [] domains) throws TextParseException {
	if (domains == null) {
		this.searchPath = null;
		return;
	}
	Name [] newdomains = new Name[domains.length];
	for (int i = 0; i < domains.length; i++)
		newdomains[i] = Name.fromString(domains[i], Name.root);
	this.searchPath = newdomains;
}

/**
 * Sets the cache to use when performing this lookup.  This overrides the
 * default value.  If the results of this lookup should not be permanently
 * cached, null can be provided here.
 * @param cache The cache to use.
 */
public void
setCache(Cache cache) {
	if (cache == null) {
		this.cache = new Cache(dclass);
		this.temporary_cache = true;
	} else {
		this.cache = cache;
		this.temporary_cache = false;
	}
}

/**
 * Sets ndots to use when performing this lookup, overriding the default value.
 * Specifically, this refers to the number of "dots" which, if present in a
 * name, indicate that a lookup for the absolute name should be attempted
 * before appending any search path elements.
 * @param ndots The ndots value to use, which must be greater than or equal to
 * 0.
 */
public void
setNdots(int ndots) {
	if (ndots < 0)
		throw new IllegalArgumentException("Illegal ndots value: " +
						   ndots);
	defaultNdots = ndots;
}

/**
 * Sets the minimum credibility level that will be accepted when performing
 * the lookup.  This defaults to Credibility.NORMAL.
 * @param credibility The minimum credibility level.
 */
public void
setCredibility(int credibility) {
	this.credibility = credibility;
}

private void
follow(Name name, Name oldname) {
	foundAlias = true;
	badresponse = false;
	networkerror = false;
	timedout = false;
	nxdomain = false;
	referral = false;
	iterations++;
	if (iterations >= 6 || name.equals(oldname)) {
		result = UNRECOVERABLE;
		error = "CNAME loop";
		done = true;
		return;
	}
	if (aliases == null)
		aliases = new ArrayList();
	aliases.add(oldname);
	lookup(name);
}

private void
processResponse(Name name, SetResponse response) {
	if (response.isSuccessful()) {
		RRset [] rrsets = response.answers();
		List l = new ArrayList();
		Iterator it;
		int i;

		for (i = 0; i < rrsets.length; i++) {
			it = rrsets[i].rrs();
			while (it.hasNext())
				l.add(it.next());
		}

		result = SUCCESSFUL;
		answers = (Record []) l.toArray(new Record[l.size()]);
		done = true;
	} else if (response.isNXDOMAIN()) {
		nxdomain = true;
		doneCurrent = true;
		if (iterations > 0) {
			result = HOST_NOT_FOUND;
			done = true;
		}
	} else if (response.isNXRRSET()) {
		result = TYPE_NOT_FOUND;
		answers = null;
		done = true;
	} else if (response.isCNAME()) {
		CNAMERecord cname = response.getCNAME();
		follow(cname.getTarget(), name);
	} else if (response.isDNAME()) {
		DNAMERecord dname = response.getDNAME();
		try {
			follow(name.fromDNAME(dname), name);
		} catch (NameTooLongException e) {
			result = UNRECOVERABLE;
			error = "Invalid DNAME target";
			done = true;
		}
	} else if (response.isDelegation()) {
		// We shouldn't get a referral.  Ignore it.
		referral = true;
	}
}

private void
lookup(Name current) {
	SetResponse sr = cache.lookupRecords(current, type, credibility);
	if (verbose) {
		System.err.println("lookup " + current + " " +
				   Type.string(type));
		System.err.println(sr);
	}
	processResponse(current, sr);
	if (done || doneCurrent)
		return;

	Record question = Record.newRecord(current, type, dclass);
	Message query = Message.newQuery(question);
	Message response = null;
	try {
		response = resolver.send(query);
	}
	catch (IOException e) {
		// A network error occurred.  Press on.
		if (e instanceof InterruptedIOException)
			timedout = true;
		else
			networkerror = true;
		return;
	}
	int rcode = response.getHeader().getRcode();
	if (rcode != Rcode.NOERROR && rcode != Rcode.NXDOMAIN) {
		// The server we contacted is broken or otherwise unhelpful.
		// Press on.
		badresponse = true;
		badresponse_error = Rcode.string(rcode);
		return;
	}

	if (!query.getQuestion().equals(response.getQuestion())) {
		// The answer doesn't match the question.  That's not good.
		badresponse = true;
		badresponse_error = "response does not match query";
		return;
	}

	sr = cache.addMessage(response);
	if (sr == null)
		sr = cache.lookupRecords(current, type, credibility);
	if (verbose) {
		System.err.println("queried " + current + " " +
				   Type.string(type));
		System.err.println(sr);
	}
	processResponse(current, sr);
}

private void
resolve(Name current, Name suffix) {
	doneCurrent = false;
	Name tname = null;
	if (suffix == null)
		tname = current;
	else {
		try {
			tname = Name.concatenate(current, suffix);
		}
		catch (NameTooLongException e) {
			nametoolong = true;
			return;
		}
	}
	lookup(tname);
}

/**
 * Performs the lookup, using the specified Cache, Resolver, and search path.
 * @return The answers, or null if none are found.
 */
public Record []
run() {
	if (done)
		reset();
	if (name.isAbsolute())
		resolve(name, null);
	else if (searchPath == null)
		resolve(name, Name.root);
	else {
		if (name.labels() > defaultNdots)
			resolve(name, Name.root);
		if (done)
			return answers;

		for (int i = 0; i < searchPath.length; i++) {
			resolve(name, searchPath[i]);
			if (done)
				return answers;
			else if (foundAlias)
				break;
		}
	}
	if (!done) {
		if (badresponse) {
			result = TRY_AGAIN;
			error = badresponse_error;
			done = true;
		} else if (timedout) {
			result = TRY_AGAIN;
			error = "timed out";
			done = true;
		} else if (networkerror) {
			result = TRY_AGAIN;
			error = "network error";
			done = true;
		} else if (nxdomain) {
			result = HOST_NOT_FOUND;
			done = true;
		} else if (referral) {
			result = UNRECOVERABLE;
			error = "referral";
			done = true;
		} else if (nametoolong) {
			result = UNRECOVERABLE;
			error = "name too long";
			done = true;
		}
	}
	return answers;
}

private void
checkDone() {
	if (done && result != -1)
		return;
	StringBuffer sb = new StringBuffer("Lookup of " + name + " ");
	if (dclass != DClass.IN)
		sb.append(DClass.string(dclass) + " ");
	sb.append(Type.string(type) + " isn't done");
	throw new IllegalStateException(sb.toString());
}

/**
 * Returns the answers from the lookup.
 * @return The answers, or null if none are found.
 * @throws IllegalStateException The lookup has not completed.
 */
public Record []
getAnswers() {
	checkDone();
	return answers;
}

/**
 * Returns all known aliases for this name.  Whenever a CNAME/DNAME is
 * followed, an alias is added to this array.  The last element in this
 * array will be the owner name for records in the answer, if there are any.
 * @return The aliases.
 * @throws IllegalStateException The lookup has not completed.
 */
public Name []
getAliases() {
	checkDone();
	if (aliases == null)
		return noAliases;
	return (Name []) aliases.toArray(new Name[aliases.size()]);
}

/**
 * Returns the result code of the lookup.
 * @return The result code, which can be SUCCESSFUL, UNRECOVERABLE, TRY_AGAIN,
 * HOST_NOT_FOUND, or TYPE_NOT_FOUND.
 * @throws IllegalStateException The lookup has not completed.
 */
public int
getResult() {
	checkDone();
	return result;
}

/**
 * Returns an error string describing the result code of this lookup.
 * @return A string, which may either directly correspond the result code
 * or be more specific.
 * @throws IllegalStateException The lookup has not completed.
 */
public String
getErrorString() {
	checkDone();
	if (error != null)
		return error;
	switch (result) {
		case SUCCESSFUL:	return "successful";
		case UNRECOVERABLE:	return "unrecoverable error";
		case TRY_AGAIN:		return "try again";
		case HOST_NOT_FOUND:	return "host not found";
		case TYPE_NOT_FOUND:	return "type not found";
	}
	throw new IllegalStateException("unknown result");
}

}