public List<InetAddress> resolve(String host) { List<InetAddress> hostIPs = new ArrayList<>(); try { Lookup lookup = new Lookup(host, Type.A); lookup.setResolver(resolver); Record[] records = lookup.run(); if (records == null) { return hostIPs; } for (Record record : records) { hostIPs.add(((ARecord) record).getAddress()); } } catch (TextParseException ex) { Log.e(TAG, ex.getMessage(), ex); throw new IllegalStateException(ex); } return hostIPs; }
@Override public void setResolver(Resolver res) { lu.setResolver(res); }
protected List<Record> lookupRecords(String query, int type) throws TextParseException { Lookup lookup = new Lookup(query, type); if (this.resolver != null) { lookup.setResolver(this.resolver); } Record[] records = lookup.run(); return records == null ? new ArrayList<Record>() : Arrays.asList(records); }
@Nonnull protected Lookup createLookupFor(@Nonnull String query, @Nonnegative int type) { final Lookup lookup; try { lookup = new Lookup(query, type); } catch (final TextParseException e) { throw new IllegalArgumentException("Could not parse query: " + query, e); } final Resolver resolver = _resolver; lookup.setResolver(resolver != null ? resolver : getDefaultResolver()); lookup.setCache(null); return lookup; }
@Override public Lookup forName(String fqdn) { try { final Lookup lookup = new Lookup(fqdn, Type.SRV, DClass.IN); if (resolver != null) { lookup.setResolver(resolver); } return lookup; } catch (TextParseException e) { throw new DnsException("unable to create lookup for name: " + fqdn, e); } } }
@Nonnull protected Lookup createLookup (@Nonnull final String sHost) throws TextParseException { final Lookup aDNSLookup = new Lookup (sHost, Type.ANY); try { aDNSLookup.setResolver (new SimpleResolver ()); } catch (final UnknownHostException ex) { // Shit happens - no special resolver needed } // No cache! aDNSLookup.setCache (null); return aDNSLookup; }
private static boolean resolve(final Name name, final Resolver resolver, final int type) { final Lookup lookup = new Lookup(name, type); // NMS-9238: Do not use a cache when looking up the record, // that kind of defeats the purpose of this monitor :) lookup.setCache(null); lookup.setResolver(resolver); final Record[] records = lookup.run(); if (records == null) { return false; } return Arrays.stream(records) .filter(r -> r.getType() == type) .count() > 0; } }
public List<InetAddress> getAllAddresses(String hostName) throws UnknownHostException { Lookup lookup; try { lookup = new Lookup(hostName, Type.A); lookup.setCache(null); lookup.setResolver(new SimpleResolver(server)); } catch (TextParseException e) { throw new UnknownHostException(hostName); } List<InetAddress> addresses = new ArrayList<>(); Record[] a = lookup.run(); if (a == null || a.length == 0) { throw new UnknownHostException(hostName); } for (Record record : a) { addresses.add(((ARecord) record).getAddress()); } return addresses; } }
lu.setResolver(createExResolver(dnsServers.toArray(new String[dnsServers.size()]), 0, 6)); lu.setSearchPath((String[])null);
lu.setResolver(dnsResolver); lu.setSearchPath((String[])null); lu.setResolver(dnsResolver); lu.setSearchPath((String[])null);
/** * Performs a reverse DNS lookup. * * @param addr The ip address to lookup. * @return The host name found for the ip address. * Absent if the ip is not mapped, or something. * @throws IOException on a possibly temporary network error. */ private Optional<String> getHostByAddr(byte[] addr) throws IOException { Name name = ReverseMap.fromAddress(InetAddress.getByAddress(addr)); Record[] records; Lookup lookup; if (dnsServers!=null) { final Resolver res = new ExtendedResolver(dnsServers); lookup = new Lookup(name, Type.PTR); lookup.setResolver(res); records = lookup.run(); } else { lookup = new Lookup(name, Type.PTR); records = lookup.run(); } int result = lookup.getResult(); if (result==Lookup.TRY_AGAIN) { throw new IOException("Network error when trying to look up "+ Arrays.toString(addr) +", try again."); } if (result != Lookup.SUCCESSFUL || records == null) { return Optional.absent(); } return Optional.of(((PTRRecord) records[0]).getTarget().toString()); }
resolver.setTimeout(timeoutMs / 1000, timeoutMs % 1000); lookup.setResolver(resolver); Record[] records = lookup.run(); if (records == null || records.length == 0) {
/** * @see org.apache.james.jdkim.api.PublicKeyRecordRetriever#getRecords(java.lang.CharSequence, java.lang.CharSequence, java.lang.CharSequence) */ public List<String> getRecords(CharSequence methodAndOptions, CharSequence selector, CharSequence token) throws TempFailException, PermFailException { if (!"dns/txt".equals(methodAndOptions)) throw new PermFailException("Only dns/txt is supported: " + methodAndOptions + " options unsupported."); try { Lookup query = new Lookup(selector + "._domainkey." + token, Type.TXT); query.setResolver(resolver); Record[] rr = query.run(); int queryResult = query.getResult(); if (queryResult == Lookup.TRY_AGAIN) { throw new TempFailException(query.getErrorString()); } List<String> records = convertRecordsToList(rr); return records; } catch (TextParseException e) { // TODO log return null; } }
l.setResolver(resolver); l.setCredibility(dnsCredibility); l.setSearchPath(searchPaths);
l.setResolver(resolver); l.setCredibility(dnsCredibility); l.setSearchPath(searchPaths);
lu.setResolver(createExResolver(servers.toArray(new String[servers.size()]), retries, timeout)); // default retries is 3, limite to 2 lu.setSearchPath((String[])null); lu.setResolver(createExResolver(servers.toArray(new String[servers.size()]), retries, timeout)); lu.setSearchPath((String[])null); lu.setResolver(createExResolver(servers.toArray(new String[servers.size()]), retries, timeout)); lu.setSearchPath((String[])null); retRecords = lu.run(); ExtendedResolver remoteResolver = createExResolver(remoteServers, 2, 3); if (remoteResolver.getResolvers().length > 0) { lu.setResolver(remoteResolver); lu.setSearchPath((String[])null);
aLookup.setResolver (aNewResolver);
query.setResolver(resolver);