public static final int DEFAULT_MAX_ITERATIONS = 16;

public static final int DEFAULT_NDOTS = 1;

private final Resolver resolver;

private final int maxRedirects;

private final int ndots;

private final List<Name> searchPath;

private final boolean cycleResults;

private final Map<Integer, Cache> caches;

private final HostsFileParser hostsFileParser;

private final Executor executor;

private LookupSession(

@NonNull Resolver resolver,

int maxRedirects,

int ndots,

List<Name> searchPath,

boolean cycleResults,

List<Cache> caches,

HostsFileParser hostsFileParser,

Executor executor) {

this.resolver = resolver;

this.maxRedirects = maxRedirects;

this.ndots = ndots;

this.searchPath = searchPath;

this.cycleResults = cycleResults;

this.caches =

caches == null

? Collections.emptyMap()

: caches.stream().collect(Collectors.toMap(Cache::getDClass, e -> e));

this.hostsFileParser = hostsFileParser;

this.executor = executor == null ? ForkJoinPool.commonPool() : executor;

}

/**

@ToString

public static class LookupSessionBuilder {

private Resolver resolver;

private int maxRedirects;

private int ndots;

private List<Name> searchPath;

private boolean cycleResults;

private List<Cache> caches;

private HostsFileParser hostsFileParser;

private Executor executor;

private LookupSessionBuilder() {}

/**

public LookupSessionBuilder resolver(@NonNull Resolver resolver) {

this.resolver = resolver;

return this;

}

/**

public LookupSessionBuilder maxRedirects(int maxRedirects) {

this.maxRedirects = maxRedirects;

return this;

}

/**

public LookupSessionBuilder ndots(int ndots) {

this.ndots = ndots;

return this;

}

/**

public LookupSessionBuilder searchPath(Name searchPath) {

if (this.searchPath == null) {

this.searchPath = new ArrayList<>();

}

this.searchPath.add(searchPath);

return this;

}

/**

public LookupSessionBuilder searchPath(Collection<? extends Name> searchPath) {

if (this.searchPath == null) {

this.searchPath = new ArrayList<>();

}

this.searchPath.addAll(searchPath);

return this;

}

/**

public LookupSessionBuilder clearSearchPath() {

if (this.searchPath != null) {

this.searchPath.clear();

}

return this;

}

/**

public LookupSessionBuilder cycleResults(boolean cycleResults) {

this.cycleResults = cycleResults;

return this;

}

/**

public LookupSessionBuilder hostsFileParser(HostsFileParser hostsFileParser) {

this.hostsFileParser = hostsFileParser;

return this;

}

/**

public LookupSessionBuilder executor(Executor executor) {

this.executor = executor;

return this;

}

/**

public LookupSessionBuilder defaultHostsFileParser() {

hostsFileParser = new HostsFileParser();

return this;

}

/**

public LookupSessionBuilder cache(@NonNull Cache cache) {

if (caches == null) {

caches = new ArrayList<>(1);

}

for (Cache c : caches) {

if (c.getDClass() == cache.getDClass()) {

caches.remove(c);

break;

}

}

caches.add(cache);

return this;

}

/**

public LookupSessionBuilder caches(@NonNull Collection<Cache> caches) {

caches.forEach(this::cache);

return this;

}

/**

public LookupSessionBuilder clearCaches() {

if (caches != null) {

caches.clear();

}

return this;

}

/**

@Deprecated

public LookupSessionBuilder cache(@NonNull Integer dclass, @NonNull Cache cache) {

cache(cache);

return this;

}

/**

@Deprecated

public LookupSessionBuilder caches(@NonNull Map<Integer, Cache> caches) {

return caches(caches.values());

}

/** Create an instance of {@link LookupSession} configured by this builder. */

public LookupSession build() {

// note that this transform is idempotent, as concatenating an already absolute Name with root

// is a noop.

if (searchPath != null) {

searchPath =

searchPath.stream()

.map(

name -> {

try {

return Name.concatenate(name, Name.root);

} catch (NameTooLongException e) {

throw new IllegalArgumentException("Search path name too long");

}

})

.collect(Collectors.toCollection(ArrayList::new));

} else {

searchPath = Collections.emptyList();

}

return new LookupSession(

resolver,

maxRedirects,

ndots,

searchPath,

cycleResults,

caches,

hostsFileParser,

executor);

}

}

/**

public static LookupSessionBuilder builder() {

LookupSessionBuilder builder = new LookupSessionBuilder();

builder.maxRedirects = DEFAULT_MAX_ITERATIONS;

builder.ndots = DEFAULT_NDOTS;

return builder;

}

/**

public static LookupSessionBuilder defaultBuilder() {

return builder()

.resolver(

new ExtendedResolver(

ResolverConfig.getCurrentConfig().servers().stream()

.map(SimpleResolver::new)

.collect(Collectors.toList())))

.ndots(ResolverConfig.getCurrentConfig().ndots())

.cache(new Cache(DClass.IN))

.defaultHostsFileParser();

}

/**

public CompletionStage<LookupResult> lookupAsync(Name name, int type) {

return lookupAsync(name, type, DClass.IN);

}

/**

public CompletionStage<LookupResult> lookupAsync(Name name, int type, int dclass) {

List<Name> searchNames = expandName(name);

LookupResult localHostsLookupResult = lookupWithHosts(searchNames, type);

if (localHostsLookupResult != null) {

return CompletableFuture.completedFuture(localHostsLookupResult);

}

return lookupUntilSuccess(searchNames.iterator(), type, dclass);

}

/**

List<Name> expandName(Name name) {

if (name.isAbsolute()) {

return Collections.singletonList(name);

}

List<Name> fromSearchPath =

searchPath.stream()

.map(searchSuffix -> safeConcat(name, searchSuffix))

.filter(Objects::nonNull)

.collect(Collectors.toCollection(ArrayList::new));

if (name.labels() > ndots) {

fromSearchPath.add(0, safeConcat(name, Name.root));

} else {

fromSearchPath.add(safeConcat(name, Name.root));

}

return fromSearchPath;

}

private static Name safeConcat(Name name, Name suffix) {

try {

return Name.concatenate(name, suffix);

} catch (NameTooLongException e) {

return null;

}

}

private LookupResult lookupWithHosts(List<Name> names, int type) {

if (hostsFileParser != null && (type == Type.A || type == Type.AAAA)) {

try {

for (Name name : names) {

Optional<InetAddress> result = hostsFileParser.getAddressForHost(name, type);

if (result.isPresent()) {

Record r;

if (type == Type.A) {

r = new ARecord(name, DClass.IN, 0, result.get());

} else {

r = new AAAARecord(name, DClass.IN, 0, result.get());

}

return new LookupResult(Collections.singletonList(r), Collections.emptyList());

}

}

} catch (IOException e) {

log.debug("Local hosts database parsing failed, ignoring and using resolver", e);

}

}

return null;

}

private CompletionStage<LookupResult> lookupUntilSuccess(

Iterator<Name> names, int type, int dclass) {

Record query = Record.newRecord(names.next(), type, dclass);

return lookupWithCache(query, null)

.thenCompose(answer -> resolveRedirects(answer, query))

.handle(

(result, ex) -> {

Throwable cause = ex == null ? null : ex.getCause();

if (cause instanceof NoSuchDomainException || cause instanceof NoSuchRRSetException) {

if (names.hasNext()) {

return lookupUntilSuccess(names, type, dclass);

} else {

return completeExceptionally(cause);

}

} else if (cause != null) {

return completeExceptionally(cause);

} else {

return CompletableFuture.completedFuture(result);

}

})

.thenCompose(Function.identity());

}

private CompletionStage<LookupResult> lookupWithCache(Record queryRecord, List<Name> aliases) {

return Optional.ofNullable(caches.get(queryRecord.getDClass()))

.map(c -> c.lookupRecords(queryRecord.getName(), queryRecord.getType(), Credibility.NORMAL))

.map(setResponse -> setResponseToMessageFuture(setResponse, queryRecord, aliases))

.orElseGet(() -> lookupWithResolver(queryRecord, aliases));

}

private CompletionStage<LookupResult> lookupWithResolver(Record queryRecord, List<Name> aliases) {

return resolver

.sendAsync(Message.newQuery(queryRecord), executor)

.thenApply(this::maybeAddToCache)

.thenApply(answer -> buildResult(answer, aliases, queryRecord));

}

private Message maybeAddToCache(Message message) {

for (RRset set : message.getSectionRRsets(Section.ANSWER)) {

if ((set.getType() == Type.CNAME || set.getType() == Type.DNAME) && set.size() != 1) {

throw new InvalidZoneDataException("Multiple CNAME RRs not allowed, see RFC1034 3.6.2");

}

}

Optional.ofNullable(caches.get(message.getQuestion().getDClass()))

.ifPresent(cache -> cache.addMessage(message));

return message;

}

private CompletionStage<LookupResult> setResponseToMessageFuture(

SetResponse setResponse, Record queryRecord, List<Name> aliases) {

if (setResponse.isNXDOMAIN()) {

return completeExceptionally(

new NoSuchDomainException(queryRecord.getName(), queryRecord.getType()));

}

if (setResponse.isNXRRSET()) {

return completeExceptionally(

new NoSuchRRSetException(queryRecord.getName(), queryRecord.getType()));

}

if (setResponse.isSuccessful()) {

List<Record> records =

setResponse.answers().stream()

.flatMap(rrset -> rrset.rrs(cycleResults).stream())

.collect(Collectors.toList());

return CompletableFuture.completedFuture(new LookupResult(records, aliases));

}

return null;

}

private <T extends Throwable> CompletionStage<LookupResult> completeExceptionally(T failure) {

CompletableFuture<LookupResult> future = new CompletableFuture<>();

future.completeExceptionally(failure);

return future;

}

private CompletionStage<LookupResult> resolveRedirects(LookupResult response, Record query) {

return maybeFollowRedirect(response, query, 1);

}

private CompletionStage<LookupResult> maybeFollowRedirect(

LookupResult response, Record query, int redirectCount) {

if (redirectCount > maxRedirects) {

throw new RedirectOverflowException(maxRedirects);

}

List<Record> records = response.getRecords();

if (!records.isEmpty()

&& query.getType() != records.get(0).getType()

&& (records.get(0).getType() == Type.CNAME || records.get(0).getType() == Type.DNAME)) {

return maybeFollowRedirectsInAnswer(response, query, redirectCount);

} else {

return CompletableFuture.completedFuture(response);

}

}

private CompletionStage<LookupResult> maybeFollowRedirectsInAnswer(

LookupResult response, Record query, int redirectCount) {

List<Name> aliases = new ArrayList<>(response.getAliases());

List<Record> results = new ArrayList<>();

Name current = query.getName();

for (Record r : response.getRecords()) {

if (redirectCount > maxRedirects) {

throw new RedirectOverflowException(maxRedirects);

}

if (r.getDClass() != query.getDClass()) {

continue;

}

if (r.getType() == Type.CNAME && current.equals(r.getName())) {

aliases.add(current);

redirectCount++;

current = ((CNAMERecord) r).getTarget();

} else if (r.getType() == Type.DNAME && current.subdomain(r.getName())) {

aliases.add(current);

redirectCount++;

try {

current = current.fromDNAME((DNAMERecord) r);

} catch (NameTooLongException e) {

throw new InvalidZoneDataException(

"Cannot derive DNAME from " + r + " for " + current, e);

}

} else if (r.getType() == query.getType() && current.equals(r.getName())) {

results.add(r);

}

}

if (!results.isEmpty()) {

return CompletableFuture.completedFuture(new LookupResult(results, aliases));

}

if (redirectCount > maxRedirects) {

throw new RedirectOverflowException(maxRedirects);

}

int finalRedirectCount = redirectCount + 1;

Record redirectQuery = Record.newRecord(current, query.getType(), query.getDClass());

return lookupWithCache(redirectQuery, aliases)

.thenCompose(

responseFromCache ->

maybeFollowRedirect(responseFromCache, redirectQuery, finalRedirectCount));

}

/**

private static LookupResult buildResult(Message answer, List<Name> aliases, Record query) {

int rcode = answer.getRcode();

List<Record> answerRecords = answer.getSection(Section.ANSWER);

if (answerRecords.isEmpty() && rcode != Rcode.NOERROR) {

switch (rcode) {

case Rcode.NXDOMAIN:

throw new NoSuchDomainException(query.getName(), query.getType());

case Rcode.NXRRSET:

throw new NoSuchRRSetException(query.getName(), query.getType());

case Rcode.SERVFAIL:

if (answer.getOPT() != null) {

List<EDNSOption> options =

answer.getOPT().getOptions(EDNSOption.Code.EDNS_EXTENDED_ERROR);

if (!options.isEmpty()) {

throw new ServerFailedException(

query.getName(), query.getType(), (ExtendedErrorCodeOption) options.get(0));

}

}

throw new ServerFailedException(query.getName(), query.getType());

default:

throw new LookupFailedException(

String.format("Unknown non-success error code %s", Rcode.string(rcode)));

}

}

return new LookupResult(answerRecords, aliases);

}