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

static void doAXFR(Message response) throws IOException {
    System.out.println("; java dig 0.0 <> " + name + " axfr");
    if (response.isSigned()) {
        System.out.print(";; TSIG ");
        if (response.isVerified())
            System.out.println("ok");
        else
            System.out.println("failed");
    }

    if (response.getRcode() != Rcode.NOERROR) {
        System.out.println(response);
        return;
    }

    Record [] records = response.getSectionArray(Section.ANSWER);
    for (int i = 0; i < records.length; i++)
        System.out.println(records[i]);

    System.out.print(";; done (");
    System.out.print(response.getHeader().getCount(Section.ANSWER));
    System.out.print(" records, ");
    System.out.print(response.getHeader().getCount(Section.ADDITIONAL));
    System.out.println(" additional)");
}

/**
 * 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;
}

/**
 * @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];
    }
}

@Test
@Ignore("Testing behind nat produces timeouts")
public void testDigForMonkey() throws Exception {
    resultEndpoint.expectedMessageCount(1);
    resultEndpoint.expectedMessagesMatches(new Predicate() {
        public boolean matches(Exchange exchange) {
            String str = ((Message) exchange.getIn().getBody()).getSectionArray(Section.ANSWER)[0].rdataToString();
            return RESPONSE_MONKEY.equals(str);
        }
    });
    Map<String, Object> headers = new HashMap<String, Object>();
    headers.put("dns.name", "monkey.wp.dg.cx");
    headers.put("dns.type", "TXT");
    template.sendBodyAndHeaders(null, headers);
    resultEndpoint.assertIsSatisfied();
}

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);
    }
}

private String[] findAddressesRecursive(Set<Name> stack, Name target) throws IOException {
    String[] ipv4Addresses = null;
    String[] ipv6Addresses = null;
    Message ipv4 = lookup(stack, getRoots(), Message.newQuery(Record.newRecord(target, Type.A, DClass.IN)));
    if (ipv4 != null)
        ipv4Addresses = findAddresses(target, ipv4.getSectionArray(Section.ANSWER));
    Message ipv6 = lookup(stack, getRoots(), Message.newQuery(Record.newRecord(target, Type.AAAA, DClass.IN)));
    if (ipv6 != null)
        ipv6Addresses = findAddresses(target, ipv6.getSectionArray(Section.ANSWER));

    String[] addresses = new String[0];
    if (ipv4Addresses != null)
        addresses = ipv4Addresses;
    if (ipv6Addresses != null) {
        String[] concatAddresses = new String[addresses.length + ipv6Addresses.length];
        System.arraycopy(addresses, 0, concatAddresses, 0, addresses.length);
        System.arraycopy(ipv6Addresses, 0, concatAddresses, addresses.length, ipv6Addresses.length);
        addresses = concatAddresses;
    }

    if (addresses.length == 0)
        return null;
    return addresses;
}

private Message getCached(Message query) {
    Cache cache = getCache();
    if (cache == null)
        return null;

    Record question = query.getQuestion();
    RRset[] rrsets = cache.findAnyRecords(question.getName(), question.getType());
    if (rrsets == null)
        return null;

    Message msg = new Message();
    for (RRset rrset : rrsets) {
        @SuppressWarnings("unchecked")
        Iterator<Record> recordsIter = rrset.rrs();
        while (recordsIter.hasNext()) {
            msg.addRecord(recordsIter.next(), Section.ANSWER);
        }
    }
    return msg;
}

/**
 * Gets the number of records.
 * 
 * @param section The section for which the records are counted.
 * @return The number of records for the queried section.
 */
public int getCount(int section) {
    if (section == Section.QUESTION) {
        return 1;
    }

    List<SRRset> sectionList = this.getSectionRRsets(section);
    if (sectionList.size() == 0) {
        return 0;
    }

    int count = 0;
    for (SRRset sr : sectionList) {
        count += sr.size();
    }

    return count;
}

@Test
public void testUnsignedThatMustBeSigned() throws IOException {
    Name query = Name.fromString("www.ingotronic.ch.");

    // prepare a faked, unsigned response message that must have a signature
    // to be valid
    Message message = new Message();
    message.addRecord(Record.newRecord(query, Type.A, DClass.IN), Section.QUESTION);
    message.addRecord(new ARecord(query, Type.A, DClass.IN, InetAddress.getByName(localhost)), Section.ANSWER);
    add("www.ingotronic.ch./A", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.bogus.missingsig", getReason(response));
}

@Test
public void testModifiedSignature() throws IOException {
    Name query = Name.fromString("www.ingotronic.ch.");

    // prepare a faked, unsigned response message that must have a signature
    // to be valid
    Message message = new Message();
    message.addRecord(Record.newRecord(query, Type.A, DClass.IN), Section.QUESTION);
    message.addRecord(new ARecord(query, Type.A, DClass.IN, InetAddress.getByName(localhost)), Section.ANSWER);
    message.addRecord(new RRSIGRecord(query, DClass.IN, 0, Type.A, Algorithm.RSASHA256, 5, new Date(System.currentTimeMillis() + 5000), new Date(System.currentTimeMillis() - 5000), 1234, Name.fromString("ingotronic.ch."), new byte[] { 1, 2, 3 }), Section.ANSWER);
    add("www.ingotronic.ch./A", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertTrue(getReason(response).startsWith("failed.answer.positive:{ www.ingotronic.ch."));
}

@Test
public void testValidAnswerToDifferentQueryTypeIsBogus() throws IOException {
    Message m = resolver.send(createMessage("www.ingotronic.ch./A"));
    Message message = createMessage("www.ingotronic.ch./MX");
    for (int i = 1; i < Section.ADDITIONAL; i++) {
        for (Record r: m.getSectionArray(i)) {
            message.addRecord(r, i);
        }
    }

    add("www.ingotronic.ch./A", message);
    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.response.unknown:UNKNOWN", getReason(response));
}

protected String getReason(Message m) {
    for (RRset set : m.getSectionRRsets(Section.ADDITIONAL)) {
        if (set.getName().equals(Name.root) && set.getType() == Type.TXT && set.getDClass() == ValidatingResolver.VALIDATION_REASON_QCLASS) {
            StringBuilder sb = new StringBuilder();
            @SuppressWarnings("unchecked")
            List<String> strings = (List<String>)((TXTRecord)set.first()).getStrings();
            for (String part : strings){
                sb.append(part);
            }

            return sb.toString();
        }
    }

    return null;
}

private static String reverseDnsLookupUsingDnsJavaSimpleResolver(long ipAddress) throws IOException {
    String result = null;
    byte[] address = convertLongAddressToBuf(ipAddress);
    Name name = ReverseMap.fromAddress(InetAddress.getByAddress(address));
    Record record = Record.newRecord(name, Type.PTR, DClass.IN);
    Message query = Message.newQuery(record);
    Message response = simpleResolver.send(query);
    Record[] answers = response.getSectionArray(Section.ANSWER);
    if (answers.length != 0) {
        // If PTR-record exists this will be at index 1 or above (more than one PTR-record may exist)
        Record answer = (answers.length > 1) ? answers[1] : answers[0];  
        result = answer.rdataToString();
        // remove trailing "."
        result = result.endsWith(".") ? result.substring(0, result.length() - 1) : result;
    } else {
        throw new IOException("Empty DNS response.");
    }
    return result;
}

private ImmutableList<Record> findUpdateRecords(
    Update update, String resourceName, int recordType) {
  for (RRset set : update.getSectionRRsets(Section.UPDATE)) {
    if (set.getName().toString().equals(resourceName) && set.getType() == recordType) {
      return fixIterator(Record.class, set.rrs());
    }
  }
  assert_().fail(
      "No record set found for resource '%s' type '%s'",
      resourceName, Type.string(recordType));
  throw new AssertionError();
}

@Override
public void process(Exchange exchange) throws Exception {
    SimpleResolver resolver = new SimpleResolver();
    int type = Type.TXT;
    Name name = Name.fromString(String.valueOf(exchange.getIn().getHeader(DnsConstants.TERM)) + ".wp.dg.cx", Name.root);
    Record rec = Record.newRecord(name, type, DClass.IN);
    Message query = Message.newQuery(rec);
    Message response = resolver.send(query);
    Record[] records = response.getSectionArray(Section.ANSWER);
    if (records.length > 0) {
        exchange.getIn().setBody(records[0].rdataToString());
    } else {
        exchange.getIn().setBody(null);
    }
}

@Test
public void testDigForMonkey() throws Exception {
    resultEndpoint.expectedMessageCount(1);
    resultEndpoint.expectedMessagesMatches(new Predicate() {
        public boolean matches(Exchange exchange) {
            String str = ((Message) exchange.getIn().getBody()).getSectionArray(Section.ANSWER)[0].rdataToString();
            return RESPONSE_MONKEY.equals(str);
        }
    });
    Map<String, Object> headers = new HashMap<String, Object>();
    headers.put("dns.name", "monkey.wp.dg.cx");
    headers.put("dns.type", "TXT");
    template.sendBodyAndHeaders(null, headers);
    resultEndpoint.assertIsSatisfied();
}

private Message messageWithRCode(String query, int rcode) throws TextParseException {
  Name queryName = Name.fromString(query);
  Record question = Record.newRecord(queryName, Type.SRV, DClass.IN);
  Message queryMessage = Message.newQuery(question);
  Message result = new Message();
  result.setHeader(queryMessage.getHeader());
  result.addRecord(question, Section.QUESTION);

  result.getHeader().setRcode(rcode);

  return result;
}

private Message messageWithNodes(String query, Iterable<String> names) throws TextParseException {
  Name queryName = Name.fromString(query);
  Record question = Record.newRecord(queryName, Type.SRV, DClass.IN);
  Message queryMessage = Message.newQuery(question);
  Message result = new Message();
  result.setHeader(queryMessage.getHeader());
  result.addRecord(question, Section.QUESTION);

  for (String name1 : names){
    result.addRecord(new SRVRecord(queryName, DClass.IN, 1, 1, 1, 8080, Name.fromString(name1)), Section.ANSWER);
  }

  return result;
}

@Test
public void canResolveRecord() throws Exception {
    AcceptanceTestRunner runner = new AcceptanceTestRunner();
    runner.runUngarded(new AcceptanceScenario() {

        public void run(WebDriver driver, String deployedURL) throws Exception {
            int id = new SecureRandom().nextInt();
            final String systemTestBase = "system-tests.onomate.test";
            final String soaBase = "soa-" + id +"."+ systemTestBase;
            final String ns = "ns." + soaBase;
            final String contactName = "admin." + soaBase;
            final String aTestRecordHost = "record."+soaBase;
            final String aTestRecordNS = "ns.test";

            OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL);
            OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName);
            board.authorityByZone(soaBase).details().createRecord(aTestRecordHost, OnomateAssembly.RecordType.NS, aTestRecordNS);

            Options.set("verbose");

            SimpleResolver resolver = new SimpleResolver();
            resolver.setAddress(InetAddress.getLocalHost());
            resolver.setPort(9101);

            Record query = Record.newRecord(Name.fromString(aTestRecordHost + "."), Type.NS, DClass.IN);
            Message question = Message.newQuery(query);
            Message response = resolver.send(question);
            Record responses[] = response.getSectionArray(Section.AUTHORITY);
            NSRecord record = ((NSRecord) responses[0]);
            assertEquals(record.getName().toString(), aTestRecordHost+ ".");
            assertEquals(record.getTarget().toString(), aTestRecordNS + ".");
        }
    });
}

@Test
public void canResolveRecord() throws Exception {
    AcceptanceTestRunner runner = new AcceptanceTestRunner();
    runner.runUngarded(new AcceptanceScenario() {

        public void run(WebDriver driver, String deployedURL) throws Exception {
            int id = new SecureRandom().nextInt();
            final String systemTestBase = "system-tests.onomate.test";
            final String soaBase = "soa-" + id +"."+ systemTestBase;
            final String ns = "ns." + soaBase;
            final String contactName = "admin." + soaBase;
            final String aTestRecordHost = "record."+soaBase;
            final String aRealTestRecord = soaBase;

            OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL);
            OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName);
            board.authorityByZone(soaBase).details().createRecord(aTestRecordHost, OnomateAssembly.RecordType.CNAME, aRealTestRecord);

            Options.set("verbose");

            SimpleResolver resolver = new SimpleResolver();
            resolver.setAddress(InetAddress.getLocalHost());
            resolver.setPort(9101);

            Record query = Record.newRecord(Name.fromString(aTestRecordHost + "."), Type.CNAME, DClass.IN);
            Message question = Message.newQuery(query);
            Message response = resolver.send(question);
            Record responses[] = response.getSectionArray(Section.ANSWER);
            CNAMERecord record = ((CNAMERecord) responses[0]);
            assertEquals(record.getName().toString(), aTestRecordHost+ ".");
            assertEquals(record.getTarget().toString(), aRealTestRecord + ".");
        }
    });
}

/**
 * Checks if the authority section of a message contains at least one signed
 * NSEC or NSEC3 record.
 * 
 * @param message The message to inspect.
 * @return True if at least one record is found, false otherwise.
 */
public boolean hasSignedNsecs(SMessage message) {
    for (SRRset set : message.getSectionRRsets(Section.AUTHORITY)) {
        if (set.getType() == Type.NSEC || set.getType() == Type.NSEC3) {
            if (set.sigs().hasNext()) {
                return true;
            }
        }
    }

    return false;
}

/**
 * Creates a new instance of this class.
 * 
 * @param m The DNS message to wrap.
 */
public SMessage(Message m) {
    this(m.getHeader());
    this.question = m.getQuestion();
    this.oPTRecord = m.getOPT();

    for (int i = Section.ANSWER; i <= Section.ADDITIONAL; i++) {
        RRset[] rrsets = m.getSectionRRsets(i);

        for (int j = 0; j < rrsets.length; j++) {
            this.addRRset(new SRRset(rrsets[j]), i);
        }
    }
}

@Test
public void testHasSignedNsecsWithoutSignedSigsReturnsFalse() {
    Message m = new Message();
    m.addRecord(new NSECRecord(Name.root, DClass.IN, 0, Name.root, new int[] { Type.A }), Section.AUTHORITY);
    SMessage sm = new SMessage(m);
    boolean result = new ValUtils().hasSignedNsecs(sm);
    assertFalse(result);
}

private Message stripAdditional(Message m) {
    if (m.getQuestion().getType() == Type.RRSIG) {
        return m;
    }

    Message copy = new Message();
    copy.setHeader(m.getHeader());
    for (int i = 0; i < Section.ADDITIONAL; i++) {
        for (RRset set : m.getSectionRRsets(i)) {
            if (set.getType() == Type.NS && m.getQuestion().getType() != Type.NS) {
                continue;
            }

            Iterator<?> rrs = set.rrs();
            while (rrs.hasNext()) {
                copy.addRecord((Record)rrs.next(), i);
            }

            Iterator<?> sigs = set.sigs();
            while (sigs.hasNext()) {
                copy.addRecord((Record)sigs.next(), i);
            }
        }
    }

    return copy;
}

@Test()
public void testGetSectionByType() throws UnknownHostException {
    Message m = new Message();
    Record r1 = new ARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0}));
    m.addRecord(r1, Section.ANSWER);
    Record r2 = new AAAARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}));
    m.addRecord(r2, Section.ANSWER);
    SMessage sm = new SMessage(m);
    SRRset[] result = sm.getSectionRRsets(Section.ANSWER, Type.A);
    assertEquals(1, result.length);
    assertEquals(Type.A, result[0].getType());
}

@Test()
public void testRecordCountForIsValid() throws UnknownHostException {
    Message m = new Message();
    m.addRecord(new ARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0})), Section.ANSWER);
    SMessage sm = new SMessage(m);
    int count = sm.getCount(Section.ANSWER);
    assertEquals(1, count);
}

@Test()
public void testAnswerSectionSearchFound() throws UnknownHostException {
    Message m = new Message();
    Record r = new ARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0}));
    m.addRecord(r, Section.ANSWER);
    SMessage sm = new SMessage(m);
    SRRset result = sm.findAnswerRRset(Name.root, Type.A, DClass.IN);
    assertEquals(r, result.first());
}

@Test()
public void testAnswerSectionSearchNotFoundDifferentClass() throws UnknownHostException {
    Message m = new Message();
    Record r = new ARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0}));
    m.addRecord(r, Section.ANSWER);
    SMessage sm = new SMessage(m);
    SRRset result = sm.findAnswerRRset(Name.root, Type.A, DClass.CH);
    assertNull(result);
}

@Test()
public void testAnswerSectionSearchNotFoundDifferentType() throws UnknownHostException {
    Message m = new Message();
    Record r = new ARecord(Name.root, DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0}));
    m.addRecord(r, Section.ANSWER);
    SMessage sm = new SMessage(m);
    SRRset result = sm.findAnswerRRset(Name.root, Type.MX, DClass.IN);
    assertNull(result);
}

@Test()
public void testAnswerSectionSearchNotFoundDifferentName() throws UnknownHostException, TextParseException {
    Message m = new Message();
    Record r = new ARecord(Name.fromString("asdf."), DClass.IN, 0, InetAddress.getByAddress(new byte[]{0,0,0,0}));
    m.addRecord(r, Section.ANSWER);
    SMessage sm = new SMessage(m);
    SRRset result = sm.findAnswerRRset(Name.root, Type.MX, DClass.IN);
    assertNull(result);
}

@Test
public void testDNameDirectQueryIsValid() throws IOException {
    Message response = resolver.send(createMessage("alias.ingotronic.ch./DNAME"));
    assertTrue("AD flag must not set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.NOERROR, response.getRcode());
    assertNull(getReason(response));
    for (RRset set : response.getSectionRRsets(Section.ANSWER)) {
        if (set.getType() == Type.DNAME) {
            DNAMERecord r = (DNAMERecord)set.first();
            assertEquals(Name.fromString("ingotronic.ch."), r.getTarget());
        }
    }
}

@SuppressWarnings("unchecked")
@Test
public void testDNameInNsecIsUnderstood_Rfc6672_5_3_4_1() throws IOException {
    Message nsecs = resolver.send(createMessage("alias.ingotronic.ch./NS"));
    RRset nsecSet = null;
    for (RRset set : nsecs.getSectionRRsets(Section.AUTHORITY)) {
        if (set.getName().equals(Name.fromString("alias.ingotronic.ch."))) {
            nsecSet = set;
            break;
        }
    }

    Message message = new Message();
    message.getHeader().setRcode(Rcode.NXDOMAIN);
    message.addRecord(Record.newRecord(Name.fromString("www.alias.ingotronic.ch."), Type.A, DClass.IN), Section.QUESTION);
    Iterator<Record> rrs = nsecSet.rrs();
    while (rrs.hasNext()) {
        message.addRecord(rrs.next(), Section.AUTHORITY);
    }
    Iterator<Record> sigs = nsecSet.sigs();
    while (sigs.hasNext()) {
        message.addRecord(sigs.next(), Section.AUTHORITY);
    }

    add("www.alias.ingotronic.ch./A", message);

    Message response = resolver.send(createMessage("www.alias.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("failed.nxdomain.exists:www.alias.ingotronic.ch.", getReason(response));
}

@Test
public void testDnskeyPrimeResponseWithEmptyAnswerIsBad() throws IOException {
    Message message = new Message();
    message.addRecord(Record.newRecord(Name.root, Type.DNSKEY, DClass.IN), Section.QUESTION);
    add("./DNSKEY", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.bogus.badkey:.:dnskey.no_rrset:.", getReason(response));
}

@Test
public void testRootDnskeyPrimeResponseWithNxDomainIsBad() throws IOException {
    Message message = new Message();
    message.addRecord(Record.newRecord(Name.root, Type.DNSKEY, DClass.IN), Section.QUESTION);
    message.getHeader().setRcode(Rcode.NXDOMAIN);
    add("./DNSKEY", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.bogus.badkey:.:dnskey.no_rrset:.", getReason(response));
}

@Test
public void testDsPrimeResponseWithEmptyAnswerIsBad() throws IOException {
    Message message = new Message();
    message.addRecord(Record.newRecord(Name.fromString("ch."), Type.DS, DClass.IN), Section.QUESTION);
    add("ch./DS", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.bogus.badkey:ch.:failed.ds.nonsec:ch.", getReason(response));
}

@Test
public void testDsPrimeResponseWithNxDomainForTld() throws IOException {
    Message message = new Message();
    message.addRecord(Record.newRecord(Name.fromString("ch."), Type.DS, DClass.IN), Section.QUESTION);
    message.getHeader().setRcode(Rcode.NXDOMAIN);
    add("ch./DS", message);

    Message response = resolver.send(createMessage("www.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
    assertEquals("validate.bogus.badkey:ch.:failed.ds.nonsec:ch.", getReason(response));
}

@Test
public void testDsNodataFromWildcardNsecChild() throws IOException {
    Message m = Message.newQuery(Record.newRecord(Name.fromString("www.x.c.ingotronic.ch."), Type.A, DClass.IN));
    m.addRecord(new ARecord(Name.fromString("www.x.c.ingotronic.ch."), DClass.IN, 300, InetAddress.getLocalHost()), Section.ANSWER);
    add("www.x.c.ingotronic.ch./A", m);

    Message response = resolver.send(createMessage("www.x.c.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
}

@Test
public void testDsNodataFromWildcardNsecCovered() throws IOException {
    Message m = Message.newQuery(Record.newRecord(Name.fromString("www.x.ce.ingotronic.ch."), Type.A, DClass.IN));
    m.addRecord(new ARecord(Name.fromString("www.x.ce.ingotronic.ch."), DClass.IN, 300, InetAddress.getLocalHost()), Section.ANSWER);
    add("www.x.ce.ingotronic.ch./A", m);

    Message response = resolver.send(createMessage("www.x.ce.ingotronic.ch./A"));
    assertFalse("AD flag must not be set", response.getHeader().getFlag(Flags.AD));
    assertEquals(Rcode.SERVFAIL, response.getRcode());
}

@Test
public void testSmessageReturnsOptRecordOfOriginal() {
    int xrcode = 0xFED;
    Message m = Message.newQuery(Record.newRecord(Name.root, Type.NS, DClass.IN));
    m.getHeader().setRcode(xrcode & 0xF);
    m.addRecord(new OPTRecord(1, xrcode >> 4, 1), Section.ADDITIONAL);
    SMessage sm = new SMessage(m);
    assertEquals(m.toString(), sm.getMessage().toString());
    assertEquals(xrcode, sm.getRcode());
}

@Test
public void testCopyMessageWithoutQuestion() {
    Message m = new Message();
    m.addRecord(new ARecord(Name.root, DClass.IN, 120, localhost), Section.ANSWER);
    SMessage sm = new SMessage(m);
    assertEquals(m.toString(), sm.getMessage().toString());
}