From 858cac9ccd6496ccb107845cb9552d4e404d3103 Mon Sep 17 00:00:00 2001 From: Stephane Landelle Date: Wed, 23 Mar 2016 12:34:50 +0100 Subject: [PATCH] Update DNS codec --- .../handler/codec/dns/AbstractDnsRecord.java | 14 +- .../codec/dns/DatagramDnsQueryDecoder.java | 114 +++++++++++++++ .../codec/dns/DatagramDnsQueryEncoder.java | 22 +-- .../codec/dns/DatagramDnsResponseDecoder.java | 11 +- .../codec/dns/DatagramDnsResponseEncoder.java | 133 ++++++++++++++++++ .../codec/dns/DefaultDnsPtrRecord.java | 72 ++++++++++ .../codec/dns/DefaultDnsRecordDecoder.java | 4 + .../codec/dns/DefaultDnsRecordEncoder.java | 12 ++ .../handler/codec/dns/DnsMessageUtil.java | 2 +- .../netty/handler/codec/dns/DnsPtrRecord.java | 25 ++++ .../codec/dns/AbstractDnsRecordTest.java | 18 ++- .../netty/resolver/dns/DefaultDnsCache.java | 3 +- .../dns/DefaultDnsNameResolverBuilder.java | 43 ------ .../resolver/dns/DnsAddressResolverGroup.java | 2 +- .../java/io/netty/resolver/dns/DnsCache.java | 2 - .../netty/resolver/dns/DnsNameResolver.java | 49 +++++-- .../resolver/dns/DnsNameResolverBuilder.java | 125 ++++++++-------- .../netty/resolver/dns/DnsQueryContext.java | 28 ++-- .../resolver/dns/DnsServerAddresses.java | 4 +- .../resolver/dns/DnsNameResolverTest.java | 7 +- 20 files changed, 538 insertions(+), 152 deletions(-) create mode 100644 netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryDecoder.java create mode 100644 netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseEncoder.java create mode 100644 netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsPtrRecord.java create mode 100644 netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsPtrRecord.java delete mode 100644 netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsNameResolverBuilder.java diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/AbstractDnsRecord.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/AbstractDnsRecord.java index e15ace4e88..bf3cd685bd 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/AbstractDnsRecord.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/AbstractDnsRecord.java @@ -15,9 +15,10 @@ */ package io.netty.handler.codec.dns; +import io.netty.util.internal.StringUtil; + import java.net.IDN; -import io.netty.util.internal.StringUtil; import static io.netty.util.internal.ObjectUtil.checkNotNull; /** @@ -62,16 +63,23 @@ protected AbstractDnsRecord(String name, DnsRecordType type, int dnsClass, long if (timeToLive < 0) { throw new IllegalArgumentException("timeToLive: " + timeToLive + " (expected: >= 0)"); } - // Convert to ASCII which will also check that the length is not too big. + // Convert to ASCII which will also check that the length is not too big. // See: // - https://github.com/netty/netty/issues/4937 // - https://github.com/netty/netty/issues/4935 - this.name = IDN.toASCII(checkNotNull(name, "name")); + this.name = appendTrailingDot(IDN.toASCII(checkNotNull(name, "name"))); this.type = checkNotNull(type, "type"); this.dnsClass = (short) dnsClass; this.timeToLive = timeToLive; } + private static String appendTrailingDot(String name) { + if (name.length() > 0 && name.charAt(name.length() - 1) != '.') { + return name + '.'; + } + return name; + } + @Override public String name() { return name; diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryDecoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryDecoder.java new file mode 100644 index 0000000000..c932075572 --- /dev/null +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryDecoder.java @@ -0,0 +1,114 @@ +/* + * Copyright 2015 The Netty Project + * + * The Netty Project licenses this file to you under the Apache License, + * version 2.0 (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ +package io.netty.handler.codec.dns; + +import io.netty.buffer.ByteBuf; +import io.netty.channel.ChannelHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.socket.DatagramPacket; +import io.netty.handler.codec.CorruptedFrameException; +import io.netty.handler.codec.MessageToMessageDecoder; + +import java.net.InetSocketAddress; +import java.util.List; + +import static io.netty.util.internal.ObjectUtil.checkNotNull; + +/** + * Decodes a {@link DatagramPacket} into a {@link DatagramDnsQuery}. + */ +@ChannelHandler.Sharable +public class DatagramDnsQueryDecoder extends MessageToMessageDecoder { + + private final DnsRecordDecoder recordDecoder; + + /** + * Creates a new decoder with {@linkplain DnsRecordDecoder#DEFAULT the default record decoder}. + */ + public DatagramDnsQueryDecoder() { + this(DnsRecordDecoder.DEFAULT); + } + + /** + * Creates a new decoder with the specified {@code recordDecoder}. + */ + public DatagramDnsQueryDecoder(DnsRecordDecoder recordDecoder) { + this.recordDecoder = checkNotNull(recordDecoder, "recordDecoder"); + } + + @Override + protected void decode(ChannelHandlerContext ctx, DatagramPacket packet, List out) throws Exception { + final ByteBuf buf = packet.content(); + + final DnsQuery query = newQuery(packet, buf); + boolean success = false; + try { + final int questionCount = buf.readUnsignedShort(); + final int answerCount = buf.readUnsignedShort(); + final int authorityRecordCount = buf.readUnsignedShort(); + final int additionalRecordCount = buf.readUnsignedShort(); + + decodeQuestions(query, buf, questionCount); + decodeRecords(query, DnsSection.ANSWER, buf, answerCount); + decodeRecords(query, DnsSection.AUTHORITY, buf, authorityRecordCount); + decodeRecords(query, DnsSection.ADDITIONAL, buf, additionalRecordCount); + + out.add(query); + success = true; + } finally { + if (!success) { + query.release(); + } + } + } + + private static DnsQuery newQuery(DatagramPacket packet, ByteBuf buf) { + final int id = buf.readUnsignedShort(); + + final int flags = buf.readUnsignedShort(); + if (flags >> 15 == 1) { + throw new CorruptedFrameException("not a query"); + } + final DnsQuery query = + new DatagramDnsQuery( + packet.sender(), + packet.recipient(), + id, + DnsOpCode.valueOf((byte) (flags >> 11 & 0xf))); + query.setRecursionDesired((flags >> 8 & 1) == 1); + query.setZ(flags >> 4 & 0x7); + return query; + } + + private void decodeQuestions(DnsQuery query, ByteBuf buf, int questionCount) throws Exception { + for (int i = questionCount; i > 0; i--) { + query.addRecord(DnsSection.QUESTION, recordDecoder.decodeQuestion(buf)); + } + } + + private void decodeRecords( + DnsQuery query, DnsSection section, ByteBuf buf, int count) throws Exception { + for (int i = count; i > 0; i--) { + final DnsRecord r = recordDecoder.decodeRecord(buf); + if (r == null) { + // Truncated response + break; + } + + query.addRecord(section, r); + } + } +} diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryEncoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryEncoder.java index 62b607324b..8344801a45 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryEncoder.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsQueryEncoder.java @@ -52,8 +52,8 @@ public DatagramDnsQueryEncoder(DnsRecordEncoder recordEncoder) { @Override protected void encode( - ChannelHandlerContext ctx, - AddressedEnvelope in, List out) throws Exception { + ChannelHandlerContext ctx, + AddressedEnvelope in, List out) throws Exception { final InetSocketAddress recipient = in.recipient(); final DnsQuery query = in.content(); @@ -79,24 +79,24 @@ protected void encode( * Sub-classes may override this method to return a {@link ByteBuf} with a perfect matching initial capacity. */ protected ByteBuf allocateBuffer( - ChannelHandlerContext ctx, - @SuppressWarnings("unused") AddressedEnvelope msg) throws Exception { + ChannelHandlerContext ctx, + @SuppressWarnings("unused") AddressedEnvelope msg) throws Exception { return ctx.alloc().ioBuffer(1024); } /** * Encodes the header that is always 12 bytes long. * - * @param query - * the query header being encoded - * @param buf - * the buffer the encoded data should be written to + * @param query the query header being encoded + * @param buf the buffer the encoded data should be written to */ private static void encodeHeader(DnsQuery query, ByteBuf buf) { buf.writeShort(query.id()); int flags = 0; flags |= (query.opCode().byteValue() & 0xFF) << 14; - flags |= query.isRecursionDesired()? 1 << 8 : 0; + if (query.isRecursionDesired()) { + flags |= 1 << 8; + } buf.writeShort(flags); buf.writeShort(query.count(DnsSection.QUESTION)); buf.writeShort(0); // answerCount @@ -106,14 +106,14 @@ private static void encodeHeader(DnsQuery query, ByteBuf buf) { private void encodeQuestions(DnsQuery query, ByteBuf buf) throws Exception { final int count = query.count(DnsSection.QUESTION); - for (int i = 0; i < count; i ++) { + for (int i = 0; i < count; i++) { recordEncoder.encodeQuestion((DnsQuestion) query.recordAt(DnsSection.QUESTION, i), buf); } } private void encodeRecords(DnsQuery query, DnsSection section, ByteBuf buf) throws Exception { final int count = query.count(section); - for (int i = 0; i < count; i ++) { + for (int i = 0; i < count; i++) { recordEncoder.encodeRecord(query.recordAt(section, i), buf); } } diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseDecoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseDecoder.java index b4c1fd09e0..c9e879a47f 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseDecoder.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseDecoder.java @@ -51,10 +51,9 @@ public DatagramDnsResponseDecoder(DnsRecordDecoder recordDecoder) { @Override protected void decode(ChannelHandlerContext ctx, DatagramPacket packet, List out) throws Exception { - final InetSocketAddress sender = packet.sender(); final ByteBuf buf = packet.content(); - final DnsResponse response = newResponse(sender, buf); + final DnsResponse response = newResponse(packet, buf); boolean success = false; try { final int questionCount = buf.readUnsignedShort(); @@ -76,7 +75,7 @@ protected void decode(ChannelHandlerContext ctx, DatagramPacket packet, List> 11 & 0xf)), DnsResponseCode.valueOf((byte) (flags & 0xf))); + packet.sender(), + packet.recipient(), + id, + DnsOpCode.valueOf((byte) (flags >> 11 & 0xf)), DnsResponseCode.valueOf((byte) (flags & 0xf))); response.setRecursionDesired((flags >> 8 & 1) == 1); response.setAuthoritativeAnswer((flags >> 10 & 1) == 1); diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseEncoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseEncoder.java new file mode 100644 index 0000000000..ac7d909156 --- /dev/null +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DatagramDnsResponseEncoder.java @@ -0,0 +1,133 @@ +/* + * Copyright 2015 The Netty Project + * + * The Netty Project licenses this file to you under the Apache License, + * version 2.0 (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ +package io.netty.handler.codec.dns; + +import io.netty.buffer.ByteBuf; +import io.netty.channel.AddressedEnvelope; +import io.netty.channel.ChannelHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.socket.DatagramPacket; +import io.netty.handler.codec.MessageToMessageEncoder; + +import java.net.InetSocketAddress; +import java.util.List; + +import static io.netty.util.internal.ObjectUtil.checkNotNull; + +/** + * Encodes a {@link DatagramDnsResponse} (or an {@link AddressedEnvelope} of {@link DnsResponse}} into a + * {@link DatagramPacket}. + */ +@ChannelHandler.Sharable +public class DatagramDnsResponseEncoder + extends MessageToMessageEncoder> { + + private final DnsRecordEncoder recordEncoder; + + /** + * Creates a new encoder with {@linkplain DnsRecordEncoder#DEFAULT the default record encoder}. + */ + public DatagramDnsResponseEncoder() { + this(DnsRecordEncoder.DEFAULT); + } + + /** + * Creates a new encoder with the specified {@code recordEncoder}. + */ + public DatagramDnsResponseEncoder(DnsRecordEncoder recordEncoder) { + this.recordEncoder = checkNotNull(recordEncoder, "recordEncoder"); + } + + @Override + protected void encode(ChannelHandlerContext ctx, + AddressedEnvelope in, List out) throws Exception { + + final InetSocketAddress recipient = in.recipient(); + final DnsResponse response = in.content(); + final ByteBuf buf = allocateBuffer(ctx, in); + + boolean success = false; + try { + encodeHeader(response, buf); + encodeQuestions(response, buf); + encodeRecords(response, DnsSection.ANSWER, buf); + encodeRecords(response, DnsSection.AUTHORITY, buf); + encodeRecords(response, DnsSection.ADDITIONAL, buf); + success = true; + } finally { + if (!success) { + buf.release(); + } + } + + out.add(new DatagramPacket(buf, recipient, null)); + } + + /** + * Allocate a {@link ByteBuf} which will be used for constructing a datagram packet. + * Sub-classes may override this method to return a {@link ByteBuf} with a perfect matching initial capacity. + */ + protected ByteBuf allocateBuffer( + ChannelHandlerContext ctx, + @SuppressWarnings("unused") AddressedEnvelope msg) throws Exception { + return ctx.alloc().ioBuffer(1024); + } + + /** + * Encodes the header that is always 12 bytes long. + * + * @param response the response header being encoded + * @param buf the buffer the encoded data should be written to + */ + private static void encodeHeader(DnsResponse response, ByteBuf buf) { + buf.writeShort(response.id()); + int flags = 32768; + flags |= (response.opCode().byteValue() & 0xFF) << 11; + if (response.isAuthoritativeAnswer()) { + flags |= 1 << 10; + } + if (response.isTruncated()) { + flags |= 1 << 9; + } + if (response.isRecursionDesired()) { + flags |= 1 << 8; + } + if (response.isRecursionAvailable()) { + flags |= 1 << 7; + } + flags |= response.z() << 4; + flags |= response.code().intValue(); + buf.writeShort(flags); + buf.writeShort(response.count(DnsSection.QUESTION)); + buf.writeShort(response.count(DnsSection.ANSWER)); + buf.writeShort(response.count(DnsSection.AUTHORITY)); + buf.writeShort(response.count(DnsSection.ADDITIONAL)); + } + + private void encodeQuestions(DnsResponse response, ByteBuf buf) throws Exception { + final int count = response.count(DnsSection.QUESTION); + for (int i = 0; i < count; i++) { + recordEncoder.encodeQuestion((DnsQuestion) response.recordAt(DnsSection.QUESTION, i), buf); + } + } + + private void encodeRecords(DnsResponse response, DnsSection section, ByteBuf buf) throws Exception { + final int count = response.count(section); + for (int i = 0; i < count; i++) { + recordEncoder.encodeRecord(response.recordAt(section, i), buf); + } + } +} diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsPtrRecord.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsPtrRecord.java new file mode 100644 index 0000000000..517c5f9570 --- /dev/null +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsPtrRecord.java @@ -0,0 +1,72 @@ +/* + * Copyright 2016 The Netty Project + * + * The Netty Project licenses this file to you under the Apache License, + * version 2.0 (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ +package io.netty.handler.codec.dns; + +import static io.netty.util.internal.ObjectUtil.checkNotNull; + +import io.netty.util.internal.StringUtil; + +public class DefaultDnsPtrRecord extends AbstractDnsRecord implements DnsPtrRecord { + + private final String hostname; + + /** + * Creates a new PTR record. + * + * @param name the domain name + * @param type the type of the record + * @param dnsClass the class of the record, usually one of the following: + *
    + *
  • {@link #CLASS_IN}
    • + *
  • {@link #CLASS_CSNET}
    • + *
  • {@link #CLASS_CHAOS}
    • + *
  • {@link #CLASS_HESIOD}
    • + *
  • {@link #CLASS_NONE}
    • + *
  • {@link #CLASS_ANY}
    • + *
+ * @param timeToLive the TTL value of the record + * @param hostname the hostname this PTR record resolves to. + */ + public DefaultDnsPtrRecord( + String name, int dnsClass, long timeToLive, String hostname) { + super(name, DnsRecordType.PTR, dnsClass, timeToLive); + this.hostname = checkNotNull(hostname, "hostname"); + } + + @Override + public String hostname() { + return hostname; + } + + @Override + public String toString() { + final StringBuilder buf = new StringBuilder(64).append(StringUtil.simpleClassName(this)).append('('); + final DnsRecordType type = type(); + buf.append(name().isEmpty()? "" : name()) + .append(' ') + .append(timeToLive()) + .append(' '); + + DnsMessageUtil.appendRecordClass(buf, dnsClass()) + .append(' ') + .append(type.name()); + + buf.append(' ') + .append(hostname); + + return buf.toString(); + } +} diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordDecoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordDecoder.java index 6d6beea4e4..5f04e2bd63 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordDecoder.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordDecoder.java @@ -87,6 +87,10 @@ protected DnsRecord decodeRecord( String name, DnsRecordType type, int dnsClass, long timeToLive, ByteBuf in, int offset, int length) throws Exception { + if (type == DnsRecordType.PTR) { + in.setIndex(offset, offset + length); + return new DefaultDnsPtrRecord(name, dnsClass, timeToLive, decodeName(in)); + } return new DefaultDnsRawRecord( name, type, dnsClass, timeToLive, in.duplicate().setIndex(offset, offset + length).retain()); } diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordEncoder.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordEncoder.java index 055ac2f34f..e9dc602032 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordEncoder.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DefaultDnsRecordEncoder.java @@ -43,6 +43,8 @@ public final void encodeQuestion(DnsQuestion question, ByteBuf out) throws Excep public void encodeRecord(DnsRecord record, ByteBuf out) throws Exception { if (record instanceof DnsQuestion) { encodeQuestion((DnsQuestion) record, out); + } else if (record instanceof DnsPtrRecord) { + encodePtrRecord((DnsPtrRecord) record, out); } else if (record instanceof DnsRawRecord) { encodeRawRecord((DnsRawRecord) record, out); } else { @@ -50,6 +52,16 @@ public void encodeRecord(DnsRecord record, ByteBuf out) throws Exception { } } + private void encodePtrRecord(DnsPtrRecord record, ByteBuf out) throws Exception { + encodeName(record.name(), out); + + out.writeShort(record.type().intValue()); + out.writeShort(record.dnsClass()); + out.writeInt((int) record.timeToLive()); + + encodeName(record.hostname(), out); + } + private void encodeRawRecord(DnsRawRecord record, ByteBuf out) throws Exception { encodeName(record.name(), out); diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsMessageUtil.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsMessageUtil.java index b5db80a1b7..67115e28b4 100644 --- a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsMessageUtil.java +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsMessageUtil.java @@ -173,7 +173,7 @@ private static void appendRecords(StringBuilder buf, DnsMessage message, DnsSect for (int i = 0; i < count; i ++) { buf.append(StringUtil.NEWLINE) .append('\t') - .append(message.recordAt(section, i).toString()); + .append(message. recordAt(section, i)); } } diff --git a/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsPtrRecord.java b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsPtrRecord.java new file mode 100644 index 0000000000..53962e1142 --- /dev/null +++ b/netty-bp/codec-dns/src/main/java/io/netty/handler/codec/dns/DnsPtrRecord.java @@ -0,0 +1,25 @@ +/* + * Copyright 2016 The Netty Project + * + * The Netty Project licenses this file to you under the Apache License, + * version 2.0 (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ +package io.netty.handler.codec.dns; + +public interface DnsPtrRecord extends DnsRecord { + + /** + * Returns the hostname this PTR record resolves to. + */ + String hostname(); + +} diff --git a/netty-bp/codec-dns/src/test/java/io/netty/handler/codec/dns/AbstractDnsRecordTest.java b/netty-bp/codec-dns/src/test/java/io/netty/handler/codec/dns/AbstractDnsRecordTest.java index 666c1601d9..d55a0b1354 100644 --- a/netty-bp/codec-dns/src/test/java/io/netty/handler/codec/dns/AbstractDnsRecordTest.java +++ b/netty-bp/codec-dns/src/test/java/io/netty/handler/codec/dns/AbstractDnsRecordTest.java @@ -24,14 +24,28 @@ public class AbstractDnsRecordTest { public void testValidDomainName() { String name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; AbstractDnsRecord record = new AbstractDnsRecord(name, DnsRecordType.A, 0) { }; - Assert.assertEquals(name, record.name()); + Assert.assertEquals(name + '.', record.name()); } @Test public void testValidDomainNameUmlaut() { String name = "ä"; AbstractDnsRecord record = new AbstractDnsRecord(name, DnsRecordType.A, 0) { }; - Assert.assertEquals("xn--4ca", record.name()); + Assert.assertEquals("xn--4ca.", record.name()); + } + + @Test + public void testValidDomainNameTrailingDot() { + String name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; + AbstractDnsRecord record = new AbstractDnsRecord(name, DnsRecordType.A, 0) { }; + Assert.assertEquals(name, record.name()); + } + + @Test + public void testValidDomainNameUmlautTrailingDot() { + String name = "ä."; + AbstractDnsRecord record = new AbstractDnsRecord(name, DnsRecordType.A, 0) { }; + Assert.assertEquals("xn--4ca.", record.name()); } @Test(expected = IllegalArgumentException.class) diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsCache.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsCache.java index 2ddefcd79e..506c973420 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsCache.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsCache.java @@ -27,7 +27,8 @@ import java.util.concurrent.ConcurrentMap; import java.util.concurrent.TimeUnit; -import static io.netty.util.internal.ObjectUtil2.*; +import static io.netty.util.internal.ObjectUtil.checkNotNull; +import static io.netty.util.internal.ObjectUtil2.checkPositiveOrZero; /** * Default implementation of {@link DnsCache}, backed by a {@link ConcurrentMap}. diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsNameResolverBuilder.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsNameResolverBuilder.java deleted file mode 100644 index cc69db8682..0000000000 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DefaultDnsNameResolverBuilder.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2015 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -package io.netty.resolver.dns; - -import io.netty.channel.EventLoop; - -public class DefaultDnsNameResolverBuilder extends DnsNameResolverBuilder { - - public DefaultDnsNameResolverBuilder(EventLoop eventLoop) { - super(eventLoop); - } - - @Override - protected DnsNameResolver build0(DnsCache cache) { - return new DnsNameResolver( - eventLoop, - channelFactory, - localAddress, - nameServerAddresses, - cache, - queryTimeoutMillis, - resolvedAddressTypes, - recursionDesired, - maxQueriesPerResolve, - traceEnabled, - maxPayloadSize, - optResourceEnabled, - hostsFileEntriesResolver); - } -} diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsAddressResolverGroup.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsAddressResolverGroup.java index 363a35843d..f5f1b602cf 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsAddressResolverGroup.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsAddressResolverGroup.java @@ -81,7 +81,7 @@ protected AddressResolver newResolver( EventLoop eventLoop, ChannelFactory channelFactory, InetSocketAddress localAddress, DnsServerAddresses nameServerAddresses) throws Exception { - return new DefaultDnsNameResolverBuilder(eventLoop) + return new DnsNameResolverBuilder(eventLoop) .channelFactory(channelFactory) .localAddress(localAddress) .nameServerAddresses(nameServerAddresses) diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsCache.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsCache.java index 276cb5af89..79ea3876d5 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsCache.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsCache.java @@ -28,8 +28,6 @@ public interface DnsCache { /** * Clears all the resolved addresses cached by this resolver. * - * @return {@code this} - * * @see #clear(String) */ void clear(); diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolver.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolver.java index 581fc6ab3f..140a70699f 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolver.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolver.java @@ -16,8 +16,8 @@ package io.netty.resolver.dns; import io.netty.bootstrap.Bootstrap; -import io.netty.channel.AddressedEnvelope; import io.netty.bootstrap.ChannelFactory; +import io.netty.channel.AddressedEnvelope; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; @@ -29,6 +29,7 @@ import io.netty.channel.socket.InternetProtocolFamily; import io.netty.handler.codec.dns.DatagramDnsQueryEncoder; import io.netty.handler.codec.dns.DatagramDnsResponse; +import io.netty.handler.codec.dns.DnsRecord; import io.netty.handler.codec.dns.DatagramDnsResponseDecoder; import io.netty.handler.codec.dns.DnsQuestion; import io.netty.handler.codec.dns.DnsResponse; @@ -506,12 +507,20 @@ public Future> query(DnsQuesti return query(nextNameServerAddress(), question); } + /** + * Sends a DNS query with the specified question with additional records. + */ + public Future> query( + DnsQuestion question, Iterable additional) { + return query(nextNameServerAddress(), question, additional); + } + /** * Sends a DNS query with the specified question. */ public Future> query( DnsQuestion question, Promise> promise) { - return query(nextNameServerAddress(), question, promise); + return query(nextNameServerAddress(), question, Collections.emptyList(), promise); } private InetSocketAddress nextNameServerAddress() { @@ -524,9 +533,18 @@ private InetSocketAddress nextNameServerAddress() { public Future> query( InetSocketAddress nameServerAddr, DnsQuestion question) { - return query0(checkNotNull(nameServerAddr, "nameServerAddr"), - checkNotNull(question, "question"), - ch.eventLoop().>newPromise()); + return query0(nameServerAddr, question, Collections.emptyList(), + ch.eventLoop().>newPromise()); + } + + /** + * Sends a DNS query with the specified question with additional records using the specified name server list. + */ + public Future> query( + InetSocketAddress nameServerAddr, DnsQuestion question, Iterable additional) { + + return query0(nameServerAddr, question, additional, + ch.eventLoop().>newPromise()); } /** @@ -536,18 +554,29 @@ public Future> query( InetSocketAddress nameServerAddr, DnsQuestion question, Promise> promise) { - return query0(checkNotNull(nameServerAddr, "nameServerAddr"), - checkNotNull(question, "question"), - checkNotNull(promise, "promise")); + return query0(nameServerAddr, question, Collections.emptyList(), promise); + } + + /** + * Sends a DNS query with the specified question with additional records using the specified name server list. + */ + public Future> query( + InetSocketAddress nameServerAddr, DnsQuestion question, + Iterable additional, + Promise> promise) { + + return query0(nameServerAddr, question, additional, promise); } private Future> query0( InetSocketAddress nameServerAddr, DnsQuestion question, + Iterable additional, Promise> promise) { - final Promise> castPromise = cast(promise); + final Promise> castPromise = cast( + checkNotNull(promise, "promise")); try { - new DnsQueryContext(this, nameServerAddr, question, castPromise).query(); + new DnsQueryContext(this, nameServerAddr, question, additional, castPromise).query(); return castPromise; } catch (Exception e) { return castPromise.setFailure(e); diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolverBuilder.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolverBuilder.java index 586710163b..405c76523e 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolverBuilder.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolverBuilder.java @@ -15,13 +15,14 @@ */ package io.netty.resolver.dns; -import static io.netty.util.internal.ObjectUtil2.*; +import static io.netty.util.internal.ObjectUtil2.intValue; import io.netty.bootstrap.ChannelFactory; import io.netty.channel.EventLoop; import io.netty.channel.ReflectiveChannelFactory; import io.netty.channel.socket.DatagramChannel; import io.netty.channel.socket.InternetProtocolFamily; import io.netty.resolver.HostsFileEntriesResolver; +import io.netty.util.internal.InternalThreadLocalMap; import java.net.InetSocketAddress; import java.util.ArrayList; @@ -32,24 +33,24 @@ /** * A {@link DnsNameResolver} builder. */ -public abstract class DnsNameResolverBuilder> { - - protected final EventLoop eventLoop; - protected ChannelFactory channelFactory; - protected InetSocketAddress localAddress = DnsNameResolver.ANY_LOCAL_ADDR; - protected DnsServerAddresses nameServerAddresses = DnsServerAddresses.defaultAddresses(); - protected DnsCache resolveCache; - protected Integer minTtl; - protected Integer maxTtl; - protected Integer negativeTtl; - protected long queryTimeoutMillis = 5000; - protected InternetProtocolFamily[] resolvedAddressTypes = DnsNameResolver.DEFAULT_RESOLVE_ADDRESS_TYPES; - protected boolean recursionDesired = true; - protected int maxQueriesPerResolve = 3; - protected boolean traceEnabled; - protected int maxPayloadSize = 4096; - protected boolean optResourceEnabled = true; - protected HostsFileEntriesResolver hostsFileEntriesResolver = HostsFileEntriesResolver.DEFAULT; +public final class DnsNameResolverBuilder { + + private final EventLoop eventLoop; + private ChannelFactory channelFactory; + private InetSocketAddress localAddress = DnsNameResolver.ANY_LOCAL_ADDR; + private DnsServerAddresses nameServerAddresses = DnsServerAddresses.defaultAddresses(); + private DnsCache resolveCache; + private Integer minTtl; + private Integer maxTtl; + private Integer negativeTtl; + private long queryTimeoutMillis = 5000; + private InternetProtocolFamily[] resolvedAddressTypes = DnsNameResolver.DEFAULT_RESOLVE_ADDRESS_TYPES; + private boolean recursionDesired = true; + private int maxQueriesPerResolve = 3; + private boolean traceEnabled; + private int maxPayloadSize = 4096; + private boolean optResourceEnabled = true; + private HostsFileEntriesResolver hostsFileEntriesResolver = HostsFileEntriesResolver.DEFAULT; /** * Creates a new builder. @@ -61,30 +62,25 @@ public DnsNameResolverBuilder(EventLoop eventLoop) { this.eventLoop = eventLoop; } - @SuppressWarnings("unchecked") - private T cast() { - return (T) this; - } - /** * Sets the {@link ChannelFactory} that will create a {@link DatagramChannel}. * * @param channelFactory the {@link ChannelFactory} * @return {@code this} */ - public T channelFactory(ChannelFactory channelFactory) { + public DnsNameResolverBuilder channelFactory(ChannelFactory channelFactory) { this.channelFactory = channelFactory; - return cast(); + return this; } /** * Sets the {@link ChannelFactory} as a {@link ReflectiveChannelFactory} of this type. * Use as an alternative to {@link #channelFactory(ChannelFactory)}. * - * @param channelType + * @param channelType the type * @return {@code this} */ - public T channelType(Class channelType) { + public DnsNameResolverBuilder channelType(Class channelType) { return channelFactory(new ReflectiveChannelFactory(channelType)); } @@ -94,9 +90,9 @@ public T channelType(Class channelType) { * @param localAddress the local address * @return {@code this} */ - public T localAddress(InetSocketAddress localAddress) { + public DnsNameResolverBuilder localAddress(InetSocketAddress localAddress) { this.localAddress = localAddress; - return cast(); + return this; } /** @@ -105,9 +101,9 @@ public T localAddress(InetSocketAddress localAddress) { * @param nameServerAddresses the DNS server addresses * @return {@code this} */ - public T nameServerAddresses(DnsServerAddresses nameServerAddresses) { + public DnsNameResolverBuilder nameServerAddresses(DnsServerAddresses nameServerAddresses) { this.nameServerAddresses = nameServerAddresses; - return cast(); + return this; } /** @@ -116,9 +112,9 @@ public T nameServerAddresses(DnsServerAddresses nameServerAddresses) { * @param resolveCache the DNS resolution results cache * @return {@code this} */ - public T resolveCache(DnsCache resolveCache) { + public DnsNameResolverBuilder resolveCache(DnsCache resolveCache) { this.resolveCache = resolveCache; - return cast(); + return this; } /** @@ -133,10 +129,10 @@ public T resolveCache(DnsCache resolveCache) { * @param maxTtl the maximum TTL * @return {@code this} */ - public T ttl(int minTtl, int maxTtl) { + public DnsNameResolverBuilder ttl(int minTtl, int maxTtl) { this.maxTtl = maxTtl; this.minTtl = minTtl; - return cast(); + return this; } /** @@ -145,9 +141,9 @@ public T ttl(int minTtl, int maxTtl) { * @param negativeTtl the TTL for failed cached queries * @return {@code this} */ - public T negativeTtl(int negativeTtl) { + public DnsNameResolverBuilder negativeTtl(int negativeTtl) { this.negativeTtl = negativeTtl; - return cast(); + return this; } /** @@ -156,9 +152,9 @@ public T negativeTtl(int negativeTtl) { * @param queryTimeoutMillis the query timeout * @return {@code this} */ - public T queryTimeoutMillis(long queryTimeoutMillis) { + public DnsNameResolverBuilder queryTimeoutMillis(long queryTimeoutMillis) { this.queryTimeoutMillis = queryTimeoutMillis; - return cast(); + return this; } /** @@ -170,7 +166,7 @@ public T queryTimeoutMillis(long queryTimeoutMillis) { * @param resolvedAddressTypes the address types * @return {@code this} */ - public T resolvedAddressTypes(InternetProtocolFamily... resolvedAddressTypes) { + public DnsNameResolverBuilder resolvedAddressTypes(InternetProtocolFamily... resolvedAddressTypes) { checkNotNull(resolvedAddressTypes, "resolvedAddressTypes"); final List list = @@ -195,7 +191,7 @@ public T resolvedAddressTypes(InternetProtocolFamily... resolvedAddressTypes) { this.resolvedAddressTypes = list.toArray(new InternetProtocolFamily[list.size()]); - return cast(); + return this; } /** @@ -207,7 +203,7 @@ public T resolvedAddressTypes(InternetProtocolFamily... resolvedAddressTypes) { * @param resolvedAddressTypes the address types * @return {@code this} */ - public T resolvedAddressTypes(Iterable resolvedAddressTypes) { + public DnsNameResolverBuilder resolvedAddressTypes(Iterable resolvedAddressTypes) { checkNotNull(resolvedAddressTypes, "resolveAddressTypes"); final List list = @@ -232,7 +228,7 @@ public T resolvedAddressTypes(Iterable resolvedAddressTy this.resolvedAddressTypes = list.toArray(new InternetProtocolFamily[list.size()]); - return cast(); + return this; } /** @@ -241,9 +237,9 @@ public T resolvedAddressTypes(Iterable resolvedAddressTy * @param recursionDesired true if recursion is desired * @return {@code this} */ - public T recursionDesired(boolean recursionDesired) { + public DnsNameResolverBuilder recursionDesired(boolean recursionDesired) { this.recursionDesired = recursionDesired; - return cast(); + return this; } /** @@ -252,9 +248,9 @@ public T recursionDesired(boolean recursionDesired) { * @param maxQueriesPerResolve the max number of queries * @return {@code this} */ - public T maxQueriesPerResolve(int maxQueriesPerResolve) { + public DnsNameResolverBuilder maxQueriesPerResolve(int maxQueriesPerResolve) { this.maxQueriesPerResolve = maxQueriesPerResolve; - return cast(); + return this; } /** @@ -264,9 +260,9 @@ public T maxQueriesPerResolve(int maxQueriesPerResolve) { * @param traceEnabled true if trace is enabled * @return {@code this} */ - public T traceEnabled(boolean traceEnabled) { + public DnsNameResolverBuilder traceEnabled(boolean traceEnabled) { this.traceEnabled = traceEnabled; - return cast(); + return this; } /** @@ -275,9 +271,9 @@ public T traceEnabled(boolean traceEnabled) { * @param maxPayloadSize the capacity of the datagram packet buffer * @return {@code this} */ - public T maxPayloadSize(int maxPayloadSize) { + public DnsNameResolverBuilder maxPayloadSize(int maxPayloadSize) { this.maxPayloadSize = maxPayloadSize; - return cast(); + return this; } /** @@ -288,9 +284,9 @@ public T maxPayloadSize(int maxPayloadSize) { * @param optResourceEnabled if optional records inclusion is enabled * @return {@code this} */ - public T optResourceEnabled(boolean optResourceEnabled) { + public DnsNameResolverBuilder optResourceEnabled(boolean optResourceEnabled) { this.optResourceEnabled = optResourceEnabled; - return cast(); + return this; } /** @@ -298,9 +294,9 @@ public T optResourceEnabled(boolean optResourceEnabled) { * if the hostname is locally aliased. * @return {@code this} */ - public T hostsFileEntriesResolver(HostsFileEntriesResolver hostsFileEntriesResolver) { + public DnsNameResolverBuilder hostsFileEntriesResolver(HostsFileEntriesResolver hostsFileEntriesResolver) { this.hostsFileEntriesResolver = hostsFileEntriesResolver; - return cast(); + return this; } /** @@ -317,8 +313,19 @@ public DnsNameResolver build() { DnsCache cache = resolveCache != null ? resolveCache : new DefaultDnsCache(intValue(minTtl, 0), intValue(maxTtl, Integer.MAX_VALUE), intValue(negativeTtl, 0)); - return build0(cache); + return new DnsNameResolver( + eventLoop, + channelFactory, + localAddress, + nameServerAddresses, + cache, + queryTimeoutMillis, + resolvedAddressTypes, + recursionDesired, + maxQueriesPerResolve, + traceEnabled, + maxPayloadSize, + optResourceEnabled, + hostsFileEntriesResolver); } - - protected abstract DnsNameResolver build0(DnsCache cache); } diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsQueryContext.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsQueryContext.java index 8217c82ea6..660b7793c5 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsQueryContext.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsQueryContext.java @@ -37,6 +37,8 @@ import java.net.InetSocketAddress; import java.util.concurrent.TimeUnit; +import static io.netty.util.internal.ObjectUtil.checkNotNull; + final class DnsQueryContext { private static final InternalLogger logger = InternalLoggerFactory.getInstance(DnsQueryContext.class); @@ -45,6 +47,7 @@ final class DnsQueryContext { private final Promise> promise; private final int id; private final DnsQuestion question; + private final Iterable additional; private final DnsRecord optResource; private final InetSocketAddress nameServerAddr; @@ -53,12 +56,15 @@ final class DnsQueryContext { DnsQueryContext(DnsNameResolver parent, InetSocketAddress nameServerAddr, - DnsQuestion question, Promise> promise) { - - this.parent = parent; - this.nameServerAddr = nameServerAddr; - this.question = question; - this.promise = promise; + DnsQuestion question, + Iterable additional, + Promise> promise) { + + this.parent = checkNotNull(parent, "parent"); + this.nameServerAddr = checkNotNull(nameServerAddr, "nameServerAddr"); + this.question = checkNotNull(question, "question"); + this.additional = checkNotNull(additional, "additional"); + this.promise = checkNotNull(promise, "promise"); recursionDesired = parent.isRecursionDesired(); id = parent.queryContextManager.add(this); @@ -82,10 +88,16 @@ void query() { final DnsQuestion question = question(); final InetSocketAddress nameServerAddr = nameServerAddr(); final DatagramDnsQuery query = new DatagramDnsQuery(null, nameServerAddr, id); + query.setRecursionDesired(recursionDesired); - query.setRecord(DnsSection.QUESTION, question); + + query.addRecord(DnsSection.QUESTION, question); + + for (DnsRecord record:additional) { + query.addRecord(DnsSection.ADDITIONAL, record); + } if (optResource != null) { - query.setRecord(DnsSection.ADDITIONAL, optResource); + query.addRecord(DnsSection.ADDITIONAL, optResource); } if (logger.isDebugEnabled()) { diff --git a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsServerAddresses.java b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsServerAddresses.java index 4561b64251..0d83fd9eff 100644 --- a/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsServerAddresses.java +++ b/netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsServerAddresses.java @@ -16,13 +16,13 @@ package io.netty.resolver.dns; +import io.netty.util.internal.InternalThreadLocalMap; import io.netty.util.internal.logging.InternalLogger; import io.netty.util.internal.logging.InternalLoggerFactory; import java.lang.reflect.Method; import java.net.InetAddress; import java.net.InetSocketAddress; -import java.net.SocketAddress; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -261,7 +261,7 @@ private static InetSocketAddress[] sanitize(InetSocketAddress[] addresses) { /** * Starts a new infinite stream of DNS server addresses. This method is invoked by {@link DnsNameResolver} on every - * uncached {@link DnsNameResolver#resolve(SocketAddress)} or {@link DnsNameResolver#resolveAll(SocketAddress)}. + * uncached {@link DnsNameResolver#resolve(String)}or {@link DnsNameResolver#resolveAll(String)}. */ public abstract DnsServerAddressStream stream(); } diff --git a/netty-bp/resolver-dns/src/test/java/io/netty/resolver/dns/DnsNameResolverTest.java b/netty-bp/resolver-dns/src/test/java/io/netty/resolver/dns/DnsNameResolverTest.java index b49f14374e..64b2d2213e 100644 --- a/netty-bp/resolver-dns/src/test/java/io/netty/resolver/dns/DnsNameResolverTest.java +++ b/netty-bp/resolver-dns/src/test/java/io/netty/resolver/dns/DnsNameResolverTest.java @@ -265,15 +265,15 @@ public class DnsNameResolverTest { private static final TestDnsServer dnsServer = new TestDnsServer(); private static final EventLoopGroup group = new NioEventLoopGroup(1); - private static DnsNameResolverBuilder newResolver() { - return new DefaultDnsNameResolverBuilder(group.next()) + private static DnsNameResolverBuilder newResolver() { + return new DnsNameResolverBuilder(group.next()) .channelType(NioDatagramChannel.class) .nameServerAddresses(DnsServerAddresses.singleton(dnsServer.localAddress())) .maxQueriesPerResolve(1) .optResourceEnabled(false); } - private static DnsNameResolverBuilder newResolver(InternetProtocolFamily... resolvedAddressTypes) { + private static DnsNameResolverBuilder newResolver(InternetProtocolFamily... resolvedAddressTypes) { return newResolver() .resolvedAddressTypes(resolvedAddressTypes); } @@ -505,7 +505,6 @@ public void testResolveIp() { } private static void resolve(DnsNameResolver resolver, Map> futures, String hostname) { - futures.put(hostname, resolver.resolve(hostname)); }