Java 类org.xbill.DNS.Name 实例源码

项目：open-rmbt 文件：Helperfunctions.java

public static String reverseDNSLookup(final InetAddress adr)
{
    try
    {
        final Name name = ReverseMap.fromAddress(adr);

        final Lookup lookup = new Lookup(name, Type.PTR);
        lookup.setResolver(new SimpleResolver());
        lookup.setCache(null);
        final Record[] records = lookup.run();
        if (lookup.getResult() == Lookup.SUCCESSFUL)
            for (final Record record : records)
                if (record instanceof PTRRecord)
                {
                    final PTRRecord ptr = (PTRRecord) record;
                    return ptr.getTarget().toString();
                }
    }
    catch (final Exception e)
    {
    }
    return null;
}

项目：openvisualtraceroute 文件：DNSLookupService.java

/**
 * Dns lookup more efficient than the INetAddress.getHostName(ip)
 *
 * @param hostIp
 * @return
 * @throws IOException
 */
public String dnsLookup(final String hostIp) {
    try {
        final Name name = ReverseMap.fromAddress(hostIp);
        final int type = Type.PTR;
        final int dclass = DClass.IN;
        final Record rec = Record.newRecord(name, type, dclass);
        final Message query = Message.newQuery(rec);

        final Message response = _resolver.send(query);

        final Record[] answers = response.getSectionArray(Section.ANSWER);
        if (answers.length > 0) {
            String ret = answers[0].rdataToString();
            if (ret.endsWith(".")) {
                ret = ret.substring(0, ret.length() - 1);
            }
            return ret;
        }
    } catch (final IOException e) {
        LOGGER.warn("Failed to resolve hostname for " + hostIp, e);
    }
    return UNKNOWN_HOST;
}

项目：nomulus 文件：DnsMessageTransportTest.java

@Test
public void testSentMessageTooLongThrowsException() throws Exception {
  Update oversize = new Update(Name.fromString("tld", Name.root));
  for (int i = 0; i < 2000; i++) {
    oversize.add(
        ARecord.newRecord(
            Name.fromString("test-extremely-long-name-" + i + ".tld", Name.root),
            Type.A,
            DClass.IN));
  }
  ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  when(mockSocket.getOutputStream()).thenReturn(outputStream);
  IllegalArgumentException thrown =
      expectThrows(IllegalArgumentException.class, () -> resolver.send(oversize));
  assertThat(thrown).hasMessageThat().contains("message larger than maximum");
}

项目：Camel 文件：DnsRecordConverter.java

/**
 * @param ip, like "192.168.1.1"
 * @return the complete DNS record for that IP.
 */
@Converter
public static Record toRecord(String ip) throws IOException {
    Resolver res = new ExtendedResolver();

    Name name = ReverseMap.fromAddress(ip);
    int type = Type.PTR;
    int dclass = DClass.IN;
    Record rec = Record.newRecord(name, type, dclass);
    Message query = Message.newQuery(rec);
    Message response = res.send(query);

    Record[] answers = response.getSectionArray(Section.ANSWER);
    if (answers.length == 0) {
        return null;
    } else {
        return answers[0];
    }
}

项目：Wilma 文件：CERTConverter.java

/** Builds a CERT record from a Certificate associated with a key also in DNS */
public static CERTRecord
buildRecord(Name name, int dclass, long ttl, Certificate cert, int tag,
        int alg)
{
    int type;
    byte [] data;

    try {
        if (cert instanceof X509Certificate) {
            type = CERTRecord.PKIX;
            data = cert.getEncoded();
        }
        else
            return null;

        return new CERTRecord(name, dclass, ttl, type, tag, alg, data);
    }
    catch (CertificateException e) {
        if (Options.check("verboseexceptions"))
            System.err.println("Cert build exception:" + e);
        return null;
    }
}

项目：plum 文件：DnsResolver.java

private String resolveHostByName(Resolver resolver, Name target) {
    Lookup lookup = new Lookup(target, A);
    if (resolver != null) {
        lookup.setResolver(resolver);
    }
    Record[] records = lookup.run();
    Optional<InetAddress> address = of(records)
            .filter(it -> it instanceof ARecord)
            .map(a -> ((ARecord) a).getAddress())
            .findFirst();
    if (address.isPresent()) {
        return address.get().getHostAddress();
    } else {
        log.warn("unknown name: " + target);
        return null;
    }
}

项目：ddns 文件：TestDatagram.java

public static void main(String[] args) throws Exception {
    try (DatagramSocket socket = new DatagramSocket()) {
        Message message = new Message();
        Header header = message.getHeader();
        header.setOpcode(Opcode.QUERY);
        header.setID(1);
        header.setRcode(Rcode.NOERROR);
        header.setFlag(Flags.RD);
        message.addRecord(Record.newRecord(new Name("www.xqbase.com."), Type.A, DClass.IN), Section.QUESTION);
        byte[] data = message.toWire();
        DatagramPacket packet = new DatagramPacket(data, data.length, new InetSocketAddress("localhost", 53));
        socket.send(packet);
        data = new byte[65536];
        packet = new DatagramPacket(data, data.length);
        socket.setSoTimeout(2000);
        socket.receive(packet);
        Message response = new Message(Bytes.left(data, packet.getLength()));
        System.out.println(response);
    }
}

项目：mireka 文件：MxLookup.java

/**
 * Returns an ordered host name list based on the MX records of the domain.
 * The first has the highest priority. If the domain has no MX records, then
 * it returns the host itself. Records with the same priority are shuffled
 * randomly.
 * 
 * @see <a href="http://tools.ietf.org/html/rfc5321#section-5.1">RFC 5321
 *      Simple Mail Transfer Protocol - Locating the Target Host</a>
 */
public Name[] queryMxTargets(Domain domain) throws MxLookupException {
    MXRecord[] records = queryMxRecords(domain);
    if (records.length == 0) {
        logger.debug("Domain {} has no MX records, using an implicit "
                + "MX record targetting the host", domain);
        return implicitMxTargetForDomain(domain);
    } else {
        //
        ArrayList<MXRecord> list =
                new ArrayList<MXRecord>(Arrays.asList(records));
        Collections.shuffle(list);
        // This sort is guaranteed to be stable: equal elements will not be
        // reordered as a result of the sort, so shuffle remains in effect
        Collections.sort(list, mxRecordPriorityComparator);
        list.toArray(records);
        return convertMxRecordsToHostNames(records);
    }
}