From 4eae019189e1d8758566174f7fa1fd956e71ba97 Mon Sep 17 00:00:00 2001 From: nathan Date: Tue, 30 Jan 2018 16:24:24 +0100 Subject: [PATCH] WIP DnsServer --- src/dorkbox/network/DnsServer.java | 148 +++++--- src/dorkbox/network/dns/DnsEnvelope.java | 9 + .../network/dns/records/DnsMessage.java | 21 +- .../network/dns/records/EmptyRecord.java | 1 - src/dorkbox/network/dns/records/RRset.java | 43 +-- .../serverHandlers/DnsDecisionHandler.java | 344 ++++++++++++++++++ .../dns/serverHandlers/DnsMessageDecoder.java | 50 ++- .../dns/serverHandlers/DnsServerHandler.java | 14 +- .../dns/serverHandlers/ForwardingHandler.java | 76 ++-- ... => aaaDNSMessageDecoderandForwarder.java} | 11 +- 10 files changed, 565 insertions(+), 152 deletions(-) create mode 100644 src/dorkbox/network/dns/serverHandlers/DnsDecisionHandler.java rename src/dorkbox/network/dns/serverHandlers/{DNSMessageDecoder.java => aaaDNSMessageDecoderandForwarder.java} (94%) diff --git a/src/dorkbox/network/DnsServer.java b/src/dorkbox/network/DnsServer.java index 84b274c1..de2cfdd6 100644 --- a/src/dorkbox/network/DnsServer.java +++ b/src/dorkbox/network/DnsServer.java @@ -1,3 +1,18 @@ +/* + * Copyright 2018 dorkbox, llc. + * + * Licensed 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 dorkbox.network; import org.slf4j.Logger; @@ -19,12 +34,16 @@ import io.netty.channel.epoll.EpollChannelOption; import io.netty.channel.epoll.EpollDatagramChannel; import io.netty.channel.epoll.EpollEventLoopGroup; import io.netty.channel.epoll.EpollServerSocketChannel; +import io.netty.channel.kqueue.KQueueDatagramChannel; +import io.netty.channel.kqueue.KQueueEventLoopGroup; +import io.netty.channel.kqueue.KQueueServerSocketChannel; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.oio.OioEventLoopGroup; import io.netty.channel.socket.nio.NioDatagramChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.channel.socket.oio.OioDatagramChannel; import io.netty.channel.socket.oio.OioServerSocketChannel; +import io.netty.channel.unix.UnixChannelOption; /** * from: https://blog.cloudflare.com/how-the-consumer-product-safety-commission-is-inadvertently-behind-the-internets-largest-ddos-attacks/ @@ -56,6 +75,25 @@ class DnsServer extends Shutdownable { private final int udpPort; private final String hostName; + public static + void main(String[] args) { + DnsServer server = new DnsServer("localhost", 2053); + // server.bind(false); + server.bind(); + + + // DnsClient client = new DnsClient("localhost", 2053); + // List resolve = null; + // try { + // resolve = client.resolve("google.com"); + // } catch (UnknownHostException e) { + // e.printStackTrace(); + // } + // System.err.println("RESOLVED: " + resolve); + // client.stop(); + // server.stop(); + } + public DnsServer(String host, int port) { @@ -87,6 +125,11 @@ class DnsServer extends Shutdownable { boss = new EpollEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName + "-boss", threadGroup)); worker = new EpollEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName, threadGroup)); } + else if (OS.isMacOsX()) { + // KQueue network stack is MUCH faster (but only on macosx) + boss = new KQueueEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName + "-boss", threadGroup)); + worker = new KQueueEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName, threadGroup)); + } else { boss = new NioEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName + "-boss", threadGroup)); worker = new NioEventLoopGroup(EndPoint.DEFAULT_THREAD_POOL_SIZE, new NamedThreadFactory(threadName, threadGroup)); @@ -101,63 +144,72 @@ class DnsServer extends Shutdownable { udpBootstrap = new Bootstrap(); - if (OS.isAndroid()) { - // android ONLY supports OIO (not NIO) - tcpBootstrap.channel(OioServerSocketChannel.class); - } - else if (OS.isLinux()) { - // JNI network stack is MUCH faster (but only on linux) - tcpBootstrap.channel(EpollServerSocketChannel.class); - } - else { - tcpBootstrap.channel(NioServerSocketChannel.class); - } + if (OS.isAndroid()) { + // android ONLY supports OIO (not NIO) + tcpBootstrap.channel(OioServerSocketChannel.class); + } + else if (OS.isLinux()) { + // JNI network stack is MUCH faster (but only on linux) + tcpBootstrap.channel(EpollServerSocketChannel.class); + } + else if (OS.isMacOsX()) { + // KQueue network stack is MUCH faster (but only on macosx) + tcpBootstrap.channel(KQueueServerSocketChannel.class); + } + else { + tcpBootstrap.channel(NioServerSocketChannel.class); + } - // TODO: If we use netty for an HTTP server, - // Beside the usual ChannelOptions the Native Transport allows to enable TCP_CORK which may come in handy if you implement a HTTP Server. + // TODO: If we use netty for an HTTP server, + // Beside the usual ChannelOptions the Native Transport allows to enable TCP_CORK which may come in handy if you implement a HTTP Server. - tcpBootstrap.group(boss, worker) - .option(ChannelOption.SO_BACKLOG, backlogConnectionCount) - .option(ChannelOption.SO_REUSEADDR, true) - .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) - .childOption(ChannelOption.SO_KEEPALIVE, true) - .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(EndPoint.WRITE_BUFF_LOW, EndPoint.WRITE_BUFF_HIGH)) - .childHandler(new DnsServerHandler()); + tcpBootstrap.group(boss, worker) + .option(ChannelOption.SO_BACKLOG, backlogConnectionCount) + .option(ChannelOption.SO_REUSEADDR, true) + .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) + .childOption(ChannelOption.SO_KEEPALIVE, true) + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(EndPoint.WRITE_BUFF_LOW, EndPoint.WRITE_BUFF_HIGH)) + .childHandler(new DnsServerHandler(logger)); - // have to check options.host for null. we don't bind to 0.0.0.0, we bind to "null" to get the "any" address! - if (hostName != null) { - tcpBootstrap.localAddress(hostName, tcpPort); - } - else { - tcpBootstrap.localAddress(tcpPort); - } + // have to check options.host for null. we don't bind to 0.0.0.0, we bind to "null" to get the "any" address! + if (hostName != null) { + tcpBootstrap.localAddress(hostName, tcpPort); + } + else { + tcpBootstrap.localAddress(tcpPort); + } - // android screws up on this!! - tcpBootstrap.option(ChannelOption.TCP_NODELAY, !OS.isAndroid()) - .childOption(ChannelOption.TCP_NODELAY, !OS.isAndroid()); + // android screws up on this!! + tcpBootstrap.option(ChannelOption.TCP_NODELAY, !OS.isAndroid()) + .childOption(ChannelOption.TCP_NODELAY, !OS.isAndroid()); - if (OS.isAndroid()) { - // android ONLY supports OIO (not NIO) - udpBootstrap.channel(OioDatagramChannel.class); - } - else if (OS.isLinux()) { - // JNI network stack is MUCH faster (but only on linux) - udpBootstrap.channel(EpollDatagramChannel.class) - .option(EpollChannelOption.SO_REUSEPORT, true); - } - else { - udpBootstrap.channel(NioDatagramChannel.class); - } + if (OS.isAndroid()) { + // android ONLY supports OIO (not NIO) + udpBootstrap.channel(OioDatagramChannel.class); + } + else if (OS.isLinux()) { + // JNI network stack is MUCH faster (but only on linux) + udpBootstrap.channel(EpollDatagramChannel.class) + .option(EpollChannelOption.SO_REUSEPORT, true); + } + else if (OS.isMacOsX()) { + // JNI network stack is MUCH faster (but only on macosx) + udpBootstrap.channel(KQueueDatagramChannel.class) + .option(UnixChannelOption.SO_REUSEPORT, true); + } + else { + udpBootstrap.channel(NioDatagramChannel.class); + } - udpBootstrap.group(worker) - .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) - .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(EndPoint.WRITE_BUFF_LOW, EndPoint.WRITE_BUFF_HIGH)) + udpBootstrap.group(worker) + .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(EndPoint.WRITE_BUFF_LOW, EndPoint.WRITE_BUFF_HIGH)) - // not binding to specific address, since it's driven by TCP, and that can be bound to a specific address - .localAddress(udpPort) // if you bind to a specific interface, Linux will be unable to receive broadcast packets! - .handler(new DnsServerHandler()); + // not binding to specific address, since it's driven by TCP, and that can be bound to a specific address + .localAddress(udpPort) // if you bind to a specific interface, Linux will be unable to receive broadcast packets! + .handler(new DnsServerHandler(logger)); } /** diff --git a/src/dorkbox/network/dns/DnsEnvelope.java b/src/dorkbox/network/dns/DnsEnvelope.java index d1a49ed6..87caeece 100644 --- a/src/dorkbox/network/dns/DnsEnvelope.java +++ b/src/dorkbox/network/dns/DnsEnvelope.java @@ -36,6 +36,15 @@ class DnsEnvelope extends DnsMessage implements AddressedEnvelope newlist = new ArrayList(this.config.getForwarders()); + // sendRequest(e, original, cb, newlist); + // } + // + // protected void sendRequest(final MessageEvent e, final DNSMessage original, final ClientBootstrap bootstrap, final List forwarders) { + // if (0 < forwarders.size()) { + // SocketAddress sa = forwarders.remove(0); + // LOG.debug("send to {}", sa); + // + // ChannelFuture f = bootstrap.connect(sa); + // ChannelBuffer newone = ChannelBuffers.buffer(512); + // DNSMessage msg = new DNSMessage(original); + // msg.write(newone); + // newone.resetReaderIndex(); + // final Channel c = f.getChannel(); + // + // if (LOG.isDebugEnabled()) { + // LOG.debug( + // "STATUS : [isOpen/isConnected/isWritable {}] {} {}", + // new Object[] { + // new boolean[] { c.isOpen(), c.isConnected(), + // c.isWritable() }, c.getRemoteAddress(), + // c.getClass() }); + // } + // + // c.write(newone, sa).addListener(new ChannelFutureListener() { + // @Override + // public void operationComplete(ChannelFuture future) + // throws Exception { + // LOG.debug("request complete isSuccess : {}", + // future.isSuccess()); + // if (future.isSuccess() == false) { + // if (0 < forwarders.size()) { + // sendRequest(e, original, bootstrap, forwarders); + // } else { + // original.header().rcode(RCode.ServFail); + // ChannelBuffer buffer = ChannelBuffers.buffer(512); + // original.write(buffer); + // // close inbound channel + // e.getChannel().write(buffer) + // .addListener(ChannelFutureListener.CLOSE); + // } + // } + // } + // }); + // + // // f.awaitUninterruptibly(30, TimeUnit.SECONDS); + // } + // } + + @Override + public + void exceptionCaught(final ChannelHandlerContext context, final Throwable cause) throws Exception { + logger.error("ForwardingHandler#exceptionCaught", cause); + super.exceptionCaught(context, cause); + } + + + protected class ClientHandler extends ChannelInboundHandlerAdapter { + + // protected DNSMessage original; + // + // protected Channel originalChannel; + // + // protected SocketAddress originalAddress; + // + // public ClientHanler(DNSMessage msg, Channel c, SocketAddress sa) { + // this.original = msg; + // this.originalChannel = c; + // this.originalAddress = sa; + // } + // + // @Override + // public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception { + // LOG.debug("ClientHanler#messageReceived"); + // ChannelBuffer buffer = (ChannelBuffer) e.getMessage(); + // DNSMessage msg = new DNSMessage(buffer); + // msg.header().id(this.original.header().id()); + // ChannelBuffer newone = ChannelBuffers.buffer(buffer.capacity()); + // msg.write(newone); + // newone.resetReaderIndex(); + // this.originalChannel.write(newone, this.originalAddress) + // .addListener(new ChannelFutureListener() { + // @Override + // public void operationComplete(ChannelFuture future) + // throws Exception { + // e.getChannel().close(); + // } + // }); + // } + // + + @Override + public + void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception { + logger.error("ClientHanler#exceptionCaught"); + logger.error(cause.getMessage(), cause); + // e.getFuture() + // .setFailure(t); + ctx.channel().close(); + } + } +} diff --git a/src/dorkbox/network/dns/serverHandlers/DnsMessageDecoder.java b/src/dorkbox/network/dns/serverHandlers/DnsMessageDecoder.java index a02edbdf..247ffdd7 100644 --- a/src/dorkbox/network/dns/serverHandlers/DnsMessageDecoder.java +++ b/src/dorkbox/network/dns/serverHandlers/DnsMessageDecoder.java @@ -1,46 +1,58 @@ package dorkbox.network.dns.serverHandlers; +import java.net.InetSocketAddress; import java.util.List; -import dorkbox.network.dns.records.DnsMessage; +import org.slf4j.Logger; + +import dorkbox.network.dns.DnsEnvelope; +import dorkbox.network.dns.exceptions.WireParseException; +import dorkbox.network.dns.records.Header; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.socket.DatagramPacket; import io.netty.handler.codec.MessageToMessageDecoder; - -public class DnsMessageDecoder extends MessageToMessageDecoder { + private final Logger logger; + + DnsMessageDecoder(final Logger logger) { + this.logger = logger; + } + @Override public - void exceptionCaught(ChannelHandlerContext context, Throwable cause) throws Exception { - // Channel channel = context.channel(); - - System.err.println("POW! "); - cause.printStackTrace(); - // this.logger.error("Unexpected exception while trying to send/receive data on Client remote (network) channel. ({})" + - // System.getProperty("line.separator"), channel.remoteAddress(), cause); - // if (channel.isOpen()) { - // channel.close(); - // } + void exceptionCaught(final ChannelHandlerContext context, final Throwable cause) throws Exception { + logger.error("DnsMessageDecoder#exceptionCaught", cause); + super.exceptionCaught(context, cause); } @Override protected - void decode(ChannelHandlerContext ctx, DatagramPacket packet, List out) throws Exception { - System.err.println("READING MESSAGE"); + void decode(ChannelHandlerContext context, DatagramPacket packet, List out) throws Exception { final ByteBuf buf = packet.content(); + // Check that the response is long enough. + if (buf.readableBytes() < Header.LENGTH) { + throw new WireParseException("invalid DNS header - " + "too short"); + } + boolean success = false; try { - DnsMessage dnsMessage = new DnsMessage(buf); - dnsMessage.retain(); - out.add(dnsMessage); + InetSocketAddress localAddress = packet.recipient(); + InetSocketAddress remoteAddress = packet.sender(); + + DnsEnvelope dnsEnvelope = new DnsEnvelope(buf, localAddress, remoteAddress); + dnsEnvelope.retain(); + + + // send down the pipeline + out.add(dnsEnvelope); success = true; } finally { if (!success) { buf.release(); } } - } + } } diff --git a/src/dorkbox/network/dns/serverHandlers/DnsServerHandler.java b/src/dorkbox/network/dns/serverHandlers/DnsServerHandler.java index 8d94a2e9..bbfc8299 100644 --- a/src/dorkbox/network/dns/serverHandlers/DnsServerHandler.java +++ b/src/dorkbox/network/dns/serverHandlers/DnsServerHandler.java @@ -13,12 +13,13 @@ import io.netty.channel.ChannelPipeline; */ public class DnsServerHandler extends ChannelInboundHandlerAdapter { - private static final Logger LOG = org.slf4j.LoggerFactory.getLogger(DnsServerHandler.class); - - protected final DnsMessageDecoder decoder = new DnsMessageDecoder(); + protected final DnsMessageDecoder decoder; + private final Logger logger; public - DnsServerHandler() { + DnsServerHandler(final Logger logger) { + this.logger = logger; + decoder = new DnsMessageDecoder(logger); } @Override @@ -30,7 +31,7 @@ class DnsServerHandler extends ChannelInboundHandlerAdapter { context.fireChannelRegistered(); success = true; } catch (Throwable t) { - LOG.error("Failed to initialize a channel. Closing: {}", context.channel(), t); + logger.error("Failed to initialize a channel. Closing: {}", context.channel(), t); } finally { if (!success) { context.close(); @@ -52,7 +53,8 @@ class DnsServerHandler extends ChannelInboundHandlerAdapter { // ENCODE (or downstream) ///////////////////////// - pipeline.addLast("fowarder", new ForwardingHandler()); + pipeline.addLast("dnsDecision", new DnsDecisionHandler(logger)); + pipeline.addLast("fowarder", new ForwardingHandler(logger)); // pipeline.addLast("fowarder", new ForwardingHandler(this.config, this.clientChannelFactory)); } } diff --git a/src/dorkbox/network/dns/serverHandlers/ForwardingHandler.java b/src/dorkbox/network/dns/serverHandlers/ForwardingHandler.java index adb1289c..36d64b9e 100644 --- a/src/dorkbox/network/dns/serverHandlers/ForwardingHandler.java +++ b/src/dorkbox/network/dns/serverHandlers/ForwardingHandler.java @@ -1,17 +1,29 @@ package dorkbox.network.dns.serverHandlers; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.io.IOException; +import org.slf4j.Logger; + +import dorkbox.network.dns.DnsEnvelope; +import dorkbox.network.dns.DnsOutput; +import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; -import io.netty.channel.ChannelOutboundHandlerAdapter; +import io.netty.channel.socket.DatagramPacket; +import io.netty.handler.codec.MessageToByteEncoder; -public class ForwardingHandler extends ChannelOutboundHandlerAdapter { +public class ForwardingHandler extends MessageToByteEncoder { - static final Logger LOG = LoggerFactory.getLogger(ForwardingHandler.class); - // protected ServerConfiguration config; + private final int maxPayloadSize = 512; + private final Logger logger; + + public + ForwardingHandler(final Logger logger) { + this.logger = logger; + } + + // protected ServerConfiguration config; // protected ChannelFactory clientChannelFactory; // public @@ -21,18 +33,27 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { // this.clientChannelFactory = clientChannelFactory; // } + @Override - public - void read(final ChannelHandlerContext ctx) throws Exception { - System.err.println("FORWARD HANDLER READ"); - super.read(ctx); + protected + void encode(final ChannelHandlerContext context, final DnsEnvelope message, final ByteBuf out) throws Exception { + System.err.println("FORWARD HANDLER ENCODE"); + + try { + DnsOutput dnsOutput = new DnsOutput(out); + message.toWire(dnsOutput); + + context.channel() + .writeAndFlush(new DatagramPacket(out, message.recipient(), null)); + // .write(new DatagramPacket(out, message.recipient(), message.sender())); + } catch (Exception e) { + context.fireExceptionCaught(new IOException("Unable to write dns message: " + message, e)); + } } - // @Override - // public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) - // throws Exception { + // public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception { // final DNSMessage original = DNSMessage.class.cast(e.getMessage()); // // ClientBootstrap cb = new ClientBootstrap(this.clientChannelFactory); @@ -40,13 +61,11 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { // cb.setPipelineFactory(new ChannelPipelineFactory() { // @Override // public ChannelPipeline getPipeline() throws Exception { - // return Channels.pipeline(new ClientHanler(original, e - // .getChannel(), e.getRemoteAddress())); + // return Channels.pipeline(new ClientHandler(original, e.getChannel(), e.getRemoteAddress())); // } // }); // - // List newlist = new ArrayList( - // this.config.getForwarders()); + // List newlist = new ArrayList(this.config.getForwarders()); // sendRequest(e, original, cb, newlist); // } // @@ -73,10 +92,8 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { // // c.write(newone, sa).addListener(new ChannelFutureListener() { // @Override - // public void operationComplete(ChannelFuture future) - // throws Exception { - // LOG.debug("request complete isSuccess : {}", - // future.isSuccess()); + // public void operationComplete(ChannelFuture future) throws Exception { + // LOG.debug("request complete isSuccess : {}", future.isSuccess()); // if (future.isSuccess() == false) { // if (0 < forwarders.size()) { // sendRequest(e, original, bootstrap, forwarders); @@ -98,9 +115,9 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { @Override public - void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception { - LOG.error("ForwardingHandler#exceptionCaught"); - LOG.error(cause.getMessage(), cause); + void exceptionCaught(final ChannelHandlerContext context, final Throwable cause) throws Exception { + logger.error("ForwardingHandler#exceptionCaught", cause); + super.exceptionCaught(context, cause); } @@ -117,13 +134,6 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { // this.originalChannel = c; // this.originalAddress = sa; // } - // - - - - - - // @Override // public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception { // LOG.debug("ClientHanler#messageReceived"); @@ -147,8 +157,8 @@ public class ForwardingHandler extends ChannelOutboundHandlerAdapter { @Override public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception { - LOG.error("ClientHanler#exceptionCaught"); - LOG.error(cause.getMessage(), cause); + logger.error("ClientHandler#exceptionCaught"); + logger.error(cause.getMessage(), cause); // e.getFuture() // .setFailure(t); ctx.channel().close(); diff --git a/src/dorkbox/network/dns/serverHandlers/DNSMessageDecoder.java b/src/dorkbox/network/dns/serverHandlers/aaaDNSMessageDecoderandForwarder.java similarity index 94% rename from src/dorkbox/network/dns/serverHandlers/DNSMessageDecoder.java rename to src/dorkbox/network/dns/serverHandlers/aaaDNSMessageDecoderandForwarder.java index e70ef4a2..c7c3f235 100644 --- a/src/dorkbox/network/dns/serverHandlers/DNSMessageDecoder.java +++ b/src/dorkbox/network/dns/serverHandlers/aaaDNSMessageDecoderandForwarder.java @@ -7,14 +7,7 @@ import dorkbox.util.NamedThreadFactory; import io.netty.bootstrap.Bootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.PooledByteBufAllocator; -import io.netty.channel.ChannelFuture; -import io.netty.channel.ChannelHandler; -import io.netty.channel.ChannelHandlerContext; -import io.netty.channel.ChannelInboundHandler; -import io.netty.channel.ChannelInboundHandlerAdapter; -import io.netty.channel.ChannelOption; -import io.netty.channel.ChannelPipeline; -import io.netty.channel.EventLoopGroup; +import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.oio.OioEventLoopGroup; import io.netty.channel.socket.DatagramPacket; @@ -24,7 +17,7 @@ import io.netty.util.internal.PlatformDependent; @ChannelHandler.Sharable public -class DNSMessageDecoder extends ChannelInboundHandlerAdapter { +class aaaDNSMessageDecoderandForwarder extends ChannelInboundHandlerAdapter { /** * This is what is called whenever a DNS packet is received. Currently only support UDP packets.